In `@src/plugin/object/src/utils/MeshSimplifier.cpp`:
- Around line 421-425: The multiplication cellsX * cellsY * cellsZ can overflow
uint32_t; change the intermediate computation to use uint64_t (e.g., compute
uint64_t maxCells64 = static_cast<uint64_t>(cellsX) * cellsY * cellsZ), then
clamp or validate the result before assigning to uint32_t maxCells (use
std::numeric_limits<uint32_t>::max() or fail/resize if maxCells64 exceeds that)
and update any uses of maxCells accordingly to avoid silent wraparound in
MeshSimplifier.cpp (references: cellsX, cellsY, cellsZ, maxCells).

In `@src/plugin/object/src/utils/MeshSimplifier.cpp`:
- Around line 19-20: The SpatialHash constructor currently sets _invCellSize =
1.0f / cellSize which yields Inf for zero/negative inputs; update
SpatialHash(float cellSize) to validate or clamp cellSize (e.g., if cellSize <=
0.0f then set cellSize = max(cellSize, std::numeric_limits<float>::epsilon()) or
a small positive fallback) before assigning _cellSize and computing
_invCellSize, or alternatively assert/throw on invalid input; ensure GetKey and
any other methods relying on _invCellSize then operate on the validated/clamped
value.

In `@src/plugin/physics/src/system/SoftBodyChassisSystem.cpp`:
- Around line 452-469: The computation of invScale = 1.0f /
internal.initialScale can divide by zero if any component of initialScale is
zero; change it to clamp each component against a small epsilon (use the same
epsilon used in SoftBodySystem) before inversion (e.g., compute safeScale =
glm::max(internal.initialScale, glm::vec3(epsilon)) then invScale = 1.0f /
safeScale) so invScale contains no inf/NaN and the subsequent mesh.SetVertexAt
updates remain valid.
- Around line 223-303: The internal.vertexMap must map original mesh vertex
indices to the final Jolt vertex indices (deduped simplified mesh) — currently
when wasSimplified is true you assign only simplificationMap, losing the dedup
mapping from CreateChassisSharedSettings (vertexMap) and causing
incorrect/out-of-range indices during sync. Fix by composing the maps when
wasSimplified: take simplificationMap (orig->simplifiedIndex) and the dedup
vertexMap returned by CreateChassisSharedSettings (simplifiedIndex->joltIndex)
and build a combined map orig->joltIndex, then assign that combined map to
Component::SoftBodyChassisInternal::vertexMap (instead of assigning only
simplificationMap); keep the existing move semantics (use std::move where
appropriate) and ensure the code references simplificationMap, vertexMap (the
one returned by CreateChassisSharedSettings), internal.vertexMap and
wasSimplified.

In `@src/plugin/object/src/utils/MeshSimplifier.cpp`:
- Around line 281-368: The function SimplifyMesh currently unconditionally sets
result.wasSimplified = true at the end of the simplification path; change this
to reflect actual change by comparing counts: set result.wasSimplified =
(result.simplifiedVertexCount != result.originalVertexCount) ||
(newIndices.size() != indices.size()). Update the assignment for
result.wasSimplified (after computing result.simplifiedVertexCount and
newIndices) instead of the unconditional true so the flag accurately reflects
whether vertices or indices changed.

In `@src/plugin/physics/src/system/SoftBodyChassisSystem.cpp`:
- Around line 135-169: The static function CreateSkeletonBody is unused and
should be removed or explicitly documented; either delete the entire
CreateSkeletonBody function (including its references to JPH::BoxShapeSettings,
bodySettings, and physicsManager/GetBodyInterface/CreateBody) to eliminate dead
code, or keep it but add a clear comment above CreateSkeletonBody stating its
intended future use (e.g., purpose for VehicleConstraint skeleton bodies), why
it’s static/unused, and when/where it will be invoked so reviewers know it’s
intentionally retained.

In `@src/plugin/physics/src/system/SoftBodyChassisSystem.cpp`:
- Around line 224-257: When autoSimplify is enabled but simplification didn't
reduce to settings.maxVertices and settings.fallbackToRigidBody is false,
explicitly handle that case instead of silently continuing with an over-budget
mesh: inside the branch where result.wasSimplified is false and
settings.fallbackToRigidBody is false, add a Log::Warn message describing that
simplification was insufficient and fallback is disabled, then if result.mesh is
available use it as the working mesh (assign workingMesh =
std::move(result.mesh); simplificationMap = std::move(result.vertexMap); set
wasSimplified accordingly) so we at least use the best-effort simplified mesh,
otherwise keep the original mesh but make the warning explicit and consider
setting a flag or metric to show the chassis remains over-budget; reference
symbols: meshVertices, settings.autoSimplify, settings.fallbackToRigidBody,
result, workingMesh, simplificationMap, wasSimplified, chassisComp.isActive.

In `@src/plugin/object/src/utils/MeshSimplifier.cpp`:
- Around line 263-270: The loop in MeshSimplifier.cpp that writes res.normals
from normalSums (inside the for over i) must guard against zero-length
normalSums before calling glm::normalize to avoid NaNs; update the block that
currently does res.normals[i] = glm::normalize(normalSums[i]) to compute the
squared length (or length) of normalSums[i], compare against a small epsilon,
and only normalize when above the threshold, otherwise set a safe fallback
normal (e.g., a unit up vector or the vertex-normal computed from surrounding
geometry) so res.normals[i] never becomes NaN; locate this change around the
variables normalSums, res.normals, clusterCounts and clusterSums in the same
loop.
- Around line 475-477: Clamp the computed cellSize to a small positive minimum
before using it to compute cellsX/cellsY to avoid division by zero when
settings.mergeDistance is zero or negative; specifically, replace the direct use
of settings.mergeDistance * 2.0f for cellSize with a clamped value (e.g.,
max(settings.mergeDistance * 2.0f, some small epsilon like 1e-6f)) and then use
that clamped cellSize when computing cellsX and cellsY so the ceil(extent.x /
cellSize) and ceil(extent.y / cellSize) calls cannot divide by zero.

In `@src/plugin/physics/src/component/SoftBodyChassisInternal.hpp`:
- Around line 58-64: The field skeletonBodyID in SoftBodyChassisInternal is left
uninitialized causing HasValidSkeleton() to be unreliable; fix it by
initializing skeletonBodyID to a known invalid value (e.g., JPH::BodyID() or
JPH::BodyID::sInvalid) in SoftBodyChassisInternal's constructor OR ensure the
code that creates a SoftBodyChassisInternal instance in SoftBodyChassisSystem
assigns the actual created rigid body ID to skeletonBodyID after creation;
update either the SoftBodyChassisInternal constructor or the instantiation site
so skeletonBodyID is deterministically set before any call to
HasValidSkeleton().

In `@src/plugin/physics/src/component/SoftBodyChassisInternal.hpp`:
- Around line 149-161: The IsValid() check always fails because skeletonBodyID
is never set; update the code to remove the unused skeleton requirement by
deleting HasValidSkeleton() and skeletonBodyID usages and change IsValid() (in
SoftBodyChassisInternal) to return HasValidSoftBody() && isInitialized; then
update any call sites (e.g., SyncSoftBodyChassisWithSkeleton loop in
SoftBodyChassisSystem.cpp) that reference HasValidSkeleton or skeletonBodyID to
rely on the new IsValid() semantics and ensure anchorsInitialized and softBodyID
usage remain intact so processing continues when the soft body is present and
initialized.