feat: expose validated path smoothing service

ClumsyPilot/ParkrobTrajplanner/PathSmoothing/Facade/PathSmoothingService.cs

@@ -0,0 +1,310 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Threading;
+using MultiWheelC.TrajectoryPlanning.CoarsePath;
+using MultiWheelC.TrajectoryPlanning.CoarsePath.Vehicle;
+using MultiWheelC.TrajectoryPlanning.PathSmoothing.Algorithms;
+using MultiWheelC.TrajectoryPlanning.PathSmoothing.Processing;
+using MultiWheelC.TrajectoryPlanning.PathSmoothing.Validation;
+using MultiWheelC.TrajectoryPlanning.Utils;
+
+namespace MultiWheelC.TrajectoryPlanning.PathSmoothing.Facade;
+
+/// <summary>正式单算法路径平滑入口，负责输入校验、有限重试与经过复核的粗路径回退。</summary>
+public sealed class PathSmoothingService
+{
+    private readonly PathSmoothingPreprocessor _preprocessor = new PathSmoothingPreprocessor();
+    private readonly SmoothingAlgorithmRunner _runner = new SmoothingAlgorithmRunner();
+    private readonly PathGeometryAnalyzer _analyzer = new PathGeometryAnalyzer();
+    private readonly SmoothedPathValidator _validator = new SmoothedPathValidator();
+    private readonly IPathSmoother _bSpline = new CubicBSplineSmoother();
+    private readonly IPathSmoother _bezier = new LocalCubicBezierSmoother();
+    private readonly IPathSmoother _quintic = new PiecewiseQuinticSmoother();
+
+    /// <summary>执行一次经过完整安全复核的单算法平滑。</summary>
+    public PathSmoothingResult Smooth(
+        PathSmoothingRequest request,
+        CancellationToken cancellationToken = default)
+    {
+        var stopwatch = Stopwatch.StartNew();
+        try
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!TryValidateRequest(request, out PathSmoothingConfiguration configuration, out string reason))
+                return Failure(PathSmoothingStatus.InvalidInput, stopwatch, 0, 0d, reason);
+
+            if (!_preprocessor.TryPrepare(request, out PreparedPath preparedPath, out reason))
+                return Failure(PathSmoothingStatus.InvalidInput, stopwatch, 0, 0d, reason);
+
+            cancellationToken.ThrowIfCancellationRequested();
+            var input = new SmoothingAlgorithmInput(
+                preparedPath,
+                request.Map,
+                request.Vehicle,
+                configuration.MaximumCollisionCheckStepMeters,
+                configuration.MinimumClearanceReserveMeters,
+                new SmoothingOptionsSnapshot(configuration));
+            SmoothingAlgorithmRunner.AlgorithmRunResult runResult = _runner.Run(
+                Resolve(configuration.Method), input, configuration, cancellationToken);
+            int retryCount = GetRetryCount(runResult.AttemptedStrengths);
+            PathSmoothingDiagnostics diagnostics = new PathSmoothingDiagnostics(
+                runResult.Metrics,
+                stopwatch.Elapsed,
+                retryCount,
+                runResult.AcceptedStrength,
+                runResult.Reason);
+
+            if (runResult.Status == PathSmoothingStatus.Success)
+            {
+                return PathSmoothingResult.Success(
+                    configuration.Method,
+                    runResult.Path,
+                    runResult.Segments,
+                    diagnostics);
+            }
+
+            if (!configuration.AllowFallbackToCoarsePath)
+                return PathSmoothingResult.Failure(runResult.Status, diagnostics);
+
+            cancellationToken.ThrowIfCancellationRequested();
+            if (!TryCreateVerifiedFallback(
+                    request,
+                    configuration,
+                    cancellationToken,
+                    out IReadOnlyList<SmoothedPathPoint> fallbackPath,
+                    out IReadOnlyList<SmoothedPathSegment> fallbackSegments,
+                    out PathQualityMetrics fallbackMetrics,
+                    out reason))
+            {
+                return PathSmoothingResult.Failure(runResult.Status, diagnostics);
+            }
+
+            var fallbackDiagnostics = new PathSmoothingDiagnostics(
+                fallbackMetrics,
+                stopwatch.Elapsed,
+                retryCount,
+                runResult.AcceptedStrength,
+                runResult.Reason);
+            return PathSmoothingResult.Fallback(
+                configuration.Method,
+                fallbackPath,
+                fallbackSegments,
+                fallbackDiagnostics);
+        }
+        catch (OperationCanceledException)
+        {
+            return Failure(PathSmoothingStatus.Cancelled, stopwatch, 0, 0d, "路径平滑已取消。");
+        }
+        catch (Exception exception)
+        {
+            return Failure(PathSmoothingStatus.Failed, stopwatch, 0, 0d, exception.Message);
+        }
+    }
+
+    private bool TryCreateVerifiedFallback(
+        PathSmoothingRequest request,
+        PathSmoothingConfiguration configuration,
+        CancellationToken cancellationToken,
+        out IReadOnlyList<SmoothedPathPoint> fallbackPath,
+        out IReadOnlyList<SmoothedPathSegment> fallbackSegments,
+        out PathQualityMetrics fallbackMetrics,
+        out string reason)
+    {
+        fallbackPath = null;
+        fallbackSegments = null;
+        fallbackMetrics = null;
+        reason = string.Empty;
+
+        // Reprepare from the immutable request instead of reusing the algorithm input: fallback is a
+        // separately published output and must repeat the coarse-path contract validation.
+        if (!_preprocessor.TryPrepare(request, out PreparedPath revalidatedPath, out reason)) return false;
+        cancellationToken.ThrowIfCancellationRequested();
+
+        if (!_analyzer.TryAnalyze(
+                ToFallbackSegments(revalidatedPath),
+                configuration.OutputSpacingMeters,
+                out PathGeometryAnalysis analysis,
+                out reason))
+        {
+            return false;
+        }
+
+        IReadOnlyList<SmoothedPathPoint> fallbackSourcePath = ToFallbackPoints(analysis.Path);
+        cancellationToken.ThrowIfCancellationRequested();
+        if (!_validator.TryValidate(
+                fallbackSourcePath,
+                analysis.Segments,
+                revalidatedPath,
+                request.Map,
+                request.Vehicle,
+                configuration.MaximumCollisionCheckStepMeters,
+                out IReadOnlyList<SmoothedPathPoint> safePath,
+                out double minimumClearanceMeters,
+                out reason))
+        {
+            return false;
+        }
+
+        fallbackPath = safePath;
+        fallbackSegments = analysis.Segments;
+        fallbackMetrics = CreateMetrics(analysis, minimumClearanceMeters);
+        return true;
+    }
+
+    private IPathSmoother Resolve(SmoothingMethod method)
+    {
+        return method switch
+        {
+            SmoothingMethod.CubicBSpline => _bSpline,
+            SmoothingMethod.LocalCubicBezier => _bezier,
+            SmoothingMethod.PiecewiseQuintic => _quintic,
+            _ => throw new ArgumentOutOfRangeException(nameof(method)),
+        };
+    }
+
+    private static bool TryValidateRequest(
+        PathSmoothingRequest request,
+        out PathSmoothingConfiguration configuration,
+        out string reason)
+    {
+        configuration = null;
+        reason = string.Empty;
+        if (request == null)
+        {
+            reason = "平滑请求为空。";
+            return false;
+        }
+
+        configuration = request.Configuration;
+        VehicleParameters vehicle = request.Vehicle;
+        if (configuration == null || request.Map == null || !request.Map.PlanningReady || vehicle == null)
+        {
+            reason = "平滑请求缺少可用的地图、车辆或配置。";
+            return false;
+        }
+
+        if (!NumericGuard.IsPositiveFinite(vehicle.LengthMeters) ||
+            !NumericGuard.IsPositiveFinite(vehicle.WidthMeters) ||
+            !NumericGuard.IsFinite(vehicle.SafetyMarginMeters) || vehicle.SafetyMarginMeters < 0d ||
+            !VehicleKinematics.TryGetMaximumCurvaturePerMeter(vehicle, out _))
+        {
+            reason = "平滑请求中的车辆几何或曲率约束无效。";
+            return false;
+        }
+
+        if (!Enum.IsDefined(typeof(SmoothingMethod), configuration.Method))
+        {
+            reason = "平滑方法无效。";
+            return false;
+        }
+
+        if (!NumericGuard.IsPositiveFinite(configuration.OutputSpacingMeters) ||
+            !NumericGuard.IsPositiveFinite(configuration.MaximumCollisionCheckStepMeters) ||
+            !NumericGuard.IsFinite(configuration.MinimumClearanceReserveMeters) ||
+            configuration.MinimumClearanceReserveMeters < 0d ||
+            !NumericGuard.IsPositiveFinite(configuration.SmoothingStrength) ||
+            !NumericGuard.IsPositiveFinite(configuration.CubicBSpline.EndpointTangentScale) ||
+            !IsValidBezierThreshold(configuration.LocalCubicBezier.CornerHeadingThresholdRadians) ||
+            !NumericGuard.IsPositiveFinite(configuration.LocalCubicBezier.MaximumWindowLengthMeters) ||
+            !NumericGuard.IsPositiveFinite(configuration.LocalCubicBezier.HandleLengthRatio) ||
+            !NumericGuard.IsPositiveFinite(configuration.PiecewiseQuintic.KnotSpacingMeters) ||
+            !NumericGuard.IsPositiveFinite(configuration.PiecewiseQuintic.MinimumKnotSpacingMeters) ||
+            configuration.PiecewiseQuintic.KnotSpacingMeters < configuration.PiecewiseQuintic.MinimumKnotSpacingMeters)
+        {
+            reason = "平滑配置包含非法数值或不满足方法契约。";
+            return false;
+        }
+        return true;
+    }
+
+    private static bool IsValidBezierThreshold(double thresholdRadians)
+    {
+        return NumericGuard.IsFinite(thresholdRadians) && thresholdRadians > 0d && thresholdRadians <= Math.PI;
+    }
+
+    private static IReadOnlyList<PreparedDirectionSegment> ToFallbackSegments(PreparedPath path)
+    {
+        var segments = new List<PreparedDirectionSegment>(path.Segments.Count);
+        for (int segmentIndex = 0; segmentIndex < path.Segments.Count; segmentIndex++)
+        {
+            PreparedDirectionSegment segment = path.Segments[segmentIndex];
+            var points = new List<SmoothingPoint2D>(segment.Points.Count);
+            for (int pointIndex = 0; pointIndex < segment.Points.Count; pointIndex++)
+            {
+                SmoothingPoint2D point = segment.Points[pointIndex];
+                points.Add(new SmoothingPoint2D(
+                    point.X,
+                    point.Y,
+                    point.ArcLength,
+                    point.Heading,
+                    point.UnwrappedHeading,
+                    point.BodyClearance,
+                    point.IsGearSwitchPoint,
+                    SmoothedPathPointSource.CoarsePathFallback));
+            }
+            segments.Add(new PreparedDirectionSegment(
+                segment.SegmentIndex,
+                segment.Direction,
+                points,
+                segment.StartsAtGearSwitch,
+                segment.EndsAtGearSwitch));
+        }
+        return segments;
+    }
+
+    private static IReadOnlyList<SmoothedPathPoint> ToFallbackPoints(IReadOnlyList<SmoothedPathPoint> path)
+    {
+        var points = new List<SmoothedPathPoint>(path.Count);
+        for (int index = 0; index < path.Count; index++)
+        {
+            SmoothedPathPoint point = path[index];
+            points.Add(new SmoothedPathPoint(
+                point.X,
+                point.Y,
+                point.Heading,
+                point.UnwrappedHeading,
+                point.ArcLength,
+                point.Direction,
+                point.GeometricCurvature,
+                point.VehicleCurvature,
+                point.BodyClearance,
+                point.IsGearSwitchPoint,
+                SmoothedPathPointSource.CoarsePathFallback));
+        }
+        return points;
+    }
+
+    private static PathQualityMetrics CreateMetrics(PathGeometryAnalysis analysis, double minimumClearanceMeters)
+    {
+        return new PathQualityMetrics(
+            true,
+            analysis.PathLengthMeters,
+            analysis.MaximumAbsoluteVehicleCurvaturePerMeter,
+            analysis.RootMeanSquareVehicleCurvaturePerMeter,
+            analysis.TotalAbsoluteCurvatureVariationPerMeter,
+            analysis.CurvatureVariationEnergy,
+            minimumClearanceMeters,
+            0d,
+            0d,
+            0d,
+            0d);
+    }
+
+    private static int GetRetryCount(IReadOnlyList<double> attemptedStrengths)
+    {
+        return attemptedStrengths == null || attemptedStrengths.Count == 0 ? 0 : attemptedStrengths.Count - 1;
+    }
+
+    private static PathSmoothingResult Failure(
+        PathSmoothingStatus status,
+        Stopwatch stopwatch,
+        int retryCount,
+        double acceptedStrength,
+        string reason)
+    {
+        return PathSmoothingResult.Failure(
+            status,
+            new PathSmoothingDiagnostics(new PathQualityMetrics(), stopwatch.Elapsed, retryCount, acceptedStrength, reason));
+    }
+}

ClumsyPilot/tests/verify_path_smoothing_service.ps1

@@ -0,0 +1,223 @@
+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-Equal($Expected, $Actual, [string]$Message) {
+    if ($Expected -ne $Actual) { throw "$Message Expected=$Expected Actual=$Actual" }
+}
+
+function Assert-Near([double]$Expected, [double]$Actual, [double]$Tolerance, [string]$Message) {
+    if ([Math]::Abs($Expected - $Actual) -gt $Tolerance) {
+        throw "$Message Expected=$Expected Actual=$Actual Tolerance=$Tolerance"
+    }
+}
+
+function Get-RequiredType([string]$Name) {
+    return $assembly.GetType($Name, $true)
+}
+
+function New-EmptyMap {
+    $mapRequest = [Activator]::CreateInstance($mapRequestType)
+    $mapRequest.Bounds = [Activator]::CreateInstance($boundsType, @([single]0, [single]5000, [single]0, [single]5000))
+    $mapRequest.ResolutionMm = [single]50
+    $mapRequest.AllowExplicitEmptyMap = $true
+    $map = [Activator]::CreateInstance($mapFactoryType).Create($mapRequest).Map
+    Assert-True ($null -ne $map) 'Service test must create an explicit empty planning map.'
+    return $map
+}
+
+function New-Vehicle {
+    $vehicle = [Activator]::CreateInstance($vehicleType)
+    $vehicle.LengthMeters = [double]0.20
+    $vehicle.WidthMeters = [double]0.20
+    $vehicle.SafetyMarginMeters = [double]0.0
+    $vehicle.MaximumCurvaturePerMeter = [double]100.0
+    return $vehicle
+}
+
+function New-CoarsePoint(
+    [double]$X,
+    [double]$Y,
+    [double]$ArcLength,
+    $Direction,
+    [double]$BodyClearance = 1.0,
+    [bool]$IsGearSwitch = $false) {
+    return [Activator]::CreateInstance($coarsePointType, @(
+        $X, $Y, [double]0.0, [double]0.0, $ArcLength, $Direction,
+        [double]0.0, $BodyClearance, $IsGearSwitch, $coarseAnchor))
+}
+
+function New-Configuration($Method = $cubicBSpline) {
+    $configuration = [Activator]::CreateInstance($configurationType)
+    $configuration.Method = $Method
+    return $configuration
+}
+
+function New-Request([object[]]$Points, $Configuration) {
+    $typedPoints = [Array]::CreateInstance($coarsePointType, $Points.Count)
+    for ($index = 0; $index -lt $Points.Count; $index++) {
+        $typedPoints.SetValue($Points[$index], $index)
+    }
+
+    $segments = [Array]::CreateInstance($coarseSegmentType, 1)
+    $segments.SetValue([Activator]::CreateInstance($coarseSegmentType, @(
+        0, $forward, 0, ($Points.Count - 1), $false, $false)), 0)
+    return [Activator]::CreateInstance($requestType, @($typedPoints, $segments, (New-EmptyMap), (New-Vehicle), $Configuration))
+}
+
+function New-StraightRequest($Configuration) {
+    return New-Request @(
+        (New-CoarsePoint 0.5 0.5 0.0 $forward),
+        (New-CoarsePoint 1.5 0.5 1.0 $forward)) $Configuration
+}
+
+function New-InfeasibleRequest($Configuration) {
+    # Zero declared movement clearance makes every non-linear B-spline displacement retryably infeasible,
+    # while the empty map still permits the independently revalidated coarse-path fallback.
+    return New-Request @(
+        (New-CoarsePoint 0.5 0.5 0.0 $forward 0.0),
+        (New-CoarsePoint 1.0 0.5 0.5 $forward 0.0),
+        (New-CoarsePoint 1.0 1.0 1.0 $forward 0.0),
+        (New-CoarsePoint 1.5 1.0 1.5 $forward 0.0)) $Configuration
+}
+
+function Invoke-Smooth($Request, [Threading.CancellationToken]$CancellationToken = [Threading.CancellationToken]::None) {
+    return $smoothMethod.Invoke($service, @($Request, $CancellationToken))
+}
+
+function Assert-NoGeometry($Result, [string]$Message) {
+    Assert-Equal 0 $Result.Path.Count "$Message A non-published result must not expose a path."
+    Assert-Equal 0 $Result.Segments.Count "$Message A non-published result must not expose segments."
+}
+
+function Assert-InvalidInputBeforeRetry($Configuration, [string]$CaseName) {
+    $result = Invoke-Smooth (New-StraightRequest $Configuration)
+    Assert-Equal 'InvalidInput' $result.Status.ToString() "$CaseName must be rejected as invalid input."
+    Assert-NoGeometry $result $CaseName
+    Assert-Equal 0 $result.Diagnostics.RetryCount "$CaseName must be rejected before any smoothing retry."
+    Assert-Near 0.0 $result.Diagnostics.AcceptedStrength 0.0 "$CaseName must not accept a smoothing strength."
+}
+
+$root = 'MultiWheelC.TrajectoryPlanning.PathSmoothing.'
+$facade = $root + 'Facade.'
+$coarsePath = 'MultiWheelC.TrajectoryPlanning.CoarsePath.'
+$mapping = 'MultiWheelC.TrajectoryPlanning.Mapping.'
+
+$serviceType = Get-RequiredType ($facade + 'PathSmoothingService')
+$requestType = Get-RequiredType ($root + 'PathSmoothingRequest')
+$resultType = Get-RequiredType ($root + 'PathSmoothingResult')
+$configurationType = Get-RequiredType ($root + 'PathSmoothingConfiguration')
+$methodType = Get-RequiredType ($root + 'SmoothingMethod')
+$coarsePointType = Get-RequiredType ($coarsePath + 'CoarsePathPoint')
+$coarseSegmentType = Get-RequiredType ($coarsePath + 'PathSegment')
+$directionType = Get-RequiredType ($coarsePath + 'TravelDirection')
+$coarsePointSourceType = Get-RequiredType ($coarsePath + 'CoarsePathPointSource')
+$vehicleType = Get-RequiredType ($coarsePath + 'VehicleParameters')
+$boundsType = Get-RequiredType ($mapping + 'MapBoundsMm')
+$mapRequestType = Get-RequiredType ($mapping + 'PlanningMapRequest')
+$mapFactoryType = Get-RequiredType ($mapping + 'PlanningMapFactory')
+
+Assert-True $serviceType.IsPublic 'PathSmoothingService must be public.'
+$service = [Activator]::CreateInstance($serviceType)
+$smoothMethod = $serviceType.GetMethod('Smooth', [Type[]]@($requestType, [Threading.CancellationToken]))
+Assert-True ($null -ne $smoothMethod) 'PathSmoothingService must expose Smooth(PathSmoothingRequest, CancellationToken).'
+Assert-Equal $resultType $smoothMethod.ReturnType 'PathSmoothingService Smooth must return PathSmoothingResult.'
+
+$forward = [Enum]::Parse($directionType, 'Forward')
+$cubicBSpline = [Enum]::Parse($methodType, 'CubicBSpline')
+$localCubicBezier = [Enum]::Parse($methodType, 'LocalCubicBezier')
+$piecewiseQuintic = [Enum]::Parse($methodType, 'PiecewiseQuintic')
+$coarseAnchor = [Enum]::Parse($coarsePointSourceType, 'Start')
+
+# The public method registry must retain every stable enum-to-algorithm mapping.
+foreach ($method in @($cubicBSpline, $localCubicBezier, $piecewiseQuintic)) {
+    $result = Invoke-Smooth (New-StraightRequest (New-Configuration $method))
+    Assert-Equal 'Success' $result.Status.ToString() "A valid straight path must succeed for $method."
+    Assert-Equal $method.ToString() $result.Method.ToString() "The result must retain the selected $method method."
+    Assert-True ($result.Path.Count -gt 0) "A successful $method result must publish geometry."
+    Assert-True $result.Diagnostics.Metrics.IsFeasible "A successful $method result must publish feasible diagnostics."
+}
+
+# Every configuration scalar is checked before the options snapshot or retry runner starts.
+$invalidConfigurationCases = @(
+    [PSCustomObject]@{ Name = 'NaN output spacing'; Mutate = { param($c) $c.OutputSpacingMeters = [double]::NaN } },
+    [PSCustomObject]@{ Name = 'zero output spacing'; Mutate = { param($c) $c.OutputSpacingMeters = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'infinite collision step'; Mutate = { param($c) $c.MaximumCollisionCheckStepMeters = [double]::PositiveInfinity } },
+    [PSCustomObject]@{ Name = 'zero collision step'; Mutate = { param($c) $c.MaximumCollisionCheckStepMeters = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'NaN clearance reserve'; Mutate = { param($c) $c.MinimumClearanceReserveMeters = [double]::NaN } },
+    [PSCustomObject]@{ Name = 'negative clearance reserve'; Mutate = { param($c) $c.MinimumClearanceReserveMeters = [double]-0.01 } },
+    [PSCustomObject]@{ Name = 'NaN smoothing strength'; Mutate = { param($c) $c.SmoothingStrength = [double]::NaN } },
+    [PSCustomObject]@{ Name = 'zero smoothing strength'; Mutate = { param($c) $c.SmoothingStrength = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'NaN B-spline scale'; Mutate = { param($c) $c.CubicBSpline.EndpointTangentScale = [double]::NaN } },
+    [PSCustomObject]@{ Name = 'zero B-spline scale'; Mutate = { param($c) $c.CubicBSpline.EndpointTangentScale = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'zero Bezier threshold'; Mutate = { param($c) $c.LocalCubicBezier.CornerHeadingThresholdRadians = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'over-pi Bezier threshold'; Mutate = { param($c) $c.LocalCubicBezier.CornerHeadingThresholdRadians = [Math]::PI + 0.01 } },
+    [PSCustomObject]@{ Name = 'NaN Bezier window'; Mutate = { param($c) $c.LocalCubicBezier.MaximumWindowLengthMeters = [double]::NaN } },
+    [PSCustomObject]@{ Name = 'zero Bezier window'; Mutate = { param($c) $c.LocalCubicBezier.MaximumWindowLengthMeters = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'infinite Bezier handle scale'; Mutate = { param($c) $c.LocalCubicBezier.HandleLengthRatio = [double]::PositiveInfinity } },
+    [PSCustomObject]@{ Name = 'zero Bezier handle scale'; Mutate = { param($c) $c.LocalCubicBezier.HandleLengthRatio = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'NaN quintic knot spacing'; Mutate = { param($c) $c.PiecewiseQuintic.KnotSpacingMeters = [double]::NaN } },
+    [PSCustomObject]@{ Name = 'zero quintic knot spacing'; Mutate = { param($c) $c.PiecewiseQuintic.KnotSpacingMeters = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'infinite minimum quintic knot spacing'; Mutate = { param($c) $c.PiecewiseQuintic.MinimumKnotSpacingMeters = [double]::PositiveInfinity } },
+    [PSCustomObject]@{ Name = 'zero minimum quintic knot spacing'; Mutate = { param($c) $c.PiecewiseQuintic.MinimumKnotSpacingMeters = [double]0.0 } },
+    [PSCustomObject]@{ Name = 'quintic knot spacing below minimum'; Mutate = { param($c) $c.PiecewiseQuintic.KnotSpacingMeters = [double]0.05; $c.PiecewiseQuintic.MinimumKnotSpacingMeters = [double]0.10 } }
+)
+foreach ($case in $invalidConfigurationCases) {
+    $configuration = New-Configuration
+    & $case.Mutate $configuration
+    Assert-InvalidInputBeforeRetry $configuration $case.Name
+}
+
+$unknownMethodConfiguration = New-Configuration ([Enum]::ToObject($methodType, 99))
+Assert-InvalidInputBeforeRetry $unknownMethodConfiguration 'unknown smoothing method'
+
+$invalidCoarseConfiguration = New-Configuration
+$invalidCoarseRequest = New-Request @(
+    (New-CoarsePoint ([double]::NaN) 0.5 0.0 $forward),
+    (New-CoarsePoint 1.5 0.5 1.0 $forward)) $invalidCoarseConfiguration
+$invalidCoarseResult = Invoke-Smooth $invalidCoarseRequest
+Assert-Equal 'InvalidInput' $invalidCoarseResult.Status.ToString() 'A non-finite coarse path coordinate must be invalid input.'
+Assert-NoGeometry $invalidCoarseResult 'Invalid coarse path'
+Assert-Equal 0 $invalidCoarseResult.Diagnostics.RetryCount 'Invalid coarse input must be rejected before retries.'
+
+$cancelledConfiguration = New-Configuration
+$cancellationSource = [Threading.CancellationTokenSource]::new()
+$cancellationSource.Cancel()
+try {
+    $cancelledResult = Invoke-Smooth (New-StraightRequest $cancelledConfiguration) $cancellationSource.Token
+    Assert-Equal 'Cancelled' $cancelledResult.Status.ToString() 'Pre-cancelled smoothing must return the explicit cancellation result.'
+    Assert-NoGeometry $cancelledResult 'Cancelled smoothing'
+    Assert-Equal 0 $cancelledResult.Diagnostics.RetryCount 'Cancellation before execution must not start retries.'
+}
+finally {
+    $cancellationSource.Dispose()
+}
+
+$withoutFallbackConfiguration = New-Configuration
+$withoutFallbackConfiguration.AllowFallbackToCoarsePath = $false
+$withoutFallbackResult = Invoke-Smooth (New-InfeasibleRequest $withoutFallbackConfiguration)
+Assert-Equal 'Infeasible' $withoutFallbackResult.Status.ToString() 'A retryably infeasible candidate without fallback must remain infeasible.'
+Assert-NoGeometry $withoutFallbackResult 'Infeasible smoothing without fallback'
+Assert-Equal 3 $withoutFallbackResult.Diagnostics.RetryCount 'Infeasible smoothing must exhaust the four configured strengths.'
+Assert-Near 0.0 $withoutFallbackResult.Diagnostics.AcceptedStrength 0.0 'Infeasible smoothing must not accept a strength.'
+
+$withFallbackConfiguration = New-Configuration
+$withFallbackConfiguration.AllowFallbackToCoarsePath = $true
+$withFallbackResult = Invoke-Smooth (New-InfeasibleRequest $withFallbackConfiguration)
+Assert-Equal 'FallbackToCoarsePath' $withFallbackResult.Status.ToString() 'A verified coarse path must return explicit fallback status.'
+Assert-Equal 'CubicBSpline' $withFallbackResult.Method.ToString() 'Fallback must retain the originally selected method.'
+Assert-True ($withFallbackResult.Path.Count -gt 0) 'A verified fallback must publish the revalidated coarse geometry.'
+Assert-True $withFallbackResult.Diagnostics.Metrics.IsFeasible 'Fallback must publish feasible shared-geometry diagnostics.'
+foreach ($point in $withFallbackResult.Path) {
+    Assert-Equal 'CoarsePathFallback' $point.Source.ToString() 'Every fallback point must be explicitly labeled as coarse-path fallback.'
+}
+Assert-Equal $withoutFallbackResult.Diagnostics.RetryCount $withFallbackResult.Diagnostics.RetryCount 'Fallback must preserve retry diagnostics from the failed method.'
+Assert-Near $withoutFallbackResult.Diagnostics.AcceptedStrength $withFallbackResult.Diagnostics.AcceptedStrength 0.0 'Fallback must preserve the failed method accepted-strength diagnostic.'
+Assert-Equal $withoutFallbackResult.Diagnostics.TerminationReason $withFallbackResult.Diagnostics.TerminationReason 'Fallback must preserve the failed method termination reason.'
+
+Write-Output 'Path smoothing service checks passed.'