layer1_static_optimization.py

Go to the documentation of this file.

"""Layer 1: Static Optimization
 
This layer implements the main optimization loop that optimizes ONLY
static (time‑independent) quantities:
 
- Engine geometry (throat, L*, expansion ratio, pintle or impinging jet geometry)
- Initial tank pressures for LOX and fuel (single value per tank)
 
All **time‑varying** pressure behavior (segments/curves over the burn)
is handled **exclusively** in Layer 2 (`layer2_pressure.py`). Layer 1
must NOT create or manipulate pressure segments or time arrays.
"""
 
from __future__ import annotations
 
from typing import Tuple, Callable, Dict, Any, Optional, List, Sequence
import numpy as np
import copy
import logging
import time
import os
from datetime import datetime
from pathlib import Path
from concurrent.futures import ProcessPoolExecutor
 
from engine.pipeline.config_schemas import PintleEngineConfig, HybridOptimizerConfig
from engine.core.runner import PintleEngineRunner
from engine.core.discharge import discharge_cd_inf_ratio
from engine.core.injectors.layout import (
    IMPINGEMENT_LD_TARGET_DEFAULT,
    EXIT_LAND_DEFAULT,
    FREE_JET_MAX_D,
    PLATE_THICKNESS_DEFAULT,
    MANIFOLD_Q_FRAC,
    channel_for_ring,
    channel_lands,
    channel_velocity_head as _channel_velocity_head,
    igniter_keepouts,
    impingement_ld_band,
    passage_back_entry,
    ring_face_reach,
)
 
#: Standoff band when a caller hands over no requirements at all.
_LD_BAND_DEFAULT = impingement_ld_band(None)
from engine.core.injectors.flow_capacity import (
    effective_flow_areas_from_cd,
    merge_effective_area_warnings,
)
from engine.optimizer.injector_dp_penalty import (
    injector_dp_bands_from_requirements,
    injector_dp_ratio_penalty_weighted,
    injector_dp_ratios_from_eval_result,
    injector_dp_ratio_within_gate,
)
 
from scipy.optimize import minimize, differential_evolution
 
try:
    import cma
except ImportError:  # pragma: no cover - optional dependency
    cma = None
   
 
from engine.optimizer.utils import (
    extract_all_parameters,
    impinging_chamber_inner_diameter_for_bounds,
    impinging_d_jet_upper_bound_m,
    impinging_n_elements_hi_int,
    impinging_spacing_upper_bound_m,
)
 
from engine.core.chamber_geometry import (
    chamber_length_calc,
    contraction_length_horizontal_calc,
)
 
 
#: How ``ChamberSolver.solve`` words a solve that ran but did not close: its own checks on
#: the root it found. A validation replay that ends in one of these is an invalid design,
#: not a crash (see ``_validation_evaluate_or_bundle`` in ``run_layer1_optimization``).
_CHAMBER_SOLVER_REFUSALS = (
    "Solution validation failed",
    "Convergence validation failed",
    "Chamber pressure solver failed",
    "Solver returned non-finite pressure",
)
 
 
TOTAL_WALL_THICKNESS_M = 0.0254  # fallback only: 1.0 inch total (0.5 in/side). See _layer1_total_wall_thickness_m.
 
 
def _layer1_total_wall_thickness_m(config: Any) -> float:
    """Total chamber-wall thickness (both sides) for the OD -> gas-side conversion.
 
    Thin alias for :func:`engine.optimizer.utils.total_wall_thickness_m`: the wall is
    DERIVED as ``2 x (metal case + ablative liner when enabled)`` from the fields that
    own those layers (``design_requirements.metal_wall_thickness_per_side_m`` and
    ``ablative_cooling.initial_thickness``). Layer 3 re-sizing the liner therefore
    updates the wall on the next run automatically — there is no lump wall field and
    no write-back (the old one overwrote metal+ablative with ablative alone, so
    rerun geometry grew past what physically fits the OD envelope).
    """
    from engine.optimizer.utils import total_wall_thickness_m
    return total_wall_thickness_m(config)
 
# Default for ``requirements["min_stability_margin"]`` when unset. MUST stay identical in
# ``run_layer1_optimization`` and ``_compute_objective_value`` — parallel CMA ranks candidates via
# workers using the latter; L-BFGS-B uses ``objective()`` on the parent process.
_LAYER1_DEFAULT_MIN_STABILITY_MARGIN = 1.2
 
# Fallback injector ΔP/Pc bands when ``constants_dict`` omits keys (must match
# ``requirements.get("injector_dp_ratio_*")`` defaults in ``run_layer1_optimization``).
_LAYER1_DEFAULT_DP_O_BAND = (0.20, 0.40)
_LAYER1_DEFAULT_DP_F_BAND = (0.20, 0.40)
 
# Fallback when ``layer1_exit_pressure_inside_quad_scale`` is absent from constants (matches
# ``_requirement_float(..., "layer1_exit_pressure_inside_quad_scale", 0.35)``).
_LAYER1_DEFAULT_EXIT_PRESSURE_INSIDE_QUAD = 0.35
 
# Tiny stability/packing residuals below this are treated as feasible for primary objective blending.
_LAYER1_DEFAULT_INFEASIBILITY_GATE_EPS = 0.002
 
# Multiplicative deadband for log-space momentum pull toward R=1 (optimizer soft term only).
# Zero = always-on (log R)^2 gradient toward R=1.
_LAYER1_DEFAULT_MOMENTUM_LOG_DEADBAND_REL = 0.0
 
_LAYER1_BASE_INFEAS = 1e6
_LAYER1_W_INFEAS = 1e5
 
# Cap on the per-candidate derived-DOF solve; it exits on tolerance well before this.
_LAYER1_DERIVE_MAX_ITERS_DEFAULT = 8
 
# Chamber-pressure target: sign-off band and the objective's interior aim band (80 % of it,
# the same convention as the dP/Pc and momentum bands -- penalty and gate never share an edge).
_LAYER1_PC_GATE_REL = 0.01
_LAYER1_PC_AIM_REL = 0.8 * _LAYER1_PC_GATE_REL
 
 
class _LocalSerialExecutor:
    """Drop-in minimal executor used when process pools are unavailable."""
 
    def __init__(self):
        self._max_workers = 1
 
    def __enter__(self):
        return self
 
    def __exit__(self, exc_type, exc, tb):
        return False
 
    def map(self, fn, iterable, chunksize=None):
        del chunksize  # Serial executor ignores chunk hints.
        return map(fn, iterable)
 
 
def _throat_area_m2_from_config(config: PintleEngineConfig) -> Optional[float]:
    """Prefer unified ``chamber_geometry``; many YAMLs leave legacy ``chamber`` null."""
    cg = getattr(config, "chamber_geometry", None)
    if cg is not None:
        at = getattr(cg, "A_throat", None)
        if at is not None and np.isfinite(float(at)) and float(at) > 0:
            return float(at)
    ch = getattr(config, "chamber", None)
    if ch is not None:
        at = getattr(ch, "A_throat", None)
        if at is not None and np.isfinite(float(at)) and float(at) > 0:
            return float(at)
    return None
 
 
def _requirement_float(requirements: Dict[str, Any], key: str, default: float) -> float:
    """Parse float from Layer-1 ``requirements``; treat explicit ``None`` as *unset*."""
    v = requirements.get(key)
    return float(default if v is None else v)
 
 
def _layer1_thrust_deadband(req: Any) -> float:
    """Relative thrust deadband for the objective.
 
    2% when the throat is searched (the historical value: thrust is a soft target CMA has to
    negotiate). 0.1% when the throat is SOLVED from thrust -- the derivation lands every
    candidate on target, so a wide deadband only lets edge-sitting winners through with a
    2-3% miss priced at ~1-3 objective points (measured: 7341 N against 7200 with no thrust
    penalty at all). ``layer1_thrust_deadband_rel`` overrides both.
    """
    get = getattr(req, "get", None)
    if get is None:
        return 0.02
    v = get("layer1_thrust_deadband_rel")
    if v is not None:
        try:
            return max(0.0, float(v))
        except (TypeError, ValueError):
            pass
    derived = get("layer1_derive_throat_from_thrust")
    derived = True if derived is None else bool(derived)
    return 0.001 if derived else 0.02
 
 
def _layer1_igniter_keepouts(config_obj: Any, requirements: Dict[str, Any]) -> Optional[Dict[str, Any]]:
    """The declared igniter port's keep-outs (engine.core.injectors.layout), or None."""
    ign = getattr(getattr(config_obj, "injector", None), "igniter", None)
    if ign is None:
        return None
    return igniter_keepouts(
        ign.model_dump() if hasattr(ign, "model_dump") else dict(ign),
        plate_thickness=_requirement_float(requirements, "layer1_injector_plate_thickness_m", 0.0),
        min_web=_requirement_float(requirements, "layer1_injector_min_web_m", 0.0))
 
 
def _layer1_plate(config_obj: Any) -> Dict[str, Any]:
    """The injector.plate block as a dict ({} when undeclared): how the plug is machined."""
    pl = getattr(getattr(config_obj, "injector", None), "plate", None)
    if pl is None:
        return {}
    return pl.model_dump() if hasattr(pl, "model_dump") else dict(pl)
 
 
def _layer1_injector_plate_constants(config_obj: Any, requirements: Dict[str, Any]) -> Dict[str, Any]:
    """The injector-plate entries of Layer 1's constants dict, from the config and requirements.
 
    Nothing declared under ``injector.plate`` => flat face, plenum back: exactly the constraints
    this optimizer had before. ``layer1_injector_plate_support`` reads ``injector.plate.support``
    when the schema carries it; a rim-retained plug defaults to simply supported.
    """
    # Orifice land length (diameters) per side, which decides whether the back-face entry is
    # the counterbore or the orifice itself. Same source the Cd model reads.
    def _land_ld(side: str) -> float:
        try:
            v = getattr(config_obj.discharge[side], "orifice_l_over_d", None)
        except (KeyError, TypeError, AttributeError):
            v = None
        return float(v) if v is not None and np.isfinite(float(v)) and float(v) > 0 else 4.0
    ld_O = _land_ld("oxidizer")
    try:
        _fuel_ld = getattr(config_obj.discharge["fuel"], "orifice_l_over_d", None)
    except (KeyError, TypeError, AttributeError):
        _fuel_ld = None
    # The layout falls back to the oxidiser's L/d, not 4.0; so does this.
    ld_F = _land_ld("fuel") if _fuel_ld is not None else ld_O
    plate = _layer1_plate(config_obj)
    plate_obj = getattr(getattr(config_obj, "injector", None), "plate", None)
    support = getattr(plate_obj, "support", None) or plate.get("support") or "simply_supported"
    _closure_plate_stress_coeff(support)          # an unknown value fails here, not per candidate
    return {
        "layer1_injector_plate_thickness_m": _requirement_float(
            requirements, "layer1_injector_plate_thickness_m", 0.0),
        "layer1_injector_land_ld_O": ld_O,
        "layer1_injector_land_ld_F": ld_F,
        "layer1_injector_face_contoured": plate.get("face") == "contoured",
        "layer1_injector_back_channels": plate.get("back") == "channels",
        "layer1_injector_exit_land": (float(plate["exit_land"]) if plate.get("exit_land") is not None
                                      else EXIT_LAND_DEFAULT),
        "layer1_injector_channel_width_m": float(plate.get("channel_width") or 0.0),
        "layer1_injector_channel_floor": str(plate.get("channel_floor") or "flat"),
        "layer1_injector_channel_inlets": int(plate.get("channel_inlets") or 1),
        "layer1_injector_plate_support": str(support),
    }
 
 
def _layer1_centre_clear_m(config_obj: Any, requirements: Dict[str, Any]) -> float:
    """Centre keep-out diameter: the explicit reservation if set, else the igniter's, else 0."""
    cc = _requirement_float(requirements, "layer1_injector_center_clear_dia_m", 0.0)
    if cc > 0.0:
        return cc
    ign = _layer1_igniter_keepouts(config_obj, requirements)
    return float(ign["face_keepout_dia"]) if ign is not None else 0.0
 
 
def _requirement_bool(requirements: Dict[str, Any], key: str, default: bool) -> bool:
    """Parse a checkbox-style flag from Layer-1 ``requirements``.
 
    Explicit ``None`` (or a missing key) means *unset* and takes ``default``.
    Accepts the string forms the frontend/YAML can produce so a config saying
    ``false`` is not read as truthy.
    """
    v = requirements.get(key)
    if v is None:
        return bool(default)
    if isinstance(v, str):
        s = v.strip().lower()
        if s in ("false", "0", "no", "off", ""):
            return False
        if s in ("true", "1", "yes", "on"):
            return True
        return bool(default)
    return bool(v)
 
 
def _layer1_infeasibility_gate_eps(requirements: Dict[str, Any]) -> float:
    return max(
        0.0,
        _requirement_float(
            requirements,
            "layer1_infeasibility_gate_eps",
            _LAYER1_DEFAULT_INFEASIBILITY_GATE_EPS,
        ),
    )
 
 
def _layer1_inf_residual(infeasibility_score: float, requirements: Dict[str, Any]) -> float:
    gate_eps = _layer1_infeasibility_gate_eps(requirements)
    return max(0.0, float(infeasibility_score) - gate_eps)
 
 
def _layer1_feasible_for_primary_objective(
    infeasibility_score: float,
    requirements: Dict[str, Any],
    *,
    length_violation: bool = False,
) -> bool:
    if length_violation:
        return False
    return _layer1_inf_residual(infeasibility_score, requirements) <= 0.0
 
 
def _layer1_inf_residual_from_objective(obj: float) -> float:
    """Infer feasibility residual from scalar objective (parallel worker path)."""
    if not np.isfinite(obj) or float(obj) < _LAYER1_BASE_INFEAS:
        return 0.0
    return max(0.0, (float(obj) - _LAYER1_BASE_INFEAS) / _LAYER1_W_INFEAS)
 
 
def _layer1_feasible_scalar_objective(obj: float) -> bool:
    """True when ``obj`` is on the feasible (weighted-sum) branch, not the 1e6 infeasibility floor."""
    return bool(np.isfinite(obj) and float(obj) < _LAYER1_BASE_INFEAS)
 
 
def _layer1_valley_escape_tier(evals: int, best_f: float, stagnation: int) -> int:
    """Sigma-boost tier for a search stuck on the infeasible plateau (0 = none).
 
    Only while no feasible design has been found. The tiers used to fire on absolute
    objective magnitudes (best > 100/150/300), which a shaping floor that never reaches zero
    -- the chamber-mass or performance term -- always exceeds, so every feasible run was
    kicked 4-7 times mid-convergence and blank ones never. Once feasible, restarts and
    refreshes do the exploring.
    """
    if _layer1_feasible_scalar_objective(best_f):
        return 0
    if evals > 5000 and stagnation > 1000:
        return 3
    if evals > 3000 and stagnation > 500:
        return 2
    if evals > 1500 and stagnation > 300:
        return 1
    return 0
 
 
def _x_solved_or(res: Dict[str, Any], fallback: np.ndarray) -> np.ndarray:
    """The candidate vector AS EVALUATED, falling back to the proposal.
 
    Derived DOFs are solved inside the worker and their bounds are collapsed, so the vector
    CMA proposed still carries the seed for them. Only ``x_solved`` describes the design that
    was actually scored -- record anything else and the winner reported back is not the
    winner that was measured.
    """
    xs = res.get("x_solved") if isinstance(res, dict) else None
    if xs is None:
        return np.asarray(fallback, dtype=float).copy()
    arr = np.asarray(xs, dtype=float)
    if arr.shape != np.asarray(fallback).shape or not np.all(np.isfinite(arr)):
        return np.asarray(fallback, dtype=float).copy()
    return arr
 
 
def _store_last_good_eval_bundle_from_worker_res(
    res: Dict[str, Any], state: Optional[Dict[str, Any]]
) -> None:
    """Keep a parent-side copy of the last successful worker ``evaluate()`` for validation replay."""
    if state is None:
        return
    if not res.get("success") or not isinstance(res.get("full_results"), dict):
        return
    fr = res["full_results"]
    try:
        rf = float(fr.get("F", float("nan")))
    except (TypeError, ValueError):
        rf = float("nan")
    if not np.isfinite(rf):
        return
    # ``res`` came off the pool by unpickling, so this process is already the only
    # holder of ``fr``; the parent reads scalars off ``res`` afterwards and never mutates
    # full_results. The one consumer of this bundle (see the validation replay) deep-copies
    # on read, so a copy here was the second of three on the same payload.
    state["last_good_eval_bundle"] = {
        "results": fr,
        "P_O_Pa": float(res.get("P_O_Pa", 0.0)),
        "P_F_Pa": float(res.get("P_F_Pa", 0.0)),
        "thrust_error": float(res.get("thrust_error", 1.0)),
        "of_error": float(res.get("of_error", 1.0)),
    }
 
 
def _lox_ring_inboard(spacing_O_m: Any, spacing_F_m: Any, *, fallback: bool = True) -> bool:
    """True when the LOX pitch circle is inside (or on) the fuel's: D_pitch = n s / pi with one
    n for both rings, so the spacings order the rings. ``fallback`` when either is unusable."""
    try:
        sO, sF = float(spacing_O_m), float(spacing_F_m)
    except (TypeError, ValueError):
        return bool(fallback)
    if not (np.isfinite(sO) and np.isfinite(sF) and sO > 0 and sF > 0):
        return bool(fallback)
    return bool(sO <= sF)
 
 
def _impinging_resultant_tilt_deg(
    mdot_O: float, mdot_F: float,
    rho_O: float, rho_F: float,
    n_elements: float, d_jet_O_m: float, d_jet_F_m: float,
    angle_O_deg: float, angle_F_deg: float,
    lox_inboard: bool = True,
    *,
    spacing_O_m: float = float("nan"),
    spacing_F_m: float = float("nan"),
) -> float:
    """Tilt of the doublet's resultant from the chamber axis [deg]; + = toward the WALL.
 
    Which ring is inboard comes from the pitch circles when the spacings are given
    (:func:`_lox_ring_inboard`, the rule :func:`_resultant_tilt_breakeven_deg` uses), and
    only falls back to ``lox_inboard`` without them. It used to come from the
    ``layer1_ring_order_fuel_outboard`` REQUEST, so a design whose LOX ring sat outboard had
    its tilt reported with the wrong sign against a break-even computed the right way.
 
    This is the quantity the "protect the ablative" rule was always meant to guard. A
    doublet's spray fan follows the VECTOR SUM of its two streams. With LOX inboard, the LOX
    jet travels radially outward to the collision and the fuel jet inward, so with outward
    positive::
 
        p   = mdot * v          (stream momentum; v = mdot / (rho * n * A_jet))
        P_r = p_O*sin(th_O) - p_F*sin(th_F)
        P_z = p_O*cos(th_O) + p_F*cos(th_F)
        alpha = atan2(P_r, P_z)
 
    The momentum-FLUX ratio ``R = sqrt(rho_O v_O^2 / (rho_F v_F^2))`` that Layer 1 used as
    the proxy carries no areas and no angles, and::
 
        p_O/p_F = R^2 * (A_O n_O)/(A_F n_F)
 
    so R = 1 is NOT balance -- balance is p_O = p_F. Measured on this design: at R = 1.0002
    the stream ratio is 1.805 and the fan tilts +16.0 deg OUTWARD, reaching the liner 99 mm
    down a 190 mm chamber while the spray is still liquid (x* = 167 mm). Banning R > 1 was
    therefore selecting the WORST case for the liner, and costing 8.2 s of ideal Isp by
    forcing O/F to 2.19 (CEA peak is at 1.65).
 
    Angles are the lever: sin(th_O)/sin(th_F) = p_F/p_O gives alpha = 0 exactly.
    """
    try:
        mO, mF = float(mdot_O), float(mdot_F)
        rO, rF = float(rho_O), float(rho_F)
        n = max(1.0, float(n_elements))
        dO, dF = float(d_jet_O_m), float(d_jet_F_m)
        tO, tF = np.deg2rad(float(angle_O_deg)), np.deg2rad(float(angle_F_deg))
    except (TypeError, ValueError):
        return float("nan")
    A_O = np.pi * (dO / 2.0) ** 2 * n
    A_F = np.pi * (dF / 2.0) ** 2 * n
    if not all(np.isfinite(v) and v > 0 for v in (mO, mF, rO, rF, A_O, A_F)):
        return float("nan")
    p_O = mO * (mO / (rO * A_O))          # mdot * v
    p_F = mF * (mF / (rF * A_F))
    if not (np.isfinite(p_O) and np.isfinite(p_F)):
        return float("nan")
    lox_inboard = _lox_ring_inboard(spacing_O_m, spacing_F_m, fallback=lox_inboard)
    sgn = 1.0 if lox_inboard else -1.0     # flip the rings, flip which way "outward" is
    P_r = sgn * (p_O * np.sin(tO) - p_F * np.sin(tF))
    P_z = p_O * np.cos(tO) + p_F * np.cos(tF)
    if not (np.isfinite(P_r) and np.isfinite(P_z)) or P_z <= 0.0:
        return float("nan")
    return float(np.degrees(np.arctan2(P_r, P_z)))
 
 
def _resultant_tilt_breakeven_deg(
    *, n_elements: float, spacing_O_m: float, spacing_F_m: float,
    angle_O_deg: float, angle_F_deg: float,
    D_chamber_inner_m: float, L_chamber_m: float,
) -> float:
    """Outward tilt at which the spray fan just reaches the liner at the throat plane [deg].
 
    ``layer1_resultant_tilt_max_deg`` is a CONSTANT the operator sets, but what makes a given
    tilt safe is geometry the optimizer is free to move underneath it::
 
        r_imp   = r_inner + L_imp * tan(theta_inner)      where the fans actually start
        reach   = (r_wall - r_imp) / tan(alpha)           how far they run before the liner
        safe    <=>  reach > L_chamber
 
    so the break-even angle is ``atan2(r_wall - r_imp, L_chamber)``. Sizing the allowance by
    hand is a trap: an allowance justified at one impingement radius stops being justified
    when the ring pair moves out. Measured while setting this design up -- 6.0 deg was chosen
    against r_imp = 37 mm (break-even 9.6 deg) and the converged design landed at r_imp =
    44.1 mm, where break-even is 7.21 deg. Still inside, but on 1.25x rather than the 1.6x
    that was intended, and nothing would have said so.
 
    Returns NaN when the geometry is degenerate. This is a REPORTING aid; it deliberately does
    not move the gate, which stays exactly where the operator put it.
    """
    try:
        n = float(n_elements)
        dp_O = n * float(spacing_O_m) / np.pi
        dp_F = n * float(spacing_F_m) / np.pi
        tan_sum = float(np.tan(np.deg2rad(float(angle_O_deg)))
                        + np.tan(np.deg2rad(float(angle_F_deg))))
        r_wall = 0.5 * float(D_chamber_inner_m)
        L = float(L_chamber_m)
    except (TypeError, ValueError):
        return float("nan")
    if not (np.isfinite(tan_sum) and tan_sum > 1e-9 and r_wall > 0 and np.isfinite(L) and L > 0):
        return float("nan")
    dr = 0.5 * abs(dp_O - dp_F)
    L_imp = dr / tan_sum
    inner_is_O = _lox_ring_inboard(spacing_O_m, spacing_F_m)
    th_in = float(angle_O_deg) if inner_is_O else float(angle_F_deg)
    r_imp = 0.5 * (dp_O if inner_is_O else dp_F) + L_imp * float(np.tan(np.deg2rad(th_in)))
    if not np.isfinite(r_imp) or r_imp >= r_wall:
        return 0.0
    return float(np.degrees(np.arctan2(r_wall - r_imp, L)))
 
 
def _resolve_tilt_allowance_deg(
    *, from_reach: bool, constant_deg: float, breakeven_deg: float, margin: float,
) -> float:
    """The outward tilt this design is allowed, in degrees.
 
    Two modes, and the default is the old one exactly:
 
    * ``from_reach = False`` -- the operator's constant. Previous behaviour.
    * ``from_reach = True``  -- derived from the design's own geometry. ``breakeven_deg`` is the
      angle at which the fan arrives at the liner exactly at the throat plane; dividing the
      chamber length by ``margin`` and re-taking the arctangent gives the angle that arrives at
      ``margin`` chamber lengths instead, which is the same thing as::
 
          allowed = atan( tan(breakeven) / margin )
 
    Why this exists: an outward fan is a hazard only if it REACHES the liner, and the angle at
    which it does is set by ``r_wall - r_imp`` over the chamber length. ``r_imp`` is an output
    the optimizer moves freely, so a constant allowance silently changes meaning between runs.
    Measured: 6.0 deg was justified against r_imp = 37 mm (break-even 9.6) and the converged
    design landed at r_imp = 44.1 mm, where break-even is 7.21 -- still safe, but on 1.25x
    rather than the 1.6x that was intended, and nothing said so.
 
    A non-finite or non-positive break-even falls back to the constant rather than to zero: a
    degenerate geometry should not silently forbid every candidate.
    """
    if not from_reach:
        return float(constant_deg)
    be = float(breakeven_deg)
    if not (np.isfinite(be) and be > 0.0):
        return float(constant_deg)
    m = float(margin) if (np.isfinite(margin) and margin > 0.0) else 1.5
    return float(np.degrees(np.arctan(np.tan(np.deg2rad(be)) / m)))
 
 
def _impinging_resultant_tilt_preference(
    tilt_deg: Any,
    *,
    scale_deg: float = 2.0,
    outward_multiplier: float = 25.0,
) -> float:
    """Preference for a spray fan aimed straight down the chamber: ``(tilt/scale)^2``.
 
    ``tilt_deg`` is the resultant tilt, positive OUTWARD (toward the liner). Inward lean costs the
    plain quadratic, outward lean ``outward_multiplier`` times it. This is a preference priced in
    the objective; the wall guard (:func:`_impinging_resultant_wall_violation`) stays the hard limit.
    """
    try:
        a = float(tilt_deg)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(a):
        return 0.0
    sc = float(scale_deg) if (np.isfinite(scale_deg) and scale_deg > 0) else 2.0
    k = max(1.0, float(outward_multiplier)) if a > 0.0 else 1.0
    return float(k * (a / sc) ** 2)
 
 
def _impinging_resultant_wall_violation(
    tilt_deg: Any,
    *,
    max_outward_deg: float = 0.0,
    scale_deg: float = 2.0,
) -> float:
    """Squared normalized excess of the resultant tilt past ``max_outward_deg``.
 
    A CONSTRAINT, not a preference: a fan aimed at the liner is a burn-through, so this goes
    to the infeasibility score (same treatment the R proxy had) rather than being priced
    against Isp. Tilting INWARD costs nothing here -- it is a mixing loss, handled by the
    ordinary quality terms.
    """
    if tilt_deg is None:
        return 0.0
    try:
        a = float(tilt_deg)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(a):
        return 0.0
    excess = a - float(max_outward_deg)
    if excess <= 0.0:
        return 0.0
    sc = float(scale_deg) if (np.isfinite(scale_deg) and scale_deg > 0) else 2.0
    return float((excess / sc) ** 2)
 
 
def _impinging_momentum_wall_violation(
    R: Any,
    *,
    band_width: float = 0.025,
    safe_side_is_below_one: bool = True,
    scale: float = 0.005,
) -> float:
    """SUPERSEDED by _impinging_resultant_wall_violation; retained for tests/back-compat.
 
    R is a momentum-FLUX ratio: it carries no areas and no angles, so R = 1 is not a balanced
    doublet (p_O/p_F = R^2 * A_O/A_F). Banning R > 1 to protect the liner selected the most
    outward-tilted design available and cost 8.2 s of ideal Isp. The live guard is the
    resultant tilt.
 
    Squared normalized excess of the momentum ratio past the WALL side of the band.
 
    Zero when safe. This is a CONSTRAINT, not a preference, so it is added to the
    infeasibility score rather than priced as a quality term. Pricing it instead -- a
    999999x multiplier on a W_MOM of 1.2e5 -- put a quality term at 1e7..1e11 against a
    BASE_INFEAS of 1e6, which inverted the lexicographic order (every wall-side design
    scored worse than every genuinely infeasible one), flattened the landscape CMA adapts
    to, and stopped the run dead in about a second.
 
    Routed through infeasibility it keeps the intended meaning -- no feasible design ever
    sits on the wall side -- while staying on the same numeric scale as every other hard
    constraint, so the infeasibility gradient can still walk a candidate back into the band.
    """
    if R is None:
        return 0.0
    try:
        r = float(R)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(r) or r <= 0.0:
        return 0.0
    w = abs(float(band_width)) if np.isfinite(band_width) else 0.025
    lo, hi = (1.0 - w, 1.0) if safe_side_is_below_one else (1.0, 1.0 + w)
    excess = np.log(r / hi) if safe_side_is_below_one else np.log(lo / r)
    if not np.isfinite(excess) or excess <= 0.0:
        return 0.0
    # Normalize before squaring. Raw log-excess is ~1e-5 for a 1% overshoot, which sits under
    # the infeasibility gate epsilon (0.002) and would be waved through as "practically
    # feasible" -- the failure this function exists to prevent. At 0.005 (0.5% in log R) a
    # 0.1% overshoot already scores 0.04, comfortably past the gate.
    s_norm = float(scale) if (np.isfinite(scale) and scale > 0) else 0.005
    return float((float(excess) / s_norm) ** 2)
 
 
def _impinging_momentum_asymmetric_squared(
    R: Any,
    *,
    wall_side_multiplier: float = 1.0,
    low_side_multiplier: float = 1.0,
    band_width: float = 0.05,
    safe_side_is_below_one: bool = True,
    scale: float = 0.10,
    band_lo: Optional[float] = None,
    band_hi: Optional[float] = None,
) -> float:
    """Mild symmetric cost on the momentum ratio: free in the band, quadratic outside.
 
    ``band_lo``/``band_hi`` (the configured impinging_momentum_R_min/max, or their aim band)
    set the free band when given; otherwise it is [1/(1+band_width), 1+band_width].
 
    A doublet's resultant is the vector sum of its two streams. With LOX inboard its jet
    travels radially outward to the collision and the fuel jet travels inward, so R > 1 means
    the LOX side wins and the fan is thrown OUTWARD onto the ablative; R < 1 sends it into
    the core, which only costs mixing::
 
        [1 - band_width, 1]   free          -- slightly fuel-dominant, fan leans safely in
        R < 1 - band_width    discouraged   -- 10x, a mixing loss and negotiable
        R > 1                 not priced here -- it is a hard constraint; see
                              _impinging_momentum_wall_violation
 
    ``wall_side_multiplier`` is retained only so an existing config can still express "price
    the wall side instead of banning it"; at its default the wall side returns 0 from this
    function because the infeasibility path owns it.
    """
    if R is None:
        return 0.0
    try:
        r = float(R)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(r) or r <= 0.0:
        return 0.0
 
    # SYMMETRIC band about 1. The one-sided [1-w, 1] band existed because R was the liner
    # guard and "below 1" was the safe side. It is not the guard any more -- the resultant
    # tilt is -- and keeping the band one-sided taxed exactly the tilt-balanced designs,
    # which sit at R ~ 1.010-1.013 (measured: 1286-2050 objective points for R being 1% high).
    # ``safe_side_is_below_one`` still selects which side the multiplier applies to, for
    # anyone who deliberately re-enables a directional preference.
    # LOG-symmetric band: [1/(1+w), 1+w]. Deviations are measured in log space, so a linear
    # band [1-w, 1+w] would price R and 1/R differently for purely arithmetic reasons
    # (0.90 -> 0.292 but 1.111 -> 0.319 at w = 0.05).
    w = abs(float(band_width)) if np.isfinite(band_width) else 0.025
    hi = 1.0 + w
    lo = 1.0 / hi
    if (band_lo is not None and band_hi is not None and np.isfinite(band_lo)
            and np.isfinite(band_hi) and 0.0 < float(band_lo) < float(band_hi)):
        lo, hi = float(band_lo), float(band_hi)
    if lo <= r <= hi:
        return 0.0
 
    on_wall_side = (r > hi) if safe_side_is_below_one else (r < lo)
    mult = float(wall_side_multiplier if on_wall_side else low_side_multiplier)
    if not (np.isfinite(mult) and mult > 0):
        mult = 1.0
    # Clamp: a config left over from when this term was the liner BAN can still carry
    # 999999, which against W_MOM = 1.2e5 put a quality term at 1e7..1e11 versus a
    # BASE_INFEAS of 1e6 and stopped the run dead. The liner guard is the resultant tilt now.
    mult = min(mult, 1.0e3)
 
    s_norm = float(scale) if (np.isfinite(scale) and scale > 0) else 0.10
    dev = np.log(r / hi) if r > hi else np.log(lo / r)
    return float(mult * (float(dev) / s_norm) ** 2)
 
 
def _impinging_momentum_hinge_squared(
    R: Any,
    *,
    r_band_lo: Optional[float] = None,
    r_band_hi: Optional[float] = None,
) -> float:
    """Penalty for momentum_ratio_R outside a preferred band.
 
    If both ``r_band_lo`` and ``r_band_hi`` are finite and ``r_band_hi > r_band_lo``,
    uses a **ratio-space** deadband: zero when ``r_band_lo <= R <= r_band_hi``,
    else squared distance to the nearest band edge.
 
    Otherwise (defaults / legacy): **log-space** deadband zero for R in [1/1.1, 1.1],
    ``max(0, |log R| - log(1.1))**2`` outside.
 
    Returns 0.0 if R is missing, non-finite, or <= 0.
    """
    if R is None:
        return 0.0
    try:
        r = float(R)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(r) or r <= 0.0:
        return 0.0
 
    if (
        r_band_lo is not None
        and r_band_hi is not None
        and np.isfinite(r_band_lo)
        and np.isfinite(r_band_hi)
        and float(r_band_hi) > float(r_band_lo)
    ):
        lo, hi = float(r_band_lo), float(r_band_hi)
        if lo <= r <= hi:
            return 0.0
        excess = float(lo - r) if r < lo else float(r - hi)
        return float(excess * excess)
 
    log_R = float(np.log(r))
    tol = float(np.log(1.1))
    excess = max(0.0, abs(log_R) - tol)
    return float(excess * excess)
 
 
def _impinging_momentum_log_target_squared(
    R: Any,
    *,
    rel_deadband: float = _LAYER1_DEFAULT_MOMENTUM_LOG_DEADBAND_REL,
) -> float:
    """Soft penalty pulling ``momentum_ratio_R`` toward 1.0 in log space.
 
    Unlike the wide ratio-band hinge (zero throughout [R_min, R_max]), this stays active near R≈1
    so CMA/L-BFGS can co-optimize momentum with thrust and O/F without lexicographic blocking.
    Final validation still uses ``impinging_momentum_R_min/max``.
    """
    if R is None:
        return 0.0
    try:
        r = float(R)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(r) or r <= 0.0:
        return 0.0
    log_R = float(np.log(r))
    db = max(0.0, float(rel_deadband))
    if db <= 0.0:
        return float(log_R * log_R)
    # SOFT deadband (not a hard flat zero). A hard zero-penalty band around R=1 removes the
    # sharp attractor that steers CMA-ES, so R wanders out of band and the parallel search
    # collapses (L-BFGS survives it, CMA does not). Instead, inside the tolerance band we keep a
    # *gentle* quadratic (IN_BAND_SCALE × the full curvature) so there is still a gradient toward
    # R=1, and outside the band we apply the full quadratic — made continuous at the edge. Net
    # effect: machining-tolerance deviations of R are cheap (won't be chased below the
    # manufacturing floor), but R is still held firmly inside the band for the optimizer.
    IN_BAND_SCALE = 0.1
    log_tol = float(np.log(1.0 + db))
    abs_log_R = abs(log_R)
    if abs_log_R <= log_tol:
        return float(IN_BAND_SCALE * abs_log_R * abs_log_R)
    # Continuous with the in-band branch at abs_log_R == log_tol:
    #   in_band(log_tol) = IN_BAND_SCALE * log_tol**2
    #   out_band(log_tol) = log_tol**2 - (1 - IN_BAND_SCALE) * log_tol**2 = IN_BAND_SCALE * log_tol**2
    return float(abs_log_R * abs_log_R - (1.0 - IN_BAND_SCALE) * log_tol * log_tol)
 
 
def _impinging_momentum_band_violation_squared(
    R: Any,
    *,
    r_band_lo: Optional[float] = None,
    r_band_hi: Optional[float] = None,
) -> float:
    """Normalized squared violation outside a configured momentum band.
 
    Returns 0.0 when no valid band is configured or R is missing/non-finite.
    """
    if (
        r_band_lo is None
        or r_band_hi is None
        or not np.isfinite(float(r_band_lo))
        or not np.isfinite(float(r_band_hi))
        or float(r_band_hi) <= float(r_band_lo)
    ):
        return 0.0
    try:
        r = float(R)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(r) or r <= 0.0:
        return 0.0
    lo = float(r_band_lo)
    hi = float(r_band_hi)
    if lo <= r <= hi:
        return 0.0
    excess = (lo - r) if r < lo else (r - hi)
    band_span = max(hi - lo, 1e-9)
    norm = excess / band_span
    return float(norm * norm)
 
 
def _impinging_angle_hinge_squared(
    impingement_angle_deg: Any,
    *,
    angle_band_lo_deg: Optional[float] = None,
    angle_band_hi_deg: Optional[float] = None,
) -> float:
    """Penalty for effective impingement angle outside a preferred degree band.
 
    Returns 0.0 when bounds are unset/invalid, or when angle is missing/non-finite.
    """
    if impingement_angle_deg is None:
        return 0.0
    try:
        phi = float(impingement_angle_deg)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(phi):
        return 0.0
    if (
        angle_band_lo_deg is None
        or angle_band_hi_deg is None
        or not np.isfinite(float(angle_band_lo_deg))
        or not np.isfinite(float(angle_band_hi_deg))
        or float(angle_band_hi_deg) <= float(angle_band_lo_deg)
    ):
        return 0.0
    lo = float(angle_band_lo_deg)
    hi = float(angle_band_hi_deg)
    # Jet angles are snapped to whole degrees, so the INCLUDED angle (theta_O + theta_F) moves
    # in 1 deg steps and can only straddle a band edge, never sit on it. Half a degree of
    # rounding slack keeps a 91 deg sum against a 90 deg ceiling from costing a flat
    # W_IMPINGING_ANGLE (=400) on every single run.
    if (lo - 0.5) <= phi <= (hi + 0.5):
        return 0.0
    excess = float((lo - 0.5) - phi) if phi < lo else float(phi - (hi + 0.5))
    # Normalise by band span, exactly like _impinging_momentum_asymmetric_squared above.
    # This term used to return raw DEGREES squared while every other objective term is a
    # squared RELATIVE error, so 1.5 deg over a ceiling scored 2.25 where a 5% O/F miss
    # scores 0.0025 -- a ~900x unit mismatch. With W_IMPINGING_ANGLE=400 that made a
    # *preference* band outrank the user's primary O/F target 9:1 (900 vs ~102), silently
    # returning O/F ~1.75 against a 1.65 request. Normalised, a 10 deg excursion on a
    # 35 deg band now costs about as much as a 1.8% O/F miss, which is a sane trade.
    band_span = max(hi - lo, 1e-9)
    norm = excess / band_span
    return float(norm * norm)
 
 
def _layer1_lstar_target_from_smd(
    smd_um: float,
    *,
    smd_ref_um: float = 99.0,
    Lstar_ref_m: float = 1.10,
    exponent: float = 2.0,
    Lstar_min_m: float = 0.0,
    Lstar_max_m: float = float("inf"),
) -> float:
    """L* the chamber needs in order to vaporise a spray of this fineness [m].
 
    L* and SMD are not independent knobs -- L* exists to buy residence time, and how much
    residence time you need is set by how long the droplets take to evaporate:
 
        tau_res = L* * c* / (R * Tc)          (chamber volume / volumetric gas flow)
        tau_vap = D32^2 / k_evap              (d^2-law)
 
    Holding the required margin ``tau_res / tau_vap`` fixed and solving for L* gives
 
        L*_required  ∝  D32^2
 
    so the target scales as the SQUARE of SMD. That exponent is the d^2-law, not a fit; only
    the anchor point is empirical, and it is stated as a pair the user can move:
    ``smd_ref_um`` -> ``Lstar_ref_m``.
 
    Anchored at 99 um -> 1.10 m, the implied targets are::
 
        50 um -> 0.28 m     70 um -> 0.55 m     99 um -> 1.10 m
       120 um -> 1.62 m    150 um -> 2.53 m
 
    Clamping to [``Lstar_min_m``, ``Lstar_max_m``] is meaningful information, not a fudge: a
    target pinned at the ceiling means the spray is too coarse to vaporise inside the chamber
    envelope the requirements allow, and the honest fix is a finer spray, not a longer engine.
    """
    try:
        smd = float(smd_um)
    except (TypeError, ValueError):
        return float("nan")
    if not (np.isfinite(smd) and smd > 0 and smd_ref_um > 0 and Lstar_ref_m > 0):
        return float("nan")
    target = float(Lstar_ref_m) * (smd / float(smd_ref_um)) ** float(exponent)
    if not np.isfinite(target):
        return float("nan")
    return float(np.clip(target, Lstar_min_m, Lstar_max_m))
 
 
def _layer1_lstar_band_term(Lstar_m: float, target_m: float, deadband_m: float) -> float:
    """Two-sided cost on L* outside ``target +/- deadband/2``, saturating.
 
    Replaces the one-sided "don't grow past target" shape now that the target is a PHYSICAL
    quantity rather than a preference. Under-shooting is now just as wrong as over-shooting:
    below the band the droplets do not finish evaporating (c* falls), above it you are
    carrying chamber you do not need. Free anywhere inside the band -- a 0.1 m window is
    finer than the correlation's own accuracy, so there is nothing to gain by resolving
    inside it.
 
    Still saturating (e²/(1+e²), bounded in [0,1)) so an unreachable target can never
    outvote a hard gate -- the failure mode that made the original quadratic 91% of the
    objective.
    """
    if not (np.isfinite(Lstar_m) and np.isfinite(target_m)) or target_m <= 0 or Lstar_m <= 0:
        return 0.0
    half = max(0.0, 0.5 * float(deadband_m))
    excess = max(0.0, abs(float(Lstar_m) - float(target_m)) - half)
    if excess <= 0.0:
        return 0.0
    e = excess / float(target_m)
    e2 = e * e
    return float(e2 / (1.0 + e2))
 
 
def _req_lookup(requirements, key):
    """Read one requirement from either a dict or the pydantic DesignRequirementsConfig.
 
    Layer 1 hands this module a plain dict in the worker objective but the model object
    when the value is pulled off config.design_requirements, so a bare .get() silently
    returns the default for half the call sites.
    """
    if requirements is None:
        return None
    getter = getattr(requirements, "get", None)
    if callable(getter):
        try:
            return getter(key)
        except Exception:
            pass
    return getattr(requirements, key, None)
 
 
DEFAULT_CONTRACTION_HALF_ANGLE_DEG = 45.0
 
 
def _layer1_contraction_theta(requirements) -> float:
    """Convergent half-angle [rad], from config.
 
    Was hardcoded np.pi/4 in three places (here, the worker objective, and
    chamber_geometry.theta_default). 45 deg is the LENGTH-optimal angle but not the
    MASS-optimal one: a shallower cone is longer yet moves volume out of the
    full-diameter barrel -- which carries the whole ablative + structural wall stack --
    into the tapering cone shell. Measured on the 8 kN ethalox point, 30 deg is the
    lighter chamber at equal L*. Leaving this pinned hid that trade entirely.
    """
    v = _req_lookup(requirements, "layer1_contraction_half_angle_deg")
    if v is None:
        v = DEFAULT_CONTRACTION_HALF_ANGLE_DEG
    try:
        deg = float(v)
    except (TypeError, ValueError):
        deg = DEFAULT_CONTRACTION_HALF_ANGLE_DEG
    if not np.isfinite(deg):
        deg = DEFAULT_CONTRACTION_HALF_ANGLE_DEG
    return np.radians(float(np.clip(deg, 5.0, 85.0)))
 
 
def _layer1_geometry_infeasibility(requirements, *, L_cylindrical, D_chamber_inner,
                                   A_chamber, n_elements) -> float:
    """Hard geometric constraints, as INFEASIBILITY -- never as weighted penalties.
 
    A weight on a shape preference only moves the fixed point of the scalarised sum; it
    cannot express "this design cannot be built". These two genuinely cannot:
 
    * ``layer1_min_Lcyl_over_D`` -- the CONSTANT-AREA length is where impinging sprays
      actually mix. Only total L_chamber/D was gated, which lets the convergent cone
      masquerade as mixing length. Paired with spray.evaporation.x_star_limit, which
      spray.py already raises on.
    * ``layer1_max_element_pitch_m`` -- element spacing on the injector face. eta_mixing
      (Rupe) sees only momentum ratio, so nothing charged for spreading a fixed element
      count over a bigger face. Without this the optimiser buys chamber diameter free.
 
    Both return 0.0 when unset, so behaviour is unchanged unless configured.
    """
    score = 0.0
    if requirements is None:
        return score
    min_ld = _req_lookup(requirements, "layer1_min_Lcyl_over_D")
    if min_ld is not None and D_chamber_inner > 0 and np.isfinite(L_cylindrical):
        try:
            lo = float(min_ld)
        except (TypeError, ValueError):
            lo = 0.0
        if lo > 0:
            # RELATIVE residual, matching the stability/geometry gates elsewhere in this
            # function. An absolute squared miss does not scale against
            # layer1_infeasibility_gate_eps (default 2e-3): an 8 % shortfall on a 0.55 floor
            # squares to 1.8e-3 and slips under the gate, which is exactly what let Layer 1
            # return L_cyl/D = 0.507 and call it feasible.
            ratio = float(L_cylindrical) / float(D_chamber_inner)
            score += max(0.0, (lo - ratio) / lo) ** 2
 
    max_pitch = _req_lookup(requirements, "layer1_max_element_pitch_m")
    if max_pitch is not None and n_elements and A_chamber > 0:
        try:
            hi = float(max_pitch)
            n = int(n_elements)
        except (TypeError, ValueError):
            hi, n = 0.0, 0
        if hi > 0 and n > 0:
            pitch = float(np.sqrt(A_chamber / n))
            score += max(0.0, pitch / hi - 1.0) ** 2
    return score
 
 
def _layer1_lstar_term(Lstar_m: float, target_m: float) -> float:
    """One-sided SATURATING cost on L* above ``target_m``: e²/(1+e²), e=(L*-target)/target.
 
    Bounded in [0, 1) on purpose. The first version of this was a bare quadratic, and it
    reproduced exactly the pathology it was written to avoid: against a target L* cannot
    physically reach (~1.24 m at this design point), ((L*-0.6)/0.6)² × 4000 came to 4899 of a
    5363 objective -- 91% -- so the optimizer sold the momentum-ratio gate (R fell to 0.90,
    validation FAILED) chasing an L* it was never going to reach. Same shape as the W_SMD=2000
    trap against an unreachable 50 µm target.
 
    Saturating means the WORST an L* miss can ever cost is W_LSTAR, so it can express a
    preference without outvoting a hard gate no matter how the target is set.
 
    A chamber DRY-MASS penalty does not do this job. Wall mass ~ pi*D*L*t but chamber volume
    ~ pi*D^2*L/4, so mass/volume ~ 4t/D -- a FATTER chamber is more mass-efficient per unit
    volume. Charging for mass therefore buys a short wide chamber at the SAME L*, which is
    what was measured (D 0.131 -> 0.144 m, L_eng 0.327 -> 0.290 m, L* unchanged at 1.4986).
 
    L* is the variable that actually has no opposing force anywhere in the objective: more
    residence time is pure reward (vaporisation -> c* -> thrust). One-sided so that anything
    at or below target is free -- this expresses "don't grow the chamber past what you need",
    not "prefer a small chamber".
    """
    if not (np.isfinite(Lstar_m) and np.isfinite(target_m)) or target_m <= 0 or Lstar_m <= 0:
        return 0.0
    e = max(0.0, (float(Lstar_m) - float(target_m)) / float(target_m))
    e2 = e * e
    return float(e2 / (1.0 + e2))
 
 
def _layer1_chamber_mass_kg(
    A_chamber_inner_m2: float,
    L_chamber_m: float,
    total_wall_thickness_m: float,
    wall_density_kg_m3: float,
    Pc_pa: float = 0.0,
    closure_yield_pa: float = 205e6,   # 304 stainless, annealed, minimum yield (ASTM A240)
    plate_support: str = "clamped",
    r_plate_m: float = 0.0,
    poisson: float = 0.3,              # steels, 0.27-0.30; 304 SS ~0.29
) -> float:
    """Cylindrical-shell dry-mass proxy for the chamber barrel [kg].
 
    Why this exists: chamber volume carried no cost. More residence time only helps delivered
    c*, so with nothing opposing it L* either pinned to its maximum or, once the objective hit
    zero, wandered with the seed. This is the counterweight to the Isp term.
 
    Deliberately a barrel-only shell, not a full stack mass: it is a monotone proxy whose whole
    job is to make L* trade against something. ``wall_density_kg_m3`` is an EFFECTIVE density for
    the liner stack (metal + ablative + graphite), configured rather than derived.
    """
    if not (np.isfinite(A_chamber_inner_m2) and np.isfinite(L_chamber_m)):
        return float("nan")
    if A_chamber_inner_m2 <= 0 or L_chamber_m <= 0:
        return float("nan")
    t_side = 0.5 * float(total_wall_thickness_m)
    if t_side <= 0:
        return float("nan")
    d_inner = float(np.sqrt(4.0 * float(A_chamber_inner_m2) / np.pi))
    d_mean = d_inner + t_side          # mid-wall diameter of the shell
    m_barrel = float(np.pi * d_mean * float(L_chamber_m) * t_side * float(wall_density_kg_m3))
 
    # Injector-face closure. A flat plate under Pc thickens as t ~ R*sqrt(k*Pc/sigma), so its
    # mass goes as R^3 -- the only term in this model that opposes chamber DIAMETER. Without it
    # the barrel proxy alone is minimised by a short FAT chamber (mass/volume ~ 4t/D), which is
    # the documented reason a mass penalty was abandoned here. With it the proxy is monotone in
    # both length and diameter and the L*/bore trade is priced. Zero when Pc is not supplied,
    # so existing callers are unchanged.
    m_closure = 0.0
    if np.isfinite(Pc_pa) and Pc_pa > 0 and closure_yield_pa > 0:
        # The plate spans the plug (sleeve bore) when that is known, else the gas bore.
        a = float(r_plate_m) if (np.isfinite(r_plate_m) and r_plate_m > 0) else 0.5 * d_inner
        k = _closure_plate_stress_coeff(plate_support, poisson)
        t_face = a * float(np.sqrt(k * float(Pc_pa) / float(closure_yield_pa)))
        m_closure = float(np.pi * a ** 2 * t_face * float(wall_density_kg_m3))
    return m_barrel + m_closure
 
 
#: Declared ``injector.plate.support`` values -> the edge condition they mean.
_PLATE_SUPPORTS = {"simply_supported": "simply_supported", "clamped": "clamped", "fixed": "clamped"}
 
 
def _closure_plate_stress_coeff(support: str, poisson: float = 0.3) -> float:
    """k in sigma_max = k p a^2 / t^2 for a solid circular plate under uniform pressure p.
 
    Roark's Formulas for Stress and Strain (7th ed.), Table 11.2, uniform load over the plate
    (Timoshenko & Woinowsky-Krieger, Theory of Plates and Shells, 2nd ed., sections 15-16,
    give the same):
 
    * case 10a, edge SIMPLY SUPPORTED: max stress at the centre, k = 3 (3 + nu) / 8
      (1.2375 at nu = 0.3);
    * case 10b, edge FIXED (clamped): max stress at the edge, k = 3 / 4.
 
    A plug retained by a rim/shoulder and a snap ring rotates at its edge, so it is closer to
    simply supported than to clamped -- the clamped figure sizes it ~22 % thin.
    """
    kind = _PLATE_SUPPORTS.get(str(support).strip().lower())
    if kind is None:
        raise ValueError(f"plate support {support!r}: expected one of {sorted(_PLATE_SUPPORTS)}")
    if kind == "clamped":
        return 0.75
    nu = float(poisson)
    return 3.0 * (3.0 + nu) / 8.0
 
 
def _layer1_chamber_mass_term(
    chamber_mass_kg: float,
    mass_ref_kg: float,
) -> float:
    """Normalised, dimensionless mass cost: (m / m_ref)^2. 0 when mass is unavailable."""
    if not np.isfinite(chamber_mass_kg) or chamber_mass_kg <= 0:
        return 0.0
    ref = float(mass_ref_kg)
    if not np.isfinite(ref) or ref <= 0:
        return 0.0
    return float((float(chamber_mass_kg) / ref) ** 2)
 
 
# nozzle_solver.rao's bell_percent: the contour Layer 1 emits is an 80 % Rao bell.
_LAYER1_BELL_FRACTION = 0.8
_G0 = 9.80665
 
 
def _layer1_chamber_od_floor_m(
    max_od_m: float, wall_total_m: float, A_throat_lo_m2: float, dt_ratio_min: float,
) -> float:
    """Smallest chamber OD worth searching [m]: wall + (D/Dt)_min x Dt at the smallest throat.
 
    Any bore below that sits under the chamber-shape band for every reachable throat.
    """
    dt_lo = float(np.sqrt(4.0 * max(float(A_throat_lo_m2), 0.0) / np.pi))
    return float(wall_total_m) + max(float(dt_ratio_min), 1.05) * dt_lo
 
 
def _layer1_chamber_lengths(
    A_throat: float, Lstar: float, D_chamber_inner: float, theta: float,
) -> Dict[str, float]:
    """Axial lengths of the chamber Layer 1 builds [m].
 
    One source for the objective, the config writer and validation, so all three score the
    chamber that is drawn. The cone runs to the tangency of the 1.5 R_t entrance arc,
    r_tan = R_t (1 + 1.5 (1 - cos theta)); the arc then covers 1.5 R_t sin(theta) to the
    throat plane (nozzle_solver.rao)::
 
        length          = L_cyl + L_cone                 (cg.length: mass proxy, L/D band)
        face_to_throat  = length + 1.5 R_t sin(theta)    (injector face to throat plane)
    """
    A_t = float(A_throat)
    V = float(Lstar) * A_t
    D_in = float(D_chamber_inner)
    A_c = np.pi * (D_in / 2.0) ** 2 if D_in > 0 else 0.0
    R_t = float(np.sqrt(max(0.0, A_t / np.pi)))
    cr = A_c / A_t if (A_t > 0 and A_c > 0) else 10.0
    r_tan = R_t * (1.0 + 1.5 * (1.0 - float(np.cos(theta))))
    L_cyl = chamber_length_calc(
        chamber_volume=V, area_throat=A_t, contraction_ratio=cr, theta=theta)
    L_con = contraction_length_horizontal_calc(
        area_chamber=A_c, entrance_arc_start_y=r_tan, theta=theta)
    L = L_cyl + L_con
    if L <= 0 or L_cyl <= 0 or not np.isfinite(L):
        L = V / A_c if A_c > 0 else 0.2
        L_cyl = max(L * 0.5, 0.05)
    L = max(float(L), 0.005)
    L_arc = 1.5 * R_t * float(np.sin(theta))
    return {
        "length": L,
        "length_cylindrical": float(L_cyl),
        "length_contraction": float(L_con),
        "length_entrance_arc": float(L_arc),
        "face_to_throat": float(L + L_arc),
    }
 
 
def _layer1_site_ambient_pa(config_obj: Any) -> float:
    """The site's ambient pressure [Pa]: the engine solver's own (runner._get_ambient_pressure).
 
    ``compute_ambient_pressure_from_elevation`` (the 1976 standard atmosphere) at
    ``environment.elevation``; sea level without one. Layer 1 runs every evaluation at this
    pressure and targets it as the exit pressure. It used to compute its own isothermal
    exponential, which read 94 069.7 Pa at the LE4 site's 626.67 m while the solver -- forward
    mode, the Time-Series tab, Layer X -- evaluates the design at 94 020.4 Pa.
    """
    from engine.core.runner import compute_ambient_pressure_from_elevation
 
    env = getattr(config_obj, "environment", None)
    elevation = getattr(env, "elevation", None) if env is not None else None
    if elevation is None or not np.isfinite(float(elevation)) or float(elevation) < 0:
        return 101325.0
    return float(compute_ambient_pressure_from_elevation(float(elevation)))
 
 
def _layer1_bell_length_m(A_throat: float, eps: float) -> float:
    """Rao 80 % bell length from the throat [m]: 0.8 (sqrt(eps) - 1) R_t / tan 15 deg.
 
    Huzel & Huang ch. 4; the same L_noz nozzle_solver.rao draws.
    """
    R_t = float(np.sqrt(max(0.0, float(A_throat) / np.pi)))
    e = float(eps)
    if not (np.isfinite(e) and e > 1.0 and R_t > 0):
        return 0.0
    return float(_LAYER1_BELL_FRACTION * (np.sqrt(e) - 1.0) * R_t / np.tan(np.radians(15.0)))
 
 
def _layer1_cea_ok(cea_cache: Any) -> bool:
    try:
        from engine.pipeline.cea_cache import CEACache
    except Exception:  # pragma: no cover
        return False
    return isinstance(cea_cache, CEACache)
 
 
def _layer1_ideal_isp_s(cea_cache: Any, MR: float, Pc_pa: float, Pa: float, eps: float) -> float:
    """Ideal ambient Isp from the CEA table [s]: c* (Cf_vac - eps Pa/Pc) / g0.
 
    Shifting equilibrium, the same table the thrust model integrates. NaN when unavailable.
    """
    if not _layer1_cea_ok(cea_cache):
        return float("nan")
    try:
        MR, Pc_pa, Pa, eps = float(MR), float(Pc_pa), float(Pa), float(eps)
        if not (MR > 0 and Pc_pa > 0 and Pa >= 0 and eps > 1.0):
            return float("nan")
        out = cea_cache.eval(MR, Pc_pa, Pa, eps)
        cf = float(out["Cf_vac"]) - eps * Pa / Pc_pa
        isp = float(out["cstar_ideal"]) * cf / _G0
    except Exception:
        return float("nan")
    return isp if np.isfinite(isp) and isp > 0 else float("nan")
 
 
def _layer1_isp_merit_s(result: Any, constants: dict, cea_cache: Any = None) -> float:
    """Delivered Isp with the requirement-pinned operating point held at its requirement [s].
 
    O/F, and Pc when a target is set, are specifications with their own deadbands; the figure
    of merit must not buy Isp by moving them. Ideal Isp is re-evaluated with O/F clamped to its
    deadband and Pc to its aim band, and the delivered efficiency is kept::
 
        Isp_merit = Isp * Isp_ideal(Pc', O/F') / Isp_ideal(Pc, O/F)
 
    Inside both bands this is the delivered Isp exactly. Without a CEA table it is the
    delivered Isp.
    """
    if not isinstance(result, dict):
        return float("nan")
    try:
        isp = float(result.get("Isp", np.nan))
        mr = float(result.get("MR", np.nan))
        pc = float(result.get("Pc", np.nan))
    except (TypeError, ValueError):
        return float("nan")
    if not (np.isfinite(isp) and isp > 0):
        return float("nan")
    of_t = float(constants.get("optimal_of", 0.0) or 0.0)
    tol = max(0.0, float(constants.get("layer1_of_deadband_rel", 0.0) or 0.0))
    mr_h = float(np.clip(mr, of_t * (1.0 - tol), of_t * (1.0 + tol))) if of_t > 0 else mr
    pc_t = constants.get("layer1_target_Pc_pa")
    pc_h = (float(np.clip(pc, (1.0 - _LAYER1_PC_AIM_REL) * float(pc_t),
                          (1.0 + _LAYER1_PC_AIM_REL) * float(pc_t)))
            if pc_t and float(pc_t) > 0 else pc)
    if (mr_h == mr and pc_h == pc) or not (np.isfinite(mr) and np.isfinite(pc)):
        return isp
    try:
        eps = float(result.get("eps", np.nan))
    except (TypeError, ValueError):
        eps = float("nan")
    Pa = float(constants.get("P_ambient", 101325.0))
    num = _layer1_ideal_isp_s(cea_cache, mr_h, pc_h, Pa, eps)
    den = _layer1_ideal_isp_s(cea_cache, mr, pc, Pa, eps)
    if not (np.isfinite(num) and np.isfinite(den) and den > 0):
        return isp
    return float(isp * num / den)
 
 
def _layer1_isp_term(isp_merit_s: float, isp_ref_s: float) -> float:
    """Propellant this engine needs beyond an ideal one, as a fraction: Isp_ref/Isp - 1.
 
    At fixed total impulse I = F t_b the propellant is I/(g0 Isp) (Sutton & Biblarz ch. 2), so
    this equals (m_prop - m_prop_ideal)/m_prop_ideal: linear in the propellant the delivered Isp
    costs, the same currency as the chamber-mass term. 0 when either Isp is unavailable.
    """
    try:
        a, r = float(isp_merit_s), float(isp_ref_s)
    except (TypeError, ValueError):
        return 0.0
    if not (np.isfinite(a) and np.isfinite(r) and a > 0 and r > 0):
        return 0.0
    return float(r / a - 1.0)
 
 
def _layer1_isp_reference(
    cea_cache: Any, MR: float, Pc_pa: float, Pa: float, eps_lo: float, eps_hi: float,
) -> Tuple[float, float]:
    """(Isp_ref [s], eps_ref): ideal ambient Isp at the requirement point, expanded to Pe = Pa.
 
    The normaliser of the performance term -- an ideal engine at the target O/F and reference
    Pc, with the expansion ratio where the table's own exit pressure is ambient (the maximum of
    Cf_vac - eps Pa/Pc), clamped to the searchable eps range.
    """
    if not _layer1_cea_ok(cea_cache) or not (eps_hi > eps_lo > 1.0):
        return float("nan"), float("nan")
    e = _layer1_eps_for_exit_pressure_cea(cea_cache, MR, Pc_pa, Pa, 0.5 * (eps_lo + eps_hi))
    e = float(np.clip(e if e is not None else eps_lo, eps_lo, eps_hi))
    isp = _layer1_ideal_isp_s(cea_cache, MR, Pc_pa, Pa, e)
    return (isp, e) if np.isfinite(isp) else (float("nan"), float("nan"))
 
 
def _layer1_merit_weights(
    requirements: dict, cea_cache: Any, optimal_of: float, Pc_ref_pa: float, Pa: float,
    eps_range: Tuple[float, float], target_thrust: float, burn_time_s: float,
    W_MASS_config: float, mass_ref_kg: float,
) -> Dict[str, float]:
    """Weights of the figure of merit: {W_ISP, W_MASS, Isp_ref_s, eps_ref, m_prop_ref_kg}.
 
    ``layer1_W_ISP`` defaults to 1000, so the isp penalty reads in tenths of a percent of an
    ideal engine's propellant. An unset ``layer1_W_MASS`` prices chamber mass at the same rate
    per kg as that propellant, (W_ISP / m_prop_ref) = 2 W_MASS / m_ref at the reference mass --
    the fixed-total-impulse exchange. No CEA table: both terms keep their configured values
    and the Isp term is off.
    """
    W_ISP = _requirement_float(requirements, "layer1_W_ISP", 1000.0)
    isp_ref, eps_ref = _layer1_isp_reference(
        cea_cache, optimal_of, Pc_ref_pa, Pa, float(eps_range[0]), float(eps_range[1]))
    m_ref = (float(target_thrust) * float(burn_time_s) / (_G0 * isp_ref)
             if (burn_time_s > 0 and np.isfinite(isp_ref)) else float("nan"))
    if not np.isfinite(isp_ref):
        W_ISP = 0.0
    W_MASS = float(W_MASS_config)
    if (requirements.get("layer1_W_MASS") is None and W_ISP > 0
            and np.isfinite(m_ref) and m_ref > 0 and mass_ref_kg > 0):
        W_MASS = W_ISP * float(mass_ref_kg) / (2.0 * m_ref)
    return {"W_ISP": float(W_ISP), "W_MASS": float(W_MASS), "Isp_ref_s": float(isp_ref),
            "eps_ref": float(eps_ref), "m_prop_ref_kg": float(m_ref)}
 
 
def _layer1_eps_for_exit_pressure_cea(
    cea_cache: Any, MR: float, Pc_pa: float, Pa: float, eps_guess: Optional[float] = None,
) -> Optional[float]:
    """Expansion ratio at which the CEA table's own exit pressure equals ``Pa``.
 
    For an isentropic (shifting) expansion dCf_vac/deps = Pe/Pc, so the secant slope of the
    table's Cf_vac between eps nodes is Pe/Pc at the interval midpoint. Interpolating
    ln(Pe/Pc) in ln(eps) between midpoints and solving Pe = Pa inverts the table the thrust
    model integrates -- not an isentrope at the chamber gamma. None when the table cannot say
    (2-D table, or Pa outside its eps range).
    """
    if not _layer1_cea_ok(cea_cache) or not getattr(cea_cache, "use_3d", False):
        return None
    grid = getattr(cea_cache, "eps_grid", None)
    try:
        MR, Pc_pa, Pa = float(MR), float(Pc_pa), float(Pa)
    except (TypeError, ValueError):
        return None
    if grid is None or len(grid) < 3 or not (MR > 0 and Pc_pa > Pa > 0):
        return None
    grid = np.asarray(grid, dtype=float)
    target = np.log(Pa / Pc_pa)
    # Local window around the guess: six nodes are enough and keep the call cheap.
    k0 = int(np.searchsorted(grid, float(eps_guess))) if (
        eps_guess is not None and np.isfinite(eps_guess)) else len(grid) // 2
    lo_i, hi_i = max(0, k0 - 3), min(len(grid), k0 + 3)
    for _ in range(len(grid)):
        nodes = grid[lo_i:hi_i]
        try:
            cf = np.array([cea_cache.eval_cf_vac(MR, Pc_pa, e) for e in nodes], dtype=float)
        except Exception:
            return None
        slope = np.diff(cf) / np.diff(nodes)           # Pe/Pc at the midpoints
        if not np.all(np.isfinite(slope)) or np.any(slope <= 0):
            return None
        mids = np.sqrt(nodes[:-1] * nodes[1:])
        y = np.log(slope)                               # decreasing in eps
        inside = y[0] >= target >= y[-1]
        # Past the outer midpoints but inside the table: extend the end segment to the node.
        edge = (target > y[0] and lo_i == 0) or (target < y[-1] and hi_i == len(grid))
        if inside or edge:
            j = int(np.searchsorted(-y, -target))
            j = min(max(j, 1), len(y) - 1)
            t = (target - y[j - 1]) / (y[j] - y[j - 1])
            e = float(np.exp(np.log(mids[j - 1]) + t * (np.log(mids[j]) - np.log(mids[j - 1]))))
            return e if grid[0] <= e <= grid[-1] else None
        if target > y[0]:
            lo_i = max(0, lo_i - 3)
        else:
            hi_i = min(len(grid), hi_i + 3)
    return None
 
 
def _layer1_exit_pressure_sq_term(
    P_exit_actual: float,
    target_P_exit: float,
    *,
    deadband_rel: float = 0.05,
    inside_rel_quad_scale: float = 0.0,
) -> float:
    """Exit nozzle vs ambient-equivalent ``target``: asymmetric hinge beyond deadband, optional quad inside.
 
    Outside ``deadband_rel`` uses the asymmetric hinge used elsewhere; inside the deadband optionally
    adds ``inside_rel_quad_scale * rel**2`` to gently center on target (preference, not a hard gate).
    """
    if target_P_exit <= 0.0 or not np.isfinite(P_exit_actual):
        return 0.0
    rel = (float(P_exit_actual) - float(target_P_exit)) / float(target_P_exit)
    if not np.isfinite(rel):
        return 0.0
    deadband_rel = float(max(deadband_rel, 1e-9))
    if rel < -deadband_rel:
        excess = rel + deadband_rel
        return float((5.0 * excess) ** 2)
    if rel > deadband_rel:
        excess = rel - deadband_rel
        return float((1.0 * excess) ** 2)
    return float(max(0.0, inside_rel_quad_scale)) * float(rel ** 2)
 
 
def _layer1_primary_relative_metrics(
    final_performance: Dict[str, Any],
    *,
    target_thrust: float,
    optimal_of: float,
    target_P_exit: float,
) -> Dict[str, float]:
    """Dimensionless thrust / O-F / exit-pressure mismatches (not weighted optimizer penalties).
 
    The Layer 1 scalar objective multiplies these kinds of errors by ``W_THRUST``, ``W_OF``, ``W_EXIT``
    (order 1e2–1e4); the weighted sum will never approach machine epsilon. Use these metrics (especially
    ``rms_primary``) to judge whether the **physics** matches are tight.
    """
    try:
        F = float(final_performance.get("F", float("nan")))
    except (TypeError, ValueError):
        F = float("nan")
    try:
        MR = float(final_performance.get("MR", float("nan")))
    except (TypeError, ValueError):
        MR = float("nan")
    try:
        p_ex = float(final_performance.get("P_exit", float("nan")))
    except (TypeError, ValueError):
        p_ex = float("nan")
    rel_thrust = (
        abs(F - float(target_thrust)) / float(target_thrust)
        if float(target_thrust) > 0 and np.isfinite(F)
        else float("nan")
    )
    rel_of = (
        abs(MR - float(optimal_of)) / float(optimal_of)
        if float(optimal_of) > 0 and np.isfinite(MR)
        else float("nan")
    )
    rel_p_exit = (
        abs(p_ex - float(target_P_exit)) / float(target_P_exit)
        if float(target_P_exit) > 0 and np.isfinite(p_ex)
        else float("nan")
    )
    parts = [x for x in (rel_thrust, rel_of, rel_p_exit) if np.isfinite(x)]
    rms_primary = float(np.sqrt(np.mean(np.square(parts)))) if parts else float("nan")
    return {
        "rel_thrust": float(rel_thrust),
        "rel_of": float(rel_of),
        "rel_P_exit": float(rel_p_exit),
        "rms_primary": float(rms_primary),
    }
 
 
def _impinging_jet_pair_asymmetry_squared(
    theta_o_deg: Any,
    theta_f_deg: Any,
    *,
    max_delta_deg: float,
) -> float:
    """Soft penalty when paired oxidizer/fuel jet inclinations diverge excessively.
 
    ``max_delta_deg`` is an allowable |Δθ| band for nominally coherent doublet impingement; excess
    is normalized by ``max(max_delta_deg, 5 degrees)`` so the term is order one before weights.
    """
    if max_delta_deg <= 0.0 or not np.isfinite(max_delta_deg):
        return 0.0
    try:
        t_o = float(theta_o_deg)
        t_f = float(theta_f_deg)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(t_o) or not np.isfinite(t_f):
        return 0.0
    dd = abs(t_o - t_f)
    cap = float(max_delta_deg)
    if dd <= cap:
        return 0.0
    excess = dd - cap
    span = float(max(cap, 5.0))
    return float((excess / span) ** 2)
 
 
def _relative_hinge_band_squared(v: Any, lo: Optional[float], hi: Optional[float]) -> float:
    """Normalized hinge² outside [lo, hi]."""
    try:
        vv = float(v)
    except (TypeError, ValueError):
        return 0.0
    if not np.isfinite(vv):
        return 0.0
    if (
        lo is None
        or hi is None
        or not np.isfinite(float(lo))
        or not np.isfinite(float(hi))
        or float(hi) <= float(lo)
    ):
        return 0.0
    lo_f = float(lo)
    hi_f = float(hi)
    if lo_f <= vv <= hi_f:
        return 0.0
    if vv < lo_f:
        s = max(1e-12, abs(lo_f))
        return float(((lo_f - vv) / s) ** 2)
    s = max(1e-12, abs(hi_f))
    return float(((vv - hi_f) / s) ** 2)
 
 
def _layer1_discharge_cd_inf_ratio_from_config(config_obj: Any, injector_type: str) -> float:
    """Cd_inf,O / Cd_inf,F at seed jet/orifice diameters (≈1 for matched impinging holes)."""
    if injector_type != "impinging":
        return 1.0
    try:
        geom = config_obj.injector.geometry
        d_o = float(geom.oxidizer.d_jet)
        d_f = float(geom.fuel.d_jet)
        return discharge_cd_inf_ratio(
            d_o,
            d_f,
            config_obj.discharge["oxidizer"],
            config_obj.discharge["fuel"],
        )
    except (AttributeError, TypeError, ValueError, KeyError):
        return 1.0
 
 
def _expected_geom_ao_af_for_unit_momentum_ratio(optimal_of: float, rho_o: float, rho_f: float) -> float:
    """Geometric A_O/A_F consistent with MR ≈ optimal_of when R ≈ 1 (bulk u, fixed ρ)."""
    if optimal_of <= 0 or rho_f <= 0 or rho_o <= 0:
        return float("nan")
    return float(optimal_of) / float(np.sqrt(float(rho_o) / float(rho_f)))
 
 
def _rescale_impinging_jet_diameters_for_mr_target(
    d_jet_O: float,
    d_jet_F: float,
    *,
    n_elements_O: int,
    n_elements_F: int,
    optimal_of: float,
    rho_o: float,
    rho_f: float,
    min_d: float = 1e-5,
    rel_tol: float = 0.02,
) -> Tuple[float, float]:
    """Rescale jet diameters so A_O/A_F matches MR at R≈1 while preserving A_O·A_F.
 
    YAML / UI seed orifices are not O/F-tuned; Layer 1 applies this before x0 so CMA/L-BFGS
    still optimize ``d_jet_O`` and ``d_jet_F`` from a physics-aligned starting point.
    """
    if optimal_of <= 0 or d_jet_O <= 0 or d_jet_F <= 0:
        return float(d_jet_O), float(d_jet_F)
    n_o = max(1, int(n_elements_O))
    n_f = max(1, int(n_elements_F))
    exp_af = _expected_geom_ao_af_for_unit_momentum_ratio(optimal_of, rho_o, rho_f)
    if not (np.isfinite(exp_af) and exp_af > 0):
        return float(d_jet_O), float(d_jet_F)
    a_o = float(n_o * np.pi * (float(d_jet_O) / 2.0) ** 2)
    a_f = float(n_f * np.pi * (float(d_jet_F) / 2.0) ** 2)
    if a_f <= 0:
        return float(d_jet_O), float(d_jet_F)
    actual_af = a_o / a_f
    if actual_af <= 0:
        return float(d_jet_O), float(d_jet_F)
    ratio_scale = float(exp_af / actual_af)
    if abs(ratio_scale - 1.0) < float(rel_tol):
        return float(d_jet_O), float(d_jet_F)
    a_o_new = a_o * np.sqrt(ratio_scale)
    a_f_new = a_f / np.sqrt(ratio_scale)
    d_o_new = float(np.sqrt(4.0 * a_o_new / (n_o * np.pi)))
    d_f_new = float(np.sqrt(4.0 * a_f_new / (n_f * np.pi)))
    return max(min_d, d_o_new), max(min_d, d_f_new)
 
 
def _write_impinging_jet_diameters_to_config(config_obj: Any, d_jet_O: float, d_jet_F: float) -> None:
    try:
        geom = config_obj.injector.geometry
        geom.oxidizer.d_jet = float(d_jet_O)
        geom.fuel.d_jet = float(d_jet_F)
    except (AttributeError, TypeError, ValueError):
        pass
 
 
def _layer1_rescale_impinging_seed_jets_for_mr(
    config_obj: Any,
    *,
    d_jet_O: float,
    d_jet_F: float,
    n_doublets: int,
    optimal_of: float,
    bounds: Sequence[Tuple[float, float]],
    logger: logging.Logger,
    also_config: Optional[Any] = None,
) -> Tuple[float, float]:
    """Align impinging x0 jet diameters with ``optimal_of_ratio`` and clip to Layer-1 bounds."""
    try:
        rho_o = float(config_obj.fluids["oxidizer"].density)
        rho_f = float(config_obj.fluids["fuel"].density)
    except (TypeError, ValueError, KeyError, AttributeError):
        return float(d_jet_O), float(d_jet_F)
    d_o_old, d_f_old = float(d_jet_O), float(d_jet_F)
    d_o_new, d_f_new = _rescale_impinging_jet_diameters_for_mr_target(
        d_o_old,
        d_f_old,
        n_elements_O=int(n_doublets),
        n_elements_F=int(n_doublets),
        optimal_of=float(optimal_of),
        rho_o=rho_o,
        rho_f=rho_f,
    )
    d_o_new = float(np.clip(d_o_new, bounds[5][0], bounds[5][1]))
    d_f_new = float(np.clip(d_f_new, bounds[8][0], bounds[8][1]))
    if abs(d_o_new - d_o_old) > 1e-9 or abs(d_f_new - d_f_old) > 1e-9:
        _write_impinging_jet_diameters_to_config(config_obj, d_o_new, d_f_new)
        if also_config is not None:
            _write_impinging_jet_diameters_to_config(also_config, d_o_new, d_f_new)
        exp_af = _expected_geom_ao_af_for_unit_momentum_ratio(optimal_of, rho_o, rho_f)
        logger.info(
            "Auto-scaled impinging seed jets for MR=%.2f (ρ_O/ρ_F from config): "
            "d_jet_O %.4f→%.4f mm, d_jet_F %.4f→%.4f mm (target A_O/A_F≈%.3f for R≈1; "
            "d_jet_O/F remain optimizer DOFs)",
            float(optimal_of),
            d_o_old * 1e3,
            d_o_new * 1e3,
            d_f_old * 1e3,
            d_f_new * 1e3,
            float(exp_af) if np.isfinite(exp_af) else float("nan"),
        )
    return d_o_new, d_f_new
 
 
def _geom_ao_af_momentum_hint_squared(
    A_geom_o: float,
    A_geom_f: float,
    optimal_of: float,
    rho_o: float,
    rho_f: float,
) -> Tuple[float, float, float]:
    """Returns (relative_error_squared, A_O/A_F, expected_A_O/A_F for R≈1)."""
    exp_af = _expected_geom_ao_af_for_unit_momentum_ratio(optimal_of, rho_o, rho_f)
    if not (np.isfinite(exp_af) and exp_af > 0 and A_geom_f > 0):
        return 0.0, float("nan"), exp_af
    ao_af = float(A_geom_o) / float(A_geom_f)
    rel = (ao_af - exp_af) / exp_af
    return float(rel * rel), ao_af, exp_af
 
 
def _effective_smd_um(diagnostics: Any, mr_mass: Any = None) -> float:
    """Mass-flux-weighted effective spray SMD [um] from injector diagnostics.
 
    The blend the SMD penalty has always used, hoisted out so the L*-target correlation can
    read the SAME number rather than recomputing it from a second correlation (which is what
    previously let the two disagree about how fine the spray was).
    """
    if not isinstance(diagnostics, dict):
        return float("nan")
 
    def _f(key):
        try:
            return float(diagnostics.get(key, np.nan))
        except (TypeError, ValueError):
            return float("nan")
 
    d32_o, d32_f = _f("D32_O"), _f("D32_F")
    mr = float(mr_mass) if (mr_mass is not None and np.isfinite(float(mr_mass))
                            and float(mr_mass) > 0) else _f("MR")
    if not (np.isfinite(mr) and mr > 0):
        mr = 3.0
    if np.isfinite(d32_o) and d32_o > 0 and np.isfinite(d32_f) and d32_f > 0:
        d32 = mr / (1.0 + mr) * d32_o + 1.0 / (1.0 + mr) * d32_f
    elif np.isfinite(d32_o) and d32_o > 0:
        d32 = d32_o
    elif np.isfinite(d32_f) and d32_f > 0:
        d32 = d32_f
    else:
        return float("nan")
    val = float(d32 * 1e6)
    return val if np.isfinite(val) and val > 0 else float("nan")
 
 
def _layer1_resolve_lstar_target(
    smd_um: float,
    constants_or_req: Any,
    getter,
    fallback_target_m: float,
) -> Tuple[float, float]:
    """(target_m, deadband_m) for the L* penalty.
 
    When ``layer1_Lstar_from_smd`` is on (default) the target is the physical one from
    :func:`_layer1_lstar_target_from_smd`; a fixed ``layer1_Lstar_target_m`` is the opt-out.
    Falls back to the fixed target whenever SMD is unavailable, so a diagnostics gap cannot
    silently switch the penalty off.
    """
    # NOTE: model_dump() emits an explicit None for every unset Optional field, so a bare
    # ``.get(key, default)`` returns None rather than the default. Treat None as unset --
    # this is the same trap _requirement_float exists to avoid.
    def _num(key, default):
        v = getter(key)
        try:
            return float(default if v is None else v)
        except (TypeError, ValueError):
            return float(default)
 
    def _flag(key, default):
        v = getter(key)
        return bool(default) if v is None else bool(v)
 
    deadband = _num("layer1_Lstar_deadband_m", 0.1)
    if not _flag("layer1_Lstar_from_smd", True):
        return float(fallback_target_m), deadband
    if not (np.isfinite(smd_um) and smd_um > 0):
        return float(fallback_target_m), deadband
    tgt = _layer1_lstar_target_from_smd(
        smd_um,
        smd_ref_um=_num("layer1_Lstar_smd_ref_um", 99.0),
        Lstar_ref_m=_num("layer1_Lstar_ref_m", 1.10),
        exponent=_num("layer1_Lstar_smd_exponent", 2.0),
        Lstar_min_m=_num("min_Lstar", 0.0),
        Lstar_max_m=_num("max_Lstar", 1.0e9),
    )
    if not np.isfinite(tgt) or tgt <= 0:
        return float(fallback_target_m), deadband
    return float(tgt), deadband
 
 
def _impinging_smd_penalty_with_angle(
    diagnostics: Dict[str, Any],
    *,
    target_smd_microns: float,
    smd_rel_tol: float = 0.20,
    mr_mass: Optional[float] = None,
) -> Tuple[float, float, float]:
    """Return (range_penalty, effective_smd_um, impingement_angle_deg).
 
    Single source of truth: the effective spray SMD is the mass-flux-weighted blend of the
    injector-physics Sauter means ``D32_O`` / ``D32_F`` (metres) reported by the impinging solve.
    Those values come from the Ingebo correlation, which already embeds the aerodynamic Weber number
    (gas-shear breakup), the liquid Reynolds number (viscous resistance — important for cryogens),
    and the impingement angle (through the law-of-cosines collision velocity ``u_rel``). We do NOT
    recompute SMD from a separate parametric correlation here — that previously gave the optimizer a
    different answer than the reported physics.
 
    Penalty is a **two-sided** deadband: zero inside ``[target·(1−tol), target·(1+tol)]`` and the
    squared, target-normalized distance to the nearest edge outside it (so both too-coarse and
    too-fine atomization are penalized — "SMD within a range").
    """
    def _f(key: str) -> float:
        try:
            return float(diagnostics.get(key, np.nan))
        except (TypeError, ValueError):
            return float("nan")
 
    d32_o = _f("D32_O")
    d32_f = _f("D32_F")
    imp_deg = _f("impingement_angle_deg")
 
    mr = float(mr_mass) if (mr_mass is not None and np.isfinite(float(mr_mass)) and float(mr_mass) > 0) else _f("MR")
    if not (np.isfinite(mr) and mr > 0):
        mr = 3.0
 
    if np.isfinite(d32_o) and d32_o > 0 and np.isfinite(d32_f) and d32_f > 0:
        d32_eff_m = float(mr / (1.0 + mr) * d32_o + 1.0 / (1.0 + mr) * d32_f)
    elif np.isfinite(d32_o) and d32_o > 0:
        d32_eff_m = float(d32_o)
    elif np.isfinite(d32_f) and d32_f > 0:
        d32_eff_m = float(d32_f)
    else:
        return 0.0, float("nan"), imp_deg
 
    d32_eff_um = float(d32_eff_m * 1e6)
    if not np.isfinite(d32_eff_um) or d32_eff_um <= 0.0 or target_smd_microns <= 0.0:
        return 0.0, d32_eff_um, imp_deg
 
    tol = max(0.0, float(smd_rel_tol))
    lo = float(target_smd_microns * (1.0 - tol))
    hi = float(target_smd_microns * (1.0 + tol))
    scale = max(float(target_smd_microns), 1e-9)
    if d32_eff_um < lo:
        smd_term = float(((lo - d32_eff_um) / scale) ** 2)
    elif d32_eff_um > hi:
        smd_term = float(((d32_eff_um - hi) / scale) ** 2)
    else:
        smd_term = 0.0
    return smd_term, d32_eff_um, imp_deg
 
 
def _tank_pressure_equal_squared(
    P_O_tank_psi: float,
    P_F_tank_psi: float,
    scale_psi: float = 100.0,
    tol_psi: float = 0.0,
    inband_frac: float = 0.0,
) -> float:
    """Squared, scale-normalized penalty on unequal propellant tank pressures.
 
    Equal tank pressures do NOT fall out of momentum matching: the two propellants have different
    densities, different feed-system losses, and (because the orifices are sized/angled differently)
    different injector ΔP. So driving the tanks toward a common pressure is its own objective, and the
    optimizer pays for it by reshaping orifice area / velocity / angle while still holding R≈1 and SMD.
    """
    # ``tol_psi`` is a DEADBAND: a delta the instrumentation cannot even resolve is not an
    # error and must cost nothing. Without it, matching the tanks to 1.93 psi -- comfortably
    # inside a 10 psi PT margin, i.e. a success -- still carried 11 objective points, which
    # reads as "did not converge" when in fact the requirement was met with margin.
    po = float(P_O_tank_psi)
    pf = float(P_F_tank_psi)
    if not (np.isfinite(po) and np.isfinite(pf)):
        return 0.0
    s = float(scale_psi) if (np.isfinite(scale_psi) and scale_psi > 0) else 100.0
    t = float(tol_psi) if (np.isfinite(tol_psi) and tol_psi > 0) else 0.0
    delta = abs(po - pf)
    excess = max(0.0, delta - t)
 
    # A pure deadband is flat inside the band, so nothing distinguishes "1 psi apart"
    # from "9.9 psi apart" and the optimizer parks on the edge -- which is how a 10 psi
    # requirement lands at 10.1 psi. ``inband_frac`` adds a weak always-on pull toward
    # equality: strong enough to break the tie inside the band, far too small (5% by
    # default) to outrank the real constraint outside it.
    # Normalize the in-band part by the TOLERANCE, not by ``scale``, so it saturates at
    # ``inband_frac`` exactly at the band edge and cannot grow with the scale choice. With the
    # old ``/s`` form and scale=10, tol=10, W=300, a delta sitting at the edge of the band
    # cost 15 objective points and a physically-required 13 psi cost 42 -- a permanent tax
    # that no design could pay off, on top of a requirement that may not be reachable at all.
    # This is a tie-breaker to stop the optimizer parking on the band edge, nothing more.
    f = float(inband_frac) if (np.isfinite(inband_frac) and inband_frac > 0) else 0.0
    inband = f * (min(delta, t) / t) ** 2 if (f > 0.0 and t > 0.0) else 0.0
    return float((excess / s) ** 2 + inband)
 
 
def _face_halves(*, r_in: float, d_in: float, th_in: float, r_out: float, d_out: float,
                 th_out: float, face_contoured: bool, exit_land: float) -> Tuple[float, float]:
    """How far the ring pair reaches in from the inner pitch circle and out from the outer one on
    the face datum: the elliptical exit traces on a flat face, the groove edges on a contoured one
    (engine.core.injectors.layout.ring_face_reach -- the drawing's own rule)."""
    reach_in, reach_out = ring_face_reach(
        contoured=bool(face_contoured), r_in=r_in, d_in=float(d_in), th_in=float(th_in),
        r_out=r_out, d_out=float(d_out), th_out=float(th_out), exit_land=float(exit_land))
    return r_in - reach_in, reach_out - r_out
 
 
def _impinging_ring_geometry_squared(
    *,
    n_elements: float,
    spacing_O_m: float,
    spacing_F_m: float,
    d_jet_O_m: float,
    d_jet_F_m: float,
    D_chamber_inner_m: float,
    angle_O_deg: float = float("nan"),
    angle_F_deg: float = float("nan"),
    Ld_min: float = 0.0,
    Ld_max: float = 0.0,
    ring_order_fuel_outboard: bool = True,
    center_clear_dia_m: float = 0.0,
    min_web_m: float = 0.0,
    wall_clearance_m: float = 0.0,
    spray_radius_frac: float = 0.0,
    spray_radius_tol: float = 0.08,
    face_contoured: bool = False,
    exit_land: float = EXIT_LAND_DEFAULT,
) -> float:
    """Doublet ring geometry, computed straight from the DESIGN VARIABLES.
 
    HOW AN UNLIKE DOUBLET ACTUALLY WORKS. The oxidizer and fuel orifices sit on two DIFFERENT
    pitch circles and are canted toward each other; the jets close the radial gap between the
    rings and collide partway between them:
 
        radial offset   dr    = |D_pitch_O - D_pitch_F| / 2
        impingement dist L_imp = dr / (tan(theta_O) + tan(theta_F))
 
    So the rings MUST be separated -- that separation is the whole mechanism. An earlier version
    of this function penalised |D_pitch_O - D_pitch_F| toward zero, i.e. drove both streams onto
    the SAME circle, which gives dr = 0 and L_imp = 0: the jets "impinge" at the face plate.
    That is a face-eroding non-injector, and it was wrong.
 
    The real constraint is on the impingement DISTANCE, not on the ring separation itself.
    Published practice for unlike impinging elements puts L_imp at roughly 3-7 orifice diameters
    (5-7 as SP-8089 is usually quoted), with ~60 deg included angle. The band itself comes
    from ``engine.core.injectors.layout.impingement_ld_band``; the defaults here (0, 0) leave
    the standoff term off for a caller that passes no band. Too short and the jets collide on
    the face; too long and the free jets wander before they meet, so the pair stops mixing.
 
    This exists because ``_impinging_geometry_fit_squared`` reads its inputs out of the physics
    ``diagnostics`` dict, and the numba accelerator -- which is what the Layer-1 inner loop runs
    on -- emits none of the keys it needs (``D_pitch_O``, ``element_gap_O``,
    ``vaporization_length_total``, ``L_imp``, ``s_pair``: zero occurrences in engine/accel/).
    They come back None, every lookup fails, and the whole W_IMP_GEOM constraint has been
    returning 0.0 for every candidate since the C->numba port. The A/B parity suite compares
    physics outputs (thrust, Pc, MR), not diagnostic keys, so it passed while a constraint was
    silently switched off.
 
    Consequences seen live: a seed whose fuel ring was 119.4 mm across a 114.8 mm bore (orifices
    outside the chamber wall), and converged designs with the oxidizer and fuel rings 20-51 mm
    apart radially -- i.e. "doublets" whose two jets are on different circles and cannot meet.
 
    Pitch circle, orifice pitch and overlap are pure geometry -- n, spacing and d_jet are design
    variables -- so deriving them here makes the constraint independent of which physics path ran.
    Terms (all relative, one-sided, zero when comfortable):
      * ring fit        -- each D_pitch = n*spacing/pi must stay inside the bore
      * no overlap      -- adjacent orifices must not collide (spacing >= d_jet + min web)
      * standoff        -- L_imp/d_avg inside [Ld_min, Ld_max]
      * ring order      -- fuel outboard, so wall spillover is fuel-rich
      * centre clear    -- keep a circle free at the axis (igniter boss / centre port)
      * wall clearance  -- keep a land between the outer ring and the bore
      * spray radius    -- put the impingement circle where the propellant is wanted
 
    WHERE THE RING PAIR SITS was an exactly flat direction until the last three terms existed.
    ``_layer1_derive_fuel_spacing`` solves s_F so the standoff hits its target, and it does that
    by fixing the GAP ``|s_F - s_O|``; dr is therefore independent of s_O, the pair slides
    radially at zero cost, and s_O fell onto its own lower bound (0.003 m). The result on
    ethalox_8kN_FINAL: D_pitch_O = 26.90 mm, all 28 doublets impinging on a 41.79 mm circle
    inside a 127.00 mm bore -- 10.8 % of the chamber area, narrower than the 49.57 mm throat,
    a 1.44 mm LOX web, and no room at the axis for the 3/8 NPT igniter.
 
    WHERE THE PROPELLANT LANDS. Every doublet on one ring collides on the SAME circle,
    ``r_imp = r_inner + L_imp*tan(theta_inner)``, and nothing used to constrain it. Bounding the
    pair only from BELOW (the centre-clear term) is not enough -- the direction is still flat
    above that bound, and the search parks on it: measured r_imp/r_wall = 0.33 before any of
    these terms, then 0.44 once only the lower bound existed. The target is the EQUAL-AREA
    radius, ``r_wall/sqrt(2)``, which splits the chamber cross-section in half.
 
    RADIAL EXTENT IS ELLIPTICAL. A hole of diameter d inclined ``theta`` from the chamber axis
    cuts the (axis-normal) face as an ellipse: minor axis d circumferentially, MAJOR axis
    ``d/cos(theta)`` radially. At theta = 69 deg that is 2.79x the drill diameter, so the
    centre- and wall-clearance terms use the ellipse while the web term -- a circumferential
    distance -- correctly uses d.
    """
    bore = float(D_chamber_inner_m)
    n = float(n_elements)
    if not (np.isfinite(bore) and bore > 0 and np.isfinite(n) and n > 0):
        return 0.0
    term = 0.0
    dp = {}
    for tag, sp, dj in (("O", spacing_O_m, d_jet_O_m), ("F", spacing_F_m, d_jet_F_m)):
        s = float(sp)
        if not (np.isfinite(s) and s > 0):
            continue
        d_pitch = n * s / float(np.pi)
        dp[tag] = d_pitch
        term += max(0.0, d_pitch / bore - 1.0) ** 2          # ring must fit the bore
        d = float(dj)
        if np.isfinite(d) and d > 0:
            # Circumferential land between adjacent holes of the same stream. spacing >= d_jet
            # alone permits a web of exactly zero; min_web_m is the drill/manifold floor.
            web_min = float(min_web_m) if np.isfinite(min_web_m) and min_web_m > 0 else 0.0
            term += max(0.0, (d + web_min - s) / bore) ** 2
    # Impingement distance from the RADIAL ring offset. Both rings inside the bore is handled
    # above; here we require the pair to actually meet at a sane standoff.
    if "O" in dp and "F" in dp:
        dr = 0.5 * abs(dp["O"] - dp["F"])
        # Ring ORDER: fuel outboard of LOX. Whatever spills past the impingement point on
        # the outer ring is what reaches the chamber wall, and a fuel-rich wall film is what
        # the ablative liner wants -- an oxidiser-rich one attacks it. The physics below uses
        # |dr| and so is indifferent to the order; this term is what makes the choice.
        if ring_order_fuel_outboard and dp["F"] < dp["O"]:
            term += ((dp["O"] - dp["F"]) / bore) ** 2
        tO, tF = float(angle_O_deg), float(angle_F_deg)
        # CENTRE CLEARANCE and WALL CLEARANCE, on the elliptical face trace (major = d/cos th).
        _half_major = {}
        for _tag, _d, _th in (("O", d_jet_O_m, tO), ("F", d_jet_F_m, tF)):
            _dv = float(_d)
            if not (np.isfinite(_dv) and _dv > 0):
                continue
            _c = float(np.cos(np.deg2rad(float(_th)))) if np.isfinite(_th) else 1.0
            _half_major[_tag] = 0.5 * _dv / max(0.10, abs(_c))
        if _half_major:
            _inner_tag = "O" if dp["O"] <= dp["F"] else "F"
            _outer_tag = "F" if _inner_tag == "O" else "O"
            if face_contoured and len(_half_major) == 2 and np.isfinite(tO) and np.isfinite(tF):
                # Contoured face: the ring pair ends at the groove edges, not the hole traces.
                _dd = {"O": float(d_jet_O_m), "F": float(d_jet_F_m)}
                _tt = {"O": tO, "F": tF}
                _half_major[_inner_tag], _half_major[_outer_tag] = _face_halves(
                    r_in=0.5 * dp[_inner_tag], d_in=_dd[_inner_tag], th_in=_tt[_inner_tag],
                    r_out=0.5 * dp[_outer_tag], d_out=_dd[_outer_tag], th_out=_tt[_outer_tag],
                    face_contoured=True, exit_land=exit_land)
            _cc = float(center_clear_dia_m)
            if np.isfinite(_cc) and _cc > 0 and _inner_tag in _half_major:
                inner_edge = 0.5 * dp[_inner_tag] - _half_major[_inner_tag]
                term += max(0.0, (0.5 * _cc - inner_edge) / bore) ** 2
            _wc = float(wall_clearance_m)
            _wc = max(0.0, _wc) if np.isfinite(_wc) else 0.0
            if _outer_tag in _half_major:
                outer_edge = 0.5 * dp[_outer_tag] + _half_major[_outer_tag]
                term += max(0.0, (outer_edge + _wc - 0.5 * bore) / bore) ** 2
        d_avg = 0.5 * (float(d_jet_O_m) + float(d_jet_F_m))
        if np.isfinite(tO) and np.isfinite(tF) and np.isfinite(d_avg) and d_avg > 0:
            tan_sum = float(np.tan(np.deg2rad(tO)) + np.tan(np.deg2rad(tF)))
            if tan_sum > 1e-9:
                L_imp = dr / tan_sum
                # SPRAY PLACEMENT. Relative, banded, zero inside the band.
                _srf = float(spray_radius_frac)
                if np.isfinite(_srf) and _srf > 0.0:
                    _th_in = tO if dp["O"] <= dp["F"] else tF
                    _r_in = 0.5 * min(dp["O"], dp["F"])
                    _r_imp = _r_in + L_imp * float(np.tan(np.deg2rad(_th_in)))
                    _frac = _r_imp / (0.5 * bore)
                    _tol = float(spray_radius_tol) if (
                        np.isfinite(spray_radius_tol) and spray_radius_tol > 0) else 0.08
                    _miss = abs(_frac - _srf) - _tol
                    if _miss > 0.0:
                        term += (_miss / _srf) ** 2
                Ld = L_imp / d_avg
                lo, hi = float(Ld_min), float(Ld_max)
                if lo > 0 and hi >= lo:
                    # Relative, one-sided: anywhere inside [lo, hi] orifice diameters is free.
                    if Ld < lo:
                        term += ((lo - Ld) / lo) ** 2
                    elif Ld > hi:
                        term += ((Ld - hi) / hi) ** 2
    return float(term)
 
 
def _impinging_geometry_fit_squared(
    diagnostics: Dict[str, Any],
    *,
    D_chamber_inner_m: float,
    L_chamber_m: float,
) -> float:
    """Squared penalty keeping the impinging element geometry physically self-consistent.
 
    Two soft constraints, read from the physics ``diagnostics``:
 
    * **Ring fit** — the hole pitch-circle ``D_pitch = n·spacing/π`` must stay inside the chamber bore.
    * **No overlap** — adjacent orifices must not collide (``element_gap = spacing − d_jet`` ≥ 0).
 
    It no longer co-locates the rings (that drove the impingement standoff to zero) nor charges a
    vaporization-length budget (a second, cruder evaporation model double-counting eta_vap); see
    the comments below. :func:`_impinging_ring_geometry_squared` carries the ring pair.
 
    All terms are relative (scale-free) and one-sided (only violations are penalized), so a comfortably
    sized element contributes exactly zero.
    """
    def _f(key: str) -> float:
        try:
            return float(diagnostics.get(key, np.nan))
        except (TypeError, ValueError):
            return float("nan")
 
    term = 0.0
 
    bore = float(D_chamber_inner_m)
    if np.isfinite(bore) and bore > 0:
        for k in ("D_pitch_O", "D_pitch_F"):
            d_pitch = _f(k)
            if np.isfinite(d_pitch) and d_pitch > 0:
                term += max(0.0, d_pitch / bore - 1.0) ** 2
 
    # No ring CO-LOCATION term. One used to charge (|D_pitch_O - D_pitch_F| / bore)^2, which
    # drives the ring gap -- and with it the impingement standoff L_imp = dr / (tan th_O +
    # tan th_F) -- to zero: jets colliding on the face. _impinging_ring_geometry_squared owns
    # the ring pair (fit, web, standoff band, order, clearances) from the design variables.
 
    for k in ("element_gap_O", "element_gap_F"):
        gap = _f(k)
        if np.isfinite(gap):
            d_ref = _f("D_pitch_O") if k.endswith("_O") else _f("D_pitch_F")
            ref = d_ref if (np.isfinite(d_ref) and d_ref > 0) else (bore if np.isfinite(bore) and bore > 0 else 1.0)
            if gap < 0.0:
                term += (gap / ref) ** 2
 
    # No vaporization-length budget. It charged (L_imp + L_b + x*) / L_chamber past 1, with
    # x* = u_ax D32^2 / k_evap from spray.py's second evaporation model (1-atm boiling point
    # and latent heat, a C_evap fitted to a legacy K, constant drop speed, no heat-up) -- a
    # cruder model than the c* spray march, whose eta_vap already charges incomplete
    # vaporization through Isp. On the 6500N doublet it added ~142 points (x* 186 mm against
    # the march's fuel drop gone by ~110-130 mm): the same loss counted twice, once wrongly.
    # ``L_chamber_m`` is kept in the signature for callers; nothing here reads it now.
    return float(term)
 
 
def _impinging_free_jet_ld(
    *, n_elements: float, spacing_O_m: float, spacing_F_m: float,
    d_jet_O_m: float, d_jet_F_m: float, angle_O_deg: float, angle_F_deg: float,
) -> float:
    """Longest free jet to the impingement point, in that stream's own orifice diameters.
 
    SP-8089 criterion 3.1.1.1.4 measures the impingement distance ALONG each jet:
    L_k / d_k = L_imp,axial / (d_k cos theta_k). Layer 1's standoff target is axial over the
    mean diameter, so the same target means a longer free jet at steep angles and for the
    smaller hole. NaN when the geometry is degenerate.
    """
    try:
        n = float(n_elements)
        dr = 0.5 * abs(n * (float(spacing_F_m) - float(spacing_O_m)) / np.pi)
        tO, tF = np.deg2rad(float(angle_O_deg)), np.deg2rad(float(angle_F_deg))
        dO, dF = float(d_jet_O_m), float(d_jet_F_m)
    except (TypeError, ValueError):
        return float("nan")
    tan_sum = float(np.tan(tO) + np.tan(tF))
    if not (np.isfinite(dr) and tan_sum > 1e-9 and dO > 0 and dF > 0):
        return float("nan")
    L_ax = dr / tan_sum
    return float(max(L_ax / (dO * max(1e-6, np.cos(tO))), L_ax / (dF * max(1e-6, np.cos(tF)))))
 
 
def _impinging_free_jet_violation(**kw) -> float:
    """Squared relative excess of the longest free jet over SP-8089's 7 d (0 inside)."""
    ld = _impinging_free_jet_ld(**kw)
    if not np.isfinite(ld):
        return 0.0
    return float(max(0.0, ld / FREE_JET_MAX_D - 1.0) ** 2)
 
 
def _layer1_stability_gate(
    state: str, score: float, chug: float, acoustic: float, feed: float,
    stability_results: Any, requirements: dict, min_stability: float,
) -> Tuple[bool, List[str]]:
    """Final stability sign-off: (passed, reasons).
 
    ``require_stable_state`` means 'stable', not 'stable or marginal'. Margins are checked at
    face value -- a hidden 5 % let a chug gate margin of 0.9975 (Nyquist gain margin 0.998, an
    unstable loop) pass -- and an unknown chug gain margin is a failure, not a pass.
    """
    handicap = float(requirements.get("stability_margin_handicap", 0.0) or 0.0)
    eff_score = float(requirements.get("min_stability_score", 0.75)) * max(0.0, 1.0 - handicap)
    eff_margin = float(min_stability) * max(0.0, 1.0 - handicap)
    parts: List[str] = []
    if bool(requirements.get("require_stable_state", True)):
        if state != "stable":
            parts.append(f"state == 'stable' (got '{state}')")
    elif state == "unstable":
        parts.append("state!='unstable'")
    chug_sr = (stability_results.get("chugging") or {}) if isinstance(stability_results, dict) else {}
    if "chug_gain_margin" in chug_sr:
        try:
            gm_known = bool(np.isfinite(float(chug_sr["chug_gain_margin"])))
        except (TypeError, ValueError):
            gm_known = False
        if not gm_known:
            parts.append("chug gain margin unknown")
    if score < eff_score:
        parts.append(f"score>={eff_score:.2f} (got {score:.2f})")
    for name, m in (("chugging", chug), ("acoustic", acoustic), ("feed", feed)):
        if not (m >= eff_margin):
            parts.append(f"{name}_margin>={eff_margin:.3f} (got {m:.4f})")
    return (not parts), parts
 
 
def _layer1_momentum_gate(R: float, R_min: Optional[float], R_max: Optional[float],
                          slack: float = 1.0) -> Tuple[bool, Tuple[Optional[float], Optional[float]]]:
    """Momentum-ratio sign-off on the configured band (``slack`` > 1 widens it about 1)."""
    if R_min is None or R_max is None or not (np.isfinite(R) and R > 0):
        return True, (R_min, R_max)
    lo = max(0.0, 1.0 - (1.0 - float(R_min)) * float(slack))
    hi = 1.0 + (float(R_max) - 1.0) * float(slack)
    return bool(lo <= R <= hi), (lo, hi)
 
 
def _layer1_declared_limit_gates(
    config: Any, requirements: dict, constants: dict,
    performance: Optional[Dict[str, Any]] = None,
) -> Dict[str, Tuple[bool, str]]:
    """Every declared geometric limit, checked on the emitted design at face value.
 
    {gate: (passed, reason)}. Only limits the configuration declares are checked (plus the
    SP-8089 free-jet length and the bore, which always apply to a doublet). ``performance``
    (the emitted design's solve: ``mdot_O/F`` and ``diagnostics.delta_p_injector_O/F``) adds
    the manifold velocity-head gate when the plate declares channels.
    """
    gates: Dict[str, Tuple[bool, str]] = {}
    # Plate entries the caller's constants lack come from the config (a hand-built constants
    # dict, or none); the run's own constants carry every one of them.
    constants = {**_layer1_injector_plate_constants(config, requirements), **(constants or {})}
    inj = getattr(config, "injector", None)
 
    # Igniter thread engagement: the tapped port needs the thread's effective length L2
    # (ASME B1.20.1, engine.core.injectors.hardware_tables.NPT) of metal -- the hub at the port
    # when one is declared, else the plate. The plate thickness is a declared number, not a
    # design variable, so nothing in the search can move this: it is a sign-off gate only.
    ign = getattr(inj, "igniter", None)
    if ign is not None and getattr(ign, "thread", None):
        t_plate = float(constants.get("layer1_injector_plate_thickness_m", 0.0) or 0.0)
        if not (np.isfinite(t_plate) and t_plate > 0.0):
            t_plate = PLATE_THICKNESS_DEFAULT          # the layout's own fallback
        ko = igniter_keepouts(
            ign.model_dump() if hasattr(ign, "model_dump") else dict(ign),
            plate_thickness=t_plate,
            min_web=float(constants.get("layer1_injector_min_web_m", 0.0) or 0.0))
        if ko is not None:
            at = "injector.igniter.hub_thickness" if ko["hub_thickness"] is not None else "the plate"
            gates["igniter_engagement"] = (
                ko["engaged_thickness"] >= ko["l2"],
                f"{ko['thread']} igniter needs {ko['l2'] * 1e3:.2f} mm of thread engagement (ASME "
                f"B1.20.1 L2); {at} gives {ko['engaged_thickness'] * 1e3:.2f} mm at the port")
 
    cg = getattr(config, "chamber_geometry", None)
    if cg is None:
        return gates
    try:
        At = float(cg.A_throat or 0.0)
        D = float(cg.chamber_diameter or 0.0)
        Lstar = float(cg.Lstar or 0.0)
        eps = float(cg.expansion_ratio or 0.0)
    except (TypeError, ValueError):
        return gates
    if not (At > 0 and D > 0 and Lstar > 0):
        return gates
    A_c = np.pi * D * D / 4.0
    lens = _layer1_chamber_lengths(At, Lstar, D, _layer1_contraction_theta(constants))
    geom = getattr(inj, "geometry", None)
    n = 0
    if getattr(inj, "type", None) == "impinging" and geom is not None:
        n = int(getattr(geom.oxidizer, "n_elements", 0) or 0)
 
    max_pitch = _req_lookup(requirements, "layer1_max_element_pitch_m")
    if max_pitch is not None and float(max_pitch) > 0 and n > 0:
        pitch = float(np.sqrt(A_c / n))
        gates["element_pitch"] = (
            pitch <= float(max_pitch),
            f"Element pitch {pitch * 1e3:.2f} mm > limit {float(max_pitch) * 1e3:.2f} mm "
            f"({n} elements in a {D * 1e3:.1f} mm bore)")
    min_ld = _req_lookup(requirements, "layer1_min_Lcyl_over_D")
    if min_ld is not None and float(min_ld) > 0:
        r = lens["length_cylindrical"] / D
        gates["lcyl_over_d"] = (r >= float(min_ld),
                                f"L_cyl/D {r:.3f} < minimum {float(min_ld):.3f}")
    max_len = _req_lookup(requirements, "max_engine_length")
    if max_len is not None and float(max_len) > 0:
        L_eng = lens["face_to_throat"] + _layer1_bell_length_m(At, eps)
        gates["engine_length"] = (L_eng <= float(max_len),
                                  f"Engine length {L_eng * 1e3:.1f} mm (face to exit) > "
                                  f"max_engine_length {float(max_len) * 1e3:.1f} mm")
    if n > 0:
        g = dict(n_elements=n, spacing_O_m=float(geom.oxidizer.spacing),
                 spacing_F_m=float(geom.fuel.spacing), d_jet_O_m=float(geom.oxidizer.d_jet),
                 d_jet_F_m=float(geom.fuel.d_jet), angle_O_deg=float(geom.oxidizer.impingement_angle),
                 angle_F_deg=float(geom.fuel.impingement_angle))
        fj = _impinging_free_jet_ld(**g)
        if np.isfinite(fj):
            gates["free_jet"] = (fj <= FREE_JET_MAX_D,
                                 f"Free jet {fj:.2f} d to impingement > SP-8089's {FREE_JET_MAX_D:g} d")
        c = constants
        face = _impinging_face_infeasibility_terms(
            **g, D_chamber_inner_m=D,
            center_clear_dia_m=float(c.get("layer1_injector_center_clear_dia_m", 0.0) or 0.0),
            min_web_m=float(c.get("layer1_injector_min_web_m", 0.0) or 0.0),
            wall_clearance_m=float(c.get("layer1_injector_wall_clearance_m", 0.0) or 0.0),
            spray_radius_frac=float(c.get("layer1_injector_spray_radius_frac", 0.0) or 0.0),
            spray_radius_tol=float(c.get("layer1_injector_spray_radius_tol", 0.08) or 0.08),
            min_face_incidence_deg=float(c.get("layer1_injector_min_face_incidence_deg", 0.0) or 0.0),
            face_contoured=bool(c.get("layer1_injector_face_contoured", False)),
            exit_land=float(c.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)))
        gates["injector_face"] = (face <= 0.0, f"Injector face limits violated (score {face:.3g})")
        back = _impinging_back_face_terms(
            **g, D_chamber_inner_m=D,
            plate_thickness_m=float(c.get("layer1_injector_plate_thickness_m", 0.0) or 0.0),
            counterbore_dia_m=float(c.get("layer1_injector_counterbore_dia_m", 0.0) or 0.0),
            land_ld_O=float(c.get("layer1_injector_land_ld_O", 4.0) or 4.0),
            land_ld_F=float(c.get("layer1_injector_land_ld_F", 4.0) or 4.0),
            min_back_web_m=float(c.get("layer1_injector_min_back_web_m", 0.0) or 0.0),
            back_keepout_dia_m=float(c.get("layer1_injector_back_keepout_dia_m", 0.0) or 0.0),
            back_keepout_wall_m=float(c.get("layer1_injector_back_keepout_wall_m", 0.0) or 0.0),
            face_contoured=bool(c.get("layer1_injector_face_contoured", False)),
            exit_land=float(c.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)),
            back_channels=bool(c.get("layer1_injector_back_channels", False)),
            passage_ld_O=float(c.get("layer1_injector_land_ld_O", 4.0) or 4.0),
            passage_ld_F=float(c.get("layer1_injector_land_ld_F", 4.0) or 4.0),
            channel_width_m=float(c.get("layer1_injector_channel_width_m", 0.0) or 0.0),
            channel_floor=str(c.get("layer1_injector_channel_floor", "flat")),
            r_plate_m=float(c.get("layer1_injector_r_plate_m", 0.0) or 0.0),
            r_port_m=float(c.get("layer1_injector_r_port_m", 0.0) or 0.0),
            liner_thickness_m=float(c.get("layer1_injector_liner_thickness_m", 0.0) or 0.0))
        gates["injector_back_face"] = (back <= 0.0,
                                       f"Injector back-face limits violated (score {back:.3g})")
        if bool(c.get("layer1_injector_back_channels", False)) and isinstance(performance, dict):
            _dg = performance.get("diagnostics") if isinstance(performance.get("diagnostics"), dict) else {}
            fl = getattr(config, "fluids", None) or {}
 
            def _rho(key: str, side: str) -> Any:
                v = c.get(key)
                if v is None:
                    try:
                        v = fl[side].density
                    except (KeyError, TypeError, AttributeError):
                        v = None
                return v
            inlets = int(c.get("layer1_injector_channel_inlets", 1) or 1)
            mq = _impinging_manifold_q(
                **g, plate_thickness_m=float(c.get("layer1_injector_plate_thickness_m", 0.0) or 0.0),
                face_contoured=bool(c.get("layer1_injector_face_contoured", False)),
                exit_land=float(c.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)),
                passage_ld_O=float(c.get("layer1_injector_land_ld_O", 4.0) or 4.0),
                passage_ld_F=float(c.get("layer1_injector_land_ld_F", 4.0) or 4.0),
                channel_width_m=float(c.get("layer1_injector_channel_width_m", 0.0) or 0.0),
                channel_floor=str(c.get("layer1_injector_channel_floor", "flat")),
                channel_inlets=inlets,
                mdot_O=performance.get("mdot_O"), mdot_F=performance.get("mdot_F"),
                dp_O=_dg.get("delta_p_injector_O"), dp_F=_dg.get("delta_p_injector_F"),
                rho_O=_rho("rho_O", "oxidizer"), rho_F=_rho("rho_F", "fuel"))
            for k, tag in (("O", "LOX"), ("F", "fuel")):
                h = mq.get(k)
                if h is None:
                    continue
                gates[f"manifold_q_{k}"] = (
                    h["q_over_dp"] <= h["q_frac"],
                    f"{tag} channel velocity head {100 * h['q_over_dp']:.0f} % of the injector "
                    f"drop at {inlets} feed port{'s' if inlets > 1 else ''} > "
                    f"{100 * MANIFOLD_Q_FRAC:.0f} % (channel {h['flow_area'] * 1e6:.1f} mm^2, "
                    f"needs {h['area_needed'] * 1e6:.0f} mm^2, or more ports)")
    return gates
 
 
def _impinging_face_infeasibility_terms(
    *,
    n_elements: float, spacing_O_m: float, spacing_F_m: float,
    d_jet_O_m: float, d_jet_F_m: float, D_chamber_inner_m: float,
    angle_O_deg: float, angle_F_deg: float,
    center_clear_dia_m: float = 0.0, min_web_m: float = 0.0,
    wall_clearance_m: float = 0.0, spray_radius_frac: float = 0.0,
    spray_radius_tol: float = 0.08, min_face_incidence_deg: float = 0.0,
    face_contoured: bool = False, exit_land: float = EXIT_LAND_DEFAULT,
) -> float:
    """Face real-estate misses as a GRADED infeasibility, for the parallel worker path.
 
    These limits need three properties at once and only this shape has all three:
 
    * **Hard.** Routed into ``infeasibility_score``, so any violation ranks below every
      feasible design instead of being priced against Isp. As a plain objective term at
      W_IMP_GEOM = 1500 a 0.022 spray-radius miss cost 1.5 points against an objective of
      ~2690 and every seed simply bought it -- the same way a 2.7 %-over ring once bought
      orifices outside the bore for 1.1 points.
    * **Graded.** A binary ``+= 1.0`` was tried and is worse than useless: it puts the whole
      violating region on one flat 1e6 plateau with no gradient, and 2 of 3 seeds then never
      found the feasible set at all (converged O/F 2.09 and 25.6). Same failure the
      per-jet angle box produced once; see the note at the angle bounds.
    * **In both paths.** The serial loop's ``_impinging_hard_geometry_blocks_eval`` never ran
      in the parallel CMA workers, where essentially every candidate is scored.
 
    All terms are relative, one-sided, and exactly zero for a comfortable design, so a config
    that declares none of these keys contributes nothing -- except the bore itself: an
    orifice whose elliptical trace crosses the chamber wall is drilled into the liner whether
    or not a wall land was declared, so that check runs at a clearance of 0 too. The soft
    term and the serial hard block apply the same rule.
    """
    bore = float(D_chamber_inner_m)
    n = float(n_elements)
    if not (np.isfinite(bore) and bore > 0 and np.isfinite(n) and n > 0):
        return 0.0
    try:
        dp_O = n * float(spacing_O_m) / np.pi
        dp_F = n * float(spacing_F_m) / np.pi
    except (TypeError, ValueError):
        return 0.0
    if not (np.isfinite(dp_O) and np.isfinite(dp_F) and dp_O > 0 and dp_F > 0):
        return 0.0
 
    def _half_major(d: float, th: float) -> float:
        c = float(np.cos(np.deg2rad(float(th)))) if np.isfinite(th) else 1.0
        return 0.5 * float(d) / max(0.10, abs(c))
 
    ox_inner = dp_O <= dp_F
    r_in = 0.5 * (dp_O if ox_inner else dp_F)
    r_out = 0.5 * (dp_F if ox_inner else dp_O)
    d_in, th_in = (d_jet_O_m, angle_O_deg) if ox_inner else (d_jet_F_m, angle_F_deg)
    d_out, th_out = (d_jet_F_m, angle_F_deg) if ox_inner else (d_jet_O_m, angle_O_deg)
    if face_contoured and np.isfinite(th_in) and np.isfinite(th_out):
        h_in, h_out = _face_halves(r_in=r_in, d_in=d_in, th_in=th_in, r_out=r_out, d_out=d_out,
                                   th_out=th_out, face_contoured=True, exit_land=exit_land)
    else:
        h_in, h_out = _half_major(d_in, th_in), _half_major(d_out, th_out)
 
    term = 0.0
    cc = float(center_clear_dia_m)
    if np.isfinite(cc) and cc > 0.0:
        inner_edge = r_in - h_in
        term += max(0.0, (0.5 * cc - inner_edge) / bore) ** 2
    wc = float(wall_clearance_m)
    wc = max(0.0, wc) if np.isfinite(wc) else 0.0
    outer_edge = r_out + h_out
    term += max(0.0, (outer_edge + wc - 0.5 * bore) / bore) ** 2
    # FACE INCIDENCE (90 - theta against the declared floor). The jet-angle search box already
    # holds this for free variables; a frozen or seeded angle does not pass through that box.
    inc = float(min_face_incidence_deg)
    if np.isfinite(inc) and inc > 0.0:
        for _th in (angle_O_deg, angle_F_deg):
            if np.isfinite(_th):
                term += max(0.0, (inc - (90.0 - float(_th))) / 90.0) ** 2
    web = float(min_web_m)
    if np.isfinite(web) and web > 0.0:
        for _sp, _dj in ((spacing_O_m, d_jet_O_m), (spacing_F_m, d_jet_F_m)):
            if float(_sp) > 0:
                term += max(0.0, (float(_dj) + web - float(_sp)) / bore) ** 2
    srf = float(spray_radius_frac)
    if np.isfinite(srf) and srf > 0.0:
        tan_sum = float(np.tan(np.deg2rad(float(angle_O_deg)))
                        + np.tan(np.deg2rad(float(angle_F_deg))))
        if np.isfinite(tan_sum) and tan_sum > 1e-9:
            L_imp = 0.5 * abs(dp_O - dp_F) / tan_sum
            r_imp = r_in + L_imp * float(np.tan(np.deg2rad(float(th_in))))
            frac = r_imp / (0.5 * bore)
            tol = float(spray_radius_tol) if (
                np.isfinite(spray_radius_tol) and spray_radius_tol > 0) else 0.08
            term += max(0.0, abs(frac - srf) - tol) ** 2
    return float(term)
 
 
def _impinging_channel_pair(
    *,
    n_elements: float, spacing_O_m: float, spacing_F_m: float,
    d_jet_O_m: float, d_jet_F_m: float, angle_O_deg: float, angle_F_deg: float,
    plate_thickness_m: float, face_contoured: bool, exit_land: float,
    passage_ld_O: float, passage_ld_F: float, channel_width_m: float, channel_floor: str,
) -> Optional[Tuple[Dict[str, Any], Dict[str, Any], bool]]:
    """(LOX channel, fuel channel, LOX inboard) from ``layout.channel_for_ring`` -- the drawing's
    own geometry -- or None when the ring pair is degenerate."""
    from engine.core.injectors.layout import exit_recess as _exit_recess
    try:
        n = int(round(float(n_elements))) if np.isfinite(n_elements) else 0
    except (TypeError, ValueError):
        return None
    if n < 1:
        return None
    r_O = n * float(spacing_O_m) / np.pi / 2.0
    r_F = n * float(spacing_F_m) / np.pi / 2.0
    ox_inner = r_O <= r_F
    thO, thF = float(angle_O_deg), float(angle_F_deg)
    if not (np.isfinite(thO) and np.isfinite(thF)):
        return None
    dO, dF = float(d_jet_O_m), float(d_jet_F_m)
    if face_contoured:
        d_in, th_in, d_out, th_out = (dO, thO, dF, thF) if ox_inner else (dF, thF, dO, thO)
        z_E = -_exit_recess(d_in=d_in, th_in=th_in, d_out=d_out, th_out=th_out,
                            exit_land=float(exit_land))
    else:
        z_E = 0.0
    w = float(channel_width_m) if np.isfinite(channel_width_m) and channel_width_m > 0 else None
    t = float(plate_thickness_m)
    chO = channel_for_ring(r_exit=r_O, z_exit=z_E, d=dO, theta_deg=thO, is_inner=ox_inner,
                           plate_thickness=t, passage_ld=float(passage_ld_O), width=w,
                           floor=channel_floor, exit_land=float(exit_land))
    chF = channel_for_ring(r_exit=r_F, z_exit=z_E, d=dF, theta_deg=thF, is_inner=not ox_inner,
                           plate_thickness=t, passage_ld=float(passage_ld_F), width=w,
                           floor=channel_floor, exit_land=float(exit_land))
    return chO, chF, ox_inner
 
 
def _impinging_manifold_q(
    *,
    n_elements: float, spacing_O_m: float, spacing_F_m: float,
    d_jet_O_m: float, d_jet_F_m: float, angle_O_deg: float, angle_F_deg: float,
    plate_thickness_m: float, face_contoured: bool, exit_land: float,
    passage_ld_O: float, passage_ld_F: float, channel_width_m: float, channel_floor: str,
    channel_inlets: int, mdot_O: Any, mdot_F: Any, dp_O: Any, dp_F: Any, rho_O: Any, rho_F: Any,
) -> Dict[str, Dict[str, float]]:
    """Channels back: each channel's velocity head at its feed port against the injector drop.
 
    ``layout.channel_velocity_head`` on the channel ``layout.channel_for_ring`` draws, with
    ``channel_inlets`` ports each splitting two ways: q = rho/2 (mdot / (2 n rho A))^2. The limit
    is ``layout.MANIFOLD_Q_FRAC`` of the drop (Rohde, Richards & Metger, NASA TN D-5467: holes
    fed across a channel recover none of its velocity head). {side: velocity-head dict}; a side
    is missing when its channel pierces the back (no channel) or its flow is not known -- the
    same skips as ``layout._check_manifold``.
    """
    t = float(plate_thickness_m)
    if not (np.isfinite(t) and t > 0.0):
        t = PLATE_THICKNESS_DEFAULT            # the layout's own fallback, so both agree
    pair = _impinging_channel_pair(
        n_elements=n_elements, spacing_O_m=spacing_O_m, spacing_F_m=spacing_F_m,
        d_jet_O_m=d_jet_O_m, d_jet_F_m=d_jet_F_m, angle_O_deg=angle_O_deg,
        angle_F_deg=angle_F_deg, plate_thickness_m=t, face_contoured=face_contoured,
        exit_land=exit_land, passage_ld_O=passage_ld_O, passage_ld_F=passage_ld_F,
        channel_width_m=channel_width_m, channel_floor=channel_floor)
    out: Dict[str, Dict[str, float]] = {}
    if pair is None:
        return out
    chans = {"O": pair[0], "F": pair[1]}
    flows = {"O": (mdot_O, dp_O, rho_O), "F": (mdot_F, dp_F, rho_F)}
    for k, ch in chans.items():
        if ch["pierces_back"]:
            continue
        try:
            m, dp, rho = (float(v) for v in flows[k])
        except (TypeError, ValueError):
            continue
        if not (np.isfinite(m) and np.isfinite(dp) and np.isfinite(rho) and m > 0 and dp > 0 and rho > 0):
            continue
        h = _channel_velocity_head(flow_area=float(ch["flow_area"]), mdot=m, rho=rho, dp=dp,
                                   inlets=int(channel_inlets or 1))
        if np.isfinite(h["q_over_dp"]):
            out[k] = dict(h, flow_area=float(ch["flow_area"]))
    return out
 
 
def _impinging_manifold_violation(q: Dict[str, Dict[str, float]]) -> float:
    """Graded infeasibility from :func:`_impinging_manifold_q`: the channel AREA shortfall,
    ``(A_needed / A - 1)^2`` summed over the sides, 0 at or under ``MANIFOLD_Q_FRAC``."""
    term = 0.0
    for h in q.values():
        A, A_need = float(h.get("flow_area", 0.0)), float(h.get("area_needed", float("nan")))
        if A > 0 and np.isfinite(A_need):
            term += max(0.0, A_need / A - 1.0) ** 2
    return float(term)
 
 
def _impinging_channel_terms(
    *,
    n_elements: float, spacing_O_m: float, spacing_F_m: float,
    d_jet_O_m: float, d_jet_F_m: float, D_chamber_inner_m: float,
    angle_O_deg: float, angle_F_deg: float, plate_thickness_m: float,
    face_contoured: bool, exit_land: float, passage_ld_O: float, passage_ld_F: float,
    channel_width_m: float, channel_floor: str, r_plate_m: float, r_port_m: float,
    min_land_m: float = 0.0, back_keepout_dia_m: float = 0.0, back_keepout_wall_m: float = 0.0,
) -> float:
    """Channel-back misses as a graded infeasibility. Active whenever the back is channels.
 
    The same geometry the drawing uses (``engine.core.injectors.layout.channel_for_ring``):
    each passage runs its L/d from the exit to its channel floor. Infeasible when a passage would
    run out through the back face before its length, when the two channels overlap (or leave less
    than ``min_land_m`` between them), when the inner channel reaches the centre port or the
    igniter's thick centre, or when the outer channel runs off the plug.
    """
    import math as _m
    bore = float(D_chamber_inner_m)
    if not (np.isfinite(bore) and bore > 0):
        return 0.0
    pair = _impinging_channel_pair(
        n_elements=n_elements, spacing_O_m=spacing_O_m, spacing_F_m=spacing_F_m,
        d_jet_O_m=d_jet_O_m, d_jet_F_m=d_jet_F_m, angle_O_deg=angle_O_deg,
        angle_F_deg=angle_F_deg, plate_thickness_m=plate_thickness_m,
        face_contoured=face_contoured, exit_land=exit_land, passage_ld_O=passage_ld_O,
        passage_ld_F=passage_ld_F, channel_width_m=channel_width_m, channel_floor=channel_floor)
    if pair is None:
        return 0.0
    chO, chF, ox_inner = pair
    term = 0.0
    for ch in (chO, chF):
        if ch["pierces_back"]:
            term += ((ch["length_wanted"] - ch["length"]) / bore) ** 2
    ch_in, ch_out = (chO, chF) if ox_inner else (chF, chO)
    r_plate = float(r_plate_m) if np.isfinite(r_plate_m) and r_plate_m > 0 else 0.5 * bore
    lands = channel_lands(ch_in=ch_in, ch_out=ch_out, r_centre_hole=float(r_port_m or 0.0),
                          r_plate=r_plate)
    need = max(0.0, float(min_land_m) if _m.isfinite(min_land_m) else 0.0)
    term += max(0.0, (need - lands["between"]) / bore) ** 2
    term += max(0.0, -lands["inner"] / bore) ** 2
    term += max(0.0, -lands["outer"] / bore) ** 2
    keep = float(back_keepout_dia_m) if np.isfinite(back_keepout_dia_m) else 0.0
    if keep > 0.0:
        wall = float(back_keepout_wall_m) if np.isfinite(back_keepout_wall_m) else 0.0
        term += max(0.0, (0.5 * keep + wall - ch_in["r_lo"]) / bore) ** 2
    return float(term)
 
 
def _impinging_back_face_terms(
    *,
    n_elements: float, spacing_O_m: float, spacing_F_m: float,
    d_jet_O_m: float, d_jet_F_m: float, D_chamber_inner_m: float,
    angle_O_deg: float, angle_F_deg: float,
    plate_thickness_m: float = 0.0, counterbore_dia_m: float = 0.0,
    land_ld_O: float = 4.0, land_ld_F: float = 4.0,
    min_back_web_m: float = 0.0,
    back_keepout_dia_m: float = 0.0, back_keepout_wall_m: float = 0.0,
    face_contoured: bool = False, exit_land: float = EXIT_LAND_DEFAULT,
    back_channels: bool = False, passage_ld_O: float = 4.0, passage_ld_F: float = 4.0,
    channel_width_m: float = 0.0, channel_floor: str = "flat",
    r_plate_m: float = 0.0, r_port_m: float = 0.0, liner_thickness_m: float = 0.0,
) -> float:
    """Back-face (manifold side) misses as a graded infeasibility.
 
    Always on, when a plate thickness is known: passages that overlap at the back face, cross the
    axis, or open into the centre port -- none of those can be built. The declared limits
    (``min_back_web_m``, the igniter's back keep-out) add to that.
 
    Each passage walks ``t tan(theta)`` radially through the plate, the two rings walking
    APART, so a face that fits can leave entries that crowd each other (inner ring) or leave
    no room for the wall between the two manifolds. The geometry is
    ``engine.core.injectors.layout.passage_back_entry`` -- the same call the drawing makes.
    Relative to the bore and squared, like the face terms, so CMA has a gradient home.
    """
    t = float(plate_thickness_m)
    if back_channels and not (np.isfinite(t) and t > 0.0):
        t = PLATE_THICKNESS_DEFAULT            # the layout's own fallback, so both agree
    web_req = float(min_back_web_m) if np.isfinite(min_back_web_m) else 0.0
    land_req = 0.0          # the LOX and fuel entries may not overlap; the seal land is the user's
    keep = float(back_keepout_dia_m) if np.isfinite(back_keepout_dia_m) else 0.0
    # The plug fills the sleeve bore: bore + liner, from THIS candidate's bore.
    liner = float(liner_thickness_m) if np.isfinite(liner_thickness_m) else 0.0
    if np.isfinite(D_chamber_inner_m) and D_chamber_inner_m > 0:
        r_plate_m = 0.5 * float(D_chamber_inner_m) + liner
    if back_channels and np.isfinite(t) and t > 0.0:
        return _impinging_channel_terms(
            n_elements=n_elements, spacing_O_m=spacing_O_m, spacing_F_m=spacing_F_m,
            d_jet_O_m=d_jet_O_m, d_jet_F_m=d_jet_F_m, D_chamber_inner_m=D_chamber_inner_m,
            angle_O_deg=angle_O_deg, angle_F_deg=angle_F_deg, plate_thickness_m=t,
            face_contoured=face_contoured, exit_land=exit_land,
            passage_ld_O=passage_ld_O, passage_ld_F=passage_ld_F,
            channel_width_m=channel_width_m, channel_floor=channel_floor,
            r_plate_m=r_plate_m, r_port_m=r_port_m, min_land_m=land_req,
            back_keepout_dia_m=keep, back_keepout_wall_m=back_keepout_wall_m)
    if not (np.isfinite(t) and t > 0.0):
        return 0.0
    bore = float(D_chamber_inner_m)
    n = int(round(float(n_elements))) if np.isfinite(n_elements) else 0
    thO, thF = float(angle_O_deg), float(angle_F_deg)
    if not (np.isfinite(bore) and bore > 0 and n >= 1 and np.isfinite(thO) and np.isfinite(thF)):
        return 0.0
    r_O = n * float(spacing_O_m) / np.pi / 2.0
    r_F = n * float(spacing_F_m) / np.pi / 2.0
    ox_inner = r_O <= r_F
    dE = 0.0
    if face_contoured:
        from engine.core.injectors.layout import exit_recess as _exit_recess
        d_in, th_in, d_out, th_out = ((float(d_jet_O_m), thO, float(d_jet_F_m), thF) if ox_inner
                                      else (float(d_jet_F_m), thF, float(d_jet_O_m), thO))
        dE = _exit_recess(d_in=d_in, th_in=th_in, d_out=d_out, th_out=th_out, exit_land=float(exit_land))
    cb = float(counterbore_dia_m) if np.isfinite(counterbore_dia_m) else 0.0
    eO = passage_back_entry(r_face=r_O, d=float(d_jet_O_m), theta_deg=thO,
                            plate_thickness=t, counterbore_dia=cb, land_ld=float(land_ld_O),
                            is_inner=ox_inner, n=n, exit_depth=dE)
    eF = passage_back_entry(r_face=r_F, d=float(d_jet_F_m), theta_deg=thF,
                            plate_thickness=t, counterbore_dia=cb, land_ld=float(land_ld_F),
                            is_inner=not ox_inner, n=n, exit_depth=dE)
    term = 0.0
    for e in (eO, eF):                            # never buildable: entries that overlap
        term += max(0.0, (max(web_req, 0.0) - e.web) / bore) ** 2
    inner, outer = (eO, eF) if ox_inner else (eF, eO)
    # ... or cross, or reach the axis / the centre port
    term += max(0.0, (max(land_req, 0.0) - (outer.inner_edge - inner.outer_edge)) / bore) ** 2
    r_port = float(r_port_m) if np.isfinite(r_port_m) else 0.0
    term += max(0.0, (r_port - inner.inner_edge) / bore) ** 2
    if keep > 0.0:
        # The igniter's hub / socket on the back: the inner ring's entries must clear it.
        wall = float(back_keepout_wall_m) if np.isfinite(back_keepout_wall_m) else 0.0
        term += max(0.0, (0.5 * keep + wall - inner.inner_edge) / bore) ** 2
    return float(term)
 
 
def _impinging_hard_geometry_blocks_eval(
    *,
    d_jet_O: float,
    d_jet_F: float,
    sp_O: float,
    sp_F: float,
    D_chamber_inner: float,
    D_throat_check: float,
    A_chamber_check: float,
    A_throat_check: float,
    n_elements: float = float("nan"),
    angle_O_deg: float = float("nan"),
    angle_F_deg: float = float("nan"),
    center_clear_dia_m: float = 0.0,
    min_web_m: float = 0.0,
    wall_clearance_m: float = 0.0,
    min_face_incidence_deg: float = 0.0,
    spray_radius_frac: float = 0.0,
    spray_radius_tol: float = 0.08,
    plate_thickness_m: float = 0.0,
    counterbore_dia_m: float = 0.0,
    land_ld_O: float = 4.0,
    land_ld_F: float = 4.0,
    min_back_web_m: float = 0.0,
    back_keepout_dia_m: float = 0.0,
    back_keepout_wall_m: float = 0.0,
    face_contoured: bool = False,
    exit_land: float = EXIT_LAND_DEFAULT,
    back_channels: bool = False,
    passage_ld_O: float = 4.0,
    passage_ld_F: float = 4.0,
    channel_width_m: float = 0.0,
    channel_floor: str = "flat",
    r_plate_m: float = 0.0,
    r_port_m: float = 0.0,
    liner_thickness_m: float = 0.0,
) -> bool:
    """True when doublet layout is physically impossible — skip ``evaluate()``.
 
    The face-real-estate checks (centre clearance, web, wall land) are HARD for the same
    reason ring fit is: as soft terms they get bought for a rounding error against an
    objective of ~2700. They stay inert unless the corresponding requirement is set, so a
    config that declares none of them behaves exactly as before.
    """
    # FACE INCIDENCE. theta is measured from the chamber AXIS, so the angle the drill makes
    # with the face PLANE is 90 - theta. A twist drill entering a flat below ~40 deg of
    # incidence walks off the spot; the fix is a spot-face milled normal to the hole axis, and
    # whether the shop will cut 2n of those is a decision, not something the optimizer may
    # assume. This is the per-jet CEILING on theta, complementary to the
    # layer1_impinging_jet_angle_min_deg floor.
    _inc = float(min_face_incidence_deg) if np.isfinite(min_face_incidence_deg) else 0.0
    if _inc > 0.0:
        for _th in (angle_O_deg, angle_F_deg):
            if np.isfinite(_th) and (90.0 - float(_th)) < _inc:
                return True
    _web = float(min_web_m) if np.isfinite(min_web_m) and min_web_m > 0 else 0.0
    if sp_O > 0.0 and d_jet_O + _web > sp_O:
        return True
    if sp_F > 0.0 and d_jet_F + _web > sp_F:
        return True
    # RING FIT. D_pitch = n*spacing/pi, and the hole has width, so the ring needs
    # D_pitch + d_jet <= D_chamber_inner or the orifices are drilled outside the chamber
    # wall. This was only a SOFT term in _impinging_ring_geometry_squared -- a fuel ring
    # 2.7% over the bore scored (0.0268)^2 * W_IMP_GEOM = 1.1 points against an objective
    # of ~2700, so the optimiser bought impossible geometry for nothing and every gate
    # still reported PASS. Measured live: 130.4 mm fuel pitch circle on a 127.0 mm bore.
    # (A flat-face rule: on a contoured face the ring pair ends at the groove edges, which the
    # clearance check below measures; D_pitch + d is not a face extent there.)
    if np.isfinite(n_elements) and n_elements >= 1.0 and D_chamber_inner > 0.0 and not face_contoured:
        for _sp, _dj in ((sp_O, d_jet_O), (sp_F, d_jet_F)):
            if _sp > 0.0:
                if (float(n_elements) * _sp / np.pi) + _dj > D_chamber_inner:
                    return True
    # CENTRE / WALL clearance on the elliptical face trace (radial major axis = d/cos theta).
    if (np.isfinite(n_elements) and n_elements >= 1.0 and D_chamber_inner > 0.0
            and sp_O > 0.0 and sp_F > 0.0):
        _dp_O = float(n_elements) * sp_O / np.pi
        _dp_F = float(n_elements) * sp_F / np.pi
        def _half_major(d: float, th: float) -> float:
            c = float(np.cos(np.deg2rad(float(th)))) if np.isfinite(th) else 1.0
            return 0.5 * float(d) / max(0.10, abs(c))
        _in_dp, _in_d, _in_th = ((_dp_O, d_jet_O, angle_O_deg) if _dp_O <= _dp_F
                                 else (_dp_F, d_jet_F, angle_F_deg))
        _out_dp, _out_d, _out_th = ((_dp_F, d_jet_F, angle_F_deg) if _dp_O <= _dp_F
                                    else (_dp_O, d_jet_O, angle_O_deg))
        if face_contoured and np.isfinite(_in_th) and np.isfinite(_out_th):
            _h_in, _h_out = _face_halves(r_in=0.5 * _in_dp, d_in=_in_d, th_in=_in_th,
                                         r_out=0.5 * _out_dp, d_out=_out_d, th_out=_out_th,
                                         face_contoured=True, exit_land=exit_land)
        else:
            _h_in, _h_out = _half_major(_in_d, _in_th), _half_major(_out_d, _out_th)
        _cc = float(center_clear_dia_m)
        if np.isfinite(_cc) and _cc > 0.0:
            if 0.5 * _in_dp - _h_in < 0.5 * _cc:
                return True
        # Runs at a declared clearance of 0 too: a trace across the bore is never buildable.
        _wc = float(wall_clearance_m)
        _wc = max(0.0, _wc) if np.isfinite(_wc) else 0.0
        if 0.5 * _out_dp + _h_out + _wc > 0.5 * D_chamber_inner:
            return True
    # SPRAY PLACEMENT, hard for the same reason ring fit is. As a soft term it costs
    # (miss/target)^2 * W_IMP_GEOM, which on a 0.022 miss at W = 1500 is 1.5 points against an
    # objective of ~2690 -- so every seed bought a spray circle outside its own declared band
    # for nothing, exactly the way a 2.7 %-over ring once bought orifices outside the bore.
    if (np.isfinite(n_elements) and n_elements >= 1.0 and D_chamber_inner > 0.0
            and sp_O > 0.0 and sp_F > 0.0 and np.isfinite(spray_radius_frac)
            and spray_radius_frac > 0.0):
        _dpo = float(n_elements) * sp_O / np.pi
        _dpf = float(n_elements) * sp_F / np.pi
        _ts = float(np.tan(np.deg2rad(float(angle_O_deg)))
                    + np.tan(np.deg2rad(float(angle_F_deg))))
        if np.isfinite(_ts) and _ts > 1e-9:
            _L = 0.5 * abs(_dpo - _dpf) / _ts
            _th_in = float(angle_O_deg) if _dpo <= _dpf else float(angle_F_deg)
            _r_imp = 0.5 * min(_dpo, _dpf) + _L * float(np.tan(np.deg2rad(_th_in)))
            _frac = _r_imp / (0.5 * D_chamber_inner)
            _tol = float(spray_radius_tol) if (
                np.isfinite(spray_radius_tol) and spray_radius_tol > 0) else 0.08
            if abs(_frac - float(spray_radius_frac)) > _tol:
                return True
    # BACK FACE. Same graded function the worker path scores, used here as a block.
    if np.isfinite(n_elements) and _impinging_back_face_terms(
            n_elements=n_elements, spacing_O_m=sp_O, spacing_F_m=sp_F,
            d_jet_O_m=d_jet_O, d_jet_F_m=d_jet_F, D_chamber_inner_m=D_chamber_inner,
            angle_O_deg=angle_O_deg, angle_F_deg=angle_F_deg,
            plate_thickness_m=plate_thickness_m, counterbore_dia_m=counterbore_dia_m,
            land_ld_O=land_ld_O, land_ld_F=land_ld_F,
            min_back_web_m=min_back_web_m,
            back_keepout_dia_m=back_keepout_dia_m,
            back_keepout_wall_m=back_keepout_wall_m,
            face_contoured=face_contoured, exit_land=exit_land, back_channels=back_channels,
            passage_ld_O=passage_ld_O, passage_ld_F=passage_ld_F,
            channel_width_m=channel_width_m, channel_floor=channel_floor,
            r_plate_m=r_plate_m, r_port_m=r_port_m, liner_thickness_m=liner_thickness_m) > 0.0:
        return True
    if D_throat_check > 0.0 and D_chamber_inner > 0.0:
        if D_throat_check > D_chamber_inner * 0.95:
            return True
    if A_chamber_check > 0.0 and A_throat_check > 0.0:
        if (A_throat_check * 1.1) / A_chamber_check > 1.0:
            return True
    return False
 
 
def _impinging_infeasibility_layout_terms(
    *,
    d_jet_O: float,
    d_jet_F: float,
    sp_O: float,
    sp_F: float,
    n_el_O: int,
    n_el_F: int,
    D_chamber_inner: float,
) -> float:
    """Layout infeasibility for unlike doublets: overlap + pitch-circle vs bore.
 
    Uses the same pitch definition as the impinging injector model (``n·spacing/π``),
    not the legacy pintle-era ``(n_O+n_F)·spacing²/face`` proxy.
    """
    score = 0.0
    score += (max(0.0, d_jet_O - sp_O) / (sp_O + 1e-9)) ** 2
    score += (max(0.0, d_jet_F - sp_F) / (sp_F + 1e-9)) ** 2
    if D_chamber_inner > 0.0:
        for n_el, sp in ((n_el_O, sp_O), (n_el_F, sp_F)):
            n_i = max(1, int(n_el))
            s = float(sp)
            if s > 0.0:
                d_pitch = float(n_i) * s / np.pi
                score += max(0.0, d_pitch / D_chamber_inner - 1.0) ** 2
    return float(score)
 
 
def _impinging_infeasibility_flow_capacity_terms(
    *,
    A_lox_flow: float,
    A_fuel_flow: float,
    A_throat_check: float,
    flow_cap: float = 0.95,
) -> float:
    """Effective injector area vs throat — impinging uses Cd×A from diagnostics when available."""
    if A_throat_check <= 0.0:
        return 0.0
    score = 0.0
    if np.isfinite(A_lox_flow):
        score += max(0.0, A_lox_flow / A_throat_check - flow_cap) ** 2
    if np.isfinite(A_fuel_flow):
        score += max(0.0, A_fuel_flow / A_throat_check - flow_cap) ** 2
    return float(score)
 
 
def _merge_runner_eval_into_performance(
    initial_performance: Dict[str, Any],
    eval_results: Dict[str, Any],
) -> None:
    """Copy diagnostics and injector_pressure from runner.evaluate for Layer 1 summaries.
 
    Stored-validation path builds a partial ``initial_performance`` dict; without these,
    momentum_ratio_R / injector ΔP metrics do not propagate to ``final_performance``.
    """
    di = eval_results.get("diagnostics")
    if isinstance(di, dict):
        initial_performance["diagnostics"] = di
    ip = eval_results.get("injector_pressure")
    if isinstance(ip, dict):
        initial_performance["injector_pressure"] = ip
 
 
def _layer1_final_primary_objective_terms(
    final_performance: Dict[str, Any],
    *,
    thrust_deadband_rel: float = 0.02,
    target_thrust: float,
    optimal_of: float,
    target_P_exit: float,
    layer1_exit_pressure_inside_quad_scale: float = 0.0,
    layer1_w_dp: float,
    layer1_w_dp_o: float,
    layer1_w_dp_f: float,
    injector_dp_o_band: Tuple[float, float],
    injector_dp_f_band: Tuple[float, float],
    injector_dp_o_soft_floor: Optional[float] = None,
    layer1_w_dp_o_floor: float = 0.0,
    layer1_w_dp_center: float = 0.0,
    layer1_w_thrust: float = 1.0e4,
    layer1_w_of: float = 1.0e4,
    layer1_w_of_low_mr_scale: float = 1.0,
    layer1_w_of_high_mr_scale: float = 1.0,
) -> Dict[str, float]:
    """Recompute primary scalar penalty contributions (matches inner objective, excluding Cf/length/momentum)."""
    w_thrust = float(layer1_w_thrust)
    w_of = float(layer1_w_of)
    w_of_low = max(1.0, float(layer1_w_of_low_mr_scale))
    w_of_high = max(1.0, float(layer1_w_of_high_mr_scale))
    w_exit = 2.0e2
 
    f_act = float(final_performance.get("F", np.nan))
    thrust_penalty_sq_term = 0.0
    if target_thrust > 0 and np.isfinite(f_act):
        rel_error = abs(f_act - target_thrust) / target_thrust
        deadband = float(thrust_deadband_rel)
        if rel_error > deadband:
            thrust_penalty_sq_term = float((rel_error - deadband) ** 2)
    thrust_contrib = w_thrust * thrust_penalty_sq_term
 
    mr_act = float(final_performance.get("MR", np.nan))
    if optimal_of > 0 and np.isfinite(mr_act):
        of_error = abs(mr_act - optimal_of) / optimal_of
    else:
        of_error = 1.0
    of_sq = float(of_error) ** 2
    if optimal_of > 0 and np.isfinite(mr_act):
        if mr_act < optimal_of:
            of_sq *= w_of_low
        elif mr_act > optimal_of:
            of_sq *= w_of_high
    of_contrib = w_of * of_sq
 
    p_exit_actual = float(final_performance.get("P_exit", np.nan))
    exit_pressure_sq_term = float(
        _layer1_exit_pressure_sq_term(
            p_exit_actual,
            float(target_P_exit),
            deadband_rel=0.05,
            inside_rel_quad_scale=float(layer1_exit_pressure_inside_quad_scale),
        )
    )
    exit_contrib = w_exit * exit_pressure_sq_term
 
    pc = final_performance.get("Pc")
    inj_contrib = 0.0
    if pc is not None and np.isfinite(float(pc)) and float(pc) > 0:
        ro, rf = injector_dp_ratios_from_eval_result(float(pc), final_performance)
        inj_contrib = float(
            injector_dp_ratio_penalty_weighted(
                ro,
                rf,
                layer1_w_dp,
                0.0,
                o_band=injector_dp_o_band,
                f_band=injector_dp_f_band,
                w_dp_o=layer1_w_dp_o,
                w_dp_f=layer1_w_dp_f,
                o_soft_floor=injector_dp_o_soft_floor,
                w_dp_o_floor=layer1_w_dp_o_floor,
                w_dp_center=layer1_w_dp_center,
            )
        )
 
    return {
        "thrust_penalty_contribution": float(thrust_contrib),
        "of_penalty_contribution": float(of_contrib),
        "exit_pressure_penalty_contribution": float(exit_contrib),
        "injector_dp_penalty_contribution": float(inj_contrib),
    }
 
 
def _layer1_apply_chamber_geometry_to_config(
    config: PintleEngineConfig,
    *,
    A_throat: float,
    Lstar: float,
    expansion_ratio: float,
    D_chamber_outer: float,
    max_nozzle_exit: float,
    wall_thickness_m: float,
    requirements=None,
) -> float:
    """Update chamber / nozzle fields from the first four Layer-1 DOFs.
 
    Returns:
        Final expansion ratio after optional exit clipping [–]
    """
    from engine.pipeline.config_schemas import ensure_chamber_geometry
 
    V_chamber = Lstar * A_throat
    D_chamber_inner = D_chamber_outer - wall_thickness_m
    if D_chamber_inner <= 0:
        D_chamber_inner = max(D_chamber_outer * 0.3, 0.01)
    A_chamber = np.pi * (D_chamber_inner / 2) ** 2
    R_throat = np.sqrt(max(0, A_throat / np.pi))
 
    if A_throat > 0 and A_chamber > 0:
        contraction_ratio = A_chamber / A_throat
    else:
        contraction_ratio = 10.0
    if requirements is None:
        requirements = getattr(config, "design_requirements", None)
    theta_contraction = _layer1_contraction_theta(requirements)
    # The cone runs to the 1.5 R_t entrance-arc tangency, not to R_t; see
    # _layer1_chamber_lengths, which the objective scores with too.
    _lens = _layer1_chamber_lengths(A_throat, Lstar, D_chamber_inner, theta_contraction)
    L_chamber = _lens["length"]
    L_cylindrical = _lens["length_cylindrical"]
    L_contraction = _lens["length_contraction"]
 
    if config.chamber_geometry is None:
        cg = ensure_chamber_geometry(config)
    else:
        cg = config.chamber_geometry
 
    A_exit = A_throat * expansion_ratio
    if A_exit < 0:
        A_exit = A_throat * 10.0
    D_exit = np.sqrt(max(0, 4 * A_exit / np.pi))
    exp_ratio_out = expansion_ratio
    if D_exit > max_nozzle_exit:
        D_exit = max_nozzle_exit
        A_exit = np.pi * (D_exit / 2) ** 2
        exp_ratio_out = A_exit / A_throat if A_throat > 0 else 10.0
 
    cg.A_throat = A_throat
    cg.volume = V_chamber
    cg.Lstar = Lstar
    cg.length = L_chamber
    # Write the sub-lengths too. Only cg.length was written, so length_cylindrical and
    # length_contraction kept whatever the template file happened to carry -- on the shipped
    # ethalox config, 121.0 mm and 45.1 mm against a real 191.1 / 39.1. That is why the two
    # L/D code paths disagreed (L_cylindrical + L_contraction = 166.1 mm here vs cg.length =
    # 230.2 mm at the config-path gate), and why the contraction half-angle appeared to have
    # no effect: the numbers it changes were computed and then thrown away.
    cg.length_cylindrical = float(L_cylindrical)
    cg.length_contraction = float(L_contraction)
    if "length_face_to_throat" in getattr(type(cg), "model_fields", {}):
        cg.length_face_to_throat = float(_lens["face_to_throat"])
    cg.chamber_diameter = D_chamber_inner
    cg.A_exit = A_exit
    cg.exit_diameter = D_exit
    cg.expansion_ratio = exp_ratio_out
 
    if config.chamber is not None:
        config.chamber.A_throat = A_throat
        config.chamber.volume = V_chamber
        config.chamber.Lstar = Lstar
        config.chamber.length = L_chamber
        setattr(config.chamber, 'chamber_inner_diameter', D_chamber_inner)
        if hasattr(config.chamber, 'contraction_ratio'):
            config.chamber.contraction_ratio = contraction_ratio
        if hasattr(config.chamber, 'A_chamber'):
            config.chamber.A_chamber = A_chamber
    if config.nozzle is not None:
        config.nozzle.A_throat = A_throat
        config.nozzle.A_exit = A_exit
        config.nozzle.expansion_ratio = exp_ratio_out
        if hasattr(config.nozzle, 'exit_diameter'):
            config.nozzle.exit_diameter = D_exit
 
    if hasattr(config.combustion, 'cea'):
        config.combustion.cea.expansion_ratio = exp_ratio_out
 
    return float(exp_ratio_out)
 
 
# ============================================================================
# Derived design variables (solved, not searched)
# ============================================================================
# Two of the Layer-1 DOFs are not free choices -- they are determined by the
# requirements the user already stated, so searching them wastes dimensionality
# and lets CMA-ES sit on a wrong value that a penalty term then has to fight:
#
#   expansion_ratio  -- fixed by "expand to ambient". Closed-form isentropic
#                       inversion of Pc/Pe; no iteration, exact.
#   A_throat         -- fixed by the thrust requirement. Not closed form (the
#                       chamber solve gives Pc*At = mdot*c*, so thrust is set by
#                       mdot, not directly by At), but F is smooth and monotonic
#                       in At -- bigger At lowers Pc, which raises injector dP,
#                       which raises mdot -- with dlnF/dlnAt ~ 0.3. A log-log
#                       secant lands it in ~3 evaluations.
#
# Both are opt-out (``layer1_derive_expansion_ratio`` /
# ``layer1_derive_throat_from_thrust``) because this is a design suite: a user
# sizing a fixed-throat hardware set, or deliberately running over/under
# expanded, must still be able to search them.
 
_DERIVE_AT_SLOPE_DEFAULT = 0.35   # dlnF/dlnAt, measured on ethalox impinging
_DERIVE_AT_SLOPE_MIN = 0.12
_DERIVE_AT_SLOPE_MAX = 1.20
 
 
def _layer1_stamp_design_point(config, performance, logger=None) -> None:
    """Write the ACHIEVED operating point into ``chamber_geometry.design_*``.
 
    ``design_MR`` / ``design_pressure`` / ``design_thrust`` are supposed to describe the design
    the config represents. Nothing ever wrote them: `config_schemas` builds them with
    ``getattr(chamber, 'design_MR', 2.55)``, so an optimised config carried whatever the template
    started with. Observed on a real emitted design -- MR 2.55 / 350 psi / 7000 N stamped on an
    engine actually solved at O/F ~1.68 / 420 psi / 7200 N.
 
    That is not cosmetic: ``backend/routers/geometry.py`` reads ``design_MR`` and feeds it
    straight into ``solve_chamber_geometry_with_cea``, so the Chamber Geometry tab drew the
    contour at the stale mixture ratio -- and 2.55 sits OUTSIDE the shipped CEA cache range
    (``MR_range: [1.0, 2.5]``), i.e. extrapolating past the table edge.
 
    Warns rather than raises when the achieved MR falls outside the cache range: the design is
    still real, but anything reading design_MR against that cache is extrapolating.
    """
    cg = getattr(config, "chamber_geometry", None)
    if cg is None or not isinstance(performance, dict):
        return
 
    def _finite_pos(value):
        try:
            v = float(value)
        except (TypeError, ValueError):
            return None
        return v if (np.isfinite(v) and v > 0) else None
 
    mr = _finite_pos(performance.get("MR"))
    pc = _finite_pos(performance.get("Pc"))
    thrust = _finite_pos(performance.get("F"))
 
    if mr is not None:
        cg.design_MR = mr
    if pc is not None:
        cg.design_pressure = pc
    if thrust is not None:
        cg.design_thrust = thrust
 
    # Keep the legacy mirror in step -- some readers still fall back to config.chamber.
    legacy = getattr(config, "chamber", None)
    if legacy is not None:
        if mr is not None and hasattr(legacy, "design_MR"):
            legacy.design_MR = mr
        if pc is not None and hasattr(legacy, "design_pressure"):
            legacy.design_pressure = pc
        if thrust is not None and hasattr(legacy, "design_thrust"):
            legacy.design_thrust = thrust
 
    if mr is None or logger is None:
        return
    try:
        mr_range = config.combustion.cea.MR_range
        lo, hi = float(mr_range[0]), float(mr_range[1])
    except (AttributeError, TypeError, ValueError, IndexError):
        return
    if not (lo <= mr <= hi):
        logger.warning(
            "design_MR %.4f is outside the CEA cache MR_range [%.2f, %.2f]; anything reading "
            "it against that cache is extrapolating past the table edge.", mr, lo, hi
        )
 
 
 
def _layer1_warn_stale_pressure_curves(config, logger=None, tol_psi: float = 1.0) -> None:
    """Flag Layer-2 pressure curves that no longer match the tank pressures Layer 1 just set.
 
    The initial tank pressure exists twice, owned by different layers and never reconciled:
    Layer 1 writes ``lox_tank/fuel_tank.initial_pressure_psi``; Layer 2 writes
    ``pressure_curves.initial_lox/fuel_pressure_pa``. Re-running Layer 1 moves the tanks and
    silently leaves the curves describing the previous design -- observed 11.3 psi out on the
    LOX side and 24.9 psi on the fuel side of a real emitted config.
 
    This matters beyond EngineDesign. Tank pressure is the UPSTREAM BOUNDARY CONDITION for the
    feed-system twin (docs/adr/0001), which EngineDesign's optimizer will import directly for
    Layer X. Two disagreeing values for one boundary condition is exactly the kind of thing that
    silently poisons a twin, so say so loudly rather than letting it cross the boundary.
 
    Detection only -- which layer should win is a design call, not something to guess here.
    """
    if logger is None:
        return
    curves = getattr(config, "pressure_curves", None)
    if curves is None:
        return
    PSI = 6894.76
    for tank_attr, curve_attr, label in (
        ("lox_tank", "initial_lox_pressure_pa", "LOX"),
        ("fuel_tank", "initial_fuel_pressure_pa", "fuel"),
    ):
        tank = getattr(config, tank_attr, None)
        if tank is None:
            continue
        try:
            tank_psi = float(getattr(tank, "initial_pressure_psi", float("nan")))
            curve_psi = float(getattr(curves, curve_attr, float("nan"))) / PSI
        except (TypeError, ValueError):
            continue
        if not (np.isfinite(tank_psi) and np.isfinite(curve_psi)):
            continue
        if abs(tank_psi - curve_psi) > tol_psi:
            logger.warning(
                "%s tank pressure disagrees with the Layer-2 pressure curve: tank %.1f psi vs "
                "curve start %.1f psi (%.1f psi apart). The curves predate this Layer 1 run; "
                "re-run Layer 2 before trusting them or anything downstream of them.",
                label, tank_psi, curve_psi, abs(tank_psi - curve_psi),
            )
 
 
def _layer1_eps_for_exit_pressure(Pc_Pa: float, gamma: float, Pe_Pa: float):
    """Expansion ratio that puts the exit plane exactly at ``Pe_Pa``.
 
    Standard isentropic area-ratio relation -- solve the exit Mach number from
    the pressure ratio, then evaluate A/A*. Returns ``None`` when the inputs
    cannot describe a supersonic nozzle.
    """
    try:
        Pc = float(Pc_Pa)
        Pe = float(Pe_Pa)
        g = float(gamma)
    except (TypeError, ValueError):
        return None
    if not (np.isfinite(Pc) and np.isfinite(Pe) and np.isfinite(g)):
        return None
    if Pc <= 0.0 or Pe <= 0.0 or Pc <= Pe or not (1.0 < g < 2.0):
        return None
 
    M_sq = (2.0 / (g - 1.0)) * ((Pc / Pe) ** ((g - 1.0) / g) - 1.0)
    if not np.isfinite(M_sq) or M_sq <= 1.0:
        return None
    M = float(np.sqrt(M_sq))
    eps = (1.0 / M) * (
        (2.0 / (g + 1.0)) * (1.0 + 0.5 * (g - 1.0) * M_sq)
    ) ** ((g + 1.0) / (2.0 * (g - 1.0)))
    if not np.isfinite(eps) or eps <= 1.0:
        return None
    return float(eps)
 
 
def _layer1_matched_eps(result: Any, Pa: float, cea_cache: Any = None,
                       eps_guess: Optional[float] = None) -> Optional[float]:
    """Expansion ratio that expands to ``Pa`` at this result's Pc and O/F.
 
    The CEA table's own exit pressure (shifting equilibrium, what the thrust model
    integrates) when a 3-D table is at hand; the chamber-gamma isentrope otherwise, which
    over-expands (Pe/Pa 0.93 at the 6.5 kN point).
    """
    if not isinstance(result, dict):
        return None
    eps = _layer1_eps_for_exit_pressure_cea(
        cea_cache, result.get("MR"), result.get("Pc"), Pa, eps_guess)
    if eps is not None:
        return eps
    return _layer1_eps_for_exit_pressure(result.get("Pc"), result.get("gamma"), Pa)
 
 
def _layer1_derive_matched_tank_pressure(x: np.ndarray, constants: dict) -> None:
    """Slave the fuel tank pressure to the LOX tank pressure when they must match.
 
    "Match propellant tank pressures" is a statement that the two are ONE quantity, not two
    that ought to end up nearby. Searching them separately and then penalising the gap makes
    the optimizer pay, forever, for a degree of freedom it was told not to use: at
    W_TANK_EQUAL = 300 it simply accepted a 13 psi gap because closing it cost more Isp than
    the penalty; at 30000 it got to 10 psi and carried a large residual for the remainder.
    Collapsing them removes the gap by construction -- the penalty goes to zero, the residual
    stops reporting a violation that is not a design flaw, and CMA gets one dimension back.
 
    Applies to both injector families (the pressure indices come from ``constants``).
    Mutates ``x`` in place so every downstream reader sees the same pair.
    """
    if not bool(constants.get("layer1_lock_tank_pressures", False)):
        return
    io_ = int(constants.get("idx_P_O", 8))
    if_ = int(constants.get("idx_P_F", 9))
    if not (0 <= io_ < len(x) and 0 <= if_ < len(x)):
        return
    try:
        p_o = float(x[io_])
    except (TypeError, ValueError):
        return
    if not (np.isfinite(p_o) and p_o > 0):
        return
    # The fuel tank may carry a different cap; clamp rather than emit an out-of-range value.
    lo = float(constants.get("lock_P_F_min", 0.0))
    hi = float(constants.get("lock_P_F_max", np.inf))
    x[if_] = float(np.clip(p_o, lo, hi)) if hi > lo else p_o
 
 
def _layer1_derive_fuel_spacing(x: np.ndarray, constants: dict) -> None:
    """Solve the fuel-ring hole pitch so the jets meet at exactly the requested standoff.
 
    The user states ONE number -- how many jet diameters off the face the doublet should
    collide (``layer1_impingement_Ld_target``) -- and that closes the geometry algebraically.
    There is nothing to search and nothing to negotiate::
 
        L_imp = dr / (tan(theta_O) + tan(theta_F))      want L_imp = k * d_avg
        dr    = n * |s_F - s_O| / (2*pi)                 (dr = half the pitch-circle gap)
 
        =>  |s_F - s_O| = 2*pi * k * d_avg * (tan(theta_O) + tan(theta_F)) / n
 
    One equation, one unknown. ``s_O`` (the LOX / inner ring) stays the free variable because
    it is the packing-constrained one -- the inner ring has the least circumference and LOX
    carries the higher volumetric flow -- and ``s_F`` follows from it. That removes a whole
    CMA dimension AND makes L/d exact by construction instead of a penalty the search haggles
    with.
 
    Mutates ``x[10]`` in place so every downstream reader sees the solved value.
 
    If the solved fuel ring will not fit the bore the value clamps to its bound; L/d then
    misses and the ordinary ring-geometry penalty reports it, rather than the derivation
    quietly producing an unbuildable ring.
    """
    if not bool(constants.get("layer1_derive_impingement_spacing", True)):
        return
    if constants.get("injector_type") != "impinging" or len(x) < 11:
        return
    try:
        # Snap the doublet count here and write it back. The consumers disagree about how to
        # integerise it -- the worker path truncates (int(x[4])), apply_x_to_config rounds --
        # and the derivation divides by n, so a half-count of disagreement puts the solved
        # standoff off target. Rounding once, in place, makes every reader use the same n.
        n = float(max(1, int(round(float(x[4])))))
        x[4] = n
        d_avg = 0.5 * (float(x[5]) + float(x[8]))
        tan_sum = float(np.tan(np.deg2rad(float(x[6]))) + np.tan(np.deg2rad(float(x[9]))))
        s_O = float(x[7])
    except (TypeError, ValueError):
        return
    k = float(constants.get("layer1_impingement_Ld_target", IMPINGEMENT_LD_TARGET_DEFAULT))
    if not (np.isfinite(d_avg) and d_avg > 0 and np.isfinite(tan_sum) and tan_sum > 1e-9
            and np.isfinite(s_O) and s_O > 0 and k > 0):
        return
 
    delta_s = 2.0 * np.pi * k * d_avg * tan_sum / n
    if not np.isfinite(delta_s) or delta_s <= 0:
        return
    # Fuel ring outboard => larger pitch circle => larger hole pitch for the same count.
    outboard = bool(constants.get("layer1_ring_order_fuel_outboard", True))
    s_F = s_O + delta_s if outboard else max(1e-6, s_O - delta_s)
 
    lo = float(constants.get("derive_spacing_F_min", 0.0))
    hi = float(constants.get("derive_spacing_F_max", np.inf))
    if hi > lo:
        s_F = float(np.clip(s_F, lo, hi))
    x[10] = float(s_F)
 
 
def _layer1_rebuild_final_config(
    x_best: np.ndarray,
    config_base: PintleEngineConfig,
    constants: dict,
    logger=None,
    diag: Optional[dict] = None,
) -> Optional[Tuple[PintleEngineConfig, np.ndarray, dict]]:
    """Rebuild the emitted design from the winning vector through the WORKER pipeline.
 
    Finalisation used to stitch the design together from several sources -- geometry from
    ``best_config`` / ``last_eval_config``, tank pressures from whichever of
    ``best_config_x`` / ``last_eval_config_x`` / ``best_x`` was populated. Those need not
    describe the same candidate, and with the tank lock on they did not: the throat was
    solved for one pair of pressures and shipped with another, so the reported engine
    overshot thrust by 4-6% and, re-evaluated as written, did not solve at all
    ("Supply < Demand at all Pc").
 
    This does exactly what ``_eval_candidate`` does, once, on the winner: apply x (which
    locks the tanks and solves the fuel ring pitch), evaluate, solve the throat and expansion
    ratio against THOSE pressures to convergence, and hand back a config whose every field
    came from one vector. Returns None if the winner cannot be evaluated, in which case the
    caller falls back to the old snapshot path.
    """
    try:
        x = np.asarray(x_best, dtype=float).copy()
        config = copy.deepcopy(config_base)
        _apply_x_to_worker_config_inplace(x, config, constants)
        io_ = int(constants.get("idx_P_O", 8))
        if_ = int(constants.get("idx_P_F", 9))
        P_O_pa = float(x[io_]) * 6894.757293168
        P_F_pa = float(x[if_]) * 6894.757293168
        # Evaluate in the thermal state the WORKERS scored and the EMITTED config carries --
        # the user's own flags, untouched. Solving thermal-OFF and shipping thermal-ON is not
        # a subtlety: the liner is 0.5 in per side, so disabling it grows the bore by a full
        # inch (OD-1.5in vs OD-0.5in). A throat solved for one chamber cannot bracket a Pc in
        # the other, and the emitted design then failed to evaluate at all ("Supply < Demand
        # at all Pc") on a run that reported F = 7200 N.
        _runner_cfg = copy.deepcopy(config)
        # A FRESH runner on every evaluation. The solve mutates the config in place; a runner
        # built once could carry anything derived at construction, in which case the solve
        # "converges" against a stale engine and validation -- which always builds fresh --
        # sees a different one. On a knife-edge design (thrust barely reachable under the
        # momentum ban) that was enough to flip the same seed between exact and a 3-14% tank
        # boost from run to run. Finalisation runs once, so the rebuild cost is irrelevant.
        _pamb = float(constants.get("P_ambient", 101325.0))
 
        def _ev():
            try:
                return PintleEngineRunner(copy.deepcopy(_runner_cfg)).evaluate(
                    float(x[io_]) * 6894.757293168, float(x[if_]) * 6894.757293168,
                    P_ambient=_pamb, silent=True)
            except Exception:
                return None
 
        class _CfgProxy:  # what _layer1_solve_derived_geometry writes geometry onto
            config = _runner_cfg
        runner = _CfgProxy()
 
        if diag is not None:
            diag["x_in_tanks"] = [float(x[io_]), float(x[if_])]; diag["x_in_At_mm2"] = float(x[0]) * 1e6
        first = None
        _at_hi = float(constants.get("derive_At_max", np.inf))
        _prev = 1.0
        for _grow in (1.0, 1.3, 1.7, 2.2):
            if _grow != 1.0:
                # Same recovery the worker uses: "Supply < Demand" means the throat is too
                # small to bracket a Pc for this injector -- grow it and let the solve refine.
                x[0] = float(min(x[0] * (_grow / _prev), _at_hi))
                _layer1_apply_chamber_geometry_to_config(
                    _runner_cfg, A_throat=float(x[0]), Lstar=float(x[1]), expansion_ratio=float(x[2]),
                    D_chamber_outer=_quantize_chamber_od_m(
                        float(x[3]), constants.get("layer1_chamber_od_increment_in", 0.0),
                        wall_m=float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M)),
                        snap_target=constants.get("layer1_chamber_od_snap_target", "outer")),
                    max_nozzle_exit=float(constants.get("max_nozzle_exit", 1.0)),
                    wall_thickness_m=float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M)))
            _prev = _grow
            first = _ev()
            if isinstance(first, dict):
                if _grow != 1.0 and diag is not None: diag["first_eval_grew_At"] = _grow
                break
            if not bool(constants.get("layer1_derive_throat_from_thrust", True)):
                break
        if not isinstance(first, dict):
            if diag is not None: diag["fail"] = "first_eval"
            if logger is not None:
                logger.warning("Final rebuild: first evaluate() of the winner failed at tanks %.1f/%.1f psi",
                               float(x[io_]), float(x[if_]))
            return None
        if diag is not None:
            diag["first_F"] = float(first.get("F", float("nan"))); diag["first_Pc_psi"] = float(first.get("Pc", 0)) / 6894.757293168
        if logger is not None:
            logger.info("Final rebuild: winner evaluates F=%.1f Pc=%.1f before solve",
                        float(first.get("F", float("nan"))), float(first.get("Pc", float("nan"))) / 6894.757293168)
        c = dict(constants)
        c["layer1_derive_max_iters"] = max(14, int(c.get("layer1_derive_max_iters", 2)))
        c["layer1_derive_thrust_tol_rel"] = 1.0e-4
        # Solve on the runner's config (which evaluate() reads), then mirror onto ``config``.
        x_first = x.copy()
        try:
            from engine.pipeline.cea_cache import CEACache
            _rb_cea = CEACache(_runner_cfg.combustion.cea)
        except Exception:
            _rb_cea = None
        result = _layer1_solve_derived_geometry(x, runner.config, c, _ev, first, cea_cache=_rb_cea)
        if not isinstance(result, dict):
            return None
        # eps/thrust POLISH. The solve loop updates eps and A_throat from the SAME result and
        # then evaluates, so eps is always exact for the PREVIOUS Pc -- it ends one step
        # behind (measured: eps 5.5558 shipped where 5.5848 was exact at the final Pc, so the
        # exit plane sat at 13.76 psi instead of 13.64). Crucially Pc does NOT depend on eps,
        # so the system is triangular: set eps exactly from the current Pc, re-evaluate to get
        # the true thrust, then take one secant step on A_throat -- and repeat. Cheap here
        # because finalisation runs once; the per-candidate solve keeps its 2-iteration form.
        _Ft_pol = float(constants.get("target_thrust", 0.0) or 0.0)
        _tol_pol = 2.0e-4
 
        def _write_geom():
            """Push x's geometry onto the config the evaluator reads."""
            _layer1_apply_chamber_geometry_to_config(
                _runner_cfg, A_throat=float(x[0]), Lstar=float(x[1]), expansion_ratio=float(x[2]),
                D_chamber_outer=_quantize_chamber_od_m(
                    float(x[3]), constants.get("layer1_chamber_od_increment_in", 0.0),
                    wall_m=float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M)),
                    snap_target=constants.get("layer1_chamber_od_snap_target", "outer")),
                max_nozzle_exit=float(constants.get("max_nozzle_exit", 1.0)),
                wall_thickness_m=float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M)))
 
        # Everything the polish may touch, so a failed step can be undone COMPLETELY -- x and
        # the config together. Restoring x alone left the config on the geometry that had just
        # failed, and the consistency check below then rejected the whole rebuild
        # ("Supply < Demand"), throwing away a polish that had reached 7215.4 N.
        _pol_x0 = x.copy()
        _pol_result0 = result
        for _ in range(6):
            _eps_now = _layer1_matched_eps(
                result, float(c.get("P_ambient", 101325.0)), _rb_cea, float(x[2]))
            _moved = False
            if _eps_now is not None:
                _eps_now = float(np.clip(_eps_now, float(c.get("derive_eps_min", 1.5)),
                                         float(c.get("derive_eps_max", 100.0))))
                if abs(_eps_now - float(x[2])) > 1e-6 * max(1.0, abs(float(x[2]))):
                    x[2] = _eps_now; _moved = True
            if _moved:
                _eps_prev = float(_pol_x0[2]) if False else None
                _write_geom()
                _r2 = _ev()
                if isinstance(_r2, dict):
                    result = _r2
                else:
                    x[:] = _pol_x0; result = _pol_result0; _write_geom()
                    break
            _Fn = float(result.get("F", float("nan")))
            if not (_Ft_pol > 0 and np.isfinite(_Fn) and _Fn > 0):
                break
            if abs(_Fn / _Ft_pol - 1.0) <= _tol_pol and not _moved:
                break
            _at_new = float(np.clip(
                float(x[0]) * (_Ft_pol / _Fn) ** (1.0 / _DERIVE_AT_SLOPE_DEFAULT),
                float(c.get("derive_At_min", 1e-6)), float(c.get("derive_At_max", 1.0))))
            if abs(_at_new - float(x[0])) <= 1e-6 * float(x[0]):
                break
            _x_prev = x.copy(); _res_prev = result
            x[0] = _at_new
            _write_geom()
            _r3 = _ev()
            if isinstance(_r3, dict):
                result = _r3
                _pol_x0 = x.copy(); _pol_result0 = result   # last known-good polished state
            else:
                x[:] = _x_prev; result = _res_prev; _write_geom()
                break
        if diag is not None:
            diag["polish_eps"] = float(x[2]); diag["polish_F"] = float(result.get("F", float("nan")))
        # Never ship a thrust WORSE than the pool's winner we started from. The solve is a
        # local secant on a possibly knife-edge design; when it misbehaves (measured: +38%
        # runaway, +2% ratchet) the honest output is the winner itself.
        _Ft = float(constants.get("target_thrust", 0.0) or 0.0)
        if _Ft > 0:
            _e_first = abs(float(first.get("F", np.inf)) - _Ft)
            _e_solved = abs(float(result.get("F", np.inf)) - _Ft)
            if not (_e_solved <= _e_first + 1e-9):
                x[:] = x_first
                _layer1_apply_chamber_geometry_to_config(
                    _runner_cfg, A_throat=float(x[0]), Lstar=float(x[1]), expansion_ratio=float(x[2]),
                    D_chamber_outer=_quantize_chamber_od_m(
                        float(x[3]), constants.get("layer1_chamber_od_increment_in", 0.0),
                        wall_m=float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M)),
                        snap_target=constants.get("layer1_chamber_od_snap_target", "outer")),
                    max_nozzle_exit=float(constants.get("max_nozzle_exit", 1.0)),
                    wall_thickness_m=float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M)))
                result = first
                if diag is not None: diag["reverted_to_first"] = True
                if logger is not None:
                    logger.warning("Final rebuild: solve made thrust worse (%.1f -> %.1f N vs target %.0f); "
                                   "keeping the pool winner", float(first.get("F")), _e_solved + _Ft, _Ft)
        # Return the config the solve actually converged on. Re-deriving ``config`` from x
        # did not reproduce it (measured: solve F=7225, returned config "Supply < Demand").
        # No thermal-flag surgery: the solve ran in the user's own state, so the returned
        # config is already in it.
        config = copy.deepcopy(_runner_cfg)
        if diag is not None:
            diag["x_solved"] = [float(v) for v in x]
        # Independent check: the returned config, exactly as it will be handed out.
        _chk = copy.deepcopy(config)
        try:
            _fresh = PintleEngineRunner(_chk).evaluate(
                float(x[io_]) * 6894.757293168, float(x[if_]) * 6894.757293168,
                P_ambient=_pamb, silent=True)
            _dF = abs(float(_fresh["F"]) - float(result["F"])) / max(1.0, float(result["F"]))
            if diag is not None:
                if result.get("_derive_tank_fallback") is not None:
                    diag["tank_fallback"] = result.get("_derive_tank_fallback")
                diag["iters"] = result.get("_derive_iters")
                diag["restored_after_failed_step"] = bool(result.get("_derive_restored_after_failed_step", False))
                diag.update({"solved_F": float(result["F"]), "fresh_F": float(_fresh["F"]),
                             "solved_Pc_psi": float(result["Pc"]) / 6894.757293168,
                             "solved_At_mm2": float(x[0]) * 1e6, "solved_tanks": [float(x[io_]), float(x[if_])],
                             "dF_rel": float(_dF)})
            if logger is not None:
                logger.info("Final rebuild: solved F=%.1f vs fresh-runner F=%.1f (%.3f%%)",
                            float(result["F"]), float(_fresh["F"]), 100 * _dF)
            if _dF > 1e-3 and logger is not None:
                logger.warning("Final rebuild: solved/fresh thrust disagree by %.2f%% -- returned "
                               "config is not what the solve saw", 100 * _dF)
        except Exception as _e:
            if diag is not None: diag["fail"] = "fresh_eval: " + str(_e)[:80]
            if logger is not None:
                logger.warning("Final rebuild: returned config FAILS a fresh evaluate: %s", str(_e)[:90])
            return None
        if logger is not None:
            logger.info(
                "Final design rebuilt from the winning vector: F=%.1f N, Pc=%.1f psi, "
                "A_throat=%.1f mm2, tanks %.1f/%.1f psi",
                float(result.get("F", float("nan"))),
                float(result.get("Pc", float("nan"))) / 6894.757293168,
                float(x[0]) * 1e6, float(x[io_]), float(x[if_]),
            )
        return config, x, result
    except Exception as exc:
        if logger is not None:
            logger.warning("Final rebuild from winning vector failed: %s", exc)
        return None
 
 
def _layer1_finalize_derived_geometry(
    config: PintleEngineConfig,
    P_O_pa: float,
    P_F_pa: float,
    constants: dict,
    logger=None,
) -> None:
    """Re-solve the derived DOFs against the tank pressures the final config actually carries.
 
    Finalisation assembles the emitted design from more than one source: the geometry comes
    from ``best_config``/``last_eval_config`` while the tank pressures are taken from a
    separate ``x`` (see the fallback chain below it). Those need not come from the same
    candidate, and when they do not, the throat is solved for one pair of tank pressures and
    then shipped with another -- the reported engine overshot thrust by 4-6% and, in the worst
    case, did not solve at all ("Supply < Demand at all Pc") when re-evaluated as written.
 
    Solving once more here closes the loop: whatever pressures ended up on the config, the
    throat and expansion ratio are the ones that hit the target for THOSE pressures.
    """
    if not (bool(constants.get("layer1_derive_throat_from_thrust", True))
            or bool(constants.get("layer1_derive_expansion_ratio", True))):
        return
    try:
        from engine.pipeline.config_schemas import ensure_chamber_geometry
        cg = ensure_chamber_geometry(config)
        At = float(cg.A_throat or 0.0)
        Lstar = float(cg.Lstar or 0.0)
        eps = float(cg.expansion_ratio or 0.0)
        wall = float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M))
        D_outer = float(cg.chamber_diameter or 0.0) + wall
        if not (At > 0 and Lstar > 0 and eps > 0 and D_outer > 0):
            return
        runner = PintleEngineRunner(copy.deepcopy(config))
 
        def _ev():
            try:
                return runner.evaluate(P_O_pa, P_F_pa,
                                       P_ambient=float(constants.get("P_ambient", 101325.0)),
                                       silent=True)
            except Exception:
                return None
 
        first = _ev()
        if not isinstance(first, dict):
            return
        x = np.array([At, Lstar, eps, D_outer], dtype=float)
        c = dict(constants)
        # Converge properly here: this runs once, not per candidate.
        c["layer1_derive_max_iters"] = max(6, int(c.get("layer1_derive_max_iters", 2)))
        c["layer1_derive_thrust_tol_rel"] = 1.0e-4
        _layer1_solve_derived_geometry(x, runner.config, c, _ev, first,
                                       cea_cache=getattr(runner, "cea_cache", None))
        if abs(float(x[0]) - At) <= 1e-12 and abs(float(x[2]) - eps) <= 1e-12:
            return
        _layer1_apply_chamber_geometry_to_config(
            config,
            A_throat=float(x[0]),
            Lstar=float(x[1]),
            expansion_ratio=float(x[2]),
            D_chamber_outer=_quantize_chamber_od_m(
                float(x[3]),
                constants.get("layer1_chamber_od_increment_in", 0.0),
                wall_m=wall,
                snap_target=constants.get("layer1_chamber_od_snap_target", "outer"),
            ),
            max_nozzle_exit=float(constants.get("max_nozzle_exit", 1.0)),
            wall_thickness_m=wall,
        )
        if logger is not None:
            logger.info(
                "Final design re-solved against its own tank pressures: "
                "A_throat %.1f -> %.1f mm2, eps %.3f -> %.3f",
                At * 1e6, float(x[0]) * 1e6, eps, float(x[2]),
            )
    except Exception as exc:  # never let finalisation die here
        if logger is not None:
            logger.warning("Final derived-geometry re-solve skipped: %s", exc)
 
 
def _layer1_solve_derived_geometry(
    x: np.ndarray,
    config: PintleEngineConfig,
    constants: dict,
    evaluate: Callable[[], Optional[dict]],
    result: Optional[dict],
    cea_cache: Any = None,
) -> Optional[dict]:
    """Replace searched ``A_throat`` / ``expansion_ratio`` with solved values.
 
    Mutates ``x[0]`` / ``x[2]`` and ``config`` in place so that the objective
    terms, the cached design and the finalised config all see the same solved
    geometry that was actually evaluated. Returns the evaluation result for the
    solved geometry (or the input ``result`` when nothing was derived).
 
    Falling back is always safe: if the requirement is unreachable inside the
    configured bounds the value clamps to the bound and the ordinary thrust /
    exit-pressure penalty carries the remaining residual, which the
    infeasibility gradient can still descend.
    """
    derive_eps = bool(constants.get("layer1_derive_expansion_ratio", True))
    derive_at = bool(constants.get("layer1_derive_throat_from_thrust", True))
    # Fuel jet diameter from the O/F target. Only meaningful when the tanks are locked: then
    # dP_O ~= dP_F and O/F = (Cd_O*A_O*sqrt(rho_O)) / (Cd_F*A_F*sqrt(rho_F)) is a pure area
    # ratio, so mdot_F ~ d_F^2 at fixed dP and one secant step in d_F lands MR on target.
    # Unlocked, differential tank pressure also sets O/F and the derivation would fight the
    # optimizer for it.
    derive_df = (bool(constants.get("layer1_derive_fuel_jet_from_of", False))
                 and constants.get("injector_type") == "impinging" and len(x) > 8)
    # Locked tank pressure from the injector dP/Pc target: P_tank = Pc*(1+r) + dP_feed.
    # With the tanks one variable, this closes the last pressure DOF and makes the dP/Pc
    # band exact by construction -- which is what lets O/F reach its target: at the correct
    # area ratio the throat grows, Pc falls, and a tank pressure left near the cap pushes
    # dP/Pc to ~0.47 against a 0.30 ceiling (measured; obj 4.3e6). Tanks that follow Pc down
    # remove that wall.
    derive_pt = (bool(constants.get("layer1_derive_tank_from_dp_ratio", False))
                 and bool(constants.get("layer1_lock_tank_pressures", False)))
    if not (derive_eps or derive_at or derive_df or derive_pt):
        return result
    if not isinstance(result, dict):
        return result
 
    Pa = float(constants.get("P_ambient", 0.0) or 0.0)
    F_target = float(constants.get("target_thrust", 0.0) or 0.0)
    eps_lo = float(constants.get("derive_eps_min", 1.5))
    eps_hi = float(constants.get("derive_eps_max", 100.0))
    at_lo = float(constants.get("derive_At_min", 1e-6))
    at_hi = float(constants.get("derive_At_max", 1.0))
    max_iters = int(constants.get("layer1_derive_max_iters", 4))
    thrust_tol = float(constants.get("layer1_derive_thrust_tol_rel", 2.0e-4))
 
    if derive_at and not (F_target > 0.0 and at_hi > at_lo):
        derive_at = False
    MR_target = float(constants.get("optimal_of", 0.0) or 0.0)
    df_lo = float(constants.get("derive_dF_min", 1e-5))
    df_hi = float(constants.get("derive_dF_max", 1.0))
    of_tol = float(constants.get("layer1_derive_of_tol_rel", 1.0e-3))
    if derive_df and not (MR_target > 0.0 and df_hi > df_lo):
        derive_df = False
    io_ = int(constants.get("idx_P_O", 8)); if_ = int(constants.get("idx_P_F", 9))
    pt_lo = float(constants.get("lock_P_T_min", 0.0)); pt_hi = float(constants.get("lock_P_T_max", np.inf))
    r_dp = float(constants.get("layer1_dp_ratio_target", 0.25))
    if derive_pt and not (0 <= io_ < len(x) and 0 <= if_ < len(x) and pt_hi > pt_lo and r_dp > 0):
        derive_pt = False
    if derive_eps and not (Pa > 0.0 and eps_hi > eps_lo):
        derive_eps = False
    if not (derive_eps or derive_at or derive_df or derive_pt):
        return result
 
    slope = _DERIVE_AT_SLOPE_DEFAULT
    prev_at = None
    prev_F = None
    max_nozzle_exit = float(constants.get("max_nozzle_exit", 1.0))
    wall = float(constants.get("TOTAL_WALL_THICKNESS_M", TOTAL_WALL_THICKNESS_M))
    od_inc = constants.get("layer1_chamber_od_increment_in", 0.0)
    od_snap_target = constants.get("layer1_chamber_od_snap_target", "outer")
 
    _iters_used = 0
    for _ in range(max(1, max_iters)):
        _iters_used += 1
        changed = False
        # Snapshot the DOFs this step may move. If the re-evaluation below fails, the loop
        # keeps the previous good ``result`` -- so x and the config must be put back to the
        # state that result describes. Without this, a failed last step left x/config on
        # the geometry that had just FAILED while returning a result from the one before:
        # the finalised design then would not evaluate ("Supply < Demand", validation boosted
        # tanks 3-14%), and in the worker path an unbuildable vector could be recorded as the
        # winner (measured: rebuild fresh-eval failed on 3/3 seeds, residual -0.0023 kg/s).
        _snap_x = x.copy()
 
        if derive_eps:
            eps_new = _layer1_matched_eps(result, Pa, cea_cache, float(x[2]))
            if eps_new is not None:
                eps_new = float(np.clip(eps_new, eps_lo, eps_hi))
                if abs(eps_new - float(x[2])) > 1e-4 * max(1.0, abs(float(x[2]))):
                    x[2] = eps_new
                    changed = True
 
        if derive_at:
            F_now = result.get("F")
            At_now = float(x[0])
            try:
                F_now = float(F_now)
            except (TypeError, ValueError):
                F_now = float("nan")
            if np.isfinite(F_now) and F_now > 0.0 and At_now > 0.0:
                # Secant on the local log-log slope once we have two points.
                if prev_at is not None and prev_F is not None and prev_F > 0.0:
                    d_ln_at = np.log(At_now) - np.log(prev_at)
                    d_ln_F = np.log(F_now) - np.log(prev_F)
                    if abs(d_ln_at) > 1e-9:
                        s = d_ln_F / d_ln_at
                        if np.isfinite(s):
                            # Positive-only, deliberately. A sign-preserving clamp trusted a
                            # negative slope measured AT the supply boundary for too long and
                            # ran thrust away to +38% (7218 -> 9954 N) on 3/8 finalisations.
                            # Off-boundary, dlnF/dlnAt is +0.3; the guard in the rebuild
                            # handles the boundary case by refusing to make thrust worse.
                            slope = float(
                                np.clip(s, _DERIVE_AT_SLOPE_MIN, _DERIVE_AT_SLOPE_MAX)
                            )
                rel_err = F_target / F_now
                if abs(rel_err - 1.0) > thrust_tol:
                    prev_at, prev_F = At_now, F_now
                    At_new = float(np.clip(At_now * rel_err ** (1.0 / slope), at_lo, at_hi))
                    if abs(At_new - At_now) > 1e-4 * At_now:
                        x[0] = At_new
                        changed = True
 
        if derive_df:
            MR_now = result.get("MR")
            try:
                MR_now = float(MR_now)
            except (TypeError, ValueError):
                MR_now = float("nan")
            d_F = float(x[8])
            if np.isfinite(MR_now) and MR_now > 0.0 and d_F > 0.0:
                if abs(MR_now / MR_target - 1.0) > of_tol:
                    # MR = mdot_O/mdot_F and mdot_F ~ d_F^2  =>  d_F_new = d_F*sqrt(MR_now/MR_target)
                    d_F_new = float(np.clip(d_F * np.sqrt(MR_now / MR_target), df_lo, df_hi))
                    if abs(d_F_new - d_F) > 1e-6 * d_F:
                        x[8] = d_F_new
                        changed = True
 
        if derive_pt:
            Pc_now = result.get("Pc")
            ip = result.get("injector_pressure") if isinstance(result.get("injector_pressure"), dict) else {}
            try:
                Pc_now = float(Pc_now)
                dpf_O = float(ip.get("delta_p_feed_O", 0.0) or 0.0)
                dpf_F = float(ip.get("delta_p_feed_F", 0.0) or 0.0)
            except (TypeError, ValueError):
                Pc_now = float("nan")
            if np.isfinite(Pc_now) and Pc_now > 0.0:
                # One tank feeds both sides; use the larger feed loss so the weaker side still
                # meets the target (the other lands slightly above it, inside the band).
                P_needed_psi = (Pc_now * (1.0 + r_dp) + max(dpf_O, dpf_F)) / 6894.757293168
                P_needed_psi = float(np.clip(P_needed_psi, pt_lo, pt_hi))
                P_cur = float(x[io_])
                if abs(P_needed_psi - P_cur) > 1e-3 * max(1.0, P_cur):
                    # Relaxed: Pc responds strongly to P_tank at fixed throat, so a full step
                    # oscillates against the throat solve.
                    P_new = P_cur + 0.6 * (P_needed_psi - P_cur)
                    x[io_] = P_new
                    x[if_] = P_new
                    changed = True
 
        if not changed:
            break
 
        # The fuel jet lives on the injector, not the chamber: write it (and the ring pitch
        # that depends on it) back onto the config before re-evaluating.
        if derive_df and hasattr(config, "injector") and hasattr(config.injector, "geometry"):
            _layer1_derive_fuel_spacing(x, constants)
            config.injector.geometry.fuel.d_jet = float(x[8])
            config.injector.geometry.fuel.spacing = float(x[10])
 
        _layer1_apply_chamber_geometry_to_config(
            config,
            A_throat=float(x[0]),
            Lstar=float(x[1]),
            expansion_ratio=float(x[2]),
            D_chamber_outer=_quantize_chamber_od_m(
                float(x[3]), od_inc, wall_m=wall, snap_target=od_snap_target),
            max_nozzle_exit=max_nozzle_exit,
            wall_thickness_m=wall,
        )
        if derive_pt:
            if getattr(config, "lox_tank", None) is not None:
                config.lox_tank.initial_pressure_psi = float(x[io_])
            if getattr(config, "fuel_tank", None) is not None:
                config.fuel_tank.initial_pressure_psi = float(x[if_])
        next_result = evaluate()
        # A failed step off a feasibility edge is not the end: halve the move toward the
        # previous good state and retry -- the chamber solve fails to bracket by a hair on
        # knife-edge winners, and a full secant step overshoots that hair.
        _halvings = 0
        while not isinstance(next_result, dict) and _halvings < 4:
            _halvings += 1
            x[:] = _snap_x + 0.5 * (x - _snap_x)
            _layer1_apply_chamber_geometry_to_config(
                config, A_throat=float(x[0]), Lstar=float(x[1]), expansion_ratio=float(x[2]),
                D_chamber_outer=_quantize_chamber_od_m(
                    float(x[3]), od_inc, wall_m=wall, snap_target=od_snap_target),
                max_nozzle_exit=max_nozzle_exit, wall_thickness_m=wall)
            if derive_df and hasattr(config, "injector") and hasattr(config.injector, "geometry"):
                config.injector.geometry.fuel.d_jet = float(x[8]); config.injector.geometry.fuel.spacing = float(x[10])
            if derive_pt:
                if getattr(config, "lox_tank", None) is not None: config.lox_tank.initial_pressure_psi = float(x[io_])
                if getattr(config, "fuel_tank", None) is not None: config.fuel_tank.initial_pressure_psi = float(x[if_])
            next_result = evaluate()
        if not isinstance(next_result, dict):
            # Still failing after halving -- keep the last good result AND put x and the
            # config back to the state that result describes.
            x[:] = _snap_x
            _layer1_apply_chamber_geometry_to_config(
                config,
                A_throat=float(x[0]),
                Lstar=float(x[1]),
                expansion_ratio=float(x[2]),
                D_chamber_outer=_quantize_chamber_od_m(
                    float(x[3]), od_inc, wall_m=wall, snap_target=od_snap_target),
                max_nozzle_exit=max_nozzle_exit,
                wall_thickness_m=wall,
            )
            if derive_df and hasattr(config, "injector") and hasattr(config.injector, "geometry"):
                config.injector.geometry.fuel.d_jet = float(x[8])
                config.injector.geometry.fuel.spacing = float(x[10])
            if derive_pt:
                if getattr(config, "lox_tank", None) is not None:
                    config.lox_tank.initial_pressure_psi = float(x[io_])
                if getattr(config, "fuel_tank", None) is not None:
                    config.fuel_tank.initial_pressure_psi = float(x[if_])
            try:
                result["_derive_restored_after_failed_step"] = True
            except Exception:
                pass
            break
        result = next_result
 
    try:
        result["_derive_iters"] = _iters_used
    except Exception:
        pass
    return result
 
 
# ============================================================================
# Worker Process Globals (for parallel CMA-ES evaluation)
# ============================================================================
# These are set by _init_worker() in each worker process and reused across evaluations
_worker_runner = None
_worker_base_config = None
_worker_bounds = None
_worker_requirements = None
_worker_constants = None
_worker_debug_strict = False
 
 
 
def create_layer1_apply_x_to_config(
    bounds: list,
    max_chamber_od: float,
    max_nozzle_exit: float,
    injector_type: str = "pintle",
    chamber_od_increment_in: float = 0.0,
    chamber_od_snap_target: str = "outer",
    derive_constants: Optional[dict] = None,
    derive_spacing_F_range: Tuple[float, float] = (0.0, float("inf")),
) -> Callable:
    """Create the apply_x_to_config function with dependencies.
 
    Returns a function that converts optimizer variables to engine config.
    """
    derive_constants = dict(derive_constants or {})
 
    def _pf_clip_range(default_bound):
        """Clip range for the fuel tank pressure.
 
        Locked to the LOX tank means its own bound is collapsed to a seed point; clipping
        there would throw the locked value away, so use the range it was locked within.
        """
        if derive_constants.get("layer1_lock_tank_pressures"):
            return (float(derive_constants.get("lock_P_F_min", default_bound[0])),
                    float(derive_constants.get("lock_P_F_max", default_bound[1])))
        return (float(default_bound[0]), float(default_bound[1]))
 
    def apply_x_to_config(
        x: np.ndarray,
        base_config: PintleEngineConfig,
    ) -> Tuple[PintleEngineConfig, float, float]:
        """Apply optimization variables to config."""
        config = copy.deepcopy(base_config)
        inj_type = injector_type
        if inj_type not in ("pintle", "impinging"):
            inj_type = getattr(getattr(base_config, "injector", None), "type", "pintle")
 
        x = np.asarray(x, dtype=float).copy()
        _layer1_derive_matched_tank_pressure(x, derive_constants)
        A_throat = float(np.clip(x[0], bounds[0][0], bounds[0][1]))
        Lstar = float(np.clip(x[1], bounds[1][0], bounds[1][1]))
        expansion_ratio = float(np.clip(x[2], bounds[2][0], bounds[2][1]))
        D_chamber_outer = float(np.clip(x[3], bounds[3][0], bounds[3][1]))
        D_chamber_outer = _quantize_chamber_od_m(
            D_chamber_outer, chamber_od_increment_in,
            wall_m=_layer1_total_wall_thickness_m(base_config),
            snap_target=chamber_od_snap_target,
        )
 
        _layer1_apply_chamber_geometry_to_config(
            config,
            A_throat=A_throat,
            Lstar=Lstar,
            expansion_ratio=expansion_ratio,
            D_chamber_outer=D_chamber_outer,
            max_nozzle_exit=max_nozzle_exit,
            wall_thickness_m=_layer1_total_wall_thickness_m(base_config),
        )
 
        if inj_type == "impinging":
            n_doublets = int(round(np.clip(x[4], bounds[4][0], bounds[4][1])))
            n_el_O = n_doublets
            d_jet_O = float(np.clip(x[5], bounds[5][0], bounds[5][1]))
            ang_O = float(np.clip(x[6], bounds[6][0], bounds[6][1]))
            sp_O = float(np.clip(x[7], bounds[7][0], bounds[7][1]))
            n_el_F = n_doublets
            d_jet_F = float(np.clip(x[8], bounds[8][0], bounds[8][1]))
            ang_F = float(np.clip(x[9], bounds[9][0], bounds[9][1]))
            # Fuel ring pitch is SOLVED from the standoff requirement, not searched. Clip to
            # its own search range, never to bounds[10] -- that is collapsed to a point when
            # the derivation is on, and clipping there would throw the solved value away.
            _x_local = np.array(x, dtype=float)
            _layer1_derive_fuel_spacing(_x_local, derive_constants)
            _spF_lo, _spF_hi = derive_spacing_F_range
            sp_F = float(np.clip(_x_local[10], _spF_lo, _spF_hi))
            P_O_start_psi = float(np.clip(x[11], bounds[11][0], bounds[11][1]))
            P_F_start_psi = float(np.clip(x[12], *_pf_clip_range(bounds[12])))
            if hasattr(config.injector, "geometry"):
                config.injector.geometry.oxidizer.n_elements = max(1, n_el_O)
                config.injector.geometry.oxidizer.d_jet = d_jet_O
                config.injector.geometry.oxidizer.impingement_angle = ang_O
                config.injector.geometry.oxidizer.spacing = sp_O
                config.injector.geometry.fuel.n_elements = max(1, n_el_F)
                config.injector.geometry.fuel.d_jet = d_jet_F
                config.injector.geometry.fuel.impingement_angle = ang_F
                config.injector.geometry.fuel.spacing = sp_F
            # Keep tank stagnation pressures on ``config`` in sync with ``x`` (runner.evaluate uses x-derived Pa).
            if getattr(config, "lox_tank", None) is not None:
                config.lox_tank.initial_pressure_psi = float(P_O_start_psi)
            if getattr(config, "fuel_tank", None) is not None:
                config.fuel_tank.initial_pressure_psi = float(P_F_start_psi)
            return config, P_O_start_psi, P_F_start_psi
 
        d_pintle_tip = float(np.clip(x[4], bounds[4][0], bounds[4][1]))
        h_gap = float(np.clip(x[5], bounds[5][0], bounds[5][1]))
        n_orifices = int(round(np.clip(x[6], bounds[6][0], bounds[6][1])))
        d_orifice = float(np.clip(x[7], bounds[7][0], bounds[7][1]))
        P_O_start_psi = float(np.clip(x[8], bounds[8][0], bounds[8][1]))
        P_F_start_psi = float(np.clip(x[9], *_pf_clip_range(bounds[9])))
 
        if hasattr(config.injector, 'geometry'):
            if hasattr(config.injector.geometry, 'fuel'):
                config.injector.geometry.fuel.d_pintle_tip = d_pintle_tip
                config.injector.geometry.fuel.h_gap = h_gap
                config.injector.geometry.fuel.d_reservoir_inner = d_pintle_tip + 2 * h_gap
                config.injector.geometry.fuel.d_hydraulic = 2 * h_gap
                config.injector.geometry.fuel.A_entry = np.pi * (d_pintle_tip / 2) ** 2
            if hasattr(config.injector.geometry, 'lox'):
                config.injector.geometry.lox.n_orifices = n_orifices
                config.injector.geometry.lox.d_orifice = d_orifice
                config.injector.geometry.lox.theta_orifice = 90.0
                config.injector.geometry.lox.d_hydraulic = d_orifice
                config.injector.geometry.lox.A_entry = np.pi * (d_orifice / 2) ** 2
 
        if getattr(config, "lox_tank", None) is not None:
            config.lox_tank.initial_pressure_psi = float(P_O_start_psi)
        if getattr(config, "fuel_tank", None) is not None:
            config.fuel_tank.initial_pressure_psi = float(P_F_start_psi)
 
        return config, P_O_start_psi, P_F_start_psi
 
    return apply_x_to_config
 
 
 
 
 
# ============================================================================
# Helper Functions for Parallel CMA-ES Evaluation
# ============================================================================
 
def _config_to_dict(config: PintleEngineConfig) -> dict:
    """Convert config to lightweight dict for pickling.
    
    Uses pydantic's dict() method if available, otherwise falls back to __dict__.
    """
    return config.model_dump() if hasattr(config, 'model_dump') else config.__dict__
 
 
def _dict_to_config(config_dict: dict) -> PintleEngineConfig:
    """Reconstruct config from dict."""
    return PintleEngineConfig(**config_dict)
 
 
 
def _quantize_chamber_od_m(
    D_outer_m: float,
    increment_in: float,
    wall_m: float = 0.0,
    snap_target: str = "outer",
) -> float:
    """Snap a chamber diameter to a stock increment; returns the OUTER diameter [m].
 
    Ablative sleeve, chamber tube and case are bought in fixed sizes -- typically half-inch
    steps -- so a continuous optimum like 4.2 in is not purchasable: you buy 4.0 or 4.5 and
    the design you build is not the design that was optimised. Snapping inside the evaluation
    means every candidate the optimizer scores is one you can actually order, so the returned
    optimum is already manufacturable rather than something to round afterwards (rounding
    afterwards silently moves contraction ratio, L*, and wall thickness off the optimum).
 
    ``snap_target`` picks WHICH diameter lands on the increment, because only one of them
    can: bore = OD - wall, and the wall is rarely a whole increment (a 1.13 in wall turns a
    6.00 in OD into a 4.87 in bore). ``"outer"`` snaps the tube you buy; ``"bore"`` snaps the
    gas-side diameter, for when the liner ID is what comes in fixed sizes. Either way the
    OUTER diameter is returned, since that is what the geometry writer takes.
 
    increment_in <= 0 disables snapping and returns the value unchanged.
    """
    if increment_in is None or not np.isfinite(increment_in) or increment_in <= 0:
        return float(D_outer_m)
    if not np.isfinite(D_outer_m) or D_outer_m <= 0:
        return float(D_outer_m)
    step_m = float(increment_in) * 0.0254
 
    if str(snap_target).strip().lower() == "bore":
        w = float(wall_m) if wall_m is not None and np.isfinite(wall_m) else 0.0
        bore = float(D_outer_m) - w
        if bore <= 0:
            return float(D_outer_m)
        n = max(1, round(bore / step_m))
        return float(n * step_m + w)
 
    n = round(float(D_outer_m) / step_m)
    if n < 1:
        n = 1
    return float(n * step_m)
 
 
def _l1_shrink_derived_stds(cma_stds: np.ndarray, derived: Dict[int, float]) -> list:
    """CMA_stds with derived dimensions damped to effectively zero.
 
    Derived DOFs keep their FULL bounds -- collapsing them to a point made every one of the
    ~50 ``np.clip(x, bounds...)`` sites in this module silently revert the solved value to
    the seed. Full bounds make each clip a no-op; this keeps CMA from wasting variance on a
    coordinate whose value is overwritten at evaluation anyway.
    """
    out = list(np.asarray(cma_stds, dtype=float).tolist())
    for k in (derived or {}):
        k = int(k)
        if 0 <= k < len(out):
            out[k] = max(1e-12, float(out[k]) * 1e-6)
    return out
 
 
def _layer1_cma_discrete_options(
    n_dims: int,
    integer_dims: Optional[Sequence[int]],
    od_index: int = -1,
    od_step_m: float = 0.0,
    bounds: Optional[Sequence[Sequence[float]]] = None,
) -> Tuple[list, list]:
    """CMA options that make discrete DOFs behave like discrete DOFs.
 
    Snapping a variable at dispatch (``_snap_integer_dims``) guarantees the design that
    gets EVALUATED is manufacturable, but it leaves CMA-ES searching a continuous
    coordinate over a staircase objective: many distinct proposals collapse onto the same
    evaluated value, so most of the variation CMA generates in that coordinate returns a
    bit-identical objective and teaches its covariance adaptation nothing. Worse, as sigma
    decays during convergence it can fall below half a cell, at which point essentially
    every proposal rounds to the same value and the coordinate freezes on whatever cell it
    happened to occupy -- measured on a real run: 1116 distinct proposals for the chamber
    diameter produced 8 distinct evaluated sizes, and four seeds of one problem landed on
    5.5/6.5/5.5/6.5 in while every other output matched to 4 significant figures.
 
    Two fixes, both from ``cma`` itself:
 
    * ``integer_variables`` -- integer centering plus a minimum std, for coordinates whose
      granularity really is 1 (element counts, whole-degree jet angles).
    * ``minstd`` -- a hard floor on the per-coordinate std, in the coordinate's OWN units.
      This is how the chamber diameter is handled: its granularity is one stock increment
      in metres, not 1, so it must NOT be declared an integer variable (that would centre
      it on integer *metres*) -- it just needs a std floor of a fraction of one increment.
 
    Returns:
        ``(integer_variables, minstd)`` ready to drop into the CMA options dict.
    """
    def _span(i: int) -> float:
        """Width of coordinate i's search domain, or inf when bounds are unknown."""
        if bounds is None or i >= len(bounds):
            return float("inf")
        try:
            return float(bounds[i][1]) - float(bounds[i][0])
        except (TypeError, ValueError, IndexError):
            return float("inf")
 
    def _fits(i: int, m: float) -> bool:
        """A std floor only makes sense if the domain is wide enough to hold it.
 
        A PINNED coordinate -- user-frozen via frozen_parameters, or one of the derived DOFs
        this module collapses itself -- has a domain of ~2e-12. Handing cma a minstd of 0.2
        (or 0.00254 m for the chamber OD) against that makes it inflate the sampling std by
        ~1e9 to satisfy the floor, which blows up the covariance matrix on a coordinate that
        cannot move anyway: 'sigma0 x stds is larger than the bounded domain size in
        variable 3', and the run collapses. Nothing is lost by skipping them -- a pinned
        coordinate has no cells to straddle.
        """
        return _span(i) > 2.0 * m
 
    idx = [
        int(i) for i in (integer_dims or [])
        if 0 <= int(i) < n_dims and _fits(int(i), 0.2)
    ]
    minstd = [0.0] * n_dims
    # 0.2 is cma's own scale for integer handling: small enough not to inflate the search,
    # large enough that proposals still straddle a cell boundary.
    for i in idx:
        minstd[i] = 0.2
    if od_step_m > 0.0 and 0 <= od_index < n_dims:
        _m = 0.2 * float(od_step_m)
        if _fits(od_index, _m):
            minstd[od_index] = _m
    return idx, minstd
 
 
def _snap_integer_dims(x: np.ndarray, integer_indices: list) -> np.ndarray:
    """Snap integer dimensions to nearest integer.
    
    Ensures cache consistency and physical validity for discrete variables.
    
    Args:
        x: Candidate vector
        integer_indices: List of indices to snap (e.g., [6] for n_orifices)
    
    Returns:
        Snapped vector with integer dimensions rounded
    """
    x_snapped = x.copy()
    for idx in integer_indices:
        x_snapped[idx] = round(x_snapped[idx])
    return x_snapped
 
 
def _get_num_workers(config_obj) -> int:
    """Get number of workers from config or default to cpu_count - 1.
 
    ``ED_L1_WORKERS`` overrides both (``1`` runs every candidate in-process, which is what a
    debugger or an infeasibility trace needs)."""
    env = os.environ.get("ED_L1_WORKERS")
    if env:
        try:
            return max(1, int(env))
        except ValueError:
            pass
    if hasattr(config_obj, 'optimizer') and hasattr(config_obj.optimizer, 'num_workers'):
        num_workers = config_obj.optimizer.num_workers
    else:
        # Default to cpu_count - 1 (leave one core free)
        num_workers = max(1, os.cpu_count() - 1)
    
    return num_workers
 
 
def _init_worker(config_dict: dict, bounds_array: np.ndarray, requirements_dict: dict, 
                 constants_dict: dict, debug_strict: bool = False):
    """Initialize worker process with lightweight data.
    
    Builds PintleEngineRunner ONCE per worker for major speedup.
    Runner is reused by mutating its config in-place (runner.evaluate is stateless).
    
    Args:
        config_dict: Serialized config (primitives only)
        bounds_array: Bounds array [n_dims x 2]
        requirements_dict: Requirements dict
        constants_dict: Constants needed for geometry calculations
        debug_strict: If True, re-raise exceptions; if False, return penalties
    """
    global _worker_runner, _worker_base_config, _worker_bounds, _worker_requirements, _worker_constants, _worker_debug_strict
 
    # Warm the JIT in THIS process. @njit(cache=True) persists compiled code to
    # disk, but the cache is not shared memory -- every worker still loads and
    # deserializes it on first call. Un-warmed, that cost lands inside the first
    # CMA generation and skews it. (The C path never needed this: one .so was
    # mmapped into every child for free.)
    try:
        from engine import accel as _accel
        if _accel.enabled():
            _accel.warmup()
    except Exception:
        pass  # a warmup failure must never stop a worker from starting
 
    # Reconstruct config from dict
    _worker_base_config = _dict_to_config(config_dict)
    
    # Build runner ONCE per worker (major speedup)
    # Note: PintleEngineRunner.evaluate() is stateless between calls
    _worker_runner = PintleEngineRunner(_worker_base_config)
    
    # Store bounds and requirements
    _worker_bounds = np.array(bounds_array, dtype=np.float64)
    _worker_requirements = requirements_dict
    _worker_constants = constants_dict
    _worker_debug_strict = debug_strict
 
 
def _apply_x_to_worker_config_inplace(x: np.ndarray, config: PintleEngineConfig, constants: dict):
    """Apply x to config IN-PLACE (mutates config, no copy).
 
    Assumes x is already bounded and snapped (CMA-ES + parent handle this).
    """
    inj_type = constants.get("injector_type", "pintle")
    _layer1_derive_matched_tank_pressure(x, constants)
 
    A_throat = float(x[0])
    Lstar = float(x[1])
    expansion_ratio = float(x[2])
    max_nozzle_exit = constants.get('max_nozzle_exit', 1.0)
    wall = float(constants.get('TOTAL_WALL_THICKNESS_M', TOTAL_WALL_THICKNESS_M))
    D_chamber_outer = _quantize_chamber_od_m(
        float(x[3]), constants.get("layer1_chamber_od_increment_in", 0.0),
        wall_m=wall,
        snap_target=constants.get("layer1_chamber_od_snap_target", "outer"),
    )
 
    _layer1_apply_chamber_geometry_to_config(
        config,
        A_throat=A_throat,
        Lstar=Lstar,
        expansion_ratio=expansion_ratio,
        D_chamber_outer=D_chamber_outer,
        max_nozzle_exit=max_nozzle_exit,
        wall_thickness_m=wall,
    )
 
    _layer1_derive_matched_tank_pressure(x, constants)
    if inj_type == "impinging":
        # Solve the fuel ring pitch from the impingement-standoff requirement BEFORE anything
        # reads it, so config, objective and reported design all see the same solved value.
        _layer1_derive_fuel_spacing(x, constants)
        n_doublets = int(x[4])
        n_el_O = n_doublets
        d_jet_O = float(x[5])
        ang_O = float(x[6])
        sp_O = float(x[7])
        n_el_F = n_doublets
        d_jet_F = float(x[8])
        ang_F = float(x[9])
        sp_F = float(x[10])
        if hasattr(config, 'injector') and hasattr(config.injector, 'geometry'):
            config.injector.geometry.oxidizer.n_elements = max(1, n_el_O)
            config.injector.geometry.oxidizer.d_jet = d_jet_O
            config.injector.geometry.oxidizer.impingement_angle = ang_O
            config.injector.geometry.oxidizer.spacing = sp_O
            config.injector.geometry.fuel.n_elements = max(1, n_el_F)
            config.injector.geometry.fuel.d_jet = d_jet_F
            config.injector.geometry.fuel.impingement_angle = ang_F
            config.injector.geometry.fuel.spacing = sp_F
        _io = int(constants.get("idx_P_O", 11))
        _if = int(constants.get("idx_P_F", 12))
        if len(x) > _if:
            _po = float(x[_io])
            _pf = float(x[_if])
            if getattr(config, "lox_tank", None) is not None:
                config.lox_tank.initial_pressure_psi = _po
            if getattr(config, "fuel_tank", None) is not None:
                config.fuel_tank.initial_pressure_psi = _pf
        return
 
    d_pintle_tip = float(x[4])
    h_gap = float(x[5])
    n_orifices = int(x[6])
    d_orifice = float(x[7])
 
    if hasattr(config, 'injector') and getattr(config.injector, 'type', '') == "pintle":
        if hasattr(config.injector.geometry, 'fuel'):
            config.injector.geometry.fuel.d_pintle_tip = d_pintle_tip
            config.injector.geometry.fuel.h_gap = h_gap
            config.injector.geometry.fuel.d_reservoir_inner = d_pintle_tip + 2 * h_gap
            config.injector.geometry.fuel.d_hydraulic = 2 * h_gap
            config.injector.geometry.fuel.A_entry = np.pi * (d_pintle_tip / 2) ** 2
        if hasattr(config.injector.geometry, 'lox'):
            config.injector.geometry.lox.n_orifices = n_orifices
            config.injector.geometry.lox.d_orifice = d_orifice
            config.injector.geometry.lox.theta_orifice = 90.0
            config.injector.geometry.lox.d_hydraulic = d_orifice
            config.injector.geometry.lox.A_entry = np.pi * (d_orifice / 2) ** 2
 
    _io = int(constants.get("idx_P_O", 8))
    _if = int(constants.get("idx_P_F", 9))
    if len(x) > _if:
        _po = float(x[_io])
        _pf = float(x[_if])
        if getattr(config, "lox_tank", None) is not None:
            config.lox_tank.initial_pressure_psi = _po
        if getattr(config, "fuel_tank", None) is not None:
            config.fuel_tank.initial_pressure_psi = _pf
 
 
# Infeasibility trace: set ED_L1_TRACE_INFEAS=1 (with ED_L1_WORKERS=1 so candidates run in-process)
# and each objective evaluation appends {checkpoint: running infeasibility score} here -- the only
# way to see WHICH gate keeps a run infeasible when every candidate returns the 1e6 floor.
_INFEAS_TRACE: List[Dict[str, float]] = []
_INFEAS_TRACE_ON = bool(os.environ.get("ED_L1_TRACE_INFEAS"))
 
 
def _infeas_trace(entry: Optional[Dict[str, float]], label: str, value: float) -> None:
    if entry is not None:
        entry[label] = float(value)
 
 
def _compute_objective_value(
    result: Any,
    x: np.ndarray,
    requirements: dict,
    constants: dict,
    cea_cache: Any = None,
    *,
    eval_error: Optional[str] = None,
    return_terms: bool = False,
) -> Any:
    """The Layer-1 objective; with ``return_terms`` every weighted term and the values behind it.
 
    The ONE scoring function. The worker pool (``_eval_candidate``) and the inline
    ``objective()`` closure both call it on the SOLVED vector, so CMA, the block stage,
    L-BFGS-B and the reported breakdown rank the same surface. It used to exist twice and the
    two drifted by ~300 points on the same design (chamber length, ΔP centre term, L* keys).
 
    Structure: infeasibility (BASE_INFEAS + W_INFEAS x residual) dominates; below it the
    requirement terms (thrust, Pc, O/F with deadbands), the preference bands, and the
    figure of merit -- delivered Isp (``isp_penalty``) against chamber mass
    (``chamber_mass_penalty``).
 
    Returns the scalar, or with ``return_terms`` a dict: ``objective``, ``terms`` (weighted;
    sums to ``objective`` on a feasible design) and the context values.
    """
    inj_type = constants.get("injector_type", "pintle")
    x = np.asarray(x, dtype=float)
    _layer1_derive_matched_tank_pressure(x, constants)
    idx_P_O = int(constants.get("idx_P_O", 8))
    idx_P_F = int(constants.get("idx_P_F", 9))
 
    target_thrust = float(constants.get("target_thrust", 1000))
    optimal_of = float(constants.get("optimal_of", 2.5))
    target_P_exit = float(constants.get("P_ambient", 101325.0))
    max_lox_P_psi = float(constants.get("max_lox_P_psi", 500))
    max_fuel_P_psi = float(constants.get("max_fuel_P_psi", 500))
    TOTAL_WALL_THICKNESS_M = float(constants.get("TOTAL_WALL_THICKNESS_M", 0.0254))
    max_nozzle_exit = float(constants.get("max_nozzle_exit", 1.0))
    min_stability = float(requirements.get("min_stability_margin", _LAYER1_DEFAULT_MIN_STABILITY_MARGIN))
 
    A_throat = float(x[0])
    Lstar = float(x[1])
    expansion_ratio = float(x[2])
    D_chamber_outer = _quantize_chamber_od_m(
        float(x[3]), constants.get("layer1_chamber_od_increment_in", 0.0),
        wall_m=TOTAL_WALL_THICKNESS_M,
        snap_target=constants.get("layer1_chamber_od_snap_target", "outer"),
    )
 
    d_pintle_tip = 0.0
    n_el_O = 0
    d_jet_O = d_jet_F = ang_O = ang_F = sp_O = sp_F = float("nan")
    if inj_type == "impinging":
        # [4]=n_doublets, [5:8]=LOX jet, [8:11]=fuel jet, [11:13]=tank pressures.
        _layer1_derive_fuel_spacing(x, constants)
        n_el_O = int(x[4])
        d_jet_O, ang_O, sp_O = float(x[5]), float(x[6]), float(x[7])
        d_jet_F, ang_F, sp_F = float(x[8]), float(x[9]), float(x[10])
        A_lox_injector = float(n_el_O * np.pi * (d_jet_O / 2.0) ** 2)
        A_fuel_injector = float(n_el_O * np.pi * (d_jet_F / 2.0) ** 2)
    else:
        d_pintle_tip = float(x[4])
        h_gap = float(x[5])
        n_orifices = int(x[6])
        d_orifice = float(x[7])
        A_lox_injector = float(n_orifices * np.pi * (d_orifice / 2.0) ** 2)
        R_inner = float(d_pintle_tip / 2.0)
        A_fuel_injector = float(np.pi * ((R_inner + h_gap) ** 2 - R_inner ** 2))
 
    D_chamber_inner = D_chamber_outer - TOTAL_WALL_THICKNESS_M
    if D_chamber_inner <= 0:
        D_chamber_inner = max(D_chamber_outer * 0.3, 0.01)
    A_chamber_check = np.pi * (D_chamber_inner / 2.0) ** 2
    A_throat_check = A_throat
 
    A_exit = A_throat * expansion_ratio
    if A_exit < 0:
        A_exit = A_throat * 10.0
    D_exit_check = np.sqrt(max(0.0, 4.0 * A_exit / np.pi))
    if D_exit_check > max_nozzle_exit:
        D_exit_check = max_nozzle_exit
    D_throat_check = np.sqrt(4.0 * A_throat_check / np.pi) if A_throat_check > 0 else 0.0
 
    out: Dict[str, Any] = {"eval_success": False, "terms": {}}
 
    # Flow-capacity ratios use A_eff = Cd x A_geom when diagnostics supply Cd (post-evaluate)
    A_lox_flow, A_fuel_flow = A_lox_injector, A_fuel_injector
    if inj_type in ("impinging", "pintle") and isinstance(result, dict):
        A_lox_flow, A_fuel_flow, eff_w = effective_flow_areas_from_cd(
            result.get("diagnostics"), A_lox_injector, A_fuel_injector)
        if eff_w and isinstance(result.get("diagnostics"), dict):
            merge_effective_area_warnings(result["diagnostics"], eff_w)
    lox_ratio = A_lox_flow / A_throat_check if A_throat_check > 0 else np.nan
    fuel_ratio = A_fuel_flow / A_throat_check if A_throat_check > 0 else np.nan
 
    P_O_psi = float(x[idx_P_O])
    P_F_psi = float(x[idx_P_F])
    P_O_ratio = P_O_psi / max_lox_P_psi if max_lox_P_psi > 0 else 0.0
    P_F_ratio = P_F_psi / max_fuel_P_psi if max_fuel_P_psi > 0 else 0.0
 
    infeasibility_score = 0.0
    geom_hard = 0.0          # face / back-face limits: not forgiven by the gate
    _tr = {} if _INFEAS_TRACE_ON else None
    if _tr is not None:
        _INFEAS_TRACE.append(_tr)
 
    if A_chamber_check > 0 and A_throat_check > 0:
        cr_check = A_chamber_check / A_throat_check
        infeasibility_score += max(0.0, (A_throat_check * 1.1) / A_chamber_check - 1.0) ** 2
        if cr_check < 1.5:
            infeasibility_score += (1.5 - cr_check) ** 2
        elif cr_check > 15.0:
            infeasibility_score += (cr_check - 15.0) ** 2
    if inj_type == "pintle" and D_chamber_inner > 0:
        infeasibility_score += max(0.0, (d_pintle_tip * 1.1) / D_chamber_inner - 1.0) ** 2
    if D_throat_check > 0 and D_chamber_inner > 0:
        infeasibility_score += max(0.0, D_throat_check - D_chamber_inner * 0.95) ** 2 * 10.0
    if D_exit_check > 0 and D_throat_check > 0:
        infeasibility_score += max(0.0, D_throat_check / D_exit_check - 1.0) ** 2
 
    if inj_type == "pintle" and A_throat_check > 0:
        infeasibility_score += max(0.0, lox_ratio - 1.0) ** 2
        infeasibility_score += max(0.0, fuel_ratio - 1.0) ** 2
        if A_fuel_flow > 0:
            area_ratio = A_lox_flow / A_fuel_flow
            Cd_ratio = float(constants.get("discharge_cd_inf_ratio", 1.0))
            rho_ratio = np.sqrt(
                max(float(constants.get("rho_oxidizer", 1140.0)), 1e-9)
                / max(float(constants.get("rho_fuel", 780.0)), 1e-9))
            area_ratio_factor = Cd_ratio * rho_ratio * np.sqrt(1.2)
            required = optimal_of / area_ratio_factor if area_ratio_factor > 0 else np.inf
            if required > 0 and np.isfinite(required):
                infeasibility_score += max(0.0, abs(area_ratio - required) / required - 0.5) ** 2
    elif inj_type == "impinging" and A_throat_check > 0:
        # Face and back-face real estate: hard limits, scored on every path.
        geom_hard += _impinging_face_infeasibility_terms(
            n_elements=n_el_O, spacing_O_m=sp_O, spacing_F_m=sp_F,
            d_jet_O_m=d_jet_O, d_jet_F_m=d_jet_F, D_chamber_inner_m=D_chamber_inner,
            angle_O_deg=ang_O, angle_F_deg=ang_F,
            center_clear_dia_m=float(constants.get("layer1_injector_center_clear_dia_m", 0.0) or 0.0),
            min_web_m=float(constants.get("layer1_injector_min_web_m", 0.0) or 0.0),
            wall_clearance_m=float(constants.get("layer1_injector_wall_clearance_m", 0.0) or 0.0),
            spray_radius_frac=float(constants.get("layer1_injector_spray_radius_frac", 0.0) or 0.0),
            spray_radius_tol=float(constants.get("layer1_injector_spray_radius_tol", 0.08) or 0.08),
            min_face_incidence_deg=float(
                constants.get("layer1_injector_min_face_incidence_deg", 0.0) or 0.0),
            face_contoured=bool(constants.get("layer1_injector_face_contoured", False)),
            exit_land=float(constants.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)),
        )
        geom_hard += _impinging_back_face_terms(
            n_elements=n_el_O, spacing_O_m=sp_O, spacing_F_m=sp_F,
            d_jet_O_m=d_jet_O, d_jet_F_m=d_jet_F, D_chamber_inner_m=D_chamber_inner,
            angle_O_deg=ang_O, angle_F_deg=ang_F,
            plate_thickness_m=float(constants.get("layer1_injector_plate_thickness_m", 0.0) or 0.0),
            counterbore_dia_m=float(constants.get("layer1_injector_counterbore_dia_m", 0.0) or 0.0),
            land_ld_O=float(constants.get("layer1_injector_land_ld_O", 4.0) or 4.0),
            land_ld_F=float(constants.get("layer1_injector_land_ld_F", 4.0) or 4.0),
            min_back_web_m=float(constants.get("layer1_injector_min_back_web_m", 0.0) or 0.0),
            back_keepout_dia_m=float(constants.get("layer1_injector_back_keepout_dia_m", 0.0) or 0.0),
            back_keepout_wall_m=float(constants.get("layer1_injector_back_keepout_wall_m", 0.0) or 0.0),
            face_contoured=bool(constants.get("layer1_injector_face_contoured", False)),
            exit_land=float(constants.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)),
            back_channels=bool(constants.get("layer1_injector_back_channels", False)),
            # One L/d per hole: the Cd's L/d is also the passage to the channel floor.
            passage_ld_O=float(constants.get("layer1_injector_land_ld_O", 4.0) or 4.0),
            passage_ld_F=float(constants.get("layer1_injector_land_ld_F", 4.0) or 4.0),
            channel_width_m=float(constants.get("layer1_injector_channel_width_m", 0.0) or 0.0),
            channel_floor=str(constants.get("layer1_injector_channel_floor", "flat")),
            r_plate_m=float(constants.get("layer1_injector_r_plate_m", 0.0) or 0.0),
            r_port_m=float(constants.get("layer1_injector_r_port_m", 0.0) or 0.0),
            liner_thickness_m=float(constants.get("layer1_injector_liner_thickness_m", 0.0) or 0.0),
        )
        # SP-8089: impingement no further than 7 d along either jet.
        geom_hard += _impinging_free_jet_violation(
            n_elements=n_el_O, spacing_O_m=sp_O, spacing_F_m=sp_F,
            d_jet_O_m=d_jet_O, d_jet_F_m=d_jet_F, angle_O_deg=ang_O, angle_F_deg=ang_F)
        # Channels back: the channel is the manifold, and a feed port's velocity head past
        # MANIFOLD_Q_FRAC of the drop starves the holes beside it. Active only when the plate
        # declares channels and the solve produced flows; the orifice size, angle and drop are
        # all this search's to move, so it is a hard limit, not a report.
        if bool(constants.get("layer1_injector_back_channels", False)) and isinstance(result, dict):
            _dg = result.get("diagnostics") if isinstance(result.get("diagnostics"), dict) else {}
            _mq = _impinging_manifold_q(
                n_elements=n_el_O, spacing_O_m=sp_O, spacing_F_m=sp_F,
                d_jet_O_m=d_jet_O, d_jet_F_m=d_jet_F, angle_O_deg=ang_O, angle_F_deg=ang_F,
                plate_thickness_m=float(constants.get("layer1_injector_plate_thickness_m", 0.0) or 0.0),
                face_contoured=bool(constants.get("layer1_injector_face_contoured", False)),
                exit_land=float(constants.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)),
                passage_ld_O=float(constants.get("layer1_injector_land_ld_O", 4.0) or 4.0),
                passage_ld_F=float(constants.get("layer1_injector_land_ld_F", 4.0) or 4.0),
                channel_width_m=float(constants.get("layer1_injector_channel_width_m", 0.0) or 0.0),
                channel_floor=str(constants.get("layer1_injector_channel_floor", "flat")),
                channel_inlets=int(constants.get("layer1_injector_channel_inlets", 1) or 1),
                mdot_O=result.get("mdot_O"), mdot_F=result.get("mdot_F"),
                dp_O=_dg.get("delta_p_injector_O"), dp_F=_dg.get("delta_p_injector_F"),
                rho_O=constants.get("rho_O"), rho_F=constants.get("rho_F"))
            geom_hard += _impinging_manifold_violation(_mq)
            _infeas_trace(_tr, "manifold_q", geom_hard)
        infeasibility_score += _impinging_infeasibility_layout_terms(
            d_jet_O=d_jet_O, d_jet_F=d_jet_F, sp_O=sp_O, sp_F=sp_F,
            n_el_O=n_el_O, n_el_F=n_el_O, D_chamber_inner=D_chamber_inner)
        infeasibility_score += _impinging_infeasibility_flow_capacity_terms(
            A_lox_flow=A_lox_flow, A_fuel_flow=A_fuel_flow, A_throat_check=A_throat_check)
 
    _infeas_trace(_tr, "geometry", infeasibility_score)
 
    # --- Evaluation ---
    eval_success = bool(result.get("success", False)) if isinstance(result, dict) else False
    if isinstance(result, dict) and not eval_success:
        eval_success = bool(np.isfinite(float(result.get("F", np.nan)))
                            and np.isfinite(float(result.get("Pc", np.nan))))
    out.update({
        "lox_ratio": lox_ratio, "fuel_ratio": fuel_ratio,
        "D_chamber_inner": D_chamber_inner, "D_throat": D_throat_check,
    })
 
    if not eval_success:
        # Directional guidance only: which way out of the unevaluable region.
        infeasibility_score += 1.0
        err = (eval_error or "").lower()
        if ("supply > demand" in err) or ("invalid bracket" in err) or ("no solution" in err):
            if np.isfinite(lox_ratio):
                infeasibility_score += max(0.0, lox_ratio - 0.90) ** 2
            if np.isfinite(fuel_ratio):
                infeasibility_score += max(0.0, fuel_ratio - 0.90) ** 2
        else:
            infeasibility_score += max(0.0, 0.90 - P_O_ratio) ** 2 + max(0.0, 0.90 - P_F_ratio) ** 2
        if np.isfinite(geom_hard) and geom_hard > 0.0:
            infeasibility_score += float(geom_hard)
        out.update({
            "objective": float(_LAYER1_BASE_INFEAS + _LAYER1_W_INFEAS * float(infeasibility_score)),
            "infeasibility_score": float(infeasibility_score),
            "inf_residual": float(infeasibility_score),
            "length_violation": False,
            "thrust_error": 1.0, "of_error": 1.0,
            "stability_state": "unstable", "stability_score": 0.0,
            "chugging_margin": 0.0, "acoustic_margin": 0.0, "feed_margin": 0.0,
        })
        return out if return_terms else float(out["objective"])
 
    F_actual = float(result.get("F", np.nan))
    MR_actual = float(result.get("MR", np.nan))
    Pc_actual = float(result.get("Pc", np.nan))
    Isp_actual = float(result.get("Isp", np.nan))
    Cf_actual = float(result.get("Cf_actual", result.get("Cf", np.nan)))
    P_exit_actual = float(result.get("P_exit", np.nan))
    stability = result.get("stability_results", {}) or {}
    diagnostics = result.get("diagnostics") if isinstance(result.get("diagnostics"), dict) else {}
 
    thrust_error = (abs(F_actual - target_thrust) / target_thrust
                    if (target_thrust > 0 and np.isfinite(F_actual)) else 1.0)
    # O/F deadband: hitting the target to within tolerance IS success and costs zero.
    _of_tol = float(constants.get("layer1_of_deadband_rel", 0.0) or 0.0)
    of_error_raw = (abs(MR_actual - optimal_of) / optimal_of
                    if (optimal_of > 0 and np.isfinite(MR_actual)) else 1.0)
    of_error = max(0.0, of_error_raw - _of_tol)
 
    thrust_penalty_sq_term = 0.0
    if target_thrust > 0 and np.isfinite(F_actual):
        excess = thrust_error - _layer1_thrust_deadband(requirements)
        if excess > 0:
            thrust_penalty_sq_term = excess ** 2
    else:
        thrust_penalty_sq_term = 1.0
 
    # Chamber-pressure target: exact L1 outside the interior aim band (80 % of the +/-1 %
    # sign-off band, so the search never parks on the gate's edge). The L1 shape keeps a
    # constant pull; inside, the quadratic terms get the gradient.
    pc_penalty_term = 0.0
    pc_target_pa = constants.get("layer1_target_Pc_pa")
    if pc_target_pa and float(pc_target_pa) > 0:
        if np.isfinite(Pc_actual):
            pc_penalty_term = max(0.0, abs(Pc_actual - float(pc_target_pa)) / float(pc_target_pa)
                                  - _LAYER1_PC_AIM_REL)
        else:
            pc_penalty_term = 1.0
 
    _ins_q_raw = constants.get("layer1_exit_pressure_inside_quad_scale")
    _ins_q = (float(_ins_q_raw) if _ins_q_raw is not None and np.isfinite(float(_ins_q_raw))
              else _LAYER1_DEFAULT_EXIT_PRESSURE_INSIDE_QUAD)
    exit_pressure_sq_term = float(_layer1_exit_pressure_sq_term(
        P_exit_actual, target_P_exit,
        deadband_rel=float(constants.get("layer1_exit_pressure_deadband_rel", 0.05)),
        inside_rel_quad_scale=_ins_q))
 
    # Stability. require_stable_state means 'stable', not 'stable or marginal'.
    stability_state = stability.get("stability_state", "unstable")
    stability_score = float(stability.get("stability_score", 0.0))
    chugging_margin = max(0.0, float(stability.get("chugging", {}).get("stability_margin", 0.0)))
    acoustic_margin = max(0.0, float(stability.get("acoustic", {}).get("stability_margin", 0.0)))
    feed_margin = max(0.0, float(stability.get("feed_system", {}).get("stability_margin", 0.0)))
    handicap = float(requirements.get("stability_margin_handicap", 0.0))
    effective_min_score = float(requirements.get("min_stability_score", 0.75)) * max(0.0, 1.0 - handicap)
    effective_margin = float(min_stability) * max(0.0, 1.0 - handicap)
    require_stable_state = bool(requirements.get("require_stable_state", True))
    state_ok = (stability_state == "stable") if require_stable_state else (stability_state != "unstable")
    if not state_ok:
        infeasibility_score += 1.0
    if effective_min_score > 0:
        infeasibility_score += max(0.0, (effective_min_score - stability_score) / effective_min_score) ** 2
    if effective_margin > 0:
        for _m in (chugging_margin, acoustic_margin, feed_margin):
            infeasibility_score += max(0.0, (effective_margin - _m) / effective_margin) ** 2
    _infeas_trace(_tr, "stability", infeasibility_score)
 
    Cf_lo, Cf_hi = 1.3, 1.8
    _cf = float(Cf_actual) if np.isfinite(Cf_actual) else 0.0
    cf_hinge = (max(0.0, Cf_lo - _cf) ** 2 + max(0.0, _cf - Cf_hi) ** 2) / (Cf_hi - Cf_lo) ** 2
 
    # Chamber lengths: the SAME helper _layer1_apply_chamber_geometry_to_config uses.
    theta_contraction = _layer1_contraction_theta(constants)
    _lens = _layer1_chamber_lengths(A_throat, Lstar, D_chamber_inner, theta_contraction)
    L_chamber_curr = _lens["length"]
    L_cylindrical = _lens["length_cylindrical"]
    eps_eff = (np.pi * D_exit_check ** 2 / 4.0) / A_throat if A_throat > 0 else expansion_ratio
    # Face to exit plane: face-to-throat plus the 80 % Rao bell the contour draws.
    L_engine_curr = _lens["face_to_throat"] + _layer1_bell_length_m(A_throat, eps_eff)
    max_engine_length = float(requirements.get("max_engine_length", 0.50) or 0.50)
    length_term = 0.0
    length_violation = False
    if np.isfinite(L_engine_curr) and max_engine_length > 0:
        if L_engine_curr > max_engine_length:
            length_violation = True
            length_term = ((L_engine_curr - max_engine_length) / max_engine_length) ** 2
        else:
            length_term = max(0.0, (L_engine_curr - max_engine_length * 0.9)
                              / (max_engine_length * 0.1)) ** 2
 
    smd_eff_um = _effective_smd_um(diagnostics, MR_actual if np.isfinite(MR_actual) else None)
 
    # L* band around a target (SMD-derived by default). Every key from the requirements, with
    # the resolved L* search bounds from constants -- the worker used to read the keys from a
    # curated constants dict that lacked them and scored a different target.
    W_LSTAR = float(constants.get("layer1_W_LSTAR", 0.0) or 0.0)
    lstar_term = 0.0
    lstar_target_curr = float("nan")
    if W_LSTAR > 0.0:
        def _lstar_get(k):
            if k in ("min_Lstar", "max_Lstar") and constants.get(k) is not None:
                return constants.get(k)
            return requirements.get(k)
        lstar_target_curr, _lstar_db = _layer1_resolve_lstar_target(
            smd_eff_um, requirements, _lstar_get,
            float(constants.get("layer1_Lstar_target_m", 1.0) or 1.0))
        lstar_term = _layer1_lstar_band_term(Lstar, lstar_target_curr, _lstar_db)
 
    # Figure of merit: delivered Isp, as the propellant it costs for the required impulse,
    # against the chamber it takes (both priced per kg; see run_layer1_optimization).
    W_ISP = float(constants.get("layer1_W_ISP", 0.0) or 0.0)
    isp_merit = _layer1_isp_merit_s(result, constants, cea_cache)
    isp_ref = float(constants.get("layer1_Isp_ref_s", np.nan) or np.nan)
    isp_term = _layer1_isp_term(isp_merit, isp_ref) if W_ISP > 0.0 else 0.0
 
    W_MASS = float(constants.get("layer1_W_MASS", 0.0) or 0.0)
    chamber_mass_kg = _layer1_chamber_mass_kg(
        A_chamber_check, L_chamber_curr, TOTAL_WALL_THICKNESS_M,
        float(constants.get("layer1_chamber_wall_density_kg_m3", 2000.0)),
        Pc_pa=float(Pc_actual) if np.isfinite(Pc_actual) else 0.0,
        plate_support=str(constants.get("layer1_injector_plate_support", "clamped")),
        # The plug fills the sleeve bore: this candidate's bore plus the liner.
        r_plate_m=(0.5 * float(D_chamber_inner)
                   + float(constants.get("layer1_injector_liner_thickness_m", 0.0) or 0.0)
                   if constants.get("layer1_injector_plate_support") is not None else 0.0))
    mass_term = (_layer1_chamber_mass_term(
        chamber_mass_kg, float(constants.get("layer1_chamber_mass_ref_kg", 5.0)))
        if W_MASS > 0.0 else 0.0)
 
    # Hard geometric constraints (element pitch, L_cyl/D) -> infeasibility.
    infeasibility_score += _layer1_geometry_infeasibility(
        constants, L_cylindrical=L_cylindrical, D_chamber_inner=D_chamber_inner,
        A_chamber=A_chamber_check, n_elements=n_el_O if inj_type == "impinging" else 0)
 
    W_THRUST = float(constants.get("layer1_W_THRUST", 1e4))
    W_PC = float(constants.get("layer1_W_PC", 0.0))
    W_OF = float(constants.get("layer1_W_OF", 1e4))
    w_of_low_mr = max(1.0, float(constants.get("layer1_W_OF_low_MR_scale", 1.0)))
    w_of_high_mr = max(1.0, float(constants.get("layer1_W_OF_high_MR_scale", 1.0)))
    W_CF = 1e2
    W_EXIT = float(constants.get("layer1_W_EXIT", 2.0e2))
    W_LEN = 1e4
    W_MOM = float(constants.get("W_MOM", 75.0))
    W_DP = float(constants.get("W_DP", 160.0))
    W_SMD = float(constants.get("W_SMD", 0.0))
    W_ANGLE = float(constants.get("W_IMPINGING_ANGLE", 0.0))
    W_JET_ASYM = float(constants.get("W_IMPINGING_JET_ASYM", 0.0))
    _jet_asym_mx = constants.get("layer1_impinging_jet_angle_max_asym_deg")
    jet_asym_max = float(_jet_asym_mx) if _jet_asym_mx is not None else 28.0
    W_CHAMBER_SHAPE = float(constants.get("W_CHAMBER_SHAPE", 2500.0))
    W_TANK_EQUAL = float(constants.get("W_TANK_EQUAL", 0.0))
    W_IMP_GEOM = float(constants.get("W_IMP_GEOM", 0.0))
    W_geom_ao_af = float(constants.get("W_geom_ao_af_momentum", 0.0))
 
    momentum_term = angle_term = jet_asym_term = tilt_term = 0.0
    W_TILT = float(constants.get("layer1_W_TILT", 0.0) or 0.0)
    R_val = float("nan")
    tilt_deg = float("nan")
    tilt_breakeven = float("nan")
    imp_angle_deg = float("nan")
    if inj_type == "impinging":
        try:
            imp_angle_deg = float(diagnostics.get("impingement_angle_deg", np.nan))
        except (TypeError, ValueError):
            imp_angle_deg = float("nan")
        tilt_breakeven = _resultant_tilt_breakeven_deg(
            n_elements=n_el_O, spacing_O_m=sp_O, spacing_F_m=sp_F,
            angle_O_deg=ang_O, angle_F_deg=ang_F,
            D_chamber_inner_m=D_chamber_inner, L_chamber_m=L_chamber_curr)
        _Rv = diagnostics.get("momentum_ratio_R")
        if _Rv is not None and np.isfinite(float(_Rv)) and float(_Rv) > 0:
            R_val = float(_Rv)
            # Wall guard: the RESULTANT TILT, a constraint. R = 1 is not balance.
            tilt_deg = _impinging_resultant_tilt_deg(
                result.get("mdot_O"), result.get("mdot_F"),
                constants.get("rho_O", 1141.0), constants.get("rho_F", 789.0),
                n_el_O, d_jet_O, d_jet_F, ang_O, ang_F,
                lox_inboard=bool(constants.get("layer1_ring_order_fuel_outboard", True)),
                spacing_O_m=sp_O, spacing_F_m=sp_F)
            infeasibility_score += _impinging_resultant_wall_violation(
                tilt_deg,
                max_outward_deg=_resolve_tilt_allowance_deg(
                    from_reach=bool(constants.get("layer1_resultant_tilt_from_reach", False)),
                    constant_deg=float(constants.get("layer1_resultant_tilt_max_deg", 0.0)),
                    breakeven_deg=tilt_breakeven,
                    margin=float(constants.get("layer1_resultant_tilt_reach_margin", 1.5))),
                scale_deg=float(constants.get("layer1_resultant_tilt_scale_deg", 2.0)))
            _infeas_trace(_tr, "wall_tilt", infeasibility_score)
            _infeas_trace(_tr, "tilt_deg", tilt_deg)
            if W_TILT > 0.0:
                tilt_term = _impinging_resultant_tilt_preference(
                    tilt_deg,
                    scale_deg=float(constants.get("layer1_resultant_tilt_scale_deg", 2.0)),
                    outward_multiplier=float(
                        constants.get("layer1_resultant_tilt_outward_multiplier", 25.0) or 25.0))
            # The configured R band (its interior aim band, see run_layer1_optimization).
            _mlo = constants.get("impinging_momentum_R_min")
            _mhi = constants.get("impinging_momentum_R_max")
            momentum_term = _impinging_momentum_asymmetric_squared(
                R_val,
                wall_side_multiplier=float(constants.get("layer1_momentum_wall_side_multiplier", 1.0)),
                low_side_multiplier=float(constants.get("layer1_momentum_low_side_multiplier", 10.0)),
                band_width=float(constants.get("layer1_momentum_band_width", 0.05)),
                safe_side_is_below_one=bool(constants.get("layer1_ring_order_fuel_outboard", True)),
                scale=float(constants.get("layer1_momentum_scale", 0.10)),
                band_lo=float(_mlo) if _mlo is not None else None,
                band_hi=float(_mhi) if _mhi is not None else None,
            )
        if W_ANGLE > 0.0:
            _alo = constants.get("layer1_impinging_angle_deg_min")
            _ahi = constants.get("layer1_impinging_angle_deg_max")
            angle_term = _impinging_angle_hinge_squared(
                imp_angle_deg,
                angle_band_lo_deg=float(_alo) if _alo is not None else None,
                angle_band_hi_deg=float(_ahi) if _ahi is not None else None)
        if W_JET_ASYM > 0.0:
            jet_asym_term = _impinging_jet_pair_asymmetry_squared(
                ang_O, ang_F, max_delta_deg=jet_asym_max)
 
    chamber_shape_term = 0.0
    dt_ratio = D_chamber_inner / D_throat_check if (D_chamber_inner > 0 and D_throat_check > 0) else float("nan")
    ld_ratio = L_chamber_curr / D_chamber_inner if (D_chamber_inner > 0 and L_chamber_curr > 0) else float("nan")
    if np.isfinite(dt_ratio):
        chamber_shape_term += _relative_hinge_band_squared(
            dt_ratio, float(constants.get("layer1_chamber_dt_ratio_min", 2.2)),
            float(constants.get("layer1_chamber_dt_ratio_max", 3.2)))
    if np.isfinite(ld_ratio):
        chamber_shape_term += _relative_hinge_band_squared(
            ld_ratio, float(constants.get("layer1_chamber_ld_ratio_min", 1.0)),
            float(constants.get("layer1_chamber_ld_ratio_max", 3.2)))
 
    geom_ao_af_term = 0.0
    geom_ao_af_ratio = expected_ao_af = float("nan")
    if inj_type == "impinging" and W_geom_ao_af > 0.0 and A_fuel_injector > 0:
        geom_ao_af_term, geom_ao_af_ratio, expected_ao_af = _geom_ao_af_momentum_hint_squared(
            float(A_lox_injector), float(A_fuel_injector), float(optimal_of),
            float(constants.get("rho_oxidizer", 1140.0)), float(constants.get("rho_fuel", 422.6)))
    # A guidance aid: taper it as O/F approaches target.
    _of_tol_for_geom = max(0.05, float(constants.get("layer1_of_validation_tol", 0.15)))
    geom_ao_af_scale = min(1.0, float(of_error / _of_tol_for_geom) ** 2)
    geom_ao_af_weighted = W_geom_ao_af * geom_ao_af_term * geom_ao_af_scale
 
    injector_dp_weighted = 0.0
    ratio_o = ratio_f = None
    if np.isfinite(Pc_actual) and Pc_actual > 0:
        ratio_o, ratio_f = injector_dp_ratios_from_eval_result(Pc_actual, result)
        injector_dp_weighted = injector_dp_ratio_penalty_weighted(
            ratio_o, ratio_f, W_DP, float(constants.get("W_DP_HIGH", 480.0)),
            o_band=(float(constants.get("injector_dp_ratio_O_min", _LAYER1_DEFAULT_DP_O_BAND[0])),
                    float(constants.get("injector_dp_ratio_O_max", _LAYER1_DEFAULT_DP_O_BAND[1]))),
            f_band=(float(constants.get("injector_dp_ratio_F_min", _LAYER1_DEFAULT_DP_F_BAND[0])),
                    float(constants.get("injector_dp_ratio_F_max", _LAYER1_DEFAULT_DP_F_BAND[1]))),
            w_dp_o=float(constants.get("W_DP_O", W_DP)),
            w_dp_f=float(constants.get("W_DP_F", W_DP)),
            o_soft_floor=(float(constants["injector_dp_ratio_O_soft_floor"])
                          if constants.get("injector_dp_ratio_O_soft_floor") is not None else None),
            w_dp_o_floor=float(constants.get("W_DP_O_FLOOR", 0.0) or 0.0),
            w_dp_center=float(constants.get("W_DP_CENTER", 500.0)),
        )
 
    smd_term = 0.0
    if inj_type == "impinging" and W_SMD > 0.0:
        smd_term, _, _ = _impinging_smd_penalty_with_angle(
            diagnostics,
            target_smd_microns=float(constants.get("target_smd_microns", 50.0)),
            smd_rel_tol=float(constants.get("layer1_smd_rel_tol", 0.20)),
            mr_mass=float(MR_actual) if np.isfinite(MR_actual) and MR_actual > 0 else None)
 
    tank_equal_term = 0.0
    if W_TANK_EQUAL > 0.0:
        tank_equal_term = _tank_pressure_equal_squared(
            P_O_psi, P_F_psi, scale_psi=float(constants.get("layer1_tank_equal_scale_psi", 100.0)),
            tol_psi=float(constants.get("layer1_tank_equal_tol_psi", 0.0) or 0.0),
            inband_frac=float(constants.get("layer1_tank_equal_inband_frac", 0.0) or 0.0))
 
    geom_fit_term = 0.0
    if inj_type == "impinging" and W_IMP_GEOM > 0.0:
        geom_fit_term = _impinging_geometry_fit_squared(
            diagnostics, D_chamber_inner_m=D_chamber_inner, L_chamber_m=L_chamber_curr)
        # Ring geometry from the design variables (the accelerator emits none of the keys
        # the diagnostics fit reads).
        if constants.get("layer1_enforce_ring_geometry", True):
            geom_fit_term += _impinging_ring_geometry_squared(
                n_elements=n_el_O, spacing_O_m=sp_O, spacing_F_m=sp_F,
                d_jet_O_m=d_jet_O, d_jet_F_m=d_jet_F, D_chamber_inner_m=D_chamber_inner,
                angle_O_deg=ang_O, angle_F_deg=ang_F,
                Ld_min=float(constants.get("layer1_impingement_Ld_min", _LD_BAND_DEFAULT.lo)),
                Ld_max=float(constants.get("layer1_impingement_Ld_max", _LD_BAND_DEFAULT.hi)),
                ring_order_fuel_outboard=bool(constants.get("layer1_ring_order_fuel_outboard", True)),
                center_clear_dia_m=float(constants.get("layer1_injector_center_clear_dia_m", 0.0) or 0.0),
                min_web_m=float(constants.get("layer1_injector_min_web_m", 0.0) or 0.0),
                wall_clearance_m=float(constants.get("layer1_injector_wall_clearance_m", 0.0) or 0.0),
                spray_radius_frac=float(constants.get("layer1_injector_spray_radius_frac", 0.0) or 0.0),
                spray_radius_tol=float(constants.get("layer1_injector_spray_radius_tol", 0.08) or 0.08),
                face_contoured=bool(constants.get("layer1_injector_face_contoured", False)),
                exit_land=float(constants.get("layer1_injector_exit_land", EXIT_LAND_DEFAULT)),
            )
 
    if not np.isfinite(infeasibility_score) or infeasibility_score < 0:
        infeasibility_score = 1.0
    inf_residual = _layer1_inf_residual(infeasibility_score, requirements)
    # Face and back-face geometry are hard limits, not numerical residuals: they bypass the gate.
    if np.isfinite(geom_hard) and geom_hard > 0.0:
        inf_residual = float(inf_residual) + float(geom_hard)
 
    of_sq = float(of_error) ** 2
    if np.isfinite(MR_actual) and optimal_of > 0:
        if MR_actual < optimal_of:
            of_sq *= w_of_low_mr
        elif MR_actual > optimal_of:
            of_sq *= w_of_high_mr
 
    terms = {
        "thrust_penalty": float(W_THRUST * thrust_penalty_sq_term),
        "pc_target_penalty": float(W_PC * pc_penalty_term),
        "of_penalty": float(W_OF * of_sq),
        "cf_penalty": float(W_CF * cf_hinge),
        "exit_pressure_penalty": float(W_EXIT * exit_pressure_sq_term),
        "injector_dp_penalty": float(injector_dp_weighted),
        "length_penalty": float(W_LEN * length_term),
        "chamber_shape_penalty": float(W_CHAMBER_SHAPE * chamber_shape_term),
        "lstar_penalty": float(W_LSTAR * lstar_term),
        "isp_penalty": float(W_ISP * isp_term),
        "chamber_mass_penalty": float(W_MASS * mass_term),
        "momentum_balance_penalty": float(W_MOM * momentum_term),
        "resultant_tilt_penalty": float(W_TILT * tilt_term),
        "impingement_angle_penalty": float(W_ANGLE * angle_term),
        "jet_angle_asymmetry_penalty": float(W_JET_ASYM * jet_asym_term),
        "smd_penalty": float(W_SMD * smd_term),
        "tank_pressure_equal_penalty": float(W_TANK_EQUAL * tank_equal_term),
        "impinging_geometry_fit_penalty": float(W_IMP_GEOM * geom_fit_term),
        "geom_ao_af_momentum_penalty": float(geom_ao_af_weighted),
    }
    obj_quality = float(sum(terms.values()))
 
    # Infeasibility carries a gradient, not a plateau: the quality terms ride on top so an
    # infeasible start can still descend toward thrust/O-F while it crosses the boundary.
    if length_violation:
        obj = _LAYER1_BASE_INFEAS + _LAYER1_W_INFEAS * length_term + obj_quality
    elif inf_residual > 0.0:
        obj = _LAYER1_BASE_INFEAS + _LAYER1_W_INFEAS * float(inf_residual) + obj_quality
    else:
        obj = obj_quality
    if not np.isfinite(obj):
        obj = _LAYER1_BASE_INFEAS
 
    t_b = float(constants.get("target_burn_time", 0.0) or 0.0)
    out.update({
        "objective": float(obj),
        "objective_quality": obj_quality,
        "terms": terms,
        "eval_success": True,
        "infeasibility_score": float(infeasibility_score),
        "inf_residual": float(inf_residual),
        "length_violation": bool(length_violation),
        "F": F_actual, "MR": MR_actual, "Pc": Pc_actual, "Isp": Isp_actual,
        "Cf": Cf_actual, "P_exit": P_exit_actual,
        "thrust_error": float(thrust_error), "of_error": float(of_error),
        "thrust_penalty_sq": float(thrust_penalty_sq_term),
        "cf_hinge": float(cf_hinge),
        "stability_results": stability, "stability_state": stability_state,
        "stability_score": stability_score, "state_ok": bool(state_ok),
        "chugging_margin": chugging_margin, "acoustic_margin": acoustic_margin,
        "feed_margin": feed_margin, "effective_min_score": effective_min_score,
        "effective_margin": effective_margin,
        "injector_dp_ratio_O": ratio_o, "injector_dp_ratio_F": ratio_f,
        "momentum_ratio_R": R_val, "resultant_tilt_deg": tilt_deg,
        "resultant_tilt_breakeven_deg": tilt_breakeven,
        "effective_smd_microns": smd_eff_um, "impingement_angle_deg": imp_angle_deg,
        "chamber_D_over_Dt": dt_ratio, "chamber_L_over_D": ld_ratio,
        "L_chamber": L_chamber_curr, "L_cylindrical": L_cylindrical,
        "L_face_to_throat": _lens["face_to_throat"], "L_engine": float(L_engine_curr),
        "Lstar_m": Lstar, "Lstar_target_m": lstar_target_curr,
        "chamber_mass_kg": float(chamber_mass_kg),
        "Isp_merit_s": isp_merit, "Isp_ref_s": isp_ref,
        "propellant_mass_kg": (float(target_thrust * t_b / (_G0 * isp_merit))
                               if (t_b > 0 and np.isfinite(isp_merit) and isp_merit > 0) else float("nan")),
        "geom_ao_af_momentum_scale": float(geom_ao_af_scale),
        "geom_ao_af": geom_ao_af_ratio, "expected_ao_af_for_R1": expected_ao_af,
    })
    return out if return_terms else float(obj)
 
 
def _layer1_objective_terms(
    result: Any, x: np.ndarray, requirements: dict, constants: dict, *,
    cea_cache: Any = None, eval_error: Optional[str] = None,
) -> Dict[str, Any]:
    """:func:`_compute_objective_value` with its terms and context."""
    return _compute_objective_value(result, x, requirements, constants, cea_cache,
                                    eval_error=eval_error, return_terms=True)
 
 
def _native_fast_eval_enabled() -> bool:
    """Whether the Layer-1 inner loop uses the single-call native ed_evaluate.
 
    On whenever the accelerator is enabled (the default). Set
    ED_LAYER1_NATIVE_EVAL=0 to force the full Python path for the inner loop
    (debugging / A-B parity) without disabling the accelerator elsewhere.
    """
    import os
    if os.environ.get("ED_LAYER1_NATIVE_EVAL", "1") != "1":
        return False
    from engine import accel
    return accel.enabled()
 
 
def _eval_candidate(x_raw):
    """Pure evaluation function for parallel execution.
    
    Reuses worker's PintleEngineRunner by mutating its config in-place.
    Assumes x_raw is already snapped (integers) and within bounds (CMA-ES handles this).
    Returns lightweight scalar diagnostics only.
    
    Args:
        x_raw: Candidate vector (already snapped and bounded)
    
    Returns:
        dict with 'value', 'success', and optional diagnostics
    """
    try:
        # x_raw is already snapped and bounded - just convert to array
        x = np.asarray(x_raw, dtype=np.float64)
        
        # Apply x to runner's config IN-PLACE (no clipping, CMA-ES handles bounds)
        _apply_x_to_worker_config_inplace(x, _worker_runner.config, _worker_constants)
        
        # Extract pressures from x (indices depend on injector type)
        io = int(_worker_constants.get("idx_P_O", 8))
        iof = int(_worker_constants.get("idx_P_F", 9))
        P_O_psi = float(x[io])
        P_F_psi = float(x[iof])
        P_O_Pa = P_O_psi * 6894.76
        P_F_Pa = P_F_psi * 6894.76
        
        # Evaluate using worker's runner (reused across calls).
        # Inner-loop fast path: one accelerated evaluate (chamber + nozzle + thrust)
        # + accelerated stability, ~25x faster per candidate. Falls back to the full
        # Python path for unsupported configs (e.g. pintle) or a non-converged
        # accelerated solve. The winning design is always re-evaluated at full
        # Python fidelity at finalization.
        #
        # NOTE: both paths compute the SAME delivered thrust
        # (F = zeta_n*Cf_vac*Pc*At - Pa*Ae). The old "frozen vs shifting nozzle"
        # distinction is gone -- the shifting-equilibrium nozzle was retired
        # 2026-06-28 (reaction_chemistry.py) in favour of CEA's Cf_vac, which is
        # itself a shifting-equilibrium coefficient baked into the cache.
        def _evaluate_once():
            _res = None
            # Re-read pressures from x each time: the derived-DOF solve may move them.
            P_O_Pa = float(x[io]) * 6894.76
            P_F_Pa = float(x[iof]) * 6894.76
            if _native_fast_eval_enabled():
                # NOTE: `from engine import accel` + attribute access is load-bearing.
                # tests/test_accel_is_actually_used.py patches accel.evaluate to prove
                # this seam is still reached; a `from engine.accel import evaluate`
                # import would bind at import time and silently defeat that guard.
                from engine import accel as _accel
                _res = _accel.evaluate(
                    _worker_runner.config, _worker_runner.cea_cache,
                    P_O_Pa, P_F_Pa, _worker_constants['P_ambient'])
            if _res is None:
                _res = _worker_runner.evaluate(
                    P_O_Pa, P_F_Pa,
                    P_ambient=_worker_constants['P_ambient'],
                    debug=False,
                    silent=True
                )
            return _res
 
        result = None
        _first_err = None
        _prev_grow = 1.0
        for _grow in (1.0, 1.3, 1.7, 2.2):
            if _grow != 1.0:
                # A "Supply < Demand at all Pc" first evaluation is not a bad candidate, it is
                # a throat too small to bracket a Pc for this injector -- exactly what the
                # derived-throat solve would fix, except that solve never runs without a first
                # result. Grow the throat and try again before declaring the candidate dead;
                # otherwise the whole region around the correct O/F is unreachable (measured:
                # every candidate at the right area ratio died here and CMA parked at MR 2.2).
                _at_hi = float(_worker_constants.get("derive_At_max", np.inf))
                x[0] = float(min(x[0] * (_grow / _prev_grow), _at_hi))
                _apply_x_to_worker_config_inplace(x, _worker_runner.config, _worker_constants)
            _prev_grow = _grow
            try:
                result = _evaluate_once()
            except ValueError as _ve:
                if "Supply < Demand" in str(_ve) or "Insufficient mass flow" in str(_ve):
                    _first_err = _ve
                    result = None
                else:
                    raise
            if result is not None:
                break
            if not bool(_worker_constants.get("layer1_derive_throat_from_thrust", True)):
                break
        if result is None and _first_err is not None:
            raise _first_err
 
        # Solve the derived DOFs (expansion ratio, throat area) and re-evaluate.
        # Mutates x in place so _compute_objective_value and the cached design
        # below both see the geometry that was actually evaluated.
        _cea = getattr(_worker_runner, "cea_cache", None)
        result = _layer1_solve_derived_geometry(
            x, _worker_runner.config, _worker_constants, _evaluate_once, result,
            cea_cache=_cea,
        )
 
        _terms = _layer1_objective_terms(
            result, x, _worker_requirements, _worker_constants, cea_cache=_cea)
        obj_value = float(_terms["objective"])
        _f = float(result.get("F", 0))
        _mr = float(result.get("MR", 0))
        thr_e = float(_terms.get("thrust_error", 1.0))
        of_e = float(_terms.get("of_error", 1.0))
        _mom_term = float(_terms["terms"].get("momentum_balance_penalty", 0.0))
        return {
            'value': float(obj_value),
            'success': True,
            'F': _f,
            'MR': _mr,
            'Pc': float(result.get('Pc', 0)),
            # No copy: ``result`` is a fresh dict (runner.evaluate and accel.evaluate
            # both build one per call and retain no reference to it), nothing here mutates
            # it, and returning it hands it straight to the pool -- which pickles it, and
            # pickling already yields an object the parent owns outright. The deepcopy was
            # a third copy of data that crosses a process boundary anyway, and it cost
            # 0.12 ms against a 1.17 ms evaluate(), i.e. ~10% of every worker candidate.
            'full_results': result,
            # x after the derived DOFs were solved. Differs from the candidate
            # CMA-ES proposed whenever A_throat / expansion_ratio are derived;
            # the parent must report *this* vector, not the proposal.
            'x_solved': x.tolist(),
            'P_O_Pa': float(P_O_Pa),
            'P_F_Pa': float(P_F_Pa),
            'thrust_error': float(thr_e),
            'of_error': float(of_e),
            'momentum_term': float(_mom_term),
            'inf_residual': float(_layer1_inf_residual_from_objective(float(obj_value))),
        }
    except Exception as e:
        if _worker_debug_strict:
            # Strict mode: re-raise to crash fast (for debugging)
            raise
        else:
            # Robust mode: return structured penalty
            # Classify error to give more useful feedback to optimizer/logger
            err_type = type(e).__name__
            err_msg = str(e).lower()
 
            # A bug in the evaluation code (NameError, AttributeError, TypeError, ...) is
            # NOT a bad candidate -- but this handler used to bury it as one, so every
            # candidate "failed" and the run merely looked like it converged badly. These
            # can never be a property of the design vector, so re-raise them and let the
            # run die loudly instead of silently scoring garbage.
            if isinstance(e, (NameError, AttributeError, ImportError, SyntaxError)):
                raise
 
            # Base penalty for failed evaluation (much lower than 1e10 to avoid destroying covariance)
            # Feasible solutions are ~2e4 - 5e4
            penalty_base = 1.0e7
            
            # Categorize failure
            if "geometry" in err_msg or "bound" in err_msg:
                # Geometry/Bound violation (Critical but maybe structural)
                penalty_val = penalty_base * 1.0
                fail_reason = "GeometryViolation"
            elif "negative" in err_msg or "pressure" in err_msg or "choked" in err_msg:
                # Physics failure (Negative area, pressure, unchoked, etc.)
                penalty_val = penalty_base * 0.5  # Slightly "better" failure than total nonsense
                fail_reason = "PhysicsViolation"
            elif "solver" in err_msg or "convergence" in err_msg:
                # Numerical solver failure
                penalty_val = penalty_base * 0.2  # Least bad failure, might just be stiff region
                fail_reason = "SolverConvergence"
            else:
                # Unknown/Generic
                penalty_val = penalty_base * 0.8
                fail_reason = f"Error_{err_type}"
 
            return {
                'value': float(penalty_val),
                'success': False,
                'error_type': fail_reason,
                'error_msg': str(e)[:200],
            }
 
 
def _layer1_cma_warmstart_candidates(
    x0: np.ndarray,
    *,
    lower_bounds: np.ndarray,
    upper_bounds: np.ndarray,
    span: np.ndarray,
    integer_dims: List[int],
    rng: np.random.Generator,
    executor: Any,
    n_trials: int,
    sigma_frac: float,
    eval_cache: Dict[Any, Any],
    make_cache_key_fn: Callable[[np.ndarray], Any],
    opt_state: Dict[str, Any],
    logger: logging.Logger,
) -> Tuple[np.ndarray, float]:
    """Local cloud around ``x0`` using the **same** ``_eval_candidate`` path as CMA-ES.
 
    Picks the clipped/snapped vector with lowest scalar objective. This only replaces the
    CMA initial mean when ``n_trials > 0``; it does not alter ``_compute_objective_value``,
    validation gates, or final ``evaluate()`` physics.
    """
    x0_snap = _snap_integer_dims(
        np.clip(np.asarray(x0, dtype=float), lower_bounds, upper_bounds),
        integer_dims,
    )
    if n_trials <= 0:
        return x0_snap.copy(), float("inf")
 
    n_t = int(max(1, n_trials))
    candidates: List[np.ndarray] = [x0_snap.copy()]
    sig = float(max(sigma_frac, 0.0))
    scale = np.asarray(span, dtype=float)
    # Multi-ring perturbations (tighter + moderate + wider) to escape ``BASE_INFEAS`` plateau.
    fracs = (
        float(max(0.008, 0.45 * sig)),
        float(sig),
        float(min(0.22, max(sig * 1.65, sig + 0.02))),
    )
    for k in range(n_t - 1):
        f_k = fracs[k % len(fracs)]
        noise = rng.standard_normal(len(x0_snap)) * f_k * scale
        xq = np.clip(x0_snap + noise, lower_bounds, upper_bounds)
        candidates.append(_snap_integer_dims(xq, integer_dims))
 
    nw = int(getattr(executor, "_max_workers", 1) or 1)
    chunksize = max(1, len(candidates) // (nw * 4))
    results = list(executor.map(_eval_candidate, candidates, chunksize=chunksize))
 
    best_f = float("inf")
    best_x = x0_snap.copy()
    for cand, res in zip(candidates, results):
        obj_val = float(res["value"])
        cache_key = make_cache_key_fn(cand)
        eval_cache[cache_key] = {
            "value": obj_val,
            "success": bool(res.get("success", False)),
        }
        opt_state["function_evaluations"] = int(opt_state.get("function_evaluations", 0)) + 1
        _store_last_good_eval_bundle_from_worker_res(res, opt_state)
        if not res.get("success", True):
            reason = res.get("error_type", "Unknown")
            opt_state["num_failures"] = opt_state.get("num_failures", 0) + 1
            if "fail_counts" not in opt_state:
                opt_state["fail_counts"] = {}
            opt_state["fail_counts"][reason] = opt_state["fail_counts"].get(reason, 0) + 1
        if obj_val < best_f:
            best_f = obj_val
            best_x = cand.copy()
 
    logger.info(
        "Layer 1 CMA warm-start: %d candidates (sigma_frac=%.4g × span), best objective=%.6g",
        len(candidates),
        sigma_frac,
        best_f,
    )
    return best_x, best_f
 
 
def _layer1_sync_best_from_worker_eval(
    opt_state: Dict[str, Any],
    x_vec: np.ndarray,
    obj_val: float,
    *,
    parent_objective: Optional[Callable[[np.ndarray], float]] = None,
) -> None:
    """Keep ``best_objective`` / ``best_x`` aligned with parallel ``_eval_candidate`` results.
 
    When ``parent_objective`` is supplied, re-run the full parent ``objective()`` once on a
    new global best so ``iteration_history``, ``best_config``, and penalty breakdown fields
    stay populated (parallel workers only return scalars).
    """
    if not np.isfinite(obj_val):
        return
    cur = float(opt_state.get("best_objective", float("inf")))
    if obj_val < cur and _layer1_feasible_scalar_objective(obj_val):
        opt_state["best_objective"] = float(obj_val)
        opt_state["best_x"] = np.asarray(x_vec, dtype=float).copy()
        opt_state["last_best_eval"] = int(opt_state.get("function_evaluations", 0))
        if parent_objective is not None:
            try:
                parent_objective(np.asarray(x_vec, dtype=float))
            except Exception:
                pass
 
 
def _layer1_emit_objective_plot_point(
    objective_callback: Optional[Callable[[int, float, float], None]],
    opt_state: Dict[str, Any],
    iteration: int,
    current_obj: float,
    best_obj: float,
) -> None:
    """SSE / UI objective curve (parallel CMA does not call ``objective()``).
 
    ``iteration`` arrives from two different counters -- the parent candidate index in
    ``_eval_candidate`` and ``function_evaluations`` in the parallel CMA generation loop --
    and both are reset between phases. Plotted raw, the x-axis folded back on itself
    (observed: 1, 17, 65, 113, 161, 209, then 2, 3, 4 ...), which made the curve unreadable.
    Clamp to a non-decreasing sequence here, at the single point every emission passes
    through, rather than trying to keep every call site's counter in sync.
    """
    if objective_callback is None:
        return
    x = int(iteration)
    x_max = int(opt_state.get("_plot_x_max", 0))
    if x <= x_max:
        x = x_max + 1
    opt_state["_plot_x_max"] = x
    try:
        objective_callback(x, float(current_obj), float(best_obj))
    except Exception:
        pass
 
 
def _layer1_infeasibility_reason(runner, x, requirements: dict, constants: dict) -> Optional[str]:
    """One sentence on WHICH hard constraint held the best candidate out of the feasible set.
 
    A run whose every candidate sat on the 1e6 infeasibility floor used to end with
    "objective inf" and "Validation failed", which told the user nothing. Re-evaluate the best
    design in-process with the infeasibility trace on and name the dominant gate.
    """
    global _INFEAS_TRACE_ON
    try:
        idx_P_O = 11 if constants.get("injector_type") == "impinging" else 8
        P_O = float(x[idx_P_O]) * 6894.76
        P_F = float(x[idx_P_O + 1]) * 6894.76
        result = runner.evaluate(P_O, P_F, silent=True)
    except Exception as e:
        return f"No feasible design: the best candidate could not even be evaluated ({type(e).__name__}: {str(e)[:120]})."
    prev, n0 = _INFEAS_TRACE_ON, len(_INFEAS_TRACE)
    _INFEAS_TRACE_ON = True
    try:
        _compute_objective_value(result, np.asarray(x, dtype=float), requirements, constants)
    except Exception as e:
        return f"No feasible design: objective re-evaluation failed ({type(e).__name__})."
    finally:
        _INFEAS_TRACE_ON = prev
    if len(_INFEAS_TRACE) <= n0:
        return None
    tr = _INFEAS_TRACE.pop()
    geom = float(tr.get("geometry", 0.0))
    stab = float(tr.get("stability", geom)) - geom
    wall = float(tr.get("wall_tilt", tr.get("stability", geom))) - float(tr.get("stability", geom))
    parts = []
    if wall > 0:
        tilt = tr.get("tilt_deg", float("nan"))
        lim = float(constants.get("layer1_resultant_tilt_max_deg", 0.0))
        parts.append((wall, f"the spray resultant tilts {tilt:+.1f} deg outward toward the wall (limit {lim:g} deg) -- "
                            "lower the oxidizer jet angle, raise the fuel jet angle, or widen the angle bands"))
    if stab > 0:
        parts.append((stab, "a stability gate (minimum score / margins) is not met -- lower min_stability_score or stiffen the injector"))
    if geom > 0:
        parts.append((geom, "injector packing, flow capacity, or chamber proportions violate a hard limit -- widen the chamber OD or the jet bounds"))
    if not parts:
        # Re-evaluated in isolation the best design passes every gate: the search is stuck ON a
        # constraint boundary and CMA's samples keep landing a hair outside it. For a doublet that
        # is almost always the spray-resultant tilt limit, which defaults to exactly 0 deg outward.
        lim = float(constants.get("layer1_resultant_tilt_max_deg", 0.0))
        if constants.get("injector_type") == "impinging":
            return ("No candidate cleared every hard constraint, yet the best design re-evaluates as feasible "
                    f"on its own: the search is pinned on the spray-resultant tilt limit ({lim:g} deg outward). "
                    "Re-run, or allow a degree of outward tilt (layer1_resultant_tilt_max_deg) if the liner can take it.")
        return ("No candidate cleared every hard constraint, yet the best design re-evaluates as feasible on its "
                "own: the search is pinned on a constraint boundary. Re-run, or relax the tightest gate slightly.")
    parts.sort(key=lambda t: -t[0])
    return "No candidate cleared every hard constraint. On the best one, " + parts[0][1] + "."
 
 
def run_layer1_global_search(
    objective: Callable[[np.ndarray], float],
    bounds: list,
    x0: np.ndarray,
    max_evals: int = 150,
    random_seed: int = 42,
) -> np.ndarray:
    """
    Lightweight global search for Layer 1 using random sampling + short DE.
 
    This is intended to very quickly improve the starting point before the
    main local optimizer (L-BFGS-B) runs in the orchestrator.
 
    - Keeps evaluation budget small (max_evals) to avoid long runtimes.
    - Always respects the provided bounds.
    - Falls back gracefully if scipy's differential_evolution is unavailable.
    """
    try:
        from scipy.optimize import differential_evolution
    except Exception:
        differential_evolution = None
 
    if max_evals <= 0 or objective is None:
        return x0
 
    rng = np.random.default_rng(random_seed)
 
    bounds_arr = np.asarray(bounds, dtype=float)
    lower = bounds_arr[:, 0]
    upper = bounds_arr[:, 1]
 
    # Ensure starting point is within bounds
    best_x = np.clip(np.asarray(x0, dtype=float), lower, upper)
    try:
        best_f = float(objective(best_x))
    except Exception:
        # If evaluation fails, just return the original guess
        return x0
 
    evals_used = 1
    dim = best_x.size
 
    # ------------------------------------------------------------------
    # Phase 1: Random sampling within bounds (very small number of points)
    # ------------------------------------------------------------------
    n_random = max(5, min(20, max_evals // 3))
    for _ in range(n_random):
        if evals_used >= max_evals:
            break
        candidate = lower + rng.random(dim) * (upper - lower)
        try:
            f_val = float(objective(candidate))
        except Exception:
            evals_used += 1
            continue
        evals_used += 1
        if np.isfinite(f_val) and f_val < best_f:
            best_f = f_val
            best_x = candidate
 
    # ------------------------------------------------------------------
    # Phase 2: Very short Differential Evolution (if available)
    # ------------------------------------------------------------------
    if differential_evolution is not None and evals_used < max_evals:
        # Rough heuristic to keep DE cheap; cap iterations and population.
        # For typical Layer 1 dimensionality (~20 vars) this keeps runtime modest.
        remaining_evals = max_evals - evals_used
        popsize = 8
        # Each DE iter uses approximately popsize * dim evaluations
        approx_evals_per_iter = max(1, popsize * dim)
        maxiter = max(1, min(5, remaining_evals // approx_evals_per_iter))
 
        if maxiter > 0:
            # Wrap objective to track best solution without exceeding budget
            def wrapped_obj(v: np.ndarray) -> float:
                nonlocal best_x, best_f, evals_used
                if evals_used >= max_evals:
                    # Return current best to encourage convergence without new work
                    return best_f
                try:
                    f_val_inner = float(objective(v))
                except Exception:
                    evals_used += 1
                    return 1e7
                evals_used += 1
                if np.isfinite(f_val_inner) and f_val_inner < best_f:
                    best_f = f_val_inner
                    best_x = np.asarray(v, dtype=float)
                return f_val_inner
 
            try:
                _ = differential_evolution(
                    wrapped_obj,
                    bounds=bounds,
                    maxiter=maxiter,
                    popsize=popsize,
                    tol=0.01,
                    polish=False,
                    updating="deferred",
                    mutation=(0.5, 1.0),
                    recombination=0.7,
                    seed=random_seed,
                )
            except Exception:
                # If DE fails for any reason, just keep the best point found so far.
                pass
 
    return best_x
 
 
def _layer1_check_of_target_in_cea_range(config_obj: Any, optimal_of: Any) -> None:
    """Refuse a target O/F the propellant's CEA table cannot evaluate.
 
    A propellant switch keeps the previous design target, so an ethalox target of 1.4 left
    behind on a methalox config used to run a full optimization against a table that stops at
    2.4 -- the mixture ratio pinned at the table edge and the run returned a huge objective with
    nothing to say why. Fail before any work is done, with the fix in the message.
    """
    try:
        mr_range = config_obj.combustion.cea.MR_range
        lo, hi = float(mr_range[0]), float(mr_range[1])
        of = float(optimal_of)
    except (AttributeError, TypeError, ValueError, IndexError):
        return
    if not (np.isfinite(of) and lo <= of <= hi):
        preset = getattr(config_obj, "propellant_preset", None) or "this propellant"
        raise ValueError(
            f"Design target O/F {of:.2f} is outside the CEA table for {preset} "
            f"(MR_range [{lo:.2f}, {hi:.2f}]). Set optimal_of_ratio inside that range in Design "
            f"Requirements -- switching propellant keeps the previous target."
        )
 
 
def _layer1_resolve_of_target(
    config_obj: Any, optimal_of: Any, cea_cache: Any = None, Pc_pa: float = 3.0e6,
    Pa: float = 101325.0,
) -> Tuple[float, Optional[str]]:
    """The O/F Layer 1 designs to, and a warning when it is not the one requested.
 
    A target outside the propellant's CEA table (a blank template keeps the previous
    propellant's O/F) cannot be evaluated. Rather than abort, design to the O/F of peak ideal
    ambient Isp at ``Pc_pa`` inside the table -- the conventional starting point (Sutton &
    Biblarz ch. 5) -- or, without a table, the nearest table edge, and say so.
    """
    try:
        lo, hi = (float(v) for v in config_obj.combustion.cea.MR_range)
    except (AttributeError, TypeError, ValueError):
        return float(optimal_of), None
    try:
        of = float(optimal_of)
    except (TypeError, ValueError):
        of = float("nan")
    if np.isfinite(of) and lo <= of <= hi:
        return of, None
    preset = getattr(config_obj, "propellant_preset", None) or "this propellant"
    grid = np.linspace(lo, hi, 121)
    isp = np.array([_layer1_ideal_isp_s(
        cea_cache, m, Pc_pa, Pa,
        _layer1_eps_for_exit_pressure_cea(cea_cache, m, Pc_pa, Pa) or getattr(cea_cache, "eps_min", 4.0))
        for m in grid]) if _layer1_cea_ok(cea_cache) else np.full(grid.shape, np.nan)
    if np.any(np.isfinite(isp)):
        new = float(grid[int(np.nanargmax(isp))])
        why = f"the peak ideal Isp O/F at {Pc_pa / 6894.757:.0f} psia"
    else:
        new = float(np.clip(of if np.isfinite(of) else 0.5 * (lo + hi), lo, hi))
        why = "the nearest table edge"
    msg = (f"Design target O/F {of:.2f} is outside the CEA table for {preset} "
           f"(MR_range [{lo:.2f}, {hi:.2f}]); designing to O/F {new:.3f}, {why}. Set "
           f"optimal_of_ratio in Design Requirements -- switching propellant keeps the previous target.")
    return new, msg
 
 
def run_layer1_optimization(
    config_obj: PintleEngineConfig,
    runner: PintleEngineRunner,
    requirements: Dict[str, Any],
    target_burn_time: float,
    tolerances: Dict[str, float],
    pressure_config: Dict[str, Any],
    update_progress: Optional[Callable[[str, float, str], None]] = None,
    log_status: Optional[Callable[[str, str], None]] = None,
    objective_callback: Optional[Callable[[int, float, float], None]] = None,
    stop_event: Optional[Any] = None,  # threading.Event for stop signal
    layer1_max_iterations: Optional[int] = None,
    layer1_cma_restarts: Optional[int] = None,
    layer1_smoke: bool = False,
) -> Tuple[PintleEngineConfig, Dict[str, Any]]:
    """
    Run complete Layer 1 optimization: geometry + initial tank pressures.
    
    This function contains ALL Layer 1 optimization logic:
    - Setup (bounds, initial guess)
    - Objective function definition
    - Optimization loop (CMA-ES with random restarts + L-BFGS-B)
    - Validation
    - Results packaging
    
    Note:
        Default ``max_iterations`` is 150 for robust convergence (override via ``layer1_max_iterations``
        for smoke tests). Design vector is **10** DOFs for pintle and **13** for impinging injectors
        (paired unlike doublets: shared ``n_doublets`` for LOX/fuel counts, independent jets per side).
        Random CMA restarts default to 3 (override via ``layer1_cma_restarts``).
        Set ``layer1_smoke=True`` to force pure CMA-ES (ignore ``hybrid_cma_blocks``) and,
        unless ``layer1_cma_restarts`` is set explicitly, use a single CMA restart for short runs.
 
    Args:
        config_obj: Base engine configuration
        runner: Engine runner (for validation)
        requirements: Design requirements dict
        target_burn_time: Target burn time [s]
        tolerances: Tolerance dict (thrust, apogee)
        pressure_config: Pressure configuration dict
        update_progress: Optional progress callback (stage, progress, message)
        log_status: Optional status logging callback (stage, message)
        objective_callback: Optional callback for objective history (iteration, objective, best_objective)
        layer1_smoke: When True, force pure CMA-ES and (if ``layer1_cma_restarts`` is unset) a single restart.
 
    Returns:
        optimized_config: Optimized engine configuration
        results: Results dict with performance, validation, history, etc.
    """
 
    # Set up Layer 1 logging
    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
    # Ensure output/logs directory exists
    output_logs_dir = Path(__file__).resolve().parents[3] / "output" / "logs"
    output_logs_dir.mkdir(parents=True, exist_ok=True)
    # PID too: two runs started in the same second (a sweep) wrote one interleaved file.
    log_file_path = output_logs_dir / f"layer1_static_{timestamp}_{os.getpid()}.log"
    
    # Create logger for Layer 1
    layer1_logger = logging.getLogger('layer1_static')
    layer1_logger.setLevel(logging.INFO)
    
    # Remove existing handlers to avoid duplicates
    layer1_logger.handlers.clear()
    
    # File handler
    file_handler = logging.FileHandler(log_file_path, mode='w', encoding='utf-8')
    file_handler.setLevel(logging.INFO)
    file_formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
    file_handler.setFormatter(file_formatter)
    layer1_logger.addHandler(file_handler)
    
    # Prevent propagation to root logger
    layer1_logger.propagate = False
    
    layer1_logger.info("="*70)
    layer1_logger.info("Layer 1: Static Optimization")
    layer1_logger.info("="*70)
    layer1_logger.info(f"Log file: {log_file_path}")
    
    # Default callbacks
    if update_progress is None:
        def update_progress(stage: str, progress: float, message: str):
            pass
    if log_status is None:
        def log_status(stage: str, message: str):
            pass
    
    # Helper to check stop event
    class OptimizationStopped(Exception):
        """Exception raised when optimization is stopped by user."""
        pass
    
    def check_stop():
        """Check if optimization should stop and raise exception if so."""
        if stop_event is not None and stop_event.is_set():
            raise OptimizationStopped("Optimization stopped by user")
    
    # Extract requirements
    target_thrust = requirements.get("target_thrust", 7000.0)
    optimal_of = requirements.get("optimal_of_ratio", 2.3)
    layer1_warnings: List[str] = []
    min_stability = float(requirements.get("min_stability_margin", _LAYER1_DEFAULT_MIN_STABILITY_MARGIN))
 
    def _resolve_Lstar_bounds_from_req_and_config() -> Tuple[float, float]:
        """Layer‑1 DOF ``x[1]`` is L* [m]. Prefer ``requirements``; fill missing keys from ``config_obj.design_requirements``."""
        mn_raw = requirements.get("min_Lstar", None)
        mx_raw = requirements.get("max_Lstar", None)
        try:
            dr = getattr(config_obj, "design_requirements", None)
            if mn_raw is None and dr is not None:
                mn_raw = getattr(dr, "min_Lstar", None)
            if mx_raw is None and dr is not None:
                mx_raw = getattr(dr, "max_Lstar", None)
        except (TypeError, ValueError, AttributeError):
            pass
        try:
            mn = float(mn_raw) if mn_raw is not None else 0.95
        except (TypeError, ValueError):
            mn = 0.95
        try:
            mx = float(mx_raw) if mx_raw is not None else 1.27
        except (TypeError, ValueError):
            mx = 1.27
        if not np.isfinite(mn) or mn <= 0:
            mn = 0.95
        if not np.isfinite(mx) or mx <= 0:
            mx = 1.27
        if mx <= mn:
            mx = mn + 1e-6
        return mn, mx
 
    min_Lstar, max_Lstar = _resolve_Lstar_bounds_from_req_and_config()
    layer1_logger.info(
        "Layer 1 optimizing L* [m] within [%.5f, %.5f] (x[1]); freeze ``design_requirements.frozen_parameters.Lstar_mm`` for a single target.",
        min_Lstar,
        max_Lstar,
    )
 
    max_chamber_od = requirements.get("max_chamber_outer_diameter", 0.15)
    # Total OD->inner-diameter wall, DERIVED per side as metal case + ablative liner
    # (see utils.total_wall_thickness_m). Layer 3 re-sizes the liner field itself,
    # so reruns pick up the sized stack automatically.
    wall_total_m = _layer1_total_wall_thickness_m(config_obj)
    layer1_logger.info(
        "Layer 1 wall (OD - inner): %.2f mm total (%.2f mm/side = metal case + ablative liner).",
        wall_total_m * 1e3, wall_total_m * 0.5e3,
    )
    max_nozzle_exit = requirements.get("max_nozzle_exit_diameter", 0.101)
    thrust_tol = tolerances.get("thrust", 0.10)
    
    # Target exit pressure = the site's ambient, the one every evaluation below is run at
    # (P_ambient). The solver's own (_layer1_site_ambient_pa), so Layer 1 designs at the pressure
    # forward mode, the Time-Series tab and Layer X evaluate the design at.
    target_P_exit = _layer1_site_ambient_pa(config_obj)
    layer1_logger.info(f"Site ambient (target exit pressure): {target_P_exit:.1f} Pa ({target_P_exit/101325.0:.3f} atm)")
    
    # An O/F the propellant's table cannot evaluate (a blank template keeps the previous
    # propellant's) is replaced, with a warning, rather than aborting the run.
    _caps = [v for v in (requirements.get("max_lox_tank_pressure_psi"),
                         requirements.get("max_fuel_tank_pressure_psi")) if v]
    _of_pc_pa = (float(requirements.get("target_chamber_pressure_psi") or 0.0)
                 or (min(float(v) for v in _caps) / 1.3 if _caps else 435.0)) * 6894.757
    _of_cea = getattr(runner, "cea_cache", None)
    optimal_of, _of_msg = _layer1_resolve_of_target(
        config_obj, optimal_of, _of_cea if _layer1_cea_ok(_of_cea) else None, _of_pc_pa,
        float(target_P_exit))
    if _of_msg:
        requirements = dict(requirements)
        requirements["optimal_of_ratio"] = optimal_of
        layer1_warnings.append(_of_msg)
        layer1_logger.warning(_of_msg)
        log_status("warning", _of_msg)
 
    layer1_logger.info(f"Target thrust: {target_thrust:.1f} N")
    layer1_logger.info(f"Target O/F ratio: {optimal_of:.2f}")
    layer1_logger.info(f"Min stability margin: {min_stability:.2f}")
    layer1_logger.info(f"Target burn time: {target_burn_time:.2f} s")
    
    # Default max_iterations for robust convergence (10-DOF pintle / 13-DOF impinging geometry + pressures)
    # With popsize ~48: many evaluations per CMA iteration unless clamped for smoke tests.
    # Split across num_restarts as generations/restart; sized so each restart keeps ~50 generations
    # while allowing enough restarts for genuine multi-start global exploration (see restart loop).
    # CMA generations. The hybrid path spends max_iterations x popsize evaluations, so at
    # popsize=48 this sets the total budget: 625 x 48 = 30000 (was 200 -> 9600, ~10 s, which
    # was not enough to reliably escape a bad basin -- observed 1 run in 3 landing somewhere
    # useless). Everything downstream is derived by division from this (per-restart generations,
    # hybrid cycle budgets, block budgets), so raising it scales every stage together.
    max_iterations = 1042
    if layer1_max_iterations is not None:
        max_iterations = max(1, int(layer1_max_iterations))
 
    layer1_logger.info(f"Max iterations: {max_iterations}")
    layer1_logger.info("")
    
    # Get max pressures (stagnation search must never exceed these [psi]).
    max_lox_P_psi = float(pressure_config.get("max_lox_pressure_psi", 700))
    max_fuel_P_psi = float(pressure_config.get("max_fuel_pressure_psi", 850))
    # Defensive: if anything passed a looser pressure_config than ``config_obj.design_requirements``,
    # use the stricter of the two (common when requirements are edited in the UI but a stale field lingers).
    try:
        _dr_cap = getattr(config_obj, "design_requirements", None)
        if _dr_cap is not None:
            _lox_cap = getattr(_dr_cap, "max_lox_tank_pressure_psi", None)
            if _lox_cap is not None and float(_lox_cap) > 0.0:
                max_lox_P_psi = min(max_lox_P_psi, float(_lox_cap))
            _f_cap = getattr(_dr_cap, "max_fuel_tank_pressure_psi", None)
            if _f_cap is not None and float(_f_cap) > 0.0:
                max_fuel_P_psi = min(max_fuel_P_psi, float(_f_cap))
    except (TypeError, ValueError, AttributeError):
        pass
    layer1_logger.info(
        "Layer 1 tank stagnation caps (psi): max LOX=%.1f, max fuel=%.1f",
        max_lox_P_psi,
        max_fuel_P_psi,
    )
    psi_to_Pa = 6894.76
    
    # Objective tolerance for early stopping (weighted scalar; see ``primary_relative_residual`` for physics scale)
    obj_tolerance = 2.0  # For good solution: obj ≈ 1.25, so 2.0 is reasonable
    layer1_lbfgs_gtol = float(max(1e-15, _requirement_float(requirements, "layer1_lbfgs_gtol", 1e-9)))
    _lbfgs_2 = requirements.get("layer1_lbfgs_second_pass")
    layer1_lbfgs_second_pass = True if _lbfgs_2 is None else bool(_lbfgs_2)
    
    update_progress("Layer 1: Setup", 0.01, "Initializing Layer 1 optimization...")
    
    # Prepare base config
    config_base = copy.deepcopy(config_obj)
    if hasattr(config_base, 'injector') and config_base.injector.type == "pintle":
        if hasattr(config_base.injector.geometry, 'lox'):
            config_base.injector.geometry.lox.theta_orifice = 90.0
 
    l1_injector_type = getattr(getattr(config_base, "injector", None), "type", "pintle")
    if l1_injector_type not in ("pintle", "impinging"):
        raise ValueError(
            "Layer 1 static optimization supports injector types 'pintle' and 'impinging' only; "
            f"got {l1_injector_type!r}."
        )
    idx_P_O = 11 if l1_injector_type == "impinging" else 8
    idx_P_F = 12 if l1_injector_type == "impinging" else 9
    layer1_integer_dims = [4] if l1_injector_type == "impinging" else [6]
 
    # Whole-degree impingement angles (doublets only).
    #
    # A drill jig is indexed in whole degrees -- nobody sets up a 43.7 deg bore at
    # collegiate scale -- so a fractional angle is an optimum you cannot build, and
    # rounding it afterwards moves impingement distance, momentum ratio and SMD off
    # the point that was actually scored. Snapping inside the evaluation means every
    # candidate ranked is one the shop can cut. Indices 6 / 9 are impingement_angle_O
    # and impingement_angle_F; the pintle vector has no angle DOF (index 6 there is
    # n_orifices, which is already integral), hence the injector-type guard.
    if l1_injector_type == "impinging" and _requirement_bool(
        requirements, "layer1_integer_jet_angles", True
    ):
        layer1_integer_dims = layer1_integer_dims + [6, 9]
        layer1_logger.info(
            "Layer 1: impingement angles snapped to whole degrees (machining limit); "
            "set layer1_integer_jet_angles=false to search fractional angles."
        )
 
    # Enable turbulence coupling
    if hasattr(config_base, 'combustion') and hasattr(config_base.combustion, 'efficiency'):
        config_base.combustion.efficiency.use_turbulence_coupling = True
    
    # Calculate initial A_throat guess. If the user set a chamber-pressure target, SIZE THE
    # SEED THROAT FOR IT — F = Cf·Pc·At, so a throat seeded for the old hardcoded 580 psi is
    # ~35-65% undersized when the target is 300-450 psi, and CMA starts in the wrong basin
    # (low thrust at pinned Pc) it then has to climb out of.
    _pc_tgt_seed = requirements.get("target_chamber_pressure_psi")
    if _pc_tgt_seed is not None and float(_pc_tgt_seed) > 0:
        Pc_est_psi = float(_pc_tgt_seed)
    else:
        Pc_est_psi = 580.0
    Pc_est = Pc_est_psi * psi_to_Pa
    Cf_est = 1.5
    A_throat_init = target_thrust / (Cf_est * Pc_est) if Pc_est > 0 else 0.001
    A_throat_init = max(float(A_throat_init), 5e-5)
    
    # Calculate bounds ensuring injector area < throat area (pintle) or manufacturable jets (impinging)
    min_A_throat_safe = 5e-5
 
    # Stagnation-pressure search box: fractions of respective tank caps (independent LOX vs fuel).
    # Equal optimizer values (e.g. 720/720 psi) can occur when caps and fractions match and the objective is symmetric —
    # there is **no** equality constraint forcing P_O == P_F.
    # Search box for tank stagnation pressure, as a fraction of the user's cap.
    #
    # This used to be [0.65, 0.85], which made the top 15% of the user's own pressure cap
    # UNREACHABLE: a 600 psi cap could only ever be searched over 390-510 psi, so a design that
    # needed 600 psi to make thrust simply could not be found and the run looked "non-convergent".
    # The cap is already the physical limit -- the search must be allowed to reach it. The lower
    # edge stays well below 1 so low-Pc designs remain reachable.
    #
    # ``or`` would map an explicit 0.0 to the default (the layer1_W_PC falsy-value bug class),
    # so these test for None instead.
    _fmin = requirements.get("layer1_stagnation_pressure_frac_min")
    _fmax = requirements.get("layer1_stagnation_pressure_frac_max")
    min_P_ratio = float(_fmin) if _fmin is not None else 0.35
    max_P_ratio = float(_fmax) if _fmax is not None else 1.00
    if max_P_ratio <= min_P_ratio:
        max_P_ratio = min_P_ratio + 1e-3
    exp_ratio_lo = _requirement_float(requirements, "layer1_expansion_ratio_min", 4.0)
    exp_ratio_hi = _requirement_float(requirements, "layer1_expansion_ratio_max", 12.0)
    if exp_ratio_hi <= exp_ratio_lo:
        exp_ratio_hi = exp_ratio_lo + 1e-3
 
    # Never search outside the CEA table's own expansion-ratio grid. The 3D cache is built over
    # a fixed eps_range; asking it for eps outside that range interpolates off the end of the
    # data and returns a confident, wrong Cf. Observed live: a config allowing eps >= 3.0 against
    # a cache built for [4, 15] converged at eps = 3.83, i.e. silently extrapolated. The config
    # may narrow the window; it may not widen it past what the table actually covers.
    try:
        _cache_eps = getattr(getattr(config_obj.combustion, "cea", None), "eps_range", None)
        if _cache_eps and len(_cache_eps) == 2:
            _ce_lo, _ce_hi = float(_cache_eps[0]), float(_cache_eps[1])
            _clamped_lo, _clamped_hi = max(exp_ratio_lo, _ce_lo), min(exp_ratio_hi, _ce_hi)
            if (_clamped_lo, _clamped_hi) != (exp_ratio_lo, exp_ratio_hi):
                layer1_logger.warning(
                    "Expansion-ratio search [%g, %g] exceeds the CEA cache grid [%g, %g]; "
                    "clamping to [%g, %g] to avoid extrapolating the table.",
                    exp_ratio_lo, exp_ratio_hi, _ce_lo, _ce_hi, _clamped_lo, _clamped_hi,
                )
            exp_ratio_lo, exp_ratio_hi = _clamped_lo, _clamped_hi
            if exp_ratio_hi <= exp_ratio_lo:
                exp_ratio_hi = exp_ratio_lo + 1e-3
    except (AttributeError, TypeError, ValueError):
        pass
 
    # Throat floor from target thrust and available pressure envelope.
    # Prevents optimizer spending budget in clearly unreachable tiny-throat basins.
    _cf_hi_for_floor = _requirement_float(requirements, "layer1_cf_upper_bound_for_throat_floor", 1.8)
    _pc_floor_factor = _requirement_float(requirements, "layer1_pc_fraction_for_throat_floor", 0.75)
    _pc_cap_psi = min(max_lox_P_psi * max_P_ratio, max_fuel_P_psi * max_P_ratio)
    _pc_cap_pa = _pc_cap_psi * psi_to_Pa * max(0.1, _pc_floor_factor)
    if target_thrust > 0 and _pc_cap_pa > 0 and _cf_hi_for_floor > 0:
        _a_req = target_thrust / (_cf_hi_for_floor * _pc_cap_pa)
        if np.isfinite(_a_req) and _a_req > 0:
            # Keep some slack below the rough feasibility line.
            min_A_throat_safe = max(min_A_throat_safe, 0.7 * float(_a_req))
            layer1_logger.info(
                "A_throat lower bound raised by thrust-feasibility floor: %.2f mm^2 "
                "(target %.0f N, Pc_cap≈%.1f psi, Cf_hi=%.2f)",
                min_A_throat_safe * 1e6,
                target_thrust,
                _pc_cap_psi,
                _cf_hi_for_floor,
            )
    # OD floor from the smallest reachable throat, not from the envelope cap: below
    # wall + (D/Dt)_min * Dt_min every reachable throat violates the chamber-shape band.
    # 0.5 x cap put a 73 mm bore floor under a 1 kN engine that wants ~40 mm (DEF-09).
    min_outer_diameter = _layer1_chamber_od_floor_m(
        max_chamber_od, wall_total_m, min_A_throat_safe,
        _requirement_float(requirements, "layer1_chamber_dt_ratio_min", 2.2))
    if not (min_outer_diameter < max_chamber_od):
        layer1_logger.warning(
            "Chamber OD cap %.1f mm cannot hold the %.1f mm wall plus a bore at the D/Dt floor "
            "for the smallest reachable throat; the chamber-shape term will report it.",
            max_chamber_od * 1e3, wall_total_m * 1e3)
        min_outer_diameter = max_chamber_od * 0.5
    # Throat ceiling from thrust at the lowest Cf / stagnation fraction the search allows
    # (was a flat 4000 mm^2, which binds above ~15 kN).
    A_throat_hi = max(4.0e-3, float(target_thrust) / (
        1.3 * max(min_P_ratio, 0.05) * min(max_lox_P_psi, max_fuel_P_psi) * psi_to_Pa))
 
    if l1_injector_type == "impinging":
        D_inner_bounds = impinging_chamber_inner_diameter_for_bounds(
            config_base,
            max_chamber_outer_diameter_m=max_chamber_od,
            wall_thickness_m=wall_total_m,
        )
        n_hi_int = impinging_n_elements_hi_int(D_inner_bounds)
        _nd_cap = requirements.get("layer1_impinging_n_doublets_max")
        if _nd_cap is not None:
            try:
                _c = int(_nd_cap)
                if _c >= 5:
                    n_hi_int = min(n_hi_int, _c)
            except (TypeError, ValueError):
                pass
        # Upper continuous edge so clip→round cannot exceed n_hi_int (avoid legacy +3.99 overrun).
        n_hi_upper = float(n_hi_int) + 0.499
        d_jet_hi = impinging_d_jet_upper_bound_m(D_inner_bounds)
        spacing_hi = impinging_spacing_upper_bound_m(D_inner_bounds)
 
        # Impingement-angle SEARCH BOUNDS derived from the user's requirement instead of the old
        # hardcoded (15, 85), which made layer1_impinging_angle_deg_min/max unable to affect the
        # search at all -- they fed only a soft penalty (W_IMPINGING_ANGLE ~400, nothing against
        # W_MOM), so asking for a 55 deg floor still returned 42/48 deg for 0.04 objective points.
        #
        # CAREFUL -- two different quantities share the word "angle":
        #   * each design variable is ONE JET's inclination from the chamber axis, and
        #   * layer1_impinging_angle_deg_min/max bounds the INCLUDED angle, the sum of the two.
        # Applying the included-angle band per-jet is wrong: both jets went to the 55 deg floor,
        # making an included 110 deg, far outside the [55, 90] the user actually asked for, for a
        # 160000-point penalty. So map the band to per-jet limits, widened by the permitted
        # asymmetry so an asymmetric pair inside the included band is still reachable.
        _ang_lo_req = requirements.get("layer1_impinging_angle_deg_min")
        _ang_hi_req = requirements.get("layer1_impinging_angle_deg_max")
        _incl_lo = float(_ang_lo_req) if _ang_lo_req is not None else 30.0
        _incl_hi = float(_ang_hi_req) if _ang_hi_req is not None else 170.0
        _asym = _requirement_float(requirements, "layer1_impinging_jet_angle_max_asym_deg", 28.0)
        imp_angle_lo_bound = float(np.clip(0.5 * (_incl_lo - _asym), 5.0, 89.0))
        imp_angle_hi_bound = float(np.clip(0.5 * (_incl_hi + _asym), 6.0, 89.0))
        # Never let the DERIVED per-jet box come out tighter than the historical [15, 85]. The
        # included-angle band is a preference expressed through W_IMPINGING_ANGLE; shrinking the
        # hard search box to match it cut the reachable region enough that a random start often
        # never found a feasible point at all, and CMA then died on the flat 1e6 infeasible
        # plateau after ~1000 of 50016 evaluations. Measured: 2 of 4 random seeds failed.
        imp_angle_lo_bound = min(imp_angle_lo_bound, 15.0)
        imp_angle_hi_bound = max(imp_angle_hi_bound, 85.0)
        # MANUFACTURING FLOOR on a single jet's inclination. The widening above can drop the
        # per-jet lower bound to 10 deg or less, and the optimiser will use it: the 8 kN
        # ethalox point came back with theta_O = 13 deg. A hole that shallow is not drillable
        # on a flat face without a spot-face or a jig -- the drill walks on entry -- and the
        # element gets very long for the standoff it buys. This is a HARD bound, not a
        # preference, because no weight in the objective knows about drilling.
        _jet_lo = requirements.get("layer1_impinging_jet_angle_min_deg")
        if _jet_lo is not None:
            try:
                _jet_lo = float(_jet_lo)
                if np.isfinite(_jet_lo) and 0.0 < _jet_lo < imp_angle_hi_bound:
                    imp_angle_lo_bound = max(imp_angle_lo_bound, _jet_lo)
            except (TypeError, ValueError):
                pass
        # MACHINING CEILING on a single jet's inclination, the mirror of the floor above.
        # theta is measured from the chamber AXIS, so the drill meets the face PLANE at
        # (90 - theta). Requiring at least `min_face_incidence` degrees of incidence is exactly
        # theta <= 90 - min_face_incidence. This has to be applied AFTER the max(..., 85.0)
        # widening or that line hands the box straight back. Measured why it matters: the
        # first design to clear every gate put the fuel jet at 69 deg -- 21 deg of incidence,
        # and 35.4 mm of passage through a 12.7 mm plate.
        _inc_req = requirements.get("layer1_injector_min_face_incidence_deg")
        _pl = _layer1_plate(config_obj)
        if _inc_req is not None and _pl.get("face") == "contoured" and _pl.get("back") == "channels":
            # Every exit leaves its flank square on a contoured face, and with channels the
            # passage length is set by the hole's L/d rather than t / cos(theta): the ceiling
            # has nothing left to protect. (With a plenum back it still bounds the passage.)
            layer1_logger.info(
                "Contoured injector face: layer1_injector_min_face_incidence_deg (%s) not applied",
                _inc_req)
            _inc_req = None
        if _inc_req is not None:
            try:
                _inc_req = float(_inc_req)
                if np.isfinite(_inc_req) and _inc_req > 0.0:
                    _th_ceiling = 90.0 - _inc_req
                    if _th_ceiling <= imp_angle_lo_bound:
                        raise ValueError(
                            f"layer1_injector_min_face_incidence_deg = {_inc_req:g} caps the jet "
                            f"angle at {_th_ceiling:g} deg, at or below the "
                            f"layer1_impinging_jet_angle_min_deg floor of {imp_angle_lo_bound:g}. "
                            f"No jet angle satisfies both."
                        )
                    imp_angle_hi_bound = min(imp_angle_hi_bound, _th_ceiling)
                    layer1_logger.info(
                        "Face-incidence floor %g deg -> jet angle capped at %.1f deg "
                        "(drill meets the face at >= %g deg)",
                        _inc_req, imp_angle_hi_bound, _inc_req)
            except (TypeError, ValueError) as _e:
                if isinstance(_e, ValueError) and "min_face_incidence" in str(_e):
                    raise
        if imp_angle_hi_bound <= imp_angle_lo_bound:
            imp_angle_hi_bound = min(89.0, imp_angle_lo_bound + 1.0)
        layer1_logger.info(
            "Impingement-angle bounds: included [%g, %g] deg (asym <= %g) -> per-jet [%.1f, %.1f]",
            _incl_lo, _incl_hi, _asym, imp_angle_lo_bound, imp_angle_hi_bound,
        )
        # HOLE-PITCH FLOOR FROM THE RESERVED CENTRE CIRCLE. D_pitch = n*spacing/pi, so a ring
        # that must clear a centre boss of diameter D_c needs spacing >= pi*D_c/n. Without this
        # the search box still reaches the old 3 mm floor, the hard block rejects every such
        # candidate, and CMA burns its budget on a region it can never use. Take n at its CAP:
        # more elements need LESS pitch for the same circle, so n_hi_int gives the loosest floor
        # that is still valid for every reachable n.
        _spacing_lo = 0.003
        _cc_req = _layer1_centre_clear_m(config_obj, requirements)
        if np.isfinite(_cc_req) and _cc_req > 0.0 and n_hi_int >= 1:
            _spacing_lo = max(_spacing_lo, float(np.pi) * float(_cc_req) / float(n_hi_int))
            if _spacing_lo >= spacing_hi:
                raise ValueError(
                    f"layer1_injector_center_clear_dia_m = {_cc_req*1000:.1f} mm needs a hole "
                    f"pitch of at least {_spacing_lo*1000:.2f} mm at n = {n_hi_int}, but the "
                    f"pitch ceiling for a {D_inner_bounds*1000:.1f} mm bore is "
                    f"{spacing_hi*1000:.2f} mm. Reduce the reserved centre circle, or raise "
                    f"layer1_impinging_n_doublets_max."
                )
            layer1_logger.info(
                "Centre clearance %.1f mm reserved -> hole-pitch floor %.2f mm (was 3.00) at n=%d",
                _cc_req * 1000.0, _spacing_lo * 1000.0, n_hi_int,
            )
        layer1_logger.info(
            f"Impinging injector bounds from chamber bore D_inner≈{D_inner_bounds*1000:.2f} mm: "
            f"n_doublets ≤ {n_hi_int} (hard int cap via search box), "
            f"d_jet ≤ {d_jet_hi*1000:.2f} mm, spacing ≤ {spacing_hi*1000:.2f} mm"
        )
        bounds = [
            (min_A_throat_safe, A_throat_hi),
            (min_Lstar, max_Lstar),
            (exp_ratio_lo, exp_ratio_hi),
            (min_outer_diameter, max_chamber_od),
            (5.0, n_hi_upper),
            (0.0005, d_jet_hi),
            (imp_angle_lo_bound, imp_angle_hi_bound),
            (_spacing_lo, spacing_hi),
            (0.0005, d_jet_hi),
            (imp_angle_lo_bound, imp_angle_hi_bound),
            (_spacing_lo, spacing_hi),
            (max_lox_P_psi * min_P_ratio, max_lox_P_psi * max_P_ratio),
            (max_fuel_P_psi * min_P_ratio, max_fuel_P_psi * max_P_ratio),
        ]
    else:
        max_n_orifices = 14
        max_d_orifice = 0.003
        max_LOX_area = max_n_orifices * np.pi * (max_d_orifice / 2) ** 2
        max_d_pintle = 0.040
        max_h_gap = 0.0015
        R_inner_max = max_d_pintle / 2
        R_outer_max = R_inner_max + max_h_gap
        max_fuel_area = np.pi * (R_outer_max ** 2 - R_inner_max ** 2)
        max_injector_area = max(max_LOX_area, max_fuel_area)
 
        bounds = [
            (min_A_throat_safe, A_throat_hi),
            (min_Lstar, max_Lstar),
            (exp_ratio_lo, exp_ratio_hi),
            (min_outer_diameter, max_chamber_od),
            (0.006, 0.040),
            (0.0003, 0.0015),
            (14, 14.1),
            (0.001, 0.004),
            (max_lox_P_psi * min_P_ratio, max_lox_P_psi * max_P_ratio),
            (max_fuel_P_psi * min_P_ratio, max_fuel_P_psi * max_P_ratio),
        ]
 
    # Optional explicit stagnation-pressure ranges [psi] for x[idx_P_O], x[idx_P_F]
    # (overrides default 65–85% of max_lox_pressure_psi / max_fuel_pressure_psi bands).
    _p_o_min = requirements.get("layer1_P_O_start_psi_min")
    _p_o_max = requirements.get("layer1_P_O_start_psi_max")
    if _p_o_min is not None and _p_o_max is not None:
        lo_p, hi_p = float(_p_o_min), min(float(_p_o_max), max_lox_P_psi)
        lo_p = min(lo_p, hi_p)
        if hi_p > lo_p:
            bounds[idx_P_O] = (lo_p, hi_p)
    _p_f_min = requirements.get("layer1_P_F_start_psi_min")
    _p_f_max = requirements.get("layer1_P_F_start_psi_max")
    if _p_f_min is not None and _p_f_max is not None:
        lo_pf, hi_pf = float(_p_f_min), min(float(_p_f_max), max_fuel_P_psi)
        lo_pf = min(lo_pf, hi_pf)
        if hi_pf > lo_pf:
            bounds[idx_P_F] = (lo_pf, hi_pf)
 
    # Hard ceiling: optimized stagnation cannot exceed allowable tank pressures [psi].
    _o_lo, _o_hi = bounds[idx_P_O]
    bounds[idx_P_O] = (float(min(_o_lo, max_lox_P_psi)), float(min(_o_hi, max_lox_P_psi)))
    if bounds[idx_P_O][0] > bounds[idx_P_O][1]:
        bounds[idx_P_O] = (bounds[idx_P_O][1], bounds[idx_P_O][0])
    _f_lo, _f_hi = bounds[idx_P_F]
    bounds[idx_P_F] = (float(min(_f_lo, max_fuel_P_psi)), float(min(_f_hi, max_fuel_P_psi)))
    if bounds[idx_P_F][0] > bounds[idx_P_F][1]:
        bounds[idx_P_F] = (bounds[idx_P_F][1], bounds[idx_P_F][0])
 
    # Calculate initial guess
    # Check if we can use the input config as the starting point (x0)
    # This key feature allows the user to providing a "good guess" to speed up optimization
    has_valid_start_geom = False
    
    # Extract candidate values from config
    try:
        # Helper to safely get float > 0
        def _get_val(obj, attr, default=None):
            val = getattr(obj, attr, default)
            return float(val) if val is not None and val > 0 else None
 
        # Chamber/Nozzle Geometry
        # Try chamber_geometry first, then legacy sections
        cg_in = getattr(config_obj, 'chamber_geometry', None)
        c_in = getattr(config_obj, 'chamber', None)
        n_in = getattr(config_obj, 'nozzle', None)
        
        A_throat_in = _get_val(cg_in, 'A_throat') or _get_val(c_in, 'A_throat') or _get_val(n_in, 'A_throat')
        Lstar_in = _get_val(cg_in, 'Lstar') or _get_val(c_in, 'Lstar')
        eps_in = _get_val(cg_in, 'expansion_ratio') or _get_val(n_in, 'expansion_ratio')
        # Inner diameter -> Outer diameter
        D_inner_in = _get_val(cg_in, 'chamber_diameter') or _get_val(c_in, 'chamber_inner_diameter')
        
        # Injector Geometry
        inj_in = getattr(config_obj, 'injector', None)
        inj_geom = getattr(inj_in, 'geometry', None)
        is_pintle = (getattr(inj_in, 'type', '') == 'pintle')
        is_impinging = (getattr(inj_in, 'type', '') == 'impinging')
 
        d_pintle_in = h_gap_in = n_orifices_in = d_orifice_in = None
        n_O_in = d_jet_O_in = ang_O_in = sp_O_in = None
        n_F_in = d_jet_F_in = ang_F_in = sp_F_in = None
 
        if is_pintle and inj_geom:
            fuel_in = getattr(inj_geom, 'fuel', None)
            lox_in = getattr(inj_geom, 'lox', None)
 
            d_pintle_in = _get_val(fuel_in, 'd_pintle_tip')
            h_gap_in = _get_val(fuel_in, 'h_gap')
            n_orifices_in = _get_val(lox_in, 'n_orifices')
            d_orifice_in = _get_val(lox_in, 'd_orifice')
        elif is_impinging and inj_geom:
            ox_in = getattr(inj_geom, 'oxidizer', None)
            fu_in = getattr(inj_geom, 'fuel', None)
            if ox_in and fu_in:
                n_O_in = getattr(ox_in, 'n_elements', None)
                n_F_in = getattr(fu_in, 'n_elements', None)
                n_doublets_in = None
                if n_O_in is not None and float(n_O_in) > 0:
                    no_i = int(n_O_in)
                    if n_F_in is not None and float(n_F_in) > 0:
                        nf_i = int(n_F_in)
                        if nf_i != no_i:
                            layer1_logger.warning(
                                "Impinging YAML n_elements_O (%s) != n_elements_F (%s); paired doublets "
                                "use one n_doublets — Layer-1 x0 uses min(O,F)=%s.",
                                no_i,
                                nf_i,
                                min(no_i, nf_i),
                            )
                        n_doublets_in = min(no_i, nf_i)
                    else:
                        n_doublets_in = no_i
                elif n_F_in is not None and float(n_F_in) > 0:
                    n_doublets_in = int(n_F_in)
                d_jet_O_in = _get_val(ox_in, 'd_jet')
                ang_O_in = _get_val(ox_in, 'impingement_angle')
                sp_O_in = _get_val(ox_in, 'spacing')
                d_jet_F_in = _get_val(fu_in, 'd_jet')
                ang_F_in = _get_val(fu_in, 'impingement_angle')
                sp_F_in = _get_val(fu_in, 'spacing')
 
        pintle_complete = (
            is_pintle
            and all(
                v is not None
                for v in [
                    A_throat_in,
                    Lstar_in,
                    eps_in,
                    D_inner_in,
                    d_pintle_in,
                    h_gap_in,
                    n_orifices_in,
                    d_orifice_in,
                ]
            )
        )
        imp_complete = (
            is_impinging
            and all(
                v is not None
                for v in [
                    A_throat_in,
                    Lstar_in,
                    eps_in,
                    D_inner_in,
                    n_doublets_in,
                    d_jet_O_in,
                    ang_O_in,
                    sp_O_in,
                    d_jet_F_in,
                    ang_F_in,
                    sp_F_in,
                ]
            )
        )
 
        if pintle_complete:
            A_throat_init = A_throat_in
            Lstar_init = Lstar_in
            eps_init = eps_in
            outer_diameter_init = D_inner_in + wall_total_m
 
            default_d_pintle = d_pintle_in
            default_h_gap = h_gap_in
            default_n_orifices = int(n_orifices_in)
            default_d_orifice = d_orifice_in
 
            has_valid_start_geom = True
            layer1_logger.info("Using values from input configuration as initial guess (x0).")
 
        elif imp_complete:
            A_throat_init = A_throat_in
            Lstar_init = Lstar_in
            eps_init = eps_in
            outer_diameter_init = D_inner_in + wall_total_m
 
            default_n_doublets = int(n_doublets_in)
            default_d_jet_O = float(d_jet_O_in)
            default_d_jet_F = float(d_jet_F_in)
            default_ang_O = float(ang_O_in)
            default_ang_F = float(ang_F_in)
            default_sp_O = float(sp_O_in)
            default_sp_F = float(sp_F_in)
 
            has_valid_start_geom = True
            layer1_logger.info("Using impinging injector geometry from input configuration as initial guess (x0).")
 
        else:
            layer1_logger.info("Input configuration incomplete/invalid for x0. Using heuristic defaults.")
 
    except Exception as e:
        layer1_logger.warning(f"Failed to extract x0 from config: {e}. Using defaults.")
        has_valid_start_geom = False
 
    if not has_valid_start_geom:
        if l1_injector_type == "impinging":
            default_n_doublets = 12
            default_d_jet_O = 0.002
            default_d_jet_F = 0.002
            default_ang_O = 45.0
            default_ang_F = 45.0
            default_sp_O = 0.012
            default_sp_F = 0.012
            A_lox_est = default_n_doublets * np.pi * (default_d_jet_O / 2.0) ** 2
            A_fuel_est = default_n_doublets * np.pi * (default_d_jet_F / 2.0) ** 2
            max_injector_area_est = max(A_lox_est, A_fuel_est)
            A_throat_min_safe = max_injector_area_est * 1.15
            A_throat_init = max(A_throat_init, A_throat_min_safe)
            Lstar_init = (min_Lstar + max_Lstar) / 2
            eps_init = 8.0
            outer_diameter_init = np.clip(max_chamber_od * 0.55, min_outer_diameter, max_chamber_od)
        else:
            default_n_orifices = 14
            default_d_orifice = 0.002
            default_d_pintle = 0.016
            default_h_gap = 0.0006
 
            A_lox_est = default_n_orifices * np.pi * (default_d_orifice / 2) ** 2
            R_inner_est = default_d_pintle / 2
            R_outer_est = R_inner_est + default_h_gap
            A_fuel_est = np.pi * (R_outer_est ** 2 - R_inner_est ** 2)
            max_injector_area_est = max(A_lox_est, A_fuel_est)
 
            A_throat_min_safe = max_injector_area_est * 1.1
            A_throat_init = max(A_throat_init, A_throat_min_safe)
 
            Lstar_init = (min_Lstar + max_Lstar) / 2
            eps_init = 8.0
            outer_diameter_init = np.clip(max_chamber_od * 0.55, min_outer_diameter, max_chamber_od)
 
    # Clean up variables for array creation
    A_throat_init = float(np.clip(A_throat_init, bounds[0][0], bounds[0][1]))
 
    P_O_start_init = max_lox_P_psi * 0.80
    P_F_start_init = max_fuel_P_psi * 0.80
    P_O_start_init = float(np.clip(P_O_start_init, bounds[idx_P_O][0], bounds[idx_P_O][1]))
    P_F_start_init = float(np.clip(P_F_start_init, bounds[idx_P_F][0], bounds[idx_P_F][1]))
 
    if l1_injector_type == "impinging":
        default_d_jet_O, default_d_jet_F = _layer1_rescale_impinging_seed_jets_for_mr(
            config_obj,
            d_jet_O=default_d_jet_O,
            d_jet_F=default_d_jet_F,
            n_doublets=int(default_n_doublets),
            optimal_of=float(optimal_of),
            bounds=bounds,
            logger=layer1_logger,
            also_config=config_base,
        )
 
    if l1_injector_type == "impinging":
        x0 = np.array([
            A_throat_init,
            Lstar_init if 'Lstar_init' in locals() else (min_Lstar + max_Lstar) / 2,
            eps_init if 'eps_init' in locals() else 8.0,
            outer_diameter_init,
            float(default_n_doublets),
            default_d_jet_O,
            default_ang_O,
            default_sp_O,
            default_d_jet_F,
            default_ang_F,
            default_sp_F,
            P_O_start_init,
            P_F_start_init,
        ])
    else:
        x0 = np.array([
            A_throat_init,
            Lstar_init if 'Lstar_init' in locals() else (min_Lstar + max_Lstar) / 2,
            eps_init if 'eps_init' in locals() else 8.0,
            outer_diameter_init,
            default_d_pintle,
            default_h_gap,
            default_n_orifices,
            default_d_orifice,
            P_O_start_init,
            P_F_start_init,
        ])
    
    # =========================================================================
    # Handle Frozen Parameters from Design Requirements
    # =========================================================================
    # If user has specified frozen_parameters, pin those values by:
    # 1. Setting bounds to [value, value] (prevents CMA-ES from exploring)
    # 2. Setting x0 to the frozen value
    # Frozen parameters use user-friendly units and are converted to SI here.
    #
    # ``requirements`` often comes from ``design_requirements.model_dump()`` via the API. If the UI
    # saved a document without nested ``frozen_parameters`` (or with an empty dict), we must not
    # drop pins that still exist on ``config_base.design_requirements`` from the loaded YAML.
    def _frozen_param_nonempty(fp: Any) -> bool:
        return isinstance(fp, dict) and any(v is not None for v in fp.values())
 
    _fp_req = requirements.get("frozen_parameters")
    _fp_cfg: Dict[str, Any] = {}
    dr0 = getattr(config_base, "design_requirements", None)
    if dr0 is not None and dr0.frozen_parameters is not None:
        _fp_cfg = dr0.frozen_parameters.model_dump(exclude_none=True)
    if _fp_cfg:
        if not _frozen_param_nonempty(_fp_req):
            requirements = dict(requirements)
            requirements["frozen_parameters"] = dict(_fp_cfg)
        elif isinstance(_fp_req, dict):
            merged_fp = dict(_fp_cfg)
            for _k, _v in _fp_req.items():
                if _v is not None:
                    merged_fp[_k] = _v
            requirements = dict(requirements)
            requirements["frozen_parameters"] = merged_fp
 
    frozen = requirements.get("frozen_parameters", {}) or {}
    frozen_param_names = []
    
    # Map frozen parameters to their x-vector indices and unit conversions
    # Index | Parameter name          | Frozen key         | Conversion
    # ------+-------------------------+--------------------+------------
    #  0    | A_throat [m²]           | A_throat_mm2       | mm² -> m² (*1e-6)
    #  1    | Lstar [m]               | Lstar_mm           | mm -> m (*1e-3)
    #  2    | expansion_ratio [-]     | expansion_ratio    | none
    #  3    | D_chamber_outer [m]     | D_chamber_outer_mm | mm -> m (*1e-3)
    #
    # Pintle continues: 4=d_pintle_tip, 5=h_gap, 6=n_orifices, 7=d_orifice, 8-9 pressures.
    #
    # Impinging (paired unlike doublets — see frozen_mapping below): 4=n_doublets (int),
    # 5–7 LOX jet, 8–10 fuel jet, 11–12 pressures.
    #
    #  4    | d_pintle_tip [m]        | d_pintle_tip_mm    | mm -> m (*1e-3)  # pintle only
    #  5    | h_gap [m]               | h_gap_mm           | mm -> m (*1e-3)
    #  6    | n_orifices [-]          | n_orifices         | none (int)
    #  7    | d_orifice [m]           | d_orifice_mm       | mm -> m (*1e-3)
    #  8    | P_O_start [psi]         | P_O_start_psi      | none
    #  9    | P_F_start [psi]         | P_F_start_psi      | none
    
    if l1_injector_type == "impinging":
        frozen_mapping = [
            ("A_throat_mm2", 1e-6),
            ("Lstar_mm", 1e-3),
            ("expansion_ratio", 1.0),
            ("D_chamber_outer_mm", 1e-3),
            ("n_doublets", 1.0),
            ("d_jet_O_mm", 1e-3),
            ("impingement_angle_O_deg", 1.0),
            ("spacing_O_mm", 1e-3),
            ("d_jet_F_mm", 1e-3),
            ("impingement_angle_F_deg", 1.0),
            ("spacing_F_mm", 1e-3),
            ("P_O_start_psi", 1.0),
            ("P_F_start_psi", 1.0),
        ]
    else:
        frozen_mapping = [
            ("A_throat_mm2", 1e-6),
            ("Lstar_mm", 1e-3),
            ("expansion_ratio", 1.0),
            ("D_chamber_outer_mm", 1e-3),
            ("d_pintle_tip_mm", 1e-3),
            ("h_gap_mm", 1e-3),
            ("n_orifices", 1.0),
            ("d_orifice_mm", 1e-3),
            ("P_O_start_psi", 1.0),
            ("P_F_start_psi", 1.0),
        ]
 
    int_keys = {"n_orifices", "n_doublets"}
 
    for idx, (key, conversion) in enumerate(frozen_mapping):
        frozen_val = frozen.get(key)
        if frozen_val is not None:
            val_si = frozen_val * conversion
            if key in int_keys:
                val_si = int(round(frozen_val))
            eps = 1e-12 if key not in int_keys else 0.01
            bounds[idx] = (val_si - eps, val_si + eps)
            x0[idx] = val_si
            frozen_param_names.append(f"{key}={frozen_val}")
    
    if frozen_param_names:
        layer1_logger.info(f"Frozen parameters: {', '.join(frozen_param_names)}")
        layer1_logger.info("These values will be fixed during optimization.")
 
    # Optional exploration band for throat area [mm²] → bounds index 0 [m²].
    # Applied after frozen pinning so unfrozen A_throat can still be narrowed.
    _atm_lo = requirements.get("layer1_A_throat_mm2_min")
    _atm_hi = requirements.get("layer1_A_throat_mm2_max")
    if _atm_lo is not None and _atm_hi is not None:
        lo_m2 = float(_atm_lo) * 1e-6
        hi_m2 = float(_atm_hi) * 1e-6
        if hi_m2 <= lo_m2:
            raise ValueError(
                "layer1_A_throat_mm2_max must exceed layer1_A_throat_mm2_min "
                f"(got min={_atm_lo}, max={_atm_hi})."
            )
        b0_lo = max(float(bounds[0][0]), lo_m2)
        b0_hi = min(float(bounds[0][1]), hi_m2)
        if b0_lo >= b0_hi:
            raise ValueError(
                "layer1 A_throat band does not intersect default bounds "
                f"(band mm² [{_atm_lo}, {_atm_hi}], intersect [{b0_lo}, {b0_hi}] m²)."
            )
        bounds[0] = (b0_lo, b0_hi)
        layer1_logger.info(
            "Layer 1 A_throat interval from requirements "
            "layer1_A_throat_mm2_min/max: [%.6f, %.6f] mm²",
            bounds[0][0] * 1e6,
            bounds[0][1] * 1e6,
        )
    # =========================================================================
    
    # When a chamber-pressure target is set, ANCHOR the tank-pressure search window to the
    # target (the tank pressure needed to PRODUCE that Pc) rather than to the tank-pressure
    # cap. The default window is [0.65,0.85]*cap, which fixes the achievable Pc near the cap
    # and leaves a low Pc target sitting at the very edge — so the target penalty fights a
    # search space that doesn't contain it. Tank ≈ Pc + injector ΔP (~20-45% of Pc) + feed,
    # i.e. tank ≈ Pc*[1.12, 1.75]. Also re-seed x0 to the window centre (the clip below keeps
    # it in range) so the search STARTS near the target Pc.
    _pc_tgt_psi = requirements.get("target_chamber_pressure_psi")
    if _pc_tgt_psi is not None and float(_pc_tgt_psi) > 0:
        _pc_t = float(_pc_tgt_psi)
        for _pidx, _cap in ((idx_P_O, max_lox_P_psi), (idx_P_F, max_fuel_P_psi)):
            _lo = max(_pc_t * 1.12, 50.0)
            _hi = min(_pc_t * 1.75, float(_cap))
            if _hi <= _lo:
                # Target needs more tank pressure than the cap allows → best effort near the cap.
                _hi = float(_cap)
                _lo = max(0.5 * _hi, min(_pc_t, _hi - 1.0))
            bounds[_pidx] = (_lo, _hi)
            x0[_pidx] = 0.5 * (_lo + _hi)
        layer1_logger.info(
            "Layer 1 tank-pressure window re-anchored to Pc target %.0f psi: tanks ∈ [%.0f, %.0f] psi "
            "(was cap-relative). This is what lets Pc actually reach the target.",
            _pc_t, bounds[idx_P_O][0], bounds[idx_P_O][1],
        )
 
    # ------------------------------------------------------------------
    # Derived DOFs: solve instead of search
    # ------------------------------------------------------------------
    # ``expansion_ratio`` is fixed by "expand to ambient" and ``A_throat`` by the
    # thrust requirement, so neither is a free design choice -- searching them
    # burns two CMA-ES dimensions and lets the optimizer park on a wrong value
    # that a penalty term then has to claw back. Capture their *search* ranges
    # (the solver still clamps to them, so an unreachable requirement degrades to
    # a bound + the ordinary penalty rather than a runaway), then collapse the
    # CMA bounds so no population variance is spent on them.
    #
    # Both are opt-out: a user sizing to fixed throat hardware, or deliberately
    # running over/under expanded, needs to search them.
    derive_expansion_ratio = _requirement_bool(
        requirements, "layer1_derive_expansion_ratio", True)
    derive_throat_from_thrust = _requirement_bool(
        requirements, "layer1_derive_throat_from_thrust", True)
    # Solved to tolerance, not for a fixed count: the loop exits once thrust is within
    # layer1_derive_thrust_tol_rel and eps has stopped moving. Two fixed iterations left a
    # 0.4-0.9 % thrust miss that depended on where CMA proposed the throat, and the search
    # traded that miss against the chamber-mass term (L1-04). The cap only bounds a
    # non-converging secant.
    derive_max_iters = max(1, int(_requirement_float(
        requirements, "layer1_derive_max_iters", float(_LAYER1_DERIVE_MAX_ITERS_DEFAULT))))
    derive_thrust_tol = float(_requirement_float(
        requirements, "layer1_derive_thrust_tol_rel", 1.0e-3))
 
    if derive_throat_from_thrust and not (target_thrust > 0):
        layer1_logger.warning(
            "Layer 1: A_throat derivation requested but no positive thrust target; "
            "searching A_throat instead."
        )
        derive_throat_from_thrust = False
 
    derive_At_range = (float(bounds[0][0]), float(bounds[0][1]))
    derive_eps_range = (float(bounds[2][0]), float(bounds[2][1]))
    derive_dF_range = ((float(bounds[8][0]), float(bounds[8][1])) if len(bounds) > 8 else (1e-5, 1.0))
    _tanks_locked_flag = _requirement_bool(requirements, "layer1_lock_tank_pressures",
                                           _requirement_float(requirements, "W_TANK_EQUAL", 0.0) > 0.0)
    # OFF by default. It does what it says -- tanks track Pc so dP/Pc holds exactly -- but the
    # dP/Pc ceiling was not what blocked O/F (the momentum wall-ban is; see
    # _impinging_momentum_wall_violation), and un-anchoring the tank pressure let it slide
    # to 400-470 psi: Pc 298-364, Isp 217-224, a worse engine, plus a rebuild that no longer
    # converged in its iteration budget (validation had to boost tanks 6%). Opt-in.
    derive_tank_from_dp = _tanks_locked_flag and _requirement_bool(
        requirements, "layer1_derive_tank_from_dp_ratio", False)
    _dp_lo = _requirement_float(requirements, "injector_dp_ratio_F_min", 0.2)
    _dp_hi = _requirement_float(requirements, "injector_dp_ratio_F_max", 0.3)
    dp_ratio_target = _requirement_float(requirements, "layer1_dp_ratio_target", 0.5 * (_dp_lo + _dp_hi))
    lock_P_T_range = (float(bounds[idx_P_O][0]), float(bounds[idx_P_O][1]))
    # OFF by default. The one-shot secant d_F*sqrt(MR/MR_target) assumes dP is fixed, but
    # moving d_F moves total mdot, hence Pc, hence dP -- the step overshoots, rails d_F at a
    # bound, starves the injector, and every candidate fails (measured: tanks stuck at the
    # 480/480 seed on all seeds, MR 3.72, thrust -15 N). Needs a damped, multi-step solve
    # coupled with the throat before it can default on. Opt-in until then.
    derive_fuel_jet_from_of = (
        l1_injector_type == "impinging"
        and _requirement_bool(requirements, "layer1_derive_fuel_jet_from_of", False)
    )
 
    # Capture the fuel-pitch SEARCH range before the pin collapses bounds[10] to a point --
    # clamping the solved value to the pinned bound would discard the derivation entirely.
    derive_spacing_F_range = (
        (float(bounds[10][0]), float(bounds[10][1])) if len(bounds) > 10 else (0.0, float("inf"))
    )
    lock_P_F_range = (float(bounds[idx_P_F][0]), float(bounds[idx_P_F][1]))
 
    # Derived DOFs are removed from the SEARCH, but their bounds stay at full range.
    #
    # Collapsing the bounds to a point was the wrong mechanism: this module clips x to bounds
    # in ~50 places (objective entry, apply_x_to_config, per-variable reads, finalisation
    # reporting), and every one of them silently reverted the solved value back to the seed.
    # Chasing them individually is unwinnable. With full bounds every clip is a no-op, the
    # solved value survives end to end, and cma's ``fixed_variables`` keeps CMA from
    # spending any search effort on the dimension.
    _pinned_msgs = []
    _l1_fixed_vars: Dict[int, float] = {}
    if _requirement_bool(requirements, "layer1_lock_tank_pressures",
                         _requirement_float(requirements, "W_TANK_EQUAL", 0.0) > 0.0):
        _pf_seed = float(np.clip(x0[idx_P_O], *lock_P_F_range))
        x0[idx_P_F] = _pf_seed
        _l1_fixed_vars[idx_P_F] = _pf_seed
        _pinned_msgs.append("fuel tank pressure (locked to the LOX tank)")
    if derive_throat_from_thrust:
        _at_seed = float(np.clip(x0[0], *derive_At_range))
        x0[0] = _at_seed
        _l1_fixed_vars[0] = _at_seed
        _pinned_msgs.append(
            "A_throat (solved from thrust target %.0f N, search range %.1f-%.1f mm²)"
            % (target_thrust, derive_At_range[0] * 1e6, derive_At_range[1] * 1e6)
        )
    if derive_expansion_ratio:
        _eps_seed = float(np.clip(x0[2], *derive_eps_range))
        x0[2] = _eps_seed
        _l1_fixed_vars[2] = _eps_seed
        _pinned_msgs.append(
            "expansion_ratio (solved for Pe = %.2f psi, clamp %.2f-%.2f)"
            % (target_P_exit / 6894.76, derive_eps_range[0], derive_eps_range[1])
        )
    if (l1_injector_type == "impinging" and len(bounds) > 10
            and _requirement_bool(requirements, "layer1_derive_impingement_spacing", True)):
        _spf_seed = float(np.clip(x0[10], *derive_spacing_F_range))
        x0[10] = _spf_seed
        _l1_fixed_vars[10] = _spf_seed
    if derive_fuel_jet_from_of and len(bounds) > 8:
        _l1_fixed_vars[8] = float(np.clip(x0[8], *derive_dF_range))
        _pinned_msgs.append("fuel jet diameter (solved from the O/F target)")
    if derive_tank_from_dp:
        _l1_fixed_vars[idx_P_O] = float(np.clip(x0[idx_P_O], *lock_P_T_range))
        _pinned_msgs.append("tank pressure (solved from dP/Pc = %.2f)" % dp_ratio_target)
        _pinned_msgs.append(
            "fuel ring pitch (solved so the jets meet at %.2f jet diameters)"
            % _requirement_float(requirements, "layer1_impingement_Ld_target", IMPINGEMENT_LD_TARGET_DEFAULT)
        )
    if _pinned_msgs:
        layer1_logger.info(
            "Layer 1 dimensionality: %d of %d DOFs are solved, not searched -- %s",
            len(_pinned_msgs), len(bounds), "; ".join(_pinned_msgs),
        )
 
    _od_increment_in = _requirement_float(
        requirements, "layer1_chamber_od_increment_in", 0.0)
    _od_snap_target = str(
        requirements.get("layer1_chamber_od_snap_target") or "outer").strip().lower()
    if _od_snap_target not in ("outer", "bore"):
        layer1_logger.warning(
            "Layer 1: unknown layer1_chamber_od_snap_target=%r; using 'outer'.",
            _od_snap_target)
        _od_snap_target = "outer"
    # Shared by the worker pool (via constants_dict) and the inline objective, so
    # both paths solve the derived DOFs identically.
    _derive_constants = {
        "layer1_derive_expansion_ratio": derive_expansion_ratio,
        "layer1_derive_throat_from_thrust": derive_throat_from_thrust,
        "layer1_derive_max_iters": derive_max_iters,
        "layer1_derive_thrust_tol_rel": derive_thrust_tol,
        "derive_eps_min": derive_eps_range[0],
        "derive_eps_max": derive_eps_range[1],
        "derive_At_min": derive_At_range[0],
        "derive_At_max": derive_At_range[1],
        "derive_dF_min": derive_dF_range[0],
        "derive_dF_max": derive_dF_range[1],
        "layer1_derive_fuel_jet_from_of": derive_fuel_jet_from_of,
        "layer1_derive_tank_from_dp_ratio": derive_tank_from_dp,
        "layer1_dp_ratio_target": dp_ratio_target,
        "lock_P_T_min": lock_P_T_range[0],
        "lock_P_T_max": lock_P_T_range[1],
        "optimal_of": optimal_of,
        "P_ambient": target_P_exit,
        "target_thrust": target_thrust,
        "max_nozzle_exit": max_nozzle_exit,
        "TOTAL_WALL_THICKNESS_M": wall_total_m,
        "layer1_chamber_od_increment_in": _od_increment_in,
        "layer1_chamber_od_snap_target": _od_snap_target,
        "injector_type": l1_injector_type,
        "idx_P_O": idx_P_O,
        "idx_P_F": idx_P_F,
        "layer1_lock_tank_pressures": _requirement_bool(
            requirements, "layer1_lock_tank_pressures",
            _requirement_float(requirements, "W_TANK_EQUAL", 0.0) > 0.0),
        "lock_P_F_min": lock_P_F_range[0],
        "lock_P_F_max": lock_P_F_range[1],
        "layer1_derive_impingement_spacing": _requirement_bool(
            requirements, "layer1_derive_impingement_spacing", True),
        "layer1_impingement_Ld_target": _requirement_float(
            requirements, "layer1_impingement_Ld_target", IMPINGEMENT_LD_TARGET_DEFAULT),
        "layer1_ring_order_fuel_outboard": _requirement_bool(
            requirements, "layer1_ring_order_fuel_outboard", True),
        "derive_spacing_F_min": derive_spacing_F_range[0],
        "derive_spacing_F_max": derive_spacing_F_range[1],
    }
 
    # Clip to bounds
    for i, (lo, hi) in enumerate(bounds):
        x0[i] = np.clip(x0[i], lo, hi)
 
    update_progress("Layer 1: Setup", 0.05, "Creating apply_x_to_config function...")
    apply_x_to_config = create_layer1_apply_x_to_config(
        bounds, max_chamber_od, max_nozzle_exit, l1_injector_type,
        chamber_od_increment_in=_od_increment_in,
        chamber_od_snap_target=_od_snap_target,
        derive_constants=_derive_constants,
        derive_spacing_F_range=derive_spacing_F_range,
    )
    
    # Precompute bounds arrays for clipping, caching, and CMA-ES scaling
    lower_bounds = np.array([b[0] for b in bounds], dtype=float)
    upper_bounds = np.array([b[1] for b in bounds], dtype=float)
    # Clipping bounds for the OBJECTIVE, which must not throw away a solved DOF.
    #
    # The derived dims sit on collapsed bounds so CMA cannot spend variance on them. But the
    # objective clips its incoming vector to those same bounds, which snapped A_throat back
    # to the seed on every call -- so the design that got REPORTED was never the design that
    # was scored (measured: solved across 1190-4000 mm2, reported 1548 mm2 every run,
    # unmoved by tank cap, contraction ratio, or thrust). Clip those dims to the range they
    # were actually solved within instead.
    lower_bounds_eff = lower_bounds.copy()
    upper_bounds_eff = upper_bounds.copy()
    for _di, _rng in (
        (0, derive_At_range if derive_throat_from_thrust else None),
        (2, derive_eps_range if derive_expansion_ratio else None),
        (10, derive_spacing_F_range
             if (l1_injector_type == "impinging" and len(bounds) > 10
                 and _requirement_bool(requirements, "layer1_derive_impingement_spacing", True))
             else None),
        (idx_P_F, lock_P_F_range
                  if _requirement_bool(requirements, "layer1_lock_tank_pressures",
                                       _requirement_float(requirements, "W_TANK_EQUAL", 0.0) > 0.0)
                  else None),
    ):
        if _rng is not None and _di < len(lower_bounds_eff):
            lower_bounds_eff[_di] = float(_rng[0])
            upper_bounds_eff[_di] = float(_rng[1])
    span = np.maximum(upper_bounds - lower_bounds, 1e-9)
    # Default to a fresh random seed each run so reruns explore the design space
    # differently. Pin layer1_random_seed to an int only when reproducibility is wanted.
    _rs = requirements.get("layer1_random_seed")
    layer1_seed_base = int(_rs) if _rs is not None else int(np.random.SeedSequence().entropy % (2**31))
    rng = np.random.default_rng(layer1_seed_base)
    layer1_logger.info(
        "Layer 1 RNG/CMA reproducibility: layer1_random_seed base=%s "
        "(CMA seed per restart = base + restart_idx × 1_000_003)",
        layer1_seed_base,
    )
    
    # Get report_every_n from requirements (default: 1 for real-time)
    # None-safe: the key is now DECLARED in DesignRequirementsConfig, so it arrives
    # present-with-value-None rather than absent, and .get(k, default) no longer fires.
    _ren = requirements.get("report_every_n")
    report_every_n = int(_ren) if _ren is not None else 1
    report_every_n = max(1, report_every_n)  # At least every iteration
    
    # Initialize optimization state
    opt_state = {
        "iteration": 0,
        "function_evaluations": 0,
        "best_objective": float('inf'),
        "best_x": None,
        "best_config": None,
        "best_config_x": None,
        "best_lox_end_ratio": None,
        "best_fuel_end_ratio": None,
        "best_pressures": None,
        "last_eval_config": None,
        "last_eval_config_x": None,
        "best_validation_tank_pa": None,
        "last_eval_validation_tank_pa": None,
        "last_good_eval_bundle": None,
        "best_results_for_validation": None,
        "converged": False,
        "objective_satisfied": False,
        "satisfied_obj": float('inf'),
        "satisfied_eval_count": 0,
        "consecutive_failures": 0,
        "last_valid_obj": float('inf'),
        "history": [],
        "objective_buffer": [],  # Buffer for batch reporting
        "stop_optimization": False,
        "force_maxfun_1": False,
        "last_best_eval": 0,
        "valley_escape_tier": 0, # 0=normal, 1=mild, 2=medium, 3=full
        "cooldown_until": 0,
    }
 
    layer1_W_MOM = _requirement_float(requirements, "W_MOM", 75.0)
    layer1_momentum_log_deadband_rel = _requirement_float(
        requirements,
        "layer1_momentum_log_deadband_rel",
        _LAYER1_DEFAULT_MOMENTUM_LOG_DEADBAND_REL,
    )
    _irm_lo = requirements.get("impinging_momentum_R_min")
    _irm_hi = requirements.get("impinging_momentum_R_max")
    layer1_impinging_R_mom_lo = float(_irm_lo) if _irm_lo is not None else None
    layer1_impinging_R_mom_hi = float(_irm_hi) if _irm_hi is not None else None
    # AIM band for the optimizer (penalty + interior objective gates): the middle 80% of the
    # validation band. A zero-inside-deadband penalty lets CMA converge EPSILON OUTSIDE the
    # band edge (gradient there is ~0, e.g. R=1.051 costs 0.03), which the hard validation
    # gate then rejects by 0.001 — a fully converged run stamped INVALID. The penalty and the
    # gate must never share an edge: the optimizer aims at the interior; final validation
    # keeps the exact configured band and passes with real margin.
    layer1_R_mom_aim_lo = layer1_R_mom_aim_hi = None
    if layer1_impinging_R_mom_lo is not None and layer1_impinging_R_mom_hi is not None:
        _r_half = 0.5 * (layer1_impinging_R_mom_hi - layer1_impinging_R_mom_lo)
        _r_mid = 0.5 * (layer1_impinging_R_mom_hi + layer1_impinging_R_mom_lo)
        layer1_R_mom_aim_lo = _r_mid - 0.8 * _r_half
        layer1_R_mom_aim_hi = _r_mid + 0.8 * _r_half
    layer1_W_chamber_shape = _requirement_float(requirements, "W_CHAMBER_SHAPE", 2500.0)
    layer1_chamber_dt_ratio_min = _requirement_float(requirements, "layer1_chamber_dt_ratio_min", 2.2)
    layer1_chamber_dt_ratio_max = _requirement_float(requirements, "layer1_chamber_dt_ratio_max", 3.2)
    layer1_chamber_ld_ratio_min = _requirement_float(requirements, "layer1_chamber_ld_ratio_min", 1.0)
    layer1_chamber_ld_ratio_max = _requirement_float(requirements, "layer1_chamber_ld_ratio_max", 3.2)
    _iang_lo = requirements.get("layer1_impinging_angle_deg_min")
    _iang_hi = requirements.get("layer1_impinging_angle_deg_max")
    layer1_impinging_angle_deg_lo = float(_iang_lo) if _iang_lo is not None else None
    layer1_impinging_angle_deg_hi = float(_iang_hi) if _iang_hi is not None else None
    layer1_W_impinging_angle = _requirement_float(requirements, "W_IMPINGING_ANGLE", 0.0)
    layer1_W_impinging_jet_asym = _requirement_float(requirements, "W_IMPINGING_JET_ASYM", 160.0)
    layer1_impinging_jet_max_asym_deg = _requirement_float(
        requirements, "layer1_impinging_jet_angle_max_asym_deg", 28.0
    )
    layer1_exit_pressure_inside_quad = _requirement_float(
        requirements, "layer1_exit_pressure_inside_quad_scale", 0.35
    )
    layer1_W_EXIT = _requirement_float(requirements, "layer1_W_EXIT", 2.0e2)
    # Exit-pressure deadband. Was hardcoded at 0.05, i.e. ANY P_exit within +/-5% of ambient
    # cost nothing at all -- for a 13.64 psi target that is 12.96-14.33 psi free, which is why
    # runs kept landing at 14.6 and looking "converged". Config-driven so it can be tightened
    # to the precision actually wanted.
    layer1_exit_pressure_deadband_rel = _requirement_float(
        requirements, "layer1_exit_pressure_deadband_rel", 0.05
    )
    # Chamber dry-mass cost. Unset, it is priced against the performance term below.
    layer1_W_MASS = _requirement_float(requirements, "layer1_W_MASS", 0.0)
    layer1_W_LSTAR = _requirement_float(requirements, "layer1_W_LSTAR", 0.0)
    layer1_Lstar_target_m = _requirement_float(requirements, "layer1_Lstar_target_m", 1.0)
    layer1_chamber_wall_density = _requirement_float(
        requirements, "layer1_chamber_wall_density_kg_m3", 2000.0
    )
    layer1_chamber_mass_ref_kg = _requirement_float(
        requirements, "layer1_chamber_mass_ref_kg", 5.0
    )
    layer1_W_DP = _requirement_float(requirements, "W_DP", 160.0)
    # Pull toward the centre of the ΔP/Pc band. The atomization (SMD) benefit of higher ΔP is a
    # strong competing force that pins ΔP/Pc to the 0.40 edge, so this needs a real counterweight
    # (~50) to settle near ~0.33; it is still small vs the band hinge / thrust so it never overrides
    # feasibility. Lower it toward 0 to allow the edge, raise it to pull harder toward 0.30. Tune via
    # design_requirements.W_DP_CENTER.
    layer1_W_DP_CENTER = _requirement_float(requirements, "W_DP_CENTER", 500.0)
    layer1_W_DP_O = (
        float(requirements["W_DP_O"])
        if requirements.get("W_DP_O") is not None
        else layer1_W_DP
    )
    layer1_W_DP_F = (
        float(requirements["W_DP_F"])
        if requirements.get("W_DP_F") is not None
        else layer1_W_DP
    )
    layer1_W_DP_HIGH = _requirement_float(requirements, "W_DP_HIGH", 480.0)
    layer1_dp_o_band, layer1_dp_f_band = injector_dp_bands_from_requirements(
        requirements,
        default_o=_LAYER1_DEFAULT_DP_O_BAND,
        default_f=_LAYER1_DEFAULT_DP_F_BAND,
    )
 
    # Interior AIM bands for the ΔP/Pc PENALTY (workers + parent objective + diagnostics):
    # middle 80% of the validation band, same rationale as the momentum-ratio aim band —
    # a zero-inside-deadband penalty parks candidates ON the band edge (seen live:
    # ΔP_F/Pc = 0.400 vs gate [0.200, 0.400] → converged run stamped INVALID). Final
    # validation keeps the exact configured bands and now passes with real margin.
    def _interior_band(band, frac: float = 0.8):
        lo, hi = float(band[0]), float(band[1])
        half = 0.5 * (hi - lo)
        mid = 0.5 * (hi + lo)
        return (mid - frac * half, mid + frac * half)
 
    layer1_dp_o_aim = _interior_band(layer1_dp_o_band)
    layer1_dp_f_aim = _interior_band(layer1_dp_f_band)
 
    # Figure of merit: delivered Isp against chamber mass, both priced per kg. At fixed total
    # impulse I = F t_b the propellant is I/(g0 Isp); the isp term is the propellant beyond an
    # ideal engine's, as a fraction of it (W_ISP per unit fraction, so W_ISP/m_prop_ref per kg).
    # Unset, the chamber-mass weight takes the same price per kg at its reference mass.
    _l1_cea_cache = getattr(runner, "cea_cache", None)
    if not _layer1_cea_ok(_l1_cea_cache):
        _l1_cea_cache = None
    _pc_ref_psi = (float(_pc_tgt_seed) if (_pc_tgt_seed is not None and float(_pc_tgt_seed) > 0)
                   else min(max_lox_P_psi, max_fuel_P_psi) * max_P_ratio
                   / (1.0 + 0.25 * (sum(layer1_dp_o_band) + sum(layer1_dp_f_band))))
    _t_b = float(target_burn_time or 0.0)
    _mw = _layer1_merit_weights(
        requirements, _l1_cea_cache, float(optimal_of), _pc_ref_psi * psi_to_Pa,
        float(target_P_exit), (float(exp_ratio_lo), float(exp_ratio_hi)),
        float(target_thrust), _t_b, layer1_W_MASS, layer1_chamber_mass_ref_kg)
    layer1_W_ISP, layer1_W_MASS = _mw["W_ISP"], _mw["W_MASS"]
    layer1_Isp_ref_s, _eps_ref, layer1_m_prop_ref_kg = _mw["Isp_ref_s"], _mw["eps_ref"], _mw["m_prop_ref_kg"]
    if not np.isfinite(layer1_Isp_ref_s) and _requirement_float(requirements, "layer1_W_ISP", 1.0) > 0:
        layer1_logger.warning("Layer 1: no CEA table for the Isp reference; performance term off.")
    layer1_logger.info(
        "Layer 1 figure of merit: W_ISP=%g on Isp_ref %.2f s (ideal, O/F %.3f, Pc %.0f psi, eps %.3f); "
        "m_prop_ref %.3f kg for %.0f N x %.2f s; W_MASS=%g (%s)",
        layer1_W_ISP, layer1_Isp_ref_s, float(optimal_of), _pc_ref_psi, _eps_ref,
        layer1_m_prop_ref_kg, float(target_thrust), _t_b, layer1_W_MASS,
        "config" if requirements.get("layer1_W_MASS") is not None else "priced like propellant")
    _lio_sf_raw = requirements.get("injector_dp_ratio_O_soft_floor")
    layer1_dp_o_soft_floor: Optional[float] = (
        float(_lio_sf_raw)
        if _lio_sf_raw is not None and np.isfinite(float(_lio_sf_raw))
        else None
    )
    layer1_W_DP_O_FLOOR = _requirement_float(requirements, "W_DP_O_FLOOR", 0.0)
    layer1_W_SMD = _requirement_float(requirements, "W_SMD", 0.0)
    layer1_target_smd_microns = _requirement_float(requirements, "target_smd_microns", 50.0)
    layer1_smd_rel_tol = _requirement_float(requirements, "layer1_smd_rel_tol", 0.20)
    layer1_W_TANK_EQUAL = _requirement_float(requirements, "W_TANK_EQUAL", 0.0)
    layer1_tank_equal_scale_psi = _requirement_float(requirements, "layer1_tank_equal_scale_psi", 100.0)
    layer1_tank_equal_tol_psi = _requirement_float(requirements, "layer1_tank_equal_tol_psi", 0.0)
    layer1_of_deadband_rel = _requirement_float(requirements, "layer1_of_deadband_rel", 0.0)
    # Default ON. This was made opt-in while the flat 1e6 infeasibility plateau meant a hard
    # geometry constraint could stall the search before it ever found a feasible point; the
    # infeasibility GRADIENT removed that failure mode (6/6 seeds converge with it enabled),
    # so leaving it off just silences a weight the user set and lets impossible rings through.
    layer1_enforce_ring_geometry = _requirement_bool(
        requirements, "layer1_enforce_ring_geometry", True)
    # Injector face real estate. Default 0.0 => inert, identical to the previous behaviour.
    layer1_injector_center_clear_dia_m = _requirement_float(
        requirements, "layer1_injector_center_clear_dia_m", 0.0)
    layer1_injector_min_web_m = _requirement_float(
        requirements, "layer1_injector_min_web_m", 0.0)
    layer1_injector_wall_clearance_m = _requirement_float(
        requirements, "layer1_injector_wall_clearance_m", 0.0)
    layer1_injector_spray_radius_frac = _requirement_float(
        requirements, "layer1_injector_spray_radius_frac", 0.0)
    layer1_injector_spray_radius_tol = _requirement_float(
        requirements, "layer1_injector_spray_radius_tol", 0.08)
    layer1_injector_min_face_incidence_deg = _requirement_float(
        requirements, "layer1_injector_min_face_incidence_deg", 0.0)
    layer1_injector_plate_thickness_m = _requirement_float(
        requirements, "layer1_injector_plate_thickness_m", 0.0)
    layer1_injector_counterbore_dia_m = _requirement_float(
        requirements, "layer1_injector_counterbore_dia_m", 0.0)
    layer1_injector_min_back_web_m = _requirement_float(
        requirements, "layer1_injector_min_back_web_m", 0.0)
    # Orifice L/d per side and how the plug is machined (injector.plate): one derivation,
    # shared with the sign-off gates (_layer1_injector_plate_constants).
    _pc = _layer1_injector_plate_constants(config_obj, requirements)
    layer1_injector_land_ld_O = _pc["layer1_injector_land_ld_O"]
    layer1_injector_land_ld_F = _pc["layer1_injector_land_ld_F"]
    layer1_injector_face_contoured = _pc["layer1_injector_face_contoured"]
    layer1_injector_back_channels = _pc["layer1_injector_back_channels"]
    layer1_injector_exit_land = _pc["layer1_injector_exit_land"]
    layer1_injector_channel_width_m = _pc["layer1_injector_channel_width_m"]
    layer1_injector_channel_floor = _pc["layer1_injector_channel_floor"]
    layer1_injector_channel_inlets = _pc["layer1_injector_channel_inlets"]
    layer1_injector_plate_support = _pc["layer1_injector_plate_support"]
    if layer1_injector_face_contoured and layer1_injector_back_channels:
        # Square exits AND passage length set by the channel: nothing left for the ceiling.
        layer1_injector_min_face_incidence_deg = 0.0
    from engine.core.injectors.layout import assembly_envelope as _assembly_envelope
    _env = _assembly_envelope(config_obj)
    layer1_injector_r_plate_m = float(_env["r_sleeve_id"])      # fallback; per candidate below
    layer1_injector_liner_thickness_m = float(_env["liner_thickness"])
    # A declared igniter port sets the centre keep-out from its thread when no explicit
    # reservation is given, and its hub / socket becomes a back-face keep-out. Nothing
    # declared => nothing changes.
    layer1_injector_center_clear_dia_m = _layer1_centre_clear_m(config_obj, requirements)
    _ign = _layer1_igniter_keepouts(config_obj, requirements)
    layer1_injector_back_keepout_dia_m = float(_ign["back_keepout_dia"]) if _ign else 0.0
    layer1_injector_back_keepout_wall_m = float(_ign["face_wall"]) if _ign else 0.0
    layer1_injector_r_port_m = 0.5 * float(_ign["thread_od"]) if _ign else 0.0
    layer1_resultant_tilt_from_reach = _requirement_bool(
        requirements, "layer1_resultant_tilt_from_reach", False)
    layer1_resultant_tilt_reach_margin = _requirement_float(
        requirements, "layer1_resultant_tilt_reach_margin", 1.5)
    layer1_chamber_od_increment_in = _requirement_float(
        requirements, "layer1_chamber_od_increment_in", 0.0
    )
    layer1_chamber_od_snap_target = _od_snap_target
    layer1_tank_equal_inband_frac = _requirement_float(
        requirements, "layer1_tank_equal_inband_frac", 0.0)
    # "Match propellant tank pressures" says the two are ONE quantity. Follow the checkbox
    # (which sets W_TANK_EQUAL) by default, but keep it separately overridable so a user can
    # want them near-equal without welding them together.
    layer1_lock_tank_pressures = _requirement_bool(
        requirements, "layer1_lock_tank_pressures", layer1_W_TANK_EQUAL > 0.0)
    layer1_ring_order_fuel_outboard = _requirement_bool(
        requirements, "layer1_ring_order_fuel_outboard", True)
    # R's ONLY job was to guard the liner, and it did it badly (R = 1 is not balance --
    # p_O/p_F = R^2*A_O/A_F). The resultant tilt below now does that job properly, so R keeps
    # no directional preference: a multiplier of 1 makes it symmetric about 1, a mild mixing
    # preference and nothing more. Left at 10 it charged 430-1630 objective points against
    # precisely the tilt-balanced designs, because balancing the fan puts R a few tenths of a
    # percent above 1.
    layer1_momentum_wall_side_multiplier = _requirement_float(
        requirements, "layer1_momentum_wall_side_multiplier", 1.0)
    layer1_resultant_tilt_max_deg = _requirement_float(
        requirements, "layer1_resultant_tilt_max_deg", 0.0)
    layer1_resultant_tilt_scale_deg = _requirement_float(
        requirements, "layer1_resultant_tilt_scale_deg", 2.0)
    layer1_W_TILT = _requirement_float(requirements, "layer1_W_TILT", 0.0)
    layer1_resultant_tilt_outward_multiplier = _requirement_float(
        requirements, "layer1_resultant_tilt_outward_multiplier", 25.0)
    layer1_resultant_tilt_gate_tol_deg = _requirement_float(
        requirements, "layer1_resultant_tilt_gate_tol_deg", 1.0)
    layer1_momentum_low_side_multiplier = _requirement_float(
        requirements, "layer1_momentum_low_side_multiplier", 10.0)
    layer1_momentum_band_width = _requirement_float(
        requirements, "layer1_momentum_band_width", 0.05)
    layer1_momentum_scale = _requirement_float(requirements, "layer1_momentum_scale", 0.10)
    # The gate is the configured band; >1 widens it on purpose, never by default.
    layer1_momentum_gate_safe_slack = max(1.0, _requirement_float(
        requirements, "layer1_momentum_gate_safe_slack", 1.0))
    # The user states ONE number -- how many jet diameters off the face the jets should meet --
    # and the free window is that target +/- tol. Explicit Ld_min/Ld_max still win, so an
    # existing config that set the band keeps its behaviour.
    layer1_derive_impingement_spacing = _requirement_bool(
        requirements, "layer1_derive_impingement_spacing", True)
    # With the spacing DERIVED, L/d lands on the target exactly, so the band is the target --
    # zero width. It is not a preference to negotiate; the only way to miss it is the fuel
    # ring clamping at the bore, and that is exactly what should be reported. The tolerance
    # remains for anyone who turns the derivation off and wants a search window instead.
    # One resolver (engine.core.injectors.layout) so the drawing and audit agree with this.
    _ld_target, layer1_impingement_Ld_min, layer1_impingement_Ld_max = impingement_ld_band(
        requirements)
    layer1_W_IMP_GEOM = _requirement_float(requirements, "W_IMP_GEOM", 0.0)
    layer1_W_geom_ao_af = float(requirements.get("W_geom_ao_af_momentum", 0.0))
    # With the tanks locked, dP_O ~= dP_F, so R ~= Cd_O/Cd_F ~= 1 by construction and the
    # injector AREA ratio is the only lever left for O/F. This hint pushes that same area
    # ratio toward "R=1 at the target MR", which presumes the two dPs can differ -- a target
    # that no longer exists -- and its scale GROWS with O/F error, so the worse O/F gets the
    # harder it pulls the wrong way (measured: O/F 30% off, of=5500-6400 of a 6300-7700
    # objective, geom_ao_af=360-420 riding alongside it). Off when locked.
    _tanks_locked_for_geom = _requirement_bool(
        requirements, "layer1_lock_tank_pressures",
        _requirement_float(requirements, "W_TANK_EQUAL", 0.0) > 0.0)
    layer1_W_THRUST_obj = _requirement_float(requirements, "layer1_W_THRUST", 1e4)
    layer1_W_OF_obj = _requirement_float(requirements, "layer1_W_OF", 1e4)
    _w_ol = requirements.get("layer1_W_OF_low_MR_scale")
    layer1_W_OF_low_MR_scale = max(1.0, float(_w_ol)) if _w_ol is not None else 1.0
    _w_oh = requirements.get("layer1_W_OF_high_MR_scale")
    layer1_W_OF_high_MR_scale = max(1.0, float(_w_oh)) if _w_oh is not None else 1.0
    # Impinging methane runs can stall at high O/F while still satisfying momentum/ΔP if
    # AO/AF geometry guidance is disabled. Apply a conservative adaptive fallback when unset.
    if l1_injector_type == "impinging" and layer1_W_geom_ao_af <= 0.0:
        layer1_W_geom_ao_af = 0.0 if _tanks_locked_for_geom else max(400.0, 0.05 * layer1_W_OF_obj)
    if l1_injector_type == "impinging" and _tanks_locked_for_geom and layer1_W_geom_ao_af > 0.0:
        # Explicit value in the config, but the tanks are locked: dP_O ~= dP_F makes R ~= 1
        # structural and this hint redundant with the O/F term (same target area ratio), while
        # its error-scaled weight adds positive feedback to any O/F miss. Off, and say so.
        layer1_logger.info(
            "Layer 1: W_geom_ao_af_momentum=%g ignored -- tank pressures are locked, so the "
            "momentum ratio is fixed by construction and O/F alone owns the injector area ratio.",
            layer1_W_geom_ao_af)
        layer1_W_geom_ao_af = 0.0
    layer1_of_validation_tol = _requirement_float(requirements, "layer1_of_validation_tol", 0.15)
    # Final validation uses ``layer1_thrust_validation_rel_tol`` when set; errors_acceptable must match.
    _thr_gate_yaml = requirements.get("layer1_thrust_validation_rel_tol")
    layer1_gate_thrust_tol = (
        float(_thr_gate_yaml)
        if _thr_gate_yaml is not None and np.isfinite(float(_thr_gate_yaml)) and float(_thr_gate_yaml) > 0
        else float(thrust_tol)
    )
    layer1_logger.info(
        "Injector ΔP_inj/Pc preferred bands (soft hinge): "
        f"oxidizer [{layer1_dp_o_band[0]:.3f}, {layer1_dp_o_band[1]:.3f}], "
        f"fuel [{layer1_dp_f_band[0]:.3f}, {layer1_dp_f_band[1]:.3f}]"
    )
    layer1_logger.info(
        "Injector ΔP weights: W_DP=%g (fallback); W_DP_O=%g; W_DP_F=%g",
        layer1_W_DP,
        layer1_W_DP_O,
        layer1_W_DP_F,
    )
    if layer1_dp_o_soft_floor is not None and layer1_dp_o_soft_floor > 0 and layer1_W_DP_O_FLOOR > 0:
        layer1_logger.info(
            "LOX dP_inj/Pc soft floor: penalize ratios below %.4f using W_DP_O_FLOOR=%.4g*(floor-r_O)^2",
            layer1_dp_o_soft_floor,
            layer1_W_DP_O_FLOOR,
        )
    if layer1_W_geom_ao_af > 0.0:
        layer1_logger.info(
            f"Geometry AO/AF momentum hint weight W_geom_ao_af_momentum={layer1_W_geom_ao_af:g} "
            f"(targets A_O/A_F ≈ MR/√(ρ_O/ρ_F) for R≈1)"
        )
    if layer1_impinging_R_mom_lo is not None and layer1_impinging_R_mom_hi is not None:
        layer1_logger.info(
            "Impinging momentum_ratio_R: validation band "
            f"[{layer1_impinging_R_mom_lo:g}, {layer1_impinging_R_mom_hi:g}], optimizer AIM band "
            f"[{layer1_R_mom_aim_lo:g}, {layer1_R_mom_aim_hi:g}] "
            f"(penalty pushes inside the aim band so validation passes with margin)"
        )
    if layer1_W_impinging_angle > 0.0 and layer1_impinging_angle_deg_lo is not None and layer1_impinging_angle_deg_hi is not None:
        layer1_logger.info(
            "Impinging effective-angle preferred band (deg): "
            f"[{layer1_impinging_angle_deg_lo:g}, {layer1_impinging_angle_deg_hi:g}] "
            f"with W_IMPINGING_ANGLE={layer1_W_impinging_angle:g}"
        )
    if l1_injector_type == "impinging" and layer1_W_impinging_jet_asym > 0.0:
        layer1_logger.info(
            "Impinging paired jet |Δθ_O/F| soft cap: max Δ=%.2f° with W_IMPINGING_JET_ASYM=%g",
            float(layer1_impinging_jet_max_asym_deg),
            float(layer1_W_impinging_jet_asym),
        )
    layer1_logger.info(
        "Ambient-matched exit pressure: inside-deadband quadratic scale "
        "layer1_exit_pressure_inside_quad_scale=%g (W_EXIT×scale×rel²; 0=flat inside band)",
        float(layer1_exit_pressure_inside_quad),
    )
    layer1_logger.info(
        "Layer 1 primary weights: layer1_W_THRUST=%g layer1_W_OF=%g low_MR_scale=%g high_MR_scale=%g; "
        "of_validation_tol=%.4f",
        layer1_W_THRUST_obj,
        layer1_W_OF_obj,
        layer1_W_OF_low_MR_scale,
        layer1_W_OF_high_MR_scale,
        layer1_of_validation_tol,
    )
 
    log_flags = {
        "marginal_candidate_logged": False,
    }
    
    update_progress("Layer 1: Objective", 0.10, "Defining objective function...")
    
    # ------------------------------------------------------------------
    # Objective acceleration: cache expensive evaluate() calls
    # ------------------------------------------------------------------
    # Many optimizers will revisit the same point (especially with discrete
    # variables like n_orifices). Caching is a large speed win because
    # `PintleEngineRunner.evaluate()` is the expensive part.
    #
    # Cache key strategy:
    # - clip to bounds
    # - quantize continuous dims to a fraction of their span
    # - keep discrete dims exact (n_orifices)
    # Finer granularity (1e-5 instead of 1e-4) to preserve gradient information for L-BFGS-B
    _ocr = requirements.get("objective_cache_rel")  # None-safe, see report_every_n
    cache_rel = float(_ocr) if _ocr is not None else 1e-5  # 0.001% of span per bin
    cache_rel = float(np.clip(cache_rel, 1e-6, 1e-3))
    cache_steps = np.maximum(span * cache_rel, 1e-12)
    eval_cache: Dict[Tuple[int, ...], Dict[str, Any]] = {}
    
    def _make_eval_cache_key(x_raw: np.ndarray) -> Tuple[int, ...]:
        """Quantize x to a stable hashable key for caching evaluate() results."""
        x_arr = np.clip(np.asarray(x_raw, dtype=float), lower_bounds, upper_bounds)
        x_arr = x_arr.copy()
        for di in layer1_integer_dims:
            if 0 <= di < len(x_arr):
                x_arr[di] = int(round(x_arr[di]))
        key_parts = []
        for i, v in enumerate(x_arr):
            if i in layer1_integer_dims:
                key_parts.append(int(v))
                continue
            step = float(cache_steps[i])
            # Quantize within bounds so different absolute magnitudes hash consistently
            key_parts.append(int(round((float(v) - float(lower_bounds[i])) / step)))
        return tuple(key_parts)
    
    def _check_valley_escape_tier() -> int:
        return _layer1_valley_escape_tier(
            opt_state["function_evaluations"], opt_state["best_objective"],
            opt_state["function_evaluations"] - opt_state["last_best_eval"])
 
    # Define objective function
    def objective(x: np.ndarray) -> float:
        """Layer 1 objective function: optimize geometry + initial pressures.
        
        Staged/lexicographic structure (approximate but smooth):
        1) Feasibility (hard constraints + stability gates)
        2) Thrust closeness
        3) O/F closeness
        4) Regularization (Cf band, chamber length, exit pressure)
        
        Note: we still return a single scalar for SciPy/CMA-ES, but the scaling
        preserves the priority ordering and reduces "weight fights".
        """
        
        # Initialize opt_state keys
        for key in ["consecutive_failures", "last_valid_obj", "iteration", "function_evaluations", "best_objective", "best_x"]:
            if key not in opt_state:
                opt_state[key] = 0 if key in ["iteration", "function_evaluations", "consecutive_failures"] else (float('inf') if key in ["last_valid_obj", "best_objective"] else None)
        
        opt_state["iteration"] += 1
        iteration = opt_state["iteration"]
        opt_state["function_evaluations"] += 1
        
        # Progress update. ``iteration`` counts candidate evaluations, so it must be
        # measured against the evaluation budget (max_iterations x popsize x restarts),
        # not against ``max_iterations``, which caps CMA *generations*.
        # Set once popsize/restarts are known; before that (x0 validation, warm start)
        # there is no budget to measure against, so report the raw count rather than a
        # fraction of the wrong denominator.
        eval_budget = int(opt_state.get("eval_budget", 0))
        if eval_budget > 0:
            progress = 0.10 + 0.40 * min(iteration / eval_budget, 1.0)
            eval_str = f"{iteration}/{eval_budget}"
        else:
            progress = 0.10
            eval_str = f"{iteration}"
        if iteration <= 3 or iteration % 25 == 0:
            try:
                _bo = float(opt_state["best_objective"])
            except (TypeError, ValueError):
                _bo = float("inf")
            _lv_raw = opt_state.get("last_valid_obj", float("inf"))
            try:
                _lv = float(_lv_raw) if _lv_raw is not None else float("inf")
            except (TypeError, ValueError):
                _lv = float("inf")
            best_obj_str = f"{_bo:.3e}" if np.isfinite(_bo) else "inf"
            curr_obj_str = f"{_lv:.3e}" if np.isfinite(_lv) else "inf"
            update_progress("Layer 1: Optimization", progress, f"Eval {eval_str} | Curr: {curr_obj_str} | Best: {best_obj_str}")
            layer1_logger.info(f"[{int(progress*100)}%] Evaluation {eval_str} - "
                            f"Objective: {curr_obj_str} (Best: {best_obj_str})")
            for handler in layer1_logger.handlers:
                handler.flush()
        
        # Always work with a clipped/consistent candidate vector (helps caching and stability)
        x_clipped = np.clip(np.asarray(x, dtype=float), lower_bounds_eff, upper_bounds_eff)
        # Apply the SAME derivations the workers apply, to the vector this objective will
        # score, cache, store as last_eval_config and report in the history. Without this the
        # reported design is not the design that was evaluated: the fuel tank came back at
        # its pinned seed (535.2) while the physics had run with it locked to the LOX tank,
        # and the fuel ring pitch had the same problem.
        _layer1_derive_matched_tank_pressure(x_clipped, _derive_constants)
        _layer1_derive_fuel_spacing(x_clipped, _derive_constants)
        # Discrete variable
        x_clipped = x_clipped.copy()
        for di in layer1_integer_dims:
            if 0 <= di < len(x_clipped):
                x_clipped[di] = int(round(x_clipped[di]))
 
        # Convert x to config
        config, _, _ = apply_x_to_config(x_clipped, config_base)
        
        # Feasibility pre-checks (cheap): injector sizing, geometry, and O/F area sanity
        from engine.pipeline.config_schemas import ensure_chamber_geometry
        cg = ensure_chamber_geometry(config)
        A_throat_check = float(cg.A_throat or 0.0)
        D_chamber_inner = float(cg.chamber_diameter or 0.0)
        A_chamber_check = np.pi * (D_chamber_inner / 2) ** 2
        
        geom = getattr(getattr(config, "injector", None), "geometry", None)
        has_pintle = bool(getattr(getattr(config, "injector", None), "type", None) == "pintle" and geom is not None)
        has_impinging = bool(getattr(getattr(config, "injector", None), "type", None) == "impinging" and geom is not None)
 
        A_lox_injector = np.nan
        A_fuel_injector = np.nan
        lox_ratio = np.nan
        fuel_ratio = np.nan
        area_ratio_error = np.nan
        
        infeasibility_score = 0.0
        
        # --- Geometric Validation Rules ---
        
        # 1. Throat area must be less than chamber area (with some margin)
        # Typically contraction ratio (A_chamber / A_throat) is between 2 and 10
        if A_chamber_check > 0 and A_throat_check > 0:
            contraction_ratio_check = A_chamber_check / A_throat_check
            # Constraint: A_throat < A_chamber (contraction_ratio > 1.0)
            infeasibility_score += max(0.0, (A_throat_check * 1.1) / A_chamber_check - 1.0) ** 2
            
            # Preferred range for contraction ratio: [1.5, 15.0]
            if contraction_ratio_check < 1.5:
                infeasibility_score += (1.5 - contraction_ratio_check) ** 2
            elif contraction_ratio_check > 15.0:
                infeasibility_score += (contraction_ratio_check - 15.0) ** 2
 
        # 2. Pintle diameter must be less than chamber diameter
        if has_pintle and D_chamber_inner > 0:
            d_pintle_tip_check = float(geom.fuel.d_pintle_tip)
            # Constraint: d_pintle_tip < D_chamber_inner (with 10% margin)
            infeasibility_score += max(0.0, (d_pintle_tip_check * 1.1) / D_chamber_inner - 1.0) ** 2
 
        # 2a. Explicit Throat Diameter vs Chamber Diameter check
        # D_throat < D_chamber check
        D_throat_check = np.sqrt(4.0 * A_throat_check / np.pi) if A_throat_check > 0 else 0.0
        if D_throat_check > 0 and D_chamber_inner > 0:
             # Penalize if throat is larger than 95% of chamber
             # This reinforces the contraction ratio check with an explicit diameter-based gradient
             infeasibility_score += max(0.0, D_throat_check - D_chamber_inner * 0.95) ** 2 * 10.0
 
        # 3. Nozzle exit diameter vs throat diameter
        D_exit_check = float(cg.exit_diameter or 0.0)
        R_throat_check = np.sqrt(max(0, A_throat_check / np.pi))
        D_throat_check = 2 * R_throat_check
        if D_exit_check > 0 and D_throat_check > 0:
            # Expansion ratio should be >= 1.0 (already handled by bounds, but for safety)
            infeasibility_score += max(0.0, D_throat_check / D_exit_check - 1.0) ** 2
 
        # --- Injector and O/F Validation ---
        
        if has_pintle and A_throat_check > 0:
            A_lox_injector = float(geom.lox.n_orifices * np.pi * (geom.lox.d_orifice / 2) ** 2)
            R_inner = float(geom.fuel.d_pintle_tip / 2)
            R_outer = float(R_inner + geom.fuel.h_gap)
            A_fuel_injector = float(np.pi * (R_outer ** 2 - R_inner ** 2))
            # Flow-capacity vs throat and O/F area sanity use Cd-weighted A_eff (post-evaluate below)
 
        if has_impinging and A_throat_check > 0:
            oxg = geom.oxidizer
            fug = geom.fuel
            A_lox_injector = float(oxg.n_elements * np.pi * (oxg.d_jet / 2.0) ** 2)
            A_fuel_injector = float(fug.n_elements * np.pi * (fug.d_jet / 2.0) ** 2)
            sp_O = float(oxg.spacing)
            sp_F = float(fug.spacing)
            djo = float(oxg.d_jet)
            djf = float(fug.d_jet)
            infeasibility_score += _impinging_infeasibility_layout_terms(
                d_jet_O=djo,
                d_jet_F=djf,
                sp_O=sp_O,
                sp_F=sp_F,
                n_el_O=int(oxg.n_elements),
                n_el_F=int(fug.n_elements),
                D_chamber_inner=D_chamber_inner,
            )
 
        # Tank pressures (dimensionless ratios are used for penalties and caching guidance)
        P_O_psi = float(np.clip(x_clipped[idx_P_O], bounds[idx_P_O][0], bounds[idx_P_O][1]))
        P_F_psi = float(np.clip(x_clipped[idx_P_F], bounds[idx_P_F][0], bounds[idx_P_F][1]))
        P_O_test = P_O_psi * psi_to_Pa
        P_F_test = P_F_psi * psi_to_Pa
        P_O_ratio = P_O_psi / max_lox_P_psi if max_lox_P_psi > 0 else 0.0
        P_F_ratio = P_F_psi / max_fuel_P_psi if max_fuel_P_psi > 0 else 0.0
        
        skip_physics_eval = False
        if has_impinging and A_throat_check > 0 and geom is not None:
            oxg = geom.oxidizer
            fug = geom.fuel
            skip_physics_eval = _impinging_hard_geometry_blocks_eval(
                d_jet_O=float(oxg.d_jet),
                d_jet_F=float(fug.d_jet),
                sp_O=float(oxg.spacing),
                sp_F=float(fug.spacing),
                D_chamber_inner=D_chamber_inner,
                D_throat_check=D_throat_check,
                A_chamber_check=A_chamber_check,
                A_throat_check=A_throat_check,
                n_elements=float(oxg.n_elements),
                angle_O_deg=float(oxg.impingement_angle),
                angle_F_deg=float(fug.impingement_angle),
                center_clear_dia_m=layer1_injector_center_clear_dia_m,
                min_web_m=layer1_injector_min_web_m,
                wall_clearance_m=layer1_injector_wall_clearance_m,
                min_face_incidence_deg=layer1_injector_min_face_incidence_deg,
                spray_radius_frac=layer1_injector_spray_radius_frac,
                spray_radius_tol=layer1_injector_spray_radius_tol,
                plate_thickness_m=layer1_injector_plate_thickness_m,
                counterbore_dia_m=layer1_injector_counterbore_dia_m,
                land_ld_O=layer1_injector_land_ld_O,
                land_ld_F=layer1_injector_land_ld_F,
                min_back_web_m=layer1_injector_min_back_web_m,
                back_keepout_dia_m=layer1_injector_back_keepout_dia_m,
                back_keepout_wall_m=layer1_injector_back_keepout_wall_m,
                face_contoured=layer1_injector_face_contoured,
                exit_land=layer1_injector_exit_land,
                back_channels=layer1_injector_back_channels,
                passage_ld_O=layer1_injector_land_ld_O,
                passage_ld_F=layer1_injector_land_ld_F,
                channel_width_m=layer1_injector_channel_width_m,
                channel_floor=layer1_injector_channel_floor,
                r_plate_m=layer1_injector_r_plate_m,
                r_port_m=layer1_injector_r_port_m,
                liner_thickness_m=layer1_injector_liner_thickness_m,
            )
        elif infeasibility_score > 0.0:
            skip_physics_eval = True
 
        eval_success = False
        final_results: Dict[str, Any] = {}
        final_pressures = (P_O_test, P_F_test)
        eval_error_str: Optional[str] = None
        
        # During L-BFGS-B refinement, ``objective()`` is called sequentially and needs
        # exact ``evaluate()`` values for finite-diff gradients — cache quantization can
        # flatten curvature and inflate residuals. Parallel CMA paths use workers, not this
        # cache toggle.
        cache_enabled = not bool(opt_state.get("layer1_lbfgs_phase", False))
        cache_key = _make_eval_cache_key(x_clipped) if cache_enabled else None
        if not skip_physics_eval:
            cached = eval_cache.get(cache_key) if cache_enabled and cache_key is not None else None
            use_cached = False
            if cached is not None:
                # Handle both dict format (full cache from objective) and float/dict format (from parallel eval)
                if isinstance(cached, dict):
                    # Check if it's the full format with "results" key
                    if "results" in cached:
                        eval_success = bool(cached.get("success", False))
                        final_results = copy.deepcopy(cached.get("results", {})) if eval_success else {}
                        eval_error_str = cached.get("error", None)
                        use_cached = True
                        # Replay the solved DOFs onto x/config. The cache key is
                        # the *proposed* vector, so without this a hit would hand
                        # back results for the solved geometry while ``config``
                        # still described the unsolved one.
                        _xs = cached.get("x_solved")
                        if _xs is not None and len(_xs) == len(x_clipped):
                            x_clipped[:] = np.asarray(_xs, dtype=float)
                            _layer1_apply_chamber_geometry_to_config(
                                config,
                                A_throat=float(x_clipped[0]),
                                Lstar=float(x_clipped[1]),
                                expansion_ratio=float(x_clipped[2]),
                                D_chamber_outer=_quantize_chamber_od_m(
                                    float(x_clipped[3]), _od_increment_in,
                                    wall_m=wall_total_m, snap_target=_od_snap_target),
                                max_nozzle_exit=max_nozzle_exit,
                                wall_thickness_m=wall_total_m,
                            )
                    else:
                        # Partial format from parallel eval (only has 'value', 'success')
                        # Can't use this - we need the full results dict, so treat as cache miss
                        use_cached = False
                else:
                    # Old format: direct float value - can't use, need full results
                    use_cached = False
            
            if not use_cached:
                # Thermal protection stays as the config declares it, so this path scores the
                # same bore as the worker pool. It used to be forced off "for speed", which made
                # the inline objective and the pool disagree by the liner thickness.
                config_runner = copy.deepcopy(config)
                if os.environ.get("ED_L1_INLINE_THERMAL_OFF", "0") == "1":
                    if hasattr(config_runner, "ablative_cooling") and config_runner.ablative_cooling:
                        config_runner.ablative_cooling.enabled = False
                    if hasattr(config_runner, "graphite_insert") and config_runner.graphite_insert:
                        config_runner.graphite_insert.enabled = False
                
                test_runner = PintleEngineRunner(config_runner)
 
                _last_err = [None]
 
                def _evaluate_once_slow():
                    # The worker pool's evaluation path (accelerator first, Python when it
                    # declines), so the inline objective scores exactly what the pool scores.
                    try:
                        if _native_fast_eval_enabled():
                            from engine import accel as _accel
                            _r = _accel.evaluate(test_runner.config, test_runner.cea_cache,
                                                 P_O_test, P_F_test, target_P_exit)
                            if _r is not None:
                                return _r
                        return test_runner.evaluate(
                            P_O_test, P_F_test, P_ambient=target_P_exit, silent=True)
                    except Exception as _e:
                        _last_err[0] = str(_e)
                        return None
 
                # Same first-evaluation recovery as the worker: "Supply < Demand" is a throat
                # too small to bracket a Pc, which the derived-throat solve fixes once it has
                # a result -- grow it and retry before calling the candidate dead.
                _first = None
                _prev_grow = 1.0
                for _grow in (1.0, 1.3, 1.7, 2.2):
                    if _grow != 1.0:
                        x_clipped[0] = float(min(x_clipped[0] * (_grow / _prev_grow),
                                                 derive_At_range[1]))
                        _layer1_apply_chamber_geometry_to_config(
                            config_runner, A_throat=float(x_clipped[0]),
                            Lstar=float(x_clipped[1]), expansion_ratio=float(x_clipped[2]),
                            D_chamber_outer=_quantize_chamber_od_m(
                                float(x_clipped[3]), _od_increment_in,
                                wall_m=wall_total_m, snap_target=_od_snap_target),
                            max_nozzle_exit=max_nozzle_exit, wall_thickness_m=wall_total_m)
                    _prev_grow = _grow
                    _first = _evaluate_once_slow()
                    _err = (_last_err[0] or "")
                    if (_first is not None or not derive_throat_from_thrust
                            or not ("Supply < Demand" in _err or "Insufficient mass flow" in _err)):
                        break
                if _first is None:
                    eval_success = False
                    eval_error_str = _last_err[0] or "evaluate() raised"
                    final_results = {}
                else:
                    # Same derived-DOF solve as the worker path.
                    _solved = _layer1_solve_derived_geometry(
                        x_clipped, config_runner, _derive_constants,
                        _evaluate_once_slow, _first,
                        cea_cache=getattr(test_runner, "cea_cache", None),
                    )
                    final_results = _solved if isinstance(_solved, dict) else _first
                    eval_success = True
                    # Mirror the solved geometry onto ``config`` -- it is what
                    # gets stored as ``last_eval_config`` and finalised.
                    _layer1_apply_chamber_geometry_to_config(
                        config,
                        A_throat=float(x_clipped[0]),
                        Lstar=float(x_clipped[1]),
                        expansion_ratio=float(x_clipped[2]),
                        D_chamber_outer=_quantize_chamber_od_m(
                            float(x_clipped[3]), _od_increment_in,
                            wall_m=wall_total_m, snap_target=_od_snap_target),
                        max_nozzle_exit=max_nozzle_exit,
                        wall_thickness_m=wall_total_m,
                    )
 
                if cache_enabled and cache_key is not None:
                    eval_cache[cache_key] = {
                        "success": bool(eval_success),
                        "results": copy.deepcopy(final_results) if eval_success else {},
                        "error": eval_error_str,
                        "x_solved": x_clipped.tolist(),
                    }
        
        # Score with THE objective -- the one the worker pool uses -- on the solved vector.
        if eval_success and isinstance(final_results, dict):
            final_results["eps"] = float(final_results.get("eps", x_clipped[2]))
        _T = _layer1_objective_terms(
            final_results if eval_success else None, x_clipped, requirements, constants_dict,
            cea_cache=_l1_cea_cache, eval_error=eval_error_str)
        obj = float(_T["objective"])
        _tw = _T["terms"]
        infeasibility_score = float(_T.get("infeasibility_score", 1.0))
        inf_residual = float(_T.get("inf_residual", infeasibility_score))
        length_violation = bool(_T.get("length_violation", False))
        raw_feasible_obj = obj if (eval_success and inf_residual <= 0.0 and not length_violation) else float("nan")
 
        F_actual = float(_T.get("F", np.nan))
        Isp_actual = float(_T.get("Isp", np.nan))
        MR_actual = float(_T.get("MR", np.nan))
        Pc_actual = float(_T.get("Pc", np.nan))
        Cf_actual = float(_T.get("Cf", np.nan))
        thrust_error = float(_T.get("thrust_error", 1.0))
        of_error = float(_T.get("of_error", 1.0))
        stability = _T.get("stability_results", {}) or {}
        stability_state = _T.get("stability_state", "unstable")
        stability_score = float(_T.get("stability_score", 0.0))
        chugging_margin = float(_T.get("chugging_margin", 0.0))
        acoustic_margin = float(_T.get("acoustic_margin", 0.0))
        feed_margin = float(_T.get("feed_margin", 0.0))
        state_ok = bool(_T.get("state_ok", False))
        effective_min_score = float(_T.get("effective_min_score", 0.0))
        effective_margin = float(_T.get("effective_margin", 0.0))
        ratio_o_obj = _T.get("injector_dp_ratio_O")
        ratio_f_obj = _T.get("injector_dp_ratio_F")
        L_chamber_curr = float(_T.get("L_chamber", np.nan))
        smd_eff_um = float(_T.get("effective_smd_microns", np.nan))
        imp_angle_deg = float(_T.get("impingement_angle_deg", np.nan))
        cf_hinge = float(_T.get("cf_hinge", 0.0))
        W_CF = 1e2
 
        if eval_success and isinstance(final_results, dict) and np.isfinite(F_actual):
            opt_state["last_good_eval_bundle"] = {
                "results": copy.deepcopy(final_results),
                "P_O_Pa": float(P_O_test),
                "P_F_Pa": float(P_F_test),
                "thrust_error": float(thrust_error),
                "of_error": float(of_error),
            }
 
        # "Acceptable" uses the final validation gates (configured bands, not aim bands).
        thrust_tol_validation = float(layer1_gate_thrust_tol)
        of_tol_validation = float(layer1_of_validation_tol)
        dp_gate_obj = True
        _ok_o_dp = injector_dp_ratio_within_gate(ratio_o_obj, layer1_dp_o_band[0], layer1_dp_o_band[1])
        if _ok_o_dp is not None:
            dp_gate_obj &= bool(_ok_o_dp)
        _ok_f_dp = injector_dp_ratio_within_gate(ratio_f_obj, layer1_dp_f_band[0], layer1_dp_f_band[1])
        if _ok_f_dp is not None:
            dp_gate_obj &= bool(_ok_f_dp)
        momentum_gate_obj = True
        _R_m_gate = float(_T.get("momentum_ratio_R", np.nan))
        if (has_impinging and np.isfinite(_R_m_gate)
                and layer1_impinging_R_mom_lo is not None and layer1_impinging_R_mom_hi is not None):
            momentum_gate_obj = (
                float(layer1_impinging_R_mom_lo) <= _R_m_gate <= float(layer1_impinging_R_mom_hi))
        errors_acceptable = (
            eval_success
            and _layer1_feasible_for_primary_objective(infeasibility_score, requirements)
            and (thrust_error <= thrust_tol_validation + 1e-12)
            and (of_error <= of_tol_validation + 1e-12)
            and (stability_score >= effective_min_score * 0.8)
            and dp_gate_obj
            and momentum_gate_obj
        )
        if errors_acceptable:
            if final_pressures is not None:
                opt_state["best_pressures"] = final_pressures
                opt_state["best_results_for_validation"] = {
                    "F": F_actual, "MR": MR_actual,
                    "thrust_error": thrust_error, "of_error": of_error,
                    "stability_score": stability_score, "stability_state": stability_state,
                    "chugging_margin": chugging_margin, "acoustic_margin": acoustic_margin,
                    "feed_margin": feed_margin, "stability_results": stability,
                }
            if not opt_state.get('acceptable_found_logged', False):
                log_status("Layer 1", f"✓ Acceptable solution found! Obj={obj:.6e}, Thrust err: {thrust_error*100:.2f}%, O/F err: {of_error*100:.2f}% (continuing optimization...)")
                opt_state['acceptable_found_logged'] = True
            if np.isfinite(obj) and obj <= obj_tolerance:
                opt_state["objective_satisfied"] = True
                if obj < float(opt_state.get("satisfied_obj", float("inf"))):
                    opt_state["satisfied_obj"] = float(obj)
                opt_state["satisfied_eval_count"] = int(opt_state.get("satisfied_eval_count", 0)) + 1
 
        # A failed evaluation already scores >= BASE_INFEAS; never hand back anything better.
        if eval_success and np.isfinite(obj):
            opt_state['consecutive_failures'] = 0
            opt_state['last_valid_obj'] = obj
        else:
            opt_state['consecutive_failures'] += 1
 
        # Record history with all parameterization variables
        def _finite_or_none(v: Any) -> Optional[float]:
            try:
                vv = float(v)
            except Exception:
                return None
            return vv if np.isfinite(vv) else None
 
        # Derived DOFs are clipped to their *search* range, not to the collapsed
        # CMA bound -- the latter is a single point at the seed and would throw
        # away the value the solver just found.
        _at_clip = derive_At_range if derive_throat_from_thrust else bounds[0]
        _eps_clip = derive_eps_range if derive_expansion_ratio else bounds[2]
        A_throat_curr = float(np.clip(x_clipped[0], _at_clip[0], _at_clip[1]))
        Lstar_curr = float(np.clip(x_clipped[1], bounds[1][0], bounds[1][1]))
        expansion_ratio_curr = float(np.clip(x_clipped[2], _eps_clip[0], _eps_clip[1]))
        # Report the diameter that was actually EVALUATED, i.e. after stock snapping.
        # Reporting raw x[3] here meant a run snapped to a 6.000 in tube was displayed
        # as 5.963 in -- the number the user reads back was never the number built.
        D_outer_curr = _quantize_chamber_od_m(
            float(np.clip(x_clipped[3], bounds[3][0], bounds[3][1])),
            _od_increment_in, wall_m=wall_total_m, snap_target=_od_snap_target,
        )
        if l1_injector_type == "impinging":
            n_doublets_curr = int(round(np.clip(x_clipped[4], bounds[4][0], bounds[4][1])))
            n_elements_O_curr = n_doublets_curr
            d_jet_O_curr = float(np.clip(x_clipped[5], bounds[5][0], bounds[5][1]))
            imp_ang_O_curr = float(np.clip(x_clipped[6], bounds[6][0], bounds[6][1]))
            spacing_O_curr = float(np.clip(x_clipped[7], bounds[7][0], bounds[7][1]))
            n_elements_F_curr = n_doublets_curr
            d_jet_F_curr = float(np.clip(x_clipped[8], bounds[8][0], bounds[8][1]))
            imp_ang_F_curr = float(np.clip(x_clipped[9], bounds[9][0], bounds[9][1]))
            spacing_F_curr = float(np.clip(x_clipped[10], bounds[10][0], bounds[10][1]))
            d_pintle_tip_curr = float("nan")
            h_gap_curr = float("nan")
            n_orifices_curr = -1
            d_orifice_curr = float("nan")
        else:
            d_pintle_tip_curr = float(np.clip(x_clipped[4], bounds[4][0], bounds[4][1]))
            h_gap_curr = float(np.clip(x_clipped[5], bounds[5][0], bounds[5][1]))
            n_orifices_curr = int(round(np.clip(x_clipped[6], bounds[6][0], bounds[6][1])))
            d_orifice_curr = float(np.clip(x_clipped[7], bounds[7][0], bounds[7][1]))
            n_elements_O_curr = -1
            n_elements_F_curr = -1
            d_jet_O_curr = float("nan")
            d_jet_F_curr = float("nan")
            imp_ang_O_curr = float("nan")
            imp_ang_F_curr = float("nan")
            spacing_O_curr = float("nan")
            spacing_F_curr = float("nan")
        P_O_start_psi_hist = float(np.clip(x_clipped[idx_P_O], bounds[idx_P_O][0], bounds[idx_P_O][1]))
        P_F_start_psi_hist = float(np.clip(x_clipped[idx_P_F], bounds[idx_P_F][0], bounds[idx_P_F][1]))
        
        D_inner_curr = D_outer_curr - wall_total_m
        if D_inner_curr <= 0:
            D_inner_curr = max(D_outer_curr * 0.3, 0.01)
        
        lox_start_ratio_hist = P_O_start_psi_hist / max_lox_P_psi if max_lox_P_psi > 0 else 0.7
        fuel_start_ratio_hist = P_F_start_psi_hist / max_fuel_P_psi if max_fuel_P_psi > 0 else 0.7
        combined_stability_margin = min(chugging_margin, acoustic_margin, feed_margin) if eval_success else 0.0
        L_chamber_hist = L_chamber_curr if (np.isfinite(L_chamber_curr)) else None
        _R_hist = float("nan")
        if has_impinging and eval_success:
            _Rv_hist = final_results.get("diagnostics", {}).get("momentum_ratio_R")
            if _Rv_hist is not None:
                try:
                    _R_hist = float(_Rv_hist)
                except (TypeError, ValueError):
                    _R_hist = float("nan")
        _lstar_lo_hist = float(requirements.get("min_Lstar", 0.76))
        _lstar_hi_hist = float(requirements.get("max_Lstar", 1.5))
        _exp_lo_hist = float(exp_ratio_lo)
        _exp_hi_hist = float(exp_ratio_hi)
        
        _candidate_new_best = (
            eval_success
            and _layer1_feasible_scalar_objective(obj)
            and float(obj) < float(opt_state.get("best_objective", float("inf")))
        )
        _skip_history = (
            bool(opt_state.get("layer1_lbfgs_phase"))
            and not _candidate_new_best
            and (
                not eval_success
                or not _layer1_feasible_scalar_objective(obj)
                or float(inf_residual) > 0.0
            )
        )
        if not _skip_history:
            opt_state["history"].append({
            "iteration": iteration,
            "x": x_clipped.copy(),
            # Parameterization variables (geometries and pressures)
            "A_throat": A_throat_curr,
            "Lstar": Lstar_curr,
            "expansion_ratio": expansion_ratio_curr,
            "D_chamber_outer": D_outer_curr,
            "D_chamber_inner": D_inner_curr,
            "L_chamber": L_chamber_hist,
            "d_pintle_tip": d_pintle_tip_curr,
            "h_gap": h_gap_curr,
            "n_orifices": n_orifices_curr,
            "d_orifice": d_orifice_curr,
            "n_elements_O": n_elements_O_curr,
            "n_elements_F": n_elements_F_curr,
            "n_doublets": float(n_elements_O_curr) if l1_injector_type == "impinging" else float("nan"),
            "d_jet_O": d_jet_O_curr,
            "impingement_angle_O": imp_ang_O_curr,
            "spacing_O": spacing_O_curr,
            "d_jet_F": d_jet_F_curr,
            "impingement_angle_F": imp_ang_F_curr,
            "spacing_F": spacing_F_curr,
            "effective_smd_microns": _finite_or_none(smd_eff_um),
            "impingement_angle_deg_effective": _finite_or_none(imp_angle_deg),
            "P_O_start_psi": P_O_start_psi_hist,
            "P_F_start_psi": P_F_start_psi_hist,
            # Performance metrics
            "thrust": _finite_or_none(F_actual),
            "thrust_error": thrust_error,
            "of_error": of_error,
            "Isp": _finite_or_none(Isp_actual),
            "MR": _finite_or_none(MR_actual),
            "Pc": _finite_or_none(Pc_actual),
            "Cf": _finite_or_none(Cf_actual),
            "Cf_error": float(np.sqrt(cf_hinge)) if np.isfinite(cf_hinge) else 1.0,
            "Cf_penalty": float(_tw.get("cf_penalty", 0.0)),
            # Stability metrics
            "stability_margin": combined_stability_margin,
            "stability_state": stability_state,
            "stability_score": stability_score,
            "chugging_margin": chugging_margin,
            "acoustic_margin": acoustic_margin,
            "feed_margin": feed_margin,
            # Pressure ratios
            "lox_end_ratio": lox_start_ratio_hist,
            "fuel_end_ratio": fuel_start_ratio_hist,
            "lox_start_ratio": lox_start_ratio_hist,
            "fuel_start_ratio": fuel_start_ratio_hist,
            # Feasibility diagnostics
            "infeasibility_score": float(infeasibility_score),
            "eval_success": bool(eval_success),
            "eval_error": eval_error_str,
            # Constraint metrics (for UI per-term residual plots)
            "injector_dp_ratio_O": _finite_or_none(ratio_o_obj),
            "injector_dp_ratio_F": _finite_or_none(ratio_f_obj),
            "momentum_ratio_R": _finite_or_none(_R_hist),
            "raw_feasible_objective": _finite_or_none(raw_feasible_obj),
            "penalty_thrust": float(_tw.get("thrust_penalty", 0.0)),
            "penalty_pc_target": float(_tw.get("pc_target_penalty", 0.0)),
            "penalty_of": float(_tw.get("of_penalty", 0.0)),
            "penalty_cf": float(_tw.get("cf_penalty", 0.0)),
            "penalty_exit": float(_tw.get("exit_pressure_penalty", 0.0)),
            "penalty_injector_dp": float(_tw.get("injector_dp_penalty", 0.0)),
            "penalty_length": float(_tw.get("length_penalty", 0.0)),
            "penalty_chamber_shape": float(_tw.get("chamber_shape_penalty", 0.0)),
            "penalty_chamber_mass": float(_tw.get("chamber_mass_penalty", 0.0)),
            "penalty_isp": float(_tw.get("isp_penalty", 0.0)),
            "Isp_merit": _finite_or_none(_T.get("Isp_merit_s")),
            "penalty_lstar": float(_tw.get("lstar_penalty", 0.0)),
            "chamber_mass_kg": float(_T.get("chamber_mass_kg", float("nan"))),
            "penalty_momentum": float(_tw.get("momentum_balance_penalty", 0.0)),
            "penalty_impingement_angle": float(_tw.get("impingement_angle_penalty", 0.0)),
            "penalty_jet_asymmetry": float(_tw.get("jet_angle_asymmetry_penalty", 0.0)),
            "penalty_smd": float(_tw.get("smd_penalty", 0.0)),
            "penalty_tank_equal": float(_tw.get("tank_pressure_equal_penalty", 0.0)),
            "penalty_geom_fit": float(_tw.get("impinging_geometry_fit_penalty", 0.0)),
            "penalty_geom_ao_af": float(_tw.get("geom_ao_af_momentum_penalty", 0.0)),
            "band_violation_Lstar_sq": float(
                _relative_hinge_band_squared(Lstar_curr, _lstar_lo_hist, _lstar_hi_hist)
            ) if np.isfinite(Lstar_curr) else None,
            "band_violation_expansion_sq": float(
                _relative_hinge_band_squared(expansion_ratio_curr, _exp_lo_hist, _exp_hi_hist)
            ),
            "band_violation_dp_O_sq": float(
                _impinging_momentum_hinge_squared(
                    ratio_o_obj,
                    r_band_lo=float(layer1_dp_o_aim[0]),
                    r_band_hi=float(layer1_dp_o_aim[1]),
                )
            ) if ratio_o_obj is not None and np.isfinite(float(ratio_o_obj)) else None,
            "band_violation_dp_F_sq": float(
                _impinging_momentum_hinge_squared(
                    ratio_f_obj,
                    r_band_lo=float(layer1_dp_f_aim[0]),
                    r_band_hi=float(layer1_dp_f_aim[1]),
                )
            ) if ratio_f_obj is not None and np.isfinite(float(ratio_f_obj)) else None,
            "band_violation_momentum_R_sq": float(
                _impinging_momentum_hinge_squared(
                    _R_hist,
                    r_band_lo=layer1_R_mom_aim_lo,
                    r_band_hi=layer1_R_mom_aim_hi,
                )
            ) if (
                has_impinging
                and np.isfinite(_R_hist)
                and layer1_impinging_R_mom_lo is not None
                and layer1_impinging_R_mom_hi is not None
            ) else None,
            "band_violation_angle_sq": float(
                _impinging_angle_hinge_squared(
                    imp_angle_deg,
                    angle_band_lo_deg=layer1_impinging_angle_deg_lo,
                    angle_band_hi_deg=layer1_impinging_angle_deg_hi,
                )
            ) if layer1_W_impinging_angle > 0.0 else None,
            # Objective (weighted penalty sum fed to CMA/L-BFGS)
            "objective": obj,
        })
        
        # Track best (feasible weighted-sum only — never promote obj≈1e6 infeasibility floor)
        is_new_best = (
            eval_success
            and _layer1_feasible_scalar_objective(obj)
            and float(obj) < float(opt_state.get("best_objective", float("inf")))
        )
        if is_new_best:
            opt_state["best_objective"] = obj
            opt_state["best_x"] = x_clipped.copy()
            opt_state["last_best_eval"] = opt_state["function_evaluations"]
            if eval_success:
                opt_state["last_eval_config"] = copy.deepcopy(config)
                opt_state["last_eval_config_x"] = x_clipped.copy()
                opt_state["last_eval_validation_tank_pa"] = (float(P_O_test), float(P_F_test))
            
            # Store objective component breakdown for diagnostics.
            #
            # Every weighted term in the objective MUST appear here -- this is what the
            # UI plots as "where the residual is coming from", and a term that is in the
            # objective but not in this dict shows up as an unexplained constant offset.
            # ``penalty_sum`` and ``penalty_unaccounted`` make that failure visible: on a
            # feasible design the sum should reproduce ``objective`` to rounding.
            # (L* and chamber-mass were missing here, which hid a 3000 x L*-term
            # contribution -- ~95% of the reported objective -- from the plots.)
            _breakdown_terms = dict(_tw)
            _penalty_sum = float(sum(_breakdown_terms.values()))
            opt_state["best_objective_breakdown"] = {
                "objective": float(obj),
                **_breakdown_terms,
                "penalty_sum": _penalty_sum,
                # Non-zero here means a weighted term exists in the objective that is
                # not reported above; the plots would be attributing it to nothing.
                "penalty_unaccounted": float(obj) - _penalty_sum,
                # Context values (not penalties -- excluded from the sum)
                "injector_dp_ratio_O": ratio_o_obj,
                "injector_dp_ratio_F": ratio_f_obj,
                "chamber_D_over_Dt": _finite_or_none(_T.get("chamber_D_over_Dt")),
                "chamber_L_over_D": _finite_or_none(_T.get("chamber_L_over_D")),
                "Lstar_m": _finite_or_none(Lstar_curr),
                "Lstar_target_m": _finite_or_none(_T.get("Lstar_target_m")),
                "chamber_mass_kg": _finite_or_none(_T.get("chamber_mass_kg")),
                "Isp_s": _finite_or_none(Isp_actual),
                "Isp_merit_s": _finite_or_none(_T.get("Isp_merit_s")),
                "Isp_ref_s": _finite_or_none(_T.get("Isp_ref_s")),
                "propellant_mass_kg": _finite_or_none(_T.get("propellant_mass_kg")),
                "L_face_to_throat_m": _finite_or_none(_T.get("L_face_to_throat")),
                "L_engine_m": _finite_or_none(_T.get("L_engine")),
                "momentum_ratio_R": _finite_or_none(_R_hist),
                "resultant_tilt_deg": _finite_or_none(_T.get("resultant_tilt_deg")),
                "resultant_tilt_breakeven_deg": _finite_or_none(_T.get("resultant_tilt_breakeven_deg")),
                "effective_smd_microns": _finite_or_none(smd_eff_um),
                "impingement_angle_deg": _finite_or_none(imp_angle_deg),
                "geom_ao_af_momentum_scale": _finite_or_none(_T.get("geom_ao_af_momentum_scale")),
                "geom_ao_af": _finite_or_none(_T.get("geom_ao_af")),
                "expected_ao_af_for_R1": _finite_or_none(_T.get("expected_ao_af_for_R1")),
                "infeasibility_penalty": float(obj - _penalty_sum) if (inf_residual > 0.0 or length_violation or not eval_success) else 0.0,
                "length_violation": bool(length_violation),
                "is_infeasible": not _layer1_feasible_for_primary_objective(
                    infeasibility_score, requirements, length_violation=length_violation
                ),
            }
            
            # If we were in a valley escape mode, exit it
            if opt_state.get("valley_escape_tier", 0) > 0:
                layer1_logger.info(f"    *** Improvement found: Exiting Valley Escape Tier {opt_state['valley_escape_tier']} ***")
                opt_state["valley_escape_tier"] = 0
            # Only store a "best config" if we actually evaluated successfully and are feasible.
            if eval_success and _layer1_feasible_for_primary_objective(infeasibility_score, requirements):
                opt_state["best_config"] = copy.deepcopy(config)
                opt_state["best_config_x"] = x_clipped.copy()
                opt_state["best_validation_tank_pa"] = (float(P_O_test), float(P_F_test))
                opt_state["best_lox_end_ratio"] = lox_start_ratio_hist
                opt_state["best_fuel_end_ratio"] = fuel_start_ratio_hist
            if (
                eval_success
                and _layer1_feasible_for_primary_objective(infeasibility_score, requirements)
                and not length_violation
                and final_pressures is not None
            ):
                opt_state["best_pressures"] = final_pressures
                opt_state["best_results_for_validation"] = {
                    "F": F_actual,
                    "MR": MR_actual,
                    "thrust_error": thrust_error,
                    "of_error": of_error,
                    "stability_score": stability_score,
                    "stability_state": stability_state,
                    "chugging_margin": chugging_margin,
                    "acoustic_margin": acoustic_margin,
                    "feed_margin": feed_margin,
                    "stability_results": stability,
                }
            layer1_logger.info(
                f"    ✓ New best objective: {obj:.6f} "
                f"(thrust_err: {thrust_error*100:.2f}%, O/F_err: {of_error*100:.2f}%, "
                f"Cf: {Cf_actual:.3f}, stability: {stability_state}, score: {stability_score:.3f})"
            )
            for handler in layer1_logger.handlers:
                handler.flush()
        
        # Buffer objective data every iteration (for batch reporting)
        opt_state["objective_buffer"].append({
            "iteration": int(iteration),
            "objective": float(obj),
            "best_objective": float(opt_state.get("best_objective", obj)),
        })
        
        # Stream objective history to external callback (e.g., UI plot) if provided
        # Only call callback every report_every_n iterations (batch reporting)
        should_report = (iteration % report_every_n == 0) or opt_state.get('objective_satisfied', False)
        if objective_callback is not None and should_report:
            try:
                # Send all buffered entries (batch reporting)
                for buffered_entry in opt_state["objective_buffer"]:
                    _layer1_emit_objective_plot_point(
                        objective_callback,
                        opt_state,
                        buffered_entry["iteration"],
                        buffered_entry["objective"],
                        buffered_entry["best_objective"],
                    )
                # Clear buffer after reporting
                opt_state["objective_buffer"] = []
            except Exception:
                # Never let UI/consumer callback break the optimizer loop
                pass
        
        # Convergence check
        stability_acceptable = (
            state_ok and
            (stability_score >= effective_min_score * 0.6) and
            (chugging_margin >= effective_margin * 0.5) and
            (acoustic_margin >= effective_margin * 0.5) and
            (feed_margin >= effective_margin * 0.5)
        )
        
        convergence_thrust_tol = thrust_tol * 2.0
        convergence_of_tol = 0.30
        # `best_objective` is updated above when `is_new_best` is True, so comparing
        # against it here would always be False for a new best. Re-use the flag.
        converged_now = (
            thrust_error < convergence_thrust_tol
            and of_error < convergence_of_tol
            and stability_acceptable
            and np.isfinite(float(opt_state.get("best_objective", float("inf"))))
            and float(opt_state.get("best_objective", float("inf"))) <= obj_tolerance
        )
        # Sticky convergence: once reached with a qualified best solution, keep it true.
        opt_state["converged"] = bool(opt_state.get("converged", False) or converged_now)
        
        return obj
    
    # Run optimization
    layer1_logger.info("")
    layer1_logger.info("Starting optimization...")
    layer1_logger.info("")
    opt_state["iteration"] = 0
    opt_state["function_evaluations"] = 0
    
    class _ResultWrapper:
        def __init__(self, x, fun, success=True):
            self.x = np.asarray(x, dtype=float)
            self.fun = float(fun)
            self.success = success
    
    result = None
    x0_refined = x0
    # lower_bounds/upper_bounds/span are computed above (used for caching and solvers)
    
    # Check CMA-ES availability (required)
    if cma is None:
        raise ImportError(
            "CMA-ES (cma package) is required for Layer 1 optimization but not installed.\n"
            "Install with: pip install cma"
        )
    
    # Run CMA-ES global optimization with random restarts
    layer1_logger.info("Using CMA-ES with random restart strategy for robust optimization.")
    update_progress("Layer 1: CMA-ES", 0.45, "Running CMA-ES global solver...")
    
    # IMPROVED: Initial step size fraction (reduced to 0.15 for better convergence with wide bounds)
    target_fraction_of_range = 0.15  # 15% of range per sigma for reliable convergence
    
    # Calculate base sigma0 from 25th percentile span (less sensitive to large diameter bounds)
    # Using percentile instead of median prevents large bound changes from dominating step size
    sigma0 = float(np.percentile(span, 25) * target_fraction_of_range)
    if not np.isfinite(sigma0) or sigma0 <= 0:
        sigma0 = 0.05
    
    # Set CMA_stds proportional to each variable's range
    # This ensures variables with larger ranges (like expansion_ratio) get larger step sizes
    cma_stds = np.ones_like(span)
    for i in range(len(span)):
        if span[i] > 0:
            # Desired step size for this dimension: fraction of its range
            desired_step = span[i] * target_fraction_of_range
            # CMA_stds[i] = desired_step / sigma0
            # This makes step size in dimension i proportional to its range
            cma_stds[i] = max(0.1, desired_step / sigma0) if sigma0 > 0 else 1.0
    
    # Discrete integer dimensions (n_orifices or impinging element counts)
    target_step_n = 1.0
    if sigma0 > 0:
        for idx_disc in layer1_integer_dims:
            if 0 <= idx_disc < len(cma_stds):
                cma_stds[idx_disc] = max(cma_stds[idx_disc], target_step_n / sigma0)
 
    # IMPROVED: Larger population for better exploration (32-80 instead of 16-48)
    # Standardized population for better diversity (increased to 48)
    popsize = 48
    layer1_logger.info(f"Population size: {popsize}")
    
    # 4 restarts (with the alternating strategy: restarts 0,1,3 global-explore, 2 refines) gives
    # three genuine global searches from diverse starts — more chances to escape a bad basin than
    # the old 3 (which were 1 global + 2 local refinements). iter_budget keeps ~50 gens/restart.
    # Restarts are DERIVED so that generations-per-restart stays fixed as the total budget grows.
    # iter_budget = max_iterations // num_restarts, so hardcoding num_restarts=4 meant a bigger
    # budget bought LONGER restarts (200->625 gens would have made each restart 156 generations).
    # That is the wrong way to spend it: a long restart just sits in one basin burning evaluations
    # on a valley it already found. More restarts from diverse starts is what actually escapes.
    # Scaling this way, 625 generations at 50 per restart gives 12 restarts instead of 4.
    _gens_per_restart = max(5, int(_requirement_float(
        requirements, "layer1_generations_per_restart", 50.0)))
    if layer1_cma_restarts is not None:
        num_restarts = max(1, int(layer1_cma_restarts))
    else:
        num_restarts = max(1, int(round(max_iterations / float(_gens_per_restart))))
    if layer1_smoke and layer1_cma_restarts is None:
        num_restarts = 1
    layer1_logger.info(
        "Restart plan: %d generations total / %d per restart = %d restarts (%d evals at popsize %d)",
        max_iterations, _gens_per_restart, num_restarts, max_iterations * popsize, popsize,
    )
    layer1_logger.info(f"Using {num_restarts} CMA restart(s)")
 
    # Legacy CMA uses this for ``maxiter`` per restart (hybrid path sets its own budget).
    total_eval_budget = max_iterations
 
    # Evaluation budget for progress reporting only -- never used to bound the search.
    # CMA runs ``max_iterations`` generations of ``popsize`` per restart; the hybrid
    # branch replaces this with its own cap once it computes one.
    opt_state["eval_budget"] = max(1, int(max_iterations) * int(popsize) * int(num_restarts))
    
    best_x_global = x0_refined
    best_f_global = float('inf')
    
    
    # ============================================================================
    # Setup for Parallel Evaluation (used by both hybrid and default CMA-ES)
    # ============================================================================
    num_workers = _get_num_workers(config_obj)
    debug_strict = getattr(config_obj.optimizer, 'debug_strict', False) if hasattr(config_obj, 'optimizer') else False
    
    layer1_logger.info(f"Using {num_workers} worker processes for parallel evaluation")
    
    # Prepare worker init args
    # Workers must evaluate the SAME engine the inline objective, the validation replay and
    # the final rebuild evaluate -- thermal protection off (the ablative liner is sized by
    # Layer 3; Layer 1 scores the bare chamber). They did not: only the worker path left it on,
    # so a design feasible only with the liner in place could win the pool and then be
    # unbuildable everywhere downstream (finalisation: "first evaluate() of the winner
    # failed"; validation: 3-14% tank boost), and which seeds hit this depended on pool
    # ordering -- the run-to-run nondeterminism.
    _worker_cfg_src = copy.deepcopy(config_base)
    # Thermal protection stays ON in the pool by DEFAULT. Disabling ablative_cooling also drops
    # the liner from total_wall_thickness_m -- at 0.5 in per side that is a full inch of bore --
    # so scoring with it off sizes a chamber the real engine does not have. Set
    # ED_L1_WORKER_THERMAL_OFF=1 to restore the old faster/no-liner behaviour for an A/B.
    if os.environ.get("ED_L1_WORKER_THERMAL_OFF", "0") == "1":
        if getattr(_worker_cfg_src, "ablative_cooling", None):
            _worker_cfg_src.ablative_cooling.enabled = False
        if getattr(_worker_cfg_src, "graphite_insert", None):
            _worker_cfg_src.graphite_insert.enabled = False
    config_dict = _config_to_dict(_worker_cfg_src)
    bounds_array = np.column_stack([lower_bounds, upper_bounds])
    constants_dict = {
        # Geometry DOFs and hard geometric constraints. constants_dict is a CURATED dict --
        # a key absent here simply never reaches the worker objective, which silently fell
        # back to theta = 45 deg while _layer1_apply_chamber_geometry_to_config (reading the
        # config directly) used the configured angle. The objective was then scoring a
        # different chamber than the one being built.
        'layer1_contraction_half_angle_deg': requirements.get('layer1_contraction_half_angle_deg'),
        'layer1_min_Lcyl_over_D': requirements.get('layer1_min_Lcyl_over_D'),
        'layer1_max_element_pitch_m': requirements.get('layer1_max_element_pitch_m'),
        'target_thrust': target_thrust,
        'optimal_of': optimal_of,
        'P_ambient': target_P_exit,  # Ambient pressure (atmospheric)
        'max_lox_P_psi': max_lox_P_psi,
        'max_fuel_P_psi': max_fuel_P_psi,
        'TOTAL_WALL_THICKNESS_M': wall_total_m,
        'max_nozzle_exit': max_nozzle_exit,
        'max_chamber_od': max_chamber_od,
        # Derived-DOF solve (see _layer1_solve_derived_geometry)
        'layer1_derive_expansion_ratio': derive_expansion_ratio,
        'layer1_derive_throat_from_thrust': derive_throat_from_thrust,
        'layer1_derive_max_iters': derive_max_iters,
        'layer1_derive_thrust_tol_rel': derive_thrust_tol,
        # NOTE: the *search* ranges captured before the CMA bounds were pinned --
        # using lower_bounds/upper_bounds here would clamp every solve back onto
        # the seed value and silently defeat the derivation.
        'derive_eps_min': derive_eps_range[0],
        'derive_eps_max': derive_eps_range[1],
        'derive_At_min': derive_At_range[0],
        'derive_At_max': derive_At_range[1],
        'derive_dF_min': derive_dF_range[0],
        'derive_dF_max': derive_dF_range[1],
        'layer1_derive_fuel_jet_from_of': derive_fuel_jet_from_of,
        'layer1_derive_tank_from_dp_ratio': derive_tank_from_dp,
        'layer1_dp_ratio_target': dp_ratio_target,
        'lock_P_T_min': lock_P_T_range[0],
        'lock_P_T_max': lock_P_T_range[1],
        'injector_type': l1_injector_type,
        'idx_P_O': idx_P_O,
        'idx_P_F': idx_P_F,
        'W_MOM': layer1_W_MOM,
        'W_DP': layer1_W_DP,
        'W_DP_CENTER': layer1_W_DP_CENTER,
        'W_DP_O': layer1_W_DP_O,
        'W_DP_F': layer1_W_DP_F,
        'W_DP_HIGH': layer1_W_DP_HIGH,
        # Workers' ΔP/Pc PENALTY bands = interior AIM bands (validation uses the raw
        # configured bands) — see the aim-band comment where these are derived.
        'injector_dp_ratio_O_min': layer1_dp_o_aim[0],
        'injector_dp_ratio_O_max': layer1_dp_o_aim[1],
        'injector_dp_ratio_F_min': layer1_dp_f_aim[0],
        'injector_dp_ratio_F_max': layer1_dp_f_aim[1],
        'W_geom_ao_af_momentum': layer1_W_geom_ao_af,
        'rho_oxidizer': float(config_base.fluids["oxidizer"].density),
        'rho_fuel': float(config_base.fluids["fuel"].density),
        'discharge_cd_inf_ratio': _layer1_discharge_cd_inf_ratio_from_config(config_base, l1_injector_type),
        # Workers' hinge PENALTY band = the interior AIM band (final validation uses the raw
        # configured band). Sharing an edge lets CMA park epsilon outside and fail validation.
        'impinging_momentum_R_min': layer1_R_mom_aim_lo,
        'impinging_momentum_R_max': layer1_R_mom_aim_hi,
        'layer1_momentum_log_deadband_rel': layer1_momentum_log_deadband_rel,
        'W_IMPINGING_ANGLE': layer1_W_impinging_angle,
        'W_IMPINGING_JET_ASYM': layer1_W_impinging_jet_asym,
        'layer1_impinging_jet_angle_max_asym_deg': layer1_impinging_jet_max_asym_deg,
        'layer1_exit_pressure_inside_quad_scale': layer1_exit_pressure_inside_quad,
        'layer1_impinging_angle_deg_min': layer1_impinging_angle_deg_lo,
        'layer1_impinging_angle_deg_max': layer1_impinging_angle_deg_hi,
        'W_CHAMBER_SHAPE': layer1_W_chamber_shape,
        'layer1_chamber_dt_ratio_min': layer1_chamber_dt_ratio_min,
        'layer1_chamber_dt_ratio_max': layer1_chamber_dt_ratio_max,
        'layer1_chamber_ld_ratio_min': layer1_chamber_ld_ratio_min,
        'layer1_chamber_ld_ratio_max': layer1_chamber_ld_ratio_max,
        'injector_dp_ratio_O_soft_floor': layer1_dp_o_soft_floor,
        'W_DP_O_FLOOR': layer1_W_DP_O_FLOOR,
        'W_SMD': layer1_W_SMD,
        'target_smd_microns': layer1_target_smd_microns,
        'layer1_smd_rel_tol': layer1_smd_rel_tol,
        'W_TANK_EQUAL': layer1_W_TANK_EQUAL,
        'layer1_tank_equal_scale_psi': layer1_tank_equal_scale_psi,
        'layer1_tank_equal_tol_psi': layer1_tank_equal_tol_psi,
        'layer1_of_deadband_rel': layer1_of_deadband_rel,
        'layer1_chamber_od_increment_in': layer1_chamber_od_increment_in,
        'layer1_chamber_od_snap_target': layer1_chamber_od_snap_target,
        'layer1_tank_equal_inband_frac': layer1_tank_equal_inband_frac,
        'layer1_lock_tank_pressures': layer1_lock_tank_pressures,
        'lock_P_F_min': lock_P_F_range[0],
        'lock_P_F_max': lock_P_F_range[1],
        'layer1_enforce_ring_geometry': layer1_enforce_ring_geometry,
        'layer1_injector_center_clear_dia_m': layer1_injector_center_clear_dia_m,
        'layer1_injector_min_web_m': layer1_injector_min_web_m,
        'layer1_injector_wall_clearance_m': layer1_injector_wall_clearance_m,
        'layer1_injector_spray_radius_frac': layer1_injector_spray_radius_frac,
        'layer1_injector_spray_radius_tol': layer1_injector_spray_radius_tol,
        'layer1_injector_min_face_incidence_deg': layer1_injector_min_face_incidence_deg,
        'layer1_injector_plate_thickness_m': layer1_injector_plate_thickness_m,
        'layer1_injector_counterbore_dia_m': layer1_injector_counterbore_dia_m,
        'layer1_injector_min_back_web_m': layer1_injector_min_back_web_m,
        'layer1_injector_land_ld_O': layer1_injector_land_ld_O,
        'layer1_injector_land_ld_F': layer1_injector_land_ld_F,
        'layer1_injector_back_keepout_dia_m': layer1_injector_back_keepout_dia_m,
        'layer1_injector_back_keepout_wall_m': layer1_injector_back_keepout_wall_m,
        'layer1_injector_face_contoured': layer1_injector_face_contoured,
        'layer1_injector_back_channels': layer1_injector_back_channels,
        'layer1_injector_exit_land': layer1_injector_exit_land,
        'layer1_injector_channel_width_m': layer1_injector_channel_width_m,
        'layer1_injector_channel_floor': layer1_injector_channel_floor,
        'layer1_injector_channel_inlets': layer1_injector_channel_inlets,
        'layer1_injector_plate_support': layer1_injector_plate_support,
        'layer1_injector_r_plate_m': layer1_injector_r_plate_m,
        'layer1_injector_r_port_m': layer1_injector_r_port_m,
        'layer1_injector_liner_thickness_m': layer1_injector_liner_thickness_m,
        'layer1_resultant_tilt_from_reach': layer1_resultant_tilt_from_reach,
        'layer1_resultant_tilt_reach_margin': layer1_resultant_tilt_reach_margin,
        'layer1_ring_order_fuel_outboard': layer1_ring_order_fuel_outboard,
        'layer1_momentum_wall_side_multiplier': layer1_momentum_wall_side_multiplier,
        'layer1_resultant_tilt_max_deg': layer1_resultant_tilt_max_deg,
        'layer1_resultant_tilt_scale_deg': layer1_resultant_tilt_scale_deg,
        'layer1_W_TILT': layer1_W_TILT,
        'layer1_resultant_tilt_outward_multiplier': layer1_resultant_tilt_outward_multiplier,
        'rho_O': float(config_base.fluids["oxidizer"].density),
        'rho_F': float(config_base.fluids["fuel"].density),
        'layer1_momentum_low_side_multiplier': layer1_momentum_low_side_multiplier,
        'layer1_momentum_band_width': layer1_momentum_band_width,
        'layer1_momentum_scale': layer1_momentum_scale,
        'layer1_derive_impingement_spacing': layer1_derive_impingement_spacing,
        'layer1_impingement_Ld_target': _ld_target,
        'derive_spacing_F_min': derive_spacing_F_range[0],
        'derive_spacing_F_max': derive_spacing_F_range[1],
        'layer1_impingement_Ld_min': layer1_impingement_Ld_min,
        'layer1_impingement_Ld_max': layer1_impingement_Ld_max,
        'W_IMP_GEOM': layer1_W_IMP_GEOM,
        'layer1_W_EXIT': layer1_W_EXIT,
        'layer1_exit_pressure_deadband_rel': layer1_exit_pressure_deadband_rel,
        'layer1_W_MASS': layer1_W_MASS,
        'layer1_W_ISP': layer1_W_ISP,
        'layer1_Isp_ref_s': layer1_Isp_ref_s,
        'target_burn_time': float(target_burn_time or 0.0),
        'min_Lstar': min_Lstar,
        'max_Lstar': max_Lstar,
        'layer1_W_LSTAR': layer1_W_LSTAR,
        'layer1_Lstar_target_m': layer1_Lstar_target_m,
        'layer1_chamber_wall_density_kg_m3': layer1_chamber_wall_density,
        'layer1_chamber_mass_ref_kg': layer1_chamber_mass_ref_kg,
        'layer1_W_THRUST': layer1_W_THRUST_obj,
        'layer1_W_OF': layer1_W_OF_obj,
        'layer1_W_OF_low_MR_scale': layer1_W_OF_low_MR_scale,
        'layer1_W_OF_high_MR_scale': layer1_W_OF_high_MR_scale,
        'layer1_of_validation_tol': layer1_of_validation_tol,
    }
 
    # Optional chamber-pressure target (design_requirements.target_chamber_pressure_psi).
    # Pc is emergent in a pressure-fed system, so this enters as a soft objective target,
    # NOT a frozen x-pin: the optimizer moves tank pressure to land Pc here while the throat
    # absorbs the thrust target. Only wired in (nonzero weight) when the user set a target.
    _pc_target_psi = requirements.get("target_chamber_pressure_psi")
    if _pc_target_psi is not None and float(_pc_target_psi) > 0:
        constants_dict['layer1_target_Pc_pa'] = float(_pc_target_psi) * 6894.757293168
        # Matches W_THRUST magnitude. The L1 (linear) shape is what pins Pc exactly: near a
        # solution the squared thrust/OF terms have ~0 gradient, so the L1 Pc pull is
        # essentially uncontested and drives Pc onto target without a huge (ill-conditioning) weight.
        # None => default 1e4; an explicit 0.0 stays 0.0 (penalty off, seeding
        # effects kept). MUST mirror _W_PC_obj in the parent objective above.
        constants_dict['layer1_W_PC'] = _requirement_float(requirements, "layer1_W_PC", 1.0e4)
        layer1_logger.info(
            "Layer 1 chamber-pressure target: %.0f psi (%.3f MPa), W_PC=%g (exact L1). Throat sizes "
            "for thrust; tank pressure drives Pc to target.",
            float(_pc_target_psi), constants_dict['layer1_target_Pc_pa'] / 1e6,
            constants_dict['layer1_W_PC'],
        )
 
    integer_dims = list(layer1_integer_dims)
    # Chamber OD granularity: one stock increment, in metres. Zero when snapping is off,
    # in which case the coordinate really is continuous and gets no std floor.
    _l1_od_step_m = float(_od_increment_in) * 0.0254 if _od_increment_in > 0 else 0.0
    _l1_int_vars, _l1_minstd = _layer1_cma_discrete_options(
        len(bounds), integer_dims, od_index=3, od_step_m=_l1_od_step_m, bounds=bounds)
    if _l1_int_vars or _l1_od_step_m > 0:
        layer1_logger.info(
            "Layer 1 discrete DOFs handed to CMA: integer_variables=%s%s",
            _l1_int_vars,
            (" + chamber-OD std floor %.4f m (%.2f in step)"
             % (_l1_minstd[3], _od_increment_in)) if _l1_od_step_m > 0 else "",
        )
    
    # DISPATCH: Check optimizer mode (smoke runs force pure CMA so max_iterations stays meaningful)
    optimizer_mode = "cma"  # default
    if hasattr(config_obj, "optimizer") and config_obj.optimizer:
        optimizer_mode = config_obj.optimizer.mode
    effective_mode = optimizer_mode
    if layer1_smoke:
        effective_mode = "cma"
        layer1_logger.info(
            "Layer 1 smoke: forcing pure CMA-ES (config optimizer.mode=%r ignored for hybrid).",
            optimizer_mode,
        )
 
    # The accelerator (engine/accel) is the Layer-1 inner-loop fast path: one
    # evaluate() per candidate. Warm the JIT once here in the parent — before the
    # worker pool is created — so workers deserialize ready-compiled kernels rather
    # than each compiling inside the first CMA generation.
    #
    # Unlike the old C prewarm, this is NOT free per worker: a .so is mmapped into
    # every child at no cost, whereas each worker still loads the cached njit
    # artifacts on first call. _init_worker warms them again for that reason.
    try:
        from engine import accel as _accel
        if _accel.enabled():
            _accel.warmup()
    except Exception as e:  # never let a warmup hiccup block optimization
        layer1_logger.warning(
            "Accelerator warmup failed (%s); Layer-1 falls back to Python evaluation.", e)
 
    # Create evaluator executor for candidate scoring.
    # On some macOS/sandboxed environments, ProcessPool creation can fail with
    # PermissionError/OSError (e.g., semaphore sysconf restrictions). Fall back
    # to serial evaluation in-process so optimization can still run.
    executor_context = None
    if num_workers > 1:
        try:
            executor_context = ProcessPoolExecutor(
                max_workers=num_workers,
                initializer=_init_worker,
                initargs=(config_dict, bounds_array, requirements, constants_dict, debug_strict),
            )
        except (PermissionError, OSError) as e:
            layer1_logger.warning(
                "ProcessPool unavailable (%s). Falling back to serial Layer-1 evaluation.",
                e,
            )
            num_workers = 1
 
    if executor_context is None:
        _init_worker(config_dict, bounds_array, requirements, constants_dict, debug_strict)
        executor_context = _LocalSerialExecutor()
 
    with executor_context as executor:
        
        # Optional: Warm-up call per worker (first call can trigger lazy imports)
        if num_workers > 1:
            dummy_candidate = _snap_integer_dims(x0_refined.copy(), integer_dims)
            list(executor.map(_eval_candidate, [dummy_candidate] * num_workers))
 
        # ------------------------------------------------------------------
        # CMA warm-start (hybrid + legacy): same ``_eval_candidate`` / objective as CMA
        # workers. Improves ``x0``; syncs ``opt_state`` + SSE plot (parallel CMA never
        # calls ``objective()``, so the UI curve used to miss this entirely).
        # ------------------------------------------------------------------
        best_x_global = np.asarray(x0_refined, dtype=float).copy()
        best_f_global = float("inf")
        layer1_warmstart_applied = False
        _ws_n_raw = requirements.get("layer1_cma_warmstart_trials")
        _ws_n = 16 if _ws_n_raw is None else int(_ws_n_raw)
        if layer1_smoke:
            _ws_n = min(_ws_n, 4)
        _ws_sig = _requirement_float(requirements, "layer1_cma_warmstart_sigma_frac", 0.04)
        if _ws_n > 0:
            x0_refined, _ws_best_f = _layer1_cma_warmstart_candidates(
                x0_refined,
                lower_bounds=lower_bounds,
                upper_bounds=upper_bounds,
                span=span,
                integer_dims=integer_dims,
                rng=rng,
                executor=executor,
                n_trials=_ws_n,
                sigma_frac=_ws_sig,
                eval_cache=eval_cache,
                make_cache_key_fn=_make_eval_cache_key,
                opt_state=opt_state,
                logger=layer1_logger,
            )
            layer1_warmstart_applied = True
            best_x_global = np.asarray(x0_refined, dtype=float).copy()
            if np.isfinite(_ws_best_f):
                best_f_global = float(_ws_best_f)
                _layer1_sync_best_from_worker_eval(
                    opt_state, best_x_global, float(_ws_best_f), parent_objective=objective
                )
                _layer1_emit_objective_plot_point(
                    objective_callback,
                    opt_state,
                    int(opt_state.get("function_evaluations", 0)),
                    float(_ws_best_f),
                    float(opt_state.get("best_objective", _ws_best_f)),
                )
 
        # Element count n, jet diameters, hole pitches (the fuel pitch is derived).
        _l1_iso_area = (4, (5, 8), (7, 10)) if l1_injector_type == "impinging" else None
        if effective_mode == "hybrid_cma_blocks" and hasattr(config_obj.optimizer, "hybrid"):
            layer1_logger.info("Using Hybrid CMA + Block Re-optimization mode.")
            hybrid_config = config_obj.optimizer.hybrid
            
            # Hybrid evaluation budget = max_iterations * popsize (population-sized generations).
            # NOTE: a previous revision made this just `max_iterations`, which silently cut the
            # search budget by ~popsize (48x) and caused the optimizer to terminate far too early at
            # a much worse objective ("nothing converging"). The * popsize form is what gives the
            # optimizer enough evaluations to actually converge; the run still stops early via the
            # CMA stagnation/convergence criteria long before the ceiling, so this is a budget CAP,
            # not a fixed run length. (The default max_iterations is sized so this is fast under the
            # native kernel — see where max_iterations is set.)
            total_budget_evals = max(int(popsize), int(max_iterations) * int(popsize))
            opt_state["eval_budget"] = int(total_budget_evals)
            layer1_logger.info(
                "Hybrid evaluation budget: %s (max(%s, max_iterations=%s x popsize=%s))",
                total_budget_evals,
                popsize,
                max_iterations,
                popsize,
            )
            
            # Run Multi-Track Hybrid?
            num_tracks = hybrid_config.num_tracks
            
            best_x_global = x0_refined
            best_f_global = float('inf')
            
            if num_tracks > 1:
                layer1_logger.info(f"Running {num_tracks} independent hybrid tracks...")
                # Track initialization: Top-N restarts?
                # User feedback says: "track i starts from best of restart i"
                # So we first need to run N restarts of global exploration to seed tracks?
                # OR we simply start N tracks from random perturbations of x0.
                # "Multi-track: Initialize tracks from Top-N best results of Stage A restarts."
                # My run_hybrid_optimization includes Stage A internally. 
                # So "Multi-track" essentially means distinct runs of run_hybrid_optimization?
                # OR running Stage A first, then branching?
                # Let's treat "Multi-track" as running the WHOLE hybrid process N times with different seeds.
                 
                for track_i in range(num_tracks):
                    check_stop()  # Check if optimization should stop
                    layer1_logger.info(f"--- Track {track_i+1}/{num_tracks} ---")
                    
                    # Perturb start point for diversity if track > 0
                    if track_i > 0:
                        x0_track = x0_refined + rng.standard_normal(len(x0_refined)) * (0.1 * span)
                        x0_track = np.clip(x0_track, lower_bounds, upper_bounds)
                    else:
                        x0_track = x0_refined
                        
                    t_x, t_f, t_ev = run_hybrid_optimization(
                        objective,
                        list(zip(lower_bounds, upper_bounds)),
                        x0_track,
                        hybrid_config,
                        total_budget=total_budget_evals // num_tracks,
                        logger=layer1_logger,
                        log_status_fn=log_status,
                        update_progress_fn=update_progress,
                        valley_escape_tracker=opt_state,
                        # Parallel evaluation parameters
                        executor=executor,
                        integer_dims=integer_dims,
                        od_index=3,
                        od_step_m=_l1_od_step_m,
                        fixed_variables=_l1_fixed_vars,
                        eval_cache=eval_cache,
                        make_cache_key_fn=_make_eval_cache_key,
                        stop_event=stop_event,
                        seed=int((layer1_seed_base + track_i * 7919) % (2 ** 31)),
                        popsize=popsize,
                        iso_area=_l1_iso_area,
                    )
                    
                    if t_f < best_f_global:
                        best_f_global = t_f
                        best_x_global = t_x
                        layer1_logger.info(f"Track {track_i+1} found new global best: {best_f_global:.5f}")
                        
            else:
                # Single track
                best_x_global, best_f_global, evs = run_hybrid_optimization(
                    objective,
                    list(zip(lower_bounds, upper_bounds)),
                    x0_refined,
                    hybrid_config,
                    total_budget=total_budget_evals,
                    logger=layer1_logger,
                    log_status_fn=log_status,
                    update_progress_fn=update_progress,
                    valley_escape_tracker=opt_state,
                    # Parallel evaluation parameters
                    executor=executor,
                    integer_dims=integer_dims,
                    od_index=3,
                    od_step_m=_l1_od_step_m,
                    fixed_variables=_l1_fixed_vars,
                    eval_cache=eval_cache,
                    make_cache_key_fn=_make_eval_cache_key,
                    stop_event=stop_event,
                    seed=int(layer1_seed_base),
                    popsize=popsize,
                    iso_area=_l1_iso_area,
                )
 
        else:
            # Default/Fallback: Legacy CMA-ES Logic with Parallel Evaluation
            best_x_global = np.asarray(x0_refined, dtype=float).copy()
            if not layer1_warmstart_applied:
                best_f_global = float("inf")
 
            for restart_idx in range(num_restarts):
                restart_name = f"Restart {restart_idx + 1}/{num_restarts}" if num_restarts > 1 else "Main search"
                
                # Multi-start strategy. CRITICAL: odd restarts must RE-EXPLORE globally from a
                # FRESH RANDOM point — not refine the incumbent — otherwise a bad first basin traps
                # every restart at the same spot ("gives up, goes flat"). Even restarts (>0) polish
                # the best basin found so far. So we alternate genuine global exploration with
                # exploitation instead of doing three local refinements of one basin.
                if restart_idx == 0:
                    current_sigma_fraction = target_fraction_of_range  # 25% (global, from warm start)
                    x_start = x0_refined
                elif restart_idx % 2 == 1:
                    # GLOBAL re-exploration: start from the incumbent best kicked by a WIDE
                    # random perturbation (30% of each dim's span), with global sigma. A pure
                    # uniform-random 13-D start is almost surely infeasible (observed: whole
                    # restarts flatlining at the 1e6 infeasibility plateau) — anchoring at a
                    # feasible incumbent keeps the restart searching real designs while the
                    # big kick + 25% sigma still escapes the incumbent's basin.
                    current_sigma_fraction = target_fraction_of_range  # 25% (global)
                    x_start = best_x_global + rng.standard_normal(len(best_x_global)) * (0.3 * span)
                    layer1_logger.info("  (global re-exploration: wide kick off incumbent best)")
                else:
                    # Exploit: refine around the best basin found so far.
                    current_sigma_fraction = 0.15  # 15% (medium, local)
                    perturbation = rng.standard_normal(len(best_x_global)) * (sigma0 * 0.3)
                    x_start = best_x_global + perturbation
                
                x_start = np.clip(x_start, lower_bounds, upper_bounds)
                    
                current_sigma0 = float(np.percentile(span, 25) * current_sigma_fraction)
                if not np.isfinite(current_sigma0) or current_sigma0 <= 0:
                    current_sigma0 = 0.05
                # First restart only: tighter initial cloud around warm-started ``x0`` so generation-1
                # samples do not all land in ``BASE_INFEAS`` (~1e6) when global sigma is huge.
                if restart_idx == 0 and layer1_warmstart_applied:
                    _s0_scale = _requirement_float(requirements, "layer1_cma_restart0_sigma_scale", 0.48)
                    current_sigma0 *= float(np.clip(_s0_scale, 0.12, 1.0))
                    
                current_cma_stds = np.ones_like(span)
                for i in range(len(span)):
                    if span[i] > 0:
                        desired_step = span[i] * current_sigma_fraction
                        current_cma_stds[i] = max(0.1, desired_step / current_sigma0) if current_sigma0 > 0 else 1.0
                
                if current_sigma0 > 0:
                    for idx_disc in layer1_integer_dims:
                        if 0 <= idx_disc < len(current_cma_stds):
                            current_cma_stds[idx_disc] = max(
                                current_cma_stds[idx_disc], 1.0 / current_sigma0
                            )
        
                layer1_logger.info(f"")
                layer1_logger.info(f"Starting {restart_name} (sigma: {current_sigma_fraction*100:.0f}% of range)...")
                
                # Floor at 1: layer1_max_iterations < num_restarts floors this to 0,
                # which hands CMA maxiter=0 and then divides by it at the progress
                # update below (ZeroDivisionError on any run with max_iterations < 4).
                iter_budget = max(1, total_eval_budget // num_restarts)
                
                # Without an explicit ``seed``, cma uses non-deterministic defaults → different optima each run.
                _cma_restart_seed = layer1_seed_base + int(restart_idx) * 1_000_003
                cma_options = {
                    "bounds": [lower_bounds.tolist(), upper_bounds.tolist()],
                    "popsize": popsize,
                    "maxiter": iter_budget,
                    "verb_disp": 0,
                    "verb_log": 0,
                    "CMA_stds": _l1_shrink_derived_stds(current_cma_stds, _l1_fixed_vars),
                    "integer_variables": _l1_int_vars,
                    "minstd": _l1_minstd,
                    "tolx": 1e-8,
                    "tolfun": 1e-9,
                    "tolstagnation": 50,
                    "ftarget": -np.inf,
                    "seed": _cma_restart_seed,
                }
                
                try:
                    es = cma.CMAEvolutionStrategy(x_start.tolist(), current_sigma0, cma_options)
                    while not es.stop():
                        # Check if optimization should stop
                        check_stop()
                        
                        # Check for Valley Escape boost
                        target_tier = _check_valley_escape_tier()
                        if target_tier > opt_state["valley_escape_tier"] and opt_state["function_evaluations"] > opt_state["cooldown_until"]:
                            # Tier definitions
                            tier_names = ["None", "Mild", "Medium", "Full"]
                            boost_factors = [1.0, 1.5, 2.0, 3.0]
                            current_factor = boost_factors[opt_state["valley_escape_tier"]]
                            target_factor = boost_factors[target_tier]
                            relative_boost = target_factor / current_factor
                            
                            old_sigma = es.sigma
                            es.sigma *= relative_boost
                            
                            # Clamp sigma to 30% of 25th percentile span to prevent sampling nonsense
                            max_sigma = 0.3 * float(np.percentile(span, 25))
                            if es.sigma > max_sigma:
                                es.sigma = max_sigma
                                
                            # Update state
                            opt_state["valley_escape_tier"] = target_tier
                            opt_state["cooldown_until"] = opt_state["function_evaluations"] + 1000
                            
                            layer1_logger.info("!" * 20)
                            layer1_logger.info(f"VALLEY ESCAPE TRIGGERED (Tier: {tier_names[target_tier]})")
                            layer1_logger.info(f"Evals: {opt_state['function_evaluations']}, Best: {opt_state['best_objective']:.2f}, Stagnation: {opt_state['function_evaluations'] - opt_state['last_best_eval']}")
                            layer1_logger.info(f"Sigma: {old_sigma:.6f} -> {es.sigma:.6f} (Boost: {relative_boost:.2f}x)")
                            layer1_logger.info("!" * 20)
                            for handler in layer1_logger.handlers:
                                handler.flush()
 
 
                        # CMA-ES samples within bounds (no manual clipping needed)
                        candidates = es.ask()
                        
                        # Snap integer dimensions for consistency
                        # Convert to numpy arrays (pickle-safe in WSL)
                        candidates_snapped = [
                            _snap_integer_dims(np.asarray(c, dtype=np.float64), integer_dims)
                            for c in candidates
                        ]
                        
                        # Parent-side caching: check cache before submitting work
                        # Cache keys use SNAPPED values for consistency
                        cache_keys = [_make_eval_cache_key(c) for c in candidates_snapped]
                        uncached_indices = []
                        uncached_candidates = []
                        values = [None] * len(candidates)
                        gen_meta: List[Optional[Dict[str, Any]]] = [None] * len(candidates)
                        
                        for i, key in enumerate(cache_keys):
                            if key in eval_cache:
                                cached_val = eval_cache[key]
                                # Handle dict format from parallel eval (has 'value' key)
                                # Note: dict format from objective() has 'results' but not 'value', so we can't use it here
                                if isinstance(cached_val, dict) and 'value' in cached_val:
                                    values[i] = float(cached_val['value'])
                                    if cached_val.get("worker_payload"):
                                        gen_meta[i] = dict(cached_val["worker_payload"])
                                elif isinstance(cached_val, (int, float)):
                                    # Old format: direct float value (backward compatibility)
                                    values[i] = float(cached_val)
                                else:
                                    # Full format from objective() or unknown format - can't extract value, treat as uncached
                                    uncached_indices.append(i)
                                    uncached_candidates.append(candidates_snapped[i])
                            else:
                                uncached_indices.append(i)
                                uncached_candidates.append(candidates_snapped[i])
                        
                        # Parallel evaluation of uncached candidates
                        if uncached_candidates:
                            chunksize = max(1, len(uncached_candidates) // (num_workers * 4))
                            results = list(executor.map(_eval_candidate, uncached_candidates, chunksize=chunksize))
                            
                            # Merge results back and update parent state
                            for idx, res in zip(uncached_indices, results):
                                obj_val = res['value']
                                values[idx] = obj_val
                                gen_meta[idx] = res
                                
                                # Cache result (using snapped key) - store in dict format for compatibility
                                eval_cache[cache_keys[idx]] = {
                                    'value': obj_val,
                                    'success': res.get('success', True),
                                    'worker_payload': {
                                        'value': obj_val,
                                        'success': res.get('success', True),
                                        'thrust_error': res.get('thrust_error'),
                                        'of_error': res.get('of_error'),
                                        'momentum_term': res.get('momentum_term'),
                                        'inf_residual': res.get('inf_residual'),
                                        'F': res.get('F'),
                                        'MR': res.get('MR'),
                                        'full_results': res.get('full_results'),
                                    },
                                }
                                
                                # Parent owns: tracking, logging, history
                                # Count ALL evaluations (success + failure) for accurate metrics
                                opt_state['function_evaluations'] += 1
                                _store_last_good_eval_bundle_from_worker_res(res, opt_state)
 
                                if not res['success']:
                                    # Track failures
                                    reason = res.get('error_type', 'Unknown')
                                    opt_state['num_failures'] = opt_state.get('num_failures', 0) + 1
                                    
                                    # Track failure reasons
                                    if 'fail_counts' not in opt_state:
                                        opt_state['fail_counts'] = {}
                                    opt_state['fail_counts'][reason] = opt_state['fail_counts'].get(reason, 0) + 1
                                    
                                    # Periodic failure logging (every 100 evals)
                                    if opt_state['function_evaluations'] % 100 == 0:
                                        # Sort failures by count descending
                                        sorted_fails = sorted(opt_state['fail_counts'].items(), key=lambda item: item[1], reverse=True)
                                        top_fails = sorted_fails[:3]
                                        fail_msg = ", ".join([f"{k}: {v}" for k, v in top_fails])
                                        layer1_logger.warning(f"Recent Failures (Top 3): {fail_msg}")
                                        
                                    layer1_logger.warning(f"Eval failed: {reason}")
                        
                        # Tell CMA-ES using ORIGINAL candidates (not snapped)
                        # This is correct because CMA-ES needs to update its distribution
                        es.tell(candidates, values)
                        
                        _fv = [
                            float(v) if v is not None and np.isfinite(float(v)) else float("inf")
                            for v in values
                        ]
                        if _fv and min(_fv) < float("inf"):
                            _gen_best = float(min(_fv))
                            _gi = int(np.argmin(np.asarray(_fv, dtype=float)))
                            _layer1_sync_best_from_worker_eval(
                                opt_state,
                                candidates_snapped[_gi],
                                _gen_best,
                                parent_objective=objective,
                            )
                            _layer1_emit_objective_plot_point(
                                objective_callback,
                                opt_state,
                                int(opt_state.get("function_evaluations", 0)),
                                _gen_best,
                                float(opt_state.get("best_objective", _gen_best)),
                            )
                        
                        iter_idx = max(1, es.countiter)
                        overall_progress = restart_idx / num_restarts
                        restart_progress = iter_idx / iter_budget / num_restarts
                        progress = 0.10 + 0.35 * (overall_progress + restart_progress)
                        update_progress("Layer 1: CMA-ES", progress, 
                                      f"{restart_name} - iteration {iter_idx}/{iter_budget}")
                    
                    cma_result = es.result
                    restart_best_x = np.asarray(cma_result.xbest, dtype=float)
                    restart_best_f = float(cma_result.fbest)
                    
                    layer1_logger.info(f"{restart_name} finished. Final obj: {restart_best_f:.6f}")
                    
                    if restart_best_f < best_f_global:
                        best_f_global = restart_best_f
                        best_x_global = restart_best_x
                        layer1_logger.info(f"  ✓ New global best: {best_f_global:.6f}")
                    
                    if best_f_global < obj_tolerance:
                        layer1_logger.info(f"Found excellent solution, skipping restarts")
                        break
                        
                    for handler in layer1_logger.handlers:
                        handler.flush()
                        
                except Exception as e:
                    layer1_logger.error(f"{restart_name} failed: {e}")
                    if restart_idx == 0:
                        raise
                    continue
 
    
    # Use best result across all restarts
    x0_refined = best_x_global
    best_fun = best_f_global
    layer1_logger.info(f"")
    layer1_logger.info(f"CMA-ES complete. Global best objective: {best_fun:.6f}")
    layer1_logger.info(f"Total function evaluations: {opt_state['function_evaluations']}")
    log_status("Layer 1", f"CMA-ES complete: {num_restarts} restart(s), obj={best_fun:.3f}, refining with L-BFGS-B...")
    for handler in layer1_logger.handlers:
        handler.flush()
    
    # Reset function evaluation counter for L-BFGS-B refinement
    opt_state["function_evaluations"] = 0
 
    
    # L-BFGS-B refinement runs after CMA-ES
    # Always run full local optimization regardless of current objective value
    # ``minimize(..., ftol=...)`` for L-BFGS-B is **not** a tolerance on Layer 1's
    # composite objective magnitude. SciPy divides by ``mach_eps`` internally to form
    # Fortran ``factr`` (see ``scipy.optimize._lbfgsb_py``). Passing ``obj_tolerance*0.1``
    # (~0.2) made ``factr`` ~ 1e15 → effectively immediate "convergence" with ~1e-4 residuals.
    maxfun_capped = min(max_iterations * 5, 2500)
 
    opt_state["layer1_lbfgs_phase"] = True
    update_progress("Layer 1: Local Refinement", 0.47, f"Refining with L-BFGS-B (max {maxfun_capped} func evals)...")
    layer1_logger.info("Phase 2: Local refinement (L-BFGS-B)...")
 
    try:
        lbfgs_result = minimize(
            objective,
            x0_refined,
            method='L-BFGS-B',
            bounds=bounds,
            options={
                'maxiter': max_iterations,
                'maxfun': maxfun_capped,
                # Omitted ftol uses SciPy's default (~``mach_eps`` × 1e7 / ``factr`` workflow).
                'gtol': layer1_lbfgs_gtol,
                'maxls': 50,
                'disp': False,
            }
        )
        if layer1_lbfgs_second_pass and getattr(lbfgs_result, "success", True):
            _gt2 = float(max(1e-15, min(1e-12, layer1_lbfgs_gtol * 0.05)))
            try:
                lbfgs_result2 = minimize(
                    objective,
                    np.asarray(lbfgs_result.x, dtype=float),
                    method="L-BFGS-B",
                    bounds=bounds,
                    options={
                        "maxiter": max_iterations,
                        "maxfun": min(800, maxfun_capped),
                        "gtol": _gt2,
                        "maxls": 60,
                        "disp": False,
                    },
                )
                if (
                    np.isfinite(getattr(lbfgs_result2, "fun", float("nan")))
                    and _layer1_feasible_scalar_objective(float(lbfgs_result2.fun))
                    and (
                        not _layer1_feasible_scalar_objective(float(lbfgs_result.fun))
                        or float(lbfgs_result2.fun) <= float(lbfgs_result.fun)
                    )
                ):
                    lbfgs_result = lbfgs_result2
                    layer1_logger.info(
                        "L-BFGS-B second pass improved feasible objective to %.6g (gtol=%.1e)",
                        float(lbfgs_result.fun),
                        _gt2,
                    )
                elif np.isfinite(getattr(lbfgs_result2, "fun", float("nan"))):
                    layer1_logger.info(
                        "L-BFGS-B second pass rejected: fun=%.6g (infeasible or worse than %.6g)",
                        float(lbfgs_result2.fun),
                        float(lbfgs_result.fun),
                    )
            except Exception as _e2:
                layer1_logger.debug("L-BFGS-B second pass skipped: %s", _e2)
        layer1_logger.info("")
        layer1_logger.info("Optimization completed")
        layer1_logger.info(f"Success: {lbfgs_result.success}")
        _report_fun = float(getattr(lbfgs_result, "fun", float("nan")))
        if not _layer1_feasible_scalar_objective(_report_fun):
            _report_fun = float(opt_state.get("best_objective", _report_fun))
            layer1_logger.info(
                "L-BFGS-B terminal iterate was infeasible (obj≈1e6); reporting incumbent best=%.6g",
                _report_fun,
            )
        layer1_logger.info(f"Final objective value: {_report_fun:.6f}")
        layer1_logger.info(f"Iterations: {lbfgs_result.nit if hasattr(lbfgs_result, 'nit') else 'N/A'}")
        layer1_logger.info(f"Function evaluations: {lbfgs_result.nfev if hasattr(lbfgs_result, 'nfev') else 'N/A'}")
        layer1_logger.info("")
        result = lbfgs_result
    except Exception as e:
        layer1_logger.error(f"L-BFGS-B error: {e}")
        log_status("Layer 1 Warning", f"L-BFGS-B error: {e}, using best result found")
        # Use CMA-ES result or best found during optimization
        if 'best_fun' in locals():
            # CMA-ES succeeded but L-BFGS-B failed
            result = _ResultWrapper(x0_refined, best_fun)
        else:
            # Use best from optimization state
            best_x = opt_state.get('best_x', x0)
            best_obj = opt_state.get('best_objective', float('inf'))
            result = _ResultWrapper(best_x, best_obj)
    finally:
        opt_state.pop("layer1_lbfgs_phase", None)
    
    # Never report a final iterate worse than the globally-best evaluated candidate.
    # CMA-ES tracks the incumbent best (opt_state["best_x"] / best_f_global), but the
    # subsequent L-BFGS-B refinement computes finite-difference gradients on an objective
    # that is integer-snapped (n_doublets). Those gradients are unreliable, so L-BFGS-B can wander to a terminal iterate that is
    # dramatically worse than the incumbent (observed: 289 -> ~1.1e6, i.e. back to
    # infeasible). ``result.x`` is that terminal iterate, and when no feasible
    # ``best_config`` snapshot was captured (e.g. the best point was found in a parallel
    # worker eval, which only syncs best_x/best_objective) the finalizer below would report
    # the wandered iterate. Reconcile ``result`` to the incumbent best so the optimizer
    # always returns the best design it actually found.
    _incumbent_obj = float(opt_state.get("best_objective", float("inf")))
    _incumbent_x = opt_state.get("best_x")
    if (
        _incumbent_x is not None
        and np.isfinite(_incumbent_obj)
        and _incumbent_obj < float(getattr(result, "fun", float("inf")))
    ):
        layer1_logger.info(
            "Reconciling final result to incumbent best: result.fun=%.6g -> best_objective=%.6g "
            "(L-BFGS-B terminal iterate was worse than the tracked global best)",
            float(getattr(result, "fun", float("inf"))),
            _incumbent_obj,
        )
        result = _ResultWrapper(np.asarray(_incumbent_x, dtype=float).copy(), _incumbent_obj)
 
    # Parallel CMA/hybrid workers only sync scalar objectives. Re-evaluate the incumbent on
    # the parent process so best_config, validation payloads, and iteration_history carry
    # the full per-term penalty breakdown used by the UI convergence plots.
    _final_inc_x = opt_state.get("best_x")
    if _final_inc_x is not None:
        try:
            layer1_logger.info(
                "Final incumbent parent re-eval (obj=%.6g) for validation snapshot and history",
                float(opt_state.get("best_objective", float("nan"))),
            )
            objective(np.asarray(_final_inc_x, dtype=float))
        except Exception as _final_exc:
            layer1_logger.warning("Final incumbent parent re-eval failed: %s", _final_exc)
 
    validation_tank_pa: Optional[Tuple[float, float]] = None
    _rebuilt = None
    # The pool's winner is the reconciled incumbent in ``result.x``; ``opt_state["best_x"]``
    # is only written when the INLINE objective finds a new best, which in hybrid mode may
    # never happen. Keying the rebuild off best_x alone made it skip silently and fall back
    # to a stale snapshot (tanks 477 psi where the winner had 555; validation had to boost
    # 9-14% to make that snapshot solve).
    _rb_x = getattr(result, "x", None)
    _rb_src = "result.x"
    if _rb_x is None or len(_rb_x) != len(bounds) or not np.all(np.isfinite(np.asarray(_rb_x, dtype=float))):
        _rb_x = opt_state.get("best_x"); _rb_src = "opt_state.best_x"
    opt_state["final_rebuild_diag"] = {"fired": False, "src": _rb_src}
    if _rb_x is not None and len(_rb_x) == len(bounds):
        layer1_logger.info("Final rebuild: from %s (len %d)", _rb_src, len(_rb_x))
        _rebuilt = _layer1_rebuild_final_config(
            np.asarray(_rb_x, dtype=float), config_base, constants_dict, logger=layer1_logger,
            diag=opt_state["final_rebuild_diag"])
        opt_state["final_rebuild_diag"]["fired"] = True
        opt_state["final_rebuild_diag"]["returned"] = _rebuilt is not None
        if _rebuilt is None:
            layer1_logger.warning("Final rebuild returned None -- falling back to snapshot path")
    else:
        layer1_logger.warning(
            "Final rebuild SKIPPED: no usable vector (result.x=%s, best_x=%s, expected len %d)",
            None if getattr(result, "x", None) is None else len(result.x),
            None if opt_state.get("best_x") is None else len(opt_state["best_x"]), len(bounds))
    if _rebuilt is not None:
        optimized_config, _rb_x_solved, _rb_result = _rebuilt
        # The breakdown describes the EMITTED design (full-fidelity result of the rebuild),
        # not whichever in-loop candidate last set a new inline best.
        try:
            _rbT = _layer1_objective_terms(
                _rb_result, np.asarray(_rb_x_solved, dtype=float).copy(), requirements,
                constants_dict, cea_cache=_l1_cea_cache)
            _bd = {"objective": float(_rbT["objective"]), **_rbT["terms"]}
            _bd["penalty_sum"] = float(sum(_rbT["terms"].values()))
            _bd["penalty_unaccounted"] = _bd["objective"] - _bd["penalty_sum"]
            for _k in ("injector_dp_ratio_O", "injector_dp_ratio_F", "chamber_D_over_Dt",
                       "chamber_L_over_D", "Lstar_m", "Lstar_target_m", "chamber_mass_kg",
                       "Isp", "Isp_merit_s", "Isp_ref_s", "propellant_mass_kg",
                       "L_face_to_throat", "L_engine", "momentum_ratio_R", "resultant_tilt_deg",
                       "resultant_tilt_breakeven_deg", "effective_smd_microns",
                       "impingement_angle_deg", "infeasibility_score", "length_violation"):
                _bd[_k] = _rbT.get(_k)
            _bd["source"] = "emitted design (final rebuild)"
            opt_state["best_objective_breakdown"] = _bd
        except Exception as _bd_exc:
            layer1_logger.warning("Breakdown of the emitted design failed: %s", _bd_exc)
        # Everything downstream that reads a vector for this design must see the solved one.
        opt_state["best_config"] = copy.deepcopy(optimized_config)
        opt_state["best_config_x"] = np.asarray(_rb_x_solved, dtype=float).copy()
        opt_state["last_eval_config"] = copy.deepcopy(optimized_config)
        opt_state["last_eval_config_x"] = np.asarray(_rb_x_solved, dtype=float).copy()
        final_lox_end_ratio = opt_state.get("best_lox_end_ratio", 0.7)
        final_fuel_end_ratio = opt_state.get("best_fuel_end_ratio", 0.7)
        validation_tank_pa = (
            float(_rb_x_solved[idx_P_O]) * 6894.757293168,
            float(_rb_x_solved[idx_P_F]) * 6894.757293168,
        )
    elif opt_state["best_config"] is not None:
        optimized_config = copy.deepcopy(opt_state["best_config"])
        final_lox_end_ratio = opt_state.get("best_lox_end_ratio", 0.7)
        final_fuel_end_ratio = opt_state.get("best_fuel_end_ratio", 0.7)
        validation_tank_pa = opt_state.get("best_validation_tank_pa")
    elif opt_state.get("last_eval_config") is not None:
        optimized_config = copy.deepcopy(opt_state["last_eval_config"])
        final_lox_end_ratio = opt_state.get("best_lox_end_ratio", 0.7)
        final_fuel_end_ratio = opt_state.get("best_fuel_end_ratio", 0.7)
        validation_tank_pa = opt_state.get("last_eval_validation_tank_pa")
    else:
        _rx = getattr(result, "x", None)
        _rx = np.asarray(_rx if _rx is not None else x0, dtype=float).copy()
        optimized_config, P_O_final_psi, P_F_final_psi = apply_x_to_config(_rx, config_base)
        final_lox_end_ratio = P_O_final_psi / max_lox_P_psi if max_lox_P_psi > 0 else 0.7
        final_fuel_end_ratio = P_F_final_psi / max_fuel_P_psi if max_fuel_P_psi > 0 else 0.7
    
    # Ensure tank configs exist
    if optimized_config.lox_tank is None:
        from engine.pipeline.config_schemas import LOXTankConfig
        optimized_config.lox_tank = LOXTankConfig(lox_h=0.5, lox_radius=0.1, ox_tank_pos=1.0)
    if optimized_config.fuel_tank is None:
        from engine.pipeline.config_schemas import FuelTankConfig
        optimized_config.fuel_tank = FuelTankConfig(rp1_h=0.5, rp1_radius=0.1, fuel_tank_pos=0.5)
    
    # Extract optimized pressures
    best_x = opt_state.get("best_x", result.x if hasattr(result, 'x') else x0)
    # Pressures must match the geometry snapshot in ``best_config`` when present (``best_x`` alone can
    # refer to an infeasible iterate while ``best_config`` still holds the last feasible design).
    x_for_tank_psi = opt_state.get("best_config_x")
    if x_for_tank_psi is None or len(x_for_tank_psi) <= idx_P_F:
        x_for_tank_psi = opt_state.get("last_eval_config_x")
    if x_for_tank_psi is None or len(x_for_tank_psi) <= idx_P_F:
        x_for_tank_psi = best_x
    if x_for_tank_psi is not None and len(x_for_tank_psi) > idx_P_F:
        P_O_start_optimized_psi = float(
            np.clip(x_for_tank_psi[idx_P_O], bounds[idx_P_O][0], bounds[idx_P_O][1])
        )
        # Clip to the SEARCH range, not to bounds[idx_P_F]: when the tanks are locked that
        # bound is collapsed to the seed, and clipping there overwrote the locked value with
        # it -- the reported fuel tank read 535.2 psi on every run while the physics had used
        # it equal to the LOX tank.
        P_F_start_optimized_psi = float(
            np.clip(x_for_tank_psi[idx_P_F], lower_bounds_eff[idx_P_F], upper_bounds_eff[idx_P_F])
        )
        optimized_config.lox_tank.initial_pressure_psi = P_O_start_optimized_psi
        optimized_config.fuel_tank.initial_pressure_psi = P_F_start_optimized_psi
        # The geometry above and these pressures can come from different candidates; re-solve
        # the derived DOFs so the emitted design is self-consistent. Skipped when the rebuild
        # already produced the design from ONE vector -- a second solve on top of a converged
        # one only perturbs A_throat (measured as a 0.1-0.5% thrust drift).
        if _rebuilt is None:
          _layer1_finalize_derived_geometry(
              optimized_config,
              P_O_start_optimized_psi * 6894.757293168,
              P_F_start_optimized_psi * 6894.757293168,
              constants_dict,
              logger=layer1_logger,
          )
    else:
        optimized_config.lox_tank.initial_pressure_psi = max_lox_P_psi * 0.8
        optimized_config.fuel_tank.initial_pressure_psi = max_fuel_P_psi * 0.8
 
    # Ensure orifice angle is 90°
    if hasattr(optimized_config, 'injector') and optimized_config.injector.type == "pintle":
        if hasattr(optimized_config.injector.geometry, 'lox'):
            optimized_config.injector.geometry.lox.theta_orifice = 90.0
    
    iteration_history = opt_state["history"]
    
    def _validation_evaluate_boost(
        runner: PintleEngineRunner,
        po: float,
        pf: float,
    ) -> Tuple[Dict[str, Any], float]:
        """Evaluate the emitted design at its OWN tank pressures.
 
        If it does not close there, find -- for the report only, never the verdict -- the
        smallest tank boost inside the tank limits at which it would. Any scale other than 1.0
        makes the design invalid (see validation_replay_ok below).
        """
        po0, pf0 = float(po), float(pf)
        try:
            return runner.evaluate(po0, pf0, P_ambient=target_P_exit, silent=True), 1.0
        except ValueError as exc:
            if "Supply < Demand" not in str(exc) and "Insufficient mass flow" not in str(exc):
                raise
            first_exc = exc
        _cap = min(max_lox_P_psi * psi_to_Pa / max(po0, 1.0),
                   max_fuel_P_psi * psi_to_Pa / max(pf0, 1.0))
        for scale in (1.03, 1.06, 1.09, 1.14, 1.20, 1.28, 1.40, 1.55, 1.72):
            if scale > _cap:
                break
            try:
                return runner.evaluate(po0 * scale, pf0 * scale, P_ambient=target_P_exit,
                                       silent=True), scale
            except ValueError as exc:
                if "Supply < Demand" not in str(exc) and "Insufficient mass flow" not in str(exc):
                    raise
        raise first_exc
 
    def _validation_evaluate_or_bundle(
        runner: PintleEngineRunner,
        po: float,
        pf: float,
    ) -> Tuple[Dict[str, Any], float]:
        """Replay validation evaluate; fall back to the last optimizer ``evaluate`` payload if the
        solver diverges -- for the report only; the design is then invalid.
 
        The chamber solver says it did not close in two ways: a ``ValueError`` from the root
        find, and a ``RuntimeError`` from its own checks on what it found ("Solution
        validation failed: Isp is non-positive"). Both mean the emitted design does not
        close at its tank pressures; only the first used to be caught, so a design whose
        replay landed on a non-physical root crashed the optimizer instead of being reported
        invalid -- on CI's runners, where the smoke search's last candidate is one of them.
        """
        try:
            return _validation_evaluate_boost(runner, po, pf)
        except (ValueError, RuntimeError) as exc:
            if isinstance(exc, RuntimeError) and not str(exc).startswith(_CHAMBER_SOLVER_REFUSALS):
                raise
            b = opt_state.get("last_good_eval_bundle")
            if not isinstance(b, dict) or not isinstance(b.get("results"), dict):
                raise
            layer1_logger.warning(
                "Layer 1 validation replay failed (%s); reporting the last in-loop evaluate "
                "payload, and the design is INVALID.", exc
            )
            perf = copy.deepcopy(b["results"])
            perf["layer1_validation_used_last_good_bundle"] = True
            perf["layer1_validation_replay_error"] = str(exc)[:200]
            return perf, 1.0
    
    # Validation
    update_progress("Layer 1: Validation", 0.52, "Validating optimized configuration...")
    
    best_x = opt_state.get("best_x", result.x if hasattr(result, 'x') else x0)
    validation_pressure_scale = 1.0
    
    # Prefer exact LOX/fuel tank pressures (Pa) used in the iterate that produced this geometry snapshot;
    # avoids psi↔Pa rounding drift vs ``initial_pressure_psi`` clipping.
    if validation_tank_pa is not None and len(validation_tank_pa) == 2:
        P_O_initial = float(validation_tank_pa[0])
        P_F_initial = float(validation_tank_pa[1])
    else:
        try:
            P_O_initial = float(optimized_config.lox_tank.initial_pressure_psi) * psi_to_Pa
            P_F_initial = float(optimized_config.fuel_tank.initial_pressure_psi) * psi_to_Pa
        except Exception:
            if best_x is not None and len(best_x) > idx_P_O:
                P_O_initial = float(np.clip(best_x[idx_P_O], bounds[idx_P_O][0], bounds[idx_P_O][1])) * psi_to_Pa
            else:
                P_O_initial = max_lox_P_psi * psi_to_Pa * 0.95
            if best_x is not None and len(best_x) > idx_P_F:
                P_F_initial = float(np.clip(best_x[idx_P_F], bounds[idx_P_F][0], bounds[idx_P_F][1])) * psi_to_Pa
            else:
                P_F_initial = max_fuel_P_psi * psi_to_Pa * 0.95
 
    # Validate the engine AS DESIGNED. Disabling the liner here changed the wall by 0.5 in
    # per side, i.e. a full inch of bore, so the replay scored a different chamber than the
    # one being shipped: the rebuild solved F = 7208.8 N and validation reported 7240.4 N for
    # the same design. Reported numbers must describe the config the user receives.
    optimized_config_runner = copy.deepcopy(optimized_config)
    if os.environ.get("ED_L1_VALIDATE_THERMAL_OFF", "0") == "1":   # A/B hook only
        if getattr(optimized_config_runner, "ablative_cooling", None):
            optimized_config_runner.ablative_cooling.enabled = False
        if getattr(optimized_config_runner, "graphite_insert", None):
            optimized_config_runner.graphite_insert.enabled = False
    
    optimized_runner = PintleEngineRunner(optimized_config_runner)
 
    # When nothing was feasible, say which gate held the best candidate out (see the helper).
    infeasible_reason = None
    try:
        if best_x is not None and not _layer1_feasible_scalar_objective(float(opt_state.get("best_objective", float("inf")))):
            infeasible_reason = _layer1_infeasibility_reason(optimized_runner, best_x, requirements, constants_dict)
            if infeasible_reason and log_status:
                log_status("warning", infeasible_reason)
    except Exception:
        infeasible_reason = None
    
    # Use stored validation results if available
    if "best_results_for_validation" in opt_state and opt_state["best_results_for_validation"] is not None:
        stored_results = opt_state["best_results_for_validation"]
        # No placeholder Isp/Pc (this used to seed 250 s / 2 MPa): they come from the replay
        # below or not at all.
        initial_performance = {
            "F": stored_results["F"],
            "MR": stored_results["MR"],
            "stability_results": stored_results.get("stability_results", {}),
        }
        initial_thrust_error = stored_results["thrust_error"]
        initial_MR_error = stored_results["of_error"]
        stored_stability_score = stored_results.get("stability_score", None)
        stored_stability_state = stored_results.get("stability_state", None)
        log_status("Layer 1 Validation", f"Using stored validation results: Thrust err {initial_thrust_error*100:.2f}%, O/F err {initial_MR_error*100:.2f}%")
        
        # For stored results, we need to re-evaluate to get P_exit and Cf
        # (stored_results only contains F, MR, errors, and stability)
        try:
            eval_results, validation_pressure_scale = _validation_evaluate_or_bundle(
                optimized_runner, P_O_initial, P_F_initial
            )
            # Copy P_exit and Cf from evaluation if available
            if "P_exit" in eval_results:
                initial_performance["P_exit"] = eval_results["P_exit"]
            if "Cf" in eval_results or "Cf_actual" in eval_results:
                initial_performance["Cf"] = eval_results.get("Cf_actual", eval_results.get("Cf"))
                initial_performance["Cf_actual"] = initial_performance["Cf"]
            # Also copy other useful metrics that might be missing
            if "Isp" in eval_results:
                initial_performance["Isp"] = eval_results["Isp"]
            if "Pc" in eval_results:
                initial_performance["Pc"] = eval_results["Pc"]
            # Copy mass flow rates and efficiency metrics
            if "mdot_total" in eval_results:
                initial_performance["mdot_total"] = eval_results["mdot_total"]
            if "mdot_O" in eval_results:
                initial_performance["mdot_O"] = eval_results["mdot_O"]
            if "mdot_F" in eval_results:
                initial_performance["mdot_F"] = eval_results["mdot_F"]
            if "eta_cstar" in eval_results:
                initial_performance["eta_cstar"] = eval_results["eta_cstar"]
            if "cstar_actual" in eval_results:
                initial_performance["cstar_actual"] = eval_results["cstar_actual"]
            if "cstar_ideal" in eval_results:
                initial_performance["cstar_ideal"] = eval_results["cstar_ideal"]
            # Replay thrust/MR/stability must match diagnostics used for ΔP and momentum gates.
            if "F" in eval_results:
                initial_performance["F"] = eval_results["F"]
            if "MR" in eval_results:
                initial_performance["MR"] = eval_results["MR"]
            if eval_results.get("stability_results"):
                initial_performance["stability_results"] = eval_results["stability_results"]
            # Copy chamber_intrinsics (contains is_choked, etc.)
            if "chamber_intrinsics" in eval_results and eval_results["chamber_intrinsics"]:
                initial_performance["chamber_intrinsics"] = eval_results["chamber_intrinsics"]
            _merge_runner_eval_into_performance(initial_performance, eval_results)
            for _vk in ("layer1_validation_used_last_good_bundle", "layer1_validation_replay_error"):
                if _vk in eval_results:
                    initial_performance[_vk] = eval_results[_vk]
        except Exception as _replay_exc:
            initial_performance["layer1_validation_replay_error"] = str(_replay_exc)[:200]
            # If re-evaluation fails, calculate Cf from available data
            F_val = initial_performance.get("F", 0)
            Pc_val = initial_performance.get("Pc", 0)
            A_throat_val = _throat_area_m2_from_config(optimized_config)
            if A_throat_val and A_throat_val > 0 and Pc_val > 0:
                Cf_calculated = F_val / (Pc_val * A_throat_val)
                initial_performance["Cf_actual"] = Cf_calculated
                initial_performance["Cf"] = Cf_calculated
    else:
        initial_performance, validation_pressure_scale = _validation_evaluate_or_bundle(
            optimized_runner, P_O_initial, P_F_initial
        )
        initial_thrust_error = (
            abs(initial_performance.get("F", 0) - target_thrust) / target_thrust if target_thrust > 0 else 1.0
        )
        initial_MR_error = (
            abs(initial_performance.get("MR", 0) - optimal_of) / optimal_of if optimal_of > 0 else 1.0
        )
        
        # Ensure Cf is included (calculate if not provided by runner)
        if "Cf" not in initial_performance and "Cf_actual" not in initial_performance:
            F_val = initial_performance.get("F", 0)
            Pc_val = initial_performance.get("Pc", 0)
            A_throat_val = _throat_area_m2_from_config(optimized_config)
            if A_throat_val and A_throat_val > 0 and Pc_val > 0:
                Cf_calculated = F_val / (Pc_val * A_throat_val)
                initial_performance["Cf_actual"] = Cf_calculated
                initial_performance["Cf"] = Cf_calculated
    
    if validation_pressure_scale is not None and np.isfinite(float(validation_pressure_scale)):
        sc = float(validation_pressure_scale)
        initial_performance["layer1_validation_tank_pressure_scale"] = sc
        # Nominal stagnation pressures from the optimizer iterate (``P_O_initial`` / ``P_F_initial`` in Pa).
        _po_nom_psi = min(float(P_O_initial) / float(psi_to_Pa), max_lox_P_psi)
        _pf_nom_psi = min(float(P_F_initial) / float(psi_to_Pa), max_fuel_P_psi)
        # Saved YAML + "Optimized Tank Pressures" must stay at **nominal** caps: replay may multiply tanks
        # by ``sc>1`` only to get a convergent ``evaluate()`` after marginal supply starvation (common when
        # spray / η models tighten injector-side closure). Persisting ``*_nom*sc`` made UI/YAML look like
        # the design exceeded the Layer‑1 stagnation band (~65–85% of tank max).
        optimized_config.lox_tank.initial_pressure_psi = _po_nom_psi
        optimized_config.fuel_tank.initial_pressure_psi = _pf_nom_psi
        if abs(sc - 1.0) > 1e-6:
            initial_performance["layer1_validation_replay_boosted_tanks"] = True
            initial_performance["P_O_start_psi_validation_replay"] = float(_po_nom_psi * sc)
            initial_performance["P_F_start_psi_validation_replay"] = float(_pf_nom_psi * sc)
 
    # Impinging: expose jet momentum-balance ratio and hinge penalty at top level for UI / summaries
    if getattr(getattr(optimized_config, "injector", None), "type", None) == "impinging":
        _diag_vals = initial_performance.get("diagnostics")
        initial_performance["momentum_balance_penalty"] = 0.0
        if isinstance(_diag_vals, dict):
            _mr_promote = _diag_vals.get("momentum_ratio_R")
            if _mr_promote is not None and np.isfinite(_mr_promote) and float(_mr_promote) > 0:
                initial_performance["momentum_ratio_R"] = float(_mr_promote)
                initial_performance["momentum_balance_penalty"] = float(
                    layer1_W_MOM
                    * _impinging_momentum_hinge_squared(
                        _mr_promote,
                        r_band_lo=layer1_R_mom_aim_lo,
                        r_band_hi=layer1_R_mom_aim_hi,
                    )
                )
            # Audit fields for UI (same definitions as impinging.flows momentum_ratio_R)
            for _rk, _cast in (
                ("v_O_bulk", float),
                ("v_F_bulk", float),
                ("A_jet_O", float),
                ("A_jet_F", float),
                ("rho_O_momentum", float),
                ("rho_F_momentum", float),
                ("d_jet_O", float),
                ("d_jet_F", float),
            ):
                _rv = _diag_vals.get(_rk)
                if _rv is not None:
                    try:
                        _rf = _cast(_rv)
                        if np.isfinite(_rf):
                            initial_performance[_rk] = _rf
                    except (TypeError, ValueError):
                        pass
            for _ik in ("momentum_ratio_n_elements_O", "momentum_ratio_n_elements_F"):
                _iv = _diag_vals.get(_ik)
                if _iv is not None:
                    try:
                        initial_performance[_ik] = int(_iv)
                    except (TypeError, ValueError):
                        pass
        try:
            ig = optimized_config.injector.geometry
            rho_o_p = float(optimized_config.fluids["oxidizer"].density)
            rho_f_p = float(optimized_config.fluids["fuel"].density)
            Aog_p = float(ig.oxidizer.n_elements * np.pi * (ig.oxidizer.d_jet / 2.0) ** 2)
            Afg_p = float(ig.fuel.n_elements * np.pi * (ig.fuel.d_jet / 2.0) ** 2)
            if Afg_p > 0:
                _sq_g, ao_r, exp_r = _geom_ao_af_momentum_hint_squared(
                    Aog_p, Afg_p, optimal_of, rho_o_p, rho_f_p
                )
                initial_performance["geom_ao_af"] = float(ao_r)
                initial_performance["expected_ao_af_for_R1"] = float(exp_r)
                if np.isfinite(exp_r) and float(exp_r) != 0.0:
                    initial_performance["geom_ao_af_rel_error"] = float((float(ao_r) - float(exp_r)) / float(exp_r))
                initial_performance["geom_ao_af_momentum_hint_sq"] = float(_sq_g)
        except Exception:
            pass
 
    # Injector ΔP/Pc ratios and weighted penalty (all injector types when Pc and diagnostics allow)
    initial_performance["injector_dp_out_of_range"] = False
    _pc_prom = initial_performance.get("Pc")
    if _pc_prom is not None and np.isfinite(float(_pc_prom)) and float(_pc_prom) > 0:
        _ro_p, _rf_p = injector_dp_ratios_from_eval_result(float(_pc_prom), initial_performance)
        if _ro_p is not None:
            initial_performance["injector_dp_ratio_O"] = float(_ro_p)
        if _rf_p is not None:
            initial_performance["injector_dp_ratio_F"] = float(_rf_p)
        initial_performance["injector_dp_penalty"] = float(
            injector_dp_ratio_penalty_weighted(
                _ro_p,
                _rf_p,
                layer1_W_DP,
                layer1_W_DP_HIGH,
                o_band=layer1_dp_o_aim,
                f_band=layer1_dp_f_aim,
                w_dp_o=layer1_W_DP_O,
                w_dp_f=layer1_W_DP_F,
                o_soft_floor=layer1_dp_o_soft_floor,
                w_dp_o_floor=layer1_W_DP_O_FLOOR,
            )
        )
        lo_o, hi_o = layer1_dp_o_band
        lo_f, hi_f = layer1_dp_f_band
        _oor = False
        if injector_dp_ratio_within_gate(_ro_p, float(lo_o), float(hi_o)) is False:
            _oor = True
        if injector_dp_ratio_within_gate(_rf_p, float(lo_f), float(hi_f)) is False:
            _oor = True
        initial_performance["injector_dp_out_of_range"] = bool(_oor)
 
    # Thrust/MR gate fractions must match final replay payload (ΔP/R gates already use same evaluate).
    _Fv_gate = initial_performance.get("F")
    _MRv_gate = initial_performance.get("MR")
    if target_thrust > 0 and _Fv_gate is not None and np.isfinite(float(_Fv_gate)):
        initial_thrust_error = abs(float(_Fv_gate) - float(target_thrust)) / float(target_thrust)
    else:
        initial_thrust_error = 1.0
    if optimal_of > 0 and _MRv_gate is not None and np.isfinite(float(_MRv_gate)):
        initial_MR_error = abs(float(_MRv_gate) - float(optimal_of)) / float(optimal_of)
    else:
        initial_MR_error = 1.0
    
    # Update chamber_geometry.Cf with the calculated thrust coefficient
    Cf_final = initial_performance.get("Cf_actual", initial_performance.get("Cf"))
    if Cf_final is not None and np.isfinite(Cf_final):
        if optimized_config.chamber_geometry is not None:
            optimized_config.chamber_geometry.Cf = float(Cf_final)
    
    # Check stability (replay evaluate provides nested stability_results; snapshot uses flat margins).
    sr_live = initial_performance.get("stability_results")
    snap = opt_state.get("best_results_for_validation") or {}
    if isinstance(sr_live, dict) and sr_live:
        stability_results = sr_live
        stability_state = stability_results.get("stability_state", "unstable")
        stability_score = float(stability_results.get("stability_score", 0.0))
        chugging_margin = float(stability_results.get("chugging", {}).get("stability_margin", 0))
        acoustic_margin = float(stability_results.get("acoustic", {}).get("stability_margin", 0))
        feed_margin = float(stability_results.get("feed_system", {}).get("stability_margin", 0))
    elif snap:
        stability_results = snap.get("stability_results", {})
        stability_state = snap.get("stability_state", "unstable")
        stability_score = float(snap.get("stability_score", 0.0))
        chugging_margin = float(snap.get("chugging_margin", 0))
        acoustic_margin = float(snap.get("acoustic_margin", 0))
        feed_margin = float(snap.get("feed_margin", 0))
    else:
        stability_results = {}
        stability_state = "unstable"
        stability_score = 0.0
        chugging_margin = acoustic_margin = feed_margin = 0.0
    initial_stability = min(chugging_margin, acoustic_margin, feed_margin)
    
    # Validation checks
    stability_check_passed, stability_parts = _layer1_stability_gate(
        stability_state, stability_score, chugging_margin, acoustic_margin, feed_margin,
        stability_results, requirements, min_stability)
    require_stable_state = requirements.get("require_stable_state", True)
    
    _thr_v = requirements.get("layer1_thrust_validation_rel_tol")
    thrust_tol_valid = float(_thr_v) if _thr_v is not None else float(thrust_tol)
    _of_v = requirements.get("layer1_of_validation_tol")
    of_tol_valid = float(_of_v if _of_v is not None else 0.15)
    if not np.isfinite(of_tol_valid) or of_tol_valid <= 0.0:
        of_tol_valid = 0.15
    _gate_tol_eps = 1e-12
    thrust_check_passed = initial_thrust_error <= thrust_tol_valid + _gate_tol_eps
    of_check_passed = initial_MR_error <= of_tol_valid + _gate_tol_eps
    
    # Geometry validation (consistency check for final result)
    A_throat_final = float(getattr(optimized_config.chamber_geometry, 'A_throat', 0.0))
    D_chamber_final = float(getattr(optimized_config.chamber_geometry, 'chamber_diameter', 0.0))
    A_chamber_final = np.pi * (D_chamber_final / 2) ** 2
    
    geometry_check_passed = True
    geometry_failure_reasons = []
    
    if A_chamber_final > 0 and A_throat_final > 0:
        contraction_ratio_final = A_chamber_final / A_throat_final
        if contraction_ratio_final < 1.1:
            geometry_check_passed = False
            geometry_failure_reasons.append(f"Throat area too large for chamber (contraction ratio {contraction_ratio_final:.2f} < 1.1)")
    
    if (
        getattr(optimized_config.injector, "type", None) == "pintle"
        and hasattr(optimized_config.injector, 'geometry')
        and hasattr(optimized_config.injector.geometry, 'fuel')
    ):
        d_pintle_final = float(optimized_config.injector.geometry.fuel.d_pintle_tip)
        if d_pintle_final >= D_chamber_final:
            geometry_check_passed = False
            geometry_failure_reasons.append(f"Pintle diameter {d_pintle_final*1000:.1f}mm >= chamber diameter {D_chamber_final*1000:.1f}mm")
    
    if (
        getattr(optimized_config.injector, "type", None) == "impinging"
        and hasattr(optimized_config.injector, "geometry")
    ):
        ig = optimized_config.injector.geometry
        d_max = max(float(ig.oxidizer.d_jet), float(ig.fuel.d_jet))
        if D_chamber_final > 0 and d_max * 1.15 >= D_chamber_final:
            geometry_check_passed = False
            geometry_failure_reasons.append(
                f"Impinging jet diameter (max {d_max*1000:.2f} mm) too large vs chamber inner Ø {D_chamber_final*1000:.1f} mm"
            )
    
    # Chamber length constraint (use unified chamber_geometry when legacy chamber is null).
    from engine.pipeline.config_schemas import ensure_chamber_geometry as _ensure_cg_len
 
    _cg_len = _ensure_cg_len(optimized_config)
    _len_raw = getattr(_cg_len, "length", None)
    L_chamber_final = (
        float(_len_raw)
        if (_len_raw is not None and np.isfinite(float(_len_raw)))
        else np.nan
    )
    _mcl = requirements.get("max_chamber_length_m")  # None-safe, see report_every_n
    max_chamber_length = float(_mcl) if _mcl is not None else 0.50
    
    if np.isfinite(L_chamber_final) and max_chamber_length > 0:
        if L_chamber_final > max_chamber_length:
            geometry_check_passed = False
            geometry_failure_reasons.append(f"Chamber length {L_chamber_final*1000:.1f}mm > max allowed {max_chamber_length*1000:.1f}mm")
 
    # Injector ΔP ratio gate (optional; enforced when Pc and ratios are available).
    def _as_finite_float_or_nan(v: Any) -> float:
        try:
            f = float(v)
        except (TypeError, ValueError):
            return float("nan")
        return f if np.isfinite(f) else float("nan")
 
    ratio_o_val = ratio_f_val = float("nan")
    dp_gate_passed = True
    pc_val = float(initial_performance.get("Pc", np.nan))
    if np.isfinite(pc_val) and pc_val > 0:
        _ro, _rf = injector_dp_ratios_from_eval_result(pc_val, initial_performance)
        ratio_o_val = _as_finite_float_or_nan(_ro)
        ratio_f_val = _as_finite_float_or_nan(_rf)
        _chk_o_final = injector_dp_ratio_within_gate(
            ratio_o_val, layer1_dp_o_band[0], layer1_dp_o_band[1]
        )
        if _chk_o_final is not None:
            dp_gate_passed &= bool(_chk_o_final)
        _chk_f_final = injector_dp_ratio_within_gate(
            ratio_f_val, layer1_dp_f_band[0], layer1_dp_f_band[1]
        )
        if _chk_f_final is not None:
            dp_gate_passed &= bool(_chk_f_final)
 
    # Impinging momentum-ratio gate (optional).
    momentum_gate_passed = True
    momentum_gate_band = (layer1_impinging_R_mom_lo, layer1_impinging_R_mom_hi)
    momentum_r_val = float(initial_performance.get("momentum_ratio_R", np.nan))
    if (
        getattr(optimized_config.injector, "type", None) == "impinging"
        and layer1_impinging_R_mom_lo is not None
        and layer1_impinging_R_mom_hi is not None
        and np.isfinite(momentum_r_val)
        and momentum_r_val > 0
    ):
        # SYMMETRIC, and no longer the liner check. R is a momentum-FLUX ratio; the liner
        # gate is the resultant tilt below. The asymmetric widening here encoded the old
        # "below 1 is safe" rule, and with the tilt guard doing the real work the balanced
        # designs sit at R ~ 1.05 -- passing every other check and failing this one, which
        # marked a good engine invalid (measured: R = 1.0508 against a 1.05 ceiling,
        # momentum_gate_passed False, pressure_candidate_valid False).
        momentum_gate_passed, momentum_gate_band = _layer1_momentum_gate(
            momentum_r_val, layer1_impinging_R_mom_lo, layer1_impinging_R_mom_hi,
            layer1_momentum_gate_safe_slack)
 
    # The real ablative gate: where the spray fan actually points.
    resultant_tilt_gate_passed = True
    _tilt_final = float("nan")
    if getattr(optimized_config.injector, "type", None) == "impinging":
        _gf = getattr(optimized_config.injector, "geometry", None)
        _tilt_final = _impinging_resultant_tilt_deg(
            initial_performance.get("mdot_O"), initial_performance.get("mdot_F"),
            float(optimized_config.fluids["oxidizer"].density),
            float(optimized_config.fluids["fuel"].density),
            getattr(_gf.oxidizer, "n_elements", float("nan")) if _gf else float("nan"),
            getattr(_gf.oxidizer, "d_jet", float("nan")) if _gf else float("nan"),
            getattr(_gf.fuel, "d_jet", float("nan")) if _gf else float("nan"),
            getattr(_gf.oxidizer, "impingement_angle", float("nan")) if _gf else float("nan"),
            getattr(_gf.fuel, "impingement_angle", float("nan")) if _gf else float("nan"),
            lox_inboard=layer1_ring_order_fuel_outboard,
            spacing_O_m=getattr(_gf.oxidizer, "spacing", float("nan")) if _gf else float("nan"),
            spacing_F_m=getattr(_gf.fuel, "spacing", float("nan")) if _gf else float("nan"),
        )
        initial_performance["resultant_tilt_deg"] = (
            float(_tilt_final) if np.isfinite(_tilt_final) else None)
        # The tilt ALLOWANCE is a constant the operator sets; what makes it safe is geometry
        # the optimizer moves underneath it. Report the break-even angle for the design that
        # actually came out, so an allowance that its own impingement radius no longer
        # justifies is visible instead of silent. See _resultant_tilt_breakeven_deg.
        _cg_f = getattr(optimized_config, "chamber_geometry", None)
        _L_cham_f = float("nan")
        if _cg_f is not None:
            _lc = getattr(_cg_f, "length_cylindrical", None)
            _ln = getattr(_cg_f, "length_contraction", None)
            if _lc is not None and _ln is not None:
                _L_cham_f = float(_lc) + float(_ln)
            elif getattr(_cg_f, "length", None) is not None:
                _L_cham_f = float(_cg_f.length)
        _be_final = _resultant_tilt_breakeven_deg(
            n_elements=getattr(_gf.oxidizer, "n_elements", float("nan")) if _gf else float("nan"),
            spacing_O_m=getattr(_gf.oxidizer, "spacing", float("nan")) if _gf else float("nan"),
            spacing_F_m=getattr(_gf.fuel, "spacing", float("nan")) if _gf else float("nan"),
            angle_O_deg=getattr(_gf.oxidizer, "impingement_angle", float("nan")) if _gf else float("nan"),
            angle_F_deg=getattr(_gf.fuel, "impingement_angle", float("nan")) if _gf else float("nan"),
            D_chamber_inner_m=float(getattr(_cg_f, "chamber_diameter", float("nan")))
            if _cg_f is not None else float("nan"),
            L_chamber_m=_L_cham_f,
        )
        initial_performance["resultant_tilt_breakeven_deg"] = (
            float(_be_final) if np.isfinite(_be_final) else None)
        _tilt_allow_final = _resolve_tilt_allowance_deg(
            from_reach=layer1_resultant_tilt_from_reach,
            constant_deg=layer1_resultant_tilt_max_deg,
            breakeven_deg=_be_final,
            margin=layer1_resultant_tilt_reach_margin,
        )
        initial_performance["resultant_tilt_allowed_deg"] = float(_tilt_allow_final)
        if np.isfinite(_be_final) and float(_tilt_allow_final) > _be_final:
            layer1_logger.warning(
                "The permitted outward tilt, %.2f deg, exceeds the break-even tilt for this "
                "design's own geometry (%.2f deg): a fan at the allowed limit would reach the "
                "liner %.0f mm from the face, inside a %.0f mm chamber. Lower the allowance, or "
                "move the element ring inboard.",
                float(_tilt_allow_final), _be_final,
                1000.0 * _L_cham_f * float(np.tan(np.deg2rad(_be_final)))
                / max(1e-9, float(np.tan(np.deg2rad(float(_tilt_allow_final))))),
                1000.0 * _L_cham_f,
            )
        if np.isfinite(_tilt_final):
            resultant_tilt_gate_passed = bool(
                _tilt_final <= float(_tilt_allow_final)
                + float(layer1_resultant_tilt_gate_tol_deg))
    initial_performance["resultant_tilt_gate_passed"] = bool(resultant_tilt_gate_passed)
 
    # Every declared geometric limit, re-checked on the emitted design at face value. In the
    # search these share one sum-of-squares tolerance (gate_eps), which lets a single 4.5 %
    # violation through; sign-off does not.
    limit_gates = _layer1_declared_limit_gates(optimized_config, requirements, constants_dict,
                                               performance=initial_performance)
    for _gname, (_gok, _gmsg) in limit_gates.items():
        initial_performance[f"{_gname}_gate_passed"] = bool(_gok)
        if not _gok:
            geometry_check_passed = False
            geometry_failure_reasons.append(_gmsg)
 
    # The design must close at its OWN tank pressures, evaluated as emitted. A replay that only
    # solves with the tanks boosted, or that fell back to an earlier in-loop evaluation, does
    # not describe this design.
    _sc_v = float(initial_performance.get("layer1_validation_tank_pressure_scale", 1.0) or 1.0)
    validation_replay_ok = True
    if abs(_sc_v - 1.0) > 1e-9:
        validation_replay_ok = False
        failure_reasons_replay = (
            f"Design does not close at its own tank pressures (needs x{_sc_v:.2f}: "
            f"{float(P_O_initial) / psi_to_Pa * _sc_v:.0f}/{float(P_F_initial) / psi_to_Pa * _sc_v:.0f} psi)")
    elif initial_performance.get("layer1_validation_used_last_good_bundle"):
        validation_replay_ok = False
        failure_reasons_replay = (
            "Validation replay failed ("
            + str(initial_performance.get("layer1_validation_replay_error", "evaluate() raised"))
            + "); the numbers shown are an earlier in-loop evaluation")
    elif initial_performance.get("layer1_validation_replay_error"):
        validation_replay_ok = False
        failure_reasons_replay = ("Validation replay failed: "
                                  + str(initial_performance["layer1_validation_replay_error"]))
    else:
        failure_reasons_replay = ""
    initial_performance["validation_replay_ok"] = bool(validation_replay_ok)
 
    # A chamber-pressure target is a requirement: the emitted design must meet it.
    pc_gate_passed = True
    pc_gate_reason = ""
    _pc_t_v = requirements.get("target_chamber_pressure_psi")
    _pc_v = float(initial_performance.get("Pc", np.nan))
    if _pc_t_v is not None and float(_pc_t_v) > 0:
        _pc_miss = abs(_pc_v / (float(_pc_t_v) * 6894.757293168) - 1.0) if np.isfinite(_pc_v) else np.inf
        pc_gate_passed = bool(_pc_miss <= _LAYER1_PC_GATE_REL)
        if not pc_gate_passed:
            pc_gate_reason = (
                f"Chamber pressure {_pc_v / 6894.757293168:.1f} psia is {100 * _pc_miss:.2f} % off "
                f"the {float(_pc_t_v):.0f} psia target (limit {100 * _LAYER1_PC_GATE_REL:.0f} %)")
    initial_performance["pc_gate_passed"] = bool(pc_gate_passed)
 
    pressure_candidate_valid = (
        thrust_check_passed
        and pc_gate_passed
        and of_check_passed
        and resultant_tilt_gate_passed
        and stability_check_passed
        and geometry_check_passed
        and dp_gate_passed
        and momentum_gate_passed
        and validation_replay_ok
    )
    # Surface truth to API/UI: mid-optimization ``converged`` can latch True from soft thresholds;
    # overrides only when final hard gates settle.
    opt_state["converged"] = bool(pressure_candidate_valid)
    
    # Build failure reasons
    failure_reasons = []
    if not validation_replay_ok:
        failure_reasons.append(failure_reasons_replay)
    if not pc_gate_passed:
        failure_reasons.append(pc_gate_reason)
    if not thrust_check_passed:
        failure_reasons.append(f"Thrust error {initial_thrust_error*100:.1f}% > {thrust_tol_valid*100:.1f}% limit")
    if not of_check_passed:
        failure_reasons.append(f"O/F error {initial_MR_error*100:.1f}% > {of_tol_valid*100:.1f}% limit")
    if not geometry_check_passed:
        failure_reasons.extend(geometry_failure_reasons)
    if not stability_check_passed:
        failure_reasons.append(f"Stability failed: {'; '.join(stability_parts)}")
    if not dp_gate_passed:
        dp_parts = []
        if np.isfinite(ratio_o_val):
            dp_parts.append(
                f"ΔP_O/Pc in [{layer1_dp_o_band[0]:.3f},{layer1_dp_o_band[1]:.3f}] (got {ratio_o_val:.3f})"
            )
        if np.isfinite(ratio_f_val):
            dp_parts.append(
                f"ΔP_F/Pc in [{layer1_dp_f_band[0]:.3f},{layer1_dp_f_band[1]:.3f}] (got {ratio_f_val:.3f})"
            )
        failure_reasons.append("Injector ΔP ratio failed: " + "; ".join(dp_parts))
    if not momentum_gate_passed:
        failure_reasons.append(
            f"Momentum ratio R not in [{float(momentum_gate_band[0]):.3f},"
            f"{float(momentum_gate_band[1]):.3f}] (got {momentum_r_val:.3f})"
        )
    
    if not pressure_candidate_valid and not failure_reasons:
        failure_reasons.append("Validation failed: no requirements met")
    
    # Log validation
    if pressure_candidate_valid:
        update_progress("Layer 1: Validation", 0.53, f"✓ VALID - Thrust err: {initial_thrust_error*100:.1f}%, O/F err: {initial_MR_error*100:.1f}%, Stability: {stability_state}")
        log_status("Layer 1", f"VALID | Thrust err {initial_thrust_error*100:.1f}%, O/F err {initial_MR_error*100:.1f}%, Stability {stability_state}")
        layer1_logger.info("✓ Validation: VALID")
    else:
        update_progress("Layer 1: Validation", 0.53, f"✗ INVALID - {'; '.join(failure_reasons)}")
        log_status("Layer 1", f"INVALID | Reasons: {', '.join(failure_reasons)}")
        layer1_logger.warning(f"✗ Validation: INVALID - {'; '.join(failure_reasons)}")
    
    # Build final performance dict
    final_performance = initial_performance.copy()
    final_performance["pressure_candidate_valid"] = pressure_candidate_valid
    final_performance["initial_thrust_error"] = initial_thrust_error
    final_performance["initial_MR_error"] = initial_MR_error
    final_performance["initial_stability"] = initial_stability
    final_performance["initial_stability_state"] = stability_state
    final_performance["initial_stability_score"] = stability_score
    final_performance["thrust_check_passed"] = thrust_check_passed
    final_performance["of_check_passed"] = of_check_passed
    final_performance["stability_check_passed"] = stability_check_passed
    final_performance["geometry_check_passed"] = geometry_check_passed
    final_performance["dp_gate_passed"] = dp_gate_passed
    final_performance["momentum_gate_passed"] = momentum_gate_passed
    final_performance["injector_dp_ratio_O"] = ratio_o_val if np.isfinite(ratio_o_val) else None
    final_performance["injector_dp_ratio_F"] = ratio_f_val if np.isfinite(ratio_f_val) else None
    final_performance["layer1_Lstar_search_min_m"] = float(min_Lstar)
    final_performance["layer1_Lstar_search_max_m"] = float(max_Lstar)
    final_performance["layer1_W_geom_ao_af_momentum_effective"] = float(layer1_W_geom_ao_af)
    try:
        if isinstance(requirements, dict):
            req_used = {
                str(k): requirements.get(k) for k in sorted(requirements.keys(), key=str)
            }
            req_used["W_geom_ao_af_momentum"] = float(layer1_W_geom_ao_af)
            final_performance["layer1_requirements_used"] = req_used
        else:
            final_performance["layer1_requirements_used"] = {}
    except Exception:
        final_performance["layer1_requirements_used"] = {}
    try:
        from engine.pipeline.config_schemas import ensure_chamber_geometry as _eg_lstar_diag
        _cgd = _eg_lstar_diag(optimized_config)
        _atd = float(_cgd.A_throat) if _cgd.A_throat else float("nan")
        _vold = float(_cgd.volume) if _cgd.volume is not None else float("nan")
        _lscd = float(_cgd.Lstar) if _cgd.Lstar is not None else float("nan")
        _dind = float(_cgd.chamber_diameter) if _cgd.chamber_diameter else float("nan")
        _acd = float(np.pi * (_dind / 2.0) ** 2) if np.isfinite(_dind) and _dind > 0 else float("nan")
        final_performance["layer1_geometry_Lstar_config_m"] = _lscd if np.isfinite(_lscd) else None
        final_performance["layer1_geometry_volume_over_At_m"] = (
            float(_vold / _atd) if np.isfinite(_vold) and np.isfinite(_atd) and _atd > 0 else None
        )
        final_performance["layer1_geometry_Ac_over_At"] = (
            float(_acd / _atd) if np.isfinite(_acd) and np.isfinite(_atd) and _atd > 0 else None
        )
        if np.isfinite(_vold) and np.isfinite(_atd) and _atd > 0 and np.isfinite(_lscd):
            final_performance["layer1_geometry_V_equals_Lstar_At"] = bool(
                np.isclose(_vold, _lscd * _atd, rtol=1e-4, atol=1e-8)
            )
    except Exception:
        pass
    if getattr(optimized_config.injector, "type", None) == "impinging":
        _diag_fp = final_performance.get("diagnostics", {}) if isinstance(final_performance, dict) else {}
        _diag_map = _diag_fp if isinstance(_diag_fp, dict) else {}
        try:
            _mr_fp_raw = float(final_performance.get("MR", np.nan))
        except (TypeError, ValueError):
            _mr_fp_raw = float("nan")
        _mr_fp = _mr_fp_raw if np.isfinite(_mr_fp_raw) and _mr_fp_raw > 0 else None
        _smd_term_fp, _smd_eff_um_fp, _imp_deg_fp = _impinging_smd_penalty_with_angle(
            _diag_map,
            target_smd_microns=layer1_target_smd_microns,
            smd_rel_tol=layer1_smd_rel_tol,
            mr_mass=_mr_fp,
        )
        # When SMD objective is disabled, report physical diagnostic SMD directly.
        if layer1_W_SMD <= 0.0:
            _do = float("nan")
            _df = float("nan")
            _v_o = _diag_map.get("D32_O")
            if _v_o is not None:
                try:
                    _fv_o = float(_v_o)
                except (TypeError, ValueError):
                    _fv_o = float("nan")
                if np.isfinite(_fv_o) and _fv_o > 0:
                    _do = _fv_o
            _v_f = _diag_map.get("D32_F")
            if _v_f is not None:
                try:
                    _fv_f = float(_v_f)
                except (TypeError, ValueError):
                    _fv_f = float("nan")
                if np.isfinite(_fv_f) and _fv_f > 0:
                    _df = _fv_f
            if np.isfinite(_do) and _do > 0 and np.isfinite(_df) and _df > 0:
                _mr_b = _mr_fp if _mr_fp is not None else 3.0
                _w_o = float(_mr_b / (1.0 + _mr_b))
                _w_f = float(1.0 / (1.0 + _mr_b))
                _smd_eff_um_fp = float((_w_o * _do + _w_f * _df) * 1e6)
            elif np.isfinite(_do) and _do > 0:
                _smd_eff_um_fp = float(_do * 1e6)
            elif np.isfinite(_df) and _df > 0:
                _smd_eff_um_fp = float(_df * 1e6)
        final_performance["effective_smd_microns"] = _smd_eff_um_fp if np.isfinite(_smd_eff_um_fp) else None
        final_performance["impingement_angle_deg_effective"] = _imp_deg_fp if np.isfinite(_imp_deg_fp) else None
        final_performance["smd_penalty"] = float(layer1_W_SMD * _smd_term_fp)
        for _gk in ("L_imp", "D_pitch_O", "D_pitch_F", "element_gap_O", "element_gap_F",
                    "vaporization_length_total"):
            _gv = _diag_map.get(_gk)
            try:
                _gvf = float(_gv) if _gv is not None else float("nan")
            except (TypeError, ValueError):
                _gvf = float("nan")
            final_performance[_gk] = _gvf if np.isfinite(_gvf) else None
    final_performance["failure_reasons"] = failure_reasons
    final_performance["layer1_warnings"] = list(layer1_warnings)
    # Add individual stability margins at root level for easy access
    final_performance["chugging_margin"] = chugging_margin
    final_performance["acoustic_margin"] = acoustic_margin
    final_performance["feed_margin"] = feed_margin
    
    # Tank pressures consistent with validated runner config (avoid ``best_x`` / snapshot mismatch).
    try:
        P_O_start_optimized_psi = float(optimized_config.lox_tank.initial_pressure_psi)
        P_F_start_optimized_psi = float(optimized_config.fuel_tank.initial_pressure_psi)
        final_performance["P_O_start_psi"] = P_O_start_optimized_psi
        final_performance["P_F_start_psi"] = P_F_start_optimized_psi
        final_performance["P_O_start_ratio"] = P_O_start_optimized_psi / max_lox_P_psi if max_lox_P_psi > 0 else 0.0
        final_performance["P_F_start_ratio"] = P_F_start_optimized_psi / max_fuel_P_psi if max_fuel_P_psi > 0 else 0.0
    except Exception:
        if best_x is not None and len(best_x) > idx_P_F:
            P_O_start_optimized_psi = float(np.clip(best_x[idx_P_O], bounds[idx_P_O][0], bounds[idx_P_O][1]))
            P_F_start_optimized_psi = float(np.clip(best_x[idx_P_F], bounds[idx_P_F][0], bounds[idx_P_F][1]))
            final_performance["P_O_start_psi"] = P_O_start_optimized_psi
            final_performance["P_F_start_psi"] = P_F_start_optimized_psi
            final_performance["P_O_start_ratio"] = P_O_start_optimized_psi / max_lox_P_psi if max_lox_P_psi > 0 else 0.0
            final_performance["P_F_start_ratio"] = P_F_start_optimized_psi / max_fuel_P_psi if max_fuel_P_psi > 0 else 0.0
        else:
            final_performance["P_O_start_psi"] = max_lox_P_psi * 0.8
            final_performance["P_F_start_psi"] = max_fuel_P_psi * 0.8
            final_performance["P_O_start_ratio"] = 0.8
            final_performance["P_F_start_ratio"] = 0.8
    
    # Add chamber_intrinsics from initial_performance (contains is_choked, etc.)
    if "chamber_intrinsics" in initial_performance:
        final_performance["chamber_intrinsics"] = initial_performance["chamber_intrinsics"]
    
    # Calculate and add effective_injector_area_ratio
    # This is the ratio of (effective injector area) / (throat area)
    # Effective injector area = max(A_lox_injector, A_fuel_injector) with Cd weighting
    try:
        from engine.pipeline.config_schemas import ensure_chamber_geometry
        cg = ensure_chamber_geometry(optimized_config)
        A_throat_final = float(cg.A_throat) if cg.A_throat and cg.A_throat > 0 else None
        
        inj = getattr(optimized_config, 'injector', None)
        inj_geom = getattr(inj, 'geometry', None) if inj else None
        is_pintle = getattr(inj, 'type', None) == 'pintle' if inj else False
        is_impinging = getattr(inj, 'type', None) == 'impinging' if inj else False
 
        if is_impinging and inj_geom and A_throat_final:
            ox = getattr(inj_geom, 'oxidizer', None)
            fu = getattr(inj_geom, 'fuel', None)
            if ox and fu:
                n_o = float(getattr(ox, 'n_elements', 0))
                d_o = float(getattr(ox, 'd_jet', 0))
                n_f = float(getattr(fu, 'n_elements', 0))
                d_f = float(getattr(fu, 'd_jet', 0))
                A_lox_g = n_o * np.pi * (d_o / 2.0) ** 2 if d_o > 0 else 0.0
                A_fuel_g = n_f * np.pi * (d_f / 2.0) ** 2 if d_f > 0 else 0.0
                diag_ev = initial_performance.get("diagnostics") or {}
                cd_o = diag_ev.get("Cd_O")
                cd_f = diag_ev.get("Cd_F")
                if (
                    cd_o is not None and np.isfinite(cd_o) and float(cd_o) > 0
                    and cd_f is not None and np.isfinite(cd_f) and float(cd_f) > 0
                ):
                    A_eff = float(cd_o) * A_lox_g + float(cd_f) * A_fuel_g
                else:
                    try:
                        from engine.core.discharge import cd_inf_from_orifice_diameter
 
                        oxg = getattr(inj_geom, "oxidizer", None)
                        fug = getattr(inj_geom, "fuel", None)
                        d_o = float(getattr(oxg, "d_jet", 0.002) or 0.002)
                        d_f = float(getattr(fug, "d_jet", 0.002) or 0.002)
                        Cd_lox = cd_inf_from_orifice_diameter(
                            d_o, optimized_config.discharge["oxidizer"]
                        )
                        Cd_fu = cd_inf_from_orifice_diameter(
                            d_f, optimized_config.discharge["fuel"]
                        )
                    except Exception:
                        Cd_lox, Cd_fu = 0.6, 0.6
                    A_eff = Cd_lox * A_lox_g + Cd_fu * A_fuel_g
                final_performance["effective_injector_area_ratio"] = float(A_eff / A_throat_final)
 
        if is_pintle and inj_geom and A_throat_final:
            # LOX injector area (discrete orifices)
            lox_geom = getattr(inj_geom, 'lox', None)
            fuel_geom = getattr(inj_geom, 'fuel', None)
            
            if lox_geom and fuel_geom:
                n_orifices = float(getattr(lox_geom, 'n_orifices', 0))
                d_orifice = float(getattr(lox_geom, 'd_orifice', 0))
                d_pintle_tip = float(getattr(fuel_geom, 'd_pintle_tip', 0))
                h_gap = float(getattr(fuel_geom, 'h_gap', 0))
                Cd_lox = float(getattr(lox_geom, 'Cd', 0.65))
                Cd_fuel = float(getattr(fuel_geom, 'Cd', 0.4))
                
                A_lox_injector = n_orifices * np.pi * (d_orifice / 2) ** 2 if d_orifice > 0 else 0.0
                R_inner = d_pintle_tip / 2
                R_outer = R_inner + h_gap
                A_fuel_injector = np.pi * (R_outer ** 2 - R_inner ** 2) if h_gap > 0 else 0.0
                
                # Effective areas (Cd-weighted geometric areas)
                A_lox_effective = Cd_lox * A_lox_injector
                A_fuel_effective = Cd_fuel * A_fuel_injector
                
                # Total effective injector area (sum of both propellants)
                A_injector_total_effective = A_lox_effective + A_fuel_effective
                
                # Ratio of total effective injector area to throat area
                effective_injector_area_ratio = A_injector_total_effective / A_throat_final
                final_performance["effective_injector_area_ratio"] = float(effective_injector_area_ratio)
    except Exception as e:
        layer1_logger.debug(f"Could not calculate effective_injector_area_ratio: {e}")
    
    _prim_rel = _layer1_primary_relative_metrics(
        final_performance,
        target_thrust=target_thrust,
        optimal_of=optimal_of,
        target_P_exit=target_P_exit,
    )
    # Build results dict
    results = {
        # Top-level injector_type tag so the UI dispatches result rendering to the right param set
        # (INJECTOR_PARITY_PLAN W4). optimized_parameters already carries type-appropriate keys.
        "injector_type": getattr(getattr(optimized_config, "injector", None), "type", None),
        "performance": final_performance,
        "iteration_history": iteration_history,
        "convergence_info": {
            "converged": opt_state["converged"],
            "iterations": len(iteration_history),
            "final_change": opt_state["best_objective"],
            "best_objective": float(opt_state.get("best_objective", float("inf"))),
            "best_objective_breakdown": (
                dict(opt_state.get("best_objective_breakdown", {}))
                if isinstance(opt_state.get("best_objective_breakdown", {}), dict)
                else {}
            ),
            "primary_relative_residual": _prim_rel,
            "infeasible_reason": infeasible_reason,
        },
        "exit_pressure_targeting": {
            "target_P_exit": target_P_exit,  # Atmospheric pressure from environment config (GPS/GFS-derived)
        },
        "optimized_pressure_curves": {
            "lox_end_ratio": final_lox_end_ratio,
            "fuel_end_ratio": final_fuel_end_ratio,
            "lox_start_psi": final_performance["P_O_start_psi"],
            "fuel_start_psi": final_performance["P_F_start_psi"],
        },
        "layer_status": {
            "layer_1_pressure_candidate": pressure_candidate_valid,
        },
        "optimized_parameters": extract_all_parameters(optimized_config),
        "final_rebuild_diag": opt_state.get("final_rebuild_diag"),
    }
    
    # Final summary logging
    layer1_logger.info("")
    layer1_logger.info("="*70)
    layer1_logger.info("Final Results Summary")
    layer1_logger.info("="*70)
    if "best_results_for_validation" in opt_state and opt_state["best_results_for_validation"] is not None:
        stored = opt_state["best_results_for_validation"]
        layer1_logger.info(f"Thrust: {stored.get('F', 0):.1f} N (target: {target_thrust:.1f} N)")
        layer1_logger.info(f"Thrust error: {stored.get('thrust_error', 0)*100:.2f}%")
        layer1_logger.info(f"O/F ratio: {stored.get('MR', 0):.3f} (target: {optimal_of:.3f})")
        layer1_logger.info(f"O/F error: {stored.get('of_error', 0)*100:.2f}%")
        layer1_logger.info(f"Stability state: {stored.get('stability_state', 'unknown')}")
        layer1_logger.info(f"Stability score: {stored.get('stability_score', 0):.3f}")
        layer1_logger.info(f"Chugging margin: {stored.get('chugging_margin', 0):.3f}")
        layer1_logger.info(f"Acoustic margin: {stored.get('acoustic_margin', 0):.3f}")
        layer1_logger.info(f"Feed margin: {stored.get('feed_margin', 0):.3f}")
    if final_performance.get("P_O_start_psi") is not None:
        layer1_logger.info(f"LOX initial pressure: {final_performance['P_O_start_psi']:.1f} psi")
    if final_performance.get("P_F_start_psi") is not None:
        layer1_logger.info(f"Fuel initial pressure: {final_performance['P_F_start_psi']:.1f} psi")
    _idr_o = final_performance.get("injector_dp_ratio_O")
    _idr_f = final_performance.get("injector_dp_ratio_F")
    _idp = final_performance.get("injector_dp_penalty")
    if _idr_o is not None and np.isfinite(_idr_o):
        layer1_logger.info(f"Injector ΔP/Pc (LOX): {_idr_o:.4f}")
    if _idr_f is not None and np.isfinite(_idr_f):
        layer1_logger.info(f"Injector ΔP/Pc (fuel): {_idr_f:.4f}")
    if _idp is not None and np.isfinite(_idp):
        layer1_logger.info(f"Injector ΔP ratio penalty (weighted): {float(_idp):.6g}")
    if (
        getattr(getattr(optimized_config, "injector", None), "type", None) == "impinging"
        and final_performance.get("momentum_ratio_R") is not None
    ):
        layer1_logger.info(
            f"Impinging jet momentum ratio R: {final_performance['momentum_ratio_R']:.3f} "
            f"(sqrt momentum-flux ratio; target ~1.0)"
        )
        mbp = final_performance.get("momentum_balance_penalty")
        if mbp is not None and np.isfinite(mbp):
            layer1_logger.info(
                f"Impinging momentum-balance penalty (W_MOM × hinge): {float(mbp):.6g}"
            )
    layer1_logger.info(f"Validation: {'VALID' if pressure_candidate_valid else 'INVALID'}")
 
    _primary_terms = _layer1_final_primary_objective_terms(
        final_performance,
        thrust_deadband_rel=_layer1_thrust_deadband(requirements),
        target_thrust=target_thrust,
        optimal_of=optimal_of,
        target_P_exit=target_P_exit,
        layer1_exit_pressure_inside_quad_scale=layer1_exit_pressure_inside_quad,
        layer1_w_dp=layer1_W_DP,
        layer1_w_dp_o=layer1_W_DP_O,
        layer1_w_dp_f=layer1_W_DP_F,
        injector_dp_o_band=layer1_dp_o_band,
        injector_dp_f_band=layer1_dp_f_band,
        injector_dp_o_soft_floor=layer1_dp_o_soft_floor,
        layer1_w_dp_o_floor=layer1_W_DP_O_FLOOR,
        layer1_w_dp_center=layer1_W_DP_CENTER,
        layer1_w_thrust=layer1_W_THRUST_obj,
        layer1_w_of=layer1_W_OF_obj,
        layer1_w_of_low_mr_scale=layer1_W_OF_low_MR_scale,
        layer1_w_of_high_mr_scale=layer1_W_OF_high_MR_scale,
    )
    layer1_logger.info("")
    layer1_logger.info(
        "Final evaluate — primary objective penalty contributions "
        "(W_THRUST/W_OF/W_EXIT × terms + injector_dp weighted; same structure as scalar objective)"
    )
    layer1_logger.info(
        f"  • Thrust penalty contribution: {_primary_terms['thrust_penalty_contribution']:.6f}"
    )
    layer1_logger.info(
        f"  • O/F penalty contribution: {_primary_terms['of_penalty_contribution']:.6f}"
    )
    layer1_logger.info(
        f"  • Exit pressure penalty contribution: {_primary_terms['exit_pressure_penalty_contribution']:.6f}"
    )
    layer1_logger.info(
        f"  • Injector ΔP penalty contribution: {_primary_terms['injector_dp_penalty_contribution']:.6f}"
    )
    layer1_logger.info(
        "  • Primary relative |ΔF|/F, |ΔMR|/MR, |ΔP_exit|/P_tgt: "
        f"{_prim_rel['rel_thrust']:.4g}, {_prim_rel['rel_of']:.4g}, {_prim_rel['rel_P_exit']:.4g} "
        f"(RMS={_prim_rel['rms_primary']:.4g}, dimensionless; not the weighted scalar)"
    )
    if final_performance.get("injector_dp_out_of_range"):
        layer1_logger.warning(
            "  injector_dp_out_of_range: True (one or both ΔP_inj/Pc streams exceed 0.50)"
        )
 
    # Log objective function breakdown if objective > 1e0 (indicates non-ideal convergence)
    best_obj_value = opt_state.get("best_objective", float('inf'))
    if best_obj_value > 1.0:
        layer1_logger.info("")
        layer1_logger.info("-"*70)
        layer1_logger.info(f"⚠ Objective Function Breakdown (objective = {best_obj_value:.6f} > 1.0)")
        layer1_logger.info("-"*70)
        breakdown = opt_state.get("best_objective_breakdown", {})
        if breakdown:
            if breakdown.get("is_infeasible", False):
                layer1_logger.info("Solution is INFEASIBLE:")
                if breakdown.get("length_violation", False):
                    layer1_logger.info(f"  • Chamber length violation penalty: {breakdown.get('infeasibility_penalty', 0):.6f}")
                else:
                    layer1_logger.info(f"  • Infeasibility penalty (constraints violated): {breakdown.get('infeasibility_penalty', 0):.6f}")
            else:
                layer1_logger.info("Objective component contributions:")
                components = [
                    ("Thrust penalty", breakdown.get("thrust_penalty", 0)),
                    ("O/F ratio penalty", breakdown.get("of_penalty", 0)),
                    ("Cf band penalty", breakdown.get("cf_penalty", 0)),
                    ("Exit pressure penalty", breakdown.get("exit_pressure_penalty", 0)),
                    ("Injector ΔP penalty", breakdown.get("injector_dp_penalty", 0)),
                    ("Chamber length penalty", breakdown.get("length_penalty", 0)),
                    ("Chamber shape penalty", breakdown.get("chamber_shape_penalty", 0)),
                    ("Momentum balance penalty", breakdown.get("momentum_balance_penalty", 0)),
                    ("Impingement angle penalty", breakdown.get("impingement_angle_penalty", 0)),
                    ("Jet asymmetry penalty", breakdown.get("jet_angle_asymmetry_penalty", 0)),
                    ("SMD penalty", breakdown.get("smd_penalty", 0)),
                    ("Geometry fit penalty", breakdown.get("impinging_geometry_fit_penalty", 0)),
                    ("AO/AF momentum hint", breakdown.get("geom_ao_af_momentum_penalty", 0)),
                    ("Tank equal penalty", breakdown.get("tank_pressure_equal_penalty", 0)),
                ]
                # Sort by value descending
                components.sort(key=lambda x: x[1], reverse=True)
                total = sum(c[1] for c in components)
                for name, value in components:
                    if value > 0 or total > 0:
                        pct = (value / total * 100) if total > 0 else 0.0
                        layer1_logger.info(f"  • {name}: {value:.6f} ({pct:.1f}%)")
                layer1_logger.info(f"  Total: {total:.6f}")
        else:
            layer1_logger.info("  (component breakdown not available)")
        layer1_logger.info("-"*70)
    
    layer1_logger.info("="*70)
    layer1_logger.info("")
    layer1_logger.info(f"Layer 1 optimization complete. Log saved to: {log_file_path}")
    
    # Clean up handler to prevent file handle issues
    layer1_logger.handlers.clear()
    
    update_progress("Layer 1: Complete", 1.0, "Layer 1 optimization complete!")
 
    # Stamp the ACHIEVED operating point onto the config we are about to hand back, so
    # chamber_geometry.design_* describes this engine rather than whatever template it came from.
    _layer1_stamp_design_point(optimized_config, final_performance, layer1_logger)
    _layer1_warn_stale_pressure_curves(optimized_config, layer1_logger)
 
    return optimized_config, results
 
 
class ElitePool:
    """Manages a pool of top-K elite solutions."""
    def __init__(self, k: int = 50):
        self.k = k
        self.points = []  # List of tuples (f_val, x_array)
 
    def add(self, x: np.ndarray, f: float):
        """Add a candidate to the pool if it's good enough."""
        # Check for duplicates (optional, simple distance check or exact match)
        # For simplicity in this iteration, just naive add & sort
        self.points.append((f, np.asarray(x, dtype=float).copy()))
        # Sort by f (ascending, minimization)
        self.points.sort(key=lambda item: item[0])
        # Keep top k
        if len(self.points) > self.k:
            self.points = self.points[:self.k]
 
    def get_elites(self) -> Tuple[np.ndarray, np.ndarray]:
        """Return (X, F) arrays of current elites."""
        if not self.points:
            return np.array([]), np.array([])
        f_vals = np.array([p[0] for p in self.points])
        x_vals = np.array([p[1] for p in self.points])
        return x_vals, f_vals
 
    def get_best(self) -> Tuple[np.ndarray, float]:
        """Return best solution found so far."""
        if not self.points:
            return None, float('inf')
        return self.points[0][1], self.points[0][0]
 
 
def run_cma_core(
    objective_fn: Callable[[np.ndarray], float],
    x0: np.ndarray,
    sigma0: float,
    bounds: list,
    budget: int,
    popsize: int,
    cma_stds: np.ndarray = None,
    seed: int = None,
    elite_pool: Optional[ElitePool] = None,
    # Optional logic for penalty/validity
    true_objective_fn: Optional[Callable[[np.ndarray], float]] = None,
    valley_escape_tracker: Optional[Dict[str, Any]] = None,
    logger = None,
    # Parallel evaluation support
    executor: Optional[ProcessPoolExecutor] = None,
    integer_dims: Optional[list] = None,
    od_index: int = -1,
    od_step_m: float = 0.0,
    fixed_variables: Optional[Dict[int, float]] = None,
    eval_cache: Optional[dict] = None,
    make_cache_key_fn: Optional[Callable[[np.ndarray], Tuple[int, ...]]] = None,
    stop_event: Optional[Any] = None,  # threading.Event for stop signal
    embed_base: Optional[np.ndarray] = None,
    embed_idx: Optional[List[int]] = None,
    full_objective_fn: Optional[Callable[[np.ndarray], float]] = None,
) -> Tuple[np.ndarray, float, int]:
    """
    Core re-usable CMA-ES wrapper with optional parallel evaluation.
 
    ``embed_base``/``embed_idx``: the search is over a sub-vector (a block); each candidate is
    written into a copy of ``embed_base`` at ``embed_idx`` and the FULL vector is scored by the
    worker pool, so a block ranks on the same objective as Stage A. ``full_objective_fn`` is
    the full-vector parent objective used for best-tracking sync.
    
    Args:
        objective_fn: The function CMA-ES optimizes (could include penalties).
        x0: Initial mean.
        sigma0: Initial step size.
        bounds: List of (min, max) for EACH dimension.
        budget: Max function evaluations.
        popsize: Population size.
        cma_stds: Coordinate-wise standard deviations (optional scaling).
        seed: Random seed.
        elite_pool: Optional pool to capture all candidates evaluated.
        true_objective_fn: If provided, used to evaluate candidates for ElitePool 
                           and best-so-far tracking (ignoring the penalized objective).
                           If None, objective_fn is used.
        executor: Optional ProcessPoolExecutor for parallel evaluation.
        integer_dims: List of integer dimension indices for snapping.
        eval_cache: Optional evaluation cache dict.
                           
    Returns:
        (best_x, best_f, evals_used)
        Note: best_f returned is the one derived from true_objective_fn if present,
        otherwise objective_fn.
    """
    if cma is None:
        raise ImportError("CMA-ES required")
    
    # Prepare bounds for CMA
    lower_bounds = np.array([b[0] for b in bounds])
    upper_bounds = np.array([b[1] for b in bounds])
    
    # Options
    opts = {
        "bounds": [lower_bounds.tolist(), upper_bounds.tolist()],
        "popsize": popsize,
        "maxiter": budget, # Rough upper bound, we track evals manually better
        "verb_disp": 0,
        "verb_log": 0,
        "tolx": 1e-8,
        "tolfun": 1e-9,
        "tolstagnation": 50,
        "ftarget": -np.inf,
        "seed": seed,
    }
    if cma_stds is not None:
        opts["CMA_stds"] = cma_stds.tolist()
    # Discrete DOFs: integer centering + a std floor so a coordinate cannot collapse
    # inside one cell and freeze. See _layer1_cma_discrete_options.
    _int_vars, _minstd = _layer1_cma_discrete_options(
        len(x0), integer_dims, od_index=od_index, od_step_m=od_step_m, bounds=bounds)
    if _int_vars:
        opts["integer_variables"] = _int_vars
    if any(v > 0.0 for v in _minstd):
        opts["minstd"] = _minstd
    # Derived dims: keep FULL bounds (so no clip anywhere can revert the solved value) and
    # simply shrink CMA's step so it spends no meaningful search effort on them. cma's own
    # ``fixed_variables`` would be the natural tool, but it re-indexes the search space and
    # then collides with ``integer_variables``, whose indices are in the full space.
    if fixed_variables and cma_stds is not None and len(x0) == len(bounds):
        _st = list(opts.get("CMA_stds") or cma_stds.tolist())
        for _k in fixed_variables:
            _k = int(_k)
            if 0 <= _k < len(_st):
                _st[_k] = max(1e-12, float(_st[_k]) * 1e-6)
        opts["CMA_stds"] = _st
 
    # Initialize
    # Ensure x0 is within bounds
    x0_clamped = np.clip(x0, lower_bounds, upper_bounds)
    
    evals = 0
    best_x = x0_clamped.copy()
    
    # Initial eval (through the pool when embedded, so every value compared below is scored
    # the same way)
    if executor is not None and embed_base is not None and embed_idx is not None:
        _full0 = np.asarray(embed_base, dtype=np.float64).copy()
        _full0[list(embed_idx)] = _snap_integer_dims(best_x.astype(np.float64), integer_dims or [])
        best_f = float(list(executor.map(_eval_candidate, [_full0]))[0].get("value", float("inf")))
    elif true_objective_fn:
        best_f = true_objective_fn(best_x)
    else:
        best_f = objective_fn(best_x)
 
    # CMA object
    # CMA expects list for x0
    es = cma.CMAEvolutionStrategy(x0_clamped.tolist(), sigma0, opts)
    
    stop_loop = False
    
    while not es.stop() and not stop_loop:
        # Check if optimization should stop
        if stop_event is not None and stop_event.is_set():
            raise RuntimeError("Optimization stopped by user")
        
        if evals >= budget:
            break
            
        # Check for Valley Escape boost if tracker provided
        if valley_escape_tracker is not None:
            evals_now = valley_escape_tracker.get("function_evaluations", 0)
            best_f_tracker = valley_escape_tracker.get("best_objective", float('inf'))
            last_best = valley_escape_tracker.get("last_best_eval", 0)
            stagnation = evals_now - last_best
            current_tier = valley_escape_tracker.get("valley_escape_tier", 0)
            cooldown = valley_escape_tracker.get("cooldown_until", 0)
            
            target_tier = _layer1_valley_escape_tier(evals_now, best_f_tracker, stagnation)
            
            if target_tier > current_tier and evals_now > cooldown:
                # Apply boost
                boost_factors = [1.0, 2.0, 4.0, 8.0]
                relative_boost = boost_factors[target_tier] / boost_factors[current_tier]
                
                old_sigma = es.sigma
                es.sigma *= relative_boost
                
                # Clamp sigma to 50% of the entire span (much looser)
                # We want to allow large jumps if needed to escape deep local minima
                span_vals = upper_bounds - lower_bounds
                max_sigma = 0.5 * float(np.max(span_vals))
                if es.sigma > max_sigma:
                    es.sigma = max_sigma
                
                # Update tracker
                valley_escape_tracker["valley_escape_tier"] = target_tier
                valley_escape_tracker["cooldown_until"] = evals_now + 1000
                
                if logger:
                    tier_names = ["None", "Mild", "Medium", "Full"]
                    logger.info("!" * 20)
                    logger.info(f"VALLEY ESCAPE TRIGGERED in run_cma_core (Tier: {tier_names[target_tier]})")
                    logger.info(f"Evals: {evals_now}, Best: {best_f_tracker:.2f}, Stagnation: {stagnation}")
                    logger.info(f"Sigma: {old_sigma:.6f} -> {es.sigma:.6f} (Boost: {relative_boost:.2f}x)")
                    logger.info("!" * 20)
 
        candidates = es.ask()
        
        # PARALLEL EVALUATION PATH
        if executor is not None and integer_dims is not None:
            # Snap integer dimensions for consistency
            candidates_snapped = [
                _snap_integer_dims(np.asarray(c, dtype=np.float64), integer_dims)
                for c in candidates
            ]
            if embed_base is not None and embed_idx is not None:
                _sub = candidates_snapped
                candidates_snapped = []
                for c in _sub:
                    _full = np.asarray(embed_base, dtype=np.float64).copy()
                    _full[list(embed_idx)] = c
                    candidates_snapped.append(_full)
 
            def _out(v):
                # What CMA and the caller see: the block sub-vector when embedded.
                v = np.asarray(v, dtype=float)
                return v[list(embed_idx)].copy() if (embed_base is not None and embed_idx is not None) else v
            
            # Parent-side caching if cache provided
            if eval_cache is not None and make_cache_key_fn is not None:
                cache_keys = [make_cache_key_fn(c) for c in candidates_snapped]
                uncached_indices = []
                uncached_candidates = []
                fitness_values = [None] * len(candidates)
                
                for i, key in enumerate(cache_keys):
                    if key in eval_cache:
                        cached_val = eval_cache[key]
                        # Handle dict format from parallel eval (has 'value' key)
                        # Note: dict format from objective() has 'results' but not 'value', so we can't use it here
                        if isinstance(cached_val, dict) and 'value' in cached_val:
                            fitness_values[i] = float(cached_val['value'])
                        elif isinstance(cached_val, (int, float)):
                            # Old format: direct float value (backward compatibility)
                            fitness_values[i] = float(cached_val)
                        else:
                            # Full format from objective() or unknown format - can't extract value, treat as uncached
                            uncached_indices.append(i)
                            uncached_candidates.append(candidates_snapped[i])
                    else:
                        uncached_indices.append(i)
                        uncached_candidates.append(candidates_snapped[i])
                
                # Parallel evaluation of uncached candidates
                if uncached_candidates:
                    num_workers = executor._max_workers
                    chunksize = max(1, len(uncached_candidates) // (num_workers * 4))
                    results = list(executor.map(_eval_candidate, uncached_candidates, chunksize=chunksize))
                    
                    # Merge results back
                    for idx, res in zip(uncached_indices, results):
                        obj_val = res['value']
                        fitness_values[idx] = obj_val
                        # Store in dict format for compatibility with objective() cache format
                        eval_cache[cache_keys[idx]] = {
                            'value': obj_val,
                            'success': res.get('success', True),
                        }
                        evals += 1
                        _store_last_good_eval_bundle_from_worker_res(res, valley_escape_tracker)
                        
                        # Update best and elite pool using true objective
                        if res['success']:
                            # For hybrid mode, we use the same objective for both
                            # (true_objective_fn is typically None in hybrid mode)
                            if obj_val < best_f:
                                best_f = obj_val
                                # The SOLVED vector, not the proposal. The derived DOFs
                                # (A_throat, expansion ratio, fuel ring pitch) sit on
                                # collapsed bounds, so what CMA proposed for them is the
                                # seed -- the values that were actually SCORED come back in
                                # x_solved. Recording the proposal meant the reported design
                                # carried the seed throat: measured, A_throat was handed in
                                # at 1568 mm2 every time, solved across 1190-4000 mm2, and
                                # the final design still reported ~1556 mm2.
                                best_x = _out(_x_solved_or(res, candidates_snapped[idx]))
                            
                            if elite_pool:
                                elite_pool.add(candidates_snapped[idx], obj_val)
                        
                        if evals >= budget:
                            stop_loop = True
                
                # Count cached evals
                for i, val in enumerate(fitness_values):
                    if val is not None and i not in uncached_indices:
                        evals += 1  # Count cache hits as evals for budget tracking
            else:
                # No caching - evaluate all in parallel
                num_workers = executor._max_workers
                chunksize = max(1, len(candidates_snapped) // (num_workers * 4))
                results = list(executor.map(_eval_candidate, candidates_snapped, chunksize=chunksize))
                
                fitness_values = []
                for i, res in enumerate(results):
                    obj_val = res['value']
                    fitness_values.append(obj_val)
                    evals += 1
                    _store_last_good_eval_bundle_from_worker_res(res, valley_escape_tracker)
                    
                    if res['success']:
                        if obj_val < best_f:
                            best_f = obj_val
                            best_x = _out(_x_solved_or(res, candidates_snapped[i]))
                        
                        if elite_pool:
                            elite_pool.add(candidates_snapped[i], obj_val)
                    
                    if evals >= budget:
                        stop_loop = True
 
            # Parent-side sync: parallel workers only return scalars; record rich history on new global best.
            if valley_escape_tracker is not None and fitness_values:
                _fv = [
                    float(v) if v is not None and np.isfinite(float(v)) else float("inf")
                    for v in fitness_values
                ]
                if _fv and min(_fv) < float("inf"):
                    _gen_best = float(min(_fv))
                    _gi = int(np.argmin(np.asarray(_fv, dtype=float)))
                    _layer1_sync_best_from_worker_eval(
                        valley_escape_tracker,
                        candidates_snapped[_gi],
                        _gen_best,
                        parent_objective=(full_objective_fn if full_objective_fn is not None
                                          else objective_fn),
                    )
        else:
            # SEQUENTIAL EVALUATION PATH (original code)
            fitness_values = []
            
            for cand in candidates:
                # Clip candidate for evaluation
                cand_arr = np.clip(np.asarray(cand, dtype=float), lower_bounds, upper_bounds)
                
                # 1. Penalized objective (for CMA ranking)
                val_penalized = objective_fn(cand_arr)
                fitness_values.append(val_penalized)
                evals += 1
                
                # 2. True objective (for elites / best tracking)
                if true_objective_fn:
                    val_true = true_objective_fn(cand_arr)
                else:
                    val_true = val_penalized
                    
                # Update local best using TRUE value
                if val_true < best_f:
                    best_f = val_true
                    best_x = cand_arr.copy()
                    
                # Add to elite pool
                if elite_pool:
                    elite_pool.add(cand_arr, val_true)
                
                if evals >= budget:
                    stop_loop = True
                    
        es.tell(candidates, fitness_values)
        
    return best_x, best_f, evals
 
 
 
def _layer1_iso_area_count_scan(
    x: np.ndarray,
    f: float,
    bounds: list,
    executor: Any,
    integer_dims: list,
    iso_area: Tuple[int, Tuple[int, ...], Tuple[int, ...]],
    logger=None,
    eval_cache: Optional[dict] = None,
    make_cache_key_fn: Optional[Callable[[np.ndarray], Any]] = None,
) -> Tuple[np.ndarray, float, int]:
    """Exhaustive search over the element count along the iso-area path.
 
    ``iso_area = (i_n, (i_d, ...), (i_s, ...))``: moving the count n -> n' at fixed jet
    diameters changes the injector flow area by n'/n, so every neighbouring count is a
    different injector (dP, O/F, Pc all move) and CMA, stepping one integer at a time, rarely
    crosses between them -- four seeds ended at n = 5, 5, 7 and 13 with objectives 20 % apart.
    Scaling d by sqrt(n/n') and the hole pitch by n/n' keeps the flow areas and both pitch
    circles, so each count is scored as the same injector re-divided. Every reachable count
    is evaluated through the pool (one parallel batch per round); the best improvement is
    taken and the scan repeats from it.
    """
    i_n, i_d, i_s = iso_area
    lo_n = int(np.ceil(float(bounds[i_n][0]) - 1e-9))
    hi_n = int(np.floor(float(bounds[i_n][1]) + 1e-9))
    if executor is None or hi_n <= lo_n:
        return x, f, 0
    best_x = np.asarray(x, dtype=float).copy()
    best_f = float(f)
    evals = 0
    for _ in range(4):
        n0 = int(round(best_x[i_n]))
        cands = []
        for n in range(lo_n, hi_n + 1):
            if n == n0:
                continue
            c = best_x.copy()
            c[i_n] = float(n)
            for i in i_d:
                c[i] = c[i] * np.sqrt(n0 / n)
            for i in i_s:
                c[i] = c[i] * n0 / n
            if all(bounds[i][0] <= c[i] <= bounds[i][1] for i in (*i_d, *i_s)):
                cands.append(_snap_integer_dims(c, integer_dims))
        if not cands:
            break
        results = list(executor.map(_eval_candidate, cands))
        evals += len(results)
        vals = [float(r["value"]) if r.get("success") else float("inf") for r in results]
        k = int(np.argmin(vals))
        if eval_cache is not None and make_cache_key_fn is not None:
            for c, r in zip(cands, results):
                eval_cache[make_cache_key_fn(c)] = {"value": r["value"], "success": r.get("success", True)}
        if not (vals[k] < best_f):
            break
        if logger:
            logger.info("Element-count scan: n %d -> %d (iso-area), f %.5f -> %.5f",
                        n0, int(round(cands[k][i_n])), best_f, vals[k])
        best_f = vals[k]
        best_x = _x_solved_or(results[k], cands[k])
    return best_x, best_f, evals
 
 
def compute_blocks_from_elites(
    elite_pool: ElitePool,
    num_blocks: int,
    dim: int,
    method: str = "random",
    overlap_fraction: float = 0.0,
    rng: np.random.Generator = None,
) -> list[list[int]]:
    """
    Compute variable blocks for re-optimization.
    
    Methods:
    - "random": Randomly partition variables.
    - "corr_greedy": Use correlation matrix of standardized elites. 
      Distance = 1 - abs(Correlation).
    """
    if rng is None:
        rng = np.random.default_rng()
        
    all_indices = np.arange(dim)
    
    if method == "corr_greedy" and len(elite_pool.points) > dim + 2:
        # 1. Get elites X (size K x dim)
        X_raw, _ = elite_pool.get_elites()
        
        # 2. Standardize X (zero mean, unit variance) to avoid scale bias
        # Handle zero variance dimensions safely
        stds = np.std(X_raw, axis=0)
        valid_dims = stds > 1e-12
        X_std = np.zeros_like(X_raw)
        X_std[:, valid_dims] = (X_raw[:, valid_dims] - np.mean(X_raw[:, valid_dims], axis=0)) / stds[valid_dims]
        
        # 3. Compute correlation matrix (not covariance!)
        # Shape (dim, dim)
        if len(X_std) > 1:
            corr_mat = np.corrcoef(X_std, rowvar=False)
            # Handle NaNs if they appear (e.g. constant columns)
            corr_mat = np.nan_to_num(corr_mat, nan=0.0)
        else:
            # Fallback if not enough points
            corr_mat = np.eye(dim)
            
        # 4. Computed distance metric: d_ij = 1 - abs(corr_ij)
        dist_mat = 1.0 - np.abs(corr_mat)
        
        # 5. Greedy clustering
        # Start with unassigned, pick one, add nearest neighbors until block filled
        unassigned = set(all_indices)
        blocks = []
        target_block_size = int(np.ceil(dim / num_blocks))
        
        while unassigned:
            if len(blocks) == num_blocks - 1:
                # Last block takes all remaining
                blocks.append(list(unassigned))
                break
                
            # Pick seed (random or first available)
            seed = list(unassigned)[0]
            current_block = [seed]
            unassigned.remove(seed)
            
            # Add N nearest neighbors
            while len(current_block) < target_block_size and unassigned:
                # Find nearest to *any* in current block? Or centroid?
                # Simple: nearest to seed or mean distance to block
                # Let's do min-average-distance to current block
                candidates = list(unassigned)
                
                # Compute avg dist to current block for each candidate
                # dist_mat[c, current_block]
                avg_dists = [np.mean(dist_mat[c, current_block]) for c in candidates]
                best_cand_idx = np.argmin(avg_dists)
                best_cand = candidates[best_cand_idx]
                
                current_block.append(best_cand)
                unassigned.remove(best_cand)
                
            blocks.append(current_block)
        
        # If we have overlap
        if overlap_fraction > 0:
            # Overlap implementation:
            # Start each block with 'overlap' amount of indices from the previous block
            # This logic modifies the 'blocks' list we just created.
            # However simple partition-based generation above doesn't support overlap naturally.
            # Let's refine: The greedy approach above created partition.
            # To add overlap: Append N items from block[i-1] to block[i]
            # EXCEPT for first block.
            
            # Note: This increases total size, so "target_block_size" in previous step was for partition.
            overlap_count = int(np.ceil(target_block_size * overlap_fraction))
            if overlap_count > 0:
                for i in range(1, len(blocks)):
                    # Get overlap candidates from previous block (random or specific?)
                    # Random is safest to avoid bias
                    prev_block = blocks[i-1]
                    if len(prev_block) > 0:
                        overlap_indices = rng.choice(prev_block, size=min(len(prev_block), overlap_count), replace=False)
                        # Add to current
                        blocks[i].extend(overlap_indices)
                        # Uniquify just in case
                        blocks[i] = list(set(blocks[i]))
            
        return blocks
    else:
        # Fallback to random
        perm = rng.permutation(dim)
        # Split into ~equal chunks
        blocks = [list(a) for a in np.array_split(perm, num_blocks)]
        return blocks
 
 
def run_hybrid_optimization(
    objective: Callable[[np.ndarray], float],
    bounds: list,
    x0: np.ndarray,
    hybrid_config: HybridOptimizerConfig,
    total_budget: int = 3000,
    logger = None,
    log_status_fn = None, 
    update_progress_fn = None,
    valley_escape_tracker: Optional[Dict[str, Any]] = None,
    # Parallel evaluation support
    executor: Optional[ProcessPoolExecutor] = None,
    integer_dims: Optional[list] = None,
    od_index: int = -1,
    od_step_m: float = 0.0,
    fixed_variables: Optional[Dict[int, float]] = None,
    eval_cache: Optional[dict] = None,
    make_cache_key_fn: Optional[Callable[[np.ndarray], Tuple[int, ...]]] = None,
    stop_event: Optional[Any] = None,  # threading.Event for stop signal
    seed: Optional[int] = None,
    popsize: int = 16,
    iso_area: Optional[Tuple[int, Tuple[int, ...], Tuple[int, ...]]] = None,
) -> Tuple[np.ndarray, float, int]:
    """
    Run Hybrid CMA-ES + Block Re-optimization.
 
    ``iso_area`` (impinging): after Stage A and before every refresh, every element count is
    scored along the iso-area path (see _layer1_iso_area_count_scan) and the best is taken.
 
    ``seed`` makes the whole search a deterministic function of its inputs. It was not:
    this function built ``np.random.default_rng()`` with no seed and called ``run_cma_core``
    without ``seed=`` in Stage A, in every block and in every refresh, so CMA seeded itself
    from the clock. ``layer1_random_seed`` reached the warm start and nothing after it --
    measured, three runs of one config at seed 37 gave three different injectors (included
    angle 89 / 87 / 83 deg). Every ``run_cma_core`` call below now takes a seed derived from
    this one, distinct per stage so no two stages replay the same sample stream.
 
    ``popsize`` is the Stage A / refresh population. It was hardcoded to 16 while the caller
    computed and logged 48; the block stage keeps its own smaller population.
    
    Logic:
    1. Stage A: Global Exploration (Standard CMA-ES)
    2. Loop Cycles:
       a. Stage B: Build Blocks (Random or Correlation-based)
       b. Stage C: Block Re-optimization (Soft freezing)
    3. Stage D: Global Refresh (Periodic)
    
    Args:
        objective: Main objective function (returns float).
        bounds: List of (min, max).
        x0: Initial guess.
        hybrid_config: Configuration.
        total_budget: Max evals.
        
    Returns:
        (best_x, best_f, total_evals)
    """
    evals_used = 0
    dim = len(x0)
    
    # Setup constraints/bounds arrays
    lower_bounds = np.array([b[0] for b in bounds])
    upper_bounds = np.array([b[1] for b in bounds])
    span = upper_bounds - lower_bounds
    
    # 1. Initialize Elite Pool
    elite_pool = ElitePool(k=hybrid_config.elite_k)
 
    # One generator for everything this function samples (Stage A kick, block partition),
    # and one derived CMA seed per stage. ``None`` keeps the old fresh-entropy behaviour.
    rng = np.random.default_rng(seed)
 
    def _sub_seed(k: int) -> Optional[int]:
        return None if seed is None else int((int(seed) + k * 1_000_003) % (2 ** 31))
    
    # 2. Budget allocation
    # Reserve slice for Stage A
    # The rest is split among cycles
    stage_a_budget = int(total_budget * (1.0 - hybrid_config.per_block_budget_fraction))
    block_budget_total = total_budget - stage_a_budget
    
    if hybrid_config.cycles > 0 and hybrid_config.num_blocks > 0:
        per_cycle_budget = block_budget_total // hybrid_config.cycles
        if hybrid_config.refresh_every_pass:
             # Subtract refresh budget from per-cycle
             refresh_cost = int(total_budget * hybrid_config.refresh_budget_fraction)
             per_cycle_budget = max(0, per_cycle_budget - refresh_cost)
    else:
        per_cycle_budget = 0
        
    # --- STAGE A: Global Exploration (CMA-ES) ---
    if update_progress_fn: update_progress_fn("Hybrid: Stage A", 0.1, "Global Exploration")
    if logger: logger.info(f"Stage A: Global Search (Budget: {stage_a_budget})")
    
    # Setup CMA stds
    sigma0 = 0.25 * float(np.percentile(span, 25)) # Heuristic 25% of 25th percentile span
    cma_stds = span / (4.0 * sigma0) # Normalize so sigma*std roughly covers range
    
    # We use a randomized restart wrapper for Stage A to ensure good coverage
    # But for simplicity we call run_cma_core once with restart logic INTERNAL if we wanted,
    # but run_cma_core is single run.
    # Let's do 2 quick restarts in Stage A budget if budget allows
    
    best_x_global = x0.copy()
    valid_f = objective(best_x_global)
    elite_pool.add(best_x_global, valid_f)
    best_f_global = valid_f
    
    # Split Stage A budget into 2 restarts
    budget_a1 = int(stage_a_budget * 0.6)
    budget_a2 = stage_a_budget - budget_a1
 
    # Run 1
    x_res, f_res, evs = run_cma_core(
        objective, x0, sigma0, bounds, budget_a1,
        popsize=popsize, cma_stds=cma_stds, elite_pool=elite_pool, seed=_sub_seed(1),
        valley_escape_tracker=valley_escape_tracker, logger=logger,
        # Parallel evaluation
        executor=executor, integer_dims=integer_dims, eval_cache=eval_cache,
        od_index=od_index, od_step_m=od_step_m, fixed_variables=fixed_variables,
        make_cache_key_fn=make_cache_key_fn,
        stop_event=stop_event,
    )
    evals_used += evs
    if f_res < best_f_global:
        best_f_global = f_res
        best_x_global = x_res
 
    # Run 2: GLOBAL re-exploration, not a second polish of run 1.
    #
    # This used to restart from the incumbent with a 1 % kick and half the step size -- a
    # local refine -- and nothing downstream (blocks, refreshes) ever leaves the incumbent's
    # neighbourhood either. So after run 1 stagnated (typically ~5k of a 25k Stage A budget)
    # the entire remaining budget polished one basin, and the objective's flat directions
    # (injector angle, O/F inside its band) were settled by whichever basin run 1 happened
    # to stop in. The legacy CMA path's odd restarts kick 30 % of each dimension's span off
    # the incumbent at full sigma -- anchored so the start is not almost-surely infeasible,
    # wide enough to leave the basin -- and that is what run 2 does now.
    x0_2 = np.clip(best_x_global + rng.standard_normal(dim) * (0.30 * span),
                   lower_bounds, upper_bounds)
    if logger:
        logger.info("Stage A run 2: global re-exploration, 30 %% span kick off f=%.5f", best_f_global)
 
    if budget_a2 > 100:
        x_res, f_res, evs = run_cma_core(
            objective, x0_2, sigma0, bounds, budget_a2,
            popsize=popsize, cma_stds=cma_stds, elite_pool=elite_pool, seed=_sub_seed(2),
            valley_escape_tracker=valley_escape_tracker, logger=logger,
            # Parallel evaluation
            executor=executor, integer_dims=integer_dims, eval_cache=eval_cache,
            od_index=od_index, od_step_m=od_step_m, fixed_variables=fixed_variables,
            make_cache_key_fn=make_cache_key_fn,
            stop_event=stop_event,
        )
        evals_used += evs
        if f_res < best_f_global:
            best_f_global = f_res
            best_x_global = x_res
 
    if logger: logger.info(f"Stage A Complete. Best f: {best_f_global:.5f}")
 
    def _count_scan():
        nonlocal best_x_global, best_f_global, evals_used
        if iso_area is None or executor is None:
            return
        _x, _f, _ev = _layer1_iso_area_count_scan(
            best_x_global, best_f_global, bounds, executor, integer_dims or [], iso_area,
            logger=logger, eval_cache=eval_cache, make_cache_key_fn=make_cache_key_fn)
        evals_used += _ev
        if _f < best_f_global:
            best_x_global, best_f_global = np.asarray(_x, dtype=float), float(_f)
 
    _count_scan()
    
    # --- CYCLES ---
    current_x = best_x_global.copy()
    
    for cycle_idx in range(hybrid_config.cycles):
        # Check if optimization should stop
        if stop_event is not None and stop_event.is_set():
            raise RuntimeError("Optimization stopped by user")
        
        if update_progress_fn:
            update_progress_fn(f"Hybrid: Cycle {cycle_idx+1}", 0.3 + 0.6*(cycle_idx/max(1,hybrid_config.cycles)), f"Block Optimization ({hybrid_config.block_method})")
 
        cycle_budget = per_cycle_budget
        
        # --- STAGE B: Build Blocks ---
        blocks = compute_blocks_from_elites(
            elite_pool, hybrid_config.num_blocks, dim, 
            method=hybrid_config.block_method, 
            overlap_fraction=hybrid_config.overlap_fraction,
            rng=rng
        )
        
        # Derived DOFs are solved inside the objective, never searched: a block that proposes
        # them freely feeds the solve a random start (L1-07). Drop them, and fold any block
        # left with one coordinate into its neighbour (cma does not run a 1-D problem).
        blocks = [[int(i) for i in b if not (fixed_variables and int(i) in fixed_variables)]
                  for b in blocks]
        blocks = [b for b in blocks if b]
        _merged: List[List[int]] = []
        for b in blocks:
            if _merged and len(b) < 2:
                _merged[-1].extend(b)
            else:
                _merged.append(list(b))
        if len(_merged) > 1 and len(_merged[0]) < 2:
            _merged[1].extend(_merged.pop(0))
        blocks = _merged
 
        if logger: logger.info(f"Cycle {cycle_idx+1}: Created {len(blocks)} blocks using {hybrid_config.block_method} (Overlap: {hybrid_config.overlap_fraction})")
        
        # Calculate penalty weight
        # λ_eff = λ_schedule * f_scale / ||x||^2
        # Determine f_scale
        _, f_vals_elite = elite_pool.get_elites()
        if len(f_vals_elite) > 0:
            f_scale = np.median(np.abs(f_vals_elite))
        else:
            f_scale = max(1.0, abs(best_f_global))
            
        if not hybrid_config.lambda_normalize:
            f_scale = 1.0 # Use raw user lambda
            
        base_lambda = hybrid_config.lambda0 * (hybrid_config.lambda_mult ** cycle_idx)
        base_lambda = min(base_lambda, hybrid_config.lambda_max)
        
        # --- STAGE C: Block Re-optimization ---
        if len(blocks) > 0:
            budget_per_block = cycle_budget // len(blocks)
        else:
            budget_per_block = 0
        
        for b_i, block_indices in enumerate(blocks):
            if budget_per_block < 20: continue # Skip if too small
            # Derived DOFs are solved inside the objective, never searched: a block that
            # proposes them freely feeds the solve a random start (L1-07).
            if len(block_indices) < 2:
                continue            # cma does not run a 1-D problem
            
            non_block_indices = [i for i in range(dim) if i not in block_indices]
            
            # Constants for this block run
            x_fixed_vals = current_x[non_block_indices]
            
            # Define block bounds
            block_lower = lower_bounds[block_indices]
            block_upper = upper_bounds[block_indices]
            block_bounds = list(zip(block_lower, block_upper))
            
            # Initial mean for this block
            z0 = current_x[block_indices]
            
            # Objective wrapper
            def block_obj_fn(z):
                # Stitch
                full_x = current_x.copy() # Start with current baseline
                full_x[block_indices] = z # Overwrite block
                # Clip full x to be safe
                full_x = np.clip(full_x, lower_bounds, upper_bounds)
                return objective(full_x)
                
            # Same per-coordinate scaling as Stage A. One isotropic sigma over coordinates
            # whose ranges differ by 1e5 (m^2 next to psi) sampled the small ones uniformly
            # across their bounds and moved the large ones by a fraction of a unit.
            z_stds = np.asarray(cma_stds, dtype=float)[block_indices]
            z_sigma = sigma0
            # Apply additional boost to block sigma if valley escape is active
            if valley_escape_tracker is not None:
                tier = valley_escape_tracker.get("valley_escape_tier", 0)
                if tier > 0:
                    # Block reopt: smaller boost (1.2 - 1.8x)
                    block_boost = 1.0 + (tier * 0.2) # Tier 1: 1.2, Tier 2: 1.4, Tier 3: 1.6
                    z_sigma *= block_boost
            
            # A block optimizes a SUBSET of coordinates, so global discrete indices do
            # not address the sub-vector -- they have to be remapped through
            # ``block_indices``. Passing the global list would mark the wrong coordinates
            # as integers; passing nothing (what this did before) let a block search
            # element counts and jet angles as continuous values.
            _blk = list(block_indices)
            _blk_int_dims = [j for j, g in enumerate(_blk) if g in set(integer_dims or [])]
            _blk_od_index = _blk.index(od_index) if od_index in _blk else -1
            # Scored by the worker pool on the stitched full vector -- the same objective
            # and evaluation path as Stage A and the refreshes, so the comparisons below
            # never mix two scorings.
            z_best, z_f, z_evals = run_cma_core(
                block_obj_fn, z0, z_sigma, block_bounds, budget_per_block,
                popsize=max(8, 4 + int(3 * np.log(len(z0)+1))), # Smaller pop for blocks
                cma_stds=z_stds,
                seed=_sub_seed(100 + 10 * cycle_idx + b_i),
                elite_pool=None, 
                true_objective_fn=block_obj_fn,
                valley_escape_tracker=valley_escape_tracker, logger=logger,
                executor=executor,
                integer_dims=_blk_int_dims,
                od_index=_blk_od_index, od_step_m=od_step_m,
                eval_cache=eval_cache if executor is not None else None,
                make_cache_key_fn=make_cache_key_fn,
                stop_event=stop_event,
                embed_base=current_x.copy() if executor is not None else None,
                embed_idx=list(block_indices) if executor is not None else None,
                full_objective_fn=objective,
            )
            
            evals_used += z_evals
            
            # Update current_x if improved (current_x scored the same way z_f was)
            if executor is not None:
                _cur = _snap_integer_dims(np.asarray(current_x, dtype=np.float64), integer_dims or [])
                _cur_res = list(executor.map(_eval_candidate, [_cur]))[0]
                f_current = float(_cur_res.get("value", float("inf")))
            else:
                f_current = objective(current_x)
            if z_f < f_current:
                 current_x[block_indices] = z_best
                 if z_f < best_f_global:
                     best_f_global = z_f
                     best_x_global = current_x.copy()
                     if logger: logger.info(f"    Block {b_i} improved global best -> {best_f_global:.5f}")
            
            # Also add the new best to elite pool
            elite_pool.add(current_x, z_f)
            
        _count_scan()
        current_x = best_x_global.copy()
 
        # --- STAGE D: Global Refresh ---
        if hybrid_config.refresh_every_pass:
            ref_budget = int(total_budget * hybrid_config.refresh_budget_fraction)
            if ref_budget > 50:
                if logger: logger.info(f"Cycle {cycle_idx+1}: Global Refresh (Budget {ref_budget})")
                
                # Start around current best
                x_ref = best_x_global.copy()
                
                # Reduced sigma
                # User req 4: "sigma = refresh_sigma_scale * sigma_initial"
                sigma_ref = sigma0 * hybrid_config.refresh_sigma_scale
                
                # Apply additional boost to refresh sigma if valley escape is active
                if valley_escape_tracker is not None:
                    tier = valley_escape_tracker.get("valley_escape_tier", 0)
                    if tier > 0:
                        # Global refresh: larger boost (1.5 - 2.5x)
                        refresh_boost = 1.0 + (tier * 0.5) # Tier 1: 1.5, Tier 2: 2.0, Tier 3: 2.5
                        sigma_ref *= refresh_boost
 
                # Full-dimension restart -- same space as ``bounds``, so it takes the
                # global discrete-DOF handling. It previously passed neither, which let a
                # refresh walk element counts and jet angles off their integer grid.
                x_ref_res, f_ref_res, evs_ref = run_cma_core(
                    objective, x_ref, sigma_ref, bounds, ref_budget,
                    popsize=popsize, cma_stds=cma_stds, elite_pool=elite_pool,
                    seed=_sub_seed(1000 + cycle_idx),
                    valley_escape_tracker=valley_escape_tracker, logger=logger,
                    executor=executor, integer_dims=integer_dims,
                    od_index=od_index, od_step_m=od_step_m, fixed_variables=fixed_variables,
                    eval_cache=eval_cache,
                    make_cache_key_fn=make_cache_key_fn,
                    stop_event=stop_event,
                )
                evals_used += evs_ref
                
                if f_ref_res < best_f_global:
                    best_f_global = f_ref_res
                    best_x_global = x_ref_res
                    current_x = x_ref_res # Update incumbent for next cycle
                    if logger: logger.info(f"    Refresh improved global best -> {best_f_global:.5f}")
 
    _count_scan()
    return best_x_global, best_f_global, evals_used