fix: align smoothing feasibility and option flow

ClumsyPilot/tests/verify_path_smoothing_algorithm_input.ps1

@@ -0,0 +1,121 @@
+param([string]$AssemblyPath = (Join-Path $PSScriptRoot '..\bin\Debug\netstandard2.0\ClumsyPilot.dll'))
+
+$ErrorActionPreference = 'Stop'
+$assembly = [Reflection.Assembly]::LoadFrom((Resolve-Path $AssemblyPath))
+
+function Assert-True($Actual, [string]$Message) {
+    if (-not $Actual) { throw $Message }
+}
+
+function Assert-Near([double]$Expected, [double]$Actual, [string]$Message) {
+    if ([Math]::Abs($Expected - $Actual) -gt 0.000000001) {
+        throw "$Message Expected=$Expected Actual=$Actual"
+    }
+}
+
+function Assert-Throws([scriptblock]$Action, [string]$Message) {
+    try {
+        & $Action
+    }
+    catch {
+        return
+    }
+
+    throw $Message
+}
+
+function Get-RequiredType([string]$Name) {
+    return $assembly.GetType($Name, $true)
+}
+
+function Get-RequiredProperty($Type, [string]$Name) {
+    $property = $Type.GetProperty($Name, [Reflection.BindingFlags]'Instance,Public,NonPublic')
+    Assert-True ($null -ne $property) ("Missing property: " + $Name)
+    Assert-True (-not $property.CanWrite) ("Snapshot property must be get-only: " + $Name)
+    return $property
+}
+
+$root = 'MultiWheelC.TrajectoryPlanning.PathSmoothing.'
+$algorithms = $root + 'Algorithms.'
+$coarsePath = 'MultiWheelC.TrajectoryPlanning.CoarsePath.'
+$mapping = 'MultiWheelC.TrajectoryPlanning.Mapping.'
+
+$snapshotType = Get-RequiredType ($algorithms + 'SmoothingOptionsSnapshot')
+$inputType = Get-RequiredType ($algorithms + 'SmoothingAlgorithmInput')
+$configurationType = Get-RequiredType ($root + 'PathSmoothingConfiguration')
+$requestType = Get-RequiredType ($root + 'PathSmoothingRequest')
+$preparedPathType = Get-RequiredType ($root + 'Processing.PreparedPath')
+$mapType = Get-RequiredType ($mapping + 'PlanningGridMap')
+$vehicleType = Get-RequiredType ($coarsePath + 'VehicleParameters')
+$coarsePointType = Get-RequiredType ($coarsePath + 'CoarsePathPoint')
+$pathSegmentType = Get-RequiredType ($coarsePath + 'PathSegment')
+
+$snapshotConstructor = $snapshotType.GetConstructor([Reflection.BindingFlags]'Instance,NonPublic', $null,
+    @($configurationType), $null)
+Assert-True ($null -ne $snapshotConstructor) 'SmoothingOptionsSnapshot must be created from PathSmoothingConfiguration.'
+
+$inputConstructor = $inputType.GetConstructor([Reflection.BindingFlags]'Instance,NonPublic', $null,
+    @($preparedPathType, $mapType, $vehicleType, [double], [double], $snapshotType), $null)
+Assert-True ($null -ne $inputConstructor) 'SmoothingAlgorithmInput must accept the immutable smoothing-options snapshot at its construction boundary.'
+
+$optionNames = @(
+    'CubicBSplineEndpointTangentScale',
+    'BezierCornerHeadingThresholdRadians',
+    'BezierMaximumWindowLengthMeters',
+    'BezierHandleLengthRatio',
+    'QuinticKnotSpacingMeters',
+    'QuinticMinimumKnotSpacingMeters')
+$optionProperties = @{}
+foreach ($optionName in $optionNames) {
+    $optionProperties[$optionName] = Get-RequiredProperty $snapshotType $optionName
+}
+
+function New-Configuration {
+    return [Activator]::CreateInstance($configurationType)
+}
+
+function New-Snapshot($Configuration) {
+    return $snapshotConstructor.Invoke(@($Configuration))
+}
+
+# Request creation takes a configuration copy. Later mutations to either the source configuration
+# or a configuration copy returned by the request must not alter the algorithm snapshot.
+$configuration = New-Configuration
+$configuration.CubicBSpline.EndpointTangentScale = [double]0.20
+$configuration.LocalCubicBezier.CornerHeadingThresholdRadians = [double]0.40
+$configuration.LocalCubicBezier.MaximumWindowLengthMeters = [double]0.80
+$configuration.LocalCubicBezier.HandleLengthRatio = [double]0.25
+$configuration.PiecewiseQuintic.KnotSpacingMeters = [double]0.60
+$configuration.PiecewiseQuintic.MinimumKnotSpacingMeters = [double]0.15
+$emptyCoarsePath = [Array]::CreateInstance($coarsePointType, 0)
+$emptySegments = [Array]::CreateInstance($pathSegmentType, 0)
+$request = [Activator]::CreateInstance($requestType, @($emptyCoarsePath, $emptySegments, $null, $null, $configuration))
+$configuration.CubicBSpline.EndpointTangentScale = [double]0.90
+$requestConfiguration = $request.Configuration
+Assert-Near 0.20 $requestConfiguration.CubicBSpline.EndpointTangentScale 'Request configuration must remain independent from source-config mutations.'
+$snapshot = New-Snapshot $requestConfiguration
+$requestConfiguration.CubicBSpline.EndpointTangentScale = [double]0.70
+Assert-Near 0.20 $optionProperties['CubicBSplineEndpointTangentScale'].GetValue($snapshot) 'Algorithm options must remain independent from request-configuration mutations.'
+Assert-Near 0.40 $optionProperties['BezierCornerHeadingThresholdRadians'].GetValue($snapshot) 'Snapshot must preserve the request configuration values.'
+Assert-Near 0.80 $optionProperties['BezierMaximumWindowLengthMeters'].GetValue($snapshot) 'Snapshot must preserve the request configuration values.'
+Assert-Near 0.25 $optionProperties['BezierHandleLengthRatio'].GetValue($snapshot) 'Snapshot must preserve the request configuration values.'
+Assert-Near 0.60 $optionProperties['QuinticKnotSpacingMeters'].GetValue($snapshot) 'Snapshot must preserve the request configuration values.'
+Assert-Near 0.15 $optionProperties['QuinticMinimumKnotSpacingMeters'].GetValue($snapshot) 'Snapshot must preserve the request configuration values.'
+
+function Assert-InvalidSnapshot([scriptblock]$Mutate, [string]$Message) {
+    $invalidConfiguration = New-Configuration
+    & $Mutate $invalidConfiguration
+    Assert-Throws { New-Snapshot $invalidConfiguration } $Message
+}
+
+Assert-InvalidSnapshot { param($c) $c.CubicBSpline.EndpointTangentScale = [double]::NaN } 'Non-finite B-spline tangent scale must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.CubicBSpline.EndpointTangentScale = [double]0.0 } 'Non-positive B-spline tangent scale must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.LocalCubicBezier.CornerHeadingThresholdRadians = [double]0.0 } 'A zero Bézier heading threshold must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.LocalCubicBezier.CornerHeadingThresholdRadians = [Math]::PI + 0.0001 } 'A Bézier heading threshold above pi must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.LocalCubicBezier.MaximumWindowLengthMeters = [double]::PositiveInfinity } 'A non-finite Bézier window length must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.LocalCubicBezier.HandleLengthRatio = [double]0.0 } 'A non-positive Bézier handle ratio must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.PiecewiseQuintic.KnotSpacingMeters = [double]0.0 } 'A non-positive quintic knot spacing must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.PiecewiseQuintic.MinimumKnotSpacingMeters = [double]::NaN } 'A non-finite quintic minimum knot spacing must be rejected before retry.'
+Assert-InvalidSnapshot { param($c) $c.PiecewiseQuintic.KnotSpacingMeters = [double]0.05; $c.PiecewiseQuintic.MinimumKnotSpacingMeters = [double]0.10 } 'Quintic knot spacing below the configured minimum must be rejected before retry.'
+
+Write-Output 'Path smoothing algorithm-input checks passed.'

ClumsyPilot/tests/verify_path_smoothing_bspline.ps1

@@ -62,7 +62,10 @@ function New-EmptyMap {
     return $map
 }
 
-function New-AlgorithmInput([object[]]$Segments, [double]$ReserveMeters) {
+function New-AlgorithmInput(
+    [object[]]$Segments,
+    [double]$ReserveMeters,
+    [double]$EndpointTangentScale = (1.0 / 3.0)) {
     $typedSegments = [Array]::CreateInstance($segmentType, $Segments.Count)
     for ($index = 0; $index -lt $Segments.Count; $index++) {
         $typedSegments.SetValue($Segments[$index], $index)
@@ -74,16 +77,27 @@ function New-AlgorithmInput([object[]]$Segments, [double]$ReserveMeters) {
     $vehicle.SafetyMarginMeters = [double]0.0
     $vehicle.MaximumCurvaturePerMeter = [double]100.0
     $vehicle.MinimumTurningRadiusMeters = [double]0.01
-    return $inputConstructor.Invoke(@($preparedPath, (New-EmptyMap), $vehicle, [double]0.05, $ReserveMeters))
+    $configuration = [Activator]::CreateInstance($configurationType)
+    $configuration.CubicBSpline.EndpointTangentScale = $EndpointTangentScale
+    $options = $optionsConstructor.Invoke(@($configuration))
+    return $inputConstructor.Invoke(@($preparedPath, (New-EmptyMap), $vehicle, [double]0.05, $ReserveMeters, $options))
 }
 
-function Invoke-Candidate([object[]]$Segments, [double]$ReserveMeters, [double]$Strength = 1.0) {
+function Invoke-Candidate(
+    [object[]]$Segments,
+    [double]$ReserveMeters,
+    [double]$Strength = 1.0,
+    [double]$EndpointTangentScale = (1.0 / 3.0)) {
     return $smoothMethod.Invoke($smoother, @(
-        (New-AlgorithmInput $Segments $ReserveMeters), $Strength, [Threading.CancellationToken]::None))
+        (New-AlgorithmInput $Segments $ReserveMeters $EndpointTangentScale), $Strength, [Threading.CancellationToken]::None))
 }
 
-function Invoke-Smoothing([object[]]$Segments, [double]$ReserveMeters, [double]$Strength = 1.0) {
-    $candidate = Invoke-Candidate $Segments $ReserveMeters $Strength
+function Invoke-Smoothing(
+    [object[]]$Segments,
+    [double]$ReserveMeters,
+    [double]$Strength = 1.0,
+    [double]$EndpointTangentScale = (1.0 / 3.0)) {
+    $candidate = Invoke-Candidate $Segments $ReserveMeters $Strength $EndpointTangentScale
     Assert-True (Get-PropertyValue $candidate 'Succeeded') 'B-spline smoothing must produce a candidate for the deterministic fixture.'
     return @(Get-PropertyValue $candidate 'Segments')
 }
@@ -137,6 +151,9 @@ $pointType = Get-RequiredType ($processing + 'SmoothingPoint2D')
 $segmentType = Get-RequiredType ($processing + 'PreparedDirectionSegment')
 $preparedPathType = Get-RequiredType ($processing + 'PreparedPath')
 $inputType = Get-RequiredType ($algorithms + 'SmoothingAlgorithmInput')
+$optionsType = Get-RequiredType ($algorithms + 'SmoothingOptionsSnapshot')
+$interpolatorType = Get-RequiredType ($processing + 'PathReferenceInterpolator')
+$configurationType = Get-RequiredType ($root + 'PathSmoothingConfiguration')
 $vehicleType = Get-RequiredType ($coarsePath + 'VehicleParameters')
 $directionType = Get-RequiredType ($coarsePath + 'TravelDirection')
 $sourceType = Get-RequiredType ($root + 'SmoothedPathPointSource')
@@ -146,8 +163,12 @@ $mapRequestType = Get-RequiredType 'MultiWheelC.TrajectoryPlanning.Mapping.Plann
 $mapFactoryType = Get-RequiredType 'MultiWheelC.TrajectoryPlanning.Mapping.PlanningMapFactory'
 
 $inputConstructor = $inputType.GetConstructor([Reflection.BindingFlags]'Instance,NonPublic', $null,
-    @($preparedPathType, $mapType, $vehicleType, [double], [double]), $null)
-Assert-True ($null -ne $inputConstructor) 'Algorithm input must carry the minimum clearance reserve for per-anchor movement limits.'
+    @($preparedPathType, $mapType, $vehicleType, [double], [double], $optionsType), $null)
+Assert-True ($null -ne $inputConstructor) 'Algorithm input must carry immutable smoothing options and the minimum clearance reserve for per-anchor movement limits.'
+$optionsConstructor = $optionsType.GetConstructor([Reflection.BindingFlags]'Instance,NonPublic', $null, @($configurationType), $null)
+Assert-True ($null -ne $optionsConstructor) 'B-spline tests must create an immutable options snapshot.'
+$interpolateMethod = $interpolatorType.GetMethod('TryInterpolateByArcLength', [Reflection.BindingFlags]'Static,Public,NonPublic')
+Assert-True ($null -ne $interpolateMethod) 'PathReferenceInterpolator must expose arc-length interpolation.'
 $smoother = [Activator]::CreateInstance($smootherType, $true)
 $smoothMethod = $smootherType.GetMethod('Smooth', [Reflection.BindingFlags]'Instance,Public')
 Assert-True ($null -ne $smoothMethod) 'CubicBSplineSmoother must implement the internal smoother contract.'
@@ -157,6 +178,20 @@ $forward = [Enum]::Parse($directionType, 'Forward')
 $reverse = [Enum]::Parse($directionType, 'Reverse')
 $anchor = [Enum]::Parse($sourceType, 'Anchor')
 
+# Arc-length interpolation must bracket by local arc rather than by sample index.
+$nonUniformPoints = [Array]::CreateInstance($pointType, 4)
+$nonUniformPoints.SetValue((New-Point 0.0 0.0 0.000 0.0 1.0), 0)
+$nonUniformPoints.SetValue((New-Point 5.0 0.0 0.050 0.1 0.9), 1)
+$nonUniformPoints.SetValue((New-Point 10.0 0.0 0.100 0.2 0.8), 2)
+$nonUniformPoints.SetValue((New-Point 20.0 0.0 0.125 0.3 0.7), 3)
+$interpolateArguments = [object[]]@($nonUniformPoints, [double]0.1125, $null, $null)
+Assert-True $interpolateMethod.Invoke($null, $interpolateArguments) 'Arc-length interpolation must accept a target within the final non-uniform interval.'
+$arcReference = $interpolateArguments[2]
+Assert-Near 15.0 $arcReference.X 0.000000001 'Target arc length 0.1125 must lie halfway through the final 0.100-0.125 interval, independent of point count.'
+Assert-Near 0.1125 $arcReference.ArcLength 0.000000001 'Arc-length interpolation must preserve the requested target arc length.'
+Assert-Near 0.25 $arcReference.Heading 0.000000001 'Arc-length interpolation must linearly interpolate heading.'
+Assert-Near 0.75 $arcReference.BodyClearance 0.000000001 'Arc-length interpolation must linearly interpolate clearance.'
+
 # Straight samples are returned exactly, so a straight is never distorted or densified.
 $straightSource = @(
     (New-Point 0.0 0.0 0.0 0.0 0.03),
@@ -196,6 +231,11 @@ for ($index = 2; $index -lt $cornerPoints.Count; $index++) {
     Assert-True ((Get-AngleDifference $previousAngle $currentAngle) -lt 0.08) 'B-spline corner samples must turn without a tangent discontinuity.'
 }
 
+# Endpoint tangent scale is an immutable option and must influence the clamped B-spline endpoint handle.
+$shortHandlePoints = @(Invoke-Smoothing @((New-DirectionSegment 0 $forward $cornerSource)) 0.02 1.0 0.20)[0].Points
+$longHandlePoints = @(Invoke-Smoothing @((New-DirectionSegment 0 $forward $cornerSource)) 0.02 1.0 0.60)[0].Points
+Assert-True (($longHandlePoints[2].X - $shortHandlePoints[2].X) -gt 0.0001) 'A custom endpoint tangent scale must change the B-spline start handle and early curve samples.'
+
 # Every evaluated point may deviate only by BodyClearance - reserve, never by raw BodyClearance.
 $allowedRadius = 0.06
 foreach ($point in $cornerPoints) {

ClumsyPilot/tests/verify_path_smoothing_runner.ps1

@@ -36,7 +36,15 @@ $root = 'MultiWheelC.TrajectoryPlanning.PathSmoothing.'
 $algorithms = $root + 'Algorithms.'
 $runnerType = Get-RequiredType ($algorithms + 'SmoothingAlgorithmRunner')
 $smootherType = Get-RequiredType ($algorithms + 'IPathSmoother')
+$candidateType = Get-RequiredType ($algorithms + 'SmoothingCandidate')
+$candidateStatusType = Get-RequiredType ($algorithms + 'SmoothingCandidateStatus')
 Assert-False $smootherType.IsPublic 'IPathSmoother must remain internal to the algorithm assembly.'
+Assert-Equal 3 ([Enum]::GetNames($candidateStatusType).Length) 'Smoothing candidate status must contain only the three defined feasibility states.'
+Assert-Equal 'Success' ([Enum]::GetNames($candidateStatusType)[0]) 'Candidate status must expose Success.'
+Assert-Equal 'RetryableInfeasible' ([Enum]::GetNames($candidateStatusType)[1]) 'Candidate status must expose RetryableInfeasible.'
+Assert-Equal 'Failed' ([Enum]::GetNames($candidateStatusType)[2]) 'Candidate status must expose Failed.'
+$retryableFactory = $candidateType.GetMethod('RetryableInfeasible', [Reflection.BindingFlags]'Static,NonPublic')
+Assert-True ($null -ne $retryableFactory) 'SmoothingCandidate must create retryable infeasibility without executable geometry.'
 
 $hooksType = $runnerType.GetNestedType('TestHooks', [Reflection.BindingFlags]'Public,NonPublic')
 Assert-True ($null -ne $hooksType) 'SmoothingAlgorithmRunner must expose its narrowly scoped nested TestHooks helper.'
@@ -47,12 +55,12 @@ function Invoke-Scenario([string]$Scenario) {
     return $executeMethod.Invoke($null, @($Scenario))
 }
 
-$allRejected = Invoke-Scenario 'RejectAll'
-Assert-Equal 'Infeasible' $allRejected.Status 'All rejected finite candidates must produce an Infeasible runner result.'
-Assert-AttemptedStrengths $allRejected @(1.00, 0.75, 0.50, 0.25) 'Rejected candidates must use the finite retry schedule exactly.'
-Assert-Equal 0 $allRejected.AcceptedPathPointCount 'An infeasible runner result must not retain a rejected candidate as an accepted path.'
-Assert-True ($allRejected.RejectedComparisonCandidatePointCount -gt 0) 'Only comparison diagnostics may retain the last rejected candidate geometry.'
-Assert-Equal 4 $allRejected.FailureCount 'Every rejected validation attempt must retain its failure reason.'
+$allRetryable = Invoke-Scenario 'RetryableInfeasible'
+Assert-Equal 'Infeasible' $allRetryable.Status 'Exhausted retryable infeasibility must produce an Infeasible runner result.'
+Assert-AttemptedStrengths $allRetryable @(1.00, 0.75, 0.50, 0.25) 'Retryable infeasibility must use the finite retry schedule exactly.'
+Assert-Equal 0 $allRetryable.AcceptedPathPointCount 'An infeasible runner result must not retain a retryable candidate as an accepted path.'
+Assert-Equal 0 $allRetryable.RejectedComparisonCandidatePointCount 'Retryable infeasibility must not retain executable candidate geometry.'
+Assert-Equal 4 $allRetryable.FailureCount 'Every retryable attempt must retain its failure reason.'
 
 $accepted = Invoke-Scenario 'AcceptFirst'
 Assert-Equal 'Success' $accepted.Status 'The first safe candidate must be accepted.'
@@ -60,10 +68,10 @@ Assert-AttemptedStrengths $accepted @(1.00) 'The runner must stop immediately af
 Assert-True ($accepted.AcceptedPathPointCount -gt 0) 'A successful runner result must publish the validated path internally.'
 Assert-Equal 0 $accepted.RejectedComparisonCandidatePointCount 'An accepted candidate must not create rejected comparison geometry.'
 
-$numericalFailure = Invoke-Scenario 'NumericalFailure'
-Assert-Equal 'Failed' $numericalFailure.Status 'A numerical candidate failure must stop the runner as Failed.'
-Assert-AttemptedStrengths $numericalFailure @(1.00) 'Numerical candidate failure must not retry at lower strength.'
-Assert-Equal 0 $numericalFailure.RejectedComparisonCandidatePointCount 'A non-candidate numerical failure must not retain comparison geometry.'
+$terminalFailure = Invoke-Scenario 'TerminalFailed'
+Assert-Equal 'Failed' $terminalFailure.Status 'A terminal candidate failure must stop the runner as Failed.'
+Assert-AttemptedStrengths $terminalFailure @(1.00) 'Terminal candidate failure must run exactly once.'
+Assert-Equal 0 $terminalFailure.RejectedComparisonCandidatePointCount 'A terminal failure must not retain comparison geometry.'
 
 $cancelled = Invoke-Scenario 'CancelBeforeNextAttempt'
 Assert-True $cancelled.CancellationPropagated 'Cancellation between attempts must propagate out of the runner.'