@@ -75,10 +75,19 @@ def apply(merged: MergeResult) -> None:
             retry_delay=DEFAULT_RETRY_DELAY,
             skip_unchanged=True,
         )
+        # Change detection is set up before the initial load, so an edit made while the files
+        # are first read is picked up by the reload it triggers instead of waiting for a later
+        # change.
         with self._lock:
             if self._closed:
                 return
             self._reloader = reloader
+            if self._change_detection == ChangeDetection.WATCHING:
+                self._change_detector = Watcher(self._paths, reloader.trigger)
+            else:
+                poller = Poller(self._paths, self._poll_interval, reloader.trigger)
+                poller.start()
+                self._change_detector = poller
 
         # The initial load runs synchronously, so overrides present in the files are in effect
         # by the time the client constructor returns. A file that does not exist yet
@@ -87,16 +96,6 @@ def apply(merged: MergeResult) -> None:
         # the file is readable.
         reloader.reload_now()
 
-        with self._lock:
-            if self._closed:
-                return
-            if self._change_detection == ChangeDetection.WATCHING:
-                self._change_detector = Watcher(self._paths, reloader.trigger)
-            else:
-                poller = Poller(self._paths, self._poll_interval, reloader.trigger)
-                poller.start()
-                self._change_detector = poller
-
     def close(self) -> None:
         with self._lock:
             if self._closed:
@@ -106,10 +105,14 @@ def close(self) -> None:
             reloader = self._reloader
             self._change_detector = None
             self._reloader = None
-        if change_detector is not None:
-            change_detector.close()
-        if reloader is not None:
-            reloader.close()
+        try:
+            if change_detector is not None:
+                change_detector.close()
+        finally:
+            # The reloader stops even when the change detector fails to close, so no reload
+            # can run after close.
+            if reloader is not None:
+                reloader.close()
 
 
 def _log_overrides_in_effect(merged: MergeResult) -> None:
 
@@ -26,6 +26,7 @@
 counters, so LaunchDarkly can distinguish them. They produce no individual evaluation events.
 """
 
+import math
 from typing import List, Optional, Union
 
 from ldclient.config import DataSourceBuilderConfig, OverrideSourceBuilder
@@ -126,7 +127,13 @@ def poll_interval(self, seconds: float) -> 'FileOverrideSourceBuilder':
         :attr:`MINIMUM_POLL_INTERVAL` is raised to the minimum.
 
         :param seconds: the interval in seconds
+        :raises TypeError: when the interval is not a number
+        :raises ValueError: when the interval is not a finite number
         """
+        if isinstance(seconds, bool) or not isinstance(seconds, (int, float)):
+            raise TypeError("the poll interval must be a number of seconds")
+        if not math.isfinite(seconds):
+            raise ValueError("the poll interval must be a finite number of seconds")
         self.__poll_interval = seconds
         return self
 
 
@@ -4,9 +4,10 @@
 """
 import logging
 import os
+import threading
 import time
 from queue import Empty, Queue
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any, Dict, List, Optional, Set, Tuple
 
 import pytest
 
@@ -164,6 +165,18 @@ def test_builder_clamps_poll_interval_to_the_minimum(caplog):
     assert source._poll_interval == 2.5
 
 
+@pytest.mark.parametrize('seconds', ['1', None, True], ids=['string', 'none', 'bool'])
+def test_builder_rejects_a_poll_interval_that_is_not_a_number(seconds):
+    with pytest.raises(TypeError):
+        FileOverrideSourceBuilder(['a']).poll_interval(seconds)
+
+
+@pytest.mark.parametrize('seconds', [float('nan'), float('inf'), float('-inf')], ids=['nan', 'inf', '-inf'])
+def test_builder_rejects_a_poll_interval_that_is_not_finite(seconds):
+    with pytest.raises(ValueError):
+        FileOverrideSourceBuilder(['a']).poll_interval(seconds)
+
+
 def test_builder_rejects_watching_without_watchdog(monkeypatch):
     import ldclient.integrations.overrides as module
     monkeypatch.setattr(module, 'have_watchdog', False)
@@ -369,6 +382,56 @@ def test_source_retries_a_failed_load_without_a_change_signal(tmp_path, sources,
         assert flag_values(sink.require_snapshot()) == {'flag1': False}
 
 
+@pytest.mark.parametrize("mode", [ChangeDetection.POLLING, pytest.param(ChangeDetection.WATCHING, marks=watchdog_required)])
+def test_source_detects_an_edit_made_during_the_initial_load(tmp_path, sources, monkeypatch, mode):
+    path = os.path.join(str(tmp_path), 'overrides.json')
+    write_file(path, '{"flagValues": {"flag1": "initial"}}')
+    original_reload_now = filedata.Reloader.reload_now
+
+    def load_then_edit(reloader: filedata.Reloader) -> None:
+        # The edit lands after the files were read and before start returns.
+        original_reload_now(reloader)
+        write_file(path, '{"flagValues": {"flag1": "edited-after-the-first-read"}}')
+
+    monkeypatch.setattr(filedata.Reloader, 'reload_now', load_then_edit)
+    _, sink = build_source(sources, [path], lambda b: b.change_detection(mode).poll_interval(FileOverrideSourceBuilder.MINIMUM_POLL_INTERVAL))
+
+    # The initial snapshot holds what the first read saw. The edit is detected and applied
+    # without any further change to the file.
+    assert flag_values(sink.require_snapshot()) == {'flag1': 'initial'}
+    assert flag_values(sink.require_snapshot()) == {'flag1': 'edited-after-the-first-read'}
+
+
+def reloader_threads() -> Set[threading.Thread]:
+    return {t for t in threading.enumerate() if t.name == 'ldclient.filedata.reloader'}
+
+
+def test_source_close_stops_the_reloader_when_the_change_detector_fails_to_close(tmp_path, sources, monkeypatch):
+    path = os.path.join(str(tmp_path), 'overrides.json')
+    write_file(path, '{}')
+    before = reloader_threads()
+    source, sink = build_source(sources, [path])
+    sink.require_snapshot()
+    started = reloader_threads() - before
+    assert len(started) == 1
+
+    detector: Any = source._change_detector
+    original_close = detector.close
+
+    def failing_close() -> None:
+        original_close()
+        raise RuntimeError("detector close failure")
+
+    monkeypatch.setattr(detector, 'close', failing_close)
+
+    # The failure propagates, and the reloader is stopped all the same: its worker ends.
+    with pytest.raises(RuntimeError):
+        source.close()
+    worker = started.pop()
+    worker.join(TEST_TIMEOUT)
+    assert not worker.is_alive()
+
+
 def test_source_does_not_supply_snapshots_after_close(tmp_path, sources):
     path = os.path.join(str(tmp_path), 'overrides.json')
     write_file(path, '{"flagValues": {"flag1": true}}')