scitex 2.7.3__py3-none-any.whl → 2.8.1__py3-none-any.whl

scitex/fig/editor/flask_editor/_core.py

@@ -92,9 +92,193 @@ class WebEditor:
             print(f"Warning: Port {self._requested_port} may still be in use")
             self.port = self._requested_port
 
-        app = Flask(__name__)
+        # Configure Flask with static folder path
+        import os
+        static_folder = os.path.join(os.path.dirname(__file__), 'static')
+        app = Flask(__name__, static_folder=static_folder, static_url_path='/static')
         editor = self
 
+        def _export_composed_figure(editor, formats=["png", "svg"], dpi=150):
+            """Helper to compose and export figure to bundle."""
+            from scitex.io import ZipBundle
+            from PIL import Image
+            import numpy as np
+            import matplotlib
+            matplotlib.use('Agg')
+            import matplotlib.pyplot as plt
+            import json as json_module
+            import io
+            import zipfile
+
+            if not editor.panel_info:
+                return {"success": False, "error": "No panel info"}
+
+            bundle_path = editor.panel_info.get("bundle_path")
+            figz_dir = editor.panel_info.get("figz_dir")
+
+            if not bundle_path and not figz_dir:
+                return {"success": False, "error": "No bundle path"}
+
+            figure_name = Path(bundle_path).stem if bundle_path else (
+                Path(figz_dir).stem.replace(".figz.d", "") if figz_dir else "figure"
+            )
+
+            # Read spec.json for layout and layout.json for position overrides
+            spec = {}
+            layout_overrides = {}
+            if bundle_path:
+                try:
+                    with ZipBundle(bundle_path, mode="r") as bundle:
+                        spec = bundle.read_json("spec.json")
+                        try:
+                            layout_overrides = bundle.read_json("layout.json")
+                        except:
+                            pass
+                except:
+                    pass
+            elif figz_dir:
+                spec_path = Path(figz_dir) / "spec.json"
+                if spec_path.exists():
+                    with open(spec_path) as f:
+                        spec = json_module.load(f)
+                layout_path = Path(figz_dir) / "layout.json"
+                if layout_path.exists():
+                    with open(layout_path) as f:
+                        layout_overrides = json_module.load(f)
+
+            # Also check in-memory layout overrides
+            if editor.panel_info and editor.panel_info.get("layout"):
+                layout_overrides = editor.panel_info.get("layout", {})
+
+            # Get figure dimensions
+            fig_width_mm = 180
+            fig_height_mm = 120
+            if "figure" in spec:
+                fig_info = spec.get("figure", {})
+                styles = fig_info.get("styles", {})
+                size = styles.get("size", {})
+                fig_width_mm = size.get("width_mm", 180)
+                fig_height_mm = size.get("height_mm", 120)
+
+            fig_width_in = fig_width_mm / 25.4
+            fig_height_in = fig_height_mm / 25.4
+
+            fig = plt.figure(figsize=(fig_width_in, fig_height_in), dpi=dpi, facecolor='white')
+
+            # Compose panels
+            panels_spec = spec.get("panels", [])
+            panel_paths = editor.panel_info.get("panel_paths", [])
+            panel_is_zip = editor.panel_info.get("panel_is_zip", [])
+
+            for panel_spec in panels_spec:
+                panel_id = panel_spec.get("id", "")
+                pos = panel_spec.get("position", {})
+                size = panel_spec.get("size", {})
+
+                # Skip overview/auxiliary panels (only compose main panels A-Z)
+                panel_id_lower = panel_id.lower()
+                if any(skip in panel_id_lower for skip in ['overview', 'thumb', 'preview', 'aux']):
+                    continue
+
+                # Find panel path first (needed to check layout_overrides)
+                panel_path = None
+                is_zip = False
+                panel_name = None
+                for idx, pp in enumerate(panel_paths):
+                    pp_name = Path(pp).stem.replace(".pltz", "")
+                    if (pp_name == panel_id or
+                        pp_name.startswith(f"panel_{panel_id}_") or
+                        pp_name == f"panel_{panel_id}" or
+                        f"_{panel_id}_" in pp_name):
+                        panel_path = pp
+                        panel_name = Path(pp).name  # e.g., "panel_A_twinx.pltz"
+                        is_zip = panel_is_zip[idx] if idx < len(panel_is_zip) else False
+                        break
+
+                if not panel_path:
+                    continue
+
+                # Check for layout overrides (from layout.json or in-memory)
+                override = layout_overrides.get(panel_name, {})
+                override_pos = override.get("position", {})
+                override_size = override.get("size", {})
+
+                # Use override positions if available, otherwise use spec
+                x_mm = override_pos.get("x_mm", pos.get("x_mm", 0))
+                y_mm = override_pos.get("y_mm", pos.get("y_mm", 0))
+                w_mm = override_size.get("width_mm", size.get("width_mm", 60))
+                h_mm = override_size.get("height_mm", size.get("height_mm", 40))
+
+                x_frac = x_mm / fig_width_mm
+                y_frac = 1 - (y_mm + h_mm) / fig_height_mm
+                w_frac = w_mm / fig_width_mm
+                h_frac = h_mm / fig_height_mm
+
+                # Load panel preview
+                try:
+                    # Exclusion patterns for preview selection
+                    exclude_patterns = ['hitmap', 'overview', 'thumb', 'preview']
+
+                    if is_zip:
+                        with ZipBundle(panel_path, mode="r") as pltz_bundle:
+                            with zipfile.ZipFile(panel_path, 'r') as zf:
+                                png_files = [n for n in zf.namelist()
+                                            if n.endswith('.png')
+                                            and 'exports/' in n
+                                            and not any(p in n.lower() for p in exclude_patterns)]
+                                if png_files:
+                                    preview_path = png_files[0]
+                                    if '.pltz.d/' in preview_path:
+                                        preview_path = preview_path.split('.pltz.d/')[-1]
+                                    img_data = pltz_bundle.read_bytes(preview_path)
+                                    img = Image.open(io.BytesIO(img_data))
+                                    ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                                    ax.imshow(np.array(img))
+                                    ax.axis('off')
+                    else:
+                        pltz_dir = Path(panel_path)
+                        exports_dir = pltz_dir / "exports"
+                        if exports_dir.exists():
+                            for png_file in exports_dir.glob("*.png"):
+                                name_lower = png_file.name.lower()
+                                if not any(p in name_lower for p in exclude_patterns):
+                                    img = Image.open(png_file)
+                                    ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                                    ax.imshow(np.array(img))
+                                    ax.axis('off')
+                                    break
+                except Exception as e:
+                    print(f"Could not load panel {panel_id}: {e}")
+
+                # Draw panel letter
+                if panel_id and len(panel_id) <= 2:  # Only for short IDs like A, B, C...
+                    # Position letter at top-left corner of panel
+                    letter_x = x_frac + 0.01
+                    letter_y = y_frac + h_frac - 0.02
+                    fig.text(letter_x, letter_y, panel_id,
+                            fontsize=14, fontweight='bold', color='black',
+                            ha='left', va='top',
+                            transform=fig.transFigure,
+                            bbox=dict(boxstyle='square,pad=0.1',
+                                     facecolor='white', edgecolor='none', alpha=0.8))
+
+            exported = {}
+
+            # Save to bundle
+            if bundle_path:
+                with ZipBundle(bundle_path, mode="a") as bundle:
+                    for fmt in formats:
+                        buf = io.BytesIO()
+                        fig.savefig(buf, format=fmt, dpi=dpi, bbox_inches="tight",
+                                   facecolor="white", pad_inches=0.02)
+                        buf.seek(0)
+                        export_path = f"exports/{figure_name}.{fmt}"
+                        bundle.write_bytes(export_path, buf.read())
+                        exported[fmt] = export_path
+
+            plt.close(fig)
+            return {"success": True, "exported": exported}
+
         @app.route("/")
         def index():
             # Rebuild template each time for hot reload support
@@ -147,63 +331,94 @@ class WebEditor:
 
         @app.route("/panels")
         def panels():
-            """Return all panel images with bboxes for interactive grid view (figz bundles only)."""
-            from PIL import Image
+            """Return all panel images with bboxes for interactive grid view (figz bundles only).
+
+            Uses smart load_panel_data helper for transparent zip/directory handling.
+            Returns layout info from figz spec.json for unified canvas positioning.
+            """
             from ._bbox import extract_bboxes_from_metadata, extract_bboxes_from_geometry_px
+            from ..edit import load_panel_data
+            import json as json_module
 
             if not editor.panel_info:
                 return jsonify({"error": "Not a multi-panel figz bundle"}), 400
 
-            figz_dir = Path(editor.panel_info["figz_dir"])
             panel_names = editor.panel_info["panels"]
+            panel_paths = editor.panel_info.get("panel_paths", [])
+            panel_is_zip = editor.panel_info.get("panel_is_zip", [False] * len(panel_names))
+            figz_dir = Path(editor.panel_info["figz_dir"])
+
+            if not panel_paths:
+                panel_paths = [str(figz_dir / name) for name in panel_names]
+
+            # Load figz spec.json to get panel layout
+            figz_layout = {}
+            spec_path = figz_dir / "spec.json"
+            if spec_path.exists():
+                with open(spec_path) as f:
+                    figz_spec = json_module.load(f)
+                    for panel_spec in figz_spec.get("panels", []):
+                        panel_id = panel_spec.get("id", "")
+                        figz_layout[panel_id] = {
+                            "position": panel_spec.get("position", {}),
+                            "size": panel_spec.get("size", {}),
+                        }
+
             panel_images = []
 
-            for panel_name in panel_names:
-                panel_dir = figz_dir / panel_name
-                panel_data = {"name": panel_name.replace(".pltz.d", ""), "image": None, "bboxes": None, "img_size": None}
-
-                # Find PNG in exports/ or root
-                png_path = None
-                exports_dir = panel_dir / "exports"
-                if exports_dir.exists():
-                    for f in exports_dir.glob("*.png"):
-                        if "_hitmap" not in f.name and "_overview" not in f.name:
-                            png_path = f
-                            break
-                if not png_path:
-                    for f in panel_dir.glob("*.png"):
-                        if "_hitmap" not in f.name and "_overview" not in f.name:
-                            png_path = f
-                            break
-
-                if png_path and png_path.exists():
-                    with open(png_path, "rb") as f:
-                        panel_data["image"] = base64.b64encode(f.read()).decode("utf-8")
-                    img = Image.open(png_path)
-                    panel_data["width"], panel_data["height"] = img.size
-                    panel_data["img_size"] = {"width": img.size[0], "height": img.size[1]}
-                    img.close()
+            for idx, panel_name in enumerate(panel_names):
+                panel_path = panel_paths[idx]
+                is_zip = panel_is_zip[idx] if idx < len(panel_is_zip) else None
+                display_name = panel_name.replace(".pltz.d", "").replace(".pltz", "")
 
-                    # Try to load geometry_px.json from cache (has precise pixel coordinates)
-                    geometry_path = panel_dir / "cache" / "geometry_px.json"
-                    if geometry_path.exists():
-                        import json
-                        with open(geometry_path) as f:
-                            geometry_data = json.load(f)
-                        panel_data["bboxes"] = extract_bboxes_from_geometry_px(
-                            geometry_data,
-                            panel_data["img_size"]["width"],
-                            panel_data["img_size"]["height"]
-                        )
+                # Use smart helper to load panel data
+                loaded = load_panel_data(panel_path, is_zip=is_zip)
+
+                panel_data = {"name": display_name, "image": None, "bboxes": None, "img_size": None}
+
+                # Add layout info from figz spec
+                if display_name in figz_layout:
+                    panel_data["layout"] = figz_layout[display_name]
+
+                if loaded:
+                    # Get image data
+                    if loaded.get("is_zip"):
+                        png_bytes = loaded.get("png_bytes")
+                        if png_bytes:
+                            panel_data["image"] = base64.b64encode(png_bytes).decode("utf-8")
                     else:
-                        # Fall back to spec.json extraction
-                        spec_path = panel_dir / "spec.json"
-                        if spec_path.exists():
-                            import json
-                            with open(spec_path) as f:
-                                panel_metadata = json.load(f)
+                        png_path = loaded.get("png_path")
+                        if png_path and png_path.exists():
+                            with open(png_path, "rb") as f:
+                                panel_data["image"] = base64.b64encode(f.read()).decode("utf-8")
+
+                    # Get image size
+                    img_size = loaded.get("img_size")
+                    if img_size:
+                        panel_data["img_size"] = img_size
+                        panel_data["width"] = img_size["width"]
+                        panel_data["height"] = img_size["height"]
+                    elif loaded.get("png_path"):
+                        from PIL import Image
+                        img = Image.open(loaded["png_path"])
+                        panel_data["img_size"] = {"width": img.size[0], "height": img.size[1]}
+                        panel_data["width"], panel_data["height"] = img.size
+                        img.close()
+
+                    # Extract bboxes - prefer geometry_px.json
+                    if panel_data.get("img_size"):
+                        geometry_data = loaded.get("geometry_data")
+                        metadata = loaded.get("metadata", {})
+
+                        if geometry_data:
+                            panel_data["bboxes"] = extract_bboxes_from_geometry_px(
+                                geometry_data,
+                                panel_data["img_size"]["width"],
+                                panel_data["img_size"]["height"]
+                            )
+                        elif metadata:
                             panel_data["bboxes"] = extract_bboxes_from_metadata(
-                                panel_metadata,
+                                metadata,
                                 panel_data["img_size"]["width"],
                                 panel_data["img_size"]["height"]
                             )
@@ -213,97 +428,92 @@ class WebEditor:
             return jsonify({
                 "panels": panel_images,
                 "count": len(panel_images),
+                "layout": figz_layout,
             })
 
         @app.route("/switch_panel/<int:panel_index>")
         def switch_panel(panel_index):
             """Switch to a different panel in the figz bundle.
 
-            Loads the actual PNG from the panel's exports folder instead of re-rendering.
+            Uses smart load_panel_data helper for transparent zip/directory handling.
             """
-            from PIL import Image
-            from .._edit import _load_panel_data
             from ._bbox import extract_bboxes_from_metadata, extract_bboxes_from_geometry_px
+            from ..edit import load_panel_data
 
             if not editor.panel_info:
                 return jsonify({"error": "Not a multi-panel figz bundle"}), 400
 
             panels = editor.panel_info["panels"]
+            panel_paths = editor.panel_info.get("panel_paths", [])
+            panel_is_zip = editor.panel_info.get("panel_is_zip", [False] * len(panels))
+
             if panel_index < 0 or panel_index >= len(panels):
                 return jsonify({"error": f"Invalid panel index: {panel_index}"}), 400
 
-            figz_dir = Path(editor.panel_info["figz_dir"])
             panel_name = panels[panel_index]
-            panel_dir = figz_dir / panel_name
+            panel_path = panel_paths[panel_index] if panel_paths else str(Path(editor.panel_info["figz_dir"]) / panel_name)
+            is_zip = panel_is_zip[panel_index] if panel_index < len(panel_is_zip) else None
 
-            # Load the panel's data
             try:
-                panel_data = _load_panel_data(panel_dir)
-                if not panel_data:
-                    return jsonify({"error": f"Could not load panel: {panel_name}"}), 400
+                # Use smart helper to load panel data
+                loaded = load_panel_data(panel_path, is_zip=is_zip)
 
-                # Update editor state
-                editor.json_path = panel_data["json_path"]
-                editor.metadata = panel_data["metadata"]
-                editor.csv_data = panel_data.get("csv_data")
-                editor.png_path = panel_data.get("png_path")
-                editor.hitmap_path = panel_data.get("hitmap_path")
-                editor.panel_info["current_index"] = panel_index
-
-                # Re-extract defaults from new metadata
-                from .._defaults import get_scitex_defaults, extract_defaults_from_metadata
-                editor.scitex_defaults = get_scitex_defaults()
-                editor.metadata_defaults = extract_defaults_from_metadata(editor.metadata)
-                editor.current_overrides = copy.deepcopy(editor.scitex_defaults)
-                editor.current_overrides.update(editor.metadata_defaults)
-                editor.current_overrides.update(editor.manual_overrides)
+                if not loaded:
+                    return jsonify({"error": f"Could not load panel: {panel_name}"}), 400
 
-                # Load actual PNG from panel instead of re-rendering
+                # Get image data
                 img_data = None
-                img_size = {"width": 0, "height": 0}
-                png_path = panel_data.get("png_path")
-
-                if png_path and png_path.exists():
-                    with open(png_path, "rb") as f:
-                        img_data = base64.b64encode(f.read()).decode("utf-8")
-                    img = Image.open(png_path)
-                    img_size = {"width": img.size[0], "height": img.size[1]}
-                    img.close()
+                if loaded.get("is_zip"):
+                    png_bytes = loaded.get("png_bytes")
+                    if png_bytes:
+                        img_data = base64.b64encode(png_bytes).decode("utf-8")
                 else:
-                    # Fallback: look for any PNG in exports/
-                    exports_dir = panel_dir / "exports"
-                    if exports_dir.exists():
-                        for f in exports_dir.glob("*.png"):
-                            if "_hitmap" not in f.name and "_overview" not in f.name:
-                                with open(f, "rb") as pf:
-                                    img_data = base64.b64encode(pf.read()).decode("utf-8")
-                                img = Image.open(f)
-                                img_size = {"width": img.size[0], "height": img.size[1]}
-                                img.close()
-                                break
+                    png_path = loaded.get("png_path")
+                    if png_path and png_path.exists():
+                        with open(png_path, "rb") as f:
+                            img_data = base64.b64encode(f.read()).decode("utf-8")
 
                 if not img_data:
                     return jsonify({"error": f"No PNG found for panel: {panel_name}"}), 400
 
-                # Extract bboxes - prefer geometry_px.json for precise coordinates
+                # Get image size
+                img_size = loaded.get("img_size", {"width": 0, "height": 0})
+                if not img_size and loaded.get("png_path"):
+                    from PIL import Image
+                    img = Image.open(loaded["png_path"])
+                    img_size = {"width": img.size[0], "height": img.size[1]}
+                    img.close()
+
+                # Extract bboxes - prefer geometry_px.json
                 bboxes = {}
-                geometry_path = panel_dir / "cache" / "geometry_px.json"
-                if geometry_path.exists():
-                    with open(geometry_path) as f:
-                        geometry_data = json.load(f)
+                geometry_data = loaded.get("geometry_data")
+                metadata = loaded.get("metadata", {})
+
+                if geometry_data and img_size:
                     bboxes = extract_bboxes_from_geometry_px(
                         geometry_data,
                         img_size["width"],
-                        img_size["height"],
+                        img_size["height"]
                     )
-                else:
-                    # Fall back to metadata extraction
+                elif metadata and img_size:
                     bboxes = extract_bboxes_from_metadata(
-                        editor.metadata,
+                        metadata,
                         img_size["width"],
-                        img_size["height"],
+                        img_size["height"]
                     )
 
+                # Update editor state
+                editor.metadata = metadata
+                editor.panel_info["current_index"] = panel_index
+
+                # Re-extract defaults from new metadata
+                from .._defaults import get_scitex_defaults, extract_defaults_from_metadata
+                editor.scitex_defaults = get_scitex_defaults()
+                editor.metadata_defaults = extract_defaults_from_metadata(metadata)
+                editor.current_overrides = copy.deepcopy(editor.scitex_defaults)
+                editor.current_overrides.update(editor.metadata_defaults)
+                editor.current_overrides.update(editor.manual_overrides)
+
                 return jsonify({
                     "success": True,
                     "panel_name": panel_name,
@@ -368,7 +578,7 @@ class WebEditor:
         @app.route("/save", methods=["POST"])
         def save():
             """Save to .manual.json."""
-            from .._edit import save_manual_overrides
+            from ..edit import save_manual_overrides
 
             try:
                 manual_path = save_manual_overrides(
@@ -378,6 +588,601 @@ class WebEditor:
             except Exception as e:
                 return jsonify({"status": "error", "message": str(e)}), 500
 
+        @app.route("/save_layout", methods=["POST"])
+        def save_layout():
+            """Save panel layout positions to figz bundle."""
+            try:
+                data = request.get_json()
+                layout = data.get("layout", {})
+
+                if not layout:
+                    return jsonify({"success": False, "error": "No layout data provided"})
+
+                # Check if we have panel_info (figz bundle)
+                if not editor.panel_info:
+                    return jsonify({"success": False, "error": "No panel info available (not a figz bundle)"})
+
+                bundle_path = editor.panel_info.get("bundle_path")
+                if not bundle_path:
+                    return jsonify({"success": False, "error": "Bundle path not available"})
+
+                # Update layout in the figz bundle
+                from scitex.fig.io import ZipBundle
+
+                bundle = ZipBundle(bundle_path)
+
+                # Read existing layout or create new one
+                try:
+                    existing_layout = bundle.read_json("layout.json")
+                except:
+                    existing_layout = {}
+
+                # Update layout with new positions
+                for panel_name, pos in layout.items():
+                    if panel_name not in existing_layout:
+                        existing_layout[panel_name] = {}
+                    if "position" not in existing_layout[panel_name]:
+                        existing_layout[panel_name]["position"] = {}
+                    if "size" not in existing_layout[panel_name]:
+                        existing_layout[panel_name]["size"] = {}
+
+                    # Update position
+                    existing_layout[panel_name]["position"]["x_mm"] = pos.get("x_mm", 0)
+                    existing_layout[panel_name]["position"]["y_mm"] = pos.get("y_mm", 0)
+
+                    # Update size if provided
+                    if "width_mm" in pos:
+                        existing_layout[panel_name]["size"]["width_mm"] = pos["width_mm"]
+                    if "height_mm" in pos:
+                        existing_layout[panel_name]["size"]["height_mm"] = pos["height_mm"]
+
+                # Save updated layout
+                bundle.write_json("layout.json", existing_layout)
+
+                # Update in-memory panel_info
+                editor.panel_info["layout"] = existing_layout
+
+                # Auto-export composed figure to bundle
+                export_result = _export_composed_figure(editor, formats=["png", "svg"])
+
+                return jsonify({
+                    "success": True,
+                    "layout": existing_layout,
+                    "exported": export_result.get("exported", {})
+                })
+
+            except Exception as e:
+                import traceback
+                return jsonify({
+                    "success": False,
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                })
+
+        @app.route("/save_element_position", methods=["POST"])
+        def save_element_position():
+            """Save element position (legend/panel_letter) to figz bundle.
+
+            ONLY legends and panel letters can be repositioned to maintain
+            scientific rigor. Data elements are never moved.
+            """
+            try:
+                data = request.get_json()
+                element = data.get("element", "")
+                panel = data.get("panel", "")
+                element_type = data.get("element_type", "")
+                position = data.get("position", {})
+                snap_name = data.get("snap_name")
+
+                # Validate element type (whitelist for scientific rigor)
+                ALLOWED_TYPES = ["legend", "panel_letter"]
+                if element_type not in ALLOWED_TYPES:
+                    return jsonify({
+                        "success": False,
+                        "error": f"Element type '{element_type}' cannot be repositioned (scientific rigor)"
+                    })
+
+                if not editor.panel_info:
+                    return jsonify({"success": False, "error": "No panel info available"})
+
+                bundle_path = editor.panel_info.get("bundle_path")
+                if not bundle_path:
+                    return jsonify({"success": False, "error": "Bundle path not available"})
+
+                from scitex.fig.io import ZipBundle
+                bundle = ZipBundle(bundle_path)
+
+                # Read or create style.json for element positions
+                try:
+                    style = bundle.read_json("style.json")
+                except:
+                    style = {}
+
+                # Initialize structure
+                if "elements" not in style:
+                    style["elements"] = {}
+                if panel not in style["elements"]:
+                    style["elements"][panel] = {}
+
+                # Save element position
+                style["elements"][panel][element] = {
+                    "type": element_type,
+                    "position": position,
+                    "snap_name": snap_name,
+                }
+
+                # For legends, also update legend_location for matplotlib compatibility
+                if element_type == "legend" and snap_name:
+                    # Convert snap name to matplotlib loc format
+                    loc_map = {
+                        "upper left": "upper left",
+                        "upper center": "upper center",
+                        "upper right": "upper right",
+                        "center left": "center left",
+                        "center": "center",
+                        "center right": "center right",
+                        "lower left": "lower left",
+                        "lower center": "lower center",
+                        "lower right": "lower right",
+                    }
+                    if snap_name in loc_map:
+                        if "legend" not in style:
+                            style["legend"] = {}
+                        style["legend"]["location"] = loc_map[snap_name]
+
+                bundle.write_json("style.json", style)
+
+                return jsonify({
+                    "success": True,
+                    "element": element,
+                    "position": position,
+                    "snap_name": snap_name
+                })
+
+            except Exception as e:
+                import traceback
+                return jsonify({
+                    "success": False,
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                })
+
+        @app.route("/export", methods=["POST"])
+        def export_figure():
+            """Export composed figure to various formats and update figz bundle."""
+            try:
+                data = request.get_json()
+                formats = data.get("formats", ["png", "svg"])
+
+                if not editor.panel_info:
+                    return jsonify({"success": False, "error": "No panel info available"})
+
+                bundle_path = editor.panel_info.get("bundle_path")
+                if not bundle_path:
+                    return jsonify({"success": False, "error": "Bundle path not available"})
+
+                from scitex.io import ZipBundle
+                from pathlib import Path
+                import io
+                import matplotlib
+                matplotlib.use('Agg')
+                import matplotlib.pyplot as plt
+                from PIL import Image
+                import numpy as np
+
+                figure_name = Path(bundle_path).stem
+                dpi = data.get("dpi", 150)
+
+                with ZipBundle(bundle_path, mode="a") as bundle:
+                    # Read spec for figure size and panel positions
+                    try:
+                        spec = bundle.read_json("spec.json")
+                    except:
+                        spec = {}
+
+                    # Get figure dimensions
+                    fig_width_mm = 180
+                    fig_height_mm = 120
+                    if "figure" in spec:
+                        fig_info = spec.get("figure", {})
+                        styles = fig_info.get("styles", {})
+                        size = styles.get("size", {})
+                        fig_width_mm = size.get("width_mm", 180)
+                        fig_height_mm = size.get("height_mm", 120)
+
+                    # Convert mm to inches
+                    fig_width_in = fig_width_mm / 25.4
+                    fig_height_in = fig_height_mm / 25.4
+
+                    # Create figure with white background
+                    fig = plt.figure(figsize=(fig_width_in, fig_height_in), dpi=dpi, facecolor='white')
+
+                    # Get panels from spec or editor.panel_info
+                    panels_spec = spec.get("panels", [])
+
+                    # Compose panels onto figure
+                    for panel_spec in panels_spec:
+                        panel_id = panel_spec.get("id", "")
+                        pltz_name = panel_spec.get("plot", "")
+
+                        # Get position and size from spec
+                        pos = panel_spec.get("position", {})
+                        size = panel_spec.get("size", {})
+
+                        x_mm = pos.get("x_mm", 0)
+                        y_mm = pos.get("y_mm", 0)
+                        w_mm = size.get("width_mm", 60)
+                        h_mm = size.get("height_mm", 40)
+
+                        # Convert to figure coordinates (0-1)
+                        x_frac = x_mm / fig_width_mm
+                        y_frac = 1 - (y_mm + h_mm) / fig_height_mm  # Flip Y
+                        w_frac = w_mm / fig_width_mm
+                        h_frac = h_mm / fig_height_mm
+
+                        # Try to read panel image from pltz exports
+                        img_loaded = False
+                        for pltz_path in [f"{panel_id}.pltz", pltz_name.replace(".d", "")]:
+                            if img_loaded:
+                                break
+                            try:
+                                # Read pltz as nested bundle
+                                pltz_bytes = bundle.read_bytes(pltz_path)
+                                import tempfile
+                                with tempfile.NamedTemporaryFile(suffix=".pltz", delete=False) as tmp:
+                                    tmp.write(pltz_bytes)
+                                    tmp_path = tmp.name
+                                try:
+                                    with ZipBundle(tmp_path, mode="r") as pltz_bundle:
+                                        # Try various preview paths
+                                        for preview_path in ["exports/preview.png", "preview.png", f"exports/{panel_id}.png"]:
+                                            try:
+                                                img_data = pltz_bundle.read_bytes(preview_path)
+                                                img = Image.open(io.BytesIO(img_data))
+                                                img_array = np.array(img)
+
+                                                # Create axes and add image
+                                                ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                                                ax.imshow(img_array)
+                                                ax.axis('off')
+                                                img_loaded = True
+                                                break
+                                            except:
+                                                continue
+                                finally:
+                                    import os
+                                    os.unlink(tmp_path)
+                            except Exception as e:
+                                print(f"Could not load pltz {pltz_path}: {e}")
+                                continue
+
+                    exported = {}
+
+                    for fmt in formats:
+                        buf = io.BytesIO()
+                        if fmt in ["png", "jpeg", "jpg"]:
+                            fig.savefig(buf, format="png" if fmt == "png" else "jpeg",
+                                       dpi=dpi, bbox_inches="tight", facecolor="white",
+                                       pad_inches=0.02)
+                        elif fmt == "svg":
+                            fig.savefig(buf, format="svg", bbox_inches="tight", pad_inches=0.02)
+                        elif fmt == "pdf":
+                            fig.savefig(buf, format="pdf", bbox_inches="tight", pad_inches=0.02)
+                        else:
+                            continue
+
+                        buf.seek(0)
+                        content = buf.read()
+
+                        # Save to exports/ directory in bundle
+                        export_path = f"exports/{figure_name}.{fmt}"
+                        bundle.write_bytes(export_path, content)
+                        exported[fmt] = export_path
+
+                    plt.close(fig)
+
+                return jsonify({
+                    "success": True,
+                    "exported": exported,
+                    "bundle_path": str(bundle_path)
+                })
+
+            except Exception as e:
+                import traceback
+                return jsonify({
+                    "success": False,
+                    "error": str(e),
+                    "traceback": traceback.format_exc()
+                })
+
+        @app.route("/download/<fmt>")
+        def download_figure(fmt):
+            """Download figure in specified format."""
+            try:
+                from flask import send_file
+                import io
+                from pathlib import Path
+
+                mime_types = {
+                    "png": "image/png",
+                    "jpeg": "image/jpeg",
+                    "jpg": "image/jpeg",
+                    "svg": "image/svg+xml",
+                    "pdf": "application/pdf",
+                }
+
+                if fmt not in mime_types:
+                    return f"Unsupported format: {fmt}", 400
+
+                # For figz bundles, download the composed figure
+                if editor.panel_info:
+                    bundle_path = editor.panel_info.get("bundle_path")
+                    figz_dir = editor.panel_info.get("figz_dir")
+                    figure_name = Path(bundle_path).stem if bundle_path else (
+                        Path(figz_dir).stem.replace(".figz.d", "") if figz_dir else "figure"
+                    )
+
+                    if bundle_path or figz_dir:
+                        from scitex.io import ZipBundle
+                        from PIL import Image
+                        import numpy as np
+                        import matplotlib
+                        matplotlib.use('Agg')
+                        import matplotlib.pyplot as plt
+                        import json as json_module
+
+                        # Always compose on-demand to ensure current panel state
+                        # (existing exports in bundle may be stale or blank)
+
+                        # Read spec.json and layout.json for position overrides
+                        spec = {}
+                        layout_overrides = {}
+                        if bundle_path:
+                            try:
+                                with ZipBundle(bundle_path, mode="r") as bundle:
+                                    spec = bundle.read_json("spec.json")
+                                    try:
+                                        layout_overrides = bundle.read_json("layout.json")
+                                    except:
+                                        pass
+                            except:
+                                pass
+                        elif figz_dir:
+                            spec_path = Path(figz_dir) / "spec.json"
+                            if spec_path.exists():
+                                with open(spec_path) as f:
+                                    spec = json_module.load(f)
+                            layout_path = Path(figz_dir) / "layout.json"
+                            if layout_path.exists():
+                                with open(layout_path) as f:
+                                    layout_overrides = json_module.load(f)
+
+                        # Also check in-memory layout overrides (most current)
+                        if editor.panel_info and editor.panel_info.get("layout"):
+                            layout_overrides = editor.panel_info.get("layout", {})
+
+                        # Get figure dimensions
+                        fig_width_mm = 180
+                        fig_height_mm = 120
+                        if "figure" in spec:
+                            fig_info = spec.get("figure", {})
+                            styles = fig_info.get("styles", {})
+                            size = styles.get("size", {})
+                            fig_width_mm = size.get("width_mm", 180)
+                            fig_height_mm = size.get("height_mm", 120)
+
+                        fig_width_in = fig_width_mm / 25.4
+                        fig_height_in = fig_height_mm / 25.4
+
+                        dpi = 150 if fmt in ["jpeg", "jpg"] else 300
+                        fig = plt.figure(figsize=(fig_width_in, fig_height_in), dpi=dpi, facecolor='white')
+
+                        # Compose panels
+                        panels_spec = spec.get("panels", [])
+                        panel_paths = editor.panel_info.get("panel_paths", [])
+                        panel_is_zip = editor.panel_info.get("panel_is_zip", [])
+
+                        for panel_spec in panels_spec:
+                            panel_id = panel_spec.get("id", "")
+                            pos = panel_spec.get("position", {})
+                            size = panel_spec.get("size", {})
+
+                            # Skip overview/auxiliary panels (only compose main panels A-Z)
+                            panel_id_lower = panel_id.lower()
+                            if any(skip in panel_id_lower for skip in ['overview', 'thumb', 'preview', 'aux']):
+                                continue
+
+                            # Find panel path first (needed to check layout_overrides)
+                            panel_path = None
+                            is_zip = False
+                            panel_name = None
+                            for idx, pp in enumerate(panel_paths):
+                                pp_name = Path(pp).stem.replace(".pltz", "")
+                                # Match exact name, or name contains panel_id pattern
+                                # e.g., "panel_A_twinx" matches panel_id "A"
+                                if (pp_name == panel_id or
+                                    pp_name.startswith(f"panel_{panel_id}_") or
+                                    pp_name.startswith(f"panel_{panel_id}.") or
+                                    pp_name == f"panel_{panel_id}" or
+                                    pp_name == panel_id or
+                                    f"_{panel_id}_" in pp_name or
+                                    pp_name.endswith(f"_{panel_id}")):
+                                    panel_path = pp
+                                    panel_name = Path(pp).name  # e.g., "panel_A_twinx.pltz"
+                                    is_zip = panel_is_zip[idx] if idx < len(panel_is_zip) else False
+                                    break
+
+                            if not panel_path:
+                                print(f"Could not find panel path for id={panel_id}, available: {[Path(p).stem for p in panel_paths]}")
+                                continue
+
+                            # Check for layout overrides (from layout.json or in-memory)
+                            override = layout_overrides.get(panel_name, {})
+                            override_pos = override.get("position", {})
+                            override_size = override.get("size", {})
+
+                            # Use override positions if available, otherwise use spec
+                            x_mm = override_pos.get("x_mm", pos.get("x_mm", 0))
+                            y_mm = override_pos.get("y_mm", pos.get("y_mm", 0))
+                            w_mm = override_size.get("width_mm", size.get("width_mm", 60))
+                            h_mm = override_size.get("height_mm", size.get("height_mm", 40))
+
+                            x_frac = x_mm / fig_width_mm
+                            y_frac = 1 - (y_mm + h_mm) / fig_height_mm
+                            w_frac = w_mm / fig_width_mm
+                            h_frac = h_mm / fig_height_mm
+
+                            # Load panel preview image
+                            try:
+                                img_loaded = False
+                                # Exclusion patterns for preview selection
+                                exclude_patterns = ['hitmap', 'overview', 'thumb', 'preview']
+
+                                if is_zip:
+                                    with ZipBundle(panel_path, mode="r") as pltz_bundle:
+                                        # Find PNG in exports (exclude hitmap, overview, thumbnails)
+                                        import zipfile
+                                        with zipfile.ZipFile(panel_path, 'r') as zf:
+                                            png_files = [n for n in zf.namelist()
+                                                        if n.endswith('.png')
+                                                        and 'exports/' in n
+                                                        and not any(p in n.lower() for p in exclude_patterns)]
+                                            if png_files:
+                                                # Use first matching PNG
+                                                preview_path = png_files[0]
+                                                # Extract the path relative to .d directory
+                                                if '.pltz.d/' in preview_path:
+                                                    preview_path = preview_path.split('.pltz.d/')[-1]
+                                                try:
+                                                    img_data = pltz_bundle.read_bytes(preview_path)
+                                                    img = Image.open(io.BytesIO(img_data))
+                                                    ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                                                    ax.imshow(np.array(img))
+                                                    ax.axis('off')
+                                                    img_loaded = True
+                                                except Exception as e:
+                                                    print(f"Could not read {preview_path}: {e}")
+                                else:
+                                    # Directory-based pltz
+                                    pltz_dir = Path(panel_path)
+                                    exports_dir = pltz_dir / "exports"
+                                    if exports_dir.exists():
+                                        for png_file in exports_dir.glob("*.png"):
+                                            name_lower = png_file.name.lower()
+                                            if not any(p in name_lower for p in exclude_patterns):
+                                                img = Image.open(png_file)
+                                                ax = fig.add_axes([x_frac, y_frac, w_frac, h_frac])
+                                                ax.imshow(np.array(img))
+                                                ax.axis('off')
+                                                img_loaded = True
+                                                break
+                                if not img_loaded:
+                                    print(f"No preview found for panel {panel_id}")
+                            except Exception as e:
+                                print(f"Could not load panel {panel_id}: {e}")
+
+                            # Draw panel letter
+                            if panel_id and len(panel_id) <= 2:  # Only for short IDs like A, B, C...
+                                # Position letter at top-left corner of panel
+                                letter_x = x_frac + 0.01
+                                letter_y = y_frac + h_frac - 0.02
+                                fig.text(letter_x, letter_y, panel_id,
+                                        fontsize=14, fontweight='bold', color='black',
+                                        ha='left', va='top',
+                                        transform=fig.transFigure,
+                                        bbox=dict(boxstyle='square,pad=0.1',
+                                                 facecolor='white', edgecolor='none', alpha=0.8))
+
+                        buf = io.BytesIO()
+                        fig.savefig(buf, format=fmt if fmt != "jpg" else "jpeg",
+                                   dpi=dpi, bbox_inches="tight", facecolor="white",
+                                   pad_inches=0.02)
+                        plt.close(fig)
+                        buf.seek(0)
+
+                        return send_file(
+                            buf,
+                            mimetype=mime_types[fmt],
+                            as_attachment=True,
+                            download_name=f"{figure_name}.{fmt}"
+                        )
+
+                # For single pltz files, render from csv_data
+                from ._renderer import render_preview_with_bboxes
+                import matplotlib
+                matplotlib.use('Agg')
+                import matplotlib.pyplot as plt
+
+                figure_name = "figure"
+                if editor.json_path:
+                    figure_name = Path(editor.json_path).stem
+
+                img_data, _, _ = render_preview_with_bboxes(
+                    editor.csv_data, editor.current_overrides,
+                    metadata=editor.metadata,
+                    dark_mode=False,
+                )
+
+                if fmt == "png":
+                    import base64
+                    content = base64.b64decode(img_data)
+                    buf = io.BytesIO(content)
+                    return send_file(
+                        buf,
+                        mimetype=mime_types[fmt],
+                        as_attachment=True,
+                        download_name=f"{figure_name}.{fmt}"
+                    )
+
+                # For other formats, re-render
+                from ._plotter import plot_from_csv
+                fig, ax = plt.subplots(figsize=(8, 6))
+                plot_from_csv(ax, editor.csv_data, editor.current_overrides)
+
+                buf = io.BytesIO()
+                dpi = 150 if fmt in ["jpeg", "jpg"] else 300
+                fig.savefig(buf, format=fmt if fmt != "jpg" else "jpeg",
+                           dpi=dpi, bbox_inches="tight",
+                           facecolor="white" if fmt in ["jpeg", "jpg"] else None)
+                plt.close(fig)
+                buf.seek(0)
+
+                return send_file(
+                    buf,
+                    mimetype=mime_types[fmt],
+                    as_attachment=True,
+                    download_name=f"{figure_name}.{fmt}"
+                )
+
+            except Exception as e:
+                import traceback
+                return f"Error: {str(e)}\n{traceback.format_exc()}", 500
+
+        @app.route("/download_figz")
+        def download_figz():
+            """Download as figz bundle (re-editable format)."""
+            try:
+                if not editor.panel_info:
+                    return "No panel info available", 404
+
+                bundle_path = editor.panel_info.get("bundle_path")
+                if not bundle_path:
+                    return "Bundle path not available", 404
+
+                from flask import send_file
+                from pathlib import Path
+
+                # Send the figz file directly (it's already a pltz-compatible format)
+                return send_file(
+                    bundle_path,
+                    mimetype="application/zip",
+                    as_attachment=True,
+                    download_name=Path(bundle_path).name
+                )
+
+            except Exception as e:
+                return str(e), 500
+
         @app.route("/shutdown", methods=["POST"])
         def shutdown():
             """Shutdown the server."""