Phase 1.5 complete: GeoJSON pipeline + design API + dual-mode Gradio UI

Tested: 51 unit tests pass, end-to-end pipeline verified, error handling confirmed.

New:
- design_api.py: orchestrates valve_engine + drip_engine pipeline
- GeoJSON input → parse → UTM transform → valve placement → per-zone drip layout → GeoJSON output
- Aggregated BOM across all zones with cost breakdown
- Structured error responses as valid GeoJSON FeatureCollections

Updated app.py:
- Tab 1: Quick Test (text geofence mode, kept for dev/debug)
- Tab 2: GeoJSON Pipeline (file upload or paste raw JSON)
- Runs full design_api.py pipeline
- Shows output GeoJSON, design summary, feature counts
- Embedded sample input/output for reference

app.py

@@ -1,15 +1,21 @@
 """
-Farm Drip Irrigation Design Tool - Phase 1 (Geometry Engine Only)
+Farm Drip Irrigation Design Tool - Phase 1.5 (Geometry + Valve Engine)
 
-Simple Gradio UI to test the geometry engine before LLM integration.
-Accepts a farm boundary (geofence), generates drip layout, and displays BOM.
+Two modes:
+1. Quick test: Type geofence coordinates, select crop, get design
+2. Full pipeline: Upload GeoJSON from user app, run valve + drip layout, download result
+
+Supports:
+- GeoJSON input/output (RFC 7946 standard)
+- Valve placement with hierarchical decision matrix
+- Drip layout generation per valve zone
+- BOM estimation
 """
 
 import gradio as gr
 import json
 from shapely.geometry import Polygon
 from PIL import Image, ImageDraw
-import numpy as np
 from drip_engine import (
     parse_geofence_to_polygon,
     validate_polygon,
@@ -18,38 +24,22 @@ from drip_engine import (
     design_summary,
     DripLayoutError,
 )
+from design_api import process_farm_design
 
-# Default example geofence (100m x 100m square)
 DEFAULT_GEOFENCE = "0,0;100,0;100,100;0,100"
 DEFAULT_CROP = "generic"
 DEFAULT_HEADLAND = 1.0
 
 
-def generate_design(geofence_text: str, crop: str, headland_m: float, override_spacing: float):
-    """
-    Main function: parse geofence, generate layout, return visualizations and BOM.
-
-    Args:
-        geofence_text: Polygon coordinates as text (e.g., "0,0;100,0;100,100;0,100")
-        crop: Crop type (tomato, pepper, lettuce, etc.)
-        headland_m: Headland buffer in meters
-        override_spacing: Override lateral spacing (if > 0)
-
-    Returns:
-        (design_image, bom_json, summary_text, error_message)
-    """
+def generate_design(geofence_text, crop, headland_m, override_spacing):
+    """Quick test mode with text geofence."""
     try:
-        # Parse geofence
         polygon_px = parse_geofence_to_polygon(geofence_text)
         is_valid, msg = validate_polygon(polygon_px)
         if not is_valid:
             return None, "{}", msg, f"❌ Invalid polygon: {msg}"
 
-        # For this test, assume pixel coords directly map to meters (1:1 scale)
-        # In production, you'd convert from lat/lon or map projection
         polygon_utm = polygon_px
-
-        # Generate layout
         override_sp = override_spacing if override_spacing > 0 else None
         design = generate_drip_layout(
             polygon_utm,
@@ -57,19 +47,10 @@ def generate_design(geofence_text: str, crop: str, headland_m: float, override_s
             headland_buffer_m=headland_m,
             override_spacing_m=override_sp,
         )
-
-        # Estimate BOM
         bom = estimate_bom(design, unit="usd")
-
-        # Generate summary
         summary = design_summary(design, bom)
-
-        # Render visualization
         image = _render_design_image(design, polygon_px)
-
-        # BOM as JSON
         bom_json = json.dumps(bom, indent=2)
-
         return image, bom_json, summary, "✅ Design generated successfully"
 
     except DripLayoutError as e:
@@ -78,29 +59,14 @@ def generate_design(geofence_text: str, crop: str, headland_m: float, override_s
         return None, "{}", "", f"❌ Unexpected error: {str(e)}"
 
 
-def _render_design_image(design: dict, polygon_px: Polygon) -> Image.Image:
-    """
-    Render the drip layout on a canvas image.
-
-    Args:
-        design: Output from generate_drip_layout()
-        polygon_px: Original polygon (for bounds)
-
-    Returns:
-        PIL Image showing the design
-    """
-    # Get bounding box
+def _render_design_image(design, polygon_px):
+    """Render the drip layout on a canvas image."""
     minx, miny, maxx, maxy = polygon_px.bounds
-    width_px = int(maxx - minx) + 20
-    height_px = int(maxy - miny) + 20
-    width_px = max(width_px, 400)
-    height_px = max(height_px, 300)
+    width_px = max(int(maxx - minx) + 20, 400)
+    height_px = max(int(maxy - miny) + 20, 300)
 
-    # Create image (white background)
     image = Image.new("RGB", (width_px, height_px), color="white")
     draw = ImageDraw.Draw(image)
-
-    # Scale to fit image
     scale = min((width_px - 40) / (maxx - minx), (height_px - 40) / (maxy - miny))
     offset_x = 20 - minx * scale
     offset_y = 20 - miny * scale
@@ -108,146 +74,240 @@ def _render_design_image(design: dict, polygon_px: Polygon) -> Image.Image:
     def scale_point(x, y):
         return (x * scale + offset_x, y * scale + offset_y)
 
-    # Draw field boundary (green)
     boundary_coords = list(polygon_px.exterior.coords)
     scaled_boundary = [scale_point(x, y) for x, y in boundary_coords]
     if len(scaled_boundary) > 2:
         draw.polygon(scaled_boundary, outline="green", width=3)
 
-    # Draw main line (red, thicker)
     main_line = design["main_line"]
     main_coords = [scale_point(x, y) for x, y in main_line.coords]
     if len(main_coords) > 1:
         draw.line(main_coords, fill="red", width=4)
 
-    # Draw laterals (blue, thinner)
     for lateral in design["laterals"]:
         lateral_coords = [scale_point(x, y) for x, y in lateral.coords]
         if len(lateral_coords) > 1:
             draw.line(lateral_coords, fill="blue", width=2)
 
-    # Add title and stats
-    title = f"Farm Drip Layout - {design['crop'].title()}"
-    area_text = f"Area: {design['farm_area_ha']:.2f} ha"
-    emitter_text = f"Emitters: {design['emitter_count']}"
-
-    draw.text((10, 10), title, fill="black")
-    draw.text((10, 30), area_text, fill="black")
-    draw.text((10, 50), emitter_text, fill="black")
+    draw.text((10, 10), f"Farm Drip Layout - {design['crop'].title()}", fill="black")
+    draw.text((10, 30), f"Area: {design['farm_area_ha']:.2f} ha", fill="black")
+    draw.text((10, 50), f"Emitters: {design['emitter_count']}", fill="black")
 
     return image
 
 
-# Build Gradio UI
+def process_geojson_input(geojson_text):
+    """Full pipeline: accept GeoJSON string, return output + summary."""
+    try:
+        result = process_farm_design(geojson_text)
+
+        props = result.get("properties", {})
+        if props.get("type") == "farm_design_error":
+            err = props.get("error", {})
+            return json.dumps(result, indent=2), "", None, f"❌ {err.get('code')}: {err.get('message')}"
+
+        summary_lines = []
+        ds = props.get("design_summary", {})
+        summary_lines.append("=== Farm Design Summary ===")
+        summary_lines.append(f"Farm Area:       {ds.get('farm_area_ha', 'N/A')} ha")
+        summary_lines.append(f"Total Valves:    {ds.get('total_valves', 'N/A')}")
+        summary_lines.append(f"Drip Tape:       {ds.get('total_drip_tape_m', 'N/A')} m")
+        summary_lines.append(f"Main Line:       {ds.get('total_main_line_m', 'N/A')} m")
+        summary_lines.append(f"Emitters:        {ds.get('total_emitters', 'N/A')}")
+        summary_lines.append(f"Pump:            {ds.get('pump_hp', 'N/A')} HP ({ds.get('pump_flow_lph', 'N/A')} L/h)")
+        summary_lines.append(f"Strategy:        {ds.get('manifold_strategy', 'N/A')}")
+        summary_lines.append("")
+
+        bom = props.get("bom", {})
+        summary_lines.append("=== Bill of Materials ===")
+        summary_lines.append(f"Main Pipe (16mm):  {bom.get('main_line_16mm_m', 'N/A')} m")
+        summary_lines.append(f"Drip Tape (16mm):  {bom.get('drip_tape_16mm_m', 'N/A')} m")
+        summary_lines.append(f"Inline Emitters:   {bom.get('inline_emitters', 'N/A')}")
+        summary_lines.append(f"Valves:            {bom.get('valves_count', 'N/A')}")
+        if "total_cost_usd" in bom:
+            summary_lines.append(f"Total Cost:        ${bom.get('total_cost_usd', 'N/A')}")
+        summary_lines.append("")
+
+        zones = props.get("zone_details", [])
+        if zones:
+            summary_lines.append("=== Per-Zone Breakdown ===")
+            for z in zones:
+                if "error" in z:
+                    summary_lines.append(f"  {z['valve_id']}: {z['crop']} — ERROR: {z['error']}")
+                else:
+                    summary_lines.append(
+                        f"  {z['valve_id']}: {z['crop']} | "
+                        f"{z.get('area_ha', 0):.2f} ha | "
+                        f"{z.get('emitters', 0)} emitters | "
+                        f"{z.get('lateral_m', 0):.0f} m tape"
+                    )
+
+        summary = "\n".join(summary_lines)
+
+        feature_types = {}
+        for f in result.get("features", []):
+            t = f.get("properties", {}).get("type", "unknown")
+            feature_types[t] = feature_types.get(t, 0) + 1
+        visual_text = "Features generated:\n" + "\n".join(f"  {k}: {v}" for k, v in feature_types.items())
+
+        output_json = json.dumps(result, indent=2)
+        return output_json, summary, visual_text, "✅ Design generated from GeoJSON"
+
+    except Exception as e:
+        return "{}", "", "", f"❌ Error: {str(e)}"
+
+
+def process_geojson_file(file_obj):
+    """Accept uploaded JSON file, run pipeline."""
+    if file_obj is None:
+        return "{}", "", None, "Please upload a GeoJSON file."
+    try:
+        with open(file_obj.name, "r", encoding="utf-8") as f:
+            content = f.read()
+        return process_geojson_input(content)
+    except Exception as e:
+        return "{}", "", None, f"❌ File error: {str(e)}"
+
+
+# Load sample files for display
+with open("samples/input_example.json", "r") as f:
+    SAMPLE_INPUT = f.read()
+with open("samples/output_example.json", "r") as f:
+    SAMPLE_OUTPUT = f.read()
+
+
 with gr.Blocks(title="Farm Drip Irrigation Designer") as demo:
     gr.Markdown(
         """
-# 🌾 Farm Drip Irrigation Designer (Phase 1)
+# 🌾 Farm Drip Irrigation Designer (Phase 1.5)
 
-**Geometry engine test**: Input your farm boundary, get an irrigation layout with cost estimates.
+**Geometry engine + Valve placement**: Test layouts with geofence text or GeoJSON from your app.
 
-**Input format**: Geofence coordinates as text, e.g., `0,0;100,0;100,100;0,100` (pixel or meter coords)
-
-*Note: This is a pure geometry tool. LLM integration coming in Phase 2.*
+Two modes:
+- **Quick Test**: Type coordinates, get instant design
+- **GeoJSON Pipeline**: Upload real farm data, get full valve + drip layout
 """
     )
 
-    with gr.Row():
-        with gr.Column(scale=1):
-            gr.Markdown("### Farm Boundary Input")
-            geofence_input = gr.Textbox(
-                label="Geofence (x,y;x,y;x,y...)",
-                value=DEFAULT_GEOFENCE,
-                lines=3,
-                info="Comma-separated coords, semicolon-separated points",
+    with gr.Tabs():
+        with gr.TabItem("Quick Test"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Farm Boundary Input")
+                    geofence_input = gr.Textbox(
+                        label="Geofence (x,y;x,y;x,y...)",
+                        value=DEFAULT_GEOFENCE,
+                        lines=3,
+                        info="Comma-separated coords, semicolon-separated points",
+                    )
+                    crop_dropdown = gr.Dropdown(
+                        label="Crop Type",
+                        choices=["tomato", "pepper", "lettuce", "cucumber", "orchard", "generic"],
+                        value=DEFAULT_CROP,
+                    )
+                    headland_slider = gr.Slider(
+                        label="Headland Buffer (m)",
+                        minimum=0.0, maximum=10.0, value=DEFAULT_HEADLAND, step=0.5,
+                    )
+                    spacing_slider = gr.Slider(
+                        label="Override Lateral Spacing (m)",
+                        minimum=0.0, maximum=5.0, value=0.0, step=0.1,
+                        info="Set to 0 to use crop default",
+                    )
+                    generate_btn = gr.Button("Generate Design", variant="primary")
+
+                with gr.Column(scale=1):
+                    gr.Markdown("### Design Visualization")
+                    design_image = gr.Image(label="Drip Layout", type="pil")
+                    status_text = gr.Textbox(label="Status", interactive=False)
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Bill of Materials (USD)")
+                    bom_json = gr.Code(label="BOM (JSON)", language="json")
+                with gr.Column():
+                    gr.Markdown("### Design Summary")
+                    summary_text = gr.Textbox(label="Summary", lines=15, interactive=False)
+
+            generate_btn.click(
+                fn=generate_design,
+                inputs=[geofence_input, crop_dropdown, headland_slider, spacing_slider],
+                outputs=[design_image, bom_json, summary_text, status_text],
             )
 
-            crop_dropdown = gr.Dropdown(
-                label="Crop Type",
-                choices=[
-                    "tomato",
-                    "pepper",
-                    "lettuce",
-                    "cucumber",
-                    "orchard",
-                    "generic",
+            gr.Markdown("### Example Geofences (copy & paste)")
+            gr.Examples(
+                examples=[
+                    ["0,0;100,0;100,100;0,100", "tomato", 1.0, 0.0],
+                    ["0,0;200,0;200,50;0,50", "lettuce", 1.0, 0.0],
+                    ["0,0;100,0;100,100;50,100;50,50;0,50", "pepper", 1.5, 0.0],
                 ],
-                value=DEFAULT_CROP,
-                info="Determines default lateral spacing & emitter discharge",
+                inputs=[geofence_input, crop_dropdown, headland_slider, spacing_slider],
+                fn=generate_design,
+                outputs=[design_image, bom_json, summary_text, status_text],
+                cache_examples=False,
             )
 
-            headland_slider = gr.Slider(
-                label="Headland Buffer (m)",
-                minimum=0.0,
-                maximum=10.0,
-                value=DEFAULT_HEADLAND,
-                step=0.5,
-                info="Inward buffer from field edge (for turning)",
-            )
+        with gr.TabItem("GeoJSON Pipeline"):
+            gr.Markdown(
+                """
+### Upload farm data as GeoJSON
 
-            spacing_slider = gr.Slider(
-                label="Override Lateral Spacing (m)",
-                minimum=0.0,
-                maximum=5.0,
-                value=0.0,
-                step=0.1,
-                info="Set to 0 to use crop default",
-            )
-
-            generate_btn = gr.Button("Generate Design", variant="primary")
+Upload a GeoJSON FeatureCollection with your farm boundary, pump location, and crop zones.
+The engine will place valves, generate drip layouts per zone, and return a complete design.
 
-        with gr.Column(scale=1):
-            gr.Markdown("### Design Visualization")
-            design_image = gr.Image(label="Drip Layout", type="pil")
-            status_text = gr.Textbox(label="Status", interactive=False)
+**Required**: `farm_boundary` (Polygon), `pump` (Point with pump_hp), crop zones (Polygons)
+**Output**: GeoJSON with valves, valve_zones, main_lines, laterals + BOM
+"""
+            )
 
-    with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Bill of Materials (USD)")
-            bom_json = gr.Code(label="BOM (JSON)", language="json")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Input")
+                    geojson_file = gr.File(
+                        label="Upload GeoJSON (.json)",
+                        file_types=[".json", ".geojson"],
+                    )
+                    geojson_text = gr.Textbox(
+                        label="Or paste GeoJSON here",
+                        lines=10,
+                        placeholder='{"type": "FeatureCollection", "features": [...]}',
+                    )
+                    with gr.Row():
+                        run_file_btn = gr.Button("Run from File", variant="primary")
+                        run_text_btn = gr.Button("Run from Text")
+
+                with gr.Column(scale=1):
+                    gr.Markdown("### Output")
+                    output_status = gr.Textbox(label="Status", interactive=False)
+                    output_visual = gr.Textbox(label="Features Generated", lines=6, interactive=False)
+
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Output GeoJSON")
+                    output_geojson = gr.Code(label="Result (GeoJSON)", language="json", lines=20)
+                with gr.Column():
+                    gr.Markdown("### Design Summary")
+                    output_summary = gr.Textbox(label="Summary", lines=20, interactive=False)
+
+            run_file_btn.click(
+                fn=process_geojson_file,
+                inputs=[geojson_file],
+                outputs=[output_geojson, output_summary, output_visual, output_status],
+            )
 
-        with gr.Column():
-            gr.Markdown("### Design Summary")
-            summary_text = gr.Textbox(label="Summary", lines=15, interactive=False)
+            run_text_btn.click(
+                fn=process_geojson_input,
+                inputs=[geojson_text],
+                outputs=[output_geojson, output_summary, output_visual, output_status],
+            )
 
-    # Wire up button
-    generate_btn.click(
-        fn=generate_design,
-        inputs=[geofence_input, crop_dropdown, headland_slider, spacing_slider],
-        outputs=[design_image, bom_json, summary_text, status_text],
-    )
+            gr.Markdown("### Example Input")
+            gr.Code(SAMPLE_INPUT, language="json", label="Sample Input")
 
-    # Example geofences for quick testing
-    gr.Markdown("### Example Geofences (copy & paste)")
-    gr.Examples(
-        examples=[
-            [
-                "0,0;100,0;100,100;0,100",
-                "tomato",
-                1.0,
-                0.0,
-            ],  # 100x100m square
-            [
-                "0,0;200,0;200,50;0,50",
-                "lettuce",
-                1.0,
-                0.0,
-            ],  # Long rectangle
-            [
-                "0,0;100,0;100,100;50,100;50,50;0,50",
-                "pepper",
-                1.5,
-                0.0,
-            ],  # L-shape
-        ],
-        inputs=[geofence_input, crop_dropdown, headland_slider, spacing_slider],
-        fn=generate_design,
-        outputs=[design_image, bom_json, summary_text, status_text],
-        cache_examples=False,
-    )
+            gr.Markdown("### Example Output")
+            gr.Code(SAMPLE_OUTPUT, language="json", label="Sample Output")
 
 
 if __name__ == "__main__":
-    # HF Spaces handles public access based on Space visibility settings
-    # Make the Space public in HF UI: Settings -> Change visibility -> Public
     demo.launch()

design_api.py

@@ -0,0 +1,425 @@
+"""
+Design API — End-to-end farm irrigation design pipeline.
+
+Orchestrates:
+  GeoJSON Input → Parse → Valve Placement → Drip Layout → GeoJSON Output
+
+Input:  GeoJSON FeatureCollection (farm_boundary, pump, crop_zones, elevation)
+Output: GeoJSON FeatureCollection (valves, zones, mains, laterals, BOM)
+"""
+
+import json
+import math
+from typing import Dict, List, Any, Tuple, Optional
+from shapely.geometry import Polygon, Point, LineString
+
+import geojson_io as gj_io
+from drip_engine import (
+    generate_drip_layout,
+    estimate_bom,
+    latlon_to_utm,
+    CROP_DEFAULTS,
+    DripLayoutError,
+)
+from valve_engine import (
+    place_valves_hierarchical,
+    generate_valve_zones,
+    calculate_pump_flow_lph,
+    calculate_total_emitter_flow,
+    calculate_num_zones,
+    choose_manifold_strategy,
+    ValveEngineError,
+)
+
+
+class DesignAPIError(Exception):
+    """Top-level exception for design pipeline errors."""
+    pass
+
+
+def process_farm_design(geojson_input: str) -> Dict[str, Any]:
+    """
+    Main entry point: parse GeoJSON input, run design pipeline, return GeoJSON output.
+
+    Args:
+        geojson_input: GeoJSON FeatureCollection string (or dict)
+
+    Returns:
+        Dict that is a GeoJSON FeatureCollection with:
+          - properties: design_summary, bom
+          - features: farm_boundary, valves, valve_zones, main_lines, laterals
+
+    Raises:
+        DesignAPIError: On any pipeline failure (with structured error info)
+    """
+    try:
+        # ── 1. Parse input ──────────────────────────────────────────────
+        fc = gj_io.parse_geojson_feature_collection(geojson_input)
+        features = fc.get("features", [])
+        top_props = fc.get("properties", {})
+
+        # ── 2. Extract geometries ───────────────────────────────────────
+        farm_boundary, _ = gj_io.extract_farm_boundary(fc)
+        pump_point, pump_props = gj_io.extract_pump_location(fc)
+        crop_zones = gj_io.extract_crop_zones(fc)
+        elevation_data = gj_io.extract_elevation_data(fc)
+
+        # ── 3. Resolve parameters (top-level props override feature props)
+        pump_hp = _resolve_pump_hp(top_props, pump_props, features)
+        centralized = _resolve_centralized(top_props)
+        headland_m = top_props.get("headland_buffer_m", 1.0)
+        override_spacing = top_props.get("override_lateral_spacing_m")
+
+        # ── 4. Convert to UTM for accurate calculations ─────────────────
+        # Farm boundary lat/lon → UTM
+        farm_utm = latlon_to_utm(farm_boundary)
+        pump_utm = _transform_point_to_utm(pump_point, farm_boundary)
+
+        # Convert crop zone polygons to UTM
+        crop_zones_utm = []
+        for zone in crop_zones:
+            zone_poly = zone.get("polygon")
+            if zone_poly is None:
+                continue
+            zone_utm = latlon_to_utm(zone_poly)
+            crop_zones_utm.append({
+                "crop": zone.get("crop", "generic"),
+                "polygon": zone_utm,
+                "area_m2": zone_utm.area,
+            })
+
+        # If no explicit crop zones, treat entire farm as single generic zone
+        if not crop_zones_utm:
+            crop_zones_utm = [{
+                "crop": "generic",
+                "polygon": farm_utm,
+                "area_m2": farm_utm.area,
+            }]
+
+        # ── 5. Run valve placement engine ──────────────────────────────
+        valves = place_valves_hierarchical(
+            farm_polygon=farm_utm,
+            pump_point=pump_utm,
+            crop_zones=crop_zones_utm,
+            pump_hp=pump_hp,
+            centralized=centralized,
+            elevation_data=elevation_data,
+        )
+
+        zones = generate_valve_zones(farm_utm, valves)
+
+        # ── 6. Run drip layout per zone ────────────────────────────────
+        all_drip_designs = []
+        all_boms = []
+        zone_summaries = []
+
+        for zone in zones:
+            zone_poly = zone["polygon"]
+            valve_id = zone["valve_id"]
+
+            # Determine crop for this zone (from valve metadata or default)
+            valve_meta = next((v for v in valves if v["id"] == valve_id), None)
+            crop = valve_meta.get("crop", "generic") if valve_meta else "generic"
+
+            try:
+                design = generate_drip_layout(
+                    polygon_utm=zone_poly,
+                    crop=crop,
+                    headland_buffer_m=headland_m,
+                    override_spacing_m=override_spacing if override_spacing else None,
+                )
+                bom = estimate_bom(design, unit="usd")
+                all_drip_designs.append((valve_id, design))
+                all_boms.append(bom)
+                zone_summaries.append({
+                    "valve_id": valve_id,
+                    "crop": crop,
+                    "area_ha": design["farm_area_ha"],
+                    "emitters": design["emitter_count"],
+                    "main_m": design["total_main_length_m"],
+                    "lateral_m": design["total_drip_tape_m"],
+                })
+            except DripLayoutError as e:
+                # Zone too small after headland — skip with warning
+                zone_summaries.append({
+                    "valve_id": valve_id,
+                    "crop": crop,
+                    "error": str(e),
+                })
+
+        # ── 7. Aggregate totals ─────────────────────────────────────────
+        total_area_ha = sum(s.get("area_ha", 0) for s in zone_summaries if "area_ha" in s)
+        total_emitters = sum(s.get("emitters", 0) for s in zone_summaries if "emitters" in s)
+        total_main_m = sum(s.get("main_m", 0) for s in zone_summaries if "main_m" in s)
+        total_lateral_m = sum(s.get("lateral_m", 0) for s in zone_summaries if "lateral_m" in s)
+
+        # Aggregate BOM
+        total_bom = {
+            "main_line_16mm_m": round(sum(b.get("main_line_16mm_m", 0) for b in all_boms), 2),
+            "drip_tape_16mm_m": round(sum(b.get("drip_tape_16mm_m", 0) for b in all_boms), 2),
+            "inline_emitters": sum(b.get("inline_emitters", 0) for b in all_boms),
+            "total_pipe_m": round(sum(b.get("total_pipe_m", 0) for b in all_boms), 2),
+            "valves_count": len(valves),
+        }
+        if all_boms and "cost_main" in all_boms[0]:
+            total_bom["cost_main"] = round(sum(b.get("cost_main", 0) for b in all_boms), 2)
+            total_bom["cost_drip_tape"] = round(sum(b.get("cost_drip_tape", 0) for b in all_boms), 2)
+            total_bom["cost_emitters"] = round(sum(b.get("cost_emitters", 0) for b in all_boms), 2)
+            total_bom["cost_valves"] = round(len(valves) * 15.0, 2)  # $15 per valve estimate
+            total_bom["total_cost_usd"] = round(
+                total_bom.get("cost_main", 0)
+                + total_bom.get("cost_drip_tape", 0)
+                + total_bom.get("cost_emitters", 0)
+                + total_bom.get("cost_valves", 0),
+                2,
+            )
+
+        # ── 8. Convert back to lat/lon for GeoJSON output ───────────────
+        # Build output features in UTM, then transform all coordinates back
+        output_features = []
+
+        # Farm boundary (echo input)
+        output_features.append({
+            "type": "Feature",
+            "properties": {"type": "farm_boundary", "area_ha": round(total_area_ha, 2)},
+            "geometry": _polygon_to_geojson(farm_boundary),
+        })
+
+        # Valves (convert UTM points back to lat/lon)
+        for valve in valves:
+            valve_point_utm = valve["location"]
+            valve_point_latlon = _transform_point_from_utm(valve_point_utm, farm_boundary)
+            output_features.append({
+                "type": "Feature",
+                "properties": {
+                    "type": "valve",
+                    "id": valve["id"],
+                    "strategy": valve["strategy"],
+                    "reason": valve["reason"],
+                    "crop": valve.get("crop", "generic"),
+                },
+                "geometry": {
+                    "type": "Point",
+                    "coordinates": [valve_point_latlon.x, valve_point_latlon.y],
+                },
+            })
+
+        # Valve zones (convert UTM polygons back to lat/lon)
+        for zone in zones:
+            zone_poly_utm = zone["polygon"]
+            zone_poly_latlon = _transform_polygon_from_utm(zone_poly_utm, farm_boundary)
+            output_features.append({
+                "type": "Feature",
+                "properties": {
+                    "type": "valve_zone",
+                    "valve_id": zone["valve_id"],
+                    "area_m2": round(zone["area_m2"], 2),
+                    "area_ha": round(zone["area_m2"] / 10000, 4),
+                },
+                "geometry": _polygon_to_geojson(zone_poly_latlon),
+            })
+
+        # Drip layout: main lines and laterals per zone
+        for valve_id, design in all_drip_designs:
+            # Main line
+            main_utm = design["main_line"]
+            main_latlon = _transform_linestring_from_utm(main_utm, farm_boundary)
+            output_features.append({
+                "type": "Feature",
+                "properties": {
+                    "type": "main_line",
+                    "valve_id": valve_id,
+                    "length_m": round(main_utm.length, 2),
+                    "crop": design["crop"],
+                },
+                "geometry": _linestring_to_geojson(main_latlon),
+            })
+
+            # Laterals
+            for i, lateral_utm in enumerate(design["laterals"]):
+                lateral_latlon = _transform_linestring_from_utm(lateral_utm, farm_boundary)
+                output_features.append({
+                    "type": "Feature",
+                    "properties": {
+                        "type": "lateral",
+                        "index": i,
+                        "valve_id": valve_id,
+                        "length_m": round(lateral_utm.length, 2),
+                        "spacing_m": design["design_params"]["lateral_spacing_m"],
+                    },
+                    "geometry": _linestring_to_geojson(lateral_latlon),
+                })
+
+        # ── 9. Build output FeatureCollection ────────────────────────────
+        output = {
+            "type": "FeatureCollection",
+            "properties": {
+                "type": "farm_design",
+                "farm_id": top_props.get("farm_id", "unknown"),
+                "generated_at": _iso_timestamp(),
+                "design_summary": {
+                    "farm_area_ha": round(total_area_ha, 2),
+                    "total_valves": len(valves),
+                    "total_drip_tape_m": round(total_lateral_m, 2),
+                    "total_main_line_m": round(total_main_m, 2),
+                    "total_emitters": total_emitters,
+                    "pump_hp": pump_hp,
+                    "pump_flow_lph": round(calculate_pump_flow_lph(pump_hp), 2),
+                    "manifold_strategy": choose_manifold_strategy(farm_utm.area),
+                },
+                "bom": total_bom,
+                "zone_details": zone_summaries,
+            },
+            "features": output_features,
+        }
+
+        return output
+
+    except (gj_io.GeoJSONError, ValveEngineError, DripLayoutError) as e:
+        # Structured error response (still valid GeoJSON)
+        return _error_response(str(e), type(e).__name__)
+    except Exception as e:
+        return _error_response(str(e), "INTERNAL_ERROR")
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Helpers
+# ──────────────────────────────────────────────────────────────────────
+
+def _resolve_pump_hp(top_props: Dict, pump_props: Dict, features: List[Dict]) -> float:
+    """Get pump HP from top-level, pump feature, or feature scan."""
+    # Top-level property takes precedence
+    if "pump_hp" in top_props and top_props["pump_hp"] is not None:
+        return float(top_props["pump_hp"])
+    # Pump feature property
+    if "pump_hp" in pump_props and pump_props["pump_hp"] is not None:
+        return float(pump_props["pump_hp"])
+    # Scan all features
+    hp = gj_io.validate_pump_hp(features)
+    if hp is not None:
+        return hp
+    raise DesignAPIError("No pump_hp found in input. Add 'pump_hp' to top-level properties or pump feature.")
+
+
+def _resolve_centralized(top_props: Dict) -> bool:
+    """Get centralized flag from top-level properties (default True)."""
+    val = top_props.get("centralized")
+    if isinstance(val, bool):
+        return val
+    if isinstance(val, str):
+        return val.lower() in ("true", "yes", "1", "centralized")
+    # Default: small farms centralized, large distributed
+    return True
+
+
+def _transform_point_to_utm(point: Point, reference_polygon: Polygon) -> Point:
+    """Transform a lat/lon Point to the same UTM zone as reference_polygon."""
+    import pyproj
+    centroid = reference_polygon.centroid
+    lon, lat = centroid.x, centroid.y
+    utm_zone = int((lon + 180) / 6) + 1
+    is_southern = lat < 0
+    utm_crs = f"EPSG:{32700 + utm_zone if is_southern else 32600 + utm_zone}"
+    transformer = pyproj.Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True)
+    x, y = transformer.transform(point.x, point.y)
+    return Point(x, y)
+
+
+def _transform_point_from_utm(point: Point, reference_polygon: Polygon) -> Point:
+    """Transform a UTM Point back to lat/lon using reference_polygon's zone."""
+    import pyproj
+    centroid = reference_polygon.centroid
+    lon, lat = centroid.x, centroid.y
+    utm_zone = int((lon + 180) / 6) + 1
+    is_southern = lat < 0
+    utm_crs = f"EPSG:{32700 + utm_zone if is_southern else 32600 + utm_zone}"
+    transformer = pyproj.Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    x, y = transformer.transform(point.x, point.y)
+    return Point(x, y)
+
+
+def _transform_polygon_from_utm(polygon: Polygon, reference_polygon: Polygon) -> Polygon:
+    """Transform a UTM Polygon back to lat/lon."""
+    import pyproj
+    centroid = reference_polygon.centroid
+    lon, lat = centroid.x, centroid.y
+    utm_zone = int((lon + 180) / 6) + 1
+    is_southern = lat < 0
+    utm_crs = f"EPSG:{32700 + utm_zone if is_southern else 32600 + utm_zone}"
+    transformer = pyproj.Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    coords = []
+    for x, y in polygon.exterior.coords:
+        lon_out, lat_out = transformer.transform(x, y)
+        coords.append((lon_out, lat_out))
+    return Polygon(coords)
+
+
+def _transform_linestring_from_utm(line: LineString, reference_polygon: Polygon) -> LineString:
+    """Transform a UTM LineString back to lat/lon."""
+    import pyproj
+    centroid = reference_polygon.centroid
+    lon, lat = centroid.x, centroid.y
+    utm_zone = int((lon + 180) / 6) + 1
+    is_southern = lat < 0
+    utm_crs = f"EPSG:{32700 + utm_zone if is_southern else 32600 + utm_zone}"
+    transformer = pyproj.Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    coords = []
+    for x, y in line.coords:
+        lon_out, lat_out = transformer.transform(x, y)
+        coords.append((lon_out, lat_out))
+    return LineString(coords)
+
+
+def _polygon_to_geojson(polygon: Polygon) -> Dict:
+    """Convert Shapely Polygon to GeoJSON Polygon dict."""
+    coords = []
+    for x, y in polygon.exterior.coords:
+        coords.append([x, y])
+    return {"type": "Polygon", "coordinates": [coords]}
+
+
+def _linestring_to_geojson(line: LineString) -> Dict:
+    """Convert Shapely LineString to GeoJSON LineString dict."""
+    coords = []
+    for x, y in line.coords:
+        coords.append([x, y])
+    return {"type": "LineString", "coordinates": coords}
+
+
+def _iso_timestamp() -> str:
+    """Return current ISO timestamp string."""
+    from datetime import datetime, timezone
+    return datetime.now(timezone.utc).isoformat()
+
+
+def _error_response(message: str, code: str) -> Dict:
+    """Return a valid GeoJSON FeatureCollection containing error info."""
+    return {
+        "type": "FeatureCollection",
+        "properties": {
+            "type": "farm_design_error",
+            "error": {
+                "code": code,
+                "message": message,
+            },
+        },
+        "features": [],
+    }
+
+
+# ──────────────────────────────────────────────────────────────────────
+# Convenience functions
+# ──────────────────────────────────────────────────────────────────────
+
+def process_from_file(file_path: str) -> str:
+    """Read GeoJSON from file, run pipeline, return JSON string."""
+    with open(file_path, "r", encoding="utf-8") as f:
+        geojson_str = f.read()
+    result = process_farm_design(geojson_str)
+    return json.dumps(result, indent=2)
+
+
+def process_from_string(geojson_str: str) -> str:
+    """Run pipeline on GeoJSON string, return JSON string."""
+    result = process_farm_design(geojson_str)
+    return json.dumps(result, indent=2)