feat: host EM observation dashboard

ClumsyPilot/tests/EMPlannerVerificationHost/TrajectoryObservationChecks.cs

@@ -24,6 +24,7 @@ internal static class TrajectoryObservationChecks
         VerifiesObservationSourceUsesRequiredOperatorText();
         VerifiesOperatorDocumentationUsesExactUiEntry();
         VerifiesMovementTestVehicleInputsAndSettingsSnapshot();
+        VerifiesMovementTestKeepsNativePainterLazyAndConditional();
         VerifiesPlanningConfigurationDiagnosticUsesEffectiveConfiguration();
         RejectsInvalidObservationSettings();
         VerifiesStartGoalBoundsUseOnlyConfiguredPadding();
@@ -1025,6 +1026,17 @@ internal static class TrajectoryObservationChecks
         }
     }
 
+    private static void VerifiesMovementTestKeepsNativePainterLazyAndConditional()
+    {
+        string movementTestPath = Path.Combine(Directory.GetCurrentDirectory(), "ClumsyPilot",
+            "ParkrobTrajplanner", "tarjplanner_movementtest", "MovementTest.TrajectoryObservationTest.cs");
+        string source = new UTF8Encoding(false, true).GetString(File.ReadAllBytes(movementTestPath));
+        Verification.True(!source.Contains("static readonly TrajectoryObservationPresentation"),
+            "MovementTest has no static eager Painter presentation");
+        Verification.True(source.Contains("settings.EnableNativePainterVisualization ? new TrajectoryObservationPresentation() : null"),
+            "MovementTest creates Painter only under the native visualization flag");
+    }
+
     private static bool Throws(Action action)
     {
         try { action(); return false; }

ClumsyPilot/tests/EMPlannerVerificationHost/TrajectoryObservationVisualizationChecks.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Globalization;
+using System.IO;
 using System.Linq;
 using System.Reflection;
 using System.Threading;
@@ -20,6 +21,8 @@ internal static class TrajectoryObservationVisualizationChecks
         VerifiesKinematicChartsKeepKnotAndIntervalSemantics();
         VerifiesHandoffUsesSharedReferenceSAndSurvivesProjectionFailure();
         VerifiesDynamicSnapshotContainsObservationEvidenceWithoutCyclePoints();
+        VerifiesWebPublisherFusesFaultWithoutStoppingObserverTicks();
+        VerifiesWebPublisherGatesAtConfiguredCadenceAndSkipsDisabledOutput();
     }
 
     private static void VerifiesStaticSnapshotExportsFrozenConfigurationAndGeometry()
@@ -215,6 +218,116 @@ internal static class TrajectoryObservationVisualizationChecks
             "projection failure is reported while dynamic snapshot construction remains available");
     }
 
+    private static void VerifiesWebPublisherFusesFaultWithoutStoppingObserverTicks()
+    {
+        var settings = new TrajectoryObservationSettings { EnableWebVisualization = true };
+        var sink = new RecordingVisualizationSink { ThrowOnPublish = true };
+        var logs = new List<string>();
+        var publisher = new TrajectoryObservationVisualizationPublisher(settings, sink, logs.Add);
+        DateTimeOffset now = DateTimeOffset.UnixEpoch;
+
+        publisher.Start(CreateStaticSnapshot(settings));
+        Verification.True(!publisher.TryPublish(now, () => CreateDynamicSnapshot(now)),
+            "publisher reports a failed web publish");
+        Verification.True(!publisher.TryPublish(now.AddSeconds(1d), () => throw new InvalidOperationException("must not build after fuse")),
+            "publisher permanently disables web output after the first fault");
+        Verification.Equal(1, sink.PublishCalls, "publisher invokes the throwing sink once");
+        Verification.Equal(1, sink.StopCalls, "publisher stops the sink once after its fault");
+        Verification.Equal(1, logs.Count, "publisher logs the web fault once");
+        Verification.True(publisher.FaultReason.Contains("网页"), "publisher records an immutable Chinese web fault reason");
+
+        TrajectoryObservationBootstrapResult bootstrap = Bootstrap(settings);
+        DateTimeOffset tickAt = now.AddSeconds(1d);
+        var controller = new TrajectoryObservationController(bootstrap, settings,
+            new FixedPlanningService(CreateTrajectory("publisher-loop", tickAt, 2, EmTerminalType.Goal,
+                EmLongitudinalMode.RollingContinuation, TravelDirection.Forward)), "publisher-loop");
+        var loop = new TrajectoryObservationLoop(controller);
+        var state = new VehicleMotionState(new Pose2D(0d, 0d, 0d), 0d, null, tickAt, 1L);
+        TrajectoryObservationLoopTick firstTick = loop.Tick(tickAt, state, CancellationToken.None);
+        TrajectoryObservationLoopTick secondTick = loop.Tick(tickAt.AddSeconds(settings.ObserverPeriodSeconds), state,
+            CancellationToken.None);
+        Verification.True(firstTick.PlanningStarted || secondTick.PlanningStarted || secondTick.PlanningCompleted,
+            "observer loop continues producing ticks after a web publisher fault");
+    }
+
+    private static void VerifiesWebPublisherGatesAtConfiguredCadenceAndSkipsDisabledOutput()
+    {
+        var settings = new TrajectoryObservationSettings
+        {
+            EnableWebVisualization = true,
+            WebRefreshRateHz = 10d,
+        };
+        var sink = new RecordingVisualizationSink();
+        var publisher = new TrajectoryObservationVisualizationPublisher(settings, sink, _ => { });
+        DateTimeOffset start = DateTimeOffset.UnixEpoch;
+        publisher.Start(CreateStaticSnapshot(settings));
+        for (int index = 0; index <= 20; index++)
+            publisher.TryPublish(start.AddMilliseconds(index * 50), () => CreateDynamicSnapshot(start));
+        Verification.True(sink.PublishCalls <= 11, "20 Hz observer ticks publish no more than 11 snapshots at 10 Hz over one second");
+        Verification.Equal(11, sink.PublishCalls, "publisher includes the initial 10 Hz snapshot");
+        publisher.Stop();
+        publisher.Stop();
+        Verification.Equal(1, sink.StopCalls, "publisher stop is idempotent");
+
+        var disabledSettings = new TrajectoryObservationSettings { EnableWebVisualization = false };
+        var disabledSink = new RecordingVisualizationSink();
+        var disabledPublisher = new TrajectoryObservationVisualizationPublisher(disabledSettings, disabledSink, _ => { });
+        int factoryCalls = 0;
+        disabledPublisher.Start(CreateStaticSnapshot(disabledSettings));
+        disabledPublisher.TryPublish(start, () =>
+        {
+            factoryCalls++;
+            return CreateDynamicSnapshot(start);
+        });
+        Verification.Equal(0, disabledSink.StartCalls, "disabled web visualization does not start a service");
+        Verification.Equal(0, factoryCalls, "disabled web visualization does not build dynamic snapshots");
+    }
+
+    private static PlanningVisualizationStaticSnapshot CreateStaticSnapshot(TrajectoryObservationSettings settings)
+    {
+        TrajectoryObservationBootstrapResult bootstrap = Bootstrap(settings);
+        var controller = new TrajectoryObservationController(bootstrap, settings,
+            new FixedPlanningService(CreateTrajectory("publisher-static", DateTimeOffset.UnixEpoch, 2,
+                EmTerminalType.Goal, EmLongitudinalMode.RollingContinuation, TravelDirection.Forward)), "publisher-static");
+        return new TrajectoryObservationStaticSnapshotBuilder().Build(bootstrap,
+            ReadEffectiveConfiguration(controller), settings.CreateValidatedSnapshot(), 0L);
+    }
+
+    private static PlanningVisualizationDynamicSnapshot CreateDynamicSnapshot(DateTimeOffset now)
+    {
+        return new PlanningVisualizationDynamicSnapshot(1L, now, "OBSERVE_ONLY", 0, "Forward",
+            new VisualizationPose(0d, 0d, 0d), Array.Empty<VisualizationPolyline>(),
+            Array.Empty<VisualizationMarker>(), Array.Empty<VisualizationChart>(), Array.Empty<VisualizationValue>(),
+            new VisualizationCycleSummary(1L, now, "Success", true, 0d, 0, "Forward", "RollingContinuation",
+                "Goal", 0d, 0d, string.Empty));
+    }
+
+    private sealed class RecordingVisualizationSink : ITrajectoryObservationVisualizationSink
+    {
+        public bool ThrowOnPublish { get; set; }
+        public int StartCalls { get; private set; }
+        public int PublishCalls { get; private set; }
+        public int StopCalls { get; private set; }
+
+        public PlanningVisualizationSessionInfo Start(PlanningVisualizationOptions options,
+            PlanningVisualizationStaticSnapshot snapshot)
+        {
+            StartCalls++;
+            return new PlanningVisualizationSessionInfo(new Uri("http://127.0.0.1:12345/?token=test"), "test");
+        }
+
+        public void Publish(PlanningVisualizationDynamicSnapshot snapshot)
+        {
+            PublishCalls++;
+            if (ThrowOnPublish) throw new InvalidOperationException("synthetic publish failure");
+        }
+
+        public void Stop()
+        {
+            StopCalls++;
+        }
+    }
+
     private static TrajectoryObservationBootstrapResult Bootstrap(TrajectoryObservationSettings settings)
     {
         CoarsePathPlanningJob job = TrajectoryObservationSetupFactory.CreateBootstrapJob(