diff --git a/README.md b/README.md
index 1c18d24..4d3fd3c 100644
--- a/README.md
+++ b/README.md
@@ -77,7 +77,7 @@ function App() {
 ## Usage
 
 ```tsx
-import { MapView, Marker, Polyline } from '@lugg/maps';
+import { MapView, Marker, Polyline, Polygon } from '@lugg/maps';
 
 <MapView
   style={{ flex: 1 }}
@@ -96,6 +96,17 @@ import { MapView, Marker, Polyline } from '@lugg/maps';
     ]}
     strokeWidth={3}
   />
+  <Polygon
+    coordinates={[
+      { latitude: 37.784, longitude: -122.428 },
+      { latitude: 37.784, longitude: -122.422 },
+      { latitude: 37.779, longitude: -122.422 },
+      { latitude: 37.779, longitude: -122.428 },
+    ]}
+    fillColor="rgba(66, 133, 244, 0.3)"
+    strokeColor="#4285F4"
+    strokeWidth={2}
+  />
 </MapView>
 ```
 
@@ -104,6 +115,7 @@ import { MapView, Marker, Polyline } from '@lugg/maps';
 - [MapView](docs/MAPVIEW.md) - Main map component
 - [Marker](docs/MARKER.md) - Map markers
 - [Polyline](docs/POLYLINE.md) - Draw lines on the map
+- [Polygon](docs/POLYGON.md) - Draw filled shapes on the map
 
 ## Types
 
diff --git a/android/src/main/java/com/luggmaps/LuggMapView.kt b/android/src/main/java/com/luggmaps/LuggMapView.kt
index 6c00049..777c98e 100644
--- a/android/src/main/java/com/luggmaps/LuggMapView.kt
+++ b/android/src/main/java/com/luggmaps/LuggMapView.kt
@@ -63,6 +63,7 @@ class LuggMapView(private val reactContext: ThemedReactContext) :
       is LuggMapWrapperView -> mapWrapperView = child
       is LuggMarkerView -> provider?.addMarkerView(child)
       is LuggPolylineView -> provider?.addPolylineView(child)
+      is LuggPolygonView -> provider?.addPolygonView(child)
     }
   }
 
@@ -71,6 +72,7 @@ class LuggMapView(private val reactContext: ThemedReactContext) :
     when (view) {
       is LuggMarkerView -> provider?.removeMarkerView(view)
       is LuggPolylineView -> provider?.removePolylineView(view)
+      is LuggPolygonView -> provider?.removePolygonView(view)
     }
     super.removeViewAt(index)
   }
@@ -118,6 +120,7 @@ class LuggMapView(private val reactContext: ThemedReactContext) :
       when (val child = getChildAt(i)) {
         is LuggMarkerView -> google.addMarkerView(child)
         is LuggPolylineView -> google.addPolylineView(child)
+        is LuggPolygonView -> google.addPolygonView(child)
       }
     }
   }
diff --git a/android/src/main/java/com/luggmaps/LuggMapWrapperView.kt b/android/src/main/java/com/luggmaps/LuggMapWrapperView.kt
index b01e7cd..3e63dcb 100644
--- a/android/src/main/java/com/luggmaps/LuggMapWrapperView.kt
+++ b/android/src/main/java/com/luggmaps/LuggMapWrapperView.kt
@@ -1,13 +1,20 @@
 package com.luggmaps
 
 import android.annotation.SuppressLint
-import android.util.Log
+import android.view.MotionEvent
 import com.facebook.react.uimanager.ThemedReactContext
 import com.facebook.react.views.view.ReactViewGroup
 
 @SuppressLint("ViewConstructor")
 class LuggMapWrapperView(context: ThemedReactContext) : ReactViewGroup(context) {
 
+  var touchEventHandler: ((MotionEvent) -> Unit)? = null
+
+  override fun dispatchTouchEvent(event: MotionEvent): Boolean {
+    touchEventHandler?.invoke(event)
+    return super.dispatchTouchEvent(event)
+  }
+
   override fun requestLayout() {
     super.requestLayout()
     getChildAt(0)?.let {
diff --git a/android/src/main/java/com/luggmaps/LuggPackage.kt b/android/src/main/java/com/luggmaps/LuggPackage.kt
index 4ecfa3d..4598a42 100644
--- a/android/src/main/java/com/luggmaps/LuggPackage.kt
+++ b/android/src/main/java/com/luggmaps/LuggPackage.kt
@@ -6,5 +6,5 @@ import com.facebook.react.uimanager.ViewManager
 
 class LuggPackage : ReactPackage {
   override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> =
-    listOf(LuggMapViewManager(), LuggMarkerViewManager(), LuggMapWrapperViewManager(), LuggPolylineViewManager())
+    listOf(LuggMapViewManager(), LuggMarkerViewManager(), LuggMapWrapperViewManager(), LuggPolylineViewManager(), LuggPolygonViewManager())
 }
diff --git a/android/src/main/java/com/luggmaps/LuggPolygonView.kt b/android/src/main/java/com/luggmaps/LuggPolygonView.kt
new file mode 100644
index 0000000..91569a7
--- /dev/null
+++ b/android/src/main/java/com/luggmaps/LuggPolygonView.kt
@@ -0,0 +1,78 @@
+package com.luggmaps
+
+import android.content.Context
+import android.graphics.Color
+import com.facebook.react.views.view.ReactViewGroup
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.Polygon
+import com.luggmaps.events.PolygonPressEvent
+import com.luggmaps.extensions.dispatchEvent
+
+interface LuggPolygonViewDelegate {
+  fun polygonViewDidUpdate(polygonView: LuggPolygonView)
+}
+
+class LuggPolygonView(context: Context) : ReactViewGroup(context) {
+  var coordinates: List<LatLng> = emptyList()
+    private set
+
+  var strokeColor: Int = Color.BLACK
+    private set
+
+  var fillColor: Int = Color.argb(77, 0, 0, 0)
+    private set
+
+  var strokeWidth: Float = 1f
+    private set
+
+  var zIndex: Float = 0f
+    private set
+
+  var tappable: Boolean = false
+    private set
+
+  var delegate: LuggPolygonViewDelegate? = null
+  var polygon: Polygon? = null
+
+  init {
+    visibility = GONE
+  }
+
+  fun setCoordinates(coords: List<LatLng>) {
+    coordinates = coords
+  }
+
+  fun setStrokeColor(color: Int) {
+    strokeColor = color
+  }
+
+  fun setFillColor(color: Int) {
+    fillColor = color
+  }
+
+  fun setStrokeWidth(width: Float) {
+    strokeWidth = width
+  }
+
+  fun setZIndex(value: Float) {
+    zIndex = value
+  }
+
+  fun setTappable(value: Boolean) {
+    tappable = value
+  }
+
+  fun emitPressEvent() {
+    dispatchEvent(PolygonPressEvent(this))
+  }
+
+  fun onAfterUpdateTransaction() {
+    delegate?.polygonViewDidUpdate(this)
+  }
+
+  fun onDropViewInstance() {
+    delegate = null
+    polygon?.remove()
+    polygon = null
+  }
+}
diff --git a/android/src/main/java/com/luggmaps/LuggPolygonViewManager.kt b/android/src/main/java/com/luggmaps/LuggPolygonViewManager.kt
new file mode 100644
index 0000000..baf19a6
--- /dev/null
+++ b/android/src/main/java/com/luggmaps/LuggPolygonViewManager.kt
@@ -0,0 +1,76 @@
+package com.luggmaps
+
+import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.uimanager.ThemedReactContext
+import com.facebook.react.uimanager.ViewGroupManager
+import com.facebook.react.uimanager.ViewManagerDelegate
+import com.facebook.react.uimanager.annotations.ReactProp
+import com.facebook.react.viewmanagers.LuggPolygonViewManagerDelegate
+import com.facebook.react.viewmanagers.LuggPolygonViewManagerInterface
+import com.google.android.gms.maps.model.LatLng
+
+@ReactModule(name = LuggPolygonViewManager.NAME)
+class LuggPolygonViewManager :
+  ViewGroupManager<LuggPolygonView>(),
+  LuggPolygonViewManagerInterface<LuggPolygonView> {
+  private val delegate: ViewManagerDelegate<LuggPolygonView> = LuggPolygonViewManagerDelegate(this)
+
+  override fun getDelegate(): ViewManagerDelegate<LuggPolygonView> = delegate
+  override fun getName(): String = NAME
+  override fun createViewInstance(context: ThemedReactContext): LuggPolygonView = LuggPolygonView(context)
+
+  override fun onDropViewInstance(view: LuggPolygonView) {
+    super.onDropViewInstance(view)
+    view.onDropViewInstance()
+  }
+
+  override fun onAfterUpdateTransaction(view: LuggPolygonView) {
+    super.onAfterUpdateTransaction(view)
+    view.onAfterUpdateTransaction()
+  }
+
+  @ReactProp(name = "coordinates")
+  override fun setCoordinates(view: LuggPolygonView, value: ReadableArray?) {
+    value?.let { array ->
+      val coords = mutableListOf<LatLng>()
+      for (i in 0 until array.size()) {
+        val coord = array.getMap(i)
+        val lat = coord?.getDouble("latitude") ?: 0.0
+        val lng = coord?.getDouble("longitude") ?: 0.0
+        coords.add(LatLng(lat, lng))
+      }
+      view.setCoordinates(coords)
+    }
+  }
+
+  @ReactProp(name = "strokeColor", customType = "Color")
+  override fun setStrokeColor(view: LuggPolygonView, value: Int?) {
+    view.setStrokeColor(value ?: android.graphics.Color.BLACK)
+  }
+
+  @ReactProp(name = "fillColor", customType = "Color")
+  override fun setFillColor(view: LuggPolygonView, value: Int?) {
+    view.setFillColor(value ?: android.graphics.Color.argb(77, 0, 0, 0))
+  }
+
+  @ReactProp(name = "strokeWidth", defaultDouble = 1.0)
+  override fun setStrokeWidth(view: LuggPolygonView, value: Double) {
+    view.setStrokeWidth(value.toFloat())
+  }
+
+  @ReactProp(name = "tappable")
+  override fun setTappable(view: LuggPolygonView, value: Boolean) {
+    view.setTappable(value)
+  }
+
+  @ReactProp(name = "zIndex", defaultFloat = 0f)
+  override fun setZIndex(view: LuggPolygonView, value: Float) {
+    super.setZIndex(view, value)
+    view.setZIndex(value)
+  }
+
+  companion object {
+    const val NAME = "LuggPolygonView"
+  }
+}
diff --git a/android/src/main/java/com/luggmaps/core/GoogleMapProvider.kt b/android/src/main/java/com/luggmaps/core/GoogleMapProvider.kt
index 14c21e4..f1292a2 100644
--- a/android/src/main/java/com/luggmaps/core/GoogleMapProvider.kt
+++ b/android/src/main/java/com/luggmaps/core/GoogleMapProvider.kt
@@ -2,9 +2,10 @@ package com.luggmaps.core
 
 import android.annotation.SuppressLint
 import android.content.Context
+import android.graphics.Color
+import android.view.MotionEvent
 import android.view.View
 import com.facebook.react.uimanager.PixelUtil.dpToPx
-import com.facebook.react.util.RNLog
 import com.google.android.gms.maps.CameraUpdateFactory
 import com.google.android.gms.maps.GoogleMap
 import com.google.android.gms.maps.GoogleMapOptions
@@ -14,9 +15,14 @@ import com.google.android.gms.maps.model.AdvancedMarker
 import com.google.android.gms.maps.model.AdvancedMarkerOptions
 import com.google.android.gms.maps.model.LatLng
 import com.google.android.gms.maps.model.MapColorScheme
+import com.google.android.gms.maps.model.Polygon
+import com.google.android.gms.maps.model.PolygonOptions
 import com.google.android.gms.maps.model.PolylineOptions
+import com.luggmaps.LuggMapWrapperView
 import com.luggmaps.LuggMarkerView
 import com.luggmaps.LuggMarkerViewDelegate
+import com.luggmaps.LuggPolygonView
+import com.luggmaps.LuggPolygonViewDelegate
 import com.luggmaps.LuggPolylineView
 import com.luggmaps.LuggPolylineViewDelegate
 
@@ -25,22 +31,29 @@ class GoogleMapProvider(private val context: Context) :
   OnMapReadyCallback,
   LuggMarkerViewDelegate,
   LuggPolylineViewDelegate,
+  LuggPolygonViewDelegate,
   GoogleMap.OnCameraMoveStartedListener,
   GoogleMap.OnCameraMoveListener,
-  GoogleMap.OnCameraIdleListener {
+  GoogleMap.OnCameraIdleListener,
+  GoogleMap.OnPolygonClickListener {
 
   override var delegate: MapProviderDelegate? = null
   override val isMapReady: Boolean get() = _isMapReady
 
   var mapId: String = DEMO_MAP_ID
 
+  private var wrapperView: LuggMapWrapperView? = null
   private var mapView: MapView? = null
   private var googleMap: GoogleMap? = null
   private var _isMapReady = false
   private var isDragging = false
   private val pendingMarkerViews = mutableSetOf<LuggMarkerView>()
   private val pendingPolylineViews = mutableSetOf<LuggPolylineView>()
+  private val pendingPolygonViews = mutableSetOf<LuggPolygonView>()
   private val polylineAnimators = mutableMapOf<LuggPolylineView, PolylineAnimator>()
+  private val polygonToViewMap = mutableMapOf<Polygon, LuggPolygonView>()
+  private var pressedPolygon: Polygon? = null
+  private var pressedPolygonView: LuggPolygonView? = null
 
   // Initial camera settings
   private var initialLatitude: Double = 0.0
@@ -74,23 +87,34 @@ class GoogleMapProvider(private val context: Context) :
     initialLongitude = longitude
     initialZoom = zoom
 
+    val wrapper = wrapperView as LuggMapWrapperView
+    this.wrapperView = wrapper
+    wrapper.touchEventHandler = { event -> handleMapTouch(event) }
+
     val options = GoogleMapOptions().mapId(mapId)
     mapView = MapView(context, options).also { view ->
       view.onCreate(null)
       view.onResume()
       view.getMapAsync(this)
-      (wrapperView as android.view.ViewGroup).addView(view)
+      wrapper.addView(view)
     }
   }
 
   override fun destroy() {
     pendingMarkerViews.clear()
     pendingPolylineViews.clear()
+    pendingPolygonViews.clear()
     polylineAnimators.values.forEach { it.destroy() }
     polylineAnimators.clear()
+    polygonToViewMap.clear()
+    pressedPolygon = null
+    pressedPolygonView = null
+    wrapperView?.touchEventHandler = null
+    wrapperView = null
     googleMap?.setOnCameraMoveStartedListener(null)
     googleMap?.setOnCameraMoveListener(null)
     googleMap?.setOnCameraIdleListener(null)
+    googleMap?.setOnPolygonClickListener(null)
     googleMap?.clear()
     googleMap = null
     _isMapReady = false
@@ -109,6 +133,7 @@ class GoogleMapProvider(private val context: Context) :
     map.setOnCameraMoveStartedListener(this)
     map.setOnCameraMoveListener(this)
     map.setOnCameraIdleListener(this)
+    map.setOnPolygonClickListener(this)
 
     applyUiSettings()
     applyZoomLimits()
@@ -117,6 +142,7 @@ class GoogleMapProvider(private val context: Context) :
     applyUserLocation()
     processPendingMarkers()
     processPendingPolylines()
+    processPendingPolygons()
 
     delegate?.mapProviderDidReady()
   }
@@ -148,6 +174,77 @@ class GoogleMapProvider(private val context: Context) :
     isDragging = false
   }
 
+  override fun onPolygonClick(polygon: Polygon) {
+    val polygonView = polygonToViewMap[polygon]
+    restorePolygonHighlight()
+    polygonView?.emitPressEvent()
+  }
+
+  private fun handleMapTouch(event: MotionEvent) {
+    when (event.actionMasked) {
+      MotionEvent.ACTION_DOWN -> {
+        val map = googleMap ?: return
+        val point = android.graphics.Point(event.x.toInt(), event.y.toInt())
+        val latLng = map.projection.fromScreenLocation(point)
+
+        for ((polygon, view) in polygonToViewMap) {
+          if (!view.tappable) continue
+          if (containsLocation(latLng, polygon.points)) {
+            pressedPolygon = polygon
+            pressedPolygonView = view
+            applyPolygonHighlight()
+            return
+          }
+        }
+      }
+
+      MotionEvent.ACTION_UP, MotionEvent.ACTION_CANCEL -> {
+        restorePolygonHighlight()
+      }
+    }
+  }
+
+  private fun containsLocation(point: LatLng, polygon: List<LatLng>): Boolean {
+    if (polygon.isEmpty()) return false
+    var inside = false
+    var j = polygon.size - 1
+    for (i in polygon.indices) {
+      val pi = polygon[i]
+      val pj = polygon[j]
+      if ((pi.latitude > point.latitude) != (pj.latitude > point.latitude) &&
+        point.longitude < (pj.longitude - pi.longitude) *
+        (point.latitude - pi.latitude) /
+        (pj.latitude - pi.latitude) +
+        pi.longitude
+      ) {
+        inside = !inside
+      }
+      j = i
+    }
+    return inside
+  }
+
+  private fun applyPolygonHighlight() {
+    val polygon = pressedPolygon ?: return
+    val view = pressedPolygonView ?: return
+    polygon.fillColor = fadeColor(view.fillColor)
+    polygon.strokeColor = fadeColor(view.strokeColor)
+  }
+
+  private fun fadeColor(color: Int): Int {
+    val alpha = (Color.alpha(color) * 0.5).toInt()
+    return Color.argb(alpha, Color.red(color), Color.green(color), Color.blue(color))
+  }
+
+  private fun restorePolygonHighlight() {
+    val polygon = pressedPolygon ?: return
+    val view = pressedPolygonView ?: return
+    polygon.fillColor = view.fillColor
+    polygon.strokeColor = view.strokeColor
+    pressedPolygon = null
+    pressedPolygonView = null
+  }
+
   // endregion
 
   // region Props
@@ -270,6 +367,14 @@ class GoogleMapProvider(private val context: Context) :
 
   // endregion
 
+  // region PolygonViewDelegate
+
+  override fun polygonViewDidUpdate(polygonView: LuggPolygonView) {
+    syncPolygonView(polygonView)
+  }
+
+  // endregion
+
   // region Marker Management
 
   override fun addMarkerView(markerView: LuggMarkerView) {
@@ -404,6 +509,64 @@ class GoogleMapProvider(private val context: Context) :
 
   // endregion
 
+  // region Polygon Management
+
+  override fun addPolygonView(polygonView: LuggPolygonView) {
+    polygonView.delegate = this
+    syncPolygonView(polygonView)
+  }
+
+  override fun removePolygonView(polygonView: LuggPolygonView) {
+    polygonView.polygon?.let { polygonToViewMap.remove(it) }
+    polygonView.polygon?.remove()
+    polygonView.polygon = null
+  }
+
+  private fun syncPolygonView(polygonView: LuggPolygonView) {
+    if (googleMap == null) {
+      pendingPolygonViews.add(polygonView)
+      return
+    }
+
+    if (polygonView.polygon == null) {
+      addPolygonViewToMap(polygonView)
+      return
+    }
+
+    polygonView.polygon?.apply {
+      points = polygonView.coordinates
+      fillColor = polygonView.fillColor
+      strokeColor = polygonView.strokeColor
+      strokeWidth = polygonView.strokeWidth.dpToPx()
+      zIndex = polygonView.zIndex
+      isClickable = polygonView.tappable
+    }
+  }
+
+  private fun processPendingPolygons() {
+    if (googleMap == null) return
+    pendingPolygonViews.forEach { addPolygonViewToMap(it) }
+    pendingPolygonViews.clear()
+  }
+
+  private fun addPolygonViewToMap(polygonView: LuggPolygonView) {
+    val map = googleMap ?: return
+
+    val options = PolygonOptions()
+      .addAll(polygonView.coordinates)
+      .fillColor(polygonView.fillColor)
+      .strokeColor(polygonView.strokeColor)
+      .strokeWidth(polygonView.strokeWidth.dpToPx())
+      .zIndex(polygonView.zIndex)
+
+    val polygon = map.addPolygon(options)
+    polygon.isClickable = polygonView.tappable
+    polygonView.polygon = polygon
+    polygonToViewMap[polygon] = polygonView
+  }
+
+  // endregion
+
   // region Lifecycle
 
   override fun pauseAnimations() {
diff --git a/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt b/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt
index 210a45e..17af711 100644
--- a/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt
+++ b/android/src/main/java/com/luggmaps/core/MapProviderDelegate.kt
@@ -2,6 +2,7 @@ package com.luggmaps.core
 
 import android.view.View
 import com.luggmaps.LuggMarkerView
+import com.luggmaps.LuggPolygonView
 import com.luggmaps.LuggPolylineView
 
 data class EdgeInsets(val top: Int = 0, val left: Int = 0, val bottom: Int = 0, val right: Int = 0)
@@ -37,6 +38,8 @@ interface MapProvider {
   fun removeMarkerView(markerView: LuggMarkerView)
   fun addPolylineView(polylineView: LuggPolylineView)
   fun removePolylineView(polylineView: LuggPolylineView)
+  fun addPolygonView(polygonView: LuggPolygonView)
+  fun removePolygonView(polygonView: LuggPolygonView)
 
   // Lifecycle
   fun pauseAnimations()
diff --git a/android/src/main/java/com/luggmaps/events/PolygonPressEvent.kt b/android/src/main/java/com/luggmaps/events/PolygonPressEvent.kt
new file mode 100644
index 0000000..f68882d
--- /dev/null
+++ b/android/src/main/java/com/luggmaps/events/PolygonPressEvent.kt
@@ -0,0 +1,12 @@
+package com.luggmaps.events
+
+import android.view.View
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.uimanager.UIManagerHelper
+import com.facebook.react.uimanager.events.Event
+
+class PolygonPressEvent(view: View) : Event<PolygonPressEvent>(UIManagerHelper.getSurfaceId(view), view.id) {
+  override fun getEventName() = "topPress"
+
+  override fun getEventData() = Arguments.createMap()
+}
diff --git a/docs/POLYGON.md b/docs/POLYGON.md
new file mode 100644
index 0000000..bd7d633
--- /dev/null
+++ b/docs/POLYGON.md
@@ -0,0 +1,36 @@
+# Polygon
+
+Polygon component for drawing filled shapes on the map.
+
+## Usage
+
+```tsx
+import { MapView, Polygon } from '@lugg/maps';
+
+<MapView style={{ flex: 1 }}>
+  {/* Simple polygon */}
+  <Polygon
+    coordinates={[
+      { latitude: 37.784, longitude: -122.428 },
+      { latitude: 37.784, longitude: -122.422 },
+      { latitude: 37.779, longitude: -122.422 },
+      { latitude: 37.779, longitude: -122.428 },
+    ]}
+    fillColor="rgba(66, 133, 244, 0.3)"
+    strokeColor="#4285F4"
+    strokeWidth={2}
+    onPress={() => console.log('Polygon pressed')}
+  />
+</MapView>
+```
+
+## Props
+
+| Prop | Type | Default | Description |
+|------|------|---------|-------------|
+| `coordinates` | `Coordinate[]` | **required** | Array of coordinates forming the polygon boundary |
+| `fillColor` | `ColorValue` | - | Fill color of the polygon |
+| `strokeColor` | `ColorValue` | - | Stroke (outline) color |
+| `strokeWidth` | `number` | - | Stroke width in points |
+| `zIndex` | `number` | - | Z-index for layering |
+| `onPress` | `() => void` | - | Called when the polygon is tapped |
diff --git a/example/bare/ios/Podfile.lock b/example/bare/ios/Podfile.lock
index 0c75b36..9315d4a 100644
--- a/example/bare/ios/Podfile.lock
+++ b/example/bare/ios/Podfile.lock
@@ -11,7 +11,7 @@ PODS:
   - hermes-engine (0.14.0):
     - hermes-engine/Pre-built (= 0.14.0)
   - hermes-engine/Pre-built (0.14.0)
-  - LuggMaps (0.2.0-alpha.27):
+  - LuggMaps (0.2.0-alpha.30):
     - boost
     - DoubleConversion
     - fast_float
@@ -3050,7 +3050,7 @@ SPEC CHECKSUMS:
   glog: 5683914934d5b6e4240e497e0f4a3b42d1854183
   GoogleMaps: 0608099d4870cac8754bdba9b6953db543432438
   hermes-engine: 3515eff1a2de44b79dfa94a03d1adeed40f0dafe
-  LuggMaps: 52b43077d9f8ca87c7c9c22771aa61fd93df5ae3
+  LuggMaps: 9fadfbfebeead30c7c578722bbb306e433fce8ed
   RCT-Folly: 846fda9475e61ec7bcbf8a3fe81edfcaeb090669
   RCTDeprecation: 2b70c6e3abe00396cefd8913efbf6a2db01a2b36
   RCTRequired: f3540eee8094231581d40c5c6d41b0f170237a81
diff --git a/example/shared/src/Home.tsx b/example/shared/src/Home.tsx
index 66c1e74..550d6ff 100644
--- a/example/shared/src/Home.tsx
+++ b/example/shared/src/Home.tsx
@@ -63,8 +63,8 @@ function HomeContent() {
   const [provider, setProvider] = useState<MapProviderType>('apple');
   const [showMap, setShowMap] = useState(true);
   const [markers, setMarkers] = useState(INITIAL_MARKERS);
-  const [cameraPosition, setCameraPosition] = useState<CameraEventPayload>();
-  const [isIdle, setIsIdle] = useState(true);
+  const [statusText, setStatusText] = useState('Loading...');
+  const lastCoordinate = useRef({ latitude: 37.78, longitude: -122.43 });
 
   const getSheetBottom = useCallback(
     (event: DetentChangeEvent) => screenHeight - event.nativeEvent.position,
@@ -94,17 +94,24 @@ function HomeContent() {
     [getSheetBottom]
   );
 
-  const handleCameraEvent = useCallback(
+  const formatCameraEvent = useCallback(
     (event: { nativeEvent: CameraEventPayload }, idle: boolean) => {
-      setCameraPosition(event.nativeEvent);
-      setIsIdle(idle);
+      const { coordinate, zoom, gesture } = event.nativeEvent;
+      lastCoordinate.current = coordinate;
+      const pos = `${coordinate.latitude.toFixed(
+        5
+      )}, ${coordinate.longitude.toFixed(5)} (z${zoom.toFixed(1)})`;
+      const suffix = idle
+        ? ` (idle${gesture ? ', gesture' : ''})`
+        : gesture
+        ? ' (gesture)'
+        : '';
+      setStatusText(pos + suffix);
     },
     []
   );
 
   const addMarker = () => {
-    if (!cameraPosition) return;
-
     const type = randomFrom(MARKER_TYPES);
     const id = Date.now().toString();
 
@@ -113,7 +120,7 @@ function HomeContent() {
       {
         id,
         name: `marker-${id}`,
-        coordinate: cameraPosition.coordinate,
+        coordinate: lastCoordinate.current,
         type,
         anchor: { x: 0.5, y: type === 'icon' ? 1 : 0.5 },
         text: randomLetter(),
@@ -159,8 +166,9 @@ function HomeContent() {
           animatedPosition={animatedPosition}
           userLocationEnabled={locationPermission}
           onReady={handleMapReady}
-          onCameraMove={(e) => handleCameraEvent(e, false)}
-          onCameraIdle={(e) => handleCameraEvent(e, true)}
+          onCameraMove={(e) => formatCameraEvent(e, false)}
+          onCameraIdle={(e) => formatCameraEvent(e, true)}
+          onPolygonPress={() => setStatusText('Polygon pressed!')}
         />
       )}
 
@@ -176,22 +184,7 @@ function HomeContent() {
         onDidPresent={handleSheetPresent}
         onDetentChange={handleDetentChange}
       >
-        <Text style={styles.positionText}>
-          {cameraPosition ? (
-            <>
-              {cameraPosition.coordinate.latitude.toFixed(5)},{' '}
-              {cameraPosition.coordinate.longitude.toFixed(5)} (z
-              {cameraPosition.zoom.toFixed(1)})
-              {isIdle
-                ? ` (idle${cameraPosition.gesture ? ', gesture' : ''})`
-                : cameraPosition.gesture
-                ? ' (gesture)'
-                : ''}
-            </>
-          ) : (
-            'Loading...'
-          )}
-        </Text>
+        <Text style={styles.statusText}>{statusText}</Text>
         <View style={styles.sheetContent}>
           <Button title="Add Marker" onPress={addMarker} />
           <Button
@@ -229,7 +222,7 @@ function HomeContent() {
 
 const styles = StyleSheet.create({
   container: { flex: 1 },
-  positionText: {
+  statusText: {
     fontSize: 14,
     color: '#666',
   },
diff --git a/example/shared/src/components/Map.tsx b/example/shared/src/components/Map.tsx
index 1e55229..f654f7b 100644
--- a/example/shared/src/components/Map.tsx
+++ b/example/shared/src/components/Map.tsx
@@ -3,6 +3,7 @@ import { StyleSheet, View, useWindowDimensions } from 'react-native';
 import {
   MapView,
   Marker,
+  Polygon,
   type MapViewProps,
   type CameraEventPayload,
 } from '@lugg/maps';
@@ -22,10 +23,24 @@ import { Route, smoothCoordinates } from './Route';
 interface MapProps extends MapViewProps {
   markers: MarkerData[];
   animatedPosition?: SharedValue<number>;
+  onPolygonPress?: () => void;
 }
 
 const INITIAL_ZOOM = 14;
 
+const CIRCLE_CENTER = { latitude: 37.78, longitude: -122.43 };
+const CIRCLE_RADIUS = 0.003;
+const CIRCLE_COORDS = Array.from({ length: 36 }, (_, i) => {
+  const angle = (i * 10 * Math.PI) / 180;
+  return {
+    latitude: CIRCLE_CENTER.latitude + CIRCLE_RADIUS * Math.cos(angle),
+    longitude:
+      CIRCLE_CENTER.longitude +
+      (CIRCLE_RADIUS * Math.sin(angle)) /
+        Math.cos((CIRCLE_CENTER.latitude * Math.PI) / 180),
+  };
+});
+
 const renderMarker = (marker: MarkerData) => {
   const {
     id,
@@ -91,6 +106,7 @@ export const Map = forwardRef<MapView, MapProps>(
       animatedPosition,
       onCameraIdle,
       onCameraMove,
+      onPolygonPress,
       ...props
     },
     ref
@@ -140,6 +156,13 @@ export const Map = forwardRef<MapView, MapProps>(
           {markers.map(renderMarker)}
           <Route coordinates={smoothedRoute} />
           <CrewMarker route={smoothedRoute} zoom={zoom} />
+          <Polygon
+            coordinates={CIRCLE_COORDS}
+            fillColor="rgba(66, 133, 244, 0.15)"
+            strokeColor="#4285F4"
+            strokeWidth={2}
+            onPress={onPolygonPress}
+          />
           <MarkerText
             name="inline-marker"
             coordinate={{ latitude: 37.782, longitude: -122.425 }}
diff --git a/ios/LuggMapView.mm b/ios/LuggMapView.mm
index aa4b035..108315b 100644
--- a/ios/LuggMapView.mm
+++ b/ios/LuggMapView.mm
@@ -1,6 +1,7 @@
 #import "LuggMapView.h"
 #import "LuggMapWrapperView.h"
 #import "LuggMarkerView.h"
+#import "LuggPolygonView.h"
 #import "LuggPolylineView.h"
 #import "core/AppleMapProvider.h"
 #import "core/GoogleMapProvider.h"
@@ -83,6 +84,11 @@ - (void)mountChildComponentView:
     if (_provider) {
       [_provider addPolylineView:polylineView];
     }
+  } else if ([childComponentView isKindOfClass:[LuggPolygonView class]]) {
+    LuggPolygonView *polygonView = (LuggPolygonView *)childComponentView;
+    if (_provider) {
+      [_provider addPolygonView:polygonView];
+    }
   }
 }
 
@@ -99,6 +105,11 @@ - (void)unmountChildComponentView:
     if (_provider) {
       [_provider removePolylineView:polylineView];
     }
+  } else if ([childComponentView isKindOfClass:[LuggPolygonView class]]) {
+    LuggPolygonView *polygonView = (LuggPolygonView *)childComponentView;
+    if (_provider) {
+      [_provider removePolygonView:polygonView];
+    }
   }
 
   [super unmountChildComponentView:childComponentView index:index];
@@ -164,6 +175,8 @@ - (void)initializeProvider {
       [_provider addMarkerView:(LuggMarkerView *)subview];
     } else if ([subview isKindOfClass:[LuggPolylineView class]]) {
       [_provider addPolylineView:(LuggPolylineView *)subview];
+    } else if ([subview isKindOfClass:[LuggPolygonView class]]) {
+      [_provider addPolygonView:(LuggPolygonView *)subview];
     }
   }
 }
diff --git a/ios/LuggPolygonView.h b/ios/LuggPolygonView.h
new file mode 100644
index 0000000..7590a12
--- /dev/null
+++ b/ios/LuggPolygonView.h
@@ -0,0 +1,30 @@
+#import <CoreLocation/CoreLocation.h>
+#import <React/RCTViewComponentView.h>
+#import <UIKit/UIKit.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class LuggPolygonView;
+
+@protocol LuggPolygonViewDelegate <NSObject>
+@optional
+- (void)polygonViewDidUpdate:(LuggPolygonView *)polygonView;
+@end
+
+@interface LuggPolygonView : RCTViewComponentView
+
+@property(nonatomic, readonly) NSArray<CLLocation *> *coordinates;
+@property(nonatomic, readonly) UIColor *strokeColor;
+@property(nonatomic, readonly) UIColor *fillColor;
+@property(nonatomic, readonly) CGFloat strokeWidth;
+@property(nonatomic, readonly) NSInteger zIndex;
+@property(nonatomic, readonly) BOOL tappable;
+@property(nonatomic, weak, nullable) id<LuggPolygonViewDelegate> delegate;
+@property(nonatomic, strong, nullable) NSObject *polygon;
+@property(nonatomic, weak, nullable) NSObject *renderer;
+
+- (void)emitPressEvent;
+
+@end
+
+NS_ASSUME_NONNULL_END
diff --git a/ios/LuggPolygonView.mm b/ios/LuggPolygonView.mm
new file mode 100644
index 0000000..f373f1b
--- /dev/null
+++ b/ios/LuggPolygonView.mm
@@ -0,0 +1,132 @@
+#import "LuggPolygonView.h"
+#import "events/PolygonPressEvent.h"
+
+#import <react/renderer/components/RNMapsSpec/ComponentDescriptors.h>
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+#import <react/renderer/components/RNMapsSpec/Props.h>
+#import <react/renderer/components/RNMapsSpec/RCTComponentViewHelpers.h>
+
+#import "RCTFabricComponentsPlugins.h"
+#import <React/RCTConversions.h>
+
+using namespace facebook::react;
+using namespace luggmaps::events;
+
+@interface LuggPolygonView () <RCTLuggPolygonViewViewProtocol>
+@end
+
+@implementation LuggPolygonView {
+  NSArray<CLLocation *> *_coordinates;
+  UIColor *_strokeColor;
+  UIColor *_fillColor;
+  CGFloat _strokeWidth;
+  NSInteger _zIndex;
+  BOOL _tappable;
+}
+
++ (ComponentDescriptorProvider)componentDescriptorProvider {
+  return concreteComponentDescriptorProvider<
+      LuggPolygonViewComponentDescriptor>();
+}
+
+- (instancetype)initWithFrame:(CGRect)frame {
+  if (self = [super initWithFrame:frame]) {
+    static const auto defaultProps =
+        std::make_shared<const LuggPolygonViewProps>();
+    _props = defaultProps;
+
+    _coordinates = @[];
+    _strokeColor = [UIColor blackColor];
+    _fillColor = [UIColor colorWithRed:0 green:0 blue:0 alpha:0.3];
+    _strokeWidth = 1.0;
+
+    self.hidden = YES;
+  }
+
+  return self;
+}
+
+- (void)updateProps:(Props::Shared const &)props
+           oldProps:(Props::Shared const &)oldProps {
+  [super updateProps:props oldProps:oldProps];
+  const auto &newViewProps =
+      *std::static_pointer_cast<LuggPolygonViewProps const>(props);
+
+  NSMutableArray<CLLocation *> *coords = [NSMutableArray array];
+  for (const auto &coord : newViewProps.coordinates) {
+    CLLocation *location =
+        [[CLLocation alloc] initWithLatitude:coord.latitude
+                                   longitude:coord.longitude];
+    [coords addObject:location];
+  }
+  _coordinates = [coords copy];
+
+  if (newViewProps.strokeColor) {
+    UIColor *color = RCTUIColorFromSharedColor(newViewProps.strokeColor);
+    if (color) {
+      _strokeColor = color;
+    }
+  }
+
+  if (newViewProps.fillColor) {
+    UIColor *color = RCTUIColorFromSharedColor(newViewProps.fillColor);
+    if (color) {
+      _fillColor = color;
+    }
+  }
+
+  _strokeWidth = newViewProps.strokeWidth > 0 ? newViewProps.strokeWidth : 1.0;
+  _zIndex = newViewProps.zIndex.value_or(0);
+  _tappable = newViewProps.tappable;
+}
+
+- (void)finalizeUpdates:(RNComponentViewUpdateMask)updateMask {
+  [super finalizeUpdates:updateMask];
+
+  if (updateMask & RNComponentViewUpdateMaskProps) {
+    if ([self.delegate respondsToSelector:@selector(polygonViewDidUpdate:)]) {
+      [self.delegate polygonViewDidUpdate:self];
+    }
+  }
+}
+
+- (NSArray<CLLocation *> *)coordinates {
+  return _coordinates;
+}
+
+- (UIColor *)strokeColor {
+  return _strokeColor;
+}
+
+- (UIColor *)fillColor {
+  return _fillColor;
+}
+
+- (CGFloat)strokeWidth {
+  return _strokeWidth;
+}
+
+- (NSInteger)zIndex {
+  return _zIndex;
+}
+
+- (BOOL)tappable {
+  return _tappable;
+}
+
+- (void)emitPressEvent {
+  PolygonPressEvent::emit<LuggPolygonViewEventEmitter>(_eventEmitter);
+}
+
+- (void)prepareForRecycle {
+  [super prepareForRecycle];
+  self.polygon = nil;
+  self.renderer = nil;
+  self.delegate = nil;
+}
+
+Class<RCTComponentViewProtocol> LuggPolygonViewCls(void) {
+  return LuggPolygonView.class;
+}
+
+@end
diff --git a/ios/core/AppleMapProvider.mm b/ios/core/AppleMapProvider.mm
index e01d711..e20e223 100644
--- a/ios/core/AppleMapProvider.mm
+++ b/ios/core/AppleMapProvider.mm
@@ -1,5 +1,6 @@
 #import "AppleMapProvider.h"
 #import "../LuggMarkerView.h"
+#import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
 #import "../extensions/MKMapView+Zoom.h"
 #import "MKPolylineAnimator.h"
@@ -18,8 +19,9 @@ @implementation AppleMarkerAnnotation
 @implementation LuggAppleMapViewContent
 @end
 
-@interface AppleMapProvider () <LuggMarkerViewDelegate,
-                                LuggPolylineViewDelegate>
+@interface AppleMapProvider () <
+    LuggMarkerViewDelegate, LuggPolylineViewDelegate, LuggPolygonViewDelegate,
+    UIGestureRecognizerDelegate>
 @end
 
 @implementation AppleMapProvider {
@@ -29,6 +31,9 @@ @implementation AppleMapProvider {
   double _minZoom;
   double _maxZoom;
   NSMapTable<id<MKOverlay>, LuggPolylineView *> *_overlayToPolylineMap;
+  NSMapTable<id<MKOverlay>, LuggPolygonView *> *_overlayToPolygonMap;
+  UILongPressGestureRecognizer *_polygonPressGesture;
+  LuggPolygonView *_pressedPolygonView;
 
   // Edge insets animation
   CADisplayLink *_edgeInsetsDisplayLink;
@@ -43,6 +48,7 @@ @implementation AppleMapProvider {
 - (instancetype)init {
   if (self = [super init]) {
     _overlayToPolylineMap = [NSMapTable strongToWeakObjectsMapTable];
+    _overlayToPolygonMap = [NSMapTable strongToWeakObjectsMapTable];
   }
   return self;
 }
@@ -71,6 +77,14 @@ - (void)initializeMapInView:(UIView *)wrapperView
 
   [self applyZoomRange];
 
+  _polygonPressGesture = [[UILongPressGestureRecognizer alloc]
+      initWithTarget:self
+              action:@selector(handlePolygonPress:)];
+  _polygonPressGesture.minimumPressDuration = 0;
+  _polygonPressGesture.cancelsTouchesInView = NO;
+  _polygonPressGesture.delegate = self;
+  [_mapView addGestureRecognizer:_polygonPressGesture];
+
   [wrapperView addSubview:_mapView];
 
   MKCoordinateRegion region = [_mapView regionForCenterCoordinate:coordinate
@@ -84,6 +98,11 @@ - (void)initializeMapInView:(UIView *)wrapperView
 
 - (void)destroy {
   [self stopEdgeInsetsAnimation];
+  if (_polygonPressGesture) {
+    [_mapView removeGestureRecognizer:_polygonPressGesture];
+    _polygonPressGesture = nil;
+  }
+  _pressedPolygonView = nil;
   [_mapView removeFromSuperview];
   _mapView = nil;
   _isMapReady = NO;
@@ -227,6 +246,102 @@ - (void)applyZoomRange {
   _mapView.cameraZoomRange = zoomRange;
 }
 
+- (LuggPolygonView *)hitTestPolygonAtPoint:(CGPoint)point {
+  CLLocationCoordinate2D tapCoordinate = [_mapView convertPoint:point
+                                           toCoordinateFromView:_mapView];
+  MKMapPoint mapPoint = MKMapPointForCoordinate(tapCoordinate);
+  CGPoint mapPointAsCGP = CGPointMake(mapPoint.x, mapPoint.y);
+
+  NSArray<id<MKOverlay>> *overlays = _mapView.overlays;
+  for (NSInteger i = overlays.count - 1; i >= 0; i--) {
+    id<MKOverlay> overlay = overlays[i];
+    if (![overlay isKindOfClass:[MKPolygon class]])
+      continue;
+
+    LuggPolygonView *polygonView = [_overlayToPolygonMap objectForKey:overlay];
+    if (!polygonView || !polygonView.tappable)
+      continue;
+
+    NSArray<CLLocation *> *coordinates = polygonView.coordinates;
+    if (coordinates.count == 0)
+      continue;
+
+    CGMutablePathRef path = CGPathCreateMutable();
+    for (NSUInteger j = 0; j < coordinates.count; j++) {
+      MKMapPoint mp = MKMapPointForCoordinate(coordinates[j].coordinate);
+      if (j == 0) {
+        CGPathMoveToPoint(path, NULL, mp.x, mp.y);
+      } else {
+        CGPathAddLineToPoint(path, NULL, mp.x, mp.y);
+      }
+    }
+    CGPathCloseSubpath(path);
+
+    BOOL contains = CGPathContainsPoint(path, NULL, mapPointAsCGP, NO);
+    CGPathRelease(path);
+
+    if (contains)
+      return polygonView;
+  }
+  return nil;
+}
+
+- (void)handlePolygonPress:(UILongPressGestureRecognizer *)gesture {
+  if (gesture.state == UIGestureRecognizerStateBegan) {
+    CGPoint point = [gesture locationInView:_mapView];
+    LuggPolygonView *hit = [self hitTestPolygonAtPoint:point];
+    if (hit) {
+      _pressedPolygonView = hit;
+      [self applyPolygonHighlight];
+    }
+  } else if (gesture.state == UIGestureRecognizerStateEnded) {
+    if (_pressedPolygonView) {
+      [self restorePolygonHighlight];
+      [_pressedPolygonView emitPressEvent];
+      _pressedPolygonView = nil;
+    }
+  } else if (gesture.state == UIGestureRecognizerStateCancelled ||
+             gesture.state == UIGestureRecognizerStateFailed) {
+    if (_pressedPolygonView) {
+      [self restorePolygonHighlight];
+      _pressedPolygonView = nil;
+    }
+  }
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:
+        (UIGestureRecognizer *)otherGestureRecognizer {
+  return YES;
+}
+
+- (void)applyPolygonHighlight {
+  MKPolygonRenderer *renderer =
+      (MKPolygonRenderer *)_pressedPolygonView.renderer;
+  if (!renderer)
+    return;
+
+  UIColor *fill = _pressedPolygonView.fillColor;
+  UIColor *stroke = _pressedPolygonView.strokeColor;
+  CGFloat fillAlpha = 0, strokeAlpha = 0;
+  [fill getRed:NULL green:NULL blue:NULL alpha:&fillAlpha];
+  [stroke getRed:NULL green:NULL blue:NULL alpha:&strokeAlpha];
+  renderer.fillColor = [fill colorWithAlphaComponent:fillAlpha * 0.5];
+  renderer.strokeColor = [stroke colorWithAlphaComponent:strokeAlpha * 0.5];
+  [renderer setNeedsDisplay];
+}
+
+- (void)restorePolygonHighlight {
+  MKPolygonRenderer *renderer =
+      (MKPolygonRenderer *)_pressedPolygonView.renderer;
+  if (!renderer)
+    return;
+
+  renderer.fillColor = _pressedPolygonView.fillColor;
+  renderer.strokeColor = _pressedPolygonView.strokeColor;
+  [renderer setNeedsDisplay];
+}
+
 #pragma mark - MKMapViewDelegate
 
 - (BOOL)isUserInteracting {
@@ -336,6 +451,22 @@ - (MKOverlayRenderer *)mapView:(MKMapView *)mapView
         [[MKPolylineRenderer alloc] initWithPolyline:polyline];
     return renderer;
   }
+
+  if ([overlay isKindOfClass:[MKPolygon class]]) {
+    LuggPolygonView *polygonView = [_overlayToPolygonMap objectForKey:overlay];
+    MKPolygon *polygon = (MKPolygon *)overlay;
+
+    MKPolygonRenderer *renderer =
+        [[MKPolygonRenderer alloc] initWithPolygon:polygon];
+    if (polygonView) {
+      renderer.fillColor = polygonView.fillColor;
+      renderer.strokeColor = polygonView.strokeColor;
+      renderer.lineWidth = polygonView.strokeWidth;
+      polygonView.renderer = renderer;
+    }
+    return renderer;
+  }
+
   return nil;
 }
 
@@ -375,6 +506,12 @@ - (void)polylineViewDidUpdate:(LuggPolylineView *)polylineView {
   [self syncPolylineView:polylineView];
 }
 
+#pragma mark - PolygonViewDelegate
+
+- (void)polygonViewDidUpdate:(LuggPolygonView *)polygonView {
+  [self syncPolygonView:polygonView];
+}
+
 #pragma mark - Marker Management
 
 - (void)addMarkerView:(LuggMarkerView *)markerView {
@@ -547,6 +684,91 @@ - (void)addPolylineOverlayToMap:(LuggPolylineView *)polylineView {
   [self insertOverlay:polyline withZIndex:polylineView.zIndex];
 }
 
+#pragma mark - Polygon Management
+
+- (void)addPolygonView:(LuggPolygonView *)polygonView {
+  polygonView.delegate = self;
+  [self addPolygonOverlayToMap:polygonView];
+}
+
+- (void)removePolygonView:(LuggPolygonView *)polygonView {
+  polygonView.delegate = nil;
+  MKPolygon *polygon = (MKPolygon *)polygonView.polygon;
+  if (polygon) {
+    [_overlayToPolygonMap removeObjectForKey:polygon];
+    [_mapView removeOverlay:polygon];
+    polygonView.polygon = nil;
+  }
+}
+
+- (void)syncPolygonView:(LuggPolygonView *)polygonView {
+  if (!_mapView)
+    return;
+
+  MKPolygon *oldPolygon = (MKPolygon *)polygonView.polygon;
+
+  NSArray<CLLocation *> *coordinates = polygonView.coordinates;
+  if (coordinates.count == 0) {
+    if (oldPolygon) {
+      [_overlayToPolygonMap removeObjectForKey:oldPolygon];
+      [_mapView removeOverlay:oldPolygon];
+      polygonView.polygon = nil;
+      polygonView.renderer = nil;
+    }
+    return;
+  }
+
+  CLLocationCoordinate2D *coords = (CLLocationCoordinate2D *)malloc(
+      sizeof(CLLocationCoordinate2D) * coordinates.count);
+  for (NSUInteger i = 0; i < coordinates.count; i++) {
+    coords[i] = coordinates[i].coordinate;
+  }
+  MKPolygon *newPolygon = [MKPolygon polygonWithCoordinates:coords
+                                                      count:coordinates.count];
+  free(coords);
+
+  polygonView.polygon = newPolygon;
+  [_overlayToPolygonMap setObject:polygonView forKey:newPolygon];
+
+  MKPolygonRenderer *renderer = (MKPolygonRenderer *)polygonView.renderer;
+  if (renderer && oldPolygon) {
+    [_overlayToPolygonMap removeObjectForKey:oldPolygon];
+    [_mapView removeOverlay:oldPolygon];
+    [self insertOverlay:newPolygon withZIndex:polygonView.zIndex];
+    polygonView.renderer = nil;
+    return;
+  }
+
+  if (oldPolygon) {
+    [_overlayToPolygonMap removeObjectForKey:oldPolygon];
+    [_mapView removeOverlay:oldPolygon];
+  }
+  [self insertOverlay:newPolygon withZIndex:polygonView.zIndex];
+}
+
+- (void)addPolygonOverlayToMap:(LuggPolygonView *)polygonView {
+  if (!_mapView)
+    return;
+
+  NSArray<CLLocation *> *coordinates = polygonView.coordinates;
+  if (coordinates.count == 0)
+    return;
+
+  CLLocationCoordinate2D *coords = (CLLocationCoordinate2D *)malloc(
+      sizeof(CLLocationCoordinate2D) * coordinates.count);
+  for (NSUInteger i = 0; i < coordinates.count; i++) {
+    coords[i] = coordinates[i].coordinate;
+  }
+
+  MKPolygon *polygon = [MKPolygon polygonWithCoordinates:coords
+                                                   count:coordinates.count];
+  free(coords);
+
+  polygonView.polygon = polygon;
+  [_overlayToPolygonMap setObject:polygonView forKey:polygon];
+  [self insertOverlay:polygon withZIndex:polygonView.zIndex];
+}
+
 - (void)insertOverlay:(id<MKOverlay>)overlay withZIndex:(NSInteger)zIndex {
   if (zIndex == 0) {
     [_mapView addOverlay:overlay];
@@ -557,9 +779,19 @@ - (void)insertOverlay:(id<MKOverlay>)overlay withZIndex:(NSInteger)zIndex {
   NSInteger insertIndex = overlays.count;
 
   for (NSInteger i = 0; i < overlays.count; i++) {
+    NSInteger existingZIndex = 0;
     LuggPolylineView *existingPolylineView =
         [_overlayToPolylineMap objectForKey:overlays[i]];
-    if (existingPolylineView && existingPolylineView.zIndex > zIndex) {
+    LuggPolygonView *existingPolygonView =
+        [_overlayToPolygonMap objectForKey:overlays[i]];
+    if (existingPolylineView) {
+      existingZIndex = existingPolylineView.zIndex;
+    } else if (existingPolygonView) {
+      existingZIndex = existingPolygonView.zIndex;
+    } else {
+      continue;
+    }
+    if (existingZIndex > zIndex) {
       insertIndex = i;
       break;
     }
diff --git a/ios/core/GoogleMapProvider.mm b/ios/core/GoogleMapProvider.mm
index a0e19fe..0427bf7 100644
--- a/ios/core/GoogleMapProvider.mm
+++ b/ios/core/GoogleMapProvider.mm
@@ -1,13 +1,15 @@
 #import "GoogleMapProvider.h"
 #import "../LuggMarkerView.h"
+#import "../LuggPolygonView.h"
 #import "../LuggPolylineView.h"
 #import "GMSPolylineAnimator.h"
 #import "PolylineAnimatorBase.h"
 
 static NSString *const kDemoMapId = @"DEMO_MAP_ID";
 
-@interface GoogleMapProvider () <LuggMarkerViewDelegate,
-                                 LuggPolylineViewDelegate>
+@interface GoogleMapProvider () <
+    LuggMarkerViewDelegate, LuggPolylineViewDelegate, LuggPolygonViewDelegate,
+    UIGestureRecognizerDelegate>
 @end
 
 @implementation GoogleMapProvider {
@@ -18,7 +20,12 @@ @implementation GoogleMapProvider {
   UIEdgeInsets _edgeInsets;
   NSMutableArray<LuggMarkerView *> *_pendingMarkerViews;
   NSMutableArray<LuggPolylineView *> *_pendingPolylineViews;
+  NSMutableArray<LuggPolygonView *> *_pendingPolygonViews;
   NSMapTable<LuggPolylineView *, GMSPolylineAnimator *> *_polylineAnimators;
+  NSMapTable<GMSPolygon *, LuggPolygonView *> *_polygonToViewMap;
+  UILongPressGestureRecognizer *_polygonPressGesture;
+  LuggPolygonView *_pressedPolygonView;
+  GMSPolygon *_pressedPolygon;
 
   // Edge insets animation
   CADisplayLink *_edgeInsetsDisplayLink;
@@ -36,7 +43,9 @@ - (instancetype)init {
     _mapId = kDemoMapId;
     _pendingMarkerViews = [NSMutableArray array];
     _pendingPolylineViews = [NSMutableArray array];
+    _pendingPolygonViews = [NSMutableArray array];
     _polylineAnimators = [NSMapTable weakToStrongObjectsMapTable];
+    _polygonToViewMap = [NSMapTable strongToWeakObjectsMapTable];
   }
   return self;
 }
@@ -81,6 +90,14 @@ - (void)initializeMapInView:(UIView *)wrapperView
   _mapView.paddingAdjustmentBehavior =
       kGMSMapViewPaddingAdjustmentBehaviorNever;
 
+  _polygonPressGesture = [[UILongPressGestureRecognizer alloc]
+      initWithTarget:self
+              action:@selector(handlePolygonPress:)];
+  _polygonPressGesture.minimumPressDuration = 0;
+  _polygonPressGesture.cancelsTouchesInView = NO;
+  _polygonPressGesture.delegate = self;
+  [_mapView addGestureRecognizer:_polygonPressGesture];
+
   [wrapperView addSubview:_mapView];
 
   [self applyTheme];
@@ -88,6 +105,7 @@ - (void)initializeMapInView:(UIView *)wrapperView
   _isMapReady = YES;
   [self processPendingMarkers];
   [self processPendingPolylines];
+  [self processPendingPolygons];
 
   [_delegate mapProviderDidReady];
 }
@@ -96,7 +114,15 @@ - (void)destroy {
   [self stopEdgeInsetsAnimation];
   [_pendingMarkerViews removeAllObjects];
   [_pendingPolylineViews removeAllObjects];
+  [_pendingPolygonViews removeAllObjects];
   [_polylineAnimators removeAllObjects];
+  [_polygonToViewMap removeAllObjects];
+  if (_polygonPressGesture) {
+    [_mapView removeGestureRecognizer:_polygonPressGesture];
+    _polygonPressGesture = nil;
+  }
+  _pressedPolygonView = nil;
+  _pressedPolygon = nil;
   [_mapView clear];
   [_mapView removeFromSuperview];
   _mapView = nil;
@@ -254,6 +280,84 @@ - (void)mapView:(GMSMapView *)mapView
                               gesture:wasDragging];
 }
 
+- (void)handlePolygonPress:(UILongPressGestureRecognizer *)gesture {
+  if (gesture.state == UIGestureRecognizerStateBegan) {
+    CGPoint point = [gesture locationInView:_mapView];
+    CLLocationCoordinate2D coord =
+        [_mapView.projection coordinateForPoint:point];
+
+    for (GMSPolygon *polygon in _polygonToViewMap) {
+      LuggPolygonView *polygonView = [_polygonToViewMap objectForKey:polygon];
+      if (!polygonView || !polygonView.tappable)
+        continue;
+
+      if ([self coordinate:coord isInsidePolygon:polygonView.coordinates]) {
+        _pressedPolygon = polygon;
+        _pressedPolygonView = polygonView;
+        [self applyPolygonHighlight];
+        return;
+      }
+    }
+  } else if (gesture.state == UIGestureRecognizerStateEnded) {
+    if (_pressedPolygonView) {
+      [self restorePolygonHighlight];
+      [_pressedPolygonView emitPressEvent];
+      _pressedPolygonView = nil;
+      _pressedPolygon = nil;
+    }
+  } else if (gesture.state == UIGestureRecognizerStateCancelled ||
+             gesture.state == UIGestureRecognizerStateFailed) {
+    if (_pressedPolygonView) {
+      [self restorePolygonHighlight];
+      _pressedPolygonView = nil;
+      _pressedPolygon = nil;
+    }
+  }
+}
+
+- (BOOL)gestureRecognizer:(UIGestureRecognizer *)gestureRecognizer
+    shouldRecognizeSimultaneouslyWithGestureRecognizer:
+        (UIGestureRecognizer *)otherGestureRecognizer {
+  return YES;
+}
+
+- (BOOL)coordinate:(CLLocationCoordinate2D)coord
+    isInsidePolygon:(NSArray<CLLocation *> *)coordinates {
+  if (coordinates.count == 0)
+    return NO;
+
+  NSUInteger count = coordinates.count;
+  BOOL inside = NO;
+  for (NSUInteger i = 0, j = count - 1; i < count; j = i++) {
+    CLLocationCoordinate2D pi = coordinates[i].coordinate;
+    CLLocationCoordinate2D pj = coordinates[j].coordinate;
+    if (((pi.latitude > coord.latitude) != (pj.latitude > coord.latitude)) &&
+        (coord.longitude < (pj.longitude - pi.longitude) *
+                                   (coord.latitude - pi.latitude) /
+                                   (pj.latitude - pi.latitude) +
+                               pi.longitude)) {
+      inside = !inside;
+    }
+  }
+  return inside;
+}
+
+- (void)applyPolygonHighlight {
+  UIColor *fill = _pressedPolygonView.fillColor;
+  UIColor *stroke = _pressedPolygonView.strokeColor;
+  CGFloat fillAlpha = 0, strokeAlpha = 0;
+  [fill getRed:NULL green:NULL blue:NULL alpha:&fillAlpha];
+  [stroke getRed:NULL green:NULL blue:NULL alpha:&strokeAlpha];
+  _pressedPolygon.fillColor = [fill colorWithAlphaComponent:fillAlpha * 0.5];
+  _pressedPolygon.strokeColor =
+      [stroke colorWithAlphaComponent:strokeAlpha * 0.5];
+}
+
+- (void)restorePolygonHighlight {
+  _pressedPolygon.fillColor = _pressedPolygonView.fillColor;
+  _pressedPolygon.strokeColor = _pressedPolygonView.strokeColor;
+}
+
 #pragma mark - MarkerViewDelegate
 
 - (void)markerViewDidLayout:(LuggMarkerView *)markerView {
@@ -270,6 +374,12 @@ - (void)polylineViewDidUpdate:(LuggPolylineView *)polylineView {
   [self syncPolylineView:polylineView];
 }
 
+#pragma mark - PolygonViewDelegate
+
+- (void)polygonViewDidUpdate:(LuggPolygonView *)polygonView {
+  [self syncPolygonView:polygonView];
+}
+
 #pragma mark - Marker Management
 
 - (void)addMarkerView:(LuggMarkerView *)markerView {
@@ -438,6 +548,79 @@ - (void)addPolylineViewToMap:(LuggPolylineView *)polylineView {
   [_polylineAnimators setObject:animator forKey:polylineView];
 }
 
+#pragma mark - Polygon Management
+
+- (void)addPolygonView:(LuggPolygonView *)polygonView {
+  polygonView.delegate = self;
+  [self syncPolygonView:polygonView];
+}
+
+- (void)removePolygonView:(LuggPolygonView *)polygonView {
+  GMSPolygon *polygon = (GMSPolygon *)polygonView.polygon;
+  if (polygon) {
+    [_polygonToViewMap removeObjectForKey:polygon];
+    polygon.map = nil;
+    polygonView.polygon = nil;
+  }
+}
+
+- (void)syncPolygonView:(LuggPolygonView *)polygonView {
+  if (!_mapView) {
+    if (![_pendingPolygonViews containsObject:polygonView]) {
+      [_pendingPolygonViews addObject:polygonView];
+    }
+    return;
+  }
+
+  if (!polygonView.polygon) {
+    [self addPolygonViewToMap:polygonView];
+    return;
+  }
+
+  GMSPolygon *polygon = (GMSPolygon *)polygonView.polygon;
+
+  GMSMutablePath *path = [GMSMutablePath path];
+  for (CLLocation *location in polygonView.coordinates) {
+    [path addCoordinate:location.coordinate];
+  }
+  polygon.path = path;
+  polygon.fillColor = polygonView.fillColor;
+  polygon.strokeColor = polygonView.strokeColor;
+  polygon.strokeWidth = polygonView.strokeWidth;
+  polygon.zIndex = (int)polygonView.zIndex;
+  polygon.tappable = NO;
+}
+
+- (void)processPendingPolygons {
+  if (!_mapView)
+    return;
+
+  for (LuggPolygonView *polygonView in _pendingPolygonViews) {
+    [self addPolygonViewToMap:polygonView];
+  }
+  [_pendingPolygonViews removeAllObjects];
+}
+
+- (void)addPolygonViewToMap:(LuggPolygonView *)polygonView {
+  if (!_mapView)
+    return;
+
+  GMSMutablePath *path = [GMSMutablePath path];
+  for (CLLocation *location in polygonView.coordinates) {
+    [path addCoordinate:location.coordinate];
+  }
+
+  GMSPolygon *polygon = [GMSPolygon polygonWithPath:path];
+  polygon.fillColor = polygonView.fillColor;
+  polygon.strokeColor = polygonView.strokeColor;
+  polygon.strokeWidth = polygonView.strokeWidth;
+  polygon.zIndex = (int)polygonView.zIndex;
+  polygon.tappable = NO;
+  polygon.map = _mapView;
+  polygonView.polygon = polygon;
+  [_polygonToViewMap setObject:polygonView forKey:polygon];
+}
+
 #pragma mark - Lifecycle
 
 - (void)pauseAnimations {
diff --git a/ios/core/MapProviderDelegate.h b/ios/core/MapProviderDelegate.h
index 9e571e0..3897f90 100644
--- a/ios/core/MapProviderDelegate.h
+++ b/ios/core/MapProviderDelegate.h
@@ -5,6 +5,7 @@ NS_ASSUME_NONNULL_BEGIN
 
 @class LuggMarkerView;
 @class LuggPolylineView;
+@class LuggPolygonView;
 
 @protocol MapProviderDelegate <NSObject>
 - (void)mapProviderDidReady;
@@ -50,6 +51,9 @@ NS_ASSUME_NONNULL_BEGIN
 - (void)addPolylineView:(LuggPolylineView *)polylineView;
 - (void)removePolylineView:(LuggPolylineView *)polylineView;
 - (void)syncPolylineView:(LuggPolylineView *)polylineView;
+- (void)addPolygonView:(LuggPolygonView *)polygonView;
+- (void)removePolygonView:(LuggPolygonView *)polygonView;
+- (void)syncPolygonView:(LuggPolygonView *)polygonView;
 
 // Lifecycle
 - (void)pauseAnimations;
diff --git a/ios/events/PolygonPressEvent.h b/ios/events/PolygonPressEvent.h
new file mode 100644
index 0000000..9afacc4
--- /dev/null
+++ b/ios/events/PolygonPressEvent.h
@@ -0,0 +1,20 @@
+#pragma once
+
+#import <react/renderer/components/RNMapsSpec/EventEmitters.h>
+
+namespace luggmaps {
+namespace events {
+
+struct PolygonPressEvent {
+  template <typename Emitter>
+  static void emit(const facebook::react::SharedEventEmitter &eventEmitter) {
+    if (!eventEmitter)
+      return;
+    auto emitter = std::static_pointer_cast<Emitter const>(eventEmitter);
+    typename Emitter::OnPress event;
+    emitter->onPress(event);
+  }
+};
+
+} // namespace events
+} // namespace luggmaps
diff --git a/package.json b/package.json
index 361fc13..105887d 100644
--- a/package.json
+++ b/package.json
@@ -148,7 +148,8 @@
         "LuggMapView": "LuggMapView",
         "LuggMarkerView": "LuggMarkerView",
         "LuggMapWrapperView": "LuggMapWrapperView",
-        "LuggPolylineView": "LuggPolylineView"
+        "LuggPolylineView": "LuggPolylineView",
+        "LuggPolygonView": "LuggPolygonView"
       }
     }
   },
diff --git a/src/components/Polygon.tsx b/src/components/Polygon.tsx
new file mode 100644
index 0000000..16bc2e0
--- /dev/null
+++ b/src/components/Polygon.tsx
@@ -0,0 +1,76 @@
+import React from 'react';
+import type { ColorValue } from 'react-native';
+import { StyleSheet } from 'react-native';
+import LuggPolygonViewNativeComponent from '../fabric/LuggPolygonViewNativeComponent';
+import type { Coordinate } from '../types';
+
+export interface PolygonProps {
+  /**
+   * Array of coordinates forming the polygon boundary
+   */
+  coordinates: Coordinate[];
+  /**
+   * Stroke (outline) color
+   */
+  strokeColor?: ColorValue;
+  /**
+   * Stroke width in points
+   */
+  strokeWidth?: number;
+  /**
+   * Fill color of the polygon
+   */
+  fillColor?: ColorValue;
+  /**
+   * Z-index for layering
+   */
+  zIndex?: number;
+  /**
+   * Called when the polygon is tapped
+   */
+  onPress?: () => void;
+}
+
+export class Polygon extends React.PureComponent<PolygonProps> {
+  private _cachedZIndex: number | undefined;
+  private _cachedStyle: any;
+
+  private getStyle(zIndex: number | undefined) {
+    if (zIndex == null) return styles.polygon;
+    if (zIndex !== this._cachedZIndex) {
+      this._cachedZIndex = zIndex;
+      this._cachedStyle = [{ zIndex }, styles.polygon];
+    }
+    return this._cachedStyle!;
+  }
+
+  render() {
+    const {
+      coordinates,
+      strokeColor,
+      strokeWidth,
+      fillColor,
+      zIndex,
+      onPress,
+    } = this.props;
+
+    return (
+      <LuggPolygonViewNativeComponent
+        style={this.getStyle(zIndex)}
+        coordinates={coordinates}
+        strokeColor={strokeColor}
+        strokeWidth={strokeWidth}
+        fillColor={fillColor}
+        tappable={!!onPress}
+        onPress={onPress}
+      />
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  polygon: {
+    position: 'absolute',
+    pointerEvents: 'none',
+  },
+});
diff --git a/src/components/Polygon.web.tsx b/src/components/Polygon.web.tsx
new file mode 100644
index 0000000..cec1ebd
--- /dev/null
+++ b/src/components/Polygon.web.tsx
@@ -0,0 +1,125 @@
+import { useCallback, useEffect, useRef } from 'react';
+import { useMapContext } from '../MapProvider.web';
+import type { PolygonProps } from './Polygon';
+
+export function Polygon({
+  coordinates,
+  strokeColor = '#000000',
+  strokeWidth = 1,
+  fillColor = 'rgba(0, 0, 0, 0.3)',
+  zIndex = 0,
+  onPress,
+}: PolygonProps) {
+  const { map } = useMapContext();
+  const polygonRef = useRef<google.maps.Polygon | null>(null);
+  const listenersRef = useRef<google.maps.MapsEventListener[]>([]);
+
+  const handleClick = useCallback(() => {
+    onPress?.();
+  }, [onPress]);
+
+  const applyHighlight = useCallback(() => {
+    const polygon = polygonRef.current;
+    if (!polygon) return;
+    polygon.setOptions({
+      fillOpacity: 0.5,
+      strokeOpacity: 0.5,
+    });
+  }, []);
+
+  const restoreHighlight = useCallback(() => {
+    const polygon = polygonRef.current;
+    if (!polygon) return;
+    polygon.setOptions({
+      fillOpacity: 1,
+      strokeOpacity: 1,
+    });
+  }, []);
+
+  // Cleanup on unmount
+  useEffect(() => {
+    return () => {
+      listenersRef.current.forEach((l) => l.remove());
+      listenersRef.current = [];
+      polygonRef.current?.setMap(null);
+      polygonRef.current = null;
+    };
+  }, []);
+
+  // Sync listeners
+  useEffect(() => {
+    const polygon = polygonRef.current;
+    if (!polygon) return;
+
+    listenersRef.current.forEach((l) => l.remove());
+    listenersRef.current = [];
+
+    if (onPress) {
+      listenersRef.current.push(
+        polygon.addListener('click', handleClick),
+        polygon.addListener('mousedown', applyHighlight),
+        polygon.addListener('mouseup', restoreHighlight),
+        polygon.addListener('mouseout', restoreHighlight)
+      );
+    }
+    polygon.set('clickable', !!onPress);
+  }, [onPress, handleClick, applyHighlight, restoreHighlight]);
+
+  // Sync polygon with props
+  useEffect(() => {
+    if (!map || coordinates.length === 0) {
+      polygonRef.current?.setMap(null);
+      return;
+    }
+
+    const path = coordinates.map((c) => ({
+      lat: c.latitude,
+      lng: c.longitude,
+    }));
+
+    if (polygonRef.current) {
+      polygonRef.current.setPath(path);
+      polygonRef.current.setOptions({
+        strokeColor: strokeColor as string,
+        strokeWeight: strokeWidth,
+        fillColor: fillColor as string,
+        zIndex,
+      });
+    } else {
+      const polygon = new google.maps.Polygon({
+        paths: path,
+        strokeColor: strokeColor as string,
+        strokeWeight: strokeWidth,
+        strokeOpacity: 1,
+        fillColor: fillColor as string,
+        fillOpacity: 1,
+        zIndex,
+        clickable: !!onPress,
+        map,
+      });
+      polygonRef.current = polygon;
+
+      if (onPress) {
+        listenersRef.current.push(
+          polygon.addListener('click', handleClick),
+          polygon.addListener('mousedown', applyHighlight),
+          polygon.addListener('mouseup', restoreHighlight),
+          polygon.addListener('mouseout', restoreHighlight)
+        );
+      }
+    }
+  }, [
+    map,
+    coordinates,
+    strokeColor,
+    strokeWidth,
+    fillColor,
+    zIndex,
+    onPress,
+    handleClick,
+    applyHighlight,
+    restoreHighlight,
+  ]);
+
+  return null;
+}
diff --git a/src/components/index.ts b/src/components/index.ts
index 9b8eae3..1ab2158 100644
--- a/src/components/index.ts
+++ b/src/components/index.ts
@@ -1,5 +1,7 @@
 export { Marker } from './Marker';
 export type { MarkerProps } from './Marker';
+export { Polygon } from './Polygon';
+export type { PolygonProps } from './Polygon';
 export { Polyline } from './Polyline';
 export type {
   PolylineProps,
diff --git a/src/components/index.web.ts b/src/components/index.web.ts
index f3f7b0e..8583c34 100644
--- a/src/components/index.web.ts
+++ b/src/components/index.web.ts
@@ -1,4 +1,6 @@
 export { Marker } from './Marker.web';
+export { Polygon } from './Polygon.web';
 export { Polyline } from './Polyline.web';
 export type { MarkerProps } from './Marker';
+export type { PolygonProps } from './Polygon';
 export type { PolylineProps } from './Polyline';
diff --git a/src/fabric/LuggPolygonViewNativeComponent.ts b/src/fabric/LuggPolygonViewNativeComponent.ts
new file mode 100644
index 0000000..da93484
--- /dev/null
+++ b/src/fabric/LuggPolygonViewNativeComponent.ts
@@ -0,0 +1,24 @@
+import { codegenNativeComponent } from 'react-native';
+import type { ViewProps, HostComponent, ColorValue } from 'react-native';
+import type {
+  Double,
+  BubblingEventHandler,
+} from 'react-native/Libraries/Types/CodegenTypes';
+
+export interface Coordinate {
+  latitude: Double;
+  longitude: Double;
+}
+
+export interface NativeProps extends ViewProps {
+  coordinates: ReadonlyArray<Coordinate>;
+  strokeColor?: ColorValue;
+  strokeWidth?: Double;
+  fillColor?: ColorValue;
+  tappable?: boolean;
+  onPress?: BubblingEventHandler<null>;
+}
+
+export default codegenNativeComponent<NativeProps>(
+  'LuggPolygonView'
+) as HostComponent<NativeProps>;
diff --git a/src/index.ts b/src/index.ts
index d2ea408..f05b7d6 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -3,6 +3,8 @@ export { MapProvider } from './MapProvider';
 export type { MapProviderProps } from './MapProvider.types';
 export { Marker } from './components';
 export type { MarkerProps } from './components';
+export { Polygon } from './components';
+export type { PolygonProps } from './components';
 export { Polyline } from './components';
 export type {
   PolylineProps,
diff --git a/src/index.web.ts b/src/index.web.ts
index cbbba6c..d6e87bb 100644
--- a/src/index.web.ts
+++ b/src/index.web.ts
@@ -3,6 +3,8 @@ export { MapProvider } from './MapProvider.web';
 export type { MapProviderProps } from './MapProvider.types';
 export { Marker } from './components/index.web';
 export type { MarkerProps } from './components/index.web';
+export { Polygon } from './components/index.web';
+export type { PolygonProps } from './components/index.web';
 export { Polyline } from './components/index.web';
 export type { PolylineProps } from './components/index.web';
 export type {