@@ -80,7 +80,7 @@ void VecGeomG4Navigator::locateFromWorld(const V3& point)
 /// surely as one at normal incidence, and it is kept small: TOF has layers 2.4e-8 cm apart, and a
 /// fixed push along the direction steps over them. It never goes below a thousand times the rounding
 /// of the largest coordinate, which matters far from the origin.
-double VecGeomG4Navigator::boundaryPush(const V3& point, const V3& dir) const
+double VecGeomG4Navigator::boundaryPush(const V3& point, const V3& dir)
 {
   constexpr double kMaxPush = 1.e-4; // cm along the direction
   const double big = std::max({std::abs(point.x()), std::abs(point.y()), std::abs(point.z())});
@@ -89,6 +89,7 @@ double VecGeomG4Navigator::boundaryPush(const V3& point, const V3& dir) const
   // The face just crossed: the entered daughter's, or the current volume's own.
   vecgeom::NavigationState const& st = mWouldEnter ? mNextState : mCurState;
   double cosn = 1.;
+  mPushNormalValid = false;
   if (!st.IsOutside() && st.Top() != nullptr) {
     vecgeom::Transformation3D m;
     st.TopMatrix(m);
@@ -98,6 +99,10 @@ double VecGeomG4Navigator::boundaryPush(const V3& point, const V3& dir) const
     if (c > 0. && n.Mag2() > 0.5) {
       cosn = c;
     }
+    if (n.Mag2() > 0.5) {
+      mPushNormal = m.InverseTransformDirection(n);
+      mPushNormalValid = true;
+    }
   }
   return std::max(rounding, std::min(mPushDepth / cosn, kMaxPush));
 }
@@ -123,10 +128,20 @@ G4double VecGeomG4Navigator::ComputeStep(const G4ThreeVector& globalPoint, const
     newSafety = mLastSafety;
   }
 
-  // The step is computed on a copy. The state, and the volume blocked by the last exit, stay as
-  // the locate left them for every call until the next locate, which is what the field propagator
-  // relies on when it calls this from trial points along the curve.
+  // The step is computed on a copy. The state stays as the locate left it for every call until the
+  // next locate, which is what the field propagator relies on when it calls this from trial points
+  // along the curve. The volume the last crossing left is blocked in the first call only, and only
+  // while the direction points away from it; a track turning back into it must see its boundary.
   mStepState = mCurState;
+  if (mExitBlockPending) {
+    const bool block = samePoint(globalPoint, mLastLocatedPoint) &&
+                       (mExitNormalFromPush ? directionLeaves(mPushNormal, toDir(direction))
+                                            : directionLeaves(mExitedState, toVG(globalPoint), toDir(direction)));
+    if (!block) {
+      mStepState.SetLastExited(mEmptyState.GetLastExitedState());
+    }
+    clearLastExited();
+  }
   const double limit = std::min(proposedStepLength * kG4ToVG, static_cast<double>(vecgeom::kInfLength));
   double safety = 0.;
   double vgStep = navigator->ComputeStepAndSafety(toVG(globalPoint), toDir(direction), limit, mStepState, calcSafety,
@@ -204,6 +219,7 @@ void VecGeomG4Navigator::leaveFlushVolumes(const V3& point, const V3& dir, int m
       }
       left = mCurState.Top();
       mCurState.SetLastExited();
+      setExited(mCurState, false);
       if (mCurState.GetCurrentLevel() <= 1) {
         mCurState.Clear(); // nothing to travel in even in the world: the track left it
         return;
@@ -307,8 +323,8 @@ G4VPhysicalVolume* VecGeomG4Navigator::LocateGlobalPointAndSetup(const G4ThreeVe
     mLocatedOnBoundary = true;
   } else if (crossing) {
     // Out of the current volume: up until the point is contained, then down, never back into the
-    // volume just left; that volume stays blocked at zero distance for the next step, as
-    // G4Navigator's fBlockedPhysicalVolume.
+    // volume just left; that volume is blocked at zero distance in the next ComputeStep while the
+    // direction points away from it, as G4Navigator's fBlockedPhysicalVolume.
     mReloScratch = mCurState;
     if (mCurState.GetCurrentLevel() <= 1) {
       mCurState.Clear(); // left the world
@@ -318,6 +334,7 @@ G4VPhysicalVolume* VecGeomG4Navigator::LocateGlobalPointAndSetup(const G4ThreeVe
       vecgeom::GlobalLocator::RelocatePointFromPathForceDifferent(m.Transform(q), mCurState);
       mReloScratch.SetLastExited();
       mCurState.SetLastExited(mReloScratch.GetLastExitedState());
+      setExited(mReloScratch, true);
     }
     mLocatedOnBoundary = true;
   } else {
 
@@ -24,9 +24,10 @@ namespace o2::simsetup
 ///
 /// - ComputeStep leaves the current volume alone. It records whether the step ends on a boundary
 ///   and, for a daughter hit, the state that enters it.
-/// - The locate on a boundary relocates: into the recorded daughter, or out of the current volume,
-///   which then stays blocked for the next step. The point is first pushed across the face by a
-///   small depth, and afterwards leaves every volume it is flush with and heading out of.
+/// - The locate on a boundary relocates: into the recorded daughter, or out of the current volume.
+///   The point is first pushed across the face by a small depth, and afterwards leaves every volume
+///   it is flush with and heading out of. As in Geant4, the volume left is blocked only in the first
+///   ComputeStep after the exit, and only while the direction points away from it.
 /// - Safety is zero only at the boundary point itself.
 ///
 /// Unlike TG4VecGeomNavigator, the VecGeom geometry is converted from TGeo, not from Geant4, so one
@@ -66,9 +67,21 @@ class VecGeomG4Navigator : public VecGeomG4NavigatorBase
   void leaveFlushVolumes(const V3& point, const V3& dir, int minLevel, vecgeom::VPlacedVolume const* avoid);
   /// Sets fEnteredDaughter and fExitedMother from the paths before (mReloScratch) and after a crossing.
   void updateCrossingFlags(bool entering);
-  void clearLastExited() { mCurState.SetLastExited(mEmptyState.GetLastExitedState()); }
-  /// How far (cm) a boundary point is pushed along the direction before it is located.
-  double boundaryPush(const V3& point, const V3& dir) const;
+  void clearLastExited()
+  {
+    mCurState.SetLastExited(mEmptyState.GetLastExitedState());
+    mExitBlockPending = false;
+  }
+  /// Records the top of \a st as the volume just left, blocked in the next ComputeStep by Geant4's rule.
+  void setExited(vecgeom::NavigationState const& st, bool normalFromPush)
+  {
+    mExitedState = st;
+    mExitBlockPending = true;
+    mExitNormalFromPush = normalFromPush && mPushNormalValid;
+  }
+  /// How far (cm) a boundary point is pushed along the direction before it is located. Keeps the
+  /// global normal of the face in mPushNormal, for the exit block.
+  double boundaryPush(const V3& point, const V3& dir);
   /// The normal of the surface the last geometry-limited ComputeStep ended on, global, unit length.
   bool computeExitNormal(const G4ThreeVector& point, V3& globalNormal) const;
 
@@ -83,6 +96,11 @@ class VecGeomG4Navigator : public VecGeomG4NavigatorBase
   vecgeom::NavigationState mHistoryState; ///< the state fHistory was built from
   vecgeom::NavigationState mEmptyState;   ///< permanently empty; its last-exited entry clears others
   vecgeom::NavigationState mNormalState;  ///< the volume whose surface the last boundary step ended on
+  vecgeom::NavigationState mExitedState;  ///< the volume the last crossing left
+  bool mExitBlockPending = false;         ///< the next ComputeStep is the first after that exit
+  bool mExitNormalFromPush = false;       ///< mPushNormal is the outward normal of the volume left
+  V3 mPushNormal;                         ///< global normal of the face the last push crossed
+  bool mPushNormalValid = false;
   bool mHistoryValid = false;
 
   bool mWouldEnter = false; ///< the last ComputeStep ends by entering a daughter
 
@@ -18,8 +18,10 @@
 #include "G4SystemOfUnits.hh"
 #include "G4ThreeVector.hh"
 
+#include <VecGeom/base/Transformation3D.h>
 #include <VecGeom/base/Vector3D.h>
 #include <VecGeom/navigation/NavigationState.h>
+#include <VecGeom/volumes/PlacedVolume.h>
 
 namespace o2::simsetup
 {
@@ -48,6 +50,31 @@ class VecGeomG4NavigatorBase : public G4Navigator
   /// False if a level matches no VecGeom placement; \a state is then empty.
   bool stateFromHistory(vecgeom::NavigationState& state) const;
 
+  /// Geant4's rule for the volume a track just left (G4NormalNavigation, G4VoxelNavigation): it is
+  /// blocked only while the direction points away from it, along its outward normal \a n (global).
+  [[gnu::always_inline]] static bool directionLeaves(const V3& n, const V3& dir)
+  {
+    constexpr double kMinExitingNormalCosine = 1e-3; // as in G4NormalNavigation
+    return n.Dot(dir) >= kMinExitingNormalCosine;
+  }
+
+  /// The same, with the normal taken from \a exited, which has the volume left on top.
+  [[gnu::always_inline]] static bool directionLeaves(vecgeom::NavigationState const& exited, const V3& point,
+                                                     const V3& dir)
+  {
+    if (exited.IsOutside() || exited.Top() == nullptr) {
+      return false;
+    }
+    vecgeom::Transformation3D m;
+    exited.TopMatrix(m);
+    V3 n;
+    exited.Top()->GetUnplacedVolume()->Normal(m.Transform(point), n);
+    if (!(n.Mag2() > 0.5)) {
+      return false; // no valid exit normal: Geant4 does not block either
+    }
+    return directionLeaves(m.InverseTransformDirection(n), dir);
+  }
+
   VecGeomG4Map const& mMap;
 };
 
 
@@ -39,6 +39,7 @@ namespace o2::simsetup
 VecGeomG4PropagatingNavigator::VecGeomG4PropagatingNavigator(VecGeomG4Map const& map, bool zeroSafety)
   : VecGeomG4NavigatorBase(map), mZeroSafety(zeroSafety)
 {
+  mEmptyState.Clear();
 }
 
 VecGeomG4PropagatingNavigator::~VecGeomG4PropagatingNavigator()
@@ -69,6 +70,16 @@ G4double VecGeomG4PropagatingNavigator::ComputeStep(const G4ThreeVector& globalP
   // VecGeom's own combined entry point, rather than a step followed by a relocation of our own: it
   // is the one that knows how to descend through an assembly, whose placed volume can never be the
   // answer because it has no DistanceToOut.
+  // The adopted state marks the volume the crossing left. As in Geant4, it is blocked in the first
+  // step after the exit only, and only while the direction points away from it; a track turning
+  // back into it must see its boundary.
+  const bool block = mExitBlockPending && globalPoint.diff2(mLocatedPoint) < 1.e-20 &&
+                     directionLeaves(mPrevState, toVG(globalPoint), toDir(direction));
+  mExitBlockPending = false;
+  if (!block) {
+    mCurState.SetLastExited(mEmptyState.GetLastExitedState());
+  }
+
   double vgSafety = 0.;
   const double vgStep = navigator->ComputeStepAndSafetyAndPropagatedState(
     toVG(globalPoint), toDir(direction), limit, mCurState, mNextState, !mOnBoundary && !mZeroSafety, vgSafety);
@@ -140,11 +151,14 @@ G4VPhysicalVolume* VecGeomG4PropagatingNavigator::LocateGlobalPointAndSetup(cons
   }
 
   mPrevState = mCurState;
+  mLocatedPoint = point;
+  mExitBlockPending = false;
 
   if (!mForceReInit && relativeSearch && onBoundary && mHaveNextState) {
     // The state on the far side of the boundary was already worked out, and relocated, by the step
     // that found it. Adopting it is cheaper than locating again.
     mCurState = mNextState;
+    mExitBlockPending = mWouldExit;
   } else if (mForceReInit || !relativeSearch || onBoundary) {
     mCurState.Clear();
     vecgeom::GlobalLocator::LocateGlobalPoint(vecgeom::GeoManager::Instance().GetWorld(), toVG(point), mCurState, true);
 
@@ -50,6 +50,7 @@ class VecGeomG4PropagatingNavigator : public VecGeomG4NavigatorBase
   vecgeom::NavigationState mCurState;  ///< where the track is now
   vecgeom::NavigationState mNextState; ///< where the last computed step would put it
   vecgeom::NavigationState mPrevState; ///< where it was before the last boundary crossing
+  vecgeom::NavigationState mEmptyState; ///< permanently empty; its last-exited entry clears others
 
   bool mZeroSafety = false;
   bool mHaveNextState = false; ///< mNextState holds the result of a geometry-limited step
@@ -62,6 +63,8 @@ class VecGeomG4PropagatingNavigator : public VecGeomG4NavigatorBase
   bool mOnBoundary = false;  ///< the current point sits on a boundary
   bool mForceReInit = false; ///< next locate must start from the world, the state is suspect
   bool mCrossed = false;     ///< the last locate acted on a boundary crossing
+  bool mExitBlockPending = false;                ///< the next step is the first after leaving mPrevState's volume
+  G4ThreeVector mLocatedPoint{-1e8, -1e8, -1e8}; ///< where the last locate put the track
 
   int mZeroSteps = 0;
   long mNudgedSteps = 0;