seeding expansion

also: replace energy output with energy output density

src/physcom/engine/constraint_resolver.py

@@ -41,7 +41,7 @@ class ConstraintResolver:
         self._check_requires_vs_excludes(all_deps, result)
         self._check_mutual_exclusion(all_deps, result)
         self._check_range_incompatibility(all_deps, result)
-        self._check_force_scale(combination, result)
+        self._check_power_density(combination, result)
         self._check_energy_density(combination, result)
         self._check_unmet_requirements(all_deps, result)
 
@@ -125,34 +125,32 @@ class ConstraintResolver:
                             f"but {max_name} limits {key} <= {max_val}"
                         )
 
-    def _check_force_scale(
+    def _check_power_density(
         self, combination: Combination, result: ConstraintResult
     ) -> None:
-        """Rule 4: If power source output << platform requirement → warn/block."""
-        force_provided: list[tuple[str, float]] = []
-        force_required: list[tuple[str, float]] = []
+        """Rule 4: If power source W/kg << platform required W/kg → warn/block."""
+        density_provided: list[tuple[str, float]] = []
+        density_required: list[tuple[str, float]] = []
 
         for entity in combination.entities:
             for dep in entity.dependencies:
-                if dep.key == "force_output_watts" and dep.constraint_type == "provides":
-                    force_provided.append((entity.name, float(dep.value)))
-                elif dep.key == "force_required_watts" and dep.constraint_type == "range_min":
-                    force_required.append((entity.name, float(dep.value)))
+                if dep.key == "power_density_w_kg" and dep.constraint_type == "provides":
+                    density_provided.append((entity.name, float(dep.value)))
+                elif dep.key == "power_density_required_w_kg" and dep.constraint_type == "range_min":
+                    density_required.append((entity.name, float(dep.value)))
 
-        for req_name, req_watts in force_required:
-            for prov_name, prov_watts in force_provided:
-                if prov_watts < req_watts * 0.01:
-                    # Off by more than 100x — hard block
+        for req_name, req_density in density_required:
+            for prov_name, prov_density in density_provided:
+                if prov_density < req_density * 0.01:
                     result.violations.append(
-                        f"{prov_name} provides {prov_watts}W but "
-                        f"{req_name} requires {req_watts}W "
-                        f"(force deficit > 100x)"
+                        f"{prov_name} provides {prov_density} W/kg but "
+                        f"{req_name} requires {req_density} W/kg "
+                        f"(power density deficit > 100x)"
                     )
-                elif prov_watts < req_watts:
-                    # Under-powered but not impossibly so — warn
+                elif prov_density < req_density:
                     result.warnings.append(
-                        f"{prov_name} provides {prov_watts}W but "
-                        f"{req_name} requires {req_watts}W "
+                        f"{prov_name} provides {prov_density} W/kg but "
+                        f"{req_name} requires {req_density} W/kg "
                         f"(under-powered)"
                     )