Upload 5 files

src/calculations.py

@@ -0,0 +1,380 @@
+import math
+import pandas as pd
+import numpy as np
+from typing import List, Dict, Any, Tuple
+from models import CartonSpecification, FactoryConfig, FluteProfile
+
+class CorruLabEngine:
+    """
+    Stateless Logic Engine for CorruLab Enterprise.
+    Handles Physics, Optimization, and Costing.
+    """
+
+    @staticmethod
+    def calculate_ect_rct_method(spec: CartonSpecification, config: FactoryConfig) -> Dict[str, Any]:
+        """
+        Calculate ECT using the summation of RCT values multiplied by a Conversion Factor.
+        ECT = (Sum(Liner RCT) + Sum(Medium RCT * Takeup Factor)) * Efficiency * Moisture Factor
+        Factory RCT is in kgf, convert to kN/m: RCT(kgf) × 9.81 / 152.4 = kN/m
+        Moisture correction: higher moisture = lower strength
+        """
+        raw_ect = 0.0
+        # Conversion factor: kgf to kN/m = 9.81 N/kgf ÷ 152.4 mm sample
+        KGF_TO_KN_M = 9.81 / 152.4
+        
+        # Calculate average moisture across layers
+        total_moisture = sum(l.paper.moisture_pct for l in spec.layers)
+        avg_moisture = total_moisture / len(spec.layers) if spec.layers else 7.5
+        
+        # Moisture correction factor (research-based)
+        # Formula: Strength Factor = 1 / (M × 0.07 + 0.47)
+        # At 7.5% moisture (optimal), factor = 1 / (7.5 × 0.07 + 0.47) = 1 / 0.995 ≈ 1.0
+        # At 10% moisture, factor = 1 / (10 × 0.07 + 0.47) = 1 / 1.17 ≈ 0.85
+        # Normalize to 7.5% baseline
+        baseline_factor = 1 / (7.5 * 0.07 + 0.47)  # ~1.005
+        current_factor = 1 / (avg_moisture * 0.07 + 0.47)
+        moisture_factor = current_factor / baseline_factor  # Relative to optimal
+        
+        explanation_steps = [
+            "#### 1. Paper Strength (RCT → ECT)",
+            "Your factory measures **Ring Crush Test (RCT)** in **kgf**. We convert to ECT (kN/m):",
+            "",
+            "> **ECT (kN/m) = RCT (kgf) × 9.81 ÷ 152.4**",
+            "",
+            "**Layer-by-Layer Calculation:**"
+        ]
+        
+        for i, layer in enumerate(spec.layers):
+            # Convert RCT from kgf to kN/m
+            rct_kn_m = layer.paper.rct_cd_N * KGF_TO_KN_M
+            
+            if layer.layer_type == "Liner":
+                contribution = rct_kn_m
+                raw_ect += contribution
+                explanation_steps.append(f"*   **Liner {i+1} ({layer.paper.code})**: {contribution:.2f} kN/m (from {layer.paper.rct_cd_N:.1f} kgf)")
+            elif layer.layer_type == "Flute" and layer.flute_profile:
+                # Flute contribution = RCT × Takeup Factor
+                contribution = rct_kn_m * layer.flute_profile.factor
+                raw_ect += contribution
+                explanation_steps.append(f"*   **Flute {i+1} ({layer.paper.code})**: {contribution:.2f} kN/m _(from {layer.paper.rct_cd_N:.1f} kgf × {layer.flute_profile.factor})_")
+
+        # Apply Conversion Factor (Process Loss) and Moisture Factor
+        final_ect = raw_ect * config.ect_conversion_factor * moisture_factor
+        
+        explanation_steps.append("")
+        explanation_steps.append("#### 2. Reality Adjustments")
+        explanation_steps.append(f"*   **Theoretical Sum**: {raw_ect:.2f} kN/m")
+        explanation_steps.append(f"*   **Process Factor**: ×{config.ect_conversion_factor}")
+        explanation_steps.append("")
+        explanation_steps.append("#### 3. Moisture Correction")
+        explanation_steps.append("Paper absorbs moisture from air, which **weakens fiber bonds** and reduces compression strength.")
+        explanation_steps.append("")
+        explanation_steps.append("**The Formula:**")
+        explanation_steps.append("> **Strength Factor = 1 ÷ (M × 0.07 + 0.47)**")
+        explanation_steps.append("")
+        explanation_steps.append("**Where the constants come from:**")
+        explanation_steps.append("- **0.07**: Rate at which strength decreases per 1% moisture increase")
+        explanation_steps.append("- **0.47**: Base factor at 0% moisture (theoretical)")
+        explanation_steps.append("- _Source: Georgia Tech Paper Research (SCT moisture correction formula)_")
+        explanation_steps.append("")
+        explanation_steps.append("**Your Calculation:**")
+        denominator = avg_moisture * 0.07 + 0.47
+        raw_factor = 1 / denominator
+        explanation_steps.append(f"```")
+        explanation_steps.append(f"Step 1: M × 0.07 = {avg_moisture:.1f} × 0.07 = {avg_moisture * 0.07:.3f}")
+        explanation_steps.append(f"Step 2: Add 0.47 = {avg_moisture * 0.07:.3f} + 0.47 = {denominator:.3f}")
+        explanation_steps.append(f"Step 3: Invert = 1 ÷ {denominator:.3f} = {raw_factor:.3f}")
+        explanation_steps.append(f"Step 4: Normalize to 7.5% = {moisture_factor:.3f}")
+        explanation_steps.append(f"```")
+        explanation_steps.append("")
+        explanation_steps.append("| Moisture % | Calculation | Strength Factor |")
+        explanation_steps.append("|------------|-------------|-----------------|")
+        explanation_steps.append("| 7.5% (Optimal) | 1÷(7.5×0.07+0.47) | 1.00 |")
+        explanation_steps.append("| 9% | 1÷(9×0.07+0.47) | 0.95 |")
+        explanation_steps.append("| 10% | 1÷(10×0.07+0.47) | 0.88 |")
+        explanation_steps.append("| 12% | 1÷(12×0.07+0.47) | 0.75 |")
+        explanation_steps.append("")
+        explanation_steps.append(f"**Your Result:** Avg Moisture = {avg_moisture:.1f}% → Factor = **×{moisture_factor:.2f}**")
+        if avg_moisture > 9:
+            explanation_steps.append(f"")
+            explanation_steps.append(f"> ⚠️ **High moisture ({avg_moisture:.1f}%) reduces strength by {(1-moisture_factor)*100:.0f}%**")
+        explanation_steps.append("")
+        explanation_steps.append(f"#### ✅ Final ECT: **{final_ect:.2f} kN/m**")
+        explanation_steps.append(f"_= {raw_ect:.2f} × {config.ect_conversion_factor} × {moisture_factor:.2f}_")
+
+        return {
+            "ect_value": final_ect,
+            "moisture_factor": moisture_factor,
+            "avg_moisture": avg_moisture,
+            "explanation": "\n\n".join(explanation_steps)
+        }
+
+    @staticmethod
+    def calculate_bct_mckee(spec: CartonSpecification, ect_value: float, config: FactoryConfig) -> Dict[str, Any]:
+        """
+        Calculate BCT using McKee Formula + Process Efficiency.
+        BCT (N) = 5.87 * ECT (kN/m) * sqrt(Perimeter (mm) * Thickness (mm)) * Efficiency
+        """
+        perimeter_mm = (2 * spec.length_mm) + (2 * spec.width_mm)
+        
+        # Calculate total thickness
+        thickness_mm = 0.0
+        flute_heights = []
+        for layer in spec.layers:
+            if layer.layer_type == "Flute" and layer.flute_profile:
+                thickness_mm += layer.flute_profile.height_mm
+                flute_heights.append(f"{layer.flute_profile.height_mm} ({layer.flute_profile.name})")
+            else:
+                thickness_mm += 0.25 # Approx liner thickness
+        
+        # McKee Calculation
+        # Convert to Imperial for the calculation to match the constant 5.87 (which is for Imperial)
+        ect_lb_in = ect_value * 5.71 # 1 kN/m = 5.71 lb/in
+        p_in = perimeter_mm / 25.4
+        t_in = thickness_mm / 25.4
+        
+        # The constant 5.87 is specific to RSC boxes in Imperial units
+        bct_lbs_theoretical = 5.87 * ect_lb_in * math.sqrt(p_in * t_in)
+        
+        # Apply Process Efficiency
+        efficiency = config.process_efficiency_pct / 100.0
+        bct_lbs_real = bct_lbs_theoretical * efficiency
+        
+        bct_kg = bct_lbs_real * 0.453592
+        
+        explanation_steps = [
+            "#### 1. Geometry (Metric)",
+            f"*   **Perimeter (P)**: 2 × (L + W) = 2 × ({spec.length_mm} + {spec.width_mm}) = **{perimeter_mm:.0f} mm**",
+            f"*   **Thickness (T)**: Sum of Flutes ({' + '.join(flute_heights)}) + Liners ≈ **{thickness_mm:.2f} mm**",
+            "",
+            "#### 2. Unit Conversion (Imperial)",
+            "The standard McKee formula uses Imperial units (lbs, inches). We convert our inputs:",
+            f"*   **ECT**: {ect_value:.2f} kN/m × 5.71 = **{ect_lb_in:.2f} lb/in**",
+            f"*   **Perimeter**: {perimeter_mm:.0f} mm ÷ 25.4 = **{p_in:.2f} in**",
+            f"*   **Thickness**: {thickness_mm:.2f} mm ÷ 25.4 = **{t_in:.3f} in**",
+            "",
+            "#### 3. The McKee Formula",
+            "> BCT = 5.87 × ECT × √(Thickness × Perimeter)",
+            "",
+            f"**Calculation:**",
+            f"*   √(T × P) = √({t_in:.3f} × {p_in:.2f}) = **{math.sqrt(p_in*t_in):.2f}**",
+            f"*   BCT = 5.87 × {ect_lb_in:.2f} × {math.sqrt(p_in*t_in):.2f} = **{bct_lbs_theoretical:.1f} lbs**",
+            "",
+            "#### 4. Final Result (Metric)",
+            f"*   **Theoretical**: {bct_lbs_theoretical:.1f} lbs = **{bct_lbs_theoretical*0.453592:.1f} kg**",
+            f"*   **Process Efficiency**: {config.process_efficiency_pct}% (Loss due to converting)",
+            f"#### 💥 Final BCT: {bct_lbs_theoretical*0.453592:.1f} kg × {efficiency:.2f} = **{bct_kg:.1f} kg**"
+        ]
+        
+        return {
+            "bct_kg": bct_kg,
+            "thickness_mm": thickness_mm,
+            "explanation": "\n".join(explanation_steps)
+        }
+
+    @staticmethod
+    def calculate_box_burst(spec: CartonSpecification) -> Dict[str, Any]:
+        """
+        Calculate Box Bursting Strength.
+        Sum of Liner Burst Strengths.
+        """
+        total_burst = 0.0
+        explanation_steps = ["#### Combined Burst Strength", "Bursting Strength measures resistance to puncture (e.g., rough handling). It is the sum of all Liner strengths:"]
+        
+        for i, layer in enumerate(spec.layers):
+            if layer.layer_type == "Liner":
+                contribution = layer.paper.bursting_strength_kpa
+                total_burst += contribution
+                explanation_steps.append(f"*   **Liner {i+1} ({layer.paper.code})**: {contribution:.0f} kPa")
+                
+        explanation_steps.append(f"#### ✅ Total Burst: **{total_burst:.0f} kPa**")
+                
+        return {
+            "burst_kpa": total_burst,
+            "explanation": "\n\n".join(explanation_steps)
+        }
+
+    @staticmethod
+    def predict_lifecycle(initial_bct_kg: float, humidity_pct: float) -> pd.DataFrame:
+        """
+        Generate Strength vs Days curve.
+        Degradation based on Humidity.
+        """
+        
+        days = pd.Series(range(1, 91)) # 1 to 90 days
+        
+        if humidity_pct < 50:
+            decay_factor = 0.02
+        elif humidity_pct < 70:
+            decay_factor = 0.05
+        elif humidity_pct < 85:
+            decay_factor = 0.10
+        else:
+            decay_factor = 0.15
+            
+        k = ((humidity_pct - 30) / 100.0) * 0.5
+        
+        retention = 1.0 - (k * np.log10(days + 1))
+        retention = np.clip(retention, 0.2, 1.0) # Min 20% strength
+        
+        safe_load = initial_bct_kg * retention
+        
+        return pd.DataFrame({
+            "Days": days,
+            "Safe Load (kg)": safe_load,
+            "Target": [initial_bct_kg * 0.6] * len(days) # Example red line
+        })
+
+    @staticmethod
+    def calculate_wastage_per_layer(spec: CartonSpecification, config: FactoryConfig) -> pd.DataFrame:
+        """
+        Calculate usage and wastage stats for each layer based on its assigned deckle.
+        """
+        results = []
+        
+        sheet_w = spec.width_mm + spec.height_mm
+        
+        for i, layer in enumerate(spec.layers):
+            deckle = layer.deckle_mm if layer.deckle_mm and layer.deckle_mm > 0 else 0
+            
+            if deckle > 0:
+                ups = int(deckle / sheet_w)
+                if ups < 1: ups = 1 # Fallback to avoid div by zero, implies invalid deckle
+                
+                used_width = ups * sheet_w
+                trim_mm = deckle - used_width
+                trim_pct = (trim_mm / deckle) * 100
+            else:
+                # No deckle provided? Assume perfect fit or standard logic
+                ups = 1
+                trim_mm = 0
+                trim_pct = 0.0
+            
+            results.append({
+                "layer_idx": i,
+                "layer_type": layer.layer_type,
+                "paper": layer.paper.code,
+                "deckle_mm": deckle,
+                "ups": ups,
+                "trim_mm": trim_mm,
+                "trim_pct": trim_pct
+            })
+            
+        return pd.DataFrame(results)
+
+    @staticmethod
+    def calculate_granular_cost(spec: CartonSpecification, config: FactoryConfig, 
+                                wastage_df: pd.DataFrame, order_qty: int) -> Dict[str, Any]:
+        """
+        Detailed Costing with specific layer wastage and process costs.
+        """
+        # 1. Paper Cost & Wastage
+        # Sheet Dimensions (One Box - Full Rectangle)
+        # Factory buys/processes FULL rectangle. Stitch cut-outs become WASTE.
+        sheet_length_mm = 2*spec.length_mm + 2*spec.width_mm + spec.stitch_allowance_mm
+        sheet_width_mm = spec.width_mm + spec.height_mm
+        sheet_area_m2 = (sheet_length_mm * sheet_width_mm) / 1_000_000.0
+        
+        # Stitch cut-out waste (flaps above/below stitch are cut and wasted)
+        flap_height = min(spec.length_mm, spec.width_mm) / 2.0  # RSC standard flap
+        stitch_cutout_area_m2 = (spec.stitch_allowance_mm * 2 * flap_height) / 1_000_000.0
+        
+        total_paper_cost_net = 0.0
+        total_paper_cost_gross = 0.0
+        paper_breakdown = []
+        
+        for i, layer in enumerate(spec.layers):
+            # Takeup Factor
+            takeup = layer.flute_profile.factor if layer.flute_profile else 1.0
+            
+            # Net Weight (Theoretical box only)
+            weight_gsm = layer.paper.gsm * takeup
+            weight_sheet_net_kg = weight_gsm * sheet_area_m2 / 1000.0
+            
+            # Wastage Factors
+            row = wastage_df.loc[wastage_df['layer_idx'] == i].iloc[0]
+            trim_pct = row['trim_pct']
+            
+            # Gross Weight Calculation:
+            # 1. Process Waste added first (e.g. corrugator damage)
+            w_process = weight_sheet_net_kg * (1 + config.wastage_process_pct/100.0)
+            
+            # 2. Trim Waste (The gross paper used includes the trim area)
+            # If Trim is 10%, it means we paid for 100% but only used 90%. 
+            # So Gross = Net / (1 - Trim%) -- OR simply Gross = Net * (Deckle / UsedWidth)
+            # Let's use the explicit ratio from the deckle calc for precision
+            if row['deckle_mm'] > 0 and row['ups'] > 0:
+                 deckle_utilization = (row['ups'] * (spec.width_mm + spec.height_mm)) / row['deckle_mm']
+                 if deckle_utilization > 0:
+                     w_gross = w_process / deckle_utilization
+                 else:
+                     w_gross = w_process
+            else:
+                 w_gross = w_process # No trim calc possible
+                 
+            # Cost
+            cost_net = weight_sheet_net_kg * layer.paper.rate
+            cost_gross = w_gross * layer.paper.rate
+            
+            total_paper_cost_net += cost_net
+            total_paper_cost_gross += cost_gross
+            
+            paper_breakdown.append({
+                "layer": layer.paper.code,
+                "gsm": layer.paper.gsm,
+                "cost_net": cost_net,
+                "cost_gross": cost_gross,
+                "waste_cost": cost_gross - cost_net,
+                "weight_net": weight_sheet_net_kg * order_qty,
+                "weight_gross": w_gross * order_qty
+            })
+            
+        # 2. Fixed Wastage (Peel + Core) - REMOVED
+        wastage_fixed_per_box = 0.0
+        
+        # 3. Weight per box (for reference)
+        weight_box_net = sum(l.paper.gsm * (l.flute_profile.factor if l.flute_profile else 1.0) for l in spec.layers) * sheet_area_m2 / 1000.0
+        
+        # 4. Value Added Processes (Only if enabled by user)
+        print_cost = 0.0
+        uv_cost = 0.0
+        lam_cost = 0.0
+        die_cost = 0.0
+        
+        if spec.has_printing:
+            # Rate per 1000 + Plate Cost / Qty
+            print_cost = (config.cost_printing_per_1000 / 1000.0) + (config.cost_printing_plate / order_qty)
+            
+        if spec.has_uv:
+            uv_cost = config.cost_uv_per_1000 / 1000.0
+            
+        if spec.has_lamination:
+            lam_cost = config.cost_lamination_per_1000 / 1000.0
+            
+        if spec.has_die_cutting:
+            die_cost = (config.cost_die_cutting_per_1000 / 1000.0) + (config.cost_die_frame / order_qty)
+
+        # Total Factory Cost = Paper + Waste + Value-Add + Setup
+        factory_cost = (total_paper_cost_gross + 
+                        print_cost + uv_cost + lam_cost + die_cost +
+                        (config.cost_fixed_setup/order_qty))
+        
+        # Price
+        price = factory_cost * (1 + config.margin_pct/100.0)
+        
+        return {
+            "paper_cost_net": total_paper_cost_net,
+            "paper_cost_gross": total_paper_cost_gross,
+            "trim_and_process_waste_cost": total_paper_cost_gross - total_paper_cost_net,
+            "print_cost": print_cost,
+            "uv_cost": uv_cost,
+            "lam_cost": lam_cost,
+            "die_cost": die_cost,
+            "setup_cost": config.cost_fixed_setup/order_qty,
+            "factory_cost": factory_cost,
+            "price": price,
+            "weight_per_box": weight_box_net,
+            "stitch_cutout_waste_kg": stitch_cutout_area_m2 * sum(l.paper.gsm * (l.flute_profile.factor if l.flute_profile else 1.0) for l in spec.layers) / 1000.0 * order_qty,
+            "stitch_cutout_area_m2": stitch_cutout_area_m2,
+            "breakdown": paper_breakdown
+        }

src/config.py

@@ -0,0 +1,27 @@
+"""
+Configuration settings for Usman Packaging MRP System.
+Controls data source switching between local development and HuggingFace production.
+"""
+import os
+
+# ============================================================================
+# DEVELOPMENT MODE TOGGLE
+# ============================================================================
+# True  = Use local data folder (for development)
+# False = Fetch from Hugging Face dataset repository (for production/HF Spaces)
+# 
+# Set via environment variable in HF Space settings:
+#   DEV_MODE=false
+# ============================================================================
+DEV_MODE = os.getenv("DEV_MODE", "true").lower() == "true"
+
+# ============================================================================
+# HUGGING FACE CONFIGURATION
+# ============================================================================
+# Your HuggingFace dataset repository containing paper_db.json and factory_settings.json
+HF_REPO_ID = os.getenv("HF_REPO_ID", "Waqasjan123/usman-packaging-data")
+HF_REPO_TYPE = "dataset"
+
+# Data file names (used by both local and HF loading)
+PAPER_DB_FILENAME = "paper_db.json"
+FACTORY_SETTINGS_FILENAME = "factory_settings.json"

src/data_loader.py

@@ -0,0 +1,119 @@
+"""
+Data Loader - Handles loading data from local storage or HuggingFace.
+Automatically switches based on DEV_MODE configuration.
+"""
+import json
+from pathlib import Path
+from typing import Tuple, List
+
+from config import (
+    DEV_MODE, 
+    HF_REPO_ID, 
+    HF_REPO_TYPE,
+    PAPER_DB_FILENAME,
+    FACTORY_SETTINGS_FILENAME
+)
+from models import FluteProfile, PaperGrade, FactoryConfig
+
+# Get the directory where this file is located
+BASE_DIR = Path(__file__).parent
+
+
+def _load_from_local() -> Tuple[List[PaperGrade], "FactoryConfig", List[FluteProfile]]:
+    """Load data from local data/ folder."""
+    print("📁 Loading data from LOCAL storage...")
+    
+    paper_db_path = BASE_DIR / "data" / PAPER_DB_FILENAME
+    factory_settings_path = BASE_DIR / "data" / FACTORY_SETTINGS_FILENAME
+    
+    with open(paper_db_path, "r") as f:
+        paper_db = [PaperGrade(**p) for p in json.load(f)]
+    
+    with open(factory_settings_path, "r") as f:
+        fs_data = json.load(f)
+    
+    flutes, factory_config = _parse_factory_settings(fs_data)
+    
+    print(f"✅ Loaded {len(paper_db)} paper grades, {len(flutes)} flute profiles")
+    return paper_db, factory_config, flutes
+
+
+def _load_from_huggingface() -> Tuple[List[PaperGrade], "FactoryConfig", List[FluteProfile]]:
+    """Load data from HuggingFace dataset repository."""
+    print(f"☁️ Loading data from HuggingFace: {HF_REPO_ID}...")
+    
+    try:
+        from huggingface_hub import hf_hub_download
+    except ImportError:
+        raise ImportError(
+            "huggingface_hub is required for production mode. "
+            "Install with: pip install huggingface_hub"
+        )
+    
+    # Download files from HuggingFace (cached automatically)
+    paper_db_path = hf_hub_download(
+        repo_id=HF_REPO_ID,
+        filename=PAPER_DB_FILENAME,
+        repo_type=HF_REPO_TYPE
+    )
+    
+    factory_settings_path = hf_hub_download(
+        repo_id=HF_REPO_ID,
+        filename=FACTORY_SETTINGS_FILENAME,
+        repo_type=HF_REPO_TYPE
+    )
+    
+    with open(paper_db_path, "r") as f:
+        paper_db = [PaperGrade(**p) for p in json.load(f)]
+    
+    with open(factory_settings_path, "r") as f:
+        fs_data = json.load(f)
+    
+    flutes, factory_config = _parse_factory_settings(fs_data)
+    
+    print(f"✅ Loaded {len(paper_db)} paper grades, {len(flutes)} flute profiles from HuggingFace")
+    return paper_db, factory_config, flutes
+
+
+def _parse_factory_settings(fs_data: dict) -> Tuple[List[FluteProfile], "FactoryConfig"]:
+    """Parse factory settings JSON into typed objects."""
+    flutes = [FluteProfile(**fp) for fp in fs_data['flutes']]
+    wastage = fs_data['wastage']
+    costs = fs_data['costs']
+    reels = fs_data['reels']
+    
+    factory_config = FactoryConfig(
+        wastage_process_pct=wastage['process_pct'],
+        cost_conversion_per_kg=costs['conversion_per_kg'],
+        cost_fixed_setup=costs['fixed_setup'],
+        # Value-Add Costs (optional processes)
+        cost_printing_per_1000=costs.get('printing_per_1000', 0.0),
+        cost_printing_plate=costs.get('printing_plate', 0.0),
+        cost_uv_per_1000=costs.get('uv_per_1000', 0.0),
+        cost_lamination_per_1000=costs.get('lamination_per_1000', 0.0),
+        cost_die_cutting_per_1000=costs.get('die_cutting_per_1000', 0.0),
+        cost_die_frame=costs.get('die_frame', 0.0),
+        margin_pct=costs['margin_pct'],
+        process_efficiency_pct=costs.get('process_efficiency_pct', 85.0),
+        ect_conversion_factor=costs.get('ect_conversion_factor', 0.85),
+        currency=costs['currency'],
+        available_reel_sizes=reels
+    )
+    
+    return flutes, factory_config
+
+
+def load_all_data() -> Tuple[List[PaperGrade], "FactoryConfig", List[FluteProfile]]:
+    """
+    Main entry point for loading data.
+    Automatically chooses local or HuggingFace based on DEV_MODE.
+    
+    Returns:
+        Tuple of (paper_db, factory_config, flute_profiles)
+    """
+    print(f"🔧 DEV_MODE = {DEV_MODE}")
+    
+    if DEV_MODE:
+        return _load_from_local()
+    else:
+        return _load_from_huggingface()

src/models.py

@@ -0,0 +1,63 @@
+import math
+from dataclasses import dataclass, field
+from typing import List, Optional
+
+@dataclass
+class FluteProfile:
+    name: str
+    height_mm: float
+    factor: float # Direct input now
+    pitch_mm: float = 0.0 # Optional/Reference only now
+
+    def __post_init__(self):
+        pass # No calculation needed
+
+@dataclass
+class PaperGrade:
+    code: str
+    gsm: int
+    rate: float
+    rct_cd_N: float  # Ring Crush CD in Newtons (N)
+    rct_md_N: float  # Ring Crush MD in Newtons (N)
+    bursting_strength_kpa: float  # kPa
+    ash_pct: float
+    moisture_pct: float
+
+@dataclass
+class FactoryConfig:
+    wastage_process_pct: float
+    cost_conversion_per_kg: float
+    cost_fixed_setup: float
+    margin_pct: float
+    process_efficiency_pct: float
+    currency: str
+    available_reel_sizes: List[int]
+    # Value-Add Costs (optional processes)
+    cost_printing_per_1000: float = 0.0
+    cost_printing_plate: float = 0.0
+    cost_uv_per_1000: float = 0.0
+    cost_lamination_per_1000: float = 0.0
+    cost_die_cutting_per_1000: float = 0.0
+    cost_die_frame: float = 0.0
+    ect_conversion_factor: float = 0.85
+
+@dataclass
+class LayerInput:
+    layer_type: str  # "Liner" or "Flute"
+    paper: PaperGrade
+    flute_profile: Optional[FluteProfile] = None
+    deckle_mm: Optional[int] = None # User provided reel size for this layer
+
+@dataclass
+class CartonSpecification:
+    length_mm: float
+    width_mm: float
+    height_mm: float
+    layers: List[LayerInput]
+    ply_type: str # "3 Ply", "5 Ply", "2+1 (Bleach Card)"
+    stitch_allowance_mm: float = 40.0
+    # Process Flags
+    has_printing: bool = False
+    has_uv: bool = False
+    has_lamination: bool = False
+    has_die_cutting: bool = False

src/streamlit_app.py

@@ -0,0 +1,1403 @@
+import streamlit as st
+import pandas as pd
+import json
+import plotly.graph_objects as go
+import plotly.express as px
+from datetime import datetime
+from typing import List, Dict
+from pathlib import Path
+
+from models import FluteProfile, PaperGrade, FactoryConfig, LayerInput, CartonSpecification
+from calculations import CorruLabEngine
+from data_loader import load_all_data
+from config import DEV_MODE
+
+# --- CONFIG & SETUP ---
+st.set_page_config(page_title="NRP - New Royal Printing", page_icon="📦", layout="wide", initial_sidebar_state="expanded")
+
+# Get the directory where app.py is located (works on local + Hugging Face)
+BASE_DIR = Path(__file__).parent
+
+# --- LOAD DATA ---
+# Data loading now handled by data_loader.py
+# Automatically switches between local (DEV_MODE=true) and HuggingFace (DEV_MODE=false)
+try:
+    PAPER_DB, FACTORY_CONFIG, FLUTE_PROFILES = load_all_data()
+except Exception as e:
+    st.error(f"Critical Error Loading Data: {e}")
+    st.stop()
+
+# --- STYLING ---
+st.markdown("""
+<style>
+    /* ========== FORCE HIDE NUMBER INPUT STEPPERS ========== */
+    /* Multiple aggressive selectors to ensure buttons are hidden */
+    button[kind="secondaryFormSubmit"],
+    button[data-testid="stNumberInputStepUp"],
+    button[data-testid="stNumberInputStepDown"],
+    [data-testid="stNumberInput"] button,
+    [data-testid="stNumberInput"] div[data-testid="StyledLinkIconContainer"],
+    div[data-baseweb="input"] button {
+        display: none !important;
+        visibility: hidden !important;
+        width: 0 !important;
+        height: 0 !important;
+        padding: 0 !important;
+        margin: 0 !important;
+        opacity: 0 !important;
+    }
+    
+    /* Remove button container */
+    [data-testid="stNumberInput"] > div > div:nth-child(2),
+    [data-testid="stNumberInput"] > div > div > div:nth-child(2) {
+        display: none !important;
+    }
+    
+    /* Make input full width */
+    [data-testid="stNumberInput"] input,
+    [data-testid="stNumberInput"] > div > div > div > input {
+        width: 100% !important;
+        padding-right: 8px !important;
+    }
+    
+    /* Browser native spin buttons */
+    input::-webkit-outer-spin-button,
+    input::-webkit-inner-spin-button {
+        -webkit-appearance: none !important;
+        margin: 0 !important;
+        display: none !important;
+    }
+    input[type=number] {
+        -moz-appearance: textfield !important;
+    }
+    
+    /* ========== MODERN PROFESSIONAL STYLING ========== */
+    
+    /* Clean input styling - LARGER FOR READABILITY */
+    [data-testid="stNumberInput"] input {
+        border: 1px solid #e0e0e0 !important;
+        border-radius: 6px !important;
+        padding: 10px 14px !important;
+        font-size: 16px !important;
+        font-weight: 500 !important;
+        background: white !important;
+        transition: all 0.2s ease !important;
+        min-height: 42px !important;
+    }
+    
+    /* Sidebar specific - full width inputs */
+    [data-testid="stSidebar"] [data-testid="stNumberInput"] input {
+        width: 100% !important;
+        font-size: 15px !important;
+    }
+    
+    [data-testid="stSidebar"] [data-testid="stTextInput"] input {
+        font-size: 14px !important;
+        padding: 10px !important;
+    }
+    
+    [data-testid="stNumberInput"] input:focus {
+        border-color: #1976d2 !important;
+        box-shadow: 0 0 0 2px rgba(25, 118, 210, 0.1) !important;
+        outline: none !important;
+    }
+    
+    /* Select box styling */
+    [data-testid="stSelectbox"] > div > div {
+        border-radius: 6px !important;
+        border: 1px solid #e0e0e0 !important;
+    }
+    
+    /* Column spacing optimization */
+    div[data-testid="column"] {
+        padding: 0px 6px !important;
+    }
+    
+    /* Section cards */
+    .stContainer > div {
+        background: #ffffff;
+        border-radius: 12px;
+        padding: 20px;
+        box-shadow: 0 2px 8px rgba(0,0,0,0.05);
+        margin-bottom: 16px;
+    }
+    
+    /* Metric cards */
+    .metric-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        padding: 24px;
+        border-radius: 12px;
+        box-shadow: 0 4px 16px rgba(102, 126, 234, 0.4);
+        margin-bottom: 16px;
+    }
+    
+    .metric-title {
+        color: rgba(255,255,255,0.9);
+        font-size: 0.85rem;
+        text-transform: uppercase;
+        letter-spacing: 1.2px;
+        font-weight: 500;
+    }
+    
+    .metric-value {
+        color: white;
+        font-size: 2rem;
+        font-weight: 700;
+        margin-top: 8px;
+    }
+    
+    /* Header styling */
+    .main-header {
+        font-size: 2.4rem;
+        font-weight: 800;
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        -webkit-background-clip: text;
+        -webkit-text-fill-color: transparent;
+        background-clip: text;
+        margin-bottom: 24px;
+    }
+    
+    /* Modern tabs */
+    .stTabs [data-baseweb="tab-list"] {
+        gap: 4px;
+        background: #f8f9fa;
+        padding: 4px;
+        border-radius: 10px;
+    }
+    
+    .stTabs [data-baseweb="tab"] {
+        height: 48px;
+        background: transparent;
+        border-radius: 8px;
+        color: #666;
+        font-weight: 500;
+        transition: all 0.2s ease;
+    }
+    
+    .stTabs [data-baseweb="tab"]:hover {
+        background: rgba(102, 126, 234, 0.1);
+        color: #667eea;
+    }
+    
+    .stTabs [aria-selected="true"] {
+        background: white !important;
+        color: #667eea !important;
+        box-shadow: 0 2px 4px rgba(0,0,0,0.08);
+        border: none !important;
+    }
+    
+    /* Divider styling */
+    hr {
+        margin: 24px 0;
+        border: none;
+        height: 1px;
+        background: linear-gradient(90deg, transparent, #e0e0e0, transparent);
+    }
+    
+    /* Better spacing for layer sections */
+    .element-container {
+        margin-bottom: 8px;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# --- HELPERS ---
+def to_mm(val, unit):
+    return val * 25.4 if unit == "inch" else val
+
+def from_mm(val_mm, unit):
+    return val_mm / 25.4 if unit == "inch" else val_mm
+
+def unit_label(label, unit):
+    return f"{label} ({unit})"
+
+# Unit Switch Handler
+def update_units():
+    # Called AFTER the 'unit' state has changed.
+    new_unit = st.session_state.unit
+    prev_unit = st.session_state.get('prev_unit', 'mm')
+    
+    if prev_unit != new_unit:
+        factor = 1.0
+        if prev_unit == 'mm' and new_unit == 'inch':
+            factor = 1/25.4
+        elif prev_unit == 'inch' and new_unit == 'mm':
+            factor = 25.4
+            
+        if 'length_input' in st.session_state:
+            st.session_state.length_input *= factor
+        if 'width_input' in st.session_state:
+            st.session_state.width_input *= factor
+        if 'height_input' in st.session_state:
+            st.session_state.height_input *= factor
+            
+    st.session_state.prev_unit = new_unit
+
+if 'prev_unit' not in st.session_state:
+    st.session_state.prev_unit = "mm"
+
+# --- SIDEBAR ---
+with st.sidebar:
+    st.image("https://cdn-icons-png.flaticon.com/512/679/679821.png", width=60)
+    st.title("NRP - New Royal Printing")
+    st.caption("Advanced MRP System")
+    
+    st.divider()
+    
+    st.subheader("📏 Units")
+    unit_system = st.radio("Display Units", ["mm", "inch"], horizontal=True, key="unit", on_change=update_units) # Global Unit State
+    
+    st.divider()
+    
+    st.subheader("📝 Job Details")
+    cust_name = st.text_input("Customer", "New Client")
+    quote_ref = st.text_input("Quote Ref", f"Q-{datetime.now().strftime('%Y%m%d')}")
+    order_qty = st.number_input("Order Quantity", min_value=1, value=5000)
+    
+    st.divider()
+    
+    with st.expander("🏭 Factory Settings", expanded=False):
+        st.caption("These settings affect wastage and strength calculations.")
+        
+        st.markdown("**📉 Wastage**")
+        FACTORY_CONFIG.wastage_process_pct = st.number_input(
+            "Process Waste (%)", 
+            value=FACTORY_CONFIG.wastage_process_pct, 
+            min_value=0.0, max_value=20.0, step=0.5,
+            help="Running waste from corrugator"
+        )
+        
+        st.markdown("**💪 Strength Factors**")
+        FACTORY_CONFIG.ect_conversion_factor = st.number_input(
+            "ECT Factor", 
+            value=FACTORY_CONFIG.ect_conversion_factor, 
+            min_value=0.5, max_value=1.2, step=0.01,
+            help="Lab-to-real ECT reduction (0.80-0.90)"
+        )
+        FACTORY_CONFIG.process_efficiency_pct = st.number_input(
+            "BCT Efficiency (%)", 
+            value=FACTORY_CONFIG.process_efficiency_pct, 
+            min_value=50.0, max_value=100.0, step=1.0,
+            help="BCT process efficiency"
+        )
+        
+        st.markdown("**📏 Reel Sizes (mm)**")
+        reels_str = st.text_input(
+            "Available Reels", 
+            ", ".join(map(str, FACTORY_CONFIG.available_reel_sizes)),
+            help="Comma-separated deckle sizes"
+        )
+        try:
+            FACTORY_CONFIG.available_reel_sizes = [int(x.strip()) for x in reels_str.split(",") if x.strip()]
+        except:
+            st.error("Invalid reel format")
+        
+        st.markdown("**🌊 Flute Takeup**")
+        for fp in FLUTE_PROFILES:
+            fp.factor = st.number_input(
+                f"{fp.name} Factor", 
+                value=fp.factor, 
+                key=f"f_{fp.name}", 
+                step=0.01,
+                min_value=1.0, max_value=2.0,
+                help=f"Paper consumed per meter"
+            )
+            
+    with st.expander("💸 Process Costs (Rs)", expanded=False):
+        st.caption("Per-unit costs for value-added processes. Rates are per 1000 boxes.")
+        
+        FACTORY_CONFIG.cost_printing_per_1000 = st.number_input("🖨️ Printing / 1000", value=FACTORY_CONFIG.cost_printing_per_1000)
+        FACTORY_CONFIG.cost_printing_plate = st.number_input("🖨️ Print Plate (Fixed)", value=FACTORY_CONFIG.cost_printing_plate)
+        FACTORY_CONFIG.cost_uv_per_1000 = st.number_input("✨ UV Coating / 1000", value=FACTORY_CONFIG.cost_uv_per_1000)
+        FACTORY_CONFIG.cost_lamination_per_1000 = st.number_input("📄 Lamination / 1000", value=FACTORY_CONFIG.cost_lamination_per_1000)
+        FACTORY_CONFIG.cost_die_cutting_per_1000 = st.number_input("✂️ Die Cutting / 1000", value=FACTORY_CONFIG.cost_die_cutting_per_1000)
+        FACTORY_CONFIG.cost_die_frame = st.number_input("✂️ Die Frame (Fixed)", value=FACTORY_CONFIG.cost_die_frame)
+
+# --- MAIN LAYOUT ---
+st.markdown("<div class='main-header'>📦 New Royal Printing - MRP</div>", unsafe_allow_html=True)
+
+tabs = st.tabs(["⚗️ The Lab (Specs)", "💪 Engineering & Health", "⚙️ Production & Waste", "💰 Financials", "📄 Reports"])
+
+# --- HELPERS ---
+
+def plot_deckle_visualization(deckle_mm, sheet_width_mm, sheet_length_mm, ups, layer_name, utilization_pct):
+    """
+    Creates a 2D visual representation of Deckle Utilization.
+    X-axis = Deckle width (how many sheets fit across the reel)
+    Y-axis = Sheet length (the full sheet dimension)
+    """
+    fig = go.Figure()
+
+    # Dimensions
+    used_width = ups * sheet_width_mm
+    trim_width = deckle_mm - used_width
+    
+    # Scale for display (keep aspect ratio reasonable)
+    scale_y = min(1.0, 400 / sheet_length_mm) if sheet_length_mm > 0 else 1.0
+    display_height = sheet_length_mm * scale_y
+    
+    # Draw "Ups" (Good Sheets)
+    for i in range(ups):
+        x0 = i * sheet_width_mm
+        x1 = x0 + sheet_width_mm
+        
+        fig.add_shape(
+            type="rect",
+            x0=x0, y0=0, x1=x1, y1=display_height,
+            line=dict(color="darkgreen", width=2),
+            fillcolor="rgba(46, 204, 113, 0.6)",
+        )
+        
+        # Annotation for sheet
+        fig.add_annotation(
+            x=x0 + (sheet_width_mm/2),
+            y=display_height/2,
+            text=f"<b>Sheet {i+1}</b><br>{sheet_width_mm:.0f} × {sheet_length_mm:.0f}mm",
+            showarrow=False,
+            font=dict(color="white", size=11)
+        )
+
+    # Draw Trim (Wastage)
+    if trim_width > 1:  # Only show if more than 1mm
+        x0_trim = used_width
+        x1_trim = deckle_mm
+        
+        fig.add_shape(
+            type="rect",
+            x0=x0_trim, y0=0, x1=x1_trim, y1=display_height,
+            line=dict(color="red", width=2),
+            fillcolor="rgba(231, 76, 60, 0.8)",
+        )
+        # Annotation for trim
+        fig.add_annotation(
+            x=x0_trim + (trim_width/2),
+            y=display_height/2,
+            text=f"<b>TRIM</b><br>{trim_width:.0f}mm<br>({100-utilization_pct:.1f}%)",
+            showarrow=False,
+            font=dict(color="white", size=10)
+        )
+
+    # Add dimension arrows/labels
+    # Deckle dimension (top)
+    fig.add_annotation(
+        x=deckle_mm/2, y=display_height + 20,
+        text=f"<b>Reel Deckle: {deckle_mm}mm</b>",
+        showarrow=False, font=dict(size=12, color="#333")
+    )
+    
+    # Sheet width dimension (bottom)
+    fig.add_annotation(
+        x=sheet_width_mm/2, y=-25,
+        text=f"W+H = {sheet_width_mm:.0f}mm",
+        showarrow=False, font=dict(size=10, color="#666")
+    )
+
+    # Config
+    fig.update_layout(
+        title=dict(
+            text=f"<b>{layer_name}</b> | Utilization: <span style='color:{'green' if utilization_pct > 95 else 'orange' if utilization_pct > 85 else 'red'}'>{utilization_pct:.1f}%</span>",
+            font=dict(size=14)
+        ),
+        xaxis=dict(
+            range=[-10, deckle_mm * 1.05], 
+            title="← Deckle Width (mm) →", 
+            showgrid=True, gridcolor='rgba(0,0,0,0.1)',
+            dtick=200
+        ),
+        yaxis=dict(
+            range=[-40, display_height + 40],
+            title="Sheet Length", 
+            showgrid=True, gridcolor='rgba(0,0,0,0.1)',
+            showticklabels=False
+        ),
+        height=280,
+        margin=dict(l=60, r=20, t=50, b=50),
+        plot_bgcolor='rgba(248,248,248,1)',
+    )
+    
+    return fig
+
+# --- TAB 1: THE LAB ---
+with tabs[0]:
+    with st.container():
+        st.markdown("### 1. Carton Specification")
+        # Split into two rows for better spacing
+        r1_c1, r1_c2 = st.columns(2)
+        with r1_c1: ply_type = st.selectbox("Board Construction", ["3 Ply (Single Wall)", "5 Ply (Double Wall)", "2+1 (Bleach Card)"])
+        
+        r2_c1, r2_c2, r2_c3 = st.columns(3)
+        
+        # Smart Defaults based on Unit
+        # Note: 'value' in st.number_input is only used if key is NOT in session_state.
+        def_l = 15.75 if unit_system == "inch" else 400.0
+        def_w = 11.81 if unit_system == "inch" else 300.0
+        def_h = 11.81 if unit_system == "inch" else 300.0
+        
+        with r2_c1: l_input = st.number_input(unit_label("Length", unit_system), value=def_l, key="length_input")
+        with r2_c2: w_input = st.number_input(unit_label("Width", unit_system), value=def_w, key="width_input")
+        with r2_c3: h_input = st.number_input(unit_label("Height", unit_system), value=def_h, key="height_input")
+        
+        # Convert inputs to MM for internal logic
+        l_mm = to_mm(l_input, unit_system)
+        w_mm = to_mm(w_input, unit_system)
+        h_mm = to_mm(h_input, unit_system)
+
+        
+        st.markdown("#### Process Selection")
+        cp1, cp2, cp3, cp4 = st.columns(4)
+        has_print = cp1.checkbox("Printing")
+        has_uv = cp2.checkbox("UV Coating")
+        has_lam = cp3.checkbox("Lamination")
+        has_die = cp4.checkbox("Die Cutting")
+    
+    st.divider()
+    
+    with st.container():
+        st.markdown("### 2. Paper Composition & Deckle")
+        
+        # Define Layer Structure
+        if "3 Ply" in ply_type:
+            layer_defs = [("Top Liner", "Liner"), ("Flute", "Flute"), ("Bottom Liner", "Liner")]
+        elif "2+1" in ply_type:
+             layer_defs = [("Top Liner (Bleach Card)", "Liner"), ("Flute", "Flute"), ("Bottom Liner", "Liner")]
+        else:
+            layer_defs = [("Top Liner", "Liner"), ("Flute 1", "Flute"), ("Middle Liner", "Liner"), ("Flute 2", "Flute"), ("Bottom Liner", "Liner")]
+        
+        selected_layers = []
+        
+        for i, (name, l_type) in enumerate(layer_defs):
+            with st.expander(f"**{name}**", expanded=True):
+                # Flute Profile Selection (if applicable)
+                if l_type == "Flute":
+                    f_name = st.selectbox("Flute Profile", [f.name for f in FLUTE_PROFILES], key=f"fp_{i}")
+                    flute_prof = next(f for f in FLUTE_PROFILES if f.name == f_name)
+                else:
+                    flute_prof = None
+                
+                # Paper Selection
+                paper_opts = [f"{p.code} {p.gsm}GSM" for p in PAPER_DB]
+                
+                # Smart Defaults
+                sel_idx = 0
+                if "2+1" in ply_type and i == 0:
+                     try: sel_idx = next(idx for idx, p in enumerate(PAPER_DB) if p.code == "BC")
+                     except: sel_idx = 0
+                elif i == 1:
+                    sel_idx = 1
+                    
+                sel_paper_str = st.selectbox("Paper Grade", paper_opts, index=sel_idx, key=f"p_{i}")
+                sel_paper = next(p for p in PAPER_DB if f"{p.code} {p.gsm}GSM" == sel_paper_str)
+                
+                # Primary Inputs - Clean 3-column layout
+                col1, col2, col3 = st.columns(3)
+                with col1:
+                    gsm = st.number_input("GSM", value=sel_paper.gsm, key=f"g_{i}", help="Grams per Square Meter")
+                with col2:
+                    rate = st.number_input("Rate (per kg)", value=sel_paper.rate, key=f"rt_{i}")
+                with col3:
+                    # Deckle Logic: Input follows Unit System
+                    def_deckle = 47.0 if unit_system == "inch" else 1200.0 
+                    deckle_input = st.number_input(unit_label("Deckle", unit_system), value=def_deckle, step=1.0, key=f"dk_{i}", help="Reel Width")
+                    deckle_val_mm = to_mm(deckle_input, unit_system)
+                
+                # Technical Specs - 4-column layout
+                st.markdown("**Technical Specifications**")
+                tc1, tc2, tc3, tc4 = st.columns(4)
+                with tc1:
+                    rct_cd = st.number_input("RCT-CD (kgf)", value=sel_paper.rct_cd_N, key=f"rcd_{i}", help="Ring Crush Test CD (kgf)")
+                with tc2:
+                    rct_md = st.number_input("RCT-MD (kgf)", value=sel_paper.rct_md_N, key=f"rmd_{i}", help="Ring Crush Test MD (kgf)")
+                with tc3:
+                    burst = st.number_input("Burst (kPa)", value=sel_paper.bursting_strength_kpa, key=f"bst_{i}")
+                with tc4:
+                    moist = st.number_input("Moisture %", value=sel_paper.moisture_pct, key=f"mst_{i}")
+                
+                # Create Paper Object with overrides
+                final_paper = PaperGrade(sel_paper.code, gsm, rate, rct_cd, rct_md, burst, 0.0, moist)
+                selected_layers.append(LayerInput(l_type, final_paper, flute_prof, deckle_mm=int(deckle_val_mm)))
+
+        # Build Spec Object
+        CARTON_SPEC = CartonSpecification(l_mm, w_mm, h_mm, selected_layers, ply_type, 
+                                          has_printing=has_print, has_uv=has_uv, 
+                                          has_lamination=has_lam, has_die_cutting=has_die)
+
+# --- TAB 2: ENGINEERING ---
+with tabs[1]:
+    st.markdown("### 🔬 Physics-Based Analysis")
+    
+    col_eng1, col_eng2 = st.columns([1, 2])
+    
+    # Safety Factor Input
+    with col_eng2:
+        safety_factor = st.slider("Stacking Safety Factor (SF)", min_value=1.0, max_value=6.0, value=5.0, step=0.5, help="3=Short Term, 5=Long Term/High Humidity")
+
+    # Calculate ECT & BCT & Burst
+    # Updated to include conversion factor from config
+    ect_res = CorruLabEngine.calculate_ect_rct_method(CARTON_SPEC, FACTORY_CONFIG)
+    bct_res = CorruLabEngine.calculate_bct_mckee(CARTON_SPEC, ect_res['ect_value'], FACTORY_CONFIG)
+    burst_res = CorruLabEngine.calculate_box_burst(CARTON_SPEC)
+    
+    with col_eng1:
+        st.markdown(f"""
+        <div class='metric-card'>
+            <div class='metric-title'>Edge Crush Test (ECT)</div>
+            <div class='metric-value'>{ect_res['ect_value']:.2f} kN/m</div>
+        </div>
+        """, unsafe_allow_html=True)
+        with st.expander("🎓 ECT Calculation"):
+            st.markdown(ect_res['explanation'])
+            
+        st.markdown(f"""
+        <div class='metric-card' style='border-left: 5px solid #43a047;'>
+            <div class='metric-title'>Safe Stacking Load</div>
+            <div class='metric-value'>{bct_res['bct_kg']/safety_factor:.0f} kg</div>
+            <div style='margin-top:8px; font-size:0.9rem; color:#eee;'>Collapse Load (BCT): <b>{bct_res['bct_kg']:.0f} kg</b> (SF={safety_factor})</div>
+        </div>
+        """, unsafe_allow_html=True)
+        with st.expander("🎓 BCT Calculation"):
+            st.markdown(bct_res['explanation'])
+            
+        st.markdown(f"""
+        <div class='metric-card' style='border-left: 5px solid #ff9800;'>
+            <div class='metric-title'>Box Bursting Strength</div>
+            <div class='metric-value'>{burst_res['burst_kpa']:.0f} kPa</div>
+        </div>
+        """, unsafe_allow_html=True)
+        with st.expander("🎓 Burst Calculation"):
+            st.markdown(burst_res['explanation'])
+
+    with col_eng2:
+        st.markdown("#### 📉 Lifecycle Simulation (Strength vs Time)")
+        humidity = st.slider("Storage Humidity (%)", 20, 95, 60, help="Higher humidity accelerates strength degradation.")
+        
+        # Calculate Safe Load for Graph
+        safe_load_kg = bct_res['bct_kg'] / safety_factor
+        
+        # Use Safe Load for prediction
+        lifecycle_df = CorruLabEngine.predict_lifecycle(safe_load_kg, humidity)
+        
+        # Plotly Chart
+        fig_life = px.line(lifecycle_df, x='Days', y='Safe Load (kg)', title=f"Safe Load Degradation @ {humidity}% RH")
+        fig_life.add_hline(y=lifecycle_df['Target'][0], line_dash="dash", line_color="red", annotation_text="Safety Threshold (60%)")
+        fig_life.update_layout(height=450, hovermode="x unified")
+        
+        st.plotly_chart(fig_life, use_container_width=True)
+
+# --- TAB 3: PRODUCTION ---
+with tabs[2]:
+    st.markdown("### 🏭 Production Planning & Wastage")
+
+    # 1. Wastage Calculation (Moved to top for Dashboard access)
+    wastage_df = CorruLabEngine.calculate_wastage_per_layer(CARTON_SPEC, FACTORY_CONFIG)
+
+    # Metrics - Sheet Area (Full Rectangle - factory buys full sheet)
+    # Stitch cut-outs are waste, tracked separately
+    flap_height_mm = min(l_mm, w_mm) / 2.0  # RSC standard flap
+    sheet_area_m2 = ((2*l_mm + 2*w_mm + CARTON_SPEC.stitch_allowance_mm) * (w_mm + h_mm)) / 1_000_000.0
+    stitch_cutout_area_m2 = (CARTON_SPEC.stitch_allowance_mm * 2 * flap_height_mm) / 1_000_000.0
+    
+    # Calculate Total Weight (Net of Box * Qty) - Approximate
+    # Better: sum of layer gsm
+    total_gsm = sum(l.paper.gsm * (l.flute_profile.factor if l.flute_profile else 1.0) for l in CARTON_SPEC.layers)
+    net_weight_box_kg = total_gsm * sheet_area_m2 / 1000.0
+    total_batch_weight_ton = (net_weight_box_kg * order_qty) / 1000.0
+    
+    # Run Length (Linear Meters of Board)
+    # Assuming board width is fixed by Deckle? No, Corrugator runs full width.
+    # The Cut Length is the running direction.
+    # Linear Meters = (Sheet Length / 1000) * Qty / Ups
+    try:
+        avg_ups = wastage_df['ups'].mean()
+    except:
+        avg_ups = 1
+        
+    running_cut_length_m = (2*l_mm + 2*w_mm + CARTON_SPEC.stitch_allowance_mm) / 1000.0
+    total_linear_meters = (running_cut_length_m * order_qty) / max(1, avg_ups)
+    
+    # Estimated Time (at 150m/min avg)
+    est_time_min = total_linear_meters / 150.0
+    
+    # Dashboard Grid
+    m1, m2, m3, m4 = st.columns(4)
+    with m1:
+        st.metric("Total Batch Weight", f"{total_batch_weight_ton:.2f} tons", help="Net Paper Weight")
+    with m2:
+        st.metric("Linear Meters", f"{total_linear_meters:,.0f} m", help="Total board length at corrugator")
+    with m3:
+        st.metric("Est. Run Time", f"{est_time_min:.0f} mins", help="Based on 150m/min avg speed")
+    with m4:
+        st.metric("Avg. Ups", f"{avg_ups:.1f}", help="Average Ups across layers")
+    
+    # --- WASTAGE BREAKDOWN (NEW TRANSPARENCY SECTION) ---
+    st.divider()
+    st.markdown("#### 📊 Wastage Breakdown")
+    
+    # Calculate detailed wastage
+    total_net_kg = net_weight_box_kg * order_qty
+    
+    # Get gross from breakdown - using same corrected sheet area
+    sheet_area = sheet_area_m2  # Already calculated above with stitch cut-out correction
+    
+    total_process_waste_kg = 0.0
+    total_trim_waste_kg = 0.0
+    total_gross_kg = 0.0
+    
+    for i, layer in enumerate(CARTON_SPEC.layers):
+        takeup = layer.flute_profile.factor if layer.flute_profile else 1.0
+        weight_net_kg = (layer.paper.gsm * takeup * sheet_area / 1000.0) * order_qty
+        
+        row = wastage_df.loc[wastage_df['layer_idx'] == i].iloc[0]
+        
+        # Process waste
+        w_after_process = weight_net_kg * (1 + FACTORY_CONFIG.wastage_process_pct/100.0)
+        process_waste = w_after_process - weight_net_kg
+        total_process_waste_kg += process_waste
+        
+        # Trim waste
+        if row['deckle_mm'] > 0 and row['ups'] > 0:
+            deckle_util = (row['ups'] * (w_mm + h_mm)) / row['deckle_mm']
+            if deckle_util > 0:
+                w_gross = w_after_process / deckle_util
+            else:
+                w_gross = w_after_process
+        else:
+            w_gross = w_after_process
+            deckle_util = 1.0
+        
+        trim_waste = w_gross - w_after_process
+        total_trim_waste_kg += trim_waste
+        total_gross_kg += w_gross
+    
+    # Calculate stitch cut-out waste
+    stitch_cutout_waste_kg = stitch_cutout_area_m2 * total_gsm / 1000.0 * order_qty
+    
+    total_waste_kg = total_process_waste_kg + total_trim_waste_kg + stitch_cutout_waste_kg
+    waste_pct = (total_waste_kg / total_net_kg) * 100 if total_net_kg > 0 else 0
+    
+    # Display breakdown
+    waste_col1, waste_col2 = st.columns([2, 1])
+    
+    with waste_col1:
+        st.markdown(f"""
+        | Component | Formula | Amount |
+        |-----------|---------|--------|
+        | **Paper Purchased** | GSM × Takeup × FullArea × Qty | **{total_net_kg:,.0f} kg** |
+        | **- Stitch Cut-outs** | Paper cut above/below stitch | -{stitch_cutout_waste_kg:,.0f} kg |
+        | **+ Process Waste** | Paper × {FACTORY_CONFIG.wastage_process_pct}% | +{total_process_waste_kg:,.0f} kg |
+        | **+ Trim Waste** | (100% - Deckle Utilization) | +{total_trim_waste_kg:,.0f} kg |
+        | **= In Box** | Finished product weight | **{total_net_kg - stitch_cutout_waste_kg:,.0f} kg** |
+        """)
+        
+    with waste_col2:
+        # Visual gauge
+        st.metric("Total Waste", f"{total_waste_kg:,.0f} kg", f"{waste_pct:.1f}%", delta_color="inverse")
+        st.caption(f"Stitch: {stitch_cutout_waste_kg:.0f} kg | Process: {total_process_waste_kg:.0f} kg | Trim: {total_trim_waste_kg:.0f} kg")
+        
+    st.info(f"""
+    **💡 How Waste is Calculated:**  
+    1. **Stitch Cut-outs**: Flap areas above/below stitch tab ({CARTON_SPEC.stitch_allowance_mm}mm × 2 × {flap_height_mm}mm) are cut and discarded  
+    2. **Process Waste ({FACTORY_CONFIG.wastage_process_pct}%)**: Corrugator running waste, edge tears, startup/stop losses  
+    3. **Trim Waste**: When deckle size doesn't divide evenly by sheet width (W+H = {w_mm+h_mm}mm)
+    """)
+        
+    st.divider()
+    
+    # Display 2D Visualization for each unique layer
+    st.markdown("#### Deckle Utilization Visualizer")
+    
+    # Loop through unique layers in wastage_df
+    for idx, row in wastage_df.iterrows():
+        l_name = f"{row['layer_type']} Layer {row['layer_idx']+1} ({row['paper']})"
+        ups = int(row['ups'])
+        deckle = float(row['deckle_mm'])
+        
+        # Calculate Sheet Width used for optimization (Back calculate or assume?)
+        # Logic in calculations: ups = int(deckle / sheet_w)
+        # We need the sheet width approx. 
+        # Used Width = Deckle - Trim
+        # Sheet Width = Used / Ups
+        if ups > 0:
+            used_w = deckle - float(row['trim_mm'])
+            sheet_w = used_w / ups
+        else:
+            sheet_w = 0
+        
+        # Calculate sheet length (L + W + L + W + stitch)
+        sheet_length = 2*l_mm + 2*w_mm + CARTON_SPEC.stitch_allowance_mm
+        utilization = 100 - float(row['trim_pct'])
+            
+        fig_viz = plot_deckle_visualization(deckle, sheet_w, sheet_length, ups, l_name, utilization)
+        st.plotly_chart(fig_viz, use_container_width=True)
+        
+    # Summary Table
+    st.markdown("#### Detailed Stats")
+    st.dataframe(wastage_df.style.format({
+        "trim_pct": "{:.2f}%",
+        "trim_mm": "{:.1f}",
+        "deckle_mm": "{:.0f}"
+    }), use_container_width=True)
+
+
+
+    st.divider()
+    
+    st.divider()
+
+    st.markdown("### 🏗️ Engineering Visualizers")
+    
+    vis_col1, vis_col2 = st.columns([1, 1])
+    
+    # --- ENHANCED 2D NET VISUALIZER ---
+    # Dimensions
+    L_net = l_mm
+    W_net = w_mm
+    H_net = h_mm
+    S_net = CARTON_SPEC.stitch_allowance_mm
+    
+    # Helper for formatting units
+    use_inch = st.session_state.get('unit', 'mm') == 'inch'
+    def fmt_dim(val_mm):
+        if use_inch:
+            return f"{val_mm/25.4:.2f} in"
+        return f"{val_mm:.0f} mm"
+    def fmt_val(val_mm): # Just number for text labels with space constraint
+        if use_inch:
+            return f"{val_mm/25.4:.2f}"
+        return f"{val_mm:.0f}"
+    
+    # X Coordinates (Length Direction)
+    # Flap - Length - Width - Length - Width
+    x_coords = [0, S_net, S_net+L_net, S_net+L_net+W_net, S_net+2*L_net+W_net, S_net+2*L_net+2*W_net]
+    total_net_w = x_coords[-1]
+    
+    # Y Coordinates (Height Direction)
+    # Flap - Height - Flap
+    flap_h = min(L_net, W_net) / 2.0 # RSC flap is half of smaller dimension (L or W)
+    y_coords = [0, flap_h, flap_h+H_net, 2*flap_h+H_net]
+    total_net_h = y_coords[-1]
+    
+    fig_2d = go.Figure()
+    
+    # --- TECHNICAL DIELINE LOGIC ---
+    # Green = Cut Lines (Outline)
+    # Red Dashed = Crease Lines (Internal Folds)
+    
+    cut_lines_x = []
+    cut_lines_y = []
+    
+    crease_lines_x = []
+    crease_lines_y = []
+    
+    # Slot Gap (e.g., 5mm) to separate flap edges
+    slot_gap = 5.0
+    
+    # --- 1. Outline (Cut Lines) ---
+    # We trace the outer boundary:
+    # Start Top-Left of Stitch Tab -> Top Edge of Flaps -> Right Edge -> Bottom Edge -> Stitch Tab
+    
+    # Stitch Tab: (0, flap)->(S, flap) [Top] ? No, Stitch usually has angled cut.
+    # Let's keep smooth rect for now.
+    # Stitch: x=0..S, y=flap..flap+H
+    
+    # Top Edge Path:
+    # 1. Stitch Top: (0, flap) -> (S, flap)
+    # 2. Panel 1 Top Flap: (S + gap/2, 0) -> (S+L - gap/2, 0)
+    # 3. Panel 2 Top Flap: (S+L + gap/2, 0) -> (S+L+W - gap/2, 0)
+    # ...
+    
+    # Actually, simpler to draw "Per Panel" outlines.
+    # Cut Lines = Top of Flaps + Bottom of Flaps + Side Edges of Flaps + Outer Edges of End Panels.
+    # Crease Lines = Flap Hinge (Horizontal) + Panel Hinge (Vertical).
+    
+    # Stitch Tab
+    # Cut: Left (0, flap->flap+H), Top (0,flap->S,flap), Bottom (0,flap+H->S,flap+H).
+    # Hinge(Red): Right (S, flap->flap+H) attached to Panel 1.
+    
+    # Cut Lines (Green)
+    # Stitch Left
+    fig_2d.add_trace(go.Scatter(x=[0, 0], y=[flap_h, flap_h+H_net], mode='lines', line=dict(color='green', width=2), showlegend=False))
+    # Stitch Top/Bot (Angled usually, but straight here)
+    fig_2d.add_trace(go.Scatter(x=[0, S_net], y=[flap_h, flap_h], mode='lines', line=dict(color='green', width=2), showlegend=False))
+    fig_2d.add_trace(go.Scatter(x=[0, S_net], y=[flap_h+H_net, flap_h+H_net], mode='lines', line=dict(color='green', width=2), showlegend=False))
+    
+    # Panels Loop
+    panels = [
+        (S_net, x_coords[2]), # Panel 1 (L)
+        (x_coords[2], x_coords[3]), # Panel 2 (W)
+        (x_coords[3], x_coords[4]), # Panel 3 (L)
+        (x_coords[4], x_coords[5])  # Panel 4 (W)
+    ]
+    
+    for idx, (x_start, x_end) in enumerate(panels):
+        # Vertical Hinge (Start) - Red Dashed
+        # If it's the first panel, it's the Stitch Hinge.
+        # If it's later, it's shared with prev panel.
+        fig_2d.add_trace(go.Scatter(x=[x_start, x_start], y=[flap_h, flap_h+H_net], mode='lines', line=dict(color='red', width=1, dash='dash'), showlegend=False))
+        
+        # Horizontal Hinges (Top & Bottom) - Red Dashed
+        # Flap Fold Lines
+        fig_2d.add_trace(go.Scatter(x=[x_start, x_end], y=[flap_h, flap_h], mode='lines', line=dict(color='red', width=1, dash='dash'), showlegend=False))
+        fig_2d.add_trace(go.Scatter(x=[x_start, x_end], y=[flap_h+H_net, flap_h+H_net], mode='lines', line=dict(color='red', width=1, dash='dash'), showlegend=False))
+        
+        # --- Flaps (Green Cuts) ---
+        # Top Flap
+        # Left Edge (Cut) - with gap
+        # But adjacent flaps share a slot.
+        # So "x_start" -> "x_start + slot_gap/2" is void?
+        # Standard: Standard slot is cut centered on the crease line.
+        # So Flap Left Edge starts at x_start + slot/2.
+        
+        # Top Flap Path:
+        # (x_start + gap/2, flap) -> (x_start + gap/2, 0)
+        # (x_start + gap/2, 0) -> (x_end - gap/2, 0)
+        # (x_end - gap/2, 0) -> (x_end - gap/2, flap)
+        
+        gap_offset = slot_gap / 2.0
+        
+        t_x = [x_start + gap_offset, x_start + gap_offset, x_end - gap_offset, x_end - gap_offset]
+        t_y = [flap_h, 0, 0, flap_h]
+        fig_2d.add_trace(go.Scatter(x=t_x, y=t_y, mode='lines', line=dict(color='green', width=2), showlegend=False))
+        
+        # Bottom Flap Path
+        b_x = [x_start + gap_offset, x_start + gap_offset, x_end - gap_offset, x_end - gap_offset]
+        b_y = [flap_h + H_net, total_net_h, total_net_h, flap_h + H_net]
+        fig_2d.add_trace(go.Scatter(x=b_x, y=b_y, mode='lines', line=dict(color='green', width=2), showlegend=False))
+
+    # Final Vertical Line (End of Panel 4) - Green Cut
+    last_x = x_coords[5]
+    fig_2d.add_trace(go.Scatter(x=[last_x, last_x], y=[flap_h, flap_h+H_net], mode='lines', line=dict(color='green', width=2), showlegend=False))
+
+    # --- DIMENSIONS ---
+    # Add Arrow Annotations for L, W, H
+    
+    # 1. Length (Panel 1) - Inside Panel
+    p1_center = (panels[0][0] + panels[0][1]) / 2
+    
+    # Better: Use 'shapes' for arrows or just text?
+    # Let's simple text.
+    fig_2d.add_annotation(x=p1_center, y=flap_h + H_net/2, text=f"L={fmt_val(L_net)}", showarrow=False, font=dict(size=12, color="black"))
+    
+    # 2. Width (Panel 2)
+    p2_center = (panels[1][0] + panels[1][1]) / 2
+    fig_2d.add_annotation(x=p2_center, y=flap_h + H_net/2, text=f"W={fmt_val(W_net)}", showarrow=False, font=dict(size=12, color="black"))
+    
+    # 3. Flap Height (W/2)
+    # Vertical Arrow on Flap 2
+    fig_2d.add_annotation(x=p2_center, y=flap_h/2, text=f"Flap={fmt_val(flap_h)}", showarrow=False, font=dict(size=10, color="gray"))
+    
+    # 4. Total Height (H)
+    # Arrow on side
+    # x= -20
+    # y= flap -> flap+H
+    fig_2d.add_annotation(
+        x=-30, y=flap_h + H_net/2,
+        text=f"H={fmt_val(H_net)}", showarrow=False, textangle=-90
+    )
+    # Vertical Line for H dimension
+    fig_2d.add_shape(type="line", x0=-10, y0=flap_h, x1=-10, y1=flap_h+H_net, line=dict(color="black", width=1))
+    fig_2d.add_shape(type="line", x0=-15, y0=flap_h, x1=-5, y1=flap_h, line=dict(color="black", width=1)) # Tick
+    fig_2d.add_shape(type="line", x0=-15, y0=flap_h+H_net, x1=-5, y1=flap_h+H_net, line=dict(color="black", width=1)) # Tick
+
+    # Styling
+    padding_x = total_net_w * 0.1
+    padding_y = total_net_h * 0.1
+    
+    fig_2d.update_layout(
+        title=f"2D Production Net ({fmt_val(total_net_w)} x {fmt_val(total_net_h)} {unit_label( '', unit_system).split('(')[1][:-1]})", 
+        # Hacky split to get 'mm' or 'inch'. Better: Use my 'unit_label' or just 'unit'. 
+        # Actually I defined 'unit_label' helper earlier?
+        # Let's use simpler: 'mm' if unit=='mm' else 'inch'
+        # But wait, local scope issues? No.
+        xaxis=dict(showgrid=False, showticklabels=False, visible=False, range=[-padding_x, total_net_w + padding_x]),
+        yaxis=dict(showgrid=False, showticklabels=False, visible=False, scaleanchor="x", scaleratio=1, range=[total_net_h + padding_y, -padding_y]),
+        height=350,
+        margin=dict(l=10, r=10, t=30, b=10),
+        plot_bgcolor='white',
+    )
+
+
+    # --- SIMPLIFIED 3D VISUALIZATION ---
+    st.markdown("#### 🧊 3D Box Visualization")
+    
+    # Simple toggle between flat net and folded box
+    view_mode = st.radio("View Mode", ["📄 Flat Net", "📦 Folded Box"], horizontal=True, help="Toggle between flat production sheet and assembled box")
+    
+    import numpy as np
+    
+    # Color scheme
+    COLOR_STITCH = "#2962FF"       # Blue for stitch tab
+    COLOR_PANEL_L = "#C19A6B"      # Brown for Length panels (1, 3)
+    COLOR_PANEL_W = "#A67C52"      # Slightly different brown for Width panels (2, 4)
+    COLOR_FLAP = "#D4A574"         # Lighter brown for flaps
+    
+    fig_3d = go.Figure()
+    
+    # Helper: Create quad mesh
+    def add_quad(corners, color, name):
+        """Add a quadrilateral mesh from 4 corner points [(x,y,z), ...]"""
+        x = [c[0] for c in corners]
+        y = [c[1] for c in corners]
+        z = [c[2] for c in corners]
+        
+        fig_3d.add_trace(go.Mesh3d(
+            x=x, y=y, z=z,
+            i=[0, 0], j=[1, 2], k=[2, 3],
+            color=color, opacity=0.95, name=name,
+            flatshading=True,
+            lighting=dict(ambient=0.7, diffuse=0.8, roughness=0.3, specular=0.2)
+        ))
+        
+        # Wireframe
+        wx = x + [x[0]]
+        wy = y + [y[0]]
+        wz = z + [z[0]]
+        fig_3d.add_trace(go.Scatter3d(
+            x=wx, y=wy, z=wz, mode='lines',
+            line=dict(color='#333', width=2), showlegend=False
+        ))
+    
+    unit_label = "in" if use_inch else "mm"
+    
+    if view_mode == "📄 Flat Net":
+        # === FLAT NET VIEW ===
+        # Lay the entire net flat on XY plane (Z=0)
+        # Same layout as 2D: Stitch | P1(L) | P2(W) | P3(L) | P4(W)
+        # Y direction: Bottom Flap | Main Body (H) | Top Flap
+        
+        z = 0  # Flat on table
+        
+        # Panel X positions (same as 2D)
+        stitch_x = (0, S_net)
+        p1_x = (S_net, S_net + L_net)
+        p2_x = (S_net + L_net, S_net + L_net + W_net)
+        p3_x = (S_net + L_net + W_net, S_net + 2*L_net + W_net)
+        p4_x = (S_net + 2*L_net + W_net, total_net_w)
+        
+        # Y positions
+        bot_flap_y = (0, flap_h)
+        main_y = (flap_h, flap_h + H_net)
+        top_flap_y = (flap_h + H_net, total_net_h)
+        
+        # Stitch Tab (main body only, no flaps)
+        add_quad([
+            (stitch_x[0], main_y[0], z), (stitch_x[1], main_y[0], z),
+            (stitch_x[1], main_y[1], z), (stitch_x[0], main_y[1], z)
+        ], COLOR_STITCH, "Stitch")
+        
+        # Panel 1 (L) + Flaps
+        add_quad([(p1_x[0], main_y[0], z), (p1_x[1], main_y[0], z), (p1_x[1], main_y[1], z), (p1_x[0], main_y[1], z)], COLOR_PANEL_L, "Panel 1 (L)")
+        add_quad([(p1_x[0], bot_flap_y[0], z), (p1_x[1], bot_flap_y[0], z), (p1_x[1], bot_flap_y[1], z), (p1_x[0], bot_flap_y[1], z)], COLOR_FLAP, "P1 Bot Flap")
+        add_quad([(p1_x[0], top_flap_y[0], z), (p1_x[1], top_flap_y[0], z), (p1_x[1], top_flap_y[1], z), (p1_x[0], top_flap_y[1], z)], COLOR_FLAP, "P1 Top Flap")
+        
+        # Panel 2 (W) + Flaps
+        add_quad([(p2_x[0], main_y[0], z), (p2_x[1], main_y[0], z), (p2_x[1], main_y[1], z), (p2_x[0], main_y[1], z)], COLOR_PANEL_W, "Panel 2 (W)")
+        add_quad([(p2_x[0], bot_flap_y[0], z), (p2_x[1], bot_flap_y[0], z), (p2_x[1], bot_flap_y[1], z), (p2_x[0], bot_flap_y[1], z)], COLOR_FLAP, "P2 Bot Flap")
+        add_quad([(p2_x[0], top_flap_y[0], z), (p2_x[1], top_flap_y[0], z), (p2_x[1], top_flap_y[1], z), (p2_x[0], top_flap_y[1], z)], COLOR_FLAP, "P2 Top Flap")
+        
+        # Panel 3 (L) + Flaps
+        add_quad([(p3_x[0], main_y[0], z), (p3_x[1], main_y[0], z), (p3_x[1], main_y[1], z), (p3_x[0], main_y[1], z)], COLOR_PANEL_L, "Panel 3 (L)")
+        add_quad([(p3_x[0], bot_flap_y[0], z), (p3_x[1], bot_flap_y[0], z), (p3_x[1], bot_flap_y[1], z), (p3_x[0], bot_flap_y[1], z)], COLOR_FLAP, "P3 Bot Flap")
+        add_quad([(p3_x[0], top_flap_y[0], z), (p3_x[1], top_flap_y[0], z), (p3_x[1], top_flap_y[1], z), (p3_x[0], top_flap_y[1], z)], COLOR_FLAP, "P3 Top Flap")
+        
+        # Panel 4 (W) + Flaps
+        add_quad([(p4_x[0], main_y[0], z), (p4_x[1], main_y[0], z), (p4_x[1], main_y[1], z), (p4_x[0], main_y[1], z)], COLOR_PANEL_W, "Panel 4 (W)")
+        add_quad([(p4_x[0], bot_flap_y[0], z), (p4_x[1], bot_flap_y[0], z), (p4_x[1], bot_flap_y[1], z), (p4_x[0], bot_flap_y[1], z)], COLOR_FLAP, "P4 Bot Flap")
+        add_quad([(p4_x[0], top_flap_y[0], z), (p4_x[1], top_flap_y[0], z), (p4_x[1], top_flap_y[1], z), (p4_x[0], top_flap_y[1], z)], COLOR_FLAP, "P4 Top Flap")
+        
+        # Dimension labels
+        fig_3d.add_trace(go.Scatter3d(
+            x=[total_net_w / 2], y=[total_net_h + 20], z=[5],
+            mode='text', text=[f"Sheet: {fmt_val(total_net_w)} × {fmt_val(total_net_h)} {unit_label}"],
+            textfont=dict(size=12, color='#1976D2'), showlegend=False
+        ))
+        fig_3d.add_trace(go.Scatter3d(
+            x=[(p1_x[0] + p1_x[1]) / 2], y=[flap_h + H_net / 2], z=[5],
+            mode='text', text=[f"L={fmt_val(L_net)}"],
+            textfont=dict(size=11, color='#333'), showlegend=False
+        ))
+        fig_3d.add_trace(go.Scatter3d(
+            x=[(p2_x[0] + p2_x[1]) / 2], y=[flap_h + H_net / 2], z=[5],
+            mode='text', text=[f"W={fmt_val(W_net)}"],
+            textfont=dict(size=11, color='#333'), showlegend=False
+        ))
+        fig_3d.add_trace(go.Scatter3d(
+            x=[(p2_x[0] + p2_x[1]) / 2], y=[flap_h / 2], z=[5],
+            mode='text', text=[f"Flap={fmt_val(flap_h)}"],
+            textfont=dict(size=10, color='#666'), showlegend=False
+        ))
+        
+        # Center the view on the net
+        center_x = total_net_w / 2
+        center_y = total_net_h / 2
+        
+        fig_3d.update_layout(
+            title=f"3D Flat Net ({fmt_val(total_net_w)} × {fmt_val(total_net_h)} {unit_label})",
+            scene=dict(
+                xaxis=dict(title=f'X ({unit_label})', range=[-total_net_w*0.1, total_net_w * 1.15]),
+                yaxis=dict(title=f'Y ({unit_label})', range=[-total_net_h*0.1, total_net_h * 1.2]),
+                zaxis=dict(title='Z', range=[0, 30], showticklabels=False),
+                aspectmode='auto',  # Auto fit to container
+                camera=dict(
+                    eye=dict(x=0.0, y=0.0, z=2.5),  # Looking straight down, auto mode handles zoom
+                    center=dict(x=0, y=0, z=0),
+                    up=dict(x=0, y=1, z=0)
+                )
+            ),
+            margin=dict(l=0, r=0, t=40, b=0),
+            height=500
+        )
+    
+    else:
+        # === FOLDED BOX VIEW ===
+        # Show assembled RSC box
+        # Coordinate system: X=Width, Y=Height, Z=Length (depth)
+        
+        # Box dimensions
+        W = W_net  # Width (X)
+        H = H_net  # Height (Y)  
+        L = L_net  # Length/Depth (Z)
+        
+        # Panel 2 - Front face (Z=0)
+        add_quad([(0, 0, 0), (W, 0, 0), (W, H, 0), (0, H, 0)], COLOR_PANEL_W, "Front (P2)")
+        
+        # Panel 4 - Back face (Z=L)
+        add_quad([(0, 0, L), (W, 0, L), (W, H, L), (0, H, L)], COLOR_PANEL_W, "Back (P4)")
+        
+        # Panel 1 - Left face (X=0)
+        add_quad([(0, 0, 0), (0, 0, L), (0, H, L), (0, H, 0)], COLOR_PANEL_L, "Left (P1)")
+        
+        # Panel 3 - Right face (X=W)
+        add_quad([(W, 0, 0), (W, 0, L), (W, H, L), (W, H, 0)], COLOR_PANEL_L, "Right (P3)")
+        
+        # Bottom flaps (folded in, Y=0)
+        # Minor flaps (from P2 and P4) - partial overlap
+        add_quad([(0, 0, 0), (W, 0, 0), (W, 0, flap_h), (0, 0, flap_h)], COLOR_FLAP, "P2 Bot Flap")
+        add_quad([(0, 0, L-flap_h), (W, 0, L-flap_h), (W, 0, L), (0, 0, L)], COLOR_FLAP, "P4 Bot Flap")
+        # Major flaps (from P1 and P3) - cover the opening
+        add_quad([(0, 0, flap_h), (0, 0, L-flap_h), (flap_h, 0, L-flap_h), (flap_h, 0, flap_h)], COLOR_FLAP, "P1 Bot Flap")
+        add_quad([(W-flap_h, 0, flap_h), (W-flap_h, 0, L-flap_h), (W, 0, L-flap_h), (W, 0, flap_h)], COLOR_FLAP, "P3 Bot Flap")
+        
+        # Top flaps (folded in, Y=H)
+        add_quad([(0, H, 0), (W, H, 0), (W, H, flap_h), (0, H, flap_h)], COLOR_FLAP, "P2 Top Flap")
+        add_quad([(0, H, L-flap_h), (W, H, L-flap_h), (W, H, L), (0, H, L)], COLOR_FLAP, "P4 Top Flap")
+        add_quad([(0, H, flap_h), (0, H, L-flap_h), (flap_h, H, L-flap_h), (flap_h, H, flap_h)], COLOR_FLAP, "P1 Top Flap")
+        add_quad([(W-flap_h, H, flap_h), (W-flap_h, H, L-flap_h), (W, H, L-flap_h), (W, H, flap_h)], COLOR_FLAP, "P3 Top Flap")
+        
+        # Stitch tab (attached to back of P1, slightly offset)
+        add_quad([(-2, 0, L-2), (-2, 0, L), (-2, H, L), (-2, H, L-2)], COLOR_STITCH, "Stitch Tab")
+        
+        # Dimension labels
+        fig_3d.add_trace(go.Scatter3d(
+            x=[W/2], y=[-30], z=[L/2],
+            mode='text', text=[f"Box: {fmt_val(L)}×{fmt_val(W)}×{fmt_val(H)} {unit_label}"],
+            textfont=dict(size=12, color='#333'), showlegend=False
+        ))
+        # Width label
+        fig_3d.add_trace(go.Scatter3d(
+            x=[W/2], y=[H/2], z=[-15],
+            mode='text', text=[f"W={fmt_val(W)}"],
+            textfont=dict(size=11, color='#333'), showlegend=False
+        ))
+        # Height label  
+        fig_3d.add_trace(go.Scatter3d(
+            x=[-20], y=[H/2], z=[L/2],
+            mode='text', text=[f"H={fmt_val(H)}"],
+            textfont=dict(size=11, color='#333'), showlegend=False
+        ))
+        # Length label
+        fig_3d.add_trace(go.Scatter3d(
+            x=[W+15], y=[H/2], z=[L/2],
+            mode='text', text=[f"L={fmt_val(L)}"],
+            textfont=dict(size=11, color='#333'), showlegend=False
+        ))
+        
+        max_dim = max(W, H, L) * 1.5
+        fig_3d.update_layout(
+            title=f"3D Folded Box ({fmt_val(L)}×{fmt_val(W)}×{fmt_val(H)} {unit_label})",
+            scene=dict(
+                xaxis=dict(title=f'Width ({unit_label})', range=[-50, max_dim]),
+                yaxis=dict(title=f'Height ({unit_label})', range=[-50, max_dim]),
+                zaxis=dict(title=f'Length ({unit_label})', range=[-20, max_dim]),
+                aspectmode='data',
+                camera=dict(eye=dict(x=1.5, y=1.2, z=1.5), up=dict(x=0, y=1, z=0))
+            ),
+            margin=dict(l=0, r=0, t=40, b=0),
+            height=500
+        )
+
+    with vis_col1: st.plotly_chart(fig_2d, use_container_width=True)
+    with vis_col2: st.plotly_chart(fig_3d, use_container_width=True)
+
+
+# --- TAB 4: FINANCIALS ---
+with tabs[3]:
+    st.markdown("### 💰 Financial Analysis & Costing")
+    
+    # order_qty is now global in sidebar
+    cost_res = CorruLabEngine.calculate_granular_cost(CARTON_SPEC, FACTORY_CONFIG, wastage_df, order_qty)
+    
+    # === SECTION 1: KEY METRICS DASHBOARD ===
+    st.markdown("#### 📊 Order Summary")
+    
+    total_revenue = cost_res['price'] * order_qty
+    total_cost = cost_res['factory_cost'] * order_qty
+    total_profit = total_revenue - total_cost
+    profit_margin_pct = (total_profit / total_revenue) * 100 if total_revenue > 0 else 0
+    
+    metric_cols = st.columns(5)
+    with metric_cols[0]:
+        st.metric("Order Quantity", f"{order_qty:,} boxes", 
+                  help="Number of boxes in this order (set in sidebar)")
+    with metric_cols[1]:
+        st.metric("Price / Box", f"Rs {cost_res['price']:.2f}", 
+                  help=f"Factory Cost + {FACTORY_CONFIG.margin_pct}% Margin = Rs {cost_res['factory_cost']:.2f} × 1.{int(FACTORY_CONFIG.margin_pct):02d}")
+    with metric_cols[2]:
+        st.metric("Total Revenue", f"Rs {total_revenue:,.0f}", 
+                  help=f"Price × Quantity = Rs {cost_res['price']:.2f} × {order_qty:,}")
+    with metric_cols[3]:
+        st.metric("Total Profit", f"Rs {total_profit:,.0f}", f"{profit_margin_pct:.1f}%",
+                  help=f"Revenue - Cost = Rs {total_revenue:,.0f} - Rs {total_cost:,.0f}")
+    with metric_cols[4]:
+        st.metric("Cost / Box", f"Rs {cost_res['factory_cost']:.2f}",
+                  help="Sum of: Paper + Waste + Conversion + Value-Add + Setup")
+    
+    st.divider()
+    
+    # === FORMULA REFERENCE ===
+    with st.expander("📐 How Each Cost is Calculated (Click to Expand)", expanded=False):
+        st.markdown(f"""
+        | Cost Component | Formula | Your Values |
+        |----------------|---------|-------------|
+        | **Paper (Net)** | GSM × Takeup × Area × Rate ÷ 1000 | Area = {sheet_area_m2*1e6:,.0f} mm² |
+        | **Waste** | Paper × (Process% + Trim%) | Process = {FACTORY_CONFIG.wastage_process_pct}% |
+        | **Conversion** | Weight × Rate/kg | {cost_res['weight_per_box']*1000:.0f}g × Rs {FACTORY_CONFIG.cost_conversion_per_kg}/kg |
+        | **Setup** | Fixed Cost ÷ Order Qty | Rs {FACTORY_CONFIG.cost_fixed_setup:,.0f} ÷ {order_qty} = Rs {cost_res['setup_cost']:.2f} |
+        | **Margin** | Factory Cost × {FACTORY_CONFIG.margin_pct}% | Rs {cost_res['factory_cost']:.2f} × {FACTORY_CONFIG.margin_pct}% |
+        
+        **Value-Add Costs** (only if enabled):
+        - Printing: Rs {FACTORY_CONFIG.cost_printing_per_1000}/1000 + Plate cost/qty
+        - UV: Rs {FACTORY_CONFIG.cost_uv_per_1000}/1000
+        - Lamination: Rs {FACTORY_CONFIG.cost_lamination_per_1000}/1000
+        - Die-cutting: Rs {FACTORY_CONFIG.cost_die_cutting_per_1000}/1000 + Frame cost/qty
+        """)
+    
+    st.divider()
+    
+    # === SECTION 2: COST BREAKDOWN ===
+    fin_col1, fin_col2 = st.columns([1, 1])
+    
+    with fin_col1:
+        st.markdown("#### 📈 Cost Breakdown (Per Box)")
+        
+        cost_data = [
+            {"Component": "Paper (Net)", "Cost": cost_res['paper_cost_net'], "Category": "Material"},
+            {"Component": "Waste", "Cost": cost_res['trim_and_process_waste_cost'], "Category": "Waste"},
+            {"Component": "Printing", "Cost": cost_res['print_cost'], "Category": "Value Add"},
+            {"Component": "UV/Lam/Die", "Cost": cost_res['uv_cost'] + cost_res['lam_cost'] + cost_res['die_cost'], "Category": "Value Add"},
+            {"Component": "Setup", "Cost": cost_res['setup_cost'], "Category": "Fixed"},
+        ]
+        df_cost = pd.DataFrame(cost_data)
+        
+        # Filter out zero-cost items
+        df_cost = df_cost[df_cost['Cost'] > 0.001]
+        
+        # Pie Chart
+        fig_pie = px.pie(df_cost, values='Cost', names='Component', 
+                         title='Cost Distribution',
+                         color='Category',
+                         color_discrete_map={
+                             "Material": "#2E86AB", "Waste": "#E94F37", 
+                             "Processing": "#F39237", "Value Add": "#96E6A1", "Fixed": "#DDA0DD"
+                         })
+        fig_pie.update_traces(textposition='inside', textinfo='percent+label')
+        st.plotly_chart(fig_pie, use_container_width=True)
+    
+    with fin_col2:
+        st.markdown("#### 📉 Cost Waterfall")
+        
+        # Waterfall chart - only non-zero items
+        waterfall_data = [
+            {"x": "Paper", "y": cost_res['paper_cost_net'], "type": "relative"},
+            {"x": "Waste", "y": cost_res['trim_and_process_waste_cost'], "type": "relative"},
+        ]
+        
+        # Add value-add only if enabled
+        value_add_cost = cost_res['print_cost'] + cost_res['uv_cost'] + cost_res['lam_cost'] + cost_res['die_cost']
+        if value_add_cost > 0:
+            waterfall_data.append({"x": "Value Add", "y": value_add_cost, "type": "relative"})
+        
+        waterfall_data.extend([
+            {"x": "Setup", "y": cost_res['setup_cost'], "type": "relative"},
+            {"x": "Factory Cost", "y": cost_res['factory_cost'], "type": "total"},
+            {"x": f"+Margin ({FACTORY_CONFIG.margin_pct}%)", "y": cost_res['price'] - cost_res['factory_cost'], "type": "relative"},
+            {"x": "Price", "y": cost_res['price'], "type": "total"},
+        ])
+        
+        fig_waterfall = go.Figure(go.Waterfall(
+            x=[d['x'] for d in waterfall_data],
+            y=[d['y'] for d in waterfall_data],
+            measure=[d['type'] for d in waterfall_data],
+            text=[f"Rs {d['y']:.2f}" for d in waterfall_data],
+            textposition="outside",
+            connector=dict(line=dict(color="rgb(63, 63, 63)")),
+            increasing=dict(marker=dict(color="#E94F37")),
+            decreasing=dict(marker=dict(color="#2E86AB")),
+            totals=dict(marker=dict(color="#45B7D1"))
+        ))
+        fig_waterfall.update_layout(title="Cost Build-up to Price", showlegend=False, height=400)
+        st.plotly_chart(fig_waterfall, use_container_width=True)
+    
+    st.divider()
+    
+    # === SECTION 3: DETAILED COST TABLE ===
+    st.markdown("#### 📋 Cost Summary")
+    
+    detail_col1, detail_col2 = st.columns([2, 1])
+    
+    with detail_col1:
+        # Add per-box and order-total columns
+        df_cost['Per Box (Rs)'] = df_cost['Cost']
+        df_cost['Order Total (Rs)'] = df_cost['Cost'] * order_qty
+        df_cost['% of Cost'] = (df_cost['Cost'] / cost_res['factory_cost'] * 100)
+        
+        st.dataframe(
+            df_cost[['Component', 'Category', 'Per Box (Rs)', 'Order Total (Rs)', '% of Cost']].style.format({
+                "Per Box (Rs)": "{:.2f}",
+                "Order Total (Rs)": "{:,.0f}",
+                "% of Cost": "{:.1f}%"
+            }).background_gradient(subset=['% of Cost'], cmap='Reds'),
+            use_container_width=True, hide_index=True
+        )
+    
+    with detail_col2:
+        st.markdown("##### 💵 Profitability Summary")
+        st.markdown(f"""
+        | Metric | Per Box | Order Total |
+        |--------|---------|-------------|
+        | **Revenue** | Rs {cost_res['price']:.2f} | Rs {total_revenue:,.0f} |
+        | **Cost** | Rs {cost_res['factory_cost']:.2f} | Rs {total_cost:,.0f} |
+        | **Profit** | Rs {cost_res['price'] - cost_res['factory_cost']:.2f} | Rs {total_profit:,.0f} |
+        | **Margin** | {profit_margin_pct:.1f}% | {profit_margin_pct:.1f}% |
+        """)
+    
+    st.divider()
+    
+    # === SECTION 4: QUOTATION SUMMARY ===
+    st.markdown("#### 📝 Quotation Summary")
+    
+    quote_col1, quote_col2 = st.columns([1, 1])
+    
+    with quote_col1:
+        st.markdown(f"""
+        **📦 Product:** {ply_type} RSC Box  
+        **📏 Dimensions:** {l_mm} × {w_mm} × {h_mm} mm  
+        **⚖️ Weight:** {cost_res['weight_per_box']*1000:.0f} g per box  
+        **🔢 Quantity:** {order_qty:,} boxes  
+        """)
+        
+    with quote_col2:
+        st.markdown(f"""
+        <div style='background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); 
+                    padding: 20px; border-radius: 10px; color: white; text-align: center;'>
+            <h3 style='margin:0; color: white;'>QUOTED PRICE</h3>
+            <h1 style='margin: 10px 0; color: white;'>Rs {cost_res['price']:.2f} / box</h1>
+            <p style='margin:0; opacity: 0.9;'>Order Total: Rs {total_revenue:,.0f}</p>
+        </div>
+        """, unsafe_allow_html=True)
+
+# --- TAB 5: REPORTS ---
+with tabs[4]:
+    st.markdown("### 📄 Job Card & Quote")
+    
+    st.markdown(f"""
+    <div style='border:1px solid #ccc; padding:20px; background:white;'>
+        <h2>JOB CARD: {quote_ref}</h2>
+        <p><b>Client:</b> {cust_name} | <b>Date:</b> {datetime.now().strftime('%d-%b-%Y')}</p>
+        <hr>
+        <h4>1. Production Specs</h4>
+        <ul>
+            <li><b>Size:</b> {l_mm} x {w_mm} x {h_mm} mm</li>
+            <li><b>Board:</b> {ply_type}</li>
+            <li><b>Net Weight (Finished Boxes):</b> {cost_res['weight_per_box']*order_qty/1000.0:.2f} Tons ({order_qty} Boxes)</li>
+            <li><b>Score Lines:</b> {CARTON_SPEC.stitch_allowance_mm:.1f} | {l_mm} | {w_mm} | {l_mm} | {w_mm}</li>
+        </ul>
+        <h4>2. Material List & Deckles</h4>
+        <table width='100%' border='1' cellspacing='0' cellpadding='5'>
+            <tr><th>Layer</th><th>Grade</th><th>GSM</th><th>Deckle (mm)</th><th>Burst (kPa)</th><th>RCT-CD (kgf)</th></tr>
+            {''.join([f"<tr><td>{l.layer_type}</td><td>{l.paper.code}</td><td>{l.paper.gsm}</td><td>{l.deckle_mm}</td><td>{l.paper.bursting_strength_kpa}</td><td>{l.paper.rct_cd_N:.1f}</td></tr>" for l in CARTON_SPEC.layers])}
+        </table>
+    </div>
+    """, unsafe_allow_html=True)
+    
+    st.markdown("### 📦 Material Requisition (Store Demand)")
+    
+    # Enhanced Per-Layer Breakdown
+    st.markdown("#### Layer-by-Layer Calculation")
+    
+    layer_breakdown_data = []
+    # Sheet area - full rectangle (stitch cut-out is waste, not subtracted)
+    flap_h_calc = min(l_mm, w_mm) / 2.0
+    sheet_area_calc = ((2*l_mm + 2*w_mm + CARTON_SPEC.stitch_allowance_mm) * (w_mm + h_mm)) / 1_000_000.0
+    
+    for i, layer in enumerate(CARTON_SPEC.layers):
+        takeup = layer.flute_profile.factor if layer.flute_profile else 1.0
+        weight_net_per_box = (layer.paper.gsm * takeup * sheet_area_calc / 1000.0)
+        weight_net_total = weight_net_per_box * order_qty
+        
+        row = wastage_df.loc[wastage_df['layer_idx'] == i].iloc[0]
+        
+        # Process waste
+        w_after_process = weight_net_total * (1 + FACTORY_CONFIG.wastage_process_pct/100.0)
+        
+        # Trim waste
+        if row['deckle_mm'] > 0 and row['ups'] > 0:
+            deckle_util = (row['ups'] * (w_mm + h_mm)) / row['deckle_mm']
+            deckle_util_pct = deckle_util * 100
+            w_gross = w_after_process / deckle_util if deckle_util > 0 else w_after_process
+        else:
+            deckle_util_pct = 100.0
+            w_gross = w_after_process
+        
+        layer_breakdown_data.append({
+            "Layer": f"{layer.layer_type} ({layer.paper.code})",
+            "GSM": layer.paper.gsm,
+            "Takeup": takeup,
+            "Net (kg)": weight_net_total,
+            f"+Process ({FACTORY_CONFIG.wastage_process_pct}%)": w_after_process - weight_net_total,
+            "Deckle Util (%)": deckle_util_pct,
+            "+Trim (kg)": w_gross - w_after_process,
+            "Gross (kg)": w_gross
+        })
+    
+    df_layers = pd.DataFrame(layer_breakdown_data)
+    st.dataframe(
+        df_layers.style.format({
+            "Net (kg)": "{:.1f}",
+            f"+Process ({FACTORY_CONFIG.wastage_process_pct}%)": "{:+.1f}",
+            "Deckle Util (%)": "{:.1f}%",
+            "+Trim (kg)": "{:+.1f}",
+            "Gross (kg)": "{:.1f}",
+            "Takeup": "{:.2f}"
+        }),
+        use_container_width=True
+    )
+    
+    # Summary row
+    total_net = df_layers["Net (kg)"].sum()
+    total_process = df_layers[f"+Process ({FACTORY_CONFIG.wastage_process_pct}%)"].sum()
+    total_trim = df_layers["+Trim (kg)"].sum()
+    total_gross = df_layers["Gross (kg)"].sum()
+    
+    st.markdown(f"""
+    **Summary:**
+    | Net Weight | + Process Waste | + Trim Waste | = Gross Requirement |
+    |------------|-----------------|--------------|---------------------|
+    | {total_net:,.0f} kg | +{total_process:,.0f} kg | +{total_trim:,.0f} kg | **{total_gross:,.0f} kg** |
+    """)
+    
+    st.info(f"""
+    **📐 Formula Applied:**  
+    `Gross = (Net × 1.{int(FACTORY_CONFIG.wastage_process_pct):02d}) ÷ Deckle_Utilization`  
+    Where Deckle_Utilization = (Ups × SheetWidth) ÷ ReelSize
+    """)