figrecipe 0.6.0__py3-none-any.whl → 0.9.0__py3-none-any.whl

figrecipe/_editor/_flask_app.py

@@ -28,11 +28,7 @@ from pathlib import Path
 from typing import Any, Dict, Optional
 
 from .._wrappers import RecordingFigure
-from ._overrides import (
-    create_overrides_from_style,
-    load_overrides,
-    save_overrides,
-)
+from ._overrides import create_overrides_from_style, load_overrides
 
 
 class FigureEditor:
@@ -46,6 +42,7 @@ class FigureEditor:
     - Dark/light theme toggle
     - Download in PNG/SVG/PDF formats
     - Separate storage of manual overrides (can restore to original)
+    - Hot reload: server restarts on source file changes (like Django)
     """
 
     def __init__(
@@ -54,9 +51,13 @@ class FigureEditor:
         recipe_path: Optional[Path] = None,
         style: Optional[Dict[str, Any]] = None,
         port: int = 5050,
+        host: str = "127.0.0.1",
         static_png_path: Optional[Path] = None,
         hitmap_base64: Optional[str] = None,
         color_map: Optional[Dict] = None,
+        hot_reload: bool = False,
+        working_dir: Optional[Path] = None,
+        desktop: bool = False,
     ):
         """
         Initialize figure editor.
@@ -77,11 +78,26 @@ class FigureEditor:
             Pre-generated hitmap as base64.
         color_map : dict, optional
             Pre-generated color map for hitmap.
+        hot_reload : bool, optional
+            Enable hot reload - server restarts on source file changes.
+        working_dir : Path, optional
+            Working directory for file switching (default: current directory).
+        desktop : bool, optional
+            Launch as native desktop window using pywebview.
         """
         self.fig = fig
+        self.desktop = desktop
         self.recipe_path = Path(recipe_path) if recipe_path else None
         self.port = port
-        self.dark_mode = False
+        self.host = host
+        self.hot_reload = hot_reload
+        self.working_dir = Path(working_dir) if working_dir else Path.cwd()
+
+        # Load user preferences
+        from ._preferences import load_preferences
+
+        prefs = load_preferences()
+        self.dark_mode = prefs.get("dark_mode", False)
 
         # Pre-rendered static PNG (source of truth)
         self._static_png_path = static_png_path
@@ -92,12 +108,14 @@ class FigureEditor:
             with open(static_png_path, "rb") as f:
                 self._initial_base64 = base64.b64encode(f.read()).decode("utf-8")
 
-        # Initialize style overrides system
+        # Initialize style overrides system (captures original positions into base_style)
         self._init_style_overrides(style)
 
         # Pre-generated hitmap and color_map
+        # Use empty dict as default to prevent JavaScript errors
+        # when page loads before hitmap is generated
         self._hitmap_base64 = hitmap_base64
-        self._color_map = color_map
+        self._color_map = color_map if color_map is not None else {}
 
     def _init_style_overrides(self, programmatic_style: Optional[Dict[str, Any]]):
         """Initialize the layered style override system."""
@@ -106,14 +124,15 @@ class FigureEditor:
             existing = load_overrides(self.recipe_path)
             if existing:
                 self.style_overrides = existing
-                # Update programmatic style if provided
                 if programmatic_style:
                     self.style_overrides.programmatic_style = programmatic_style
+                # Ensure original positions are captured even when loading existing overrides
+                self._ensure_original_positions_in_base_style()
                 return
 
-        # Get base style from global preset (always ensure we have a base style)
+        # Get base style from global preset
         base_style = {}
-        style_name = "SCITEX"  # Default
+        style_name = "SCITEX"
         try:
             from ..styles._style_loader import (
                 _CURRENT_STYLE_NAME,
@@ -122,11 +141,9 @@ class FigureEditor:
                 to_subplots_kwargs,
             )
 
-            # If no style is loaded, load the default SCITEX style
             if _STYLE_CACHE is None:
                 load_style("SCITEX")
 
-            # Get the style cache (now guaranteed to exist)
             from ..styles._style_loader import _STYLE_CACHE
 
             if _STYLE_CACHE is not None:
@@ -135,10 +152,18 @@ class FigureEditor:
         except Exception:
             pass
 
-        # Store the style name for UI display
         self._style_name = style_name
 
-        # Create new overrides
+        # Capture original annotation positions into base_style for restore
+        annotation_positions = self._capture_annotation_positions()
+        for key, pos_data in annotation_positions.items():
+            base_style[f"_original_{key}"] = pos_data
+
+        # Capture original axes positions into base_style for restore
+        axes_positions = self._capture_axes_positions()
+        for ax_idx, pos in axes_positions.items():
+            base_style[f"_original_axes_position_{ax_idx}"] = pos
+
         self.style_overrides = create_overrides_from_style(
             base_style=base_style,
             programmatic_style=programmatic_style or {},
@@ -163,6 +188,75 @@ class FigureEditor:
         """Get the final merged style."""
         return self.style_overrides.get_effective_style()
 
+    def _ensure_original_positions_in_base_style(self) -> None:
+        """Ensure original positions are captured in base_style (for existing overrides)."""
+        base_style = self.style_overrides.base_style
+
+        # Add annotation positions if not present
+        annotation_positions = self._capture_annotation_positions()
+        for key, pos_data in annotation_positions.items():
+            base_key = f"_original_{key}"
+            if base_key not in base_style:
+                base_style[base_key] = pos_data
+
+        # Add axes positions if not present
+        axes_positions = self._capture_axes_positions()
+        for ax_idx, pos in axes_positions.items():
+            base_key = f"_original_axes_position_{ax_idx}"
+            if base_key not in base_style:
+                base_style[base_key] = pos
+
+    def _capture_axes_positions(self) -> Dict[int, list]:
+        """Capture current axes positions (matplotlib coords: [left, bottom, width, height])."""
+        mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
+        axes = mpl_fig.get_axes()
+        positions = {}
+        for i, ax in enumerate(axes):
+            bbox = ax.get_position()
+            positions[i] = [bbox.x0, bbox.y0, bbox.width, bbox.height]
+        return positions
+
+    def restore_axes_positions(self) -> None:
+        """Restore axes to their original positions from base_style."""
+        base_style = self.style_overrides.base_style
+        mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
+        axes = mpl_fig.get_axes()
+        for i, ax in enumerate(axes):
+            key = f"_original_axes_position_{i}"
+            if key in base_style:
+                pos = base_style[key]
+                ax.set_position(pos)
+
+    def _capture_annotation_positions(self) -> Dict[str, dict]:
+        """Capture current annotation (text) positions for each axis."""
+        mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
+        axes = mpl_fig.get_axes()
+        positions = {}
+        for ax_idx, ax in enumerate(axes):
+            for text_idx, text_obj in enumerate(ax.texts):
+                key = f"ax{ax_idx}_text{text_idx}"
+                pos = text_obj.get_position()
+                positions[key] = {
+                    "position": [
+                        float(pos[0]),
+                        float(pos[1]),
+                    ],  # Convert to float for JSON
+                    "transform_is_axes": bool(text_obj.get_transform() == ax.transAxes),
+                }
+        return positions
+
+    def restore_annotation_positions(self) -> None:
+        """Restore annotations to their original positions from base_style."""
+        base_style = self.style_overrides.base_style
+        mpl_fig = self.fig.fig if hasattr(self.fig, "fig") else self.fig
+        axes = mpl_fig.get_axes()
+        for ax_idx, ax in enumerate(axes):
+            for text_idx, text_obj in enumerate(ax.texts):
+                key = f"_original_ax{ax_idx}_text{text_idx}"
+                if key in base_style:
+                    orig = base_style[key]
+                    text_obj.set_position(tuple(orig["position"]))
+
     def run(self, open_browser: bool = True) -> Dict[str, Any]:
         """
         Run the editor server.
@@ -177,1053 +271,129 @@ class FigureEditor:
         dict
             Final style overrides after editing session.
         """
-        from flask import Flask, jsonify, render_template_string, request, send_file
+        from flask import Flask
 
-        from ._bbox import extract_bboxes
-        from ._hitmap import generate_hitmap, hitmap_to_base64
-        from ._renderer import render_download
-        from ._templates import build_html_template
+        from ._routes_annotation import register_annotation_routes
+        from ._routes_axis import register_axis_routes
 
-        # Use specified port strictly (no fallback)
+        # DISABLED: Snapshot feature corrupts figure state via visibility changes
+        # from ._routes_snapshot import register_snapshot_routes
+        from ._routes_captions import register_caption_routes
+        from ._routes_core import register_core_routes
+        from ._routes_datatable import register_datatable_routes
+        from ._routes_element import register_element_routes
+        from ._routes_files import register_file_routes
+        from ._routes_image import register_image_routes
+        from ._routes_style import register_style_routes
 
         # Defer hitmap generation until first request (lazy loading)
-        # This makes the editor start immediately
         self._hitmap_generated = self._hitmap_base64 is not None
 
-        # Create Flask app
-        app = Flask(__name__)
-        editor = self
-
-        @app.route("/")
-        def index():
-            """Main editor page."""
-            # Always render with effective style (base + programmatic + manual)
-            # to ensure YAML style settings are applied
-            base64_img, bboxes, img_size = _render_with_overrides(
-                editor.fig,
-                editor.get_effective_style(),
-                editor.dark_mode,
-            )
-
-            # Get style name (default to SCITEX if not set)
-            style_name = getattr(editor, "_style_name", "SCITEX")
-
-            # Build HTML template
-            html = build_html_template(
-                image_base64=base64_img,
-                bboxes=bboxes,
-                color_map=editor._color_map,
-                style=editor.style,
-                overrides=editor.get_effective_style(),
-                img_size=img_size,
-                style_name=style_name,
-            )
-
-            return render_template_string(html)
-
-        @app.route("/preview")
-        def preview():
-            """Get current preview image."""
-            # Always render with effective style (base + programmatic + manual)
-            base64_img, bboxes, img_size = _render_with_overrides(
-                editor.fig,
-                editor.get_effective_style(),
-                editor.dark_mode,
-            )
-
-            return jsonify(
-                {
-                    "image": base64_img,
-                    "bboxes": bboxes,
-                    "img_size": {"width": img_size[0], "height": img_size[1]},
-                }
-            )
-
-        @app.route("/update", methods=["POST"])
-        def update():
-            """Update preview with new style overrides."""
-            data = request.get_json() or {}
-
-            # Update manual overrides
-            editor.overrides.update(data.get("overrides", {}))
-            editor.dark_mode = data.get("dark_mode", editor.dark_mode)
-
-            # Re-render with effective style (base + programmatic + manual)
-            base64_img, bboxes, img_size = _render_with_overrides(
-                editor.fig,
-                editor.get_effective_style(),
-                editor.dark_mode,
-            )
-
-            return jsonify(
-                {
-                    "image": base64_img,
-                    "bboxes": bboxes,
-                    "img_size": {"width": img_size[0], "height": img_size[1]},
-                }
-            )
-
-        @app.route("/hitmap")
-        def hitmap():
-            """Get hitmap image and color map (lazy generation on first request)."""
-            # Generate hitmap on first request if not already done
-            if not editor._hitmap_generated:
-                print("Generating hitmap (first request)...")
-                hitmap_img, editor._color_map = generate_hitmap(editor.fig)
-                editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
-                editor._hitmap_generated = True
-                print("Hitmap ready.")
-
-            return jsonify(
-                {
-                    "image": editor._hitmap_base64,
-                    "color_map": editor._color_map,
-                }
-            )
-
-        def _to_json_serializable(obj):
-            """Convert numpy arrays and other non-serializable objects to JSON-safe types."""
-            import numpy as np
-
-            if isinstance(obj, np.ndarray):
-                return obj.tolist()
-            elif isinstance(obj, (np.integer, np.floating)):
-                return obj.item()
-            elif isinstance(obj, dict):
-                return {k: _to_json_serializable(v) for k, v in obj.items()}
-            elif isinstance(obj, (list, tuple)):
-                return [_to_json_serializable(item) for item in obj]
-            return obj
-
-        @app.route("/calls")
-        def get_calls():
-            """Get all recorded calls with their signatures."""
-            from .._signatures import get_signature
-
-            calls_data = {}
-            if hasattr(editor.fig, "record"):
-                for ax_key, ax_record in editor.fig.record.axes.items():
-                    for call in ax_record.calls:
-                        call_id = call.id
-                        func_name = call.function
-                        sig = get_signature(func_name)
-
-                        calls_data[call_id] = {
-                            "function": func_name,
-                            "ax_key": ax_key,
-                            "args": _to_json_serializable(call.args),
-                            "kwargs": _to_json_serializable(call.kwargs),
-                            "signature": {
-                                "args": sig.get("args", []),
-                                "kwargs": {
-                                    k: v
-                                    for k, v in sig.get("kwargs", {}).items()
-                                    if k != "**kwargs"
-                                },
-                            },
-                        }
-
-            return jsonify(calls_data)
-
-        @app.route("/call/<call_id>")
-        def get_call(call_id):
-            """Get recorded call data by call_id."""
-            from .._signatures import get_signature
-
-            if hasattr(editor.fig, "record"):
-                for ax_key, ax_record in editor.fig.record.axes.items():
-                    for call in ax_record.calls:
-                        if call.id == call_id:
-                            sig = get_signature(call.function)
-                            return jsonify(
-                                {
-                                    "call_id": call_id,
-                                    "function": call.function,
-                                    "ax_key": ax_key,
-                                    "args": call.args,
-                                    "kwargs": call.kwargs,
-                                    "signature": {
-                                        "args": sig.get("args", []),
-                                        "kwargs": {
-                                            k: v
-                                            for k, v in sig.get("kwargs", {}).items()
-                                            if k != "**kwargs"
-                                        },
-                                    },
-                                }
-                            )
-
-            return jsonify({"error": f"Call {call_id} not found"}), 404
-
-        @app.route("/style")
-        def get_style():
-            """Get current style configuration."""
-            return jsonify(
-                {
-                    "base_style": editor.style_overrides.base_style,
-                    "programmatic_style": editor.style_overrides.programmatic_style,
-                    "manual_overrides": editor.style_overrides.manual_overrides,
-                    "effective_style": editor.get_effective_style(),
-                    "has_overrides": editor.style_overrides.has_manual_overrides(),
-                    "manual_timestamp": editor.style_overrides.manual_timestamp,
-                }
-            )
-
-        @app.route("/theme")
-        def get_theme():
-            """Get current theme YAML content for display."""
-            import io as yaml_io
-
-            from ruamel.yaml import YAML
-
-            style = editor.get_effective_style()
-            style_name = style.get("_name", "SCITEX")
-
-            # Serialize to YAML
-            yaml = YAML()
-            yaml.default_flow_style = False
-            yaml.indent(mapping=2, sequence=4, offset=2)
-            stream = yaml_io.StringIO()
-            yaml.dump(style, stream)
-            yaml_content = stream.getvalue()
-
-            return jsonify(
-                {
-                    "name": style_name,
-                    "content": yaml_content,
-                }
-            )
-
-        @app.route("/list_themes")
-        def list_themes():
-            """List available theme presets."""
-            from ..styles._style_loader import list_presets
-
-            presets = list_presets()
-            current = editor.get_effective_style().get("_name", "SCITEX")
-
-            return jsonify(
-                {
-                    "themes": presets,
-                    "current": current,
-                }
-            )
-
-        @app.route("/switch_theme", methods=["POST"])
-        def switch_theme():
-            """Switch to a different theme preset by reproducing the figure."""
-            from .._reproducer import reproduce_from_record
-            from ..styles._style_loader import load_preset
-
-            data = request.get_json() or {}
-            theme_name = data.get("theme")
-
-            if not theme_name:
-                return jsonify({"error": "No theme specified"}), 400
-
-            try:
-                # Load the new preset
-                new_style = load_preset(theme_name)
-
-                if new_style is None:
-                    return jsonify({"error": f"Theme '{theme_name}' not found"}), 404
-
-                # Update the base style
-                editor.style_overrides.base_style = dict(new_style)
-                editor.style_overrides.base_style["_name"] = theme_name
-
-                # Reproduce the figure from the record
-                if hasattr(editor.fig, "record") and editor.fig.record is not None:
-                    # Update the record's style to use new theme
-                    old_style = editor.fig.record.style
-                    editor.fig.record.style = dict(new_style)
-
-                    # Reproduce figure with new style
-                    new_fig, new_ax = reproduce_from_record(editor.fig.record)
-                    editor.fig = new_fig
-
-                    # Restore original style in record for future reference
-                    editor.fig.record.style = old_style
-
-                # Apply behavior settings from new theme directly to figure
-                mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-                behavior = new_style.get("behavior", {})
-                for ax in mpl_fig.get_axes():
-                    # Apply spine visibility
-                    hide_top = behavior.get("hide_top_spine", True)
-                    hide_right = behavior.get("hide_right_spine", True)
-                    ax.spines["top"].set_visible(not hide_top)
-                    ax.spines["right"].set_visible(not hide_right)
-
-                    # Apply grid setting
-                    if behavior.get("grid", False):
-                        ax.grid(True, alpha=0.3)
-                    else:
-                        ax.grid(False)
-
-                # Re-render with new theme
-                base64_img, bboxes, img_size = _render_with_overrides(
-                    editor.fig,
-                    editor.get_effective_style(),
-                    editor.dark_mode,
-                )
-
-                # Get updated form values from new style
-                form_values = _get_form_values_from_style(editor.get_effective_style())
-
-                return jsonify(
-                    {
-                        "success": True,
-                        "theme": theme_name,
-                        "image": base64_img,
-                        "bboxes": bboxes,
-                        "img_size": {"width": img_size[0], "height": img_size[1]},
-                        "values": form_values,
-                    }
-                )
-
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                return jsonify({"error": f"Failed to switch theme: {str(e)}"}), 500
-
-        @app.route("/save", methods=["POST"])
-        def save():
-            """Save style overrides (stored separately from recipe)."""
-            data = request.get_json() or {}
-            editor.style_overrides.update_manual_overrides(data.get("overrides", {}))
-
-            # Save to .overrides.json file
-            if editor.recipe_path:
-                path = save_overrides(editor.style_overrides, editor.recipe_path)
-                return jsonify(
-                    {
-                        "success": True,
-                        "path": str(path),
-                        "has_overrides": editor.style_overrides.has_manual_overrides(),
-                        "timestamp": editor.style_overrides.manual_timestamp,
-                    }
-                )
-
-            return jsonify(
-                {
-                    "success": True,
-                    "overrides": editor.overrides,
-                    "has_overrides": editor.style_overrides.has_manual_overrides(),
-                }
-            )
-
-        @app.route("/restore", methods=["POST"])
-        def restore():
-            """Restore to original style (clear manual overrides)."""
-            editor.style_overrides.clear_manual_overrides()
-
-            # Use pre-rendered static PNG (source of truth)
-            if editor._initial_base64 and not editor.dark_mode:
-                base64_img = editor._initial_base64
-                import base64 as b64
-                import io
-
-                from PIL import Image
-
-                img_data = b64.b64decode(base64_img)
-                img = Image.open(io.BytesIO(img_data))
-                img_size = img.size
-                mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-                original_dpi = mpl_fig.dpi
-                mpl_fig.set_dpi(150)
-                mpl_fig.canvas.draw()
-                bboxes = extract_bboxes(mpl_fig, img_size[0], img_size[1])
-                mpl_fig.set_dpi(original_dpi)
-            else:
-                # Fallback: re-render with reproduce pipeline
-                base64_img, bboxes, img_size = _render_with_overrides(
-                    editor.fig,
-                    None,
-                    editor.dark_mode,
-                )
-
-            return jsonify(
-                {
-                    "success": True,
-                    "image": base64_img,
-                    "bboxes": bboxes,
-                    "img_size": {"width": img_size[0], "height": img_size[1]},
-                    "original_style": editor.style,
-                }
-            )
-
-        @app.route("/diff")
-        def get_diff():
-            """Get differences between original and manual overrides."""
-            return jsonify(
-                {
-                    "diff": editor.style_overrides.get_diff(),
-                    "has_overrides": editor.style_overrides.has_manual_overrides(),
-                }
-            )
-
-        @app.route("/update_label", methods=["POST"])
-        def update_label():
-            """Update axis labels (title, xlabel, ylabel, suptitle).
-
-            These are editable text elements that don't affect data integrity.
-            """
-            data = request.get_json() or {}
-            label_type = data.get("label_type")  # title, xlabel, ylabel, suptitle
-            text = data.get("text", "")
-            ax_index = data.get("ax_index", 0)  # For multi-axes figures
-
-            if not label_type:
-                return jsonify({"error": "Missing label_type"}), 400
-
-            # Get the underlying matplotlib figure
-            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-            axes = mpl_fig.get_axes()
-
-            if not axes:
-                return jsonify({"error": "No axes found"}), 400
-
-            # Get target axes (default to first)
-            ax = axes[min(ax_index, len(axes) - 1)]
-
-            try:
-                if label_type == "title":
-                    ax.set_title(text)
-                elif label_type == "xlabel":
-                    ax.set_xlabel(text)
-                elif label_type == "ylabel":
-                    ax.set_ylabel(text)
-                elif label_type == "suptitle":
-                    if text:
-                        mpl_fig.suptitle(text)
-                    else:
-                        # Clear suptitle by setting to empty string
-                        if mpl_fig._suptitle:
-                            mpl_fig._suptitle.set_text("")
-                else:
-                    return jsonify({"error": f"Unknown label_type: {label_type}"}), 400
-
-                # Track override
-                editor.style_overrides.manual_overrides[f"label_{label_type}"] = text
-
-                # Re-render
-                base64_img, bboxes, img_size = _render_with_overrides(
-                    editor.fig,
-                    editor.get_effective_style(),
-                    editor.dark_mode,
-                )
-
-                return jsonify(
-                    {
-                        "success": True,
-                        "image": base64_img,
-                        "bboxes": bboxes,
-                        "img_size": {"width": img_size[0], "height": img_size[1]},
-                    }
-                )
-
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                return jsonify({"error": f"Update failed: {str(e)}"}), 500
-
-        @app.route("/get_labels")
-        def get_labels():
-            """Get current axis labels (title, xlabel, ylabel, suptitle)."""
-            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-            axes = mpl_fig.get_axes()
-
-            labels = {
-                "title": "",
-                "xlabel": "",
-                "ylabel": "",
-                "suptitle": "",
-            }
-
-            if axes:
-                ax = axes[0]  # Use first axes for now
-                labels["title"] = ax.get_title()
-                labels["xlabel"] = ax.get_xlabel()
-                labels["ylabel"] = ax.get_ylabel()
-
-            if mpl_fig._suptitle:
-                labels["suptitle"] = mpl_fig._suptitle.get_text()
-
-            return jsonify(labels)
-
-        @app.route("/update_axis_type", methods=["POST"])
-        def update_axis_type():
-            """Update axis type (numerical vs categorical).
-
-            Numerical: linear scale with auto ticks
-            Categorical: discrete labels at integer positions
-            """
-            data = request.get_json() or {}
-            axis = data.get("axis")  # "x" or "y"
-            axis_type = data.get("type")  # "numerical" or "categorical"
-            labels = data.get("labels", [])  # For categorical: list of labels
-            ax_index = data.get("ax_index", 0)
-
-            if not axis or not axis_type:
-                return jsonify({"error": "Missing axis or type"}), 400
-
-            # Get the underlying matplotlib figure
-            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-            axes_list = mpl_fig.get_axes()
-
-            if not axes_list:
-                return jsonify({"error": "No axes found"}), 400
-
-            ax = axes_list[min(ax_index, len(axes_list) - 1)]
-
-            try:
-                if axis == "x":
-                    if axis_type == "categorical" and labels:
-                        # Set categorical x-axis
-                        positions = list(range(len(labels)))
-                        ax.set_xticks(positions)
-                        ax.set_xticklabels(labels)
-                    else:
-                        # Reset to numerical
-                        ax.xaxis.set_major_locator(matplotlib.ticker.AutoLocator())
-                        ax.xaxis.set_major_formatter(
-                            matplotlib.ticker.ScalarFormatter()
-                        )
-                elif axis == "y":
-                    if axis_type == "categorical" and labels:
-                        # Set categorical y-axis
-                        positions = list(range(len(labels)))
-                        ax.set_yticks(positions)
-                        ax.set_yticklabels(labels)
-                    else:
-                        # Reset to numerical
-                        ax.yaxis.set_major_locator(matplotlib.ticker.AutoLocator())
-                        ax.yaxis.set_major_formatter(
-                            matplotlib.ticker.ScalarFormatter()
-                        )
-
-                # Track override
-                key = f"axis_{axis}_type"
-                editor.style_overrides.manual_overrides[key] = axis_type
-                if labels:
-                    editor.style_overrides.manual_overrides[f"axis_{axis}_labels"] = (
-                        labels
-                    )
-
-                # Re-render
-                base64_img, bboxes, img_size = _render_with_overrides(
-                    editor.fig,
-                    editor.get_effective_style(),
-                    editor.dark_mode,
-                )
-
-                return jsonify(
-                    {
-                        "success": True,
-                        "image": base64_img,
-                        "bboxes": bboxes,
-                        "img_size": {"width": img_size[0], "height": img_size[1]},
-                    }
-                )
-
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                return jsonify({"error": f"Update failed: {str(e)}"}), 500
-
-        @app.route("/get_axis_info")
-        def get_axis_info():
-            """Get current axis type info (numerical vs categorical)."""
-            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-            axes_list = mpl_fig.get_axes()
-
-            info = {
-                "x_type": "numerical",
-                "y_type": "numerical",
-                "x_labels": [],
-                "y_labels": [],
-            }
-
-            if axes_list:
-                ax = axes_list[0]
-
-                # Check if x-axis has custom tick labels
-                x_ticklabels = [t.get_text() for t in ax.get_xticklabels()]
-                if x_ticklabels and any(t for t in x_ticklabels):
-                    info["x_type"] = "categorical"
-                    info["x_labels"] = x_ticklabels
-
-                # Check if y-axis has custom tick labels
-                y_ticklabels = [t.get_text() for t in ax.get_yticklabels()]
-                if y_ticklabels and any(t for t in y_ticklabels):
-                    info["y_type"] = "categorical"
-                    info["y_labels"] = y_ticklabels
-
-            return jsonify(info)
-
-        @app.route("/update_legend_position", methods=["POST"])
-        def update_legend_position():
-            """Update legend position, visibility, or custom xy coordinates.
-
-            For custom positioning, uses bbox_to_anchor with axes coordinates.
-            """
-            data = request.get_json() or {}
-            loc = data.get("loc")  # 'best', 'upper right', 'custom', etc.
-            x = data.get("x")  # For custom: 0-1+ (axes coordinates)
-            y = data.get("y")  # For custom: 0-1+ (axes coordinates)
-            visible = data.get("visible")  # True/False for show/hide
-            ax_index = data.get("ax_index", 0)
-
-            # Get the underlying matplotlib figure
-            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-            axes_list = mpl_fig.get_axes()
-
-            if not axes_list:
-                return jsonify({"error": "No axes found"}), 400
-
-            ax = axes_list[min(ax_index, len(axes_list) - 1)]
-            legend = ax.get_legend()
-
-            if legend is None:
-                return jsonify({"error": "No legend found on this axes"}), 400
-
-            try:
-                # Handle visibility toggle
-                if visible is not None:
-                    legend.set_visible(visible)
-                    editor.style_overrides.manual_overrides["legend_visible"] = visible
-
-                # Handle position update only if loc is provided
-                if loc is not None:
-                    if loc == "custom" and x is not None and y is not None:
-                        # Custom positioning with bbox_to_anchor
-                        legend.set_bbox_to_anchor((float(x), float(y)))
-                        legend._loc = 2  # upper left as reference point
-                    else:
-                        # Standard location string
-                        loc_map = {
-                            "best": 0,
-                            "upper right": 1,
-                            "upper left": 2,
-                            "lower left": 3,
-                            "lower right": 4,
-                            "right": 5,
-                            "center left": 6,
-                            "center right": 7,
-                            "lower center": 8,
-                            "upper center": 9,
-                            "center": 10,
-                        }
-                        loc_code = loc_map.get(loc, 0)
-                        legend._loc = loc_code
-                        # Clear bbox_to_anchor when using standard loc
-                        legend.set_bbox_to_anchor(None)
-
-                    # Track override
-                    editor.style_overrides.manual_overrides["legend_loc"] = loc
-                    if loc == "custom":
-                        editor.style_overrides.manual_overrides["legend_x"] = x
-                        editor.style_overrides.manual_overrides["legend_y"] = y
-
-                # Re-render
-                base64_img, bboxes, img_size = _render_with_overrides(
-                    editor.fig,
-                    editor.get_effective_style(),
-                    editor.dark_mode,
-                )
-
-                return jsonify(
-                    {
-                        "success": True,
-                        "image": base64_img,
-                        "bboxes": bboxes,
-                        "img_size": {"width": img_size[0], "height": img_size[1]},
-                    }
-                )
-
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                return jsonify({"error": f"Update failed: {str(e)}"}), 500
-
-        @app.route("/get_legend_info")
-        def get_legend_info():
-            """Get current legend position info."""
-            mpl_fig = editor.fig.fig if hasattr(editor.fig, "fig") else editor.fig
-            axes_list = mpl_fig.get_axes()
-
-            info = {
-                "has_legend": False,
-                "visible": True,
-                "loc": "best",
-                "x": None,
-                "y": None,
-            }
-
-            if axes_list:
-                ax = axes_list[0]
-                legend = ax.get_legend()
-
-                if legend is not None:
-                    info["has_legend"] = True
-                    info["visible"] = legend.get_visible()
-
-                    # Get location code and convert to string
-                    loc_code = legend._loc
-                    loc_names = {
-                        0: "best",
-                        1: "upper right",
-                        2: "upper left",
-                        3: "lower left",
-                        4: "lower right",
-                        5: "right",
-                        6: "center left",
-                        7: "center right",
-                        8: "lower center",
-                        9: "upper center",
-                        10: "center",
-                    }
-                    info["loc"] = loc_names.get(loc_code, "best")
-
-                    # Check for bbox_to_anchor (custom position)
-                    bbox = legend.get_bbox_to_anchor()
-                    if bbox is not None:
-                        # Get coordinates from bbox
-                        try:
-                            bounds = bbox.bounds
-                            if bounds[0] != 0 or bounds[1] != 0:
-                                info["loc"] = "custom"
-                                info["x"] = bounds[0]
-                                info["y"] = bounds[1]
-                        except Exception:
-                            pass
-
-            return jsonify(info)
-
-        @app.route("/update_call", methods=["POST"])
-        def update_call():
-            """Update a call's kwargs and re-render.
-
-            Only display kwargs are editable (orientation, colors, etc.).
-            Data (x, y arrays) remains read-only for scientific integrity.
-            """
-            from .._reproducer import reproduce_from_record
-
-            data = request.get_json() or {}
-            call_id = data.get("call_id")
-            param = data.get("param")
-            value = data.get("value")
-
-            if not call_id or not param:
-                return jsonify({"error": "Missing call_id or param"}), 400
-
-            # Find and update the call in the record
-            updated = False
-            if hasattr(editor.fig, "record"):
-                for ax_key, ax_record in editor.fig.record.axes.items():
-                    for call in ax_record.calls:
-                        if call.id == call_id:
-                            # Track the override in style_overrides
-                            editor.style_overrides.set_call_override(
-                                call_id, param, value
-                            )
-
-                            # Update the kwarg in the record
-                            if value is None or value == "" or value == "null":
-                                call.kwargs.pop(param, None)
-                            else:
-                                call.kwargs[param] = value
-                            updated = True
-                            break
-                    if updated:
-                        break
-
-            if not updated:
-                return jsonify({"error": f"Call {call_id} not found"}), 404
-
-            # Re-reproduce the figure from the updated record
-            try:
-                new_fig, new_axes = reproduce_from_record(editor.fig.record)
-
-                # Apply style overrides to the new figure
-                effective_style = editor.get_effective_style()
-                base64_img, bboxes, img_size = _render_with_overrides(
-                    new_fig,
-                    effective_style if effective_style else None,
-                    editor.dark_mode,
-                )
-
-                # Update editor's figure reference
-                editor.fig = new_fig
-
-                # Reload hitmap and color map
-                from ._hitmap import hitmap_to_base64
-
-                hitmap_img, color_map = generate_hitmap(
-                    new_fig, img_size[0], img_size[1]
-                )
-                editor._color_map = color_map
-                editor._hitmap_base64 = hitmap_to_base64(hitmap_img)
-                editor._hitmap_generated = True
-
-            except Exception as e:
-                import traceback
-
-                traceback.print_exc()
-                return jsonify({"error": f"Re-render failed: {str(e)}"}), 500
-
-            return jsonify(
-                {
-                    "success": True,
-                    "image": base64_img,
-                    "bboxes": bboxes,
-                    "img_size": {"width": img_size[0], "height": img_size[1]},
-                    "call_id": call_id,
-                    "param": param,
-                    "value": value,
-                    "has_call_overrides": editor.style_overrides.has_call_overrides(),
-                }
-            )
+        # Create Flask app with static folder for assets (click sounds, etc.)
+        static_folder = Path(__file__).parent / "static"
+        app = Flask(
+            __name__, static_folder=str(static_folder), static_url_path="/static"
+        )
 
-        @app.route("/download/<fmt>")
-        def download(fmt: str):
-            """Download figure in specified format.
-
-            Note: Downloads always use light mode for scientific document compatibility.
-            Transparent backgrounds are preserved.
-            """
-            import io
-
-            fmt = fmt.lower()
-            if fmt not in ("png", "svg", "pdf"):
-                return jsonify({"error": f"Unsupported format: {fmt}"}), 400
-
-            # Use effective style (base + programmatic + manual)
-            effective_style = editor.get_effective_style()
-            # Always use light mode for scientific documents (dark_mode=False)
-            content = render_download(
-                editor.fig,
-                fmt=fmt,
-                dpi=300,
-                overrides=effective_style if effective_style else None,
-                dark_mode=False,  # Scientific documents require light mode
-            )
+        # Register all routes
+        register_core_routes(app, self)
+        register_file_routes(app, self)
+        register_style_routes(app, self)
+        register_axis_routes(app, self)
+        register_element_routes(app, self)
+        register_image_routes(app, self)
+        register_datatable_routes(app, self)
+        register_annotation_routes(app, self)
+        register_caption_routes(app, self)
+        # DISABLED: register_snapshot_routes(app, self)
 
-            mimetype = {
-                "png": "image/png",
-                "svg": "image/svg+xml",
-                "pdf": "application/pdf",
-            }[fmt]
-
-            filename = f"figure.{fmt}"
-            if editor.recipe_path:
-                filename = f"{editor.recipe_path.stem}.{fmt}"
-
-            return send_file(
-                io.BytesIO(content),
-                mimetype=mimetype,
-                as_attachment=True,
-                download_name=filename,
-            )
+        # Start server
+        url = f"http://{self.host}:{self.port}"
 
-        @app.route("/shutdown", methods=["POST"])
-        def shutdown():
-            """Shutdown the server."""
-            func = request.environ.get("werkzeug.server.shutdown")
-            if func:
-                func()
-            return jsonify({"success": True})
+        if self.desktop:
+            # Desktop mode using pywebview
+            return self._run_desktop(app, url)
+        else:
+            # Browser mode
+            return self._run_browser(app, url, open_browser)
 
-        # Start server
-        url = f"http://127.0.0.1:{self.port}"
+    def _run_browser(self, app, url: str, open_browser: bool) -> Dict[str, Any]:
+        """Run editor in browser mode."""
         print(f"Figure Editor running at {url}")
+
+        if self.hot_reload:
+            print("Hot reload ENABLED - server will restart on source file changes")
         print("Press Ctrl+C to stop and return overrides")
 
         if open_browser:
             webbrowser.open(url)
 
         try:
-            app.run(host="127.0.0.1", port=self.port, debug=False, use_reloader=False)
+            app.run(
+                host=self.host,
+                port=self.port,
+                debug=False,
+                use_reloader=False,
+                threaded=True,
+            )
         except KeyboardInterrupt:
             print("\nEditor closed")
 
         return self.overrides
 
+    def _run_desktop(self, app, url: str) -> Dict[str, Any]:
+        """Run editor as native desktop window using pywebview."""
+        try:
+            import webview
+        except ImportError:
+            raise ImportError(
+                "pywebview is required for desktop mode. "
+                "Install with: pip install figrecipe[desktop]"
+            )
 
-def _get_form_values_from_style(style: Dict[str, Any]) -> Dict[str, Any]:
-    """Extract form field values from a style dictionary.
+        import threading
 
-    Maps style dictionary values to HTML form input IDs.
+        print("Figure Editor (Desktop Mode)")
+        print("Close the window to stop and return overrides")
 
-    Parameters
-    ----------
-    style : dict
-        Style configuration dictionary
+        # Start Flask in a background thread
+        def run_flask():
+            import logging
 
-    Returns
-    -------
-    dict
-        Mapping of form input IDs to values
-    """
-    values = {}
-
-    # Axes dimensions
-    if "axes" in style:
-        values["axes_width_mm"] = style["axes"].get("width_mm", 80)
-        values["axes_height_mm"] = style["axes"].get("height_mm", 55)
-        values["axes_thickness_mm"] = style["axes"].get("thickness_mm", 0.2)
-
-    # Margins
-    if "margins" in style:
-        values["margins_left_mm"] = style["margins"].get("left_mm", 12)
-        values["margins_right_mm"] = style["margins"].get("right_mm", 3)
-        values["margins_bottom_mm"] = style["margins"].get("bottom_mm", 10)
-        values["margins_top_mm"] = style["margins"].get("top_mm", 3)
-
-    # Spacing
-    if "spacing" in style:
-        values["spacing_horizontal_mm"] = style["spacing"].get("horizontal_mm", 8)
-        values["spacing_vertical_mm"] = style["spacing"].get("vertical_mm", 8)
-
-    # Fonts
-    if "fonts" in style:
-        values["fonts_family"] = style["fonts"].get("family", "Arial")
-        values["fonts_axis_label_pt"] = style["fonts"].get("axis_label_pt", 7)
-        values["fonts_tick_label_pt"] = style["fonts"].get("tick_label_pt", 6)
-        values["fonts_title_pt"] = style["fonts"].get("title_pt", 8)
-        values["fonts_legend_pt"] = style["fonts"].get("legend_pt", 6)
-
-    # Ticks
-    if "ticks" in style:
-        values["ticks_length_mm"] = style["ticks"].get("length_mm", 1.0)
-        values["ticks_thickness_mm"] = style["ticks"].get("thickness_mm", 0.2)
-        values["ticks_direction"] = style["ticks"].get("direction", "out")
-
-    # Lines
-    if "lines" in style:
-        values["lines_trace_mm"] = style["lines"].get("trace_mm", 0.2)
-
-    # Markers
-    if "markers" in style:
-        values["markers_size_mm"] = style["markers"].get("size_mm", 0.8)
-
-    # Output
-    if "output" in style:
-        values["output_dpi"] = style["output"].get("dpi", 300)
-
-    # Behavior
-    if "behavior" in style:
-        values["behavior_hide_top_spine"] = style["behavior"].get(
-            "hide_top_spine", True
-        )
-        values["behavior_hide_right_spine"] = style["behavior"].get(
-            "hide_right_spine", True
-        )
-        values["behavior_grid"] = style["behavior"].get("grid", False)
-
-    # Legend
-    if "legend" in style:
-        values["legend_frameon"] = style["legend"].get("frameon", True)
+            # Suppress Flask logging in desktop mode
+            log = logging.getLogger("werkzeug")
+            log.setLevel(logging.ERROR)
+            app.run(
+                host=self.host,
+                port=self.port,
+                debug=False,
+                use_reloader=False,
+                threaded=True,
+            )
 
-    return values
+        flask_thread = threading.Thread(target=run_flask, daemon=True)
+        flask_thread.start()
 
+        # Wait briefly for Flask to start
+        import time
 
-def _render_with_overrides(
-    fig, overrides: Optional[Dict[str, Any]], dark_mode: bool = False
-):
-    """
-    Re-render figure with overrides applied directly.
+        time.sleep(0.5)
 
-    Applies style overrides directly to the existing figure for reliable rendering.
-    """
-    import base64
-    import io
-    import warnings
-
-    from matplotlib.backends.backend_agg import FigureCanvasAgg
-    from PIL import Image
-
-    from ._bbox import extract_bboxes
-    from ._renderer import _apply_dark_mode, _apply_overrides
-
-    # Get the underlying matplotlib figure
-    new_fig = fig.fig if hasattr(fig, "fig") else fig
-
-    # Safety check: validate figure size before rendering
-    fig_width, fig_height = new_fig.get_size_inches()
-    dpi = 150
-    pixel_width = fig_width * dpi
-    pixel_height = fig_height * dpi
-
-    # Sanity check: prevent enormous figures (max 10000x10000 pixels)
-    MAX_PIXELS = 10000
-    if pixel_width > MAX_PIXELS or pixel_height > MAX_PIXELS:
-        # Reset to reasonable size
-        new_fig.set_size_inches(
-            min(fig_width, MAX_PIXELS / dpi), min(fig_height, MAX_PIXELS / dpi)
+        # Create native window (variable needed for pywebview lifecycle)
+        _window = webview.create_window(
+            title="FigRecipe Editor",
+            url=url,
+            width=1400,
+            height=900,
+            resizable=True,
+            min_size=(800, 600),
         )
 
-    # Switch to Agg backend to avoid Tkinter thread issues
-    new_fig.set_canvas(FigureCanvasAgg(new_fig))
-
-    # Disable constrained_layout if present (can cause rendering issues on repeated calls)
-    # Store original state to restore later
-    layout_engine = new_fig.get_layout_engine()
-    if layout_engine is not None and hasattr(layout_engine, "__class__"):
-        layout_name = layout_engine.__class__.__name__
-        if "Constrained" in layout_name:
-            new_fig.set_layout_engine("none")
-
-    # Apply overrides directly to existing figure
-    if overrides:
-        _apply_overrides(new_fig, overrides)
-
-    # Apply dark mode if requested
-    if dark_mode:
-        _apply_dark_mode(new_fig)
-
-    # Validate axes bounds before rendering (prevent infinite/invalid extents)
-    for ax in new_fig.get_axes():
-        xlim = ax.get_xlim()
-        ylim = ax.get_ylim()
-        # Check for invalid limits (inf, nan, or extremely large)
-        if any(not (-1e10 < v < 1e10) for v in xlim + ylim):
-            ax.set_xlim(-1, 1)
-            ax.set_ylim(-1, 1)
-
-    # Save to PNG using same params as static save
-    # Catch constrained_layout warnings and handle gracefully
-    buf = io.BytesIO()
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", "constrained_layout not applied")
-        try:
-            new_fig.savefig(buf, format="png", dpi=150, bbox_inches="tight")
-        except (MemoryError, ValueError):
-            # Fall back to saving without bbox_inches="tight"
-            buf = io.BytesIO()
-            new_fig.savefig(buf, format="png", dpi=150)
-    buf.seek(0)
-    png_bytes = buf.read()
-    base64_str = base64.b64encode(png_bytes).decode("utf-8")
-
-    # Get image size
-    buf.seek(0)
-    img = Image.open(buf)
-    img_size = img.size
-
-    # Extract bboxes
-    original_dpi = new_fig.dpi
-    new_fig.set_dpi(150)
-    new_fig.canvas.draw()
-    bboxes = extract_bboxes(new_fig, img_size[0], img_size[1])
-    new_fig.set_dpi(original_dpi)
-
-    return base64_str, bboxes, img_size
+        # Start webview (blocks until window is closed)
+        webview.start()
+
+        print("\nEditor closed")
+        return self.overrides
 
 
 __all__ = ["FigureEditor"]