@forgeax/engine-physics-rapier3d 0.1.28 → 0.1.30

package/src/rapier-physics-world-3d.ts

@@ -60,7 +60,7 @@ import {
 } from '@forgeax/engine-physics';
 import { ChildOf } from '@forgeax/engine-scene';
 import { err, ok, type Result } from '@forgeax/engine-types';
-import type { Rapier3DModule } from './wasm-loader';
+import type { Rapier3DModule } from './wasm-loader.js';
 
 interface Rapier3DKinematicControllerState {
   readonly entity: number;
@@ -231,6 +231,12 @@ interface DerivedCandidateRecord {
   readonly bytes: number;
   state: DerivedPhysicsCandidateState;
   commitGeometry?: () => Result<void, Error>;
+  batch?: DerivedAdmissionBatch;
+}
+
+interface DerivedAdmissionBatch {
+  readonly records: readonly DerivedCandidateRecord[];
+  readonly commitGeometry?: () => Result<void, Error>;
 }
 
 interface DerivedConstraintRecord {
@@ -536,8 +542,10 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
 
   step(deltaTime: number): void {
     this.assertActive('step');
-    void deltaTime;
+    if (!Number.isFinite(deltaTime) || deltaTime <= 0 || deltaTime > PHYSICS_DT_MAX) return;
     try {
+      // Native integration must consume the same fixed delta as force controllers.
+      (this.raw as { timestep: number }).timestep = deltaTime;
       this.processDerivedCandidates();
       // A failed native rollback is an explicit rebuild boundary. Physics does
       // not advance or publish a mixed state after this point.
@@ -625,6 +633,8 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
   ): void {
     let point: PhysicsVector | undefined;
     let normal: PhysicsVector | undefined;
+    let geometricPoint: PhysicsVector | undefined;
+    let geometricNormal: PhysicsVector | undefined;
     try {
       const colliderA = (this.raw as RapierWorld).getCollider(handleA);
       const colliderB = (this.raw as RapierWorld).getCollider(handleB);
@@ -633,6 +643,44 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
           colliderA,
           colliderB,
           (manifold: RapierWorld, flipped: boolean) => {
+            // A contact manifold can retain geometric points without solver
+            // points. Composite local points are subshape-local, so only
+            // transform points from the ordinary primitive collider surface.
+            if (
+              manifold.numSolverContacts() === 0 &&
+              geometricPoint === undefined &&
+              manifold.numContacts() > 0
+            ) {
+              const first = flipped ? colliderB : colliderA;
+              const second = flipped ? colliderA : colliderB;
+              const types = this.rapierModule.ShapeType;
+              for (const [collider, local] of [
+                [first, manifold.localContactPoint1(0)],
+                [second, manifold.localContactPoint2(0)],
+              ]) {
+                if (
+                  local == null ||
+                  ![types.Ball, types.Cuboid, types.Capsule].includes(collider.shapeType())
+                )
+                  continue;
+                const rotation = collider.rotation();
+                const rotated = quat.transformVec3(
+                  vec3.create(),
+                  [rotation.x, rotation.y, rotation.z, rotation.w],
+                  [local.x, local.y, local.z],
+                );
+                const position = collider.translation();
+                geometricPoint = [
+                  rotated[0] + position.x,
+                  rotated[1] + position.y,
+                  rotated[2] + position.z,
+                ];
+                const n = manifold.normal();
+                const direction = flipped ? -1 : 1;
+                geometricNormal = [n.x * direction, n.y * direction, n.z * direction];
+                break;
+              }
+            }
             if (manifold.numSolverContacts?.() > 0) {
               const contact = manifold.solverContactPoint(0);
               const n = manifold.normal();
@@ -651,6 +699,10 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
       // Contact events remain useful without optional manifold sampling. The
       // public type makes point/normal optional rather than inventing values.
     }
+    if (point === undefined && geometricPoint !== undefined) {
+      point = geometricPoint;
+      normal = geometricNormal;
+    }
     this.derivedContacts.push({
       ...observation,
       ...(point === undefined ? {} : { point }),
@@ -906,14 +958,85 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
     return admitted;
   }
 
+  admitDerivedShapeCandidates(
+    candidates: readonly DerivedPhysicsCandidate[],
+    commitGeometry?: () => Result<void, Error>,
+  ): ReturnType<NonNullable<PhysicsWorld['admitDerivedShapeCandidates']>> {
+    this.assertActive('admitDerivedShapeCandidates');
+    const records: DerivedCandidateRecord[] = [];
+    const sources = new Map<number, DerivedBodySource>();
+    const constraints = new Set<string>();
+    const invalid = (reason: string) =>
+      new DerivedPhysicsError(
+        'derived-candidate-invalid',
+        'one bounded admission contains distinct prepared bodies and constraint updates',
+        'prepare one candidate per body and submit the complete replacement together',
+        { reason },
+      );
+    if (candidates.length === 0 || candidates.length > DERIVED_PHYSICS_LIMITS.maxCandidates)
+      return err(invalid('invalid batch size'));
+    // Resolve credentials before mutating the queue. Never use caller input as
+    // the source projection or invalidate another owner's matching token ID.
+    for (const candidate of candidates) {
+      const record = this.derivedCandidates.get(candidate.candidateId);
+      if (
+        record === undefined ||
+        candidate.owner !== this.physicsOwner ||
+        candidate.generation !== this.backendGeneration ||
+        record.state !== 'ready'
+      )
+        return err(invalid('batch member is not a current prepared candidate'));
+      if (sources.has(record.input.entity)) return err(invalid('duplicate body'));
+      for (const constraint of record.input.constraints ?? []) {
+        if (constraints.has(constraint.id)) return err(invalid('duplicate constraint update'));
+        constraints.add(constraint.id);
+      }
+      records.push(record);
+      sources.set(record.input.entity, {
+        sourceKey: record.input.sourceKey,
+        revision: record.input.revision,
+      });
+    }
+    for (const candidate of candidates) {
+      const checked = this.admitDerivedShapeCandidateInternal(candidate, sources, true);
+      if (!checked.ok) {
+        for (const record of records) {
+          if (this.derivedCandidates.has(record.token.candidateId))
+            this.rejectPreparedCandidate(record, checked.error);
+        }
+        return checked;
+      }
+    }
+    const batch: DerivedAdmissionBatch = Object.freeze({
+      records: Object.freeze(records),
+      ...(commitGeometry === undefined ? {} : { commitGeometry }),
+    });
+    for (const record of records) record.batch = batch;
+    const queued: DerivedPhysicsCandidate[] = [];
+    for (const candidate of candidates) {
+      const admitted = this.admitDerivedShapeCandidateInternal(candidate, sources);
+      if (!admitted.ok) {
+        const first = records[0];
+        if (first !== undefined) this.rejectPreparedCandidate(first, admitted.error);
+        return admitted;
+      }
+      queued.push(admitted.value);
+    }
+    return ok(Object.freeze(queued));
+  }
+
   getDerivedAdmission(
     entity?: number,
   ):
     | { readonly entity: number; readonly revision: number; readonly fixedStep: number }
     | undefined {
-    const record = this.activeDerivedAdmission;
-    if (record === undefined || (entity !== undefined && record.input.entity !== entity))
-      return undefined;
+    const active = this.activeDerivedAdmission;
+    const record =
+      entity === undefined
+        ? active
+        : (active?.batch?.records.find((item) => item.input.entity === entity) ??
+          (active?.input.entity === entity ? active : undefined));
+    if (record === undefined) return undefined;
     return {
       entity: record.input.entity,
       revision: record.input.revision,
@@ -924,6 +1047,7 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
   private admitDerivedShapeCandidateInternal(
     candidate: DerivedPhysicsCandidate,
     sourceOverrides?: ReadonlyMap<number, DerivedBodySource>,
+    validateOnly = false,
   ): ReturnType<NonNullable<PhysicsWorld['admitDerivedShapeCandidate']>> {
     this.assertActive('admitDerivedShapeCandidate');
     const record = this.derivedCandidates.get(candidate.candidateId);
@@ -1012,6 +1136,7 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
       this.rejectPreparedCandidate(record, stale);
       return err(stale);
     }
+    if (validateOnly) return ok(record.token);
     record.state = 'queued';
     this.pendingDerivedCandidates.add(candidate.candidateId);
     const queued = Object.freeze({ ...record.token, state: 'queued' as const });
@@ -1084,10 +1209,12 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
         ),
       );
     }
-    this.pendingDerivedCandidates.delete(candidate.candidateId);
-    for (const collider of record.nativeColliders) this.removeNativeCollider(collider.handle);
-    record.state = 'cancelled';
-    this.releaseDerivedCandidate(candidate.candidateId);
+    for (const member of record.batch?.records ?? [record]) {
+      this.pendingDerivedCandidates.delete(member.token.candidateId);
+      for (const collider of member.nativeColliders) this.removeNativeCollider(collider.handle);
+      member.state = 'cancelled';
+      this.releaseDerivedCandidate(member.token.candidateId);
+    }
     return ok(undefined);
   }
 
@@ -1143,13 +1270,83 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
     const com = body.worldCom();
     const linear = body.linvel();
     const angular = body.angvel();
+    const rotation = body.rotation();
     return Object.freeze({
       centerOfMass: [com.x, com.y, com.z] as PhysicsVector,
       linearVelocity: [linear.x, linear.y, linear.z] as PhysicsVector,
       angularVelocity: [angular.x, angular.y, angular.z] as PhysicsVector,
+      rotation: [rotation.x, rotation.y, rotation.z, rotation.w] as PhysicsQuaternion,
     });
   }
 
+  applyDerivedImpulse(
+    input: Parameters<NonNullable<PhysicsWorld['applyDerivedImpulse']>>[0],
+  ): Result<void, DerivedPhysicsError> {
+    this.assertActive('applyDerivedImpulse');
+    const refuse = (code: DerivedPhysicsError['code'], expected: string) =>
+      err(
+        new DerivedPhysicsError(
+          code,
+          expected,
+          'read the committed dynamic body and submit a finite impulse outside pending admission',
+          { entity: input.entity },
+        ),
+      );
+    if (this.recoveryBlocked())
+      return refuse('derived-recovery-invalid', 'PhysicsWorld is healthy');
+    const record = this.derivedBodies.get(input.entity);
+    const body = this.bodyForEntity(input.entity);
+    if (record === undefined || body === undefined)
+      return refuse('derived-body-not-found', 'a committed derived body exists');
+    if (record.sourceKey !== input.sourceKey || record.revision !== input.revision)
+      return refuse(
+        'derived-candidate-stale',
+        'impulse identity matches the committed body revision',
+      );
+    if (
+      this.derivedPublicationPending ||
+      [...this.pendingDerivedCandidates].some(
+        (id) => this.derivedCandidates.get(id)?.input.entity === input.entity,
+      )
+    )
+      return refuse('derived-candidate-pending', 'the body has no unpublished native mutation');
+    if (
+      rapierBodyTypeToString(this.rapierModule, body.bodyType()) !== 'dynamic' ||
+      ![input.impulse, input.point].every(
+        (vector) =>
+          Array.isArray(vector) &&
+          vector.length === 3 &&
+          vector.every((value) => Number.isFinite(value) && Number.isFinite(Math.fround(value))),
+      )
+    )
+      return refuse(
+        'derived-candidate-invalid',
+        'a dynamic body receives finite Float32 world vectors',
+      );
+    try {
+      body.applyImpulseAtPoint(
+        { x: input.impulse[0], y: input.impulse[1], z: input.impulse[2] },
+        { x: input.point[0], y: input.point[1], z: input.point[2] },
+        true,
+      );
+      const linear = body.linvel(),
+        angular = body.angvel();
+      if (![linear.x, linear.y, linear.z, angular.x, angular.y, angular.z].every(Number.isFinite))
+        throw new Error('native impulse produced non-finite motion');
+      return ok(undefined);
+    } catch (cause) {
+      this.derivedPoisonedEntities.add(input.entity);
+      return err(
+        new DerivedPhysicsError(
+          'derived-backend-failed',
+          'native impulse completes with finite motion',
+          'rebuild the World from a previously committed snapshot',
+          { entity: input.entity, reason: cause instanceof Error ? cause.message : String(cause) },
+        ),
+      );
+    }
+  }
+
   getDerivedRecoveryState(): 'ready' | 'rebuild-required' {
     return this.recoveryBlocked() ? 'rebuild-required' : 'ready';
   }
@@ -1251,20 +1448,8 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
       }
       preparedCandidates.push(prepared.value);
     }
-    const candidates: DerivedPhysicsCandidate[] = [];
-    for (const prepared of preparedCandidates) {
-      const admitted = this.admitDerivedShapeCandidateInternal(prepared, snapshotSources);
-      if (!admitted.ok) {
-        // Admission may have created disabled native colliders before a later
-        // body/constraint row fails.  Cancel every prepared credential, not
-        // only rows that reached the local `candidates` list: the rejected
-        // row and any rows after it also own native staging state.
-        for (const candidate of preparedCandidates) this.cancelDerivedShapeCandidate(candidate);
-        return admitted;
-      }
-      candidates.push(admitted.value);
-    }
-    return ok(candidates);
+    if (preparedCandidates.length === 0) return ok([]);
+    return this.admitDerivedShapeCandidates(preparedCandidates);
   }
 
   createDerivedConstraint(
@@ -1424,8 +1609,11 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
     record: DerivedCandidateRecord,
     error: DerivedPhysicsError,
   ): void {
-    for (const collider of record.nativeColliders) this.removeNativeCollider(collider.handle);
-    this.rememberDerivedFailure(record, error, 'old-state-retained');
+    for (const member of record.batch?.records ?? [record]) {
+      if (!this.derivedCandidates.has(member.token.candidateId)) continue;
+      for (const collider of member.nativeColliders) this.removeNativeCollider(collider.handle);
+      this.rememberDerivedFailure(member, error, 'old-state-retained');
+    }
   }
 
   private processDerivedCandidates(): void {
@@ -1444,389 +1632,432 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
     // endpoint. This turns a queue-time source projection into a final
     // committed-source check: if the endpoint fails natively, its dependent
     // candidate sees the old source on the next iteration and is rejected.
-    const ordered: DerivedCandidateRecord[] = [];
+    const ordered: (readonly DerivedCandidateRecord[])[] = [];
     const visiting = new Set<string>();
     const visited = new Set<string>();
     const visit = (record: DerivedCandidateRecord): void => {
-      if (visited.has(record.token.candidateId)) return;
-      if (visiting.has(record.token.candidateId)) return;
-      visiting.add(record.token.candidateId);
-      for (const constraint of record.input.constraints ?? []) {
-        for (const endpoint of [
-          [constraint.bodyA, constraint.bodyASource],
-          [constraint.bodyB, constraint.bodyBSource],
-        ] as const) {
-          const dependency = endpoint[1];
-          const target = pendingByEntity.get(endpoint[0]);
-          if (
-            target !== undefined &&
-            target.input.sourceKey === dependency.sourceKey &&
-            target.input.revision === dependency.revision
-          ) {
-            visit(target);
-          }
-        }
-      }
-      visiting.delete(record.token.candidateId);
-      visited.add(record.token.candidateId);
-      ordered.push(record);
-    };
-    for (const record of pendingRecords) visit(record);
-
-    for (const record of ordered) {
-      const id = record.token.candidateId;
-      if (!this.pendingDerivedCandidates.has(id) || record.state !== 'queued') continue;
-      const pendingSources = this.pendingDerivedSources();
-      const projected = pendingSources.get(record.input.entity);
-      if (projected !== undefined && record.input.revision < projected.revision) {
+      const group = record.batch?.records ?? [record];
+      const key = group[0]?.token.candidateId ?? record.token.candidateId;
+      if (visited.has(key)) return;
+      if (visiting.has(key)) {
         this.rejectPreparedCandidate(
           record,
           new DerivedPhysicsError(
-            'derived-candidate-stale',
-            'fixed-step admission publishes only the newest queued body revision',
-            'discard the older queued candidate and submit the latest complete input',
-            {
-              entity: record.input.entity,
-              candidateId: record.token.candidateId,
-              expected: `>=${projected.revision}`,
-              actual: record.input.revision,
-            },
+            'derived-constraint-invalid',
+            'cyclic endpoint updates share one batch',
+            'submit mutually dependent body replacements together',
+            { candidateId: key },
           ),
         );
-        continue;
+        return;
       }
-      const admissionError = this.validateDerivedAdmission(record.input, pendingSources);
-      if (admissionError !== undefined) {
-        this.rejectPreparedCandidate(record, admissionError);
-        continue;
+      visiting.add(key);
+      for (const member of group) {
+        for (const constraint of member.input.constraints ?? []) {
+          for (const [entity, dependency] of [
+            [constraint.bodyA, constraint.bodyASource],
+            [constraint.bodyB, constraint.bodyBSource],
+          ] as const) {
+            const target = pendingByEntity.get(entity);
+            if (
+              target !== undefined &&
+              !group.includes(target) &&
+              target.input.sourceKey === dependency.sourceKey &&
+              target.input.revision === dependency.revision
+            )
+              visit(target);
+          }
+        }
       }
-      const old = this.derivedBodies.get(record.input.entity);
-      if (this.derivedPoisonedEntities.has(record.input.entity)) {
-        for (const collider of record.nativeColliders) this.removeNativeCollider(collider.handle);
-        this.rememberDerivedFailure(
-          record,
-          new DerivedPhysicsError(
-            'derived-recovery-invalid',
-            'the entity is stopped after an unrecoverable native admission failure',
-            'rebuild the PhysicsWorld from the last portable snapshot before retrying',
-            { entity: record.input.entity, candidateId: record.token.candidateId },
-          ),
-          'rebuild-required',
-        );
+      visiting.delete(key);
+      visited.add(key);
+      ordered.push(group);
+    };
+    for (const record of pendingRecords) visit(record);
+
+    for (const group of ordered) {
+      if (this.derivedPoisonedEntities.size > 0) break;
+      const first = group[0];
+      if (first === undefined) continue;
+      if (
+        group.some(
+          (record) =>
+            record.state !== 'queued' ||
+            !this.pendingDerivedCandidates.has(record.token.candidateId),
+        )
+      )
         continue;
-      }
-      const body = this.bodyForEntity(record.input.entity);
-      if (body === undefined) {
-        for (const collider of record.nativeColliders) this.removeNativeCollider(collider.handle);
-        this.rememberDerivedFailure(
-          record,
-          new DerivedPhysicsError(
+      // Validate the whole final projection before any native body changes.
+      const sources = this.pendingDerivedSources();
+      let rejected: DerivedPhysicsError | undefined;
+      for (const record of group) {
+        const projected = sources.get(record.input.entity);
+        if (projected !== undefined && record.input.revision < projected.revision) {
+          rejected = new DerivedPhysicsError(
+            'derived-candidate-stale',
+            'fixed-step admission publishes the final queued body revisions',
+            'discard the older group and prepare a complete replacement',
+            { entity: record.input.entity },
+          );
+        } else if (this.derivedPoisonedEntities.has(record.input.entity)) {
+          rejected = new DerivedPhysicsError(
+            'derived-recovery-invalid',
+            'every batch body has recoverable native state',
+            'rebuild the PhysicsWorld before retrying',
+            { entity: record.input.entity },
+          );
+        } else if (this.bodyForEntity(record.input.entity) === undefined) {
+          rejected = new DerivedPhysicsError(
             'derived-body-not-found',
-            'candidate entity remains a live native body at fixed-step admission',
-            'reconcile the entity and submit a fresh candidate',
-            { entity: record.input.entity, candidateId: record.token.candidateId },
-          ),
-          'old-state-retained',
-        );
+            'every batch body remains live through admission',
+            'reconcile entities and prepare again',
+            { entity: record.input.entity },
+          );
+        } else rejected = this.validateDerivedAdmission(record.input, sources);
+        if (rejected !== undefined) break;
+      }
+      if (rejected !== undefined) {
+        this.rejectPreparedCandidate(first, rejected);
         continue;
       }
-      const oldBodyType = body.bodyType();
-      const oldBodyEnabled = body.isEnabled();
-      const oldVelocity = body.linvel();
-      const oldAngularVelocity = body.angvel();
-      const oldTranslation = body.translation();
-      const oldRotation = body.rotation();
-      const oldCom = body.worldCom();
-      const oldMass = body.mass();
-      const oldAutomaticAdditionalMass =
-        this.entityMap.get(record.input.entity)?.automaticAdditionalMass ?? 0;
-      const oldAutomaticRecordMass = this.entityMap.get(
-        record.input.entity,
-      )?.automaticAdditionalMass;
-      const oldSource = this.derivedBodySources.get(record.input.entity);
-      const oldPublication = this.derivedPublications.get(record.input.entity);
-      const oldDensities = this.bodyColliders(body).map((collider) => ({
-        collider,
-        density: typeof collider.density === 'function' ? collider.density() : undefined,
-        enabled: typeof collider.isEnabled === 'function' ? collider.isEnabled() : true,
-      }));
-      const oldConstraints = new Map(this.derivedConstraints);
-      const stagedConstraints = new Map<string, DerivedConstraintRecord>();
-      let geometryCommitUncertain = false;
-      try {
-        for (const constraint of record.input.constraints ?? []) {
-          const created = this.createNativeConstraint(constraint);
-          if (!created.ok) throw created.error;
-          stagedConstraints.set(constraint.id, {
-            input: { ...constraint },
-            handle: created.value.handle,
-          });
-        }
-        if (record.input.bodyType !== undefined) {
-          const RAPIER = this.rapierModule as RapierWorld;
-          const bodyType =
-            record.input.bodyType === 'static'
-              ? RAPIER.RigidBodyType.Fixed
-              : record.input.bodyType === 'kinematic'
-                ? RAPIER.RigidBodyType.KinematicPositionBased
-                : RAPIER.RigidBodyType.Dynamic;
-          body.setBodyType(bodyType, true);
-        }
-        for (const native of record.nativeColliders) {
-          const collider = (this.raw as RapierWorld).getCollider(native.handle);
-          if (collider === null || collider === undefined)
-            throw new Error('candidate collider disappeared');
-          collider.setEnabled(true);
-        }
-        const nativeById = new Map(
-          record.input.shapes.map((shape: VoxelShapeInput, index: number) => [
-            shape.id,
-            record.nativeColliders[index]?.handle as number,
-          ]),
-        );
-        for (const seam of record.input.seams ?? []) {
-          const firstHandle = nativeById.get(seam.shapeA);
-          const secondHandle = nativeById.get(seam.shapeB);
-          const first =
-            firstHandle === undefined
-              ? undefined
-              : (this.raw as RapierWorld).getCollider(firstHandle);
-          const second =
-            secondHandle === undefined
-              ? undefined
-              : (this.raw as RapierWorld).getCollider(secondHandle);
-          if (first === undefined || second === undefined || first === null || second === null) {
-            throw new Error(`derived seam references missing shape ${seam.shapeA}`);
-          }
-          first.combineVoxelStates(second, seam.offset[0], seam.offset[1], seam.offset[2]);
-        }
-        this.applyDerivedMass(
-          body,
-          record.input.massProperties,
-          oldCom,
-          record.input.velocityPolicy ?? 'preserve',
-          this.entityMap.get(record.input.entity)?.additionalMass ?? 0,
+      const undos: (() => boolean)[] = [];
+      for (const record of group) {
+        const id = record.token.candidateId;
+        const old = this.derivedBodies.get(record.input.entity);
+        const body = this.bodyForEntity(record.input.entity);
+        const oldBodyType = body.bodyType();
+        const oldBodyEnabled = body.isEnabled();
+        const oldVelocity = body.linvel();
+        const oldAngularVelocity = body.angvel();
+        const oldTranslation = body.translation();
+        const oldRotation = body.rotation();
+        const oldCom = body.worldCom();
+        const oldMass = body.mass();
+        const oldAutomaticAdditionalMass =
+          this.entityMap.get(record.input.entity)?.automaticAdditionalMass ?? 0;
+        const oldAutomaticRecordMass = this.entityMap.get(
           record.input.entity,
-          record.input.shapes,
-          record.nativeColliders,
-        );
-        if (record.input.motion !== undefined) {
-          const currentCom = body.worldCom();
-          const targetCom = record.input.motion.centerOfMass;
-          const translation = body.translation();
-          body.setTranslation(
-            {
-              x: translation.x + targetCom[0] - currentCom.x,
-              y: translation.y + targetCom[1] - currentCom.y,
-              z: translation.z + targetCom[2] - currentCom.z,
-            },
-            true,
-          );
-          body.setLinvel(
-            {
-              x: record.input.motion.linearVelocity[0],
-              y: record.input.motion.linearVelocity[1],
-              z: record.input.motion.linearVelocity[2],
-            },
-            true,
-          );
-          body.setAngvel(
-            {
-              x: record.input.motion.angularVelocity[0],
-              y: record.input.motion.angularVelocity[1],
-              z: record.input.motion.angularVelocity[2],
-            },
-            true,
-          );
-        }
-        // A body revision invalidates any committed joint that still names
-        // that body's previous source/revision. Keep this tied to the body
-        // that is actually committing: a different queued endpoint may still
-        // fail, in which case its old joint remains valid and must not be
-        // removed speculatively.
-        const committedSources = new Map(this.derivedBodySources);
-        committedSources.set(record.input.entity, {
-          sourceKey: record.input.sourceKey,
-          revision: record.input.revision,
-        });
-        const replacementConstraintIds = new Set(
-          (record.input.constraints ?? []).map((constraint) => constraint.id),
-        );
-        for (const [constraintId, current] of [...this.derivedConstraints]) {
-          if (
-            replacementConstraintIds.has(constraintId) ||
-            this.constraintDependenciesMatch(current.input, committedSources)
-          )
-            continue;
-          this.removeNativeConstraint(current.handle);
-          this.derivedConstraints.delete(constraintId);
-        }
-        if (old !== undefined) {
-          for (const shape of old.shapes) {
-            const collider = (this.raw as RapierWorld).getCollider(shape.colliderHandle);
+        )?.automaticAdditionalMass;
+        const oldSource = this.derivedBodySources.get(record.input.entity);
+        const oldPublication = this.derivedPublications.get(record.input.entity);
+        const oldDensities = this.bodyColliders(body).map((collider) => ({
+          collider,
+          density: typeof collider.density === 'function' ? collider.density() : undefined,
+          enabled: typeof collider.isEnabled === 'function' ? collider.isEnabled() : true,
+        }));
+        const oldConstraints = new Map(this.derivedConstraints);
+        const stagedConstraints = new Map<string, DerivedConstraintRecord>();
+        let geometryCommitUncertain = false;
+        const rollback = (): boolean => {
+          for (const staged of stagedConstraints.values())
+            this.removeNativeConstraint(staged.handle);
+          // The commit path may already have removed/replaced a native joint
+          // before a later body mutation fails. Clear every current native joint
+          // now; the old records are recreated after the body state is restored
+          // instead of leaving a stale JS handle that no longer exists in
+          // Rapier.
+          for (const current of this.derivedConstraints.values())
+            this.removeNativeConstraint(current.handle);
+          this.derivedConstraints.clear();
+          if (old !== undefined) {
+            for (const shape of old.shapes) {
+              const collider = (this.raw as RapierWorld).getCollider(shape.colliderHandle);
+              if (collider !== null && collider !== undefined) collider.setEnabled(true);
+            }
+            const retiredIndex = this.retiredDerivedBodies.indexOf(old);
+            if (retiredIndex >= 0) this.retiredDerivedBodies.splice(retiredIndex, 1);
+            this.derivedBodies.set(record.input.entity, old);
+            this.derivedBodySources.set(record.input.entity, {
+              sourceKey: old.sourceKey,
+              revision: old.revision,
+            });
+          }
+          for (const native of record.nativeColliders) {
+            const collider = (this.raw as RapierWorld).getCollider(native.handle);
             if (collider !== null && collider !== undefined) collider.setEnabled(false);
           }
-          this.retiredDerivedBodies.push(old);
-        }
-        for (const constraint of record.input.constraints ?? []) {
-          const previous = this.derivedConstraints.get(constraint.id);
-          if (previous !== undefined) this.removeNativeConstraint(previous.handle);
-          const staged = stagedConstraints.get(constraint.id);
-          if (staged !== undefined) this.derivedConstraints.set(constraint.id, staged);
-        }
-        const shapes: DerivedShapeRecord[] = record.input.shapes.map(
-          (shape: VoxelShapeInput, index: number) => ({
-            input: shape as DerivedShapeRecord['input'],
-            colliderHandle: record.nativeColliders[index]?.handle as number,
-          }),
-        );
-        const committed: DerivedBodyRecord = {
-          entity: record.input.entity,
-          sourceKey: record.input.sourceKey,
-          generation: this.backendGeneration,
-          revision: record.input.revision,
-          bodyType: record.input.bodyType,
-          velocityPolicy: record.input.velocityPolicy,
-          candidateId: record.token.candidateId,
-          shapes,
-          seams: [...(record.input.seams ?? [])],
-          massProperties: record.input.massProperties,
-          constraints: [...(record.input.constraints ?? [])],
+          // Remove staged colliders before restoring mass. Rapier defers some
+          // mass-property recomputation until a collider mutation; restoring
+          // while a disabled candidate is still attached can leave an explicit
+          // override behind for the next fixed step.
+          for (const native of record.nativeColliders) this.removeNativeCollider(native.handle);
+          for (const { collider, density, enabled } of oldDensities) {
+            if (this.raw.getCollider(collider.handle) === null) continue;
+            if (density !== undefined && typeof collider.setDensity === 'function')
+              collider.setDensity(density);
+            if (typeof collider.setEnabled === 'function') collider.setEnabled(enabled);
+          }
+          let restored = true;
+          try {
+            body.setBodyType(oldBodyType, true);
+            this.restoreCommittedMass(body, old, oldAutomaticAdditionalMass);
+            body.setTranslation(oldTranslation, true);
+            body.setRotation(oldRotation, true);
+            body.setLinvel(oldVelocity, true);
+            body.setAngvel(oldAngularVelocity, true);
+            body.setEnabled(oldBodyEnabled);
+          } catch {
+            restored = false;
+          }
+          if (restored && !this.restoreNativeConstraints(oldConstraints)) restored = false;
+          if (restored) {
+            const currentMass = body.mass();
+            const currentCom = body.worldCom();
+            const currentVelocity = body.linvel();
+            const currentAngularVelocity = body.angvel();
+            const currentRotation = body.rotation();
+            restored =
+              Number.isFinite(currentMass) &&
+              Math.abs(currentMass - oldMass) <= 1e-6 * Math.max(1, Math.abs(oldMass)) &&
+              Math.abs(currentCom.x - oldCom.x) <= 1e-6 &&
+              Math.abs(currentCom.y - oldCom.y) <= 1e-6 &&
+              Math.abs(currentCom.z - oldCom.z) <= 1e-6 &&
+              Math.abs(currentVelocity.x - oldVelocity.x) <= 1e-6 &&
+              Math.abs(currentVelocity.y - oldVelocity.y) <= 1e-6 &&
+              Math.abs(currentVelocity.z - oldVelocity.z) <= 1e-6 &&
+              Math.abs(currentAngularVelocity.x - oldAngularVelocity.x) <= 1e-6 &&
+              Math.abs(currentAngularVelocity.y - oldAngularVelocity.y) <= 1e-6 &&
+              Math.abs(currentAngularVelocity.z - oldAngularVelocity.z) <= 1e-6 &&
+              Math.abs(
+                currentRotation.x * oldRotation.x +
+                  currentRotation.y * oldRotation.y +
+                  currentRotation.z * oldRotation.z +
+                  currentRotation.w * oldRotation.w,
+              ) >=
+                1 - 1e-6 &&
+              body.bodyType() === oldBodyType &&
+              body.isEnabled() === oldBodyEnabled;
+          }
+          if (old === undefined) this.derivedBodies.delete(record.input.entity);
+          else this.derivedBodies.set(record.input.entity, old);
+          if (oldSource === undefined) this.derivedBodySources.delete(record.input.entity);
+          else this.derivedBodySources.set(record.input.entity, oldSource);
+          if (oldPublication === undefined) this.derivedPublications.delete(record.input.entity);
+          else this.derivedPublications.set(record.input.entity, oldPublication);
+          const entityRecord = this.entityMap.get(record.input.entity);
+          if (entityRecord !== undefined && oldAutomaticRecordMass !== undefined)
+            entityRecord.automaticAdditionalMass = oldAutomaticRecordMass;
+          return restored;
         };
-        // The sole cross-domain observation boundary: no native operation
-        // follows a successful geometry commit before recording this body.
-        // A refused commit takes the same complete native rollback below.
-        if (record.commitGeometry !== undefined) {
-          this.activeDerivedAdmission = record;
+        const restore = (undo: () => boolean): boolean => {
           try {
-            geometryCommitUncertain = true;
-            const geometry = record.commitGeometry();
-            geometryCommitUncertain = false;
-            if (!geometry.ok) throw geometry.error;
-          } finally {
-            this.activeDerivedAdmission = undefined;
+            return undo();
+          } catch {
+            return false;
           }
-          delete record.commitGeometry;
-        }
-        this.derivedBodies.set(record.input.entity, committed);
-        const entityRecord = this.entityMap.get(record.input.entity);
-        if (entityRecord !== undefined) {
-          entityRecord.automaticAdditionalMass =
-            record.input.massProperties?.mode === 'explicit' ? 0 : entityRecord.additionalMass;
-        }
-        this.derivedBodySources.set(record.input.entity, {
-          sourceKey: record.input.sourceKey,
-          revision: record.input.revision,
-        });
-        this.derivedFailures.delete(record.input.entity);
-        record.state = 'queued';
-        this.pendingDerivedCandidates.delete(id);
-      } catch (cause) {
-        for (const staged of stagedConstraints.values()) this.removeNativeConstraint(staged.handle);
-        // The commit path may already have removed/replaced a native joint
-        // before a later body mutation fails. Clear every current native joint
-        // now; the old records are recreated after the body state is restored
-        // instead of leaving a stale JS handle that no longer exists in
-        // Rapier.
-        for (const current of this.derivedConstraints.values())
-          this.removeNativeConstraint(current.handle);
-        this.derivedConstraints.clear();
-        if (old !== undefined) {
-          for (const shape of old.shapes) {
-            const collider = (this.raw as RapierWorld).getCollider(shape.colliderHandle);
-            if (collider !== null && collider !== undefined) collider.setEnabled(true);
+        };
+        try {
+          for (const constraint of record.input.constraints ?? []) {
+            const created = this.createNativeConstraint(constraint);
+            if (!created.ok) throw created.error;
+            stagedConstraints.set(constraint.id, {
+              input: { ...constraint },
+              handle: created.value.handle,
+            });
+          }
+          if (record.input.bodyType !== undefined) {
+            const RAPIER = this.rapierModule as RapierWorld;
+            const bodyType =
+              record.input.bodyType === 'static'
+                ? RAPIER.RigidBodyType.Fixed
+                : record.input.bodyType === 'kinematic'
+                  ? RAPIER.RigidBodyType.KinematicPositionBased
+                  : RAPIER.RigidBodyType.Dynamic;
+            body.setBodyType(bodyType, true);
+          }
+          for (const native of record.nativeColliders) {
+            const collider = (this.raw as RapierWorld).getCollider(native.handle);
+            if (collider === null || collider === undefined)
+              throw new Error('candidate collider disappeared');
+            collider.setEnabled(true);
+          }
+          const nativeById = new Map(
+            record.input.shapes.map((shape: VoxelShapeInput, index: number) => [
+              shape.id,
+              record.nativeColliders[index]?.handle as number,
+            ]),
+          );
+          for (const seam of record.input.seams ?? []) {
+            const firstHandle = nativeById.get(seam.shapeA);
+            const secondHandle = nativeById.get(seam.shapeB);
+            const first =
+              firstHandle === undefined
+                ? undefined
+                : (this.raw as RapierWorld).getCollider(firstHandle);
+            const second =
+              secondHandle === undefined
+                ? undefined
+                : (this.raw as RapierWorld).getCollider(secondHandle);
+            if (first === undefined || second === undefined || first === null || second === null) {
+              throw new Error(`derived seam references missing shape ${seam.shapeA}`);
+            }
+            first.combineVoxelStates(second, seam.offset[0], seam.offset[1], seam.offset[2]);
+          }
+          if (record.input.motion?.rotation !== undefined) {
+            const [x, y, z, w] = record.input.motion.rotation;
+            body.setRotation({ x, y, z, w }, true);
+          }
+          this.applyDerivedMass(
+            body,
+            record.input.massProperties,
+            oldCom,
+            record.input.velocityPolicy ?? 'preserve',
+            this.entityMap.get(record.input.entity)?.additionalMass ?? 0,
+            record.input.entity,
+            record.input.shapes,
+            record.nativeColliders,
+          );
+          if (record.input.motion !== undefined) {
+            const currentCom = body.worldCom();
+            const targetCom = record.input.motion.centerOfMass;
+            const translation = body.translation();
+            body.setTranslation(
+              {
+                x: translation.x + targetCom[0] - currentCom.x,
+                y: translation.y + targetCom[1] - currentCom.y,
+                z: translation.z + targetCom[2] - currentCom.z,
+              },
+              true,
+            );
+            body.setLinvel(
+              {
+                x: record.input.motion.linearVelocity[0],
+                y: record.input.motion.linearVelocity[1],
+                z: record.input.motion.linearVelocity[2],
+              },
+              true,
+            );
+            body.setAngvel(
+              {
+                x: record.input.motion.angularVelocity[0],
+                y: record.input.motion.angularVelocity[1],
+                z: record.input.motion.angularVelocity[2],
+              },
+              true,
+            );
+          }
+          // A body revision invalidates any committed joint that still names
+          // that body's previous source/revision. Keep this tied to the body
+          // that is actually committing: a different queued endpoint may still
+          // fail, in which case its old joint remains valid and must not be
+          // removed speculatively.
+          const committedSources = new Map(this.derivedBodySources);
+          committedSources.set(record.input.entity, {
+            sourceKey: record.input.sourceKey,
+            revision: record.input.revision,
+          });
+          const replacementConstraintIds = new Set(
+            (record.input.constraints ?? []).map((constraint) => constraint.id),
+          );
+          for (const [constraintId, current] of [...this.derivedConstraints]) {
+            if (
+              replacementConstraintIds.has(constraintId) ||
+              this.constraintDependenciesMatch(current.input, committedSources)
+            )
+              continue;
+            this.removeNativeConstraint(current.handle);
+            this.derivedConstraints.delete(constraintId);
+          }
+          if (old !== undefined) {
+            for (const shape of old.shapes) {
+              const collider = (this.raw as RapierWorld).getCollider(shape.colliderHandle);
+              if (collider !== null && collider !== undefined) collider.setEnabled(false);
+            }
+            this.retiredDerivedBodies.push(old);
+          }
+          for (const constraint of record.input.constraints ?? []) {
+            const previous = this.derivedConstraints.get(constraint.id);
+            if (previous !== undefined) this.removeNativeConstraint(previous.handle);
+            const staged = stagedConstraints.get(constraint.id);
+            if (staged !== undefined) this.derivedConstraints.set(constraint.id, staged);
+          }
+          const shapes: DerivedShapeRecord[] = record.input.shapes.map(
+            (shape: VoxelShapeInput, index: number) => ({
+              input: shape as DerivedShapeRecord['input'],
+              colliderHandle: record.nativeColliders[index]?.handle as number,
+            }),
+          );
+          const committed: DerivedBodyRecord = {
+            entity: record.input.entity,
+            sourceKey: record.input.sourceKey,
+            generation: this.backendGeneration,
+            revision: record.input.revision,
+            bodyType: record.input.bodyType,
+            velocityPolicy: record.input.velocityPolicy,
+            candidateId: record.token.candidateId,
+            shapes,
+            seams: [...(record.input.seams ?? [])],
+            massProperties: record.input.massProperties,
+            constraints: [...(record.input.constraints ?? [])],
+          };
+          // The sole cross-domain observation boundary: no native operation
+          // follows a successful geometry commit before recording this body.
+          // A refused commit takes the same complete native rollback below.
+          const commitGeometry =
+            record === group[group.length - 1]
+              ? (record.batch?.commitGeometry ?? record.commitGeometry)
+              : undefined;
+          if (commitGeometry !== undefined) {
+            this.activeDerivedAdmission = record;
+            try {
+              geometryCommitUncertain = true;
+              const geometry = commitGeometry();
+              geometryCommitUncertain = false;
+              if (!geometry.ok) throw geometry.error;
+            } finally {
+              this.activeDerivedAdmission = undefined;
+            }
+            delete record.commitGeometry;
+          }
+          this.derivedBodies.set(record.input.entity, committed);
+          const entityRecord = this.entityMap.get(record.input.entity);
+          if (entityRecord !== undefined) {
+            entityRecord.automaticAdditionalMass =
+              record.input.massProperties?.mode === 'explicit' ? 0 : entityRecord.additionalMass;
           }
-          const retiredIndex = this.retiredDerivedBodies.indexOf(old);
-          if (retiredIndex >= 0) this.retiredDerivedBodies.splice(retiredIndex, 1);
-          this.derivedBodies.set(record.input.entity, old);
           this.derivedBodySources.set(record.input.entity, {
-            sourceKey: old.sourceKey,
-            revision: old.revision,
+            sourceKey: record.input.sourceKey,
+            revision: record.input.revision,
           });
+          this.derivedFailures.delete(record.input.entity);
+          record.state = 'queued';
+          this.pendingDerivedCandidates.delete(id);
+          undos.push(rollback);
+        } catch (cause) {
+          let restored = restore(rollback);
+          for (const undo of undos.reverse()) {
+            if (!restore(undo)) restored = false;
+          }
+          const error =
+            cause instanceof DerivedPhysicsError
+              ? cause
+              : new DerivedPhysicsError(
+                  'derived-backend-failed',
+                  'derived admission either commits completely or preserves the prior body state',
+                  'inspect the failure receipt and rebuild the PhysicsWorld if recovery is required',
+                  {
+                    entity: record.input.entity,
+                    candidateId: record.token.candidateId,
+                    reason: cause instanceof Error ? cause.message : String(cause),
+                  },
+                );
+          // A thrown consumer callback can have changed ECS state. Native
+          // rollback alone cannot certify any member of that combined group.
+          if (geometryCommitUncertain) restored = false;
+          for (const member of group) {
+            if (!restored) {
+              this.derivedPoisonedEntities.add(member.input.entity);
+              this.derivedBodies.delete(member.input.entity);
+              this.derivedPublications.delete(member.input.entity);
+            }
+            this.rememberDerivedFailure(
+              member,
+              error,
+              restored ? 'old-state-retained' : 'rebuild-required',
+            );
+          }
+          break;
         }
-        for (const native of record.nativeColliders) {
-          const collider = (this.raw as RapierWorld).getCollider(native.handle);
-          if (collider !== null && collider !== undefined) collider.setEnabled(false);
-        }
-        // Remove staged colliders before restoring mass. Rapier defers some
-        // mass-property recomputation until a collider mutation; restoring
-        // while a disabled candidate is still attached can leave an explicit
-        // override behind for the next fixed step.
-        for (const native of record.nativeColliders) this.removeNativeCollider(native.handle);
-        for (const { collider, density, enabled } of oldDensities) {
-          if (this.raw.getCollider(collider.handle) === null) continue;
-          if (density !== undefined && typeof collider.setDensity === 'function')
-            collider.setDensity(density);
-          if (typeof collider.setEnabled === 'function') collider.setEnabled(enabled);
-        }
-        let restored = true;
-        try {
-          body.setBodyType(oldBodyType, true);
-          this.restoreCommittedMass(body, old, oldAutomaticAdditionalMass);
-          body.setTranslation(oldTranslation, true);
-          body.setRotation(oldRotation, true);
-          body.setLinvel(oldVelocity, true);
-          body.setAngvel(oldAngularVelocity, true);
-          body.setEnabled(oldBodyEnabled);
-        } catch {
-          restored = false;
-        }
-        if (restored && !this.restoreNativeConstraints(oldConstraints)) restored = false;
-        if (restored) {
-          const currentMass = body.mass();
-          const currentCom = body.worldCom();
-          const currentVelocity = body.linvel();
-          const currentAngularVelocity = body.angvel();
-          restored =
-            Number.isFinite(currentMass) &&
-            Math.abs(currentMass - oldMass) <= 1e-6 * Math.max(1, Math.abs(oldMass)) &&
-            Math.abs(currentCom.x - oldCom.x) <= 1e-6 &&
-            Math.abs(currentCom.y - oldCom.y) <= 1e-6 &&
-            Math.abs(currentCom.z - oldCom.z) <= 1e-6 &&
-            Math.abs(currentVelocity.x - oldVelocity.x) <= 1e-6 &&
-            Math.abs(currentVelocity.y - oldVelocity.y) <= 1e-6 &&
-            Math.abs(currentVelocity.z - oldVelocity.z) <= 1e-6 &&
-            Math.abs(currentAngularVelocity.x - oldAngularVelocity.x) <= 1e-6 &&
-            Math.abs(currentAngularVelocity.y - oldAngularVelocity.y) <= 1e-6 &&
-            Math.abs(currentAngularVelocity.z - oldAngularVelocity.z) <= 1e-6 &&
-            body.bodyType() === oldBodyType &&
-            body.isEnabled() === oldBodyEnabled;
-        }
-        if (old === undefined) this.derivedBodies.delete(record.input.entity);
-        else this.derivedBodies.set(record.input.entity, old);
-        if (oldSource === undefined) this.derivedBodySources.delete(record.input.entity);
-        else this.derivedBodySources.set(record.input.entity, oldSource);
-        if (oldPublication === undefined) this.derivedPublications.delete(record.input.entity);
-        else this.derivedPublications.set(record.input.entity, oldPublication);
-        const entityRecord = this.entityMap.get(record.input.entity);
-        if (entityRecord !== undefined && oldAutomaticRecordMass !== undefined)
-          entityRecord.automaticAdditionalMass = oldAutomaticRecordMass;
-        const error =
-          cause instanceof DerivedPhysicsError
-            ? cause
-            : new DerivedPhysicsError(
-                'derived-backend-failed',
-                'derived admission either commits completely or preserves the prior body state',
-                'inspect the failure receipt and rebuild the PhysicsWorld if recovery is required',
-                {
-                  entity: record.input.entity,
-                  candidateId: record.token.candidateId,
-                  reason: cause instanceof Error ? cause.message : String(cause),
-                },
-              );
-        // A thrown consumer callback may already have changed its ECS domain.
-        // Native rollback alone cannot certify the combined state in that case.
-        if (geometryCommitUncertain) restored = false;
-        if (!restored) {
-          this.derivedPoisonedEntities.add(record.input.entity);
-          this.derivedBodies.delete(record.input.entity);
-          this.derivedPublications.delete(record.input.entity);
-        }
-        this.rememberDerivedFailure(
-          record,
-          error,
-          restored ? 'old-state-retained' : 'rebuild-required',
-        );
       }
     }
   }
@@ -1847,6 +2078,9 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
         }),
       );
       candidate.state = 'published';
+      // Admission membership is transient. A long-lived sibling must not keep
+      // a replaced member's private shape buffers or callback closure alive.
+      delete candidate.batch;
     }
   }
 
@@ -1893,6 +2127,9 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
         { x: frame[0], y: frame[1], z: frame[2], w: frame[3] },
         true,
       );
+      // Rapier defers additional mass updates. Admission reads worldCom below
+      // before stepping, so refresh now or COM restoration shifts the body twice.
+      body.recomputeMassPropertiesFromColliders();
     } else {
       this.restoreAutomaticDensities(
         entity,
@@ -1942,6 +2179,7 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
         { x: frame[0], y: frame[1], z: frame[2], w: frame[3] },
         true,
       );
+      body.recomputeMassPropertiesFromColliders();
       return;
     }
     this.restoreAutomaticMass(body, automaticAdditionalMass);
@@ -2958,6 +3196,10 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
     );
     if (collider === undefined) {
       const record = this.entityMap.get(entity);
+      // A new fragment can admit derived shapes in this same fixed step.
+      // Resolve Rapier's deferred descriptor mass before rollback captures the
+      // baseline, rather than comparing an uninitialized zero to restored mass.
+      this.restoreAutomaticMass(body, record?.additionalMass ?? 0);
       if (record !== undefined) record.automaticAdditionalMass = record.additionalMass;
       return;
     }
@@ -3190,6 +3432,23 @@ export class RapierPhysicsWorld3D implements PhysicsWorld {
   removeEntity(entity: number): void {
     const record = this.entityMap.get(entity);
     if (!record) return;
+    for (const candidate of this.derivedCandidates.values()) {
+      if (
+        candidate.input.entity !== entity ||
+        candidate.batch === undefined ||
+        (candidate.state !== 'ready' && candidate.state !== 'queued')
+      )
+        continue;
+      this.rejectPreparedCandidate(
+        candidate,
+        new DerivedPhysicsError(
+          'derived-body-not-found',
+          'all grouped bodies remain live until admission',
+          'prepare a new complete group after entity reconciliation',
+          { entity },
+        ),
+      );
+    }
     const derived = this.derivedBodies.get(entity);
     if (derived !== undefined) {
       for (const shape of derived.shapes) this.removeNativeCollider(shape.colliderHandle);