sim(#750): finalize waitCrossing conversion — fix tolerance gap, correct comment, add regression tests

Verifies and closes out the waitCrossing conversion from 16fb70c now that
kDisco 0.6.1-SNAPSHOT (with waitCrossing) is locally publishable and the
build works again:

- Generator.kt: correct a comment that overclaimed velocity-target events
  are root-found — only block-boundary and tail-entry were converted;
  Motor's AccelerationStopCondition still uses plain waitUntil. The
  Motor/dtMax follow-up is now tracked separately in issue #760.

- SimpleTestProcess.kt: fix a real regression exposed by the conversion.
  This test coordinator never runs Generator, so it silently relied on
  kDisco's own raw defaults (dtMin=1e-5, maxAbsError=1e-5 — nearly equal
  in magnitude). The waitCrossing guards intentionally leave a structural
  gap of exactly `dtMin` at the moment a threshold is reached (see the
  existing Train.kt comments on why that slack is necessary), which is
  negligible against the intended maxAbsError=1e-2 but trips
  LengthChecker's invariant when left at kDisco's near-equal raw
  defaults. Confirmed via A/B test against 74cd41b (same kDisco version,
  pre-conversion Train.kt) that this is new, not pre-existing. Fixed by
  configuring the same tolerances Generator.startAction() sets.

- SimpleTestProcessTest.kt: relax an assertion that assumed `position`
  stays >= 0 immediately after a block-boundary crossing. The
  waitCrossing guard deliberately fires `dtMin` short of the boundary so
  it reliably crosses zero instead of asymptoting forever; this leaves a
  bounded, harmless negative transient that was never a documented
  invariant.

- SimpleLinearTrackTestProcessTest.kt: add an explicit regression test
  proving both converted call sites fire correctly end-to-end.

Verified locally: kDisco published to mavenLocal from
copilot/add-zero-crossing-detection (feaa058), full build/test/
integrationTest/heavyTest all green (0 failures across all JUnit reports).

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>

Author: bedaHovorka

core/src/commonMain/kotlin/cz/vutbr/fit/interlockSim/sim/Generator.kt

@@ -31,11 +31,13 @@ open class Generator(
 
 	override suspend fun startAction() {
 		dtMin = 1e-6
-		// Block-boundary and velocity-target events are now located by kDisco root-finding
+		// Block-boundary and tail-entry events are now located by kDisco root-finding
 		// (`Process.waitCrossing`, see Train.kt) rather than by step granularity, so `dtMax` no
-		// longer has to be tiny to keep event overshoot negligible. Raising it to kDisco's natural
-		// value lets the adaptive RKF45 error controller pick large steps during cruise, cutting
-		// derivative evaluations by orders of magnitude (Issue #750).
+		// longer has to be tiny to keep *those* events' overshoot negligible. Motor's
+		// AccelerationStopCondition (velocity-target detection, Train.kt) is NOT yet converted —
+		// it still relies on step granularity via plain `waitUntil` — so `dtMax` is deliberately
+		// left unchanged here rather than raised further; converting Motor and re-tuning dtMax
+		// is tracked separately (Issue #760, follow-up to #750).
 		dtMax = 1e-3
 		maxRelError = 1e-2
 		maxAbsError = 1e-2

core/src/commonTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcess.kt

@@ -10,6 +10,10 @@
 package cz.vutbr.fit.interlockSim.sim
 
 import cz.ksimulantenbande.kdisco.Process
+import cz.ksimulantenbande.kdisco.dtMax
+import cz.ksimulantenbande.kdisco.dtMin
+import cz.ksimulantenbande.kdisco.maxAbsError
+import cz.ksimulantenbande.kdisco.maxRelError
 import io.github.oshai.kotlinlogging.KotlinLogging
 
 /**
@@ -121,6 +125,18 @@ class SimpleTestProcess(
 	 * The train's actions() method will then begin executing.
 	 */
 	override suspend fun startAction() {
+		// Mirrors Generator.startAction()'s physics tolerances (see Generator.kt). Unlike
+		// Generator, this coordinator never runs one, so without this the simulation falls
+		// back to kDisco's own raw defaults (dtMin=1e-5, maxAbsError=1e-5 -- nearly equal in
+		// magnitude). Train's block-boundary/tail-entry waitCrossing guards (Train.kt) are
+		// designed to leave a structural gap of exactly `dtMin` at the moment a threshold is
+		// reached (see Train.kt comments), which is negligible against the intended
+		// maxAbsError=1e-2 but can spuriously trip LengthChecker's invariant when dtMin and
+		// maxAbsError are left at kDisco's near-equal raw defaults instead.
+		dtMin = 1e-6
+		dtMax = 1e-3
+		maxRelError = 1e-2
+		maxAbsError = 1e-2
 		logger.debug { "SimpleTestProcess: Starting test with train ${train.name}" }
 		Process.activate(train) // CRITICAL: activate the train process
 	}

core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleLinearTrackTestProcessTest.kt

@@ -61,14 +61,15 @@ class SimpleLinearTrackTestProcessTest : KoinTestBase() {
 
 	private fun specAB(
 		inTime: Double = 1.0,
-		outTime: Double = 15.0
+		outTime: Double = 15.0,
+		length: Double = 20.0
 	): SimpleLinearTrackTestProcess.TrainSpec =
 		SimpleLinearTrackTestProcess.TrainSpec(
 			inName = "A",
 			outName = "B",
 			inTime = inTime,
 			outTime = outTime,
-			length = 20.0
+			length = length
 		)
 
 	/** Scenario 1: train follows a pre-reserved path A→B and makes genuine forward progress. */
@@ -244,4 +245,53 @@ class SimpleLinearTrackTestProcessTest : KoinTestBase() {
 		assertThat(train.totalDistance).isGreaterThan(distanceBeforeRelease)
 		assertThat(process.getBlockTransitions(train.name)).isGreaterThan(0)
 	}
+
+	/**
+	 * Scenario 5 (Issue #750/#760 follow-up): proves the `waitCrossing` block-boundary
+	 * conversion (Train.kt:254) actually locates each section boundary rather than hanging.
+	 * The A->Sem->B topology (linearPathWithSemaphoreSimulation) has two 100.0m blocks, so
+	 * reaching B means both boundary crossings fired; total distance exceeding the first
+	 * block's length is direct evidence the A->Sem crossing was located correctly.
+	 */
+	@Test
+	@Timeout(value = 60, unit = TimeUnit.SECONDS)
+	fun `train crosses both block boundaries and reaches destination`() {
+		val ctx = loadLinearContext()
+		val inOuts = ctx.getInOuts().toList()
+		val a = inOuts.single { it.name == "A" }
+		val b = inOuts.single { it.name == "B" }
+		val reservationService = ctx.getRoutingServices().getPathReservationService()
+
+		var capturedTrain: Train? = null
+		val process =
+			SimpleLinearTrackTestProcess(
+				ctx,
+				endTime = 50L,
+				trainSpecs = listOf(specAB()),
+				onTrainCreated = { train ->
+					capturedTrain = train
+					val res = reservationService.reservePath(train.name, a, b)
+					assertThat(res).isInstanceOf<PathReservationService.ReservationResult.Success>()
+				}
+			)
+		ctx.setMainProcess(process)
+		ctx.run()
+
+		val train = requireNotNull(capturedTrain) { "onTrainCreated was never called" }
+		// Reaching B proves both waitCrossing block-boundary calls (A->Sem, Sem->B) fired.
+		assertThat(process.getTrainsExited()).isEqualTo(1)
+		// Exceeding the first block's length (100.0m) is direct evidence the A->Sem
+		// waitCrossing call actually located that boundary rather than stalling on it.
+		assertThat(train.totalDistance).isGreaterThan(100.0)
+	}
+
+	// Note: the tail-entry "already satisfied" branch (Train.kt:1072, `if (front.getTotalDistance()
+	// < tailEntryThreshold)`) is only reachable when `length <= dtMin` (1e-6) -- but `dtMin` is
+	// itself far below `ContinuousInvariantChecker`'s `maxAbsError` (1e-2), i.e. below the
+	// simulation's own numerical noise floor for front/tail position tracking. An end-to-end
+	// scenario exercising that branch (tried during this change's verification, e.g.
+	// length = 1e-7) reliably trips the invariant checker's FATAL guard well before completion --
+	// independent of waitUntil vs waitCrossing, since it is a property of train-length realism,
+	// not of the crossing-detection primitive. This degenerate branch is effectively unreachable
+	// for any physically valid train and is not exercised here for that reason.
 }

core/src/jvmTest/kotlin/cz/vutbr/fit/interlockSim/sim/SimpleTestProcessTest.kt

@@ -247,7 +247,13 @@ class SimpleTestProcessTest : KoinTestBase() {
 			val finalState = testProcess.getTrainState()
 			assertThat(finalState).isNotNull()
 			assertThat(finalState.velocity).isGreaterThanOrEqualTo(0.0)
-			assertThat(finalState.position).isGreaterThanOrEqualTo(0.0)
+			// `position` can be transiently negative by up to `dtMin` immediately after a
+			// block-boundary crossing (Train.kt:257, `position.state -= nextLength`) -- the
+			// `waitCrossing` guard intentionally fires `dtMin` short of the boundary so it
+			// reliably crosses zero rather than asymptoting forever (see Train.kt comments
+			// on the block-boundary waitCrossing call). This was never a documented
+			// invariant; tolerate the bounded transient rather than requiring an exact >= 0.
+			assertThat(finalState.position).isGreaterThanOrEqualTo(-1e-5)
 		}
 	}
 }