Add reload_style command to avoid daemon restart on style changes

- Add ReloadStyle command to Rust daemon for in-place style updates
- Add reload_style() method to Python RenderDaemon bridge
- Update Map.load_style() to use reload_style instead of daemon restart
- Update Map.set_geojson() to use reload_style instead of daemon restart
- Improves performance by keeping daemon warm between style changes

Author: adonm

mlnative/_bridge.py

@@ -185,6 +185,28 @@ def render_batch(self, views: list[dict[str, Any]]) -> list[bytes]:
         pngs_b64 = response.get("png", "").split(",")
         return [base64.b64decode(png) for png in pngs_b64 if png]
 
+    def reload_style(self, style: str) -> None:
+        """Reload the style without restarting the daemon.
+
+        Args:
+            style: Style URL string or JSON string
+
+        Raises:
+            MlnativeError: If style reload fails
+        """
+        if not self._initialized:
+            raise MlnativeError("Renderer not initialized")
+
+        cmd = {
+            "cmd": "reload_style",
+            "style": style,
+        }
+
+        response = self._send_command(cmd)
+
+        if response.get("status") != "ok":
+            raise MlnativeError(f"Style reload failed: {response.get('error')}")
+
     def stop(self) -> None:
         """Stop the daemon."""
         if self._process is not None and self._process.poll() is None:

mlnative/map.py

@@ -148,10 +148,15 @@ def load_style(self, style: str | dict[str, Any] | Path) -> None:
         else:
             raise MlnativeError(f"Style must be str, dict, or Path, got {type(style)}")
 
-        # Reset daemon so it picks up new style
+        # Reload style in daemon if already running, otherwise it will pick up on next _get_daemon()
         if self._daemon is not None:
-            self._daemon.stop()
-            self._daemon = None
+            # Get style string for daemon
+            style_for_daemon = self._style
+            if isinstance(style_for_daemon, dict):
+                style_for_daemon = json.dumps(style_for_daemon)
+            elif isinstance(style_for_daemon, Path):
+                style_for_daemon = json.dumps(json.loads(style_for_daemon.read_text()))
+            self._daemon.reload_style(str(style_for_daemon))
 
     def render(
         self, center: list[float], zoom: float, bearing: float = 0, pitch: float = 0
@@ -488,10 +493,9 @@ def set_geojson(
             "data": geojson,
         }
 
-        # Reset daemon to pick up new style
+        # Reload style in daemon if already running
         if self._daemon is not None:
-            self._daemon.stop()
-            self._daemon = None
+            self._daemon.reload_style(json.dumps(self._style))
 
     def close(self) -> None:
         """Close the map and release resources."""

rust/src/main.rs

@@ -19,6 +19,8 @@ enum Command {
         #[serde(default = "default_pixel_ratio")]
         pixel_ratio: f64,
     },
+    #[serde(rename = "reload_style")]
+    ReloadStyle { style: String },
     #[serde(rename = "render")]
     Render {
         center: [f64; 2],
@@ -151,6 +153,34 @@ impl Renderer {
         // modifying the underlying maplibre_native renderer
         Ok(())
     }
+
+    fn reload_style(&mut self, style: &str) -> Result<(), Box<dyn std::error::Error>> {
+        let renderer = self
+            .renderer
+            .as_mut()
+            .ok_or("Renderer not initialized")?;
+
+        // Check if style is URL or file path (JSON strings need to be saved to temp file)
+        if style.starts_with("http://")
+            || style.starts_with("https://")
+            || style.starts_with("file://")
+        {
+            let url = style.parse().map_err(|_| "Invalid style URL")?;
+            renderer.load_style_from_url(&url);
+        } else if style.starts_with("{") {
+            // JSON string - save to temp file
+            let temp_dir = std::env::temp_dir();
+            let temp_file = temp_dir.join(format!("mlnative_style_{}.json", std::process::id()));
+            std::fs::write(&temp_file, style)?;
+            renderer.load_style_from_path(&temp_file)?;
+            // Note: temp file will be cleaned up by OS eventually
+        } else {
+            // Assume it's a file path
+            renderer.load_style_from_path(style)?;
+        }
+
+        Ok(())
+    }
 }
 
 fn main() {
@@ -237,6 +267,24 @@ fn main() {
                     println!("{}", serde_json::to_string(&resp).unwrap());
                 }
             },
+            Command::ReloadStyle { style } => match renderer.reload_style(&style) {
+                Ok(_) => {
+                    let resp = Response {
+                        status: "ok".to_string(),
+                        png: None,
+                        error: None,
+                    };
+                    println!("{}", serde_json::to_string(&resp).unwrap());
+                }
+                Err(e) => {
+                    let resp = Response {
+                        status: "error".to_string(),
+                        png: None,
+                        error: Some(format!("Reload style failed: {:?}", e)),
+                    };
+                    println!("{}", serde_json::to_string(&resp).unwrap());
+                }
+            },
             Command::RenderBatch { views } => {
                 let mut pngs = Vec::new();
                 let mut has_error = false;