Swapping particles one tick late

[100-TomatoJuice]

I have a falling sand simulation where particles that are denser can swap with lesser dense particles. With the code below, the particles do swap, but the other_entity takes one tick of the simulation to update its position. According to logs, the positions do correctly swap, but this change isn't seen until the next tick. I'm using bevy_ecs_tilemap if that changes anything. I'm happy to give more information about the problem if needed.

What happens

▒ Sand (moving ↓) __________________ One tick later_ █ Water
█ Water (still)_____ ▒ Sand + Water_________________ ▒ Sand

What should happen

▒ Sand (moving ↓) _ Same tick _ █ Water
█ Water (still)___________________▒ Sand

fn build(&self, app: &mut App) {
    app.add_system(update_particles.run_if(on_timer(Duration::from_secs_f32(1.0 / 1.0))));
}

pub fn update_particles(
    mut tilemap_query: Query<&mut TileStorage>, 
    mut particle_query: Query<(Entity, &mut Velocity)>,
    mut position_query: Query<&mut TilePos>,
    density_query: Query<&Density>,
){
    let mut storage = tilemap_query.single_mut();

    for (entity, mut velocity) in particle_query.iter_mut(){
        let density = density_query.get(entity).expect("Density should be on every particle entity");
        let mut position = position_query.get_mut(entity).expect("TilePos should be on every particle entity");

        let step_data = step_particle(density, &position, &mut velocity, &density_query, &mut storage);

        let swapped = update_particle_storage(entity, &mut position, &step_data, &mut storage);
        
        // Handles `other_entity` swapping here to avoid Rust mutilbily error
        if swapped{
            let mut swapped_pos = position_query.get_mut(step_data.other_entity.unwrap()).unwrap();

            swapped_pos.x = step_data.new_x as u32;
            swapped_pos.y = step_data.new_y as u32;
        }
    }
}

fn update_particle_storage(
    current_entity: Entity, 
    mut current_pos: &mut TilePos, 
    step_data: &StepData,
    matrix: &mut TileStorage,
) -> bool{
    if let Some(other_entity) = step_data.other_entity{
        if step_data.swap{
            matrix.remove(&current_pos);

            current_pos.x = step_data.other_x as u32;
            current_pos.y = step_data.other_y as u32;

            matrix.set(&current_pos, current_entity);
            matrix.set(&TilePos::new(step_data.new_x as u32, step_data.new_y as u32), other_entity);
            
            return true;
        }
    }
    
    if !step_data.moved {
        return false;
    }

    matrix.remove(&current_pos);

    current_pos.x = step_data.new_x as u32;
    current_pos.y = step_data.new_y as u32;

    matrix.set(&current_pos, current_entity);

    false
}