Replace a NaN in an input element's buffer with its default

Maintainer's decision of 2026-09-02, recorded as input-default-does-not-
replace-nan: a control cannot show NaN and the user could never enter it, so
the buffer must not hold a value the control does not. The default of an
edit, toggle, dropdown or slider replaces a NaN at the end of its buffer the
same way it fills an empty one - written as it stands, not clamped to the
element's range, and without counting as user input, because it came from an
analysis write and an analysis with onUserInput must not re-run on its own
output. Android has had it since 2026-09-02 (ExpView.expViewElement.
applyDefault); this is the iOS half, and the entry leaves phyphox-docs with
it.

Experiment.seedInputDefaults treats a trailing NaN like an empty buffer, at
every moment it already runs: when the experiment is built, on a clear, and
before each analysis pass, for every page whether or not it is on screen.
replaceValues reports no user input, so the rule's third part holds by
construction. The slider joins the collected defaults - the reason it was
kept out, that Android never seeded one, is gone, Android seeds it on every
write pass like the rest - with min and max for the two buffers of a range
slider, the values the handles show. The slider module's own catch-up between
two cycles takes the NaN case too: Float(nan) is nothing to hand a UISlider.

Tests: InputDefaultSeedingTests over the shared fixtures nan-vs-default and
init-vs-default (the rule at its source, before any view exists, plus that a
NaN written later is replaced again and never reads as user input), the
former testTheSliderIsLeftAsItIs turned into testTheSliderIsSeededLikeTheRest,
and ViewBehaviorTests.testANaNIsReplacedByTheDefault mirroring the Android
test through the remote API, asserting the experiment is still stopped.

Verified on the iPhone 17 simulator: the whole phyphoxTests target and all
five ViewBehaviorTests pass. GraphSnapshotTests and ViewSnapshotTests fail
identically on the unmodified tree on this machine (517 golden mismatches
both times) and are unrelated.

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>

Author: Staacks

phyphox-iOS/phyphox/Experiments/Experiment.swift

@@ -693,9 +693,16 @@ final class Experiment {
     ///the page the edit field is on.
     ///
     ///Only empty buffers are touched, so a value the user set - or one restored with a saved
-    ///state - stays as it is.
+    ///state - stays as it is. The one other case is a NaN at the end of the buffer, which the
+    ///default replaces the same way (input-default-does-not-replace-nan, decided 2026-09-02):
+    ///a control cannot show NaN and the user could never enter it, so the buffer must not hold a
+    ///value the control does not. It got there from an analysis write, and the replacement is
+    ///not user input any more than the seeding of an empty buffer is - replaceValues() reports
+    ///none, so an analysis with onUserInput does not re-run on its own output. The default is
+    ///written as it stands, not clamped to the element's range: a default is deliberate. A saved
+    ///state needs no exception, a NaN in it would have been replaced in the run that saved it.
     func seedInputDefaults() {
-        for (defaultValue, buffer) in inputDefaults where buffer.last == nil {
+        for (defaultValue, buffer) in inputDefaults where buffer.last?.isNaN ?? true {
             buffer.replaceValues([defaultValue])
         }
 
@@ -720,9 +727,10 @@ final class Experiment {
     }
 
     ///Collected once in init rather than walked per analysis cycle, which is where the seeding
-    ///runs. Deliberately without the slider: the parser gives it its default when the file is
-    ///read and Android never seeds one at all, so putting it back here would be a new divergence
-    ///in the other direction rather than the end of one (slider-default-never-reaches-buffer).
+    ///runs. The slider is in the list since the NaN rule (see seedInputDefaults): Android seeds
+    ///it on every write pass like the other input elements, and its own module only runs while
+    ///its page is on screen. In range mode its two buffers start from the slider's min and max,
+    ///which is what the handles show - the same values the module writes.
     private static func collectInputDefaults(_ viewDescriptors: [ExperimentViewCollectionDescriptor]?) -> [(Double, DataBuffer)] {
         var found: [(Double, DataBuffer)] = []
         for collection in viewDescriptors ?? [] {
@@ -734,6 +742,17 @@ final class Experiment {
                     found.append((dropdown.defaultValue, dropdown.buffer))
                 case let toggle as SwitchViewDescriptor:
                     found.append((toggle.defaultValue, toggle.buffer))
+                case let slider as SliderViewDescriptor:
+                    if slider.type == .Range {
+                        if let lower = slider.outputBuffers[.LowerValue] {
+                            found.append((slider.minValue, lower))
+                        }
+                        if let upper = slider.outputBuffers[.UpperValue] {
+                            found.append((slider.maxValue, upper))
+                        }
+                    } else if let buffer = slider.outputBuffers[.Empty] {
+                        found.append((slider.defaultValue, buffer))
+                    }
                 default:
                     break
                 }

phyphox-iOS/phyphox/UI/MainView/ExperimentView/ViewModules/Dynamic/ExperimentSliderView.swift

@@ -244,9 +244,12 @@ final class ExperimentSliderView: UIView, DynamicViewModule, DescriptorBoundView
     func update(){
         //If a buffer was cleared, write the default back while the slider is not being
         //dragged, so the setting is not lost for subsequent analysis cycles (matching
-        //Android's re-init)
+        //Android's re-init). Experiment.seedInputDefaults() does the same for every page at
+        //the moments that matter; this is the on-screen slider catching a cleared buffer
+        //between two analysis cycles. A NaN counts as no value here as it does there - the
+        //slider cannot show it, and Float(nan) is nothing to hand a UISlider.
         if(SliderType.Normal == descriptor.type){
-            if let buffer = sliderBuffer, buffer.last == nil, !uiSlider.isTracking {
+            if let buffer = sliderBuffer, buffer.last?.isNaN ?? true, !uiSlider.isTracking {
                 buffer.replaceValues([descriptor.defaultValue])
             }
             uiSlider.value = Float(sliderBuffer?.last ?? descriptor.defaultValue)
@@ -255,10 +258,10 @@ final class ExperimentSliderView: UIView, DynamicViewModule, DescriptorBoundView
 
         if(SliderType.Range == descriptor.type){
             if !rangeSlider.isTracking {
-                if let buffer = rangeSliderLowerBuffer, buffer.last == nil {
+                if let buffer = rangeSliderLowerBuffer, buffer.last?.isNaN ?? true {
                     buffer.replaceValues([descriptor.minValue])
                 }
-                if let buffer = rangeSliderUpperBuffer, buffer.last == nil {
+                if let buffer = rangeSliderUpperBuffer, buffer.last?.isNaN ?? true {
                     buffer.replaceValues([descriptor.maxValue])
                 }
             }

phyphox-iOS/phyphoxTests/DeserializerTests.swift

@@ -1694,30 +1694,41 @@ final class InputDefaultsTests: XCTestCase {
                        + "buffer, rather than writing the position it was showing back into it")
     }
 
-    ///The slider is deliberately left out of the seeding: the parser gives it its default when
-    ///the file is read, and Android never seeds a slider at all, so re-seeding it here would be a
-    ///new divergence in the other direction rather than the end of one
-    ///(slider-default-never-reaches-buffer, open).
-    func testTheSliderIsLeftAsItIs() throws {
+    ///The slider is seeded like the rest since the NaN rule (input-default-does-not-replace-nan,
+    ///2026-09-02): Android seeds it on every write pass like every other input element, and on
+    ///iOS its own module only runs while its page is on screen. In range mode the two buffers
+    ///start from the slider's min and max, the values the handles show.
+    func testTheSliderIsSeededLikeTheRest() throws {
         let experiment = try parse("""
         <phyphox version="1.7">
             <title>t</title><category>c</category>
-            <data-containers><container size="1" init="">sliderOut</container></data-containers>
+            <data-containers>
+                <container size="1" init="">sliderOut</container>
+                <container size="1" init="">lower</container>
+                <container size="1" init="">upper</container>
+            </data-containers>
             <views>
                 <view label="only">
                     <slider label="s" minValue="0" maxValue="10" default="7">
                         <output value="value">sliderOut</output>
                     </slider>
+                    <slider label="r" type="range" minValue="2" maxValue="8">
+                        <output value="lowerValue">lower</output>
+                        <output value="upperValue">upper</output>
+                    </slider>
                 </view>
             </views>
         </phyphox>
         """)
         XCTAssertEqual(experiment.buffers["sliderOut"]?.last, 7.0,
                        "the parser seeds it while reading the file")
         experiment.buffers["sliderOut"]?.clear(reset: true)
+        experiment.buffers["lower"]?.replaceValues([Double.nan])
+        experiment.buffers["upper"]?.clear(reset: true)
         experiment.seedInputDefaults()
-        XCTAssertNil(experiment.buffers["sliderOut"]?.last,
-                     "and nothing here puts it back, which is today's behaviour on both platforms")
+        XCTAssertEqual(experiment.buffers["sliderOut"]?.last, 7.0, "the seeding puts it back")
+        XCTAssertEqual(experiment.buffers["lower"]?.last, 2.0, "a range slider's lower buffer starts at its min")
+        XCTAssertEqual(experiment.buffers["upper"]?.last, 8.0, "and the upper one at its max")
     }
 }
 
@@ -5168,6 +5179,65 @@ final class DuplicateRootMetadataTests: XCTestCase {
 //conformance corpus and the analysis golden vectors). Nothing is copied into the test bundle,
 //where it would drift; without the sibling those tests skip with a notice (a plain clone must
 //still build and test) and CI checks it out explicitly.
+//The starting state of an input element's buffer, over the two fixtures in phyphox-docs
+//fixtures/views/ that exist for it. The UI half (ViewBehaviorTests) asserts the same through the
+//remote API on a running app; this is the rule at its source, Experiment.seedInputDefaults,
+//which runs when the experiment is built - before any page exists.
+final class InputDefaultSeedingTests: XCTestCase {
+    private func load(_ fixture: String) throws -> Experiment {
+        let directory = try DocsCorpus.docsDirectory("fixtures/views", notTestedNotice: "input defaults")
+        return try ExperimentSerialization.readExperimentFromURL(directory.appendingPathComponent("\(fixture).phyphox"))
+    }
+
+    private func assertBuffers(_ experiment: Experiment, _ expected: [(String, Double)],
+                               file: StaticString = #filePath, line: UInt = #line) throws {
+        for (name, value) in expected {
+            let values = try experiment.buffers[name].unwrap().toArray()
+            XCTAssertEqual(values, [value], name, file: file, line: line)
+        }
+    }
+
+    //A default fills an EMPTY buffer and never overwrites one that is not
+    func testContainerInitBeatsAControlsDefault() throws {
+        try assertBuffers(try load("init-vs-default"), [
+            ("toggle_init", 1), ("dropdown_init", 2), ("edit_init", 42), ("slider_init", 4),
+            ("toggle_default", 1), ("dropdown_default", 1), ("edit_default", 7), ("slider_default", 3),
+        ])
+    }
+
+    //A NaN is replaced by the default as written - the edit's default lies above its max on
+    //purpose - for every element, the slider included (input-default-does-not-replace-nan)
+    func testANaNIsReplacedByTheDefault() throws {
+        try assertBuffers(try load("nan-vs-default"), [
+            ("toggle_nan", 1), ("dropdown_nan", 2), ("edit_nan", 12), ("slider_nan", 3),
+        ])
+    }
+
+    //The replacement happens on every seeding, not only when the experiment is built: an
+    //analysis writing NaN into an input element's buffer gets the default back before the next
+    //cycle, and the buffer never reports the write as user input
+    func testANaNWrittenLaterIsReplacedAgain() throws {
+        let experiment = try load("nan-vs-default")
+        let buffer = try experiment.buffers["edit_nan"].unwrap()
+        let observer = UserInputCounter()
+        buffer.addObserver(observer)
+
+        buffer.replaceValues([Double.nan])
+        experiment.seedInputDefaults()
+        XCTAssertEqual(buffer.toArray(), [12])
+        //User input is reported asynchronously on the main queue, so give it the chance
+        RunLoop.main.run(until: Date(timeIntervalSinceNow: 0.2))
+        XCTAssertEqual(observer.userInputs, 0, "replacing a NaN must not read as user input")
+        withExtendedLifetime(observer) {}
+    }
+
+    private final class UserInputCounter: DataBufferObserver {
+        var userInputs = 0
+        func dataBufferUpdated(_ buffer: DataBuffer) {}
+        func userInputTriggered(_ buffer: DataBuffer) { userInputs += 1 }
+    }
+}
+
 enum DocsCorpus {
     //#filePath is resolvable at test time because the suite builds and runs on the same
     //machine, locally as well as on CI

phyphox-iOS/phyphoxUITests/ViewBehaviorTests.swift

@@ -262,6 +262,25 @@ final class ViewBehaviorTests: XCTestCase {
         }
     }
 
+    //A NaN in an input element's buffer is replaced by the element's default, as written and
+    //not clamped to the element's range (the edit's default lies above its max on purpose), for
+    //the slider like for the rest - and the replacement is not user input, so an experiment
+    //that has only been opened is still stopped afterwards (input-default-does-not-replace-nan,
+    //decided 2026-09-02). Mirrors ViewBehaviorTest.aNanIsReplacedByTheDefault.
+    // phyphox-test: view-behavior
+    func testANaNIsReplacedByTheDefault() throws {
+        _ = try launch(fixture: "nan-vs-default")
+
+        expectBuffer("toggle_nan", toEqual: [1], "the toggle's default replaces the NaN")
+        expectBuffer("dropdown_nan", toEqual: [2], "the dropdown's default replaces the NaN")
+        expectBuffer("edit_nan", toEqual: [12], "the edit's default replaces the NaN, unclamped")
+        expectBuffer("slider_nan", toEqual: [3], "the slider's default replaces the NaN")
+
+        let status = get("/get")?["status"] as? [String: Any]
+        XCTAssertNotNil(status, "the status is reported")
+        XCTAssertEqual(status?["measuring"] as? Bool, false, "replacing a NaN started the experiment")
+    }
+
     // MARK: - helpers
 
     ///Moves a slider and waits for the value the fixture should end up with, repeating the gesture