fix: Attach FDv1 fallback applier unconditionally so the directive halts the data system without a fallback

The previous attempt to guard FDv2DataSystem.Create against a null
FDv1FallbackSynchronizer (commit dec9450) regressed Requirement 1.6.3(4):
when no FDv1 fallback is configured and the directive arrives, the SDK
must halt -- it must not keep retrying the failing synchronizer.

Skipping the FDv1 fallback factory list also stripped the
fdv1FallbackApplier from the synchronizer entry's outer-level observer,
so the directive was no longer observed: nothing disposed the streaming
source, and the EventSource library kept reconnecting after every 500.

Attach the fdv1FallbackApplier (and the initializer variant) to the
outer composite unconditionally. When an FDv1 fallback entry is in the
outer list the applier advances to it; when one is not, the applier's
BlockCurrent + DisposeCurrent + GoToNext sequence exhausts the outer
list -- which disposes the current synchronizer (stopping reconnects)
and transitions the outer composite to Off via InternalDispose.

Add an end-to-end test (SynchronizerFDv1FallbackWithoutFallbackConfiguredHaltsDataSystem)
that mirrors the harness "directive without FDv1 fallback configured halts
the data system" scenario: a synchronizer reports Interrupted+FDv1Fallback
(500 + directive), no FDv1 fallback configured, the underlying source must
be disposed, and the data system must reach Off.

Author: keelerm84

pkgs/sdk/server/src/Internal/FDv2DataSources/FDv2DataSource.cs

@@ -89,19 +89,15 @@ public static IDataSource CreateFDv2DataSource(
                     },
                     (actionable) =>
                     {
-                        // Honor the FDv1 fallback directive in the initializer phase too. When the
-                        // server returns x-ld-fd-fallback during init, skip the FDv2 synchronizer
-                        // chain entirely and switch directly to the FDv1 fallback synchronizer.
-                        if (fdv1Synchronizers != null && fdv1Synchronizers.Count > 0)
-                        {
-                            return new CompositeObserver(
-                                initializationObserver,
-                                blacklistWhenSuccessOrOff(actionable),
-                                initializerFdv1FallbackApplierFactory(actionable));
-                        }
-
+                        // Honor the FDv1 fallback directive in the initializer phase too. The
+                        // applier is attached unconditionally: when an FDv1 fallback entry is
+                        // configured the applier advances to it; when one is not, the applier's
+                        // BlockCurrent + DisposeCurrent + GoToNext sequence exhausts the outer
+                        // list and halts the data system per Requirement 1.6.3(4).
                         return new CompositeObserver(
-                            initializationObserver, blacklistWhenSuccessOrOff(actionable));
+                            initializationObserver,
+                            blacklistWhenSuccessOrOff(actionable),
+                            initializerFdv1FallbackApplierFactory(actionable));
                     }
                 ));
             }
@@ -125,13 +121,13 @@ public static IDataSource CreateFDv2DataSource(
                     },
                     (actionable) =>
                     {
-                        // Only attach FDv1 fallback applier if FDv1 synchronizers are actually provided
-                        if (fdv1Synchronizers != null && fdv1Synchronizers.Count > 0)
-                        {
-                            return new CompositeObserver(synchronizationObserver, fdv1FallbackApplierFactory(actionable));
-                        }
-
-                        return synchronizationObserver;
+                        // The FDv1 fallback applier is attached unconditionally: when an FDv1
+                        // fallback entry exists in the outer list the applier advances to it;
+                        // when one does not, BlockCurrent + DisposeCurrent + GoToNext exhausts
+                        // the outer list and halts the data system per Requirement 1.6.3(4).
+                        // Disposing the current synchronizer is what stops the streaming source
+                        // from reconnecting.
+                        return new CompositeObserver(synchronizationObserver, fdv1FallbackApplierFactory(actionable));
                     }
                 ));
             }

pkgs/sdk/server/test/Internal/FDv2DataSources/FDv2DataSourceTest.cs

@@ -1777,6 +1777,92 @@ public async Task InitializerOffWithFDv1FallbackErrorSkipsSynchronizersAndEngage
             }
         }
 
+        // End-to-end test: synchronizer reports the FDv1 fallback directive but no FDv1
+        // fallback is configured. The SDK must HALT (Requirement 1.6.3(4)) -- which in
+        // practice means the synchronizer's underlying data source must be disposed so it
+        // stops trying to reconnect. The data system reaches Off via outer composite
+        // exhaustion. Mirrors the harness suite "directive without FDv1 fallback configured
+        // halts the data system".
+        [Fact]
+        public void SynchronizerFDv1FallbackWithoutFallbackConfiguredHaltsDataSystem()
+        {
+            var capturingSink = new CapturingDataSourceUpdatesWithHeaders();
+
+            var synchronizerDisposed = false;
+            SourceFactory synchronizerFactory = (updatesSink) =>
+                new HaltMockDataSource(
+                    onStart: async () =>
+                    {
+                        // 500 + directive: a recoverable status that would normally drive retries.
+                        // The directive must take precedence and halt those retries.
+                        updatesSink.UpdateStatus(
+                            DataSourceState.Interrupted,
+                            new DataSourceStatus.ErrorInfo
+                            {
+                                Kind = DataSourceStatus.ErrorKind.ErrorResponse,
+                                StatusCode = 500,
+                                FDv1Fallback = true,
+                                Recoverable = true,
+                                Time = DateTime.Now
+                            });
+                        await Task.Yield();
+                    },
+                    onDispose: () => synchronizerDisposed = true);
+
+            // No FDv1 fallback configured (empty list).
+            var dataSource = FDv2DataSource.CreateFDv2DataSource(
+                capturingSink,
+                new List<SourceFactory>(),
+                new List<SourceFactory> { synchronizerFactory },
+                new List<SourceFactory>(),
+                TestLogger);
+
+            try
+            {
+                _ = dataSource.Start();
+
+                // The data system must transition to Off via outer composite exhaustion. Wait a
+                // few status updates -- intermediate Interrupted statuses come first.
+                var statuses = capturingSink.WaitForStatusUpdates(2, TimeSpan.FromSeconds(5));
+                Assert.Contains(statuses, s => s.State == DataSourceState.Off);
+
+                // Critically, the synchronizer must have been disposed -- this is what stops the
+                // streaming source from reconnecting in the harness scenario.
+                Assert.True(synchronizerDisposed,
+                    "synchronizer source must be disposed so the streaming source stops reconnecting");
+            }
+            finally
+            {
+                dataSource.Dispose();
+            }
+        }
+
+        // Mock data source that reports its disposal -- used to verify that the FDv1 fallback
+        // applier disposes the current synchronizer when no fallback is configured.
+        private class HaltMockDataSource : IDataSource
+        {
+            private readonly Func<Task> _onStart;
+            private readonly Action _onDispose;
+            private bool _initialized;
+
+            public HaltMockDataSource(Func<Task> onStart, Action onDispose)
+            {
+                _onStart = onStart;
+                _onDispose = onDispose;
+            }
+
+            public async Task<bool> Start()
+            {
+                await _onStart();
+                _initialized = true;
+                return true;
+            }
+
+            public bool Initialized => _initialized;
+
+            public void Dispose() => _onDispose();
+        }
+
         // End-to-end test using the REAL FDv2StreamingDataSource (with a mock IEventSource so we
         // can drive synthetic SSE events). This catches harness-style regressions in the
         // streaming source's interaction with the FDv2DataSource composite that the simpler