@sigx/lynx-maps 0.4.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025-2026 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,134 @@
+# @sigx/lynx-maps
+
+Native map view for sigx-lynx. Backed by:
+
+- **iOS** — `MKMapView` (Apple Maps, no key required).
+- **Android** — `com.google.android.gms.maps.MapView` (Google Maps,
+  requires an API key — see [setup](#android-api-key-setup) below).
+
+Closes [signalxjs/lynx#84](https://github.com/signalxjs/lynx/issues/84).
+
+## Install
+
+```bash
+pnpm add @sigx/lynx-maps
+pnpm sigx prebuild
+```
+
+The autolinker picks up `signalx-module.json` from this package; prebuild
+regenerates `GeneratedBehaviors.kt` (Android) and
+`GeneratedComponentRegistry.swift` (iOS) so the `<sigx-map>` and
+`<sigx-map-marker>` tags are bound to their native UI classes.
+
+## Quick start
+
+```tsx
+import { Map, MapMarker } from '@sigx/lynx-maps';
+
+const region = {
+    latitude: 59.3293,
+    longitude: 18.0686,
+    latitudeDelta: 0.1,
+    longitudeDelta: 0.1,
+};
+
+export function MapScreen() {
+    return (
+        <Map
+            region={region}
+            showsUserLocation
+            mapType="standard"
+            class="flex-1"
+            onRegionChange={(e) => console.log('region', e.detail.region)}
+            onMarkerPress={(e) => console.log('marker', e.detail.id)}
+        >
+            <MapMarker
+                coordinate={{ latitude: 59.3293, longitude: 18.0686 }}
+                title="Stockholm"
+                description="Sweden's capital"
+                id="sthlm"
+            />
+        </Map>
+    );
+}
+```
+
+## Props — `<Map>`
+
+| Prop | Type | Notes |
+| --- | --- | --- |
+| `region` | `MapRegion` | `{ latitude, longitude, latitudeDelta, longitudeDelta }`. The map snaps to this on every prop change — for "initial region only" semantics, pass it once and keep it in local state. |
+| `showsUserLocation` | `boolean` | Shows the blue location dot. iOS uses `NSLocationWhenInUseUsageDescription` (added automatically); Android requires `ACCESS_FINE_LOCATION` at runtime (declared in the manifest). |
+| `mapType` | `'standard' \| 'satellite' \| 'hybrid'` | Base style. Default `'standard'`. |
+| `onRegionChange` | `(e) => void` | Fires after the user pans/zooms or after a programmatic `region` change. Detail: `{ region }`. |
+| `onPress` | `(e) => void` | User tapped the map (not on a marker). Detail: `{ coordinate }`. |
+| `onMarkerPress` | `(e) => void` | User tapped a marker. Detail: `{ id, coordinate }`. |
+| `class`, `style`, `children` | — | Standard Lynx props. Children should be `<MapMarker>` elements. |
+
+## Props — `<MapMarker>`
+
+| Prop | Type | Notes |
+| --- | --- | --- |
+| `coordinate` | `{ latitude, longitude }` | Required. |
+| `title` | `string` | Callout title shown on tap. |
+| `description` | `string` | Callout subtitle. |
+| `id` | `string` | Forwarded as `event.detail.id` on the parent's `onMarkerPress`. |
+
+## Android API key setup
+
+Google Maps requires an API key. Get one at
+[console.cloud.google.com](https://console.cloud.google.com/) → APIs &
+Services → Credentials → "Maps SDK for Android".
+
+Once you have a key, add the standard meta-data block inside
+`<application>` in `android/app/src/main/AndroidManifest.xml`:
+
+```xml
+<meta-data
+    android:name="com.google.android.geo.API_KEY"
+    android:value="@string/google_maps_api_key" />
+```
+
+…and define the string in `android/app/src/main/res/values/strings.xml`:
+
+```xml
+<resources>
+    <!-- existing entries -->
+    <string name="google_maps_api_key" translatable="false">YOUR_KEY_HERE</string>
+</resources>
+```
+
+If you don't add the meta-data block, the map still renders — but with
+Google's "For development purposes only" watermark. That's fine for early
+testing; ship a real key before publishing to the Play Store.
+
+On `sigx-lynx-go` (the prebuilt sandbox app) the placeholder watermark is
+expected — we can't bundle a per-user API key in a public binary.
+
+## Limitations (v1)
+
+Tracked as v2 follow-ups:
+
+- **Imperative methods** (`animateToRegion`, `fitToCoordinates`) need
+  Lynx's `UIMethodInvoker` surface, which isn't wired through sigx-lynx
+  yet. Same blocker as `WebView.goBack` / `reload`.
+- **Custom marker icons** — markers use the platform default pin.
+- **Polylines, polygons, circles, ground overlays.**
+- **Clustering.**
+- **Offline tiles / Map snapshots.**
+- **Google Maps on iOS** — iOS stays on MapKit (key-free); a future
+  follow-up could let apps opt into the Google Maps SDK for iOS.
+
+## Lifecycle notes (Android)
+
+`com.google.android.gms.maps.MapView` normally wants Activity lifecycle
+forwarding (`onCreate`/`onResume`/`onPause`/`onDestroy`). v1 calls
+`onCreate` + `onStart` + `onResume` in `createView`, and `onPause` +
+`onStop` in `onDetach`. For a typical screen-level map this works; if the
+host Activity is paused with the map still mounted, tile prefetching
+keeps running until the LynxUI itself detaches. A proper `activityHook`
+plumbing is tracked as a follow-up.
+
+## License
+
+MIT

package/android/com/sigx/maps/SigxMapBehavior.kt

@@ -0,0 +1,19 @@
+package com.sigx.maps
+
+import com.lynx.tasm.behavior.Behavior
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.ui.LynxUI
+
+/**
+ * Registers the `<sigx-map>` JSX tag with Lynx's UI registry.
+ *
+ * Discovered by the autolinker via `signalx-module.json`'s `android.behaviors`
+ * field; the generated `GeneratedBehaviors.attachAll(builder)` calls
+ * `builder.addBehavior(SigxMapBehavior())` for every `LynxViewBuilder`
+ * in the app (production + dev-client path).
+ */
+class SigxMapBehavior : Behavior("sigx-map") {
+    override fun createUI(context: LynxContext): LynxUI<*> {
+        return SigxMapUI(context)
+    }
+}

package/android/com/sigx/maps/SigxMapMarkerBehavior.kt

@@ -0,0 +1,18 @@
+package com.sigx.maps
+
+import com.lynx.tasm.behavior.Behavior
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.ui.LynxUI
+
+/**
+ * Registers the `<sigx-map-marker>` JSX tag with Lynx's UI registry. The
+ * actual marker is added to the parent `SigxMapUI`'s GoogleMap on attach;
+ * the LynxUI's own view is a zero-size hidden placeholder that never gets
+ * laid out, because the parent map intercepts `insertChild` and skips the
+ * default add-to-view-hierarchy path.
+ */
+class SigxMapMarkerBehavior : Behavior("sigx-map-marker") {
+    override fun createUI(context: LynxContext): LynxUI<*> {
+        return SigxMapMarkerUI(context)
+    }
+}

package/android/com/sigx/maps/SigxMapMarkerUI.kt

@@ -0,0 +1,65 @@
+package com.sigx.maps
+
+import android.content.Context
+import android.view.View
+import com.google.android.gms.maps.model.Marker
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.LynxProp
+import com.lynx.tasm.behavior.ui.LynxUI
+import org.json.JSONObject
+
+/**
+ * Native UI for the `<sigx-map-marker>` JSX element on Android.
+ *
+ * A marker doesn't render its own real view — Google Maps tracks pins
+ * separately via [com.google.android.gms.maps.GoogleMap.addMarker]. We
+ * still need a `LynxUI<View>` because Lynx's UI tree expects every child
+ * to be a UI. The native view is a zero-size hidden `View` that never
+ * gets laid out because the parent `SigxMapUI` intercepts `insertChild`
+ * for markers and skips the default add-to-view-hierarchy path.
+ */
+class SigxMapMarkerUI(context: LynxContext) : LynxUI<View>(context) {
+
+    internal var owningMap: SigxMapUI? = null
+    internal var attachedMarker: Marker? = null
+
+    internal var coordinateLat: Double = 0.0
+    internal var coordinateLng: Double = 0.0
+    internal var markerTitle: String? = null
+    internal var markerDescription: String? = null
+    internal var markerId: String = ""
+
+    override fun createView(context: Context): View {
+        val v = View(context)
+        v.visibility = View.GONE
+        return v
+    }
+
+    // ── Prop setters ─────────────────────────────────────────────────────
+
+    @LynxProp(name = "coordinate")
+    fun setCoordinate(value: String?) {
+        if (value.isNullOrEmpty()) return
+        val obj = runCatching { JSONObject(value) }.getOrNull() ?: return
+        coordinateLat = obj.optDouble("latitude", coordinateLat)
+        coordinateLng = obj.optDouble("longitude", coordinateLng)
+        owningMap?.markerDidUpdate(this)
+    }
+
+    @LynxProp(name = "title")
+    fun setTitle(value: String?) {
+        markerTitle = value
+        owningMap?.markerDidUpdate(this)
+    }
+
+    @LynxProp(name = "description")
+    fun setDescription(value: String?) {
+        markerDescription = value
+        owningMap?.markerDidUpdate(this)
+    }
+
+    @LynxProp(name = "marker-id")
+    fun setMarkerId(value: String?) {
+        markerId = value ?: ""
+    }
+}

package/android/com/sigx/maps/SigxMapUI.kt

@@ -0,0 +1,279 @@
+package com.sigx.maps
+
+import android.content.Context
+import com.google.android.gms.maps.CameraUpdateFactory
+import com.google.android.gms.maps.GoogleMap
+import com.google.android.gms.maps.MapView
+import com.google.android.gms.maps.model.CameraPosition
+import com.google.android.gms.maps.model.LatLng
+import com.google.android.gms.maps.model.MarkerOptions
+import com.lynx.tasm.behavior.LynxContext
+import com.lynx.tasm.behavior.LynxProp
+import com.lynx.tasm.behavior.ui.LynxBaseUI
+import com.lynx.tasm.behavior.ui.LynxUI
+import com.lynx.tasm.event.LynxDetailEvent
+import org.json.JSONObject
+
+/**
+ * Native UI for the `<sigx-map>` JSX element on Android.
+ *
+ * Prop / event surface (v1):
+ *   - `region`               → JSON-stringified `MapRegion`
+ *   - `shows-user-location`  → enable user-location dot (requires permission)
+ *   - `map-type`             → `"standard" | "satellite" | "hybrid"`
+ *   - `bindregionchange`     → CameraIdleListener
+ *   - `bindpress`            → OnMapClickListener
+ *   - `bindmarkerpress`      → OnMarkerClickListener
+ *
+ * Imperative methods (animateToRegion / fitToCoordinates) are tracked as a
+ * v2 follow-up — same UIMethodInvoker blocker as WebView.
+ *
+ * @remarks
+ * Google MapView requires Activity lifecycle forwarding (onCreate /
+ * onResume / onPause / onDestroy). The v1 implementation calls onCreate +
+ * onStart + onResume in [createView] so the map is interactive
+ * immediately, and onPause + onStop + onDestroy in [onDetach]. For an
+ * app that backgrounds while a map is visible, this is best-effort —
+ * most user-visible maps work, but tile prefetching pauses on
+ * backgrounding only after the next prebuild wires a proper
+ * `activityHook`. Doc'd in README.
+ */
+class SigxMapUI(context: LynxContext) : LynxUI<MapView>(context) {
+
+    private var googleMap: GoogleMap? = null
+    private var pendingRegion: JSONObject? = null
+    private var pendingShowUserLocation: Boolean = false
+    private var pendingMapType: String? = null
+    /** Marker children waiting for GoogleMap to be ready. */
+    private val pendingMarkers = mutableListOf<SigxMapMarkerUI>()
+    /** All currently-attached markers, by their LynxUI sign. */
+    internal val attachedMarkers = mutableMapOf<Int, SigxMapMarkerUI>()
+
+    override fun createView(context: Context): MapView {
+        val map = MapView(context)
+        // Bundle=null is the Google-recommended invocation when the host
+        // doesn't save/restore MapView state per-instance.
+        map.onCreate(null)
+        map.onStart()
+        map.onResume()
+        map.getMapAsync { gmap ->
+            googleMap = gmap
+            applyPendingState()
+            wireListeners(gmap)
+            // Attach any markers that arrived before the map was ready.
+            for (m in pendingMarkers) attachMarker(m)
+            pendingMarkers.clear()
+        }
+        return map
+    }
+
+    override fun onDetach() {
+        super.onDetach()
+        // Best-effort lifecycle pairing — see class-level remarks.
+        // onDestroy() releases the GL renderer, so call it last to avoid
+        // leaking native resources when the host UI tears down.
+        runCatching { mView.onPause() }
+        runCatching { mView.onStop() }
+        runCatching { mView.onDestroy() }
+    }
+
+    // ── Child plumbing ───────────────────────────────────────────────────
+
+    override fun insertChild(child: LynxBaseUI?, index: Int) {
+        if (child is SigxMapMarkerUI) {
+            attachMarker(child)
+            return
+        }
+        super.insertChild(child, index)
+    }
+
+    override fun removeChild(child: LynxBaseUI?) {
+        if (child is SigxMapMarkerUI) {
+            detachMarker(child)
+            return
+        }
+        super.removeChild(child)
+    }
+
+    internal fun attachMarker(marker: SigxMapMarkerUI) {
+        marker.owningMap = this
+        attachedMarkers[marker.sign] = marker
+        val gmap = googleMap
+        if (gmap == null) {
+            pendingMarkers.add(marker)
+            return
+        }
+        val opts = MarkerOptions()
+            .position(LatLng(marker.coordinateLat, marker.coordinateLng))
+            .title(marker.markerTitle)
+            .snippet(marker.markerDescription)
+        val pin = gmap.addMarker(opts)
+        if (pin != null) {
+            pin.tag = marker.sign
+            marker.attachedMarker = pin
+        }
+    }
+
+    internal fun detachMarker(marker: SigxMapMarkerUI) {
+        attachedMarkers.remove(marker.sign)
+        pendingMarkers.remove(marker)
+        marker.attachedMarker?.remove()
+        marker.attachedMarker = null
+        marker.owningMap = null
+    }
+
+    /** Re-sync an already-attached marker's coords/title after a prop change. */
+    internal fun markerDidUpdate(marker: SigxMapMarkerUI) {
+        val pin = marker.attachedMarker ?: return
+        pin.position = LatLng(marker.coordinateLat, marker.coordinateLng)
+        pin.title = marker.markerTitle
+        pin.snippet = marker.markerDescription
+    }
+
+    // ── State application ────────────────────────────────────────────────
+
+    private fun applyPendingState() {
+        val gmap = googleMap ?: return
+        pendingRegion?.let { applyRegion(it) }
+        pendingRegion = null
+        // SecurityException is thrown by the setter when ACCESS_FINE_LOCATION
+        // isn't granted, so the try/catch has to wrap the assignment itself
+        // (not the RHS) — see PR #93 review.
+        try {
+            gmap.isMyLocationEnabled = pendingShowUserLocation
+        } catch (_: SecurityException) {
+            android.util.Log.w(
+                "SigxMap",
+                "shows-user-location=true but ACCESS_FINE_LOCATION not granted",
+            )
+        }
+        pendingMapType?.let { applyMapType(it) }
+    }
+
+    private fun applyRegion(obj: JSONObject) {
+        val gmap = googleMap ?: return
+        val lat = obj.optDouble("latitude", Double.NaN)
+        val lon = obj.optDouble("longitude", Double.NaN)
+        val lonD = obj.optDouble("longitudeDelta", Double.NaN)
+        if (lat.isNaN() || lon.isNaN()) return
+        // Map lonDelta to a Google-Maps zoom level. Google's zoom is
+        // logarithmic — zoom n shows 360°/2^n degrees of longitude
+        // horizontally. Solve for n from the user's lonDelta: invert and
+        // log. Clamp to Google's [2, 21] zoom range. latitudeDelta is
+        // ignored because the visible viewport's aspect ratio is fixed by
+        // the view size — fitting both deltas would require knowing the
+        // pixel dimensions, which is deferred to v2's `fitToCoordinates`.
+        val zoom = if (lonD > 0.0) {
+            val z = Math.log(360.0 / lonD) / Math.log(2.0)
+            z.toFloat().coerceIn(2f, 21f)
+        } else {
+            12f
+        }
+        gmap.moveCamera(
+            CameraUpdateFactory.newCameraPosition(
+                CameraPosition.Builder().target(LatLng(lat, lon)).zoom(zoom).build(),
+            ),
+        )
+    }
+
+    private fun applyMapType(value: String) {
+        val gmap = googleMap ?: return
+        gmap.mapType = when (value) {
+            "satellite" -> GoogleMap.MAP_TYPE_SATELLITE
+            "hybrid"    -> GoogleMap.MAP_TYPE_HYBRID
+            else        -> GoogleMap.MAP_TYPE_NORMAL
+        }
+    }
+
+    private fun wireListeners(gmap: GoogleMap) {
+        gmap.setOnCameraIdleListener {
+            val target = gmap.cameraPosition.target
+            // Approximate the LynxRegion shape — Google reports zoom rather
+            // than deltas, so back-compute span from the visible bounds.
+            val bounds = gmap.projection.visibleRegion.latLngBounds
+            val latD = bounds.northeast.latitude - bounds.southwest.latitude
+            val lonD = bounds.northeast.longitude - bounds.southwest.longitude
+            fireEvent(
+                "regionchange",
+                mapOf(
+                    "region" to mapOf(
+                        "latitude" to target.latitude,
+                        "longitude" to target.longitude,
+                        "latitudeDelta" to latD,
+                        "longitudeDelta" to lonD,
+                    ),
+                ),
+            )
+        }
+        gmap.setOnMapClickListener { latLng ->
+            fireEvent(
+                "press",
+                mapOf(
+                    "coordinate" to mapOf(
+                        "latitude" to latLng.latitude,
+                        "longitude" to latLng.longitude,
+                    ),
+                ),
+            )
+        }
+        gmap.setOnMarkerClickListener { gMarker ->
+            val sign = gMarker.tag as? Int ?: return@setOnMarkerClickListener false
+            val marker = attachedMarkers[sign] ?: return@setOnMarkerClickListener false
+            fireEvent(
+                "markerpress",
+                mapOf(
+                    "id" to marker.markerId,
+                    "coordinate" to mapOf(
+                        "latitude" to marker.coordinateLat,
+                        "longitude" to marker.coordinateLng,
+                    ),
+                ),
+            )
+            // Return false so Google's default behaviour (callout + camera
+            // re-centre) still runs.
+            false
+        }
+    }
+
+    // ── Prop setters ─────────────────────────────────────────────────────
+
+    @LynxProp(name = "region")
+    fun setRegion(value: String?) {
+        if (value.isNullOrEmpty()) return
+        val obj = runCatching { JSONObject(value) }.getOrNull() ?: return
+        if (googleMap == null) {
+            pendingRegion = obj
+        } else {
+            applyRegion(obj)
+        }
+    }
+
+    @LynxProp(name = "shows-user-location")
+    fun setShowsUserLocation(value: Boolean) {
+        pendingShowUserLocation = value
+        val gmap = googleMap ?: return
+        try {
+            gmap.isMyLocationEnabled = value
+        } catch (_: SecurityException) {
+            android.util.Log.w(
+                "SigxMap",
+                "shows-user-location=true but ACCESS_FINE_LOCATION not granted",
+            )
+        }
+    }
+
+    @LynxProp(name = "map-type")
+    fun setMapType(value: String?) {
+        val v = value ?: "standard"
+        pendingMapType = v
+        applyMapType(v)
+    }
+
+    // ── Event firing ─────────────────────────────────────────────────────
+
+    private fun fireEvent(name: String, params: Map<String, Any?>) {
+        val event = LynxDetailEvent(sign, name)
+        for ((k, v) in params) event.addDetail(k, v)
+        lynxContext.eventEmitter.sendCustomEvent(event)
+    }
+}

package/dist/Map.d.ts

@@ -0,0 +1,41 @@
+import { type Define } from '@sigx/lynx';
+import './jsx-augment.js';
+import type { MapRegion, MapType, MapPressEvent, MapRegionChangeEvent, MapMarkerPressEvent } from './jsx-augment.js';
+export type MapProps = Define.Prop<'region', MapRegion, false> & Define.Prop<'showsUserLocation', boolean, false> & Define.Prop<'mapType', MapType, false> & Define.Prop<'class', string, false> & Define.Prop<'style', string | Record<string, string | number>, false> & Define.Prop<'onRegionChange', (e: MapRegionChangeEvent) => void, false> & Define.Prop<'onPress', (e: MapPressEvent) => void, false> & Define.Prop<'onMarkerPress', (e: MapMarkerPressEvent) => void, false> & Define.Prop<'children', unknown, false>;
+/**
+ * Native map view.
+ *
+ * Backed by `MKMapView` on iOS and `com.google.android.gms.maps.MapView`
+ * on Android. Pass any number of `<MapMarker>` children to render pins.
+ *
+ * @example
+ * ```tsx
+ * <Map
+ *   region={{
+ *     latitude: 59.3293,
+ *     longitude: 18.0686,
+ *     latitudeDelta: 0.1,
+ *     longitudeDelta: 0.1,
+ *   }}
+ *   showsUserLocation
+ *   onRegionChange={(e) => console.log('region', e.detail.region)}
+ *   onMarkerPress={(e) => console.log('marker', e.detail.id)}
+ * >
+ *   <MapMarker
+ *     coordinate={{ latitude: 59.3293, longitude: 18.0686 }}
+ *     title="Stockholm"
+ *   />
+ * </Map>
+ * ```
+ *
+ * @remarks
+ * - **Android API key**: Google Maps requires an API key. See this
+ *   package's README for setup. The placeholder used by `sigx-lynx-go`
+ *   shows the "For development purposes only" watermark — that's
+ *   expected until you provide your own key.
+ * - **Imperative methods** (`animateToRegion`, `fitToCoordinates`) are
+ *   tracked as a v2 follow-up — they need the Lynx UIMethodInvoker
+ *   surface which isn't wired through sigx-lynx yet. The same gap
+ *   blocks WebView's `goBack` / `reload`.
+ */
+export declare const Map: import("@sigx/runtime-core").ComponentFactory<MapProps, void, {}>;

package/dist/Map.js

@@ -0,0 +1,42 @@
+import { jsx as _jsx } from "@sigx/lynx/jsx-runtime";
+import { component } from '@sigx/lynx';
+import './jsx-augment.js';
+/**
+ * Native map view.
+ *
+ * Backed by `MKMapView` on iOS and `com.google.android.gms.maps.MapView`
+ * on Android. Pass any number of `<MapMarker>` children to render pins.
+ *
+ * @example
+ * ```tsx
+ * <Map
+ *   region={{
+ *     latitude: 59.3293,
+ *     longitude: 18.0686,
+ *     latitudeDelta: 0.1,
+ *     longitudeDelta: 0.1,
+ *   }}
+ *   showsUserLocation
+ *   onRegionChange={(e) => console.log('region', e.detail.region)}
+ *   onMarkerPress={(e) => console.log('marker', e.detail.id)}
+ * >
+ *   <MapMarker
+ *     coordinate={{ latitude: 59.3293, longitude: 18.0686 }}
+ *     title="Stockholm"
+ *   />
+ * </Map>
+ * ```
+ *
+ * @remarks
+ * - **Android API key**: Google Maps requires an API key. See this
+ *   package's README for setup. The placeholder used by `sigx-lynx-go`
+ *   shows the "For development purposes only" watermark — that's
+ *   expected until you provide your own key.
+ * - **Imperative methods** (`animateToRegion`, `fitToCoordinates`) are
+ *   tracked as a v2 follow-up — they need the Lynx UIMethodInvoker
+ *   surface which isn't wired through sigx-lynx yet. The same gap
+ *   blocks WebView's `goBack` / `reload`.
+ */
+export const Map = component(({ props }) => {
+    return () => (_jsx("sigx-map", { region: props.region == null ? undefined : JSON.stringify(props.region), "shows-user-location": props.showsUserLocation, "map-type": props.mapType, class: props.class, style: props.style, bindregionchange: props.onRegionChange, bindpress: props.onPress, bindmarkerpress: props.onMarkerPress, children: props.children }));
+});

package/dist/MapMarker.d.ts

@@ -0,0 +1,29 @@
+import { type Define } from '@sigx/lynx';
+import './jsx-augment.js';
+import type { MapCoordinate } from './jsx-augment.js';
+export type MapMarkerProps = Define.Prop<'coordinate', MapCoordinate, true> & Define.Prop<'title', string, false> & Define.Prop<'description', string, false> & Define.Prop<'id', string, false>;
+/**
+ * Marker pin on a `<Map>`.
+ *
+ * Coordinates are required; `title` / `description` show in the callout
+ * when the user taps the marker. `id` is surfaced as
+ * `event.detail.id` in the parent map's `onMarkerPress` handler — set
+ * one if multiple markers share the same coordinate.
+ *
+ * @example
+ * ```tsx
+ * <Map>
+ *   <MapMarker
+ *     coordinate={{ latitude: 59.3293, longitude: 18.0686 }}
+ *     title="Stockholm"
+ *     description="Sweden's capital"
+ *     id="sthlm"
+ *   />
+ * </Map>
+ * ```
+ *
+ * @remarks
+ * Marker pins are intentionally minimal in v1 — no custom icons, no
+ * draggable pins, no callout views. Those land in v2.
+ */
+export declare const MapMarker: import("@sigx/runtime-core").ComponentFactory<MapMarkerProps, void, {}>;

package/dist/MapMarker.js

@@ -0,0 +1,30 @@
+import { jsx as _jsx } from "@sigx/lynx/jsx-runtime";
+import { component } from '@sigx/lynx';
+import './jsx-augment.js';
+/**
+ * Marker pin on a `<Map>`.
+ *
+ * Coordinates are required; `title` / `description` show in the callout
+ * when the user taps the marker. `id` is surfaced as
+ * `event.detail.id` in the parent map's `onMarkerPress` handler — set
+ * one if multiple markers share the same coordinate.
+ *
+ * @example
+ * ```tsx
+ * <Map>
+ *   <MapMarker
+ *     coordinate={{ latitude: 59.3293, longitude: 18.0686 }}
+ *     title="Stockholm"
+ *     description="Sweden's capital"
+ *     id="sthlm"
+ *   />
+ * </Map>
+ * ```
+ *
+ * @remarks
+ * Marker pins are intentionally minimal in v1 — no custom icons, no
+ * draggable pins, no callout views. Those land in v2.
+ */
+export const MapMarker = component(({ props }) => {
+    return () => (_jsx("sigx-map-marker", { coordinate: JSON.stringify(props.coordinate), title: props.title, description: props.description, "marker-id": props.id }));
+});

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+import './jsx-augment.js';
+export { Map } from './Map.js';
+export type { MapProps } from './Map.js';
+export { MapMarker } from './MapMarker.js';
+export type { MapMarkerProps } from './MapMarker.js';
+export type { MapRegion, MapCoordinate, MapType, MapRegionChangeEvent, MapRegionChangeEventDetail, MapPressEvent, MapPressEventDetail, MapMarkerPressEvent, MapMarkerPressEventDetail, SigxMapAttributes, SigxMapMarkerAttributes, } from './jsx-augment.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+import './jsx-augment.js';
+export { Map } from './Map.js';
+export { MapMarker } from './MapMarker.js';

package/dist/jsx-augment.d.ts

@@ -0,0 +1,109 @@
+/**
+ * JSX intrinsic type augmentation for `<sigx-map>` and `<sigx-map-marker>`.
+ *
+ * Importing this module registers both tags on `JSX.IntrinsicElements` with
+ * the prop + event surface implemented by `SigxMapUI` / `SigxMapMarkerUI`
+ * (iOS) and the same-named Kotlin classes (Android). Pulled in automatically
+ * by `@sigx/lynx-maps`'s entry point so consumers do not need to import it
+ * directly.
+ *
+ * Element availability requires `sigx prebuild` to have run after adding
+ * this package as a dependency — the autolinker emits the `LynxConfig`
+ * registration (iOS) and `Behavior` attachment (Android) that bind the tags
+ * to the native UI classes.
+ */
+import type { LynxCommonAttributes, LynxEventHandler } from '@sigx/lynx-runtime';
+/**
+ * A rectangular region of the map. `latitudeDelta` / `longitudeDelta` define
+ * the span (in degrees) visible above/below and left/right of `latitude` /
+ * `longitude`. Matches the react-native-maps `Region` shape so docs and
+ * coordinate utilities translate cleanly.
+ */
+export interface MapRegion {
+    latitude: number;
+    longitude: number;
+    latitudeDelta: number;
+    longitudeDelta: number;
+}
+export interface MapCoordinate {
+    latitude: number;
+    longitude: number;
+}
+export type MapType = 'standard' | 'satellite' | 'hybrid';
+export interface MapRegionChangeEventDetail {
+    region: MapRegion;
+    [k: string]: unknown;
+}
+export interface MapRegionChangeEvent {
+    type: 'regionchange';
+    detail: MapRegionChangeEventDetail;
+}
+export interface MapPressEventDetail {
+    coordinate: MapCoordinate;
+    [k: string]: unknown;
+}
+export interface MapPressEvent {
+    type: 'press';
+    detail: MapPressEventDetail;
+}
+export interface MapMarkerPressEventDetail {
+    /** Marker's `marker-id` prop, or empty string if none was set. */
+    id: string;
+    coordinate: MapCoordinate;
+    [k: string]: unknown;
+}
+export interface MapMarkerPressEvent {
+    type: 'markerpress';
+    detail: MapMarkerPressEventDetail;
+}
+export interface SigxMapAttributes extends LynxCommonAttributes {
+    /**
+     * Visible region. The map snaps to this on every prop change, so
+     * authors who only want to set an *initial* region should pass it once
+     * and avoid re-passing it on every render (use local state).
+     *
+     * Serialised as a JSON string on the wire — the native side parses it
+     * back into a region struct. Lynx props don't support object types
+     * directly today, so JSON-on-the-wire is the standard sigx-lynx idiom.
+     */
+    region?: string;
+    /** Show the user's current location dot. Requires location permission. */
+    'shows-user-location'?: boolean;
+    /** Base map style. */
+    'map-type'?: MapType;
+    /** Visible region changed (either programmatic or user pan/zoom). */
+    bindregionchange?: LynxEventHandler<MapRegionChangeEvent>;
+    /** User tapped the map (not on a marker). */
+    bindpress?: LynxEventHandler<MapPressEvent>;
+    /** User tapped a marker. */
+    bindmarkerpress?: LynxEventHandler<MapMarkerPressEvent>;
+    children?: unknown;
+}
+export interface SigxMapMarkerAttributes extends LynxCommonAttributes {
+    /**
+     * Marker location. JSON-stringified `{ "latitude": …, "longitude": … }`
+     * for the same reason as `region` on `<sigx-map>` — Lynx props don't
+     * support nested objects directly. Required: a marker without a
+     * coordinate has nowhere to render.
+     */
+    coordinate: string;
+    /** Callout title shown on tap. */
+    title?: string;
+    /** Callout subtitle shown below the title. */
+    description?: string;
+    /**
+     * Stable identifier surfaced as `event.detail.id` in `bindmarkerpress`.
+     * Useful when many markers share the same coordinate (e.g. clustered
+     * entries) and the press handler needs to disambiguate.
+     */
+    'marker-id'?: string;
+}
+declare global {
+    namespace JSX {
+        interface IntrinsicElements {
+            'sigx-map': SigxMapAttributes;
+            'sigx-map-marker': SigxMapMarkerAttributes;
+        }
+    }
+}
+export {};

package/dist/jsx-augment.js

@@ -0,0 +1 @@
+export {};

package/ios/SigxMapMarkerUI.swift

@@ -0,0 +1,102 @@
+import Foundation
+import UIKit
+import MapKit
+import Lynx
+
+/// Native UI for the `<sigx-map-marker>` JSX element.
+///
+/// A marker doesn't render its own real view — Google Maps and MapKit both
+/// model pins as data attached to the map. We still need a `LynxUI<UIView>`
+/// because Lynx's UI tree expects every child to be a UI. The native view is
+/// a zero-size hidden `UIView` that never gets laid out: the parent
+/// `SigxMapUI` intercepts `insertChild` for markers and skips calling super,
+/// so the dummy view is created but never attached to the map view hierarchy.
+///
+/// Prop surface (v1):
+///   - `coordinate`  → JSON-stringified `{ latitude, longitude }`
+///   - `title`       → callout title
+///   - `description` → callout subtitle
+///   - `marker-id`   → forwarded as `event.detail.id` on `bindmarkerpress`
+// Class is NOT marked `@objc` — Swift forbids that on generic subclasses
+// of an ObjC lightweight-generic type like `LynxUI<__covariant V>`. Member-
+// level `@objc` / `@objc(name)` annotations still bridge because `LynxUI`
+// itself is `@objc`, so `__lynx_prop_config__*` discovery still works.
+public class SigxMapMarkerUI: LynxUI<UIView> {
+    internal weak var owningMap: SigxMapUI?
+
+    internal var currentCoordinate = CLLocationCoordinate2D(latitude: 0, longitude: 0)
+    internal var currentTitle: String?
+    internal var currentSubtitle: String?
+    internal var markerId: String = ""
+
+    public override func createView() -> UIView? {
+        let v = UIView(frame: .zero)
+        v.isHidden = true
+        return v
+    }
+
+    // Explicit prop-setter registration. See SigxWebViewUI for rationale.
+    @objc public class func propSetterLookUp() -> NSArray {
+        return [
+            ["coordinate", "setCoordinate:requestReset:"],
+            ["title", "setTitle:requestReset:"],
+            ["description", "setDescription:requestReset:"],
+            ["marker-id", "setMarkerId:requestReset:"],
+        ] as NSArray
+    }
+
+    internal func makeAnnotation() -> MKPointAnnotation {
+        let a = MKPointAnnotation()
+        a.coordinate = currentCoordinate
+        a.title = currentTitle
+        a.subtitle = currentSubtitle
+        return a
+    }
+
+    // MARK: - Prop setters
+
+    @objc public func setCoordinate(_ value: NSString?, requestReset: Bool) {
+        guard let raw = value as String?, !raw.isEmpty,
+              let data = raw.data(using: .utf8),
+              let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+              let lat = (obj["latitude"] as? NSNumber)?.doubleValue,
+              let lon = (obj["longitude"] as? NSNumber)?.doubleValue
+        else { return }
+        currentCoordinate = CLLocationCoordinate2D(latitude: lat, longitude: lon)
+        owningMap?.markerDidUpdate(self)
+    }
+
+    @objc(__lynx_prop_config__coordinate)
+    public class func __lynxPropConfigCoordinate() -> [String] {
+        return ["coordinate", "setCoordinate", "NSString *"]
+    }
+
+    @objc public func setTitle(_ value: NSString?, requestReset: Bool) {
+        currentTitle = value as String?
+        owningMap?.markerDidUpdate(self)
+    }
+
+    @objc(__lynx_prop_config__title)
+    public class func __lynxPropConfigTitle() -> [String] {
+        return ["title", "setTitle", "NSString *"]
+    }
+
+    @objc public func setDescription(_ value: NSString?, requestReset: Bool) {
+        currentSubtitle = value as String?
+        owningMap?.markerDidUpdate(self)
+    }
+
+    @objc(__lynx_prop_config__description)
+    public class func __lynxPropConfigDescription() -> [String] {
+        return ["description", "setDescription", "NSString *"]
+    }
+
+    @objc public func setMarkerId(_ value: NSString?, requestReset: Bool) {
+        markerId = (value as String?) ?? ""
+    }
+
+    @objc(__lynx_prop_config__marker_id)
+    public class func __lynxPropConfigMarkerId() -> [String] {
+        return ["marker-id", "setMarkerId", "NSString *"]
+    }
+}

package/ios/SigxMapUI.swift

@@ -0,0 +1,236 @@
+import Foundation
+import UIKit
+import MapKit
+import Lynx
+
+/// Native UI for the `<sigx-map>` JSX element.
+///
+/// Registered via the autolinker — `signalx-module.json`'s `ios.uiComponents`
+/// produces a `config.registerUI(SigxMapUI.self, withName: "sigx-map")` call
+/// in the generated `GeneratedComponentRegistry.swift`.
+///
+/// Prop / event surface (v1):
+///   - `region`               → JSON-stringified `MapRegion`
+///   - `shows-user-location`  → toggle the user-location dot
+///   - `map-type`             → `"standard" | "satellite" | "hybrid"`
+///   - `bindregionchange`     → region changed (programmatic or user gesture)
+///   - `bindpress`            → user tapped the map (not a marker)
+///   - `bindmarkerpress`      → user tapped a marker
+///
+/// Imperative methods (animateToRegion / fitToCoordinates) are tracked as a
+/// v2 follow-up — they need the Lynx UIMethodInvoker surface which isn't
+/// wired through sigx-lynx yet (same blocker as WebView.goBack / reload).
+// Class is NOT marked `@objc` — Swift forbids that on generic subclasses
+// of an ObjC lightweight-generic type like `LynxUI<__covariant V>`. Member-
+// level `@objc` / `@objc(name)` annotations still bridge because `LynxUI`
+// itself is `@objc`, so `__lynx_prop_config__*` and
+// `__lynx_ui_method_config__*` discovery still works.
+public class SigxMapUI: LynxUI<MKMapView> {
+
+    private lazy var mapDelegate = SigxMapDelegate(owner: self)
+    private lazy var tapGesture: UITapGestureRecognizer = {
+        let gr = UITapGestureRecognizer(target: self, action: #selector(handleTap(_:)))
+        gr.cancelsTouchesInView = false
+        return gr
+    }()
+    /// Tracks the `MKPointAnnotation` per marker child so we can rebuild
+    /// callout titles / coordinates in place rather than re-adding pins on
+    /// every prop change.
+    private var markerAnnotations: [ObjectIdentifier: MKPointAnnotation] = [:]
+    /// Reverse index: annotation identity → marker UI, for translating
+    /// `didSelect` callbacks back into `bindmarkerpress` events.
+    private var markersByAnnotation: [ObjectIdentifier: SigxMapMarkerUI] = [:]
+
+    // MARK: - LynxUI overrides
+
+    public override func createView() -> MKMapView? {
+        let map = MKMapView(frame: CGRect(x: 0, y: 0, width: 1, height: 1))
+        map.translatesAutoresizingMaskIntoConstraints = true
+        map.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        map.delegate = mapDelegate
+        map.addGestureRecognizer(tapGesture)
+        return map
+    }
+
+    // Explicit prop-setter registration. See SigxWebViewUI for rationale.
+    @objc public class func propSetterLookUp() -> NSArray {
+        return [
+            ["region", "setRegion:requestReset:"],
+            ["shows-user-location", "setShowsUserLocation:requestReset:"],
+            ["map-type", "setMapType:requestReset:"],
+        ] as NSArray
+    }
+
+    // Lynx's child-management hooks live on `LynxComponent<D>` where for
+    // `LynxUI` the generic `D` is `LynxUI*`. ObjC lightweight generics
+    // import into Swift as the upper bound, so the override signature uses
+    // `LynxUI<UIView>` (the declared bound `__covariant V : UIView*`).
+    // Both insert and remove take `atIndex` per the LynxComponent.h ABI.
+    // Swift imports the ObjC `insertChild:atIndex:` selector as
+    // `insertChild(_:at:)` and the same for removeChild. Override matches.
+    public override func insertChild(_ child: LynxUI<UIView>!, at index: Int) {
+        // Map markers participate in the Lynx UI tree as children of the map,
+        // but we don't want their UIViews added to MKMapView — markers
+        // render as `MKAnnotation`s on the native side. Intercept marker
+        // children, register the annotation, and skip super.
+        if let marker = child as? SigxMapMarkerUI {
+            attachMarker(marker)
+            return
+        }
+        super.insertChild(child, at: index)
+    }
+
+    public override func removeChild(_ child: LynxUI<UIView>!, at index: Int) {
+        if let marker = child as? SigxMapMarkerUI {
+            detachMarker(marker)
+            return
+        }
+        super.removeChild(child, at: index)
+    }
+
+    // MARK: - Marker plumbing
+
+    func attachMarker(_ marker: SigxMapMarkerUI) {
+        marker.owningMap = self
+        let annotation = marker.makeAnnotation()
+        markerAnnotations[ObjectIdentifier(marker)] = annotation
+        markersByAnnotation[ObjectIdentifier(annotation)] = marker
+        view().addAnnotation(annotation)
+    }
+
+    func detachMarker(_ marker: SigxMapMarkerUI) {
+        if let annotation = markerAnnotations.removeValue(forKey: ObjectIdentifier(marker)) {
+            markersByAnnotation.removeValue(forKey: ObjectIdentifier(annotation))
+            view().removeAnnotation(annotation)
+        }
+        marker.owningMap = nil
+    }
+
+    /// Called by `SigxMapMarkerUI` when its coordinate / title / description
+    /// props change so the on-screen annotation reflects the new values
+    /// without re-adding the pin (which would clear selection state).
+    func markerDidUpdate(_ marker: SigxMapMarkerUI) {
+        guard let annotation = markerAnnotations[ObjectIdentifier(marker)] else { return }
+        annotation.coordinate = marker.currentCoordinate
+        annotation.title = marker.currentTitle
+        annotation.subtitle = marker.currentSubtitle
+    }
+
+    // MARK: - Prop setters
+
+    @objc public func setRegion(_ value: NSString?, requestReset: Bool) {
+        guard let raw = value as String?, !raw.isEmpty else { return }
+        guard
+            let data = raw.data(using: .utf8),
+            let obj = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
+            let lat = (obj["latitude"] as? NSNumber)?.doubleValue,
+            let lon = (obj["longitude"] as? NSNumber)?.doubleValue,
+            let latD = (obj["latitudeDelta"] as? NSNumber)?.doubleValue,
+            let lonD = (obj["longitudeDelta"] as? NSNumber)?.doubleValue
+        else {
+            NSLog("[SigxMap] Ignoring malformed region prop: \(raw.prefix(64))")
+            return
+        }
+        let region = MKCoordinateRegion(
+            center: CLLocationCoordinate2D(latitude: lat, longitude: lon),
+            span: MKCoordinateSpan(latitudeDelta: latD, longitudeDelta: lonD)
+        )
+        view().setRegion(region, animated: false)
+    }
+
+    @objc(__lynx_prop_config__region)
+    public class func __lynxPropConfigRegion() -> [String] {
+        return ["region", "setRegion", "NSString *"]
+    }
+
+    @objc public func setShowsUserLocation(_ value: Bool, requestReset: Bool) {
+        view().showsUserLocation = value
+    }
+
+    @objc(__lynx_prop_config__shows_user_location)
+    public class func __lynxPropConfigShowsUserLocation() -> [String] {
+        return ["shows-user-location", "setShowsUserLocation", "BOOL"]
+    }
+
+    @objc public func setMapType(_ value: NSString?, requestReset: Bool) {
+        switch (value as String?) ?? "" {
+        case "satellite": view().mapType = .satellite
+        case "hybrid":    view().mapType = .hybrid
+        default:          view().mapType = .standard
+        }
+    }
+
+    @objc(__lynx_prop_config__map_type)
+    public class func __lynxPropConfigMapType() -> [String] {
+        return ["map-type", "setMapType", "NSString *"]
+    }
+
+    // MARK: - Gesture handling
+
+    @objc private func handleTap(_ gr: UITapGestureRecognizer) {
+        let map = view()
+        let point = gr.location(in: map)
+        // Skip taps on the existing annotations — those are surfaced via
+        // didSelect in the delegate as `bindmarkerpress`.
+        if map.hitTest(point, with: nil) is MKAnnotationView { return }
+        let coord = map.convert(point, toCoordinateFrom: map)
+        fireEvent("press", params: [
+            "coordinate": [
+                "latitude": coord.latitude,
+                "longitude": coord.longitude,
+            ],
+        ])
+    }
+
+    // MARK: - Event firing
+
+    internal func fireEvent(_ name: String, params: [String: Any]) {
+        let event = LynxCustomEvent(name: name, targetSign: sign, params: params)
+        // Swift renames the ObjC `sendCustomEvent:` selector to `send(_:)`
+        // when LynxCustomEvent is the parameter type — same underlying method.
+        context?.eventEmitter?.send(event)
+    }
+
+    internal func emitRegionChange(_ region: MKCoordinateRegion) {
+        fireEvent("regionchange", params: [
+            "region": [
+                "latitude": region.center.latitude,
+                "longitude": region.center.longitude,
+                "latitudeDelta": region.span.latitudeDelta,
+                "longitudeDelta": region.span.longitudeDelta,
+            ],
+        ])
+    }
+
+    internal func emitMarkerPress(_ marker: SigxMapMarkerUI) {
+        fireEvent("markerpress", params: [
+            "id": marker.markerId,
+            "coordinate": [
+                "latitude": marker.currentCoordinate.latitude,
+                "longitude": marker.currentCoordinate.longitude,
+            ],
+        ])
+    }
+
+    internal func marker(for annotation: MKAnnotation) -> SigxMapMarkerUI? {
+        guard let obj = annotation as? AnyObject else { return nil }
+        return markersByAnnotation[ObjectIdentifier(obj)]
+    }
+}
+
+/// `MKMapViewDelegate` forwarder — keeps the public class slim and avoids
+/// the `NSObject` Obj-C runtime drag on `SigxMapUI` itself.
+final class SigxMapDelegate: NSObject, MKMapViewDelegate {
+    private weak var owner: SigxMapUI?
+
+    init(owner: SigxMapUI) { self.owner = owner }
+
+    func mapView(_ mapView: MKMapView, regionDidChangeAnimated animated: Bool) {
+        owner?.emitRegionChange(mapView.region)
+    }
+
+    func mapView(_ mapView: MKMapView, didSelect view: MKAnnotationView) {
+        guard let annotation = view.annotation, let marker = owner?.marker(for: annotation) else { return }
+        owner?.emitMarkerPress(marker)
+    }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@sigx/lynx-maps",
+  "version": "0.4.1",
+  "description": "Native map view for sigx-lynx (MKMapView on iOS, Google Maps on Android).",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./signalx-module.json": "./signalx-module.json",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "ios",
+    "android",
+    "signalx-module.json",
+    "README.md",
+    "LICENSE"
+  ],
+  "peerDependencies": {
+    "@sigx/lynx": "^0.4.1"
+  },
+  "devDependencies": {
+    "@typescript/native-preview": "7.0.0-dev.20260521.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.7",
+    "@sigx/lynx": "^0.4.1"
+  },
+  "author": "Andreas Ekdahl",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/signalxjs/lynx.git",
+    "directory": "packages/lynx-maps"
+  },
+  "homepage": "https://github.com/signalxjs/lynx/tree/main/packages/lynx-maps",
+  "bugs": {
+    "url": "https://github.com/signalxjs/lynx/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "signalx",
+    "sigx",
+    "lynx",
+    "maps",
+    "mkmapview",
+    "google-maps",
+    "ios",
+    "android"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/clean.mjs dist && tsgo",
+    "dev": "tsgo --watch",
+    "test": "vitest run",
+    "clean": "node ../../scripts/clean.mjs dist .turbo"
+  }
+}

package/signalx-module.json

@@ -0,0 +1,30 @@
+{
+    "name": "Maps",
+    "package": "@sigx/lynx-maps",
+    "description": "Native map view (MKMapView / Google Maps)",
+    "platforms": ["android", "ios"],
+    "ios": {
+        "sourceDir": "ios",
+        "uiComponents": [
+            { "name": "sigx-map", "uiClass": "SigxMapUI" },
+            { "name": "sigx-map-marker", "uiClass": "SigxMapMarkerUI" }
+        ],
+        "usageDescriptions": {
+            "NSLocationWhenInUseUsageDescription": "Show your location on the map."
+        }
+    },
+    "android": {
+        "sourceDir": "android",
+        "behaviors": [
+            { "name": "sigx-map", "behaviorClass": "com.sigx.maps.SigxMapBehavior" },
+            { "name": "sigx-map-marker", "behaviorClass": "com.sigx.maps.SigxMapMarkerBehavior" }
+        ],
+        "permissions": [
+            "android.permission.ACCESS_FINE_LOCATION",
+            "android.permission.ACCESS_COARSE_LOCATION"
+        ],
+        "dependencies": [
+            "com.google.android.gms:play-services-maps:19.0.0"
+        ]
+    }
+}