fix(math): preflight finite dense operands at dispatch boundary

src/fesa/analysis/eigen_reduction.cpp

@@ -5,6 +5,7 @@
 #include <cmath>
 #include <limits>
 #include <map>
+#include <stdexcept>
 #include <string>
 #include <utility>
 #include <vector>
@@ -226,7 +227,7 @@ Result<EigenReduction> BuildEigenReduction(
     const SparseMatrix& stiffness, const std::vector<Matrix>& mass,
     const std::vector<ShellNodeInitialFrame>& frames,
     const std::vector<std::uint8_t>& mask, const std::vector<double>& drilling,
-    const double length) {
+    const double length) try {
   const std::size_t count = mass.size();
   const Status valid = stiffness.Validate();
   if (!valid.IsOk()) return Result<EigenReduction>::Failure(valid);
@@ -401,6 +402,10 @@ Result<EigenReduction> BuildEigenReduction(
   return Result<EigenReduction>::Success(
       {std::move(reduced.Value()), std::move(lifts), free_count, null_count,
        length, eta_mz, eta_kz, pz_norm});
+} catch (const std::invalid_argument&) {
+  return Result<EigenReduction>::Failure(
+      Failure("invalid-eigen-mass-space", 0U,
+              "Eigen product operands must be finite and shape compatible."));
 }
 
 Vector RestoreScaledMode(const EigenReduction& reduction, const Matrix& vectors,

src/fesa/analysis/linear_frequency_procedure.cpp

@@ -275,6 +275,10 @@ Result<EigenAnalysisState> ExecuteCandidate(const Domain& domain) {
     std::size_t pivot = 0U;
     for (std::size_t dof = 0; dof < y.Size(); ++dof) {
       physical[dof] = D(dof, length) * y[dof];
+      if (!std::isfinite(physical[dof]))
+        return Result<EigenAnalysisState>::Failure(
+            MetricFailure("initial_modal_mass", physical[dof],
+                          state.backend.column_ids[column]));
       if (std::abs(y[dof]) > std::abs(y[pivot])) pivot = dof;
     }
     Vector mass_times = eigen_internal::MultiplyNodalMass(nodal_mass, physical);
@@ -413,6 +417,10 @@ Result<EigenAnalysisState> LinearFrequencyProcedureExecutor::Execute(
           std::move(diagnostics)));
     }
     return result;
+  } catch (const std::invalid_argument&) {
+    return Result<EigenAnalysisState>::Failure(
+        Failure("invalid-eigenvalue-result", "modal-workspace",
+                "Modal product inputs must be finite and shape compatible."));
   } catch (const std::bad_alloc&) {
     return Result<EigenAnalysisState>::Failure(
         Failure("eigen-allocation-failed", "modal-workspace",