How do I decerate in time to not overshot a target?

Using the following code, the object often overshoots its target. I believe variable time steps are to blame. The higher the max speed, the larger the overshoot in absolute terms, though it seems to stay relatively consistent . Often the overshoot is only a pixel or two, but its obvious. I also tried snapping to target when close enough and slow enough, but to work, the within range needs to be high, and is obvious.

Is there an established way to deal with this problem in variable time step games? Ideally, I don't want to stop early, or begin decelerating any sooner than needed, but I wish to respect maximum acceleration/deceleration rates.

//Acceleration and deceleration are equal. 
DistanceToStop = (Velocity/Acceleration) * velocity * 0.5;
DirectionToTarget = sign(Target - CurrentPosition);
AccelerationThisTick = Acceleration * dt * DirectionToTarget;

//reverse acceleration direction for brakes
if (distanceToStop >= distancetoTarget) 
	AccelerationThisTick *= -1;

//Integration (doesn't make a difference between this and Euler - the overshooting //still occurs)
CurrentPosition += (Velocity * dt) + (AccelerationThisTick * dt * 0.5);
Velocity += AccelerationThisTick;

After more tests I'm finding that stoppingDist=velocity*velocity/2/acceleration formula not well suited to stop on a fixed spot. You can compare it with the current distance to know when to start slowing down, but it will always be a bit late so it will overshoot the target position as you've seen. I also find it a bit annoying to have to handle the case where the velocity is away from the target.

Anyways, here is one partial solution. For simplicity I'm just covering the case where the target is to the right of the position. I use a variable to store the state since we have to clamp the position and speed when moving. The result would be stopping at the target and discarding any remaining velocity.

if state=normal
-- //accelerate toward target
-- velocity+=acceleration*dt
-- position+=velocity*dt
-- distance2target = distance(position, target)
-- if distance2target < velocity*velocity/2/acceleration
-- -- state=slowing
if state=slowing
-- velocity= max(0, velocity-acceleration*dt) 
-- distance2target -= velocity*dt
-- position -= velocity*dt
-- if distance2target<0
-- -- position-=distance2target
-- -- velocity=0
-- -- state=arrived

https://www.dropbox.com/scl/fi/qoowuphapihsbvl0vg7lm/arrivalSteeringBehavior.capx?rlkey=quochzw7cd7fgp51elzqb2xx7&dl=1

https://www.dropbox.com/scl/fi/mjw9c25v91mezo18n7foj/dampedspringArrive.capx?rlkey=9rjkwlv09i5qc8uu17k89ucip&dl=1