Derive both raw swap oracles from one helper

Diagnostic, case normalized number entity lookup
Address review: exact object_id lookup for the write numbers
2026-09-10 14:57:32 +00:00 · 2026-09-08 18:11:11 +02:00 · 2026-09-08 18:11:10 +02:00 · 2026-09-08 18:11:10 +02:00 · 2026-09-08 18:11:10 +02:00 · 2026-09-08 18:11:10 +02:00
26 changed files with 570 additions and 1031 deletions
@@ -58,9 +58,6 @@ esp_err_t AudioReader::add_sink(const std::weak_ptr<ring_buffer::RingBuffer> &ou
  if (current_audio_file_ != nullptr) {
    // A transfer buffer isn't ncessary for a local file
    this->file_ring_buffer_ = output_ring_buffer.lock();
-    if (this->file_ring_buffer_ == nullptr) {
-      return ESP_ERR_INVALID_STATE;
-    }
    return ESP_OK;
  }

@@ -51,14 +51,14 @@ void AudioTransferBuffer::increase_buffer_length(size_t bytes) { this->buffer_le

 void AudioTransferBuffer::clear_buffered_data() {
  this->buffer_length_ = 0;
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
    this->ring_buffer_->reset();
  }
 }

 void AudioSinkTransferBuffer::clear_buffered_data() {
  this->buffer_length_ = 0;
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
    this->ring_buffer_->reset();
  }
 #ifdef USE_SPEAKER
@@ -69,7 +69,7 @@ void AudioSinkTransferBuffer::clear_buffered_data() {
 }

 bool AudioTransferBuffer::has_buffered_data() const {
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
    return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
  }
  return (this->available() > 0);
@@ -144,7 +144,7 @@ size_t AudioSourceTransferBuffer::transfer_data_from_source(TickType_t ticks_to_
  size_t bytes_to_read = AudioTransferBuffer::free();
  size_t bytes_read = 0;
  if (bytes_to_read > 0) {
-    if (this->ring_buffer_ != nullptr) {
+    if (this->ring_buffer_.use_count() > 0) {
      bytes_read = this->ring_buffer_->read((void *) this->get_buffer_end(), bytes_to_read, ticks_to_wait);
    }

@@ -161,7 +161,7 @@ size_t AudioSinkTransferBuffer::transfer_data_to_sink(TickType_t ticks_to_wait,
      bytes_written = this->speaker_->play(this->data_start_, this->available(), ticks_to_wait);
    } else
 #endif
-        if (this->ring_buffer_ != nullptr) {
+        if (this->ring_buffer_.use_count() > 0) {
      bytes_written =
          this->ring_buffer_->write_without_replacement((void *) this->data_start_, this->available(), ticks_to_wait);
    } else if (this->sink_callback_ != nullptr) {
@@ -186,7 +186,7 @@ bool AudioSinkTransferBuffer::has_buffered_data() const {
    return (this->speaker_->has_buffered_data() || (this->available() > 0));
  }
 #endif
-  if (this->ring_buffer_ != nullptr) {
+  if (this->ring_buffer_.use_count() > 0) {
    return ((this->ring_buffer_->available() > 0) || (this->available() > 0));
  }
  return (this->available() > 0);
@@ -41,10 +41,7 @@ const noise::NoiseContext &ESPHomeOTAComponent::noise_context_() const {
 #endif
 static constexpr uint16_t OTA_BLOCK_SIZE = 8192;
 static constexpr uint32_t OTA_SOCKET_TIMEOUT_HANDSHAKE = 20000;  // milliseconds for initial handshake
-// Milliseconds for data transfer. Covers the lwIP retransmit run seen in
-// practice for a lost chunk ack (1.5 + 3 + 6 + 12 + 24 + 48 s); the CLI waits
-// longer (espota2.DATA_PHASE_TIMEOUT) so the device is free before it retries
-static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 105000;
+static constexpr uint32_t OTA_SOCKET_TIMEOUT_DATA = 90000;       // milliseconds for data transfer

 // Single-instance pointer — multi-port configs are rejected in final_validate.
 // NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
@@ -118,24 +118,21 @@ void I2SAudioSpeakerBase::loop() {
        break;
      }

-      // Still starting up or winding down from a previous run
-      if ((this->tx_handle_ != nullptr) || (this->speaker_task_handle_ != nullptr)) {
-        break;
-      }
-
      if (this->start_i2s_driver(this->audio_stream_info_) != ESP_OK) {
        ESP_LOGE(TAG, "Driver failed to start; retrying in 1 second");
        this->status_momentary_error("driver-failure", 1000);
        break;
      }

-      xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
-                  &this->speaker_task_handle_);
-
      if (this->speaker_task_handle_ == nullptr) {
-        ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
-        this->status_momentary_error("task-failure", 1000);
-        this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
+        xTaskCreate(I2SAudioSpeakerBase::speaker_task, "speaker_task", TASK_STACK_SIZE, (void *) this, TASK_PRIORITY,
+                    &this->speaker_task_handle_);
+
+        if (this->speaker_task_handle_ == nullptr) {
+          ESP_LOGE(TAG, "Task failed to start, retrying in 1 second");
+          this->status_momentary_error("task-failure", 1000);
+          this->stop_i2s_driver_();  // Stops the driver to return the lock; will be reloaded in next attempt
+        }
      }
      break;
    case speaker::STATE_RUNNING:   // Intentional fallthrough
@@ -221,8 +218,8 @@ size_t I2SAudioSpeakerBase::play(const uint8_t *data, size_t length, TickType_t
 }

 bool I2SAudioSpeakerBase::has_buffered_data() const {
-  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
-  if (temp_ring_buffer != nullptr) {
+  if (this->audio_ring_buffer_.use_count() > 0) {
+    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->audio_ring_buffer_.lock();
    return temp_ring_buffer->available() > 0;
  }
  return false;
@@ -129,7 +129,7 @@ void MicroWakeWord::setup() {
      return;
    }
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
+    if (this->ring_buffer_.use_count() > 1) {
      // Producer-only write: never touches consumer state. If the buffer is full, ask the inference task
      // to drain it - reset() is a consumer operation and must run on the inference task's thread.
      // Disable partial writes so audio chunks are either fully accepted or rejected and handled below.
@@ -446,9 +446,9 @@ void MicroWakeWord::loop() {
    xEventGroupClearBits(this->event_group_, EventGroupBits::TASK_STOPPING);
  }

-  // Retries on a subsequent loop if the task is still running on the other core
-  if ((event_group_bits & EventGroupBits::TASK_STOPPED) && this->inference_task_.deallocate()) {
+  if ((event_group_bits & EventGroupBits::TASK_STOPPED)) {
    ESP_LOGD(TAG, "Inference task is finished, freeing task resources");
+    this->inference_task_.deallocate();
    xEventGroupClearBits(this->event_group_, ALL_BITS);
    xQueueReset(this->detection_queue_);
    this->set_state_(State::STOPPED);
@@ -48,7 +48,7 @@ class MicrophoneSource final {
  template<typename F> void add_data_callback(F &&data_callback) {
    this->mic_->add_data_callback([this, data_callback](const std::vector<uint8_t> &data) {
      if (this->enabled_ || this->passive_) {
-        if (this->processed_samples_ == nullptr) {
+        if (this->processed_samples_.use_count() == 0) {
          // Create vector if its unused
          this->processed_samples_ = std::make_shared<std::vector<uint8_t>>();
        }
@@ -218,7 +218,7 @@ size_t SourceSpeaker::play(const uint8_t *data, size_t length, TickType_t ticks_
  }
  size_t bytes_written = 0;
  std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-  if (temp_ring_buffer != nullptr) {
+  if (temp_ring_buffer.use_count() > 0) {
    // Only write to the ring buffer if the reference is valid
    bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
    if (bytes_written > 0) {
@@ -250,14 +250,14 @@ esp_err_t SourceSpeaker::start_() {
  // avoids unnecessary single-frame splices.
  const size_t ring_buffer_size =
      (this->audio_stream_info_.ms_to_bytes(this->buffer_duration_ms_) / bytes_per_frame) * bytes_per_frame;
-  if (this->audio_source_ == nullptr) {
+  if (this->audio_source_.use_count() == 0) {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer == nullptr) {
+    if (!temp_ring_buffer) {
      temp_ring_buffer = ring_buffer::RingBuffer::create(ring_buffer_size);
      this->ring_buffer_ = temp_ring_buffer;
    }

-    if (temp_ring_buffer == nullptr) {
+    if (!temp_ring_buffer) {
      return ESP_ERR_NO_MEM;
    }

@@ -278,7 +278,7 @@ void SourceSpeaker::stop() { this->send_command_(SOURCE_SPEAKER_COMMAND_STOP); }
 void SourceSpeaker::finish() { this->send_command_(SOURCE_SPEAKER_COMMAND_FINISH); }

 bool SourceSpeaker::has_buffered_data() const {
-  return ((this->audio_source_ != nullptr) && this->audio_source_->has_buffered_data());
+  return ((this->audio_source_.use_count() > 0) && this->audio_source_->has_buffered_data());
 }

 void SourceSpeaker::set_mute_state(bool mute_state) {
@@ -382,8 +382,8 @@ void MixerSpeaker::loop() {
    ESP_LOGV(TAG, "Stopping");
    xEventGroupClearBits(this->event_group_, MIXER_TASK_STATE_STOPPING);
  }
-  // Retries on a subsequent loop if the task is still running on the other core
-  if ((event_group_bits & MIXER_TASK_STATE_STOPPED) && this->task_.deallocate()) {
+  if (event_group_bits & MIXER_TASK_STATE_STOPPED) {
+    this->task_.deallocate();
    ESP_LOGD(TAG, "Stopped");
    xEventGroupClearBits(this->event_group_, MIXER_TASK_ALL_BITS);
    this->all_stopped_since_ms_ = 0;
@@ -496,7 +496,7 @@ void MixerSpeaker::audio_mixer_task(void *params) {
        if (speaker->is_running() && !speaker->get_pause_state()) {
          // Speaker is running and not paused, so it possibly can provide audio data
          std::shared_ptr<audio::RingBufferAudioSource> audio_source = speaker->get_audio_source().lock();
-          if (audio_source == nullptr) {
+          if (audio_source.use_count() == 0) {
            // No audio source allocated, so skip processing this speaker
            continue;
          }
@@ -88,12 +88,12 @@ def encryption_schema(config: ConfigType | None) -> ConfigType:

 async def to_code(config: ConfigType) -> None:
    cg.add_define("USE_NOISE")
-    cg.add_library("esphome/noise-c", "0.1.26")
+    cg.add_library("esphome/noise-c", "0.1.24")
    # noise-c depends on libsodium, but declaring it here too lets the
    # library manager see the full set up front instead of discovering
    # libsodium only after noise-c has downloaded, so the two can download
    # in parallel. The version must match noise-c's library.json.
-    cg.add_library("esphome/libsodium", "1.10021.8")
+    cg.add_library("esphome/libsodium", "1.10021.6")
    # Enable optimized memzero/memcmp in libsodium instead of volatile byte loops
    cg.add_build_flag("-DHAVE_WEAK_SYMBOLS=1")
    cg.add_build_flag("-DHAVE_INLINE_ASM=1")
@@ -153,8 +153,8 @@ void ResamplerSpeaker::loop() {
    ESP_LOGV(TAG, "Stopping");
    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::STATE_STOPPING);
  }
-  // Retries on a subsequent loop if the task is still running on the other core
-  if ((event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) && this->task_.deallocate()) {
+  if (event_group_bits & ResamplingEventGroupBits::STATE_STOPPED) {
+    this->task_.deallocate();
    ESP_LOGD(TAG, "Stopped");
    xEventGroupClearBits(this->event_group_, ResamplingEventGroupBits::ALL_BITS);
  }
@@ -235,7 +235,7 @@ size_t ResamplerSpeaker::play(const uint8_t *data, size_t length, TickType_t tic
    bytes_written = this->output_speaker_->play(data, length, ticks_to_wait);
  } else {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
+    if (temp_ring_buffer) {
      // Only write to the ring buffer if the reference is valid
      bytes_written = temp_ring_buffer->write_without_replacement(data, length, ticks_to_wait);
    } else {
@@ -299,7 +299,7 @@ bool ResamplerSpeaker::has_buffered_data() const {
  bool has_ring_buffer_data = false;
  if (this->requires_resampling_()) {
    std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this->ring_buffer_.lock();
-    if (temp_ring_buffer != nullptr) {
+    if (temp_ring_buffer) {
      has_ring_buffer_data = (temp_ring_buffer->available() > 0);
    }
  }
@@ -342,7 +342,7 @@ void ResamplerSpeaker::resample_task(void *params) {
      std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = ring_buffer::RingBuffer::create(
          this_resampler->audio_stream_info_.ms_to_bytes(this_resampler->buffer_duration_ms_));

-      if (temp_ring_buffer == nullptr) {
+      if (!temp_ring_buffer) {
        err = ESP_ERR_NO_MEM;
      } else {
        this_resampler->ring_buffer_ = temp_ring_buffer;
@@ -30,7 +30,6 @@ CONF_SENDSPIN_ID = "sendspin_id"
 CONF_INITIAL_STATIC_DELAY = "initial_static_delay"
 CONF_FIXED_DELAY = "fixed_delay"
 CONF_DECODE_MEMORY = "decode_memory"
-CONF_CODECS = "codecs"

 # Matches ARTWORK_MAX_SLOTS in sendspin-cpp.
 MAX_ARTWORK_SLOTS = 4
@@ -45,20 +44,6 @@ CODEC_FORMAT_OPUS = SendspinCodecFormat.enum("OPUS")
 CODEC_FORMAT_PCM = SendspinCodecFormat.enum("PCM")
 CODEC_FORMAT_UNSUPPORTED = SendspinCodecFormat.enum("UNSUPPORTED")

-CODEC_FLAC = "flac"
-CODEC_OPUS = "opus"
-CODEC_PCM = "pcm"
-
-CODECS = {
-    CODEC_FLAC: CODEC_FORMAT_FLAC,
-    CODEC_OPUS: CODEC_FORMAT_OPUS,
-    CODEC_PCM: CODEC_FORMAT_PCM,
-}
-
-# Opus only supports 48 kHz audio, so it is left out of the default list at other rates.
-DEFAULT_CODECS = [CODEC_FLAC, CODEC_OPUS, CODEC_PCM]
-OPUS_SAMPLE_RATE = 48000
-
 SendspinImageFormat = sendspin_library_ns.enum("SendspinImageFormat", is_class=True)
 IMAGE_FORMAT_JPEG = SendspinImageFormat.enum("JPEG")
 IMAGE_FORMAT_PNG = SendspinImageFormat.enum("PNG")
@@ -301,13 +286,16 @@ async def to_code(config: ConfigType) -> None:
    if data.player_support:
        cg.add_define("USE_SENDSPIN_PLAYER", True)

-        # Configures the player role. Each configured codec is advertised for 16 bits per sample
-        # mono and stereo at the configured sample rate. The order is a preference order, both for
-        # the codecs themselves and for stereo over mono.
+        # Configures the player role. We always assume support for 16 bits per sample mono and stereo FLAC, Opus, and PCM at the configured sample rate
+        # (with Opus only supported at 48 kHz since that's the only sample rate it supports). Users can configure the specific formats via the Sendspin server
        player_cfg = data.player_config
        sample_rate = player_cfg[CONF_SAMPLE_RATE]

-        codecs = [CODECS[codec] for codec in player_cfg[CONF_CODECS]]
+        # OPUS only supports 48 kHz audio
+        codecs = [CODEC_FORMAT_FLAC]
+        if sample_rate == 48000:
+            codecs.append(CODEC_FORMAT_OPUS)
+        codecs.append(CODEC_FORMAT_PCM)

        def _audio_format(codec: MockObj, channels: int) -> cg.StructInitializer:
            return cg.StructInitializer(
@@ -13,16 +13,11 @@ from esphome.cpp_generator import MockObj, TemplateArgsType
 from esphome.types import ConfigType

 from .. import (
-    CODEC_OPUS,
-    CODECS,
-    CONF_CODECS,
    CONF_DECODE_MEMORY,
    CONF_FIXED_DELAY,
    CONF_INITIAL_STATIC_DELAY,
    CONF_SENDSPIN_ID,
-    DEFAULT_CODECS,
    MEMORY_LOCATIONS,
-    OPUS_SAMPLE_RATE,
    SendspinHub,
    register_player_config,
    request_controller_support,
@@ -54,32 +49,10 @@ DisableStaticDelayAdjustmentAction = sendspin_ns.class_(
 )


-def _resolve_codecs(config: ConfigType) -> ConfigType:
-    """Validate the codec preference list, filling in the default when it is not set."""
-    sample_rate = config[CONF_SAMPLE_RATE]
-    if (codecs := config.get(CONF_CODECS)) is None:
-        config[CONF_CODECS] = [
-            codec
-            for codec in DEFAULT_CODECS
-            if codec != CODEC_OPUS or sample_rate == OPUS_SAMPLE_RATE
-        ]
-        return config
-
-    if len(set(codecs)) != len(codecs):
-        raise cv.Invalid("Each codec may only be listed once", path=[CONF_CODECS])
-    if CODEC_OPUS in codecs and sample_rate != OPUS_SAMPLE_RATE:
-        raise cv.Invalid(
-            f"Codec '{CODEC_OPUS}' requires a {CONF_SAMPLE_RATE} of {OPUS_SAMPLE_RATE}",
-            path=[CONF_CODECS],
-        )
-    return config
-
-
 def _register(config: ConfigType) -> ConfigType:
    request_controller_support()
    register_player_config(
        {
-            CONF_CODECS: config[CONF_CODECS],
            CONF_SAMPLE_RATE: config[CONF_SAMPLE_RATE],
            CONF_BUFFER_SIZE: config[CONF_BUFFER_SIZE],
            CONF_INITIAL_STATIC_DELAY: config[CONF_INITIAL_STATIC_DELAY],
@@ -112,13 +85,9 @@ CONFIG_SCHEMA = cv.All(
                min=16000, max=96000
            ),
            cv.Optional(CONF_DECODE_MEMORY): cv.one_of(*MEMORY_LOCATIONS, lower=True),
-            cv.Optional(CONF_CODECS): cv.All(
-                cv.ensure_list(cv.enum(CODECS, lower=True)), cv.Length(min=1)
-            ),
        }
    ),
    cv.only_on_esp32,
-    _resolve_codecs,
    _register,
 )

@@ -202,15 +202,8 @@ AudioPipelineState AudioPipeline::process_state() {
    if (!this->is_playing_) {
      // The tasks have been stopped for two ``process_state`` calls in a row, so delete the tasks
      if (this->read_task_.is_created() || this->decode_task_.is_created()) {
-        // Both are attempted every time; a task that is still running on the other core is freed by a
-        // subsequent call, and freeing an already freed task succeeds without doing anything
-        bool read_task_freed = this->read_task_.deallocate();
-        bool decode_task_freed = this->decode_task_.deallocate();
-        if (!read_task_freed || !decode_task_freed) {
-          // A task is still running on the other core, so keep the pipeline in its current state and try
-          // again on the next call
-          return AudioPipelineState::PLAYING;
-        }
+        this->read_task_.deallocate();
+        this->decode_task_.deallocate();
        if (this->hard_stop_) {
          // Stop command was sent, so immediately end the playback
          this->speaker_->stop();
@@ -322,17 +315,17 @@ void AudioPipeline::read_task(void *params) {
      if (err == ESP_OK) {
        size_t file_ring_buffer_size = this_pipeline->buffer_size_;

-        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer = this_pipeline->raw_file_ring_buffer_.lock();
+        std::shared_ptr<ring_buffer::RingBuffer> temp_ring_buffer;

-        if (temp_ring_buffer == nullptr) {
+        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
          temp_ring_buffer = ring_buffer::RingBuffer::create(file_ring_buffer_size);
          this_pipeline->raw_file_ring_buffer_ = temp_ring_buffer;
        }

-        if (temp_ring_buffer == nullptr) {
+        if (!this_pipeline->raw_file_ring_buffer_.use_count()) {
          err = ESP_ERR_NO_MEM;
        } else {
-          err = reader->add_sink(temp_ring_buffer);
+          reader->add_sink(this_pipeline->raw_file_ring_buffer_);
        }
      }

@@ -403,9 +396,7 @@ void AudioPipeline::decode_task(void *params) {
          make_unique<audio::AudioDecoder>(this_pipeline->transfer_buffer_size_, this_pipeline->transfer_buffer_size_);

      esp_err_t err = decoder->start(this_pipeline->current_audio_file_type_);
-      if (err == ESP_OK) {
-        err = decoder->add_source(this_pipeline->raw_file_ring_buffer_);
-      }
+      decoder->add_source(this_pipeline->raw_file_ring_buffer_);

      if (err != ESP_OK) {
        // Send specific error message
@@ -40,31 +40,16 @@ bool StaticTask::create(TaskFunction_t fn, const char *name, uint32_t stack_size
  return true;
 }

-bool StaticTask::destroy() {
-  if (this->handle_ == nullptr) {
-    return true;
+void StaticTask::destroy() {
+  if (this->handle_ != nullptr) {
+    TaskHandle_t handle = this->handle_;
+    this->handle_ = nullptr;
+    vTaskDelete(handle);
  }
-
-  // Suspending takes the task off the ready and event lists, so nothing can schedule it again. It only asks
-  // the other core to yield though, so the task may still be running on it for a moment.
-  vTaskSuspend(this->handle_);
-  if (eTaskGetState(this->handle_) != eSuspended) {
-    // The task is still running on the other core and using its stack. Deleting it now would only put it on
-    // the termination list and return, so the caller has to try again once it has been swapped out.
-    return false;
-  }
-
-  // The task cannot run again, so the delete completes right away instead of being left to the idle task.
-  TaskHandle_t handle = this->handle_;
-  this->handle_ = nullptr;
-  vTaskDelete(handle);
-  return true;
 }

-bool StaticTask::deallocate() {
-  if (!this->destroy()) {
-    return false;
-  }
+void StaticTask::deallocate() {
+  this->destroy();
  if (this->stack_buffer_ != nullptr) {
    RAMAllocator<StackType_t> allocator(this->use_psram_ ? RAMAllocator<StackType_t>::ALLOC_EXTERNAL
                                                         : RAMAllocator<StackType_t>::ALLOC_INTERNAL);
@@ -72,7 +57,6 @@ bool StaticTask::deallocate() {
    this->stack_buffer_ = nullptr;
    this->stack_size_ = 0;
  }
-  return true;
 }

 }  // namespace esphome
@@ -11,7 +11,6 @@ namespace esphome {

 /** Helper for FreeRTOS static task management.
 * Bundles TaskHandle_t, StaticTask_t, and the stack buffer into one object with create/destroy methods.
- * Call destroy() and deallocate() from another task: a task cannot free the stack it is still running on.
 */
 class StaticTask {
 public:
@@ -24,7 +23,7 @@ class StaticTask {
  /// @brief Allocate stack and create task.
  /// @param fn         Task function
  /// @param name       Task name (for debug)
-  /// @param stack_size Stack size in bytes (StackType_t is a byte on ESP-IDF)
+  /// @param stack_size Stack size in StackType_t words
  /// @param param      Parameter passed to task function
  /// @param priority   FreeRTOS task priority
  /// @param use_psram  If true, allocate stack in PSRAM; otherwise internal RAM
@@ -32,17 +31,11 @@ class StaticTask {
  bool create(TaskFunction_t fn, const char *name, uint32_t stack_size, void *param, UBaseType_t priority,
              bool use_psram);

-  /// @brief Delete the task, keeping the stack buffer allocated for reuse by a subsequent create() call.
-  /// The task must have finished its work and parked itself, either suspended or blocked indefinitely: it is
-  /// suspended here so that it cannot be scheduled again, and it is given no chance to clean up.
-  /// @return true if the task was deleted; false if it is still running on another core, in which case the
-  /// caller should try again later.
-  bool destroy();
+  /// @brief Delete the task but keep the stack buffer allocated for reuse by a subsequent create() call.
+  void destroy();

-  /// @brief Delete the task (if created) and free the stack buffer.
-  /// @return true if the stack buffer was freed; false if the task is still running on another core, in
-  /// which case the caller should try again later.
-  bool deallocate();
+  /// @brief Delete the task (if running) and free the stack buffer.
+  void deallocate();

 protected:
  TaskHandle_t handle_{nullptr};
@@ -96,10 +96,6 @@ UPLOAD_BUFFER_SIZE = UPLOAD_BLOCK_SIZE * 8
 # across the addresses on top of that.
 EXTRA_UPLOAD_ATTEMPTS = 2
 UPLOAD_RETRY_DELAY = 5.0
-# Data phase timeout; must stay longer than the device's OTA_SOCKET_TIMEOUT_DATA
-# (105 s) so a stalled session is gone before a retry, and long enough for lwIP
-# to get a lost chunk ack through after the retransmit run seen in practice
-DATA_PHASE_TIMEOUT = 160.0

 _LOGGER = logging.getLogger(__name__)

@@ -698,7 +694,8 @@ def perform_ota(

    _LOGGER.info("Handshake complete")

-    sock.settimeout(DATA_PHASE_TIMEOUT)
+    # Timeout must match device-side OTA_SOCKET_TIMEOUT_DATA to prevent premature failures
+    sock.settimeout(90.0)

    if extended_proto:
        send_check(sock, ota_type, "ota type")
@@ -857,7 +854,7 @@ def run_ota_impl_(
    # clean up a half-open connection (its handshake watchdog runs at 20s);
    # moving on to the next address family stays immediate. Known limitation:
    # a silent mid-transfer drop with no reset can wedge the device until its
-    # 105s data timeout, which outlasts this budget; the retries target the
+    # 90s data timeout, which outlasts this budget; the retries target the
    # common failures where the device resets or closes the link promptly.
    total_attempts = len(res) + EXTRA_UPLOAD_ATTEMPTS
    last_error = ""
@@ -45,7 +45,7 @@ lib_deps_base =
 lib_deps =
    ${common.lib_deps_base}
    https://github.com/dudanov/MideaUART.git#eeea6c3e9b4474f067054592b435be1c4e466815 ; midea
-    esphome/noise-c@0.1.26                 ; noise (api, ota)
+    esphome/noise-c@0.1.24                 ; noise (api, ota)
    improv/Improv@1.2.7                    ; improv_serial / esp32_improv
    kikuchan98/pngle@1.1.0                 ; online_image
    ; Using the repository directly, otherwise ESP-IDF can't use the library
@@ -244,7 +244,7 @@ lib_deps =
    ${common:idf-component-libs.lib_deps}
    ESP32Async/ESPAsyncWebServer@3.9.6    ; web_server_base
    droscy/esp_wireguard@0.4.5            ; wireguard
-    esphome/noise-c@0.1.26                ; noise (api, ota)
+    esphome/noise-c@0.1.24                ; noise (api, ota)
    ESP32Async/AsyncTCP@3.4.5             ; async_tcp
    DNSServer                             ; captive_portal
    heman/AsyncMqttClient-esphome@2.0.0   ; mqtt
@@ -641,7 +641,7 @@ build_unflags =
 extends = common
 platform = platformio/native
 lib_deps =
-    esphome/noise-c@0.1.26  ; used by noise (api, ota)
+    esphome/noise-c@0.1.24  ; used by noise (api, ota)
    lvgl/lvgl@9.5.0         ; lvgl
 build_flags =
    ${common.build_flags}
@@ -9,8 +9,8 @@ colorama==0.4.6
 tzlocal==5.4.4    # from time
 tzdata>=2026.3  # from time
 pyserial==3.5
-platformio==6.2.0
-esptool==5.4.0
+platformio==6.1.19
+esptool==5.3.1
 click==8.3.3
 aioesphomeapi==46.3.0
 aiohappyeyeballs==2.7.1  # Happy Eyeballs for requests downloads; already pulled in by aioesphomeapi
@@ -1,90 +0,0 @@
-"""Validation tests for the sendspin media_source platform.
-
-These cover the codec preference list, whose rejection branches a compile test
-cannot reach: a `test*.yaml` can only assert that a configuration is accepted.
-"""
-
-from typing import Any
-
-import pytest
-
-from esphome import config_validation as cv
-from esphome.components.sendspin import CONF_CODECS, _get_data
-from esphome.components.sendspin.media_source import CONFIG_SCHEMA
-from esphome.const import PlatformFramework
-from esphome.types import ConfigType
-from tests.component_tests.types import SetCoreConfigCallable
-
-
-def _media_source_config(**overrides: Any) -> ConfigType:
-    """Build a minimal valid media source config, allowing field overrides."""
-    config: ConfigType = {
-        "id": "sendspin_media_source",
-        "sendspin_id": "sendspin_hub",
-    }
-    config.update(overrides)
-    return config
-
-
-def test_default_codecs_at_48_khz(set_core_config: SetCoreConfigCallable) -> None:
-    """Every codec is advertised when the sample rate suits all of them."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    config = CONFIG_SCHEMA(_media_source_config())
-
-    assert config[CONF_CODECS] == ["flac", "opus", "pcm"]
-
-
-def test_default_codecs_drop_opus_at_other_rates(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    """Opus only supports 48 kHz, so it leaves the default list at other rates."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    config = CONFIG_SCHEMA(_media_source_config(sample_rate=44100))
-
-    assert config[CONF_CODECS] == ["flac", "pcm"]
-
-
-def test_configured_order_is_preserved(set_core_config: SetCoreConfigCallable) -> None:
-    """The list is a preference order, so it reaches the player role as written."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    CONFIG_SCHEMA(_media_source_config(codecs=["pcm", "flac"]))
-
-    assert _get_data().player_config[CONF_CODECS] == ["pcm", "flac"]
-
-
-def test_empty_codec_list_rejected(set_core_config: SetCoreConfigCallable) -> None:
-    """A player with no codecs at all could never be given a stream."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    with pytest.raises(cv.Invalid, match="length of value must be at least 1"):
-        CONFIG_SCHEMA(_media_source_config(codecs=[]))
-
-
-def test_duplicate_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
-    """A repeated codec has no meaning in a preference order."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    with pytest.raises(cv.Invalid, match="may only be listed once"):
-        CONFIG_SCHEMA(_media_source_config(codecs=["flac", "flac"]))
-
-
-def test_unknown_codec_rejected(set_core_config: SetCoreConfigCallable) -> None:
-    """Only codecs the player role can decode are accepted."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    with pytest.raises(cv.Invalid, match="Unknown value"):
-        CONFIG_SCHEMA(_media_source_config(codecs=["mp3"]))
-
-
-def test_opus_at_wrong_sample_rate_rejected(
-    set_core_config: SetCoreConfigCallable,
-) -> None:
-    """Asking for Opus at a rate it cannot handle fails rather than silently
-    dropping the stated preference."""
-    set_core_config(PlatformFramework.ESP32_IDF)
-
-    with pytest.raises(cv.Invalid, match="requires a sample_rate of 48000"):
-        CONFIG_SCHEMA(_media_source_config(codecs=["opus"], sample_rate=44100))
@@ -17,10 +17,10 @@ uart:
  baud_rate: 115200
  port: /dev/null

-# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed read-only
-# registers, addr 5 = the read/write 0x17 target, addr 2/3 on the second
-# server hub. auto_start everywhere: the controller polls at boot, so the
-# forwarding must already be live or early requests generate warnings.
+# Shared 3-bus mesh (see the shared_yaml markers): addr 1 = typed registers
+# backed by writable globals, addr 5 = the read/write 0x17 target, addr 2/3/6
+# on the second server hub. auto_start everywhere: the controller polls at
+# boot, so the forwarding must already be live or early requests generate warnings.
 # Every test presses Start Scenario, so all merged actions fire in every test.
 uart_mock:
  - id: virtual_uart_server
@@ -64,6 +64,54 @@ globals:
  - id: stored_1
    type: uint16_t
    initial_value: "0"
+  - id: stored_u_word
+    type: uint16_t
+    initial_value: "99"
+  - id: stored_u_word_s
+    type: uint16_t
+    initial_value: "4660"
+  - id: stored_s_word
+    type: int16_t
+    initial_value: "-99"
+  - id: stored_s_word_s
+    type: int16_t
+    initial_value: "-2"
+  - id: stored_u_dword
+    type: uint32_t
+    initial_value: "16909060"
+  - id: stored_s_dword
+    type: int32_t
+    initial_value: "-16909060"
+  - id: stored_u_dword_r
+    type: uint32_t
+    initial_value: "67305985"
+  - id: stored_s_dword_r
+    type: int32_t
+    initial_value: "-67305985"
+  - id: stored_u_qword
+    type: uint64_t
+    initial_value: "72623859790382856"
+  - id: stored_s_qword
+    type: int64_t
+    initial_value: "-72623859790382856"
+  - id: stored_u_qword_r
+    type: uint64_t
+    initial_value: "578437695752307201"
+  - id: stored_s_qword_r
+    type: int64_t
+    initial_value: "-578437695752307201"
+  - id: stored_fp32
+    type: float
+    initial_value: "3.14"
+  - id: stored_fp32_r
+    type: float
+    initial_value: "2.5"
+  - id: stored_bit_2
+    type: bool
+    initial_value: "false"
+  - id: stored_bit_3
+    type: bool
+    initial_value: "true"

 modbus:
  - uart_id: virtual_uart_server
@@ -90,6 +138,10 @@ modbus_controller:
    modbus_id: virtual_modbus_client
    id: modbus_controller_3
    update_interval: 1s
+  - address: 6
+    modbus_id: virtual_modbus_client
+    id: modbus_controller_6
+    update_interval: 1s

 modbus_server:
  - address: 1
@@ -97,46 +149,60 @@ modbus_server:
    registers:
      - address: 0x01
        value_type: U_WORD
-        read_lambda: return 99;
+        read_lambda: return id(stored_u_word);
+        write_lambda: id(stored_u_word) = x; return true;
      - address: 0x02
        value_type: U_WORD_S
-        read_lambda: return 4660;
+        read_lambda: return id(stored_u_word_s);
+        write_lambda: id(stored_u_word_s) = x; return true;
      - address: 0x03
        value_type: S_WORD
-        read_lambda: return -99;
+        read_lambda: return id(stored_s_word);
+        write_lambda: id(stored_s_word) = x; return true;
      - address: 0x04
        value_type: S_WORD_S
-        read_lambda: return -2;
+        read_lambda: return id(stored_s_word_s);
+        write_lambda: id(stored_s_word_s) = x; return true;
      - address: 0x05
        value_type: U_DWORD
-        read_lambda: return 16909060;
+        read_lambda: return id(stored_u_dword);
+        write_lambda: id(stored_u_dword) = x; return true;
      - address: 0x08
        value_type: S_DWORD
-        read_lambda: return -16909060;
+        read_lambda: return id(stored_s_dword);
+        write_lambda: id(stored_s_dword) = x; return true;
      - address: 0x0B
        value_type: U_DWORD_R
-        read_lambda: return 67305985;
+        read_lambda: return id(stored_u_dword_r);
+        write_lambda: id(stored_u_dword_r) = x; return true;
      - address: 0x0E
        value_type: S_DWORD_R
-        read_lambda: return -67305985;
+        read_lambda: return id(stored_s_dword_r);
+        write_lambda: id(stored_s_dword_r) = x; return true;
      - address: 0x11
        value_type: U_QWORD
-        read_lambda: return 72623859790382856;
+        read_lambda: return id(stored_u_qword);
+        write_lambda: id(stored_u_qword) = x; return true;
      - address: 0x16
        value_type: S_QWORD
-        read_lambda: return -72623859790382856;
+        read_lambda: return id(stored_s_qword);
+        write_lambda: id(stored_s_qword) = x; return true;
      - address: 0x1B
        value_type: U_QWORD_R
-        read_lambda: return 578437695752307201;
+        read_lambda: return id(stored_u_qword_r);
+        write_lambda: id(stored_u_qword_r) = x; return true;
      - address: 0x20
        value_type: S_QWORD_R
-        read_lambda: return -578437695752307201;
+        read_lambda: return id(stored_s_qword_r);
+        write_lambda: id(stored_s_qword_r) = x; return true;
      - address: 0x25
        value_type: FP32
-        read_lambda: return 3.14;
+        read_lambda: return id(stored_fp32);
+        write_lambda: id(stored_fp32) = x; return true;
      - address: 0x28
        value_type: FP32_R
-        read_lambda: return 3.14;
+        read_lambda: return id(stored_fp32_r);
+        write_lambda: id(stored_fp32_r) = x; return true;
  - address: 5
    modbus_id: virtual_modbus_server
    registers:
@@ -165,6 +231,19 @@ modbus_server:
      - address: 0x01
        value_type: U_WORD
        read_lambda: return 929;
+  - address: 6
+    modbus_id: virtual_modbus_server_2
+    bits:
+      - address: 0x00
+        read_lambda: return true;
+      - address: 0x01
+        read_lambda: return false;
+      - address: 0x02
+        read_lambda: return id(stored_bit_2);
+        write_lambda: id(stored_bit_2) = x; return true;
+      - address: 0x03
+        read_lambda: return id(stored_bit_3);
+        write_lambda: id(stored_bit_3) = x; return true;

 sensor:
  - platform: modbus_controller
@@ -280,6 +359,183 @@ sensor:
    name: "client_read_1"
    id: client_read_1

+# The number schema caps min/max at 16777215 (float32 integer precision), so
+# the large dword/qword baselines cannot be written back through these numbers.
+number:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_word"
+    address: 0x01
+    register_type: holding
+    value_type: U_WORD
+    min_value: 0
+    max_value: 65535
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_word_s"
+    address: 0x02
+    register_type: holding
+    value_type: U_WORD_S
+    min_value: 0
+    max_value: 65535
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_word"
+    address: 0x03
+    register_type: holding
+    value_type: S_WORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_word_s"
+    address: 0x04
+    register_type: holding
+    value_type: S_WORD_S
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_dword"
+    address: 0x05
+    register_type: holding
+    value_type: U_DWORD
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_dword"
+    address: 0x08
+    register_type: holding
+    value_type: S_DWORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_dword_r"
+    address: 0x0B
+    register_type: holding
+    value_type: U_DWORD_R
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_dword_r"
+    address: 0x0E
+    register_type: holding
+    value_type: S_DWORD_R
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_qword"
+    address: 0x11
+    register_type: holding
+    value_type: U_QWORD
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_qword"
+    address: 0x16
+    register_type: holding
+    value_type: S_QWORD
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_u_qword_r"
+    address: 0x1B
+    register_type: holding
+    value_type: U_QWORD_R
+    min_value: 0
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_s_qword_r"
+    address: 0x20
+    register_type: holding
+    value_type: S_QWORD_R
+    min_value: -16777215
+    max_value: 16777215
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_fp32"
+    address: 0x25
+    register_type: holding
+    value_type: FP32
+    min_value: -16777215
+    max_value: 16777215
+    step: 0.01
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_1
+    name: "write_fp32_r"
+    address: 0x28
+    register_type: holding
+    value_type: FP32_R
+    min_value: -16777215
+    max_value: 16777215
+    step: 0.01
+
+# The four bits are read both as coils (FC 0x01) and discrete inputs (FC 0x02);
+# the server serves both from one shared table, so the two views must agree.
+binary_sensor:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_0"
+    address: 0x00
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_1"
+    address: 0x01
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_2"
+    address: 0x02
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_coil_3"
+    address: 0x03
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_0"
+    address: 0x00
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_1"
+    address: 0x01
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_2"
+    address: 0x02
+    register_type: discrete_input
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "bit_di_3"
+    address: 0x03
+    register_type: discrete_input
+
+# write_bit_2 uses the single-coil write (FC 0x05); write_bit_3 opts into the
+# multiple-coils write (FC 0x0F) so both server write paths are exercised.
+switch:
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "write_bit_2"
+    address: 0x02
+    register_type: coil
+  - platform: modbus_controller
+    modbus_controller_id: modbus_controller_6
+    name: "write_bit_3"
+    address: 0x03
+    register_type: coil
+    use_write_multiple: true
+
 button:
  - platform: template
    name: "Start Scenario"
@@ -1,147 +0,0 @@
-esphome:
-  name: uart-mock-modbus-srv-bits
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_bit_2
-    type: bool
-    initial_value: "false"
-  - id: stored_bit_3
-    type: bool
-    initial_value: "true"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    update_interval: 1s
-    id: modbus_controller_1
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    bits:
-      - address: 0x00
-        read_lambda: return true;
-      - address: 0x01
-        read_lambda: return false;
-      - address: 0x02
-        read_lambda: return id(stored_bit_2);
-        write_lambda: id(stored_bit_2) = x; return true;
-      - address: 0x03
-        read_lambda: return id(stored_bit_3);
-        write_lambda: id(stored_bit_3) = x; return true;
-
-# The same four bits are read both as coils (FC 0x01) and as discrete inputs
-# (FC 0x02): the server serves both from one shared bit table, so the two
-# views must always agree.
-binary_sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_0"
-    address: 0x00
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_1"
-    address: 0x01
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_2"
-    address: 0x02
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_coil_3"
-    address: 0x03
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_0"
-    address: 0x00
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_1"
-    address: 0x01
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_2"
-    address: 0x02
-    register_type: discrete_input
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "bit_di_3"
-    address: 0x03
-    register_type: discrete_input
-
-# write_bit_2 uses the single-coil write (FC 0x05); write_bit_3 opts into the
-# multiple-coils write (FC 0x0F) so both server write paths are exercised.
-switch:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_bit_2"
-    address: 0x02
-    register_type: coil
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_bit_3"
-    address: 0x03
-    register_type: coil
-    use_write_multiple: true
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -1,371 +0,0 @@
-esphome:
-  name: uart-mock-modbus-srv-write
-
-host:
-api:
-logger:
-  level: VERBOSE
-
-external_components:
-  - source:
-      type: local
-      path: EXTERNAL_COMPONENT_PATH
-
-# Dummy uart entry to satisfy modbus's DEPENDENCIES = ["uart"]
-# The actual UART bus used is the uart_mock component below
-uart:
-  baud_rate: 115200
-  port: /dev/null
-
-uart_mock:
-  - id: virtual_uart_server
-    baud_rate: 9600
-    # auto_start must be true for loopback fixtures: the modbus controller
-    # polls on its update_interval immediately at boot, so the uart_mock
-    # forwarding must already be active or early requests are lost and
-    # generate modbus warnings.
-    auto_start: true
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_controller
-              data: !lambda return data;
-  - id: virtual_uart_controller
-    baud_rate: 9600
-    auto_start: true # See comment on virtual_uart_server above
-    debug:
-    on_tx:
-      - then:
-          - uart_mock.inject_rx:
-              id: virtual_uart_server
-              data: !lambda return data;
-
-globals:
-  - id: stored_u_word
-    type: uint16_t
-    initial_value: "11"
-  - id: stored_u_word_s
-    type: uint16_t
-    initial_value: "4660"
-  - id: stored_s_word
-    type: int16_t
-    initial_value: "-11"
-  - id: stored_s_word_s
-    type: int16_t
-    initial_value: "-2"
-  - id: stored_u_dword
-    type: uint32_t
-    initial_value: "1001"
-  - id: stored_s_dword
-    type: int32_t
-    initial_value: "-1001"
-  - id: stored_u_dword_r
-    type: uint32_t
-    initial_value: "3003"
-  - id: stored_s_dword_r
-    type: int32_t
-    initial_value: "-3003"
-  - id: stored_u_qword
-    type: uint64_t
-    initial_value: "5005"
-  - id: stored_s_qword
-    type: int64_t
-    initial_value: "-5005"
-  - id: stored_u_qword_r
-    type: uint64_t
-    initial_value: "7007"
-  - id: stored_s_qword_r
-    type: int64_t
-    initial_value: "-7007"
-  - id: stored_fp32
-    type: float
-    initial_value: "1.5"
-  - id: stored_fp32_r
-    type: float
-    initial_value: "2.5"
-
-modbus:
-  - uart_id: virtual_uart_server
-    id: virtual_modbus_server
-    role: server
-  - uart_id: virtual_uart_controller
-    id: virtual_modbus_controller
-    role: client
-    turnaround_time: 10ms
-
-modbus_controller:
-  - address: 1
-    modbus_id: virtual_modbus_controller
-    update_interval: 2s
-    id: modbus_controller_1
-
-modbus_server:
-  - address: 1
-    modbus_id: virtual_modbus_server
-    id: modbus_server_1
-    registers:
-      - address: 0x01
-        value_type: U_WORD
-        read_lambda: return id(stored_u_word);
-        write_lambda: id(stored_u_word) = x; return true;
-      - address: 0x02
-        value_type: U_WORD_S
-        read_lambda: return id(stored_u_word_s);
-        write_lambda: id(stored_u_word_s) = x; return true;
-      - address: 0x03
-        value_type: S_WORD
-        read_lambda: return id(stored_s_word);
-        write_lambda: id(stored_s_word) = x; return true;
-      - address: 0x04
-        value_type: S_WORD_S
-        read_lambda: return id(stored_s_word_s);
-        write_lambda: id(stored_s_word_s) = x; return true;
-      - address: 0x05
-        value_type: U_DWORD
-        read_lambda: return id(stored_u_dword);
-        write_lambda: id(stored_u_dword) = x; return true;
-      - address: 0x08
-        value_type: S_DWORD
-        read_lambda: return id(stored_s_dword);
-        write_lambda: id(stored_s_dword) = x; return true;
-      - address: 0x0B
-        value_type: U_DWORD_R
-        read_lambda: return id(stored_u_dword_r);
-        write_lambda: id(stored_u_dword_r) = x; return true;
-      - address: 0x0E
-        value_type: S_DWORD_R
-        read_lambda: return id(stored_s_dword_r);
-        write_lambda: id(stored_s_dword_r) = x; return true;
-      - address: 0x11
-        value_type: U_QWORD
-        read_lambda: return id(stored_u_qword);
-        write_lambda: id(stored_u_qword) = x; return true;
-      - address: 0x16
-        value_type: S_QWORD
-        read_lambda: return id(stored_s_qword);
-        write_lambda: id(stored_s_qword) = x; return true;
-      - address: 0x1B
-        value_type: U_QWORD_R
-        read_lambda: return id(stored_u_qword_r);
-        write_lambda: id(stored_u_qword_r) = x; return true;
-      - address: 0x20
-        value_type: S_QWORD_R
-        read_lambda: return id(stored_s_qword_r);
-        write_lambda: id(stored_s_qword_r) = x; return true;
-      - address: 0x25
-        value_type: FP32
-        read_lambda: return id(stored_fp32);
-        write_lambda: id(stored_fp32) = x; return true;
-      - address: 0x28
-        value_type: FP32_R
-        read_lambda: return id(stored_fp32_r);
-        write_lambda: id(stored_fp32_r) = x; return true;
-
-sensor:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_word_s"
-    address: 0x02
-    register_type: holding
-    value_type: U_WORD_S
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_word"
-    address: 0x03
-    register_type: holding
-    value_type: S_WORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_word_s"
-    address: 0x04
-    register_type: holding
-    value_type: S_WORD_S
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_dword"
-    address: 0x05
-    register_type: holding
-    value_type: U_DWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_dword"
-    address: 0x08
-    register_type: holding
-    value_type: S_DWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_dword_r"
-    address: 0x0B
-    register_type: holding
-    value_type: U_DWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_dword_r"
-    address: 0x0E
-    register_type: holding
-    value_type: S_DWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_qword"
-    address: 0x11
-    register_type: holding
-    value_type: U_QWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_qword"
-    address: 0x16
-    register_type: holding
-    value_type: S_QWORD
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_u_qword_r"
-    address: 0x1B
-    register_type: holding
-    value_type: U_QWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_s_qword_r"
-    address: 0x20
-    register_type: holding
-    value_type: S_QWORD_R
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_fp32"
-    address: 0x25
-    register_type: holding
-    value_type: FP32
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "reg_fp32_r"
-    address: 0x28
-    register_type: holding
-    value_type: FP32_R
-
-number:
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_word"
-    address: 0x01
-    register_type: holding
-    value_type: U_WORD
-    min_value: 0
-    max_value: 65535
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_word_s"
-    address: 0x02
-    register_type: holding
-    value_type: U_WORD_S
-    min_value: 0
-    max_value: 65535
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_word"
-    address: 0x03
-    register_type: holding
-    value_type: S_WORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_word_s"
-    address: 0x04
-    register_type: holding
-    value_type: S_WORD_S
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_dword"
-    address: 0x05
-    register_type: holding
-    value_type: U_DWORD
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_dword"
-    address: 0x08
-    register_type: holding
-    value_type: S_DWORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_dword_r"
-    address: 0x0B
-    register_type: holding
-    value_type: U_DWORD_R
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_dword_r"
-    address: 0x0E
-    register_type: holding
-    value_type: S_DWORD_R
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_qword"
-    address: 0x11
-    register_type: holding
-    value_type: U_QWORD
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_qword"
-    address: 0x16
-    register_type: holding
-    value_type: S_QWORD
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_u_qword_r"
-    address: 0x1B
-    register_type: holding
-    value_type: U_QWORD_R
-    min_value: 0
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_s_qword_r"
-    address: 0x20
-    register_type: holding
-    value_type: S_QWORD_R
-    min_value: -16777215
-    max_value: 16777215
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_fp32"
-    address: 0x25
-    register_type: holding
-    value_type: FP32
-    min_value: -16777215
-    max_value: 16777215
-    step: 0.01
-  - platform: modbus_controller
-    modbus_controller_id: modbus_controller_1
-    name: "write_fp32_r"
-    address: 0x28
-    register_type: holding
-    value_type: FP32_R
-    min_value: -16777215
-    max_value: 16777215
-    step: 0.01
-
-button:
-  - platform: template
-    name: "Start Scenario"
-    id: start_scenario_btn
-    # This test does not have anything to start (mock is autostart)
@@ -1,154 +1,143 @@
 {
-  "tests/integration/test_action_concurrent_reentry.py": 30.48,
-  "tests/integration/test_addressable_light_transition.py": 42.1,
-  "tests/integration/test_alarm_control_panel_state_transitions.py": 35.76,
-  "tests/integration/test_api_action_metadata.py": 22.35,
-  "tests/integration/test_api_action_responses.py": 30.31,
-  "tests/integration/test_api_action_timeout.py": 34.73,
-  "tests/integration/test_api_conditional_memory.py": 18.35,
-  "tests/integration/test_api_custom_services.py": 15.99,
-  "tests/integration/test_api_get_time_response_timezone.py": 24.21,
-  "tests/integration/test_api_homeassistant.py": 33.77,
-  "tests/integration/test_api_homeassistant_action_no_subscriber.py": 20.8,
-  "tests/integration/test_api_homeassistant_binary_sensor_initial_state.py": 23.55,
-  "tests/integration/test_api_list_entities_backpressure.py": 23.04,
-  "tests/integration/test_api_message_size_batching.py": 27.31,
-  "tests/integration/test_api_reboot_timeout.py": 29.32,
-  "tests/integration/test_api_string_lambda.py": 14.9,
-  "tests/integration/test_api_vv_logging.py": 26.25,
-  "tests/integration/test_api_zero_psk_provisioning.py": 38.19,
-  "tests/integration/test_areas_and_devices.py": 27.52,
-  "tests/integration/test_automation_wait_actions.py": 24.25,
-  "tests/integration/test_automations.py": 36.02,
-  "tests/integration/test_batch_delay_zero_rapid_transitions.py": 18.46,
-  "tests/integration/test_binary_sensor_autorepeat_filter.py": 17.47,
-  "tests/integration/test_binary_sensor_invalidate_state.py": 14.79,
-  "tests/integration/test_blocking_warning_log_time_not_charged_to_next_operation.py": 21.52,
-  "tests/integration/test_build_info.py": 21.42,
-  "tests/integration/test_camera_mock.py": 17.02,
-  "tests/integration/test_climate_control_action.py": 26.56,
-  "tests/integration/test_climate_custom_modes.py": 18.82,
-  "tests/integration/test_continuation_actions.py": 20.39,
-  "tests/integration/test_cover_control_action.py": 19.91,
-  "tests/integration/test_crc8_helper.py": 16.73,
-  "tests/integration/test_device_id_in_state.py": 58.41,
-  "tests/integration/test_duplicate_entities.py": 30.76,
-  "tests/integration/test_entity_icon.py": 25.34,
-  "tests/integration/test_fan_turn_on_action.py": 23.64,
-  "tests/integration/test_fnv1_hash_object_id.py": 25.44,
-  "tests/integration/test_fnv1a_hash.py": 20.85,
-  "tests/integration/test_gpio_expander_cache.py": 14.42,
-  "tests/integration/test_host_logger_thread_safety.py": 21.31,
-  "tests/integration/test_host_mode_basic.py": 2.65,
-  "tests/integration/test_host_mode_batch_delay.py": 22.21,
-  "tests/integration/test_host_mode_climate_basic_state.py": 27.12,
-  "tests/integration/test_host_mode_climate_control.py": 21.57,
-  "tests/integration/test_host_mode_empty_string_options.py": 27.17,
-  "tests/integration/test_host_mode_entity_fields.py": 30.1,
-  "tests/integration/test_host_mode_fan_preset.py": 17.55,
-  "tests/integration/test_host_mode_many_entities.py": 38.98,
-  "tests/integration/test_host_mode_many_entities_multiple_connections.py": 23.82,
-  "tests/integration/test_host_mode_noise_encryption.py": 39.84,
-  "tests/integration/test_host_mode_reconnect.py": 13.1,
-  "tests/integration/test_host_mode_sensor.py": 22.17,
-  "tests/integration/test_host_ota.py": 92.05,
-  "tests/integration/test_host_preferences.py": 20.29,
-  "tests/integration/test_host_preferences_suspend_resume.py": 15.02,
-  "tests/integration/test_improv_serial_uart.py": 30.15,
-  "tests/integration/test_large_message_batching.py": 25.84,
-  "tests/integration/test_legacy_area.py": 21.24,
-  "tests/integration/test_legacy_climate_compat.py": 17.34,
-  "tests/integration/test_legacy_fan_compat.py": 22.6,
-  "tests/integration/test_light_automations.py": 29.13,
-  "tests/integration/test_light_binary_effect_off_phase.py": 33.99,
-  "tests/integration/test_light_calls.py": 26.81,
-  "tests/integration/test_light_constant_brightness.py": 25.0,
-  "tests/integration/test_light_control_action.py": 25.57,
-  "tests/integration/test_light_dim_relative_action.py": 21.4,
-  "tests/integration/test_light_effect_zero_brightness.py": 19.65,
-  "tests/integration/test_light_initial_state.py": 17.58,
-  "tests/integration/test_light_toggle_action.py": 28.28,
-  "tests/integration/test_lock_automations.py": 23.3,
-  "tests/integration/test_logger_buffered_recursion_guard.py": 22.96,
-  "tests/integration/test_loop_disable_enable.py": 16.18,
-  "tests/integration/test_loop_interval_decoupling.py": 25.19,
-  "tests/integration/test_loop_interval_default_not_pulled_forward.py": 20.59,
-  "tests/integration/test_lvgl_headless_render.py": 87.78,
-  "tests/integration/test_micros_to_millis.py": 18.73,
-  "tests/integration/test_multi_click_trigger.py": 24.2,
-  "tests/integration/test_multi_device_preferences.py": 20.52,
-  "tests/integration/test_noise_encryption_key_protection.py": 19.1,
-  "tests/integration/test_object_id_api_verification.py": 26.24,
-  "tests/integration/test_object_id_friendly_name_no_mac_suffix.py": 14.88,
-  "tests/integration/test_object_id_no_friendly_name.py": 61.27,
-  "tests/integration/test_online_image_auto_detects_image_bmp_mime.py": 82.32,
-  "tests/integration/test_online_image_auto_detects_redirected_image_bmp_mime.py": 46.03,
-  "tests/integration/test_online_image_bmp.py": 34.21,
-  "tests/integration/test_oversized_payloads.py": 62.75,
-  "tests/integration/test_preference_key_stability.py": 26.8,
-  "tests/integration/test_runtime_stats.py": 28.26,
-  "tests/integration/test_safe_mode_loop_runs.py": 18.14,
-  "tests/integration/test_scheduler_blocking_warning.py": 28.7,
-  "tests/integration/test_scheduler_bulk_cleanup.py": 20.73,
-  "tests/integration/test_scheduler_defer_cancel.py": 22.99,
-  "tests/integration/test_scheduler_defer_cancel_regular.py": 21.97,
-  "tests/integration/test_scheduler_defer_fifo_simple.py": 24.15,
-  "tests/integration/test_scheduler_defer_stress.py": 23.11,
-  "tests/integration/test_scheduler_heap_stress.py": 20.2,
-  "tests/integration/test_scheduler_internal_id_no_collision.py": 23.75,
-  "tests/integration/test_scheduler_interval_reschedule.py": 15.32,
-  "tests/integration/test_scheduler_interval_zero_coerced.py": 20.1,
-  "tests/integration/test_scheduler_null_name.py": 17.43,
-  "tests/integration/test_scheduler_numeric_id_test.py": 25.51,
-  "tests/integration/test_scheduler_pool.py": 24.22,
-  "tests/integration/test_scheduler_rapid_cancellation.py": 24.01,
-  "tests/integration/test_scheduler_recursive_timeout.py": 22.94,
-  "tests/integration/test_scheduler_removed_item_race.py": 23.07,
-  "tests/integration/test_scheduler_self_keyed.py": 18.43,
-  "tests/integration/test_scheduler_simultaneous_callbacks.py": 21.99,
-  "tests/integration/test_scheduler_string_test.py": 17.27,
-  "tests/integration/test_script_array_params.py": 4.59,
-  "tests/integration/test_script_delay_params.py": 22.46,
-  "tests/integration/test_script_queued.py": 25.24,
-  "tests/integration/test_script_queued_idle_loop.py": 5.04,
-  "tests/integration/test_script_wait_on_boot.py": 21.77,
-  "tests/integration/test_sdl_headless_screenshot.py": 19.23,
-  "tests/integration/test_select_stringref_trigger.py": 19.31,
-  "tests/integration/test_sensor_filters_delta.py": 25.92,
-  "tests/integration/test_sensor_filters_ring_buffer.py": 22.39,
-  "tests/integration/test_sensor_filters_sliding_window.py": 57.93,
-  "tests/integration/test_sensor_filters_value_list.py": 20.32,
-  "tests/integration/test_sensor_timeout_filter.py": 25.35,
-  "tests/integration/test_snapshot_display.py": 19.7,
-  "tests/integration/test_socket_wake_gate_tcp.py": 14.5,
-  "tests/integration/test_status_flags.py": 33.83,
-  "tests/integration/test_strftime_to.py": 17.64,
-  "tests/integration/test_syslog.py": 24.49,
-  "tests/integration/test_template_alarm_control_panel_many_sensors.py": 24.81,
-  "tests/integration/test_template_climate_basic.py": 15.28,
-  "tests/integration/test_template_climate_custom_modes.py": 25.07,
-  "tests/integration/test_template_climate_nonoptimistic.py": 24.25,
-  "tests/integration/test_template_climate_on_control_ordering.py": 24.09,
-  "tests/integration/test_template_climate_publish_all_fields.py": 17.78,
-  "tests/integration/test_template_climate_sensor_push.py": 17.42,
-  "tests/integration/test_template_climate_set_actions.py": 23.63,
-  "tests/integration/test_template_climate_two_point_temperature.py": 25.19,
-  "tests/integration/test_template_text_save.py": 17.88,
-  "tests/integration/test_text_command.py": 22.71,
-  "tests/integration/test_text_sensor_raw_state.py": 25.17,
-  "tests/integration/test_uart_mock_ld2410.py": 58.15,
-  "tests/integration/test_uart_mock_ld2412.py": 61.14,
-  "tests/integration/test_uart_mock_ld2420.py": 33.87,
-  "tests/integration/test_uart_mock_ld2450.py": 26.06,
-  "tests/integration/test_uart_mock_modbus.py": 391.79,
-  "tests/integration/test_udp.py": 7.38,
-  "tests/integration/test_use_address_runtime.py": 24.09,
-  "tests/integration/test_valve_control_action.py": 23.22,
-  "tests/integration/test_varint_five_byte_device_id.py": 17.93,
-  "tests/integration/test_wait_until_mid_loop_timing.py": 22.26,
-  "tests/integration/test_wait_until_on_boot.py": 17.46,
-  "tests/integration/test_wait_until_ordering.py": 11.89,
-  "tests/integration/test_wait_until_reentrant_restart.py": 22.88,
-  "tests/integration/test_wake_loop_forces_phase_b.py": 16.6,
-  "tests/integration/test_water_heater_template.py": 19.66
+  "tests/integration/test_action_concurrent_reentry.py": 57.91,
+  "tests/integration/test_addressable_light_transition.py": 21.25,
+  "tests/integration/test_alarm_control_panel_state_transitions.py": 70.71,
+  "tests/integration/test_api_action_metadata.py": 66.6,
+  "tests/integration/test_api_action_responses.py": 36.1,
+  "tests/integration/test_api_action_timeout.py": 68.86,
+  "tests/integration/test_api_conditional_memory.py": 15.48,
+  "tests/integration/test_api_custom_services.py": 18.77,
+  "tests/integration/test_api_get_time_response_timezone.py": 21.08,
+  "tests/integration/test_api_homeassistant.py": 65.59,
+  "tests/integration/test_api_homeassistant_action_no_subscriber.py": 18.44,
+  "tests/integration/test_api_homeassistant_binary_sensor_initial_state.py": 15.05,
+  "tests/integration/test_api_list_entities_backpressure.py": 13.88,
+  "tests/integration/test_api_message_size_batching.py": 29.98,
+  "tests/integration/test_api_reboot_timeout.py": 16.05,
+  "tests/integration/test_api_string_lambda.py": 15.31,
+  "tests/integration/test_api_vv_logging.py": 19.28,
+  "tests/integration/test_api_zero_psk_provisioning.py": 31.5,
+  "tests/integration/test_areas_and_devices.py": 24.95,
+  "tests/integration/test_automation_wait_actions.py": 20.92,
+  "tests/integration/test_automations.py": 35.19,
+  "tests/integration/test_batch_delay_zero_rapid_transitions.py": 17.99,
+  "tests/integration/test_binary_sensor_autorepeat_filter.py": 20.39,
+  "tests/integration/test_binary_sensor_invalidate_state.py": 18.41,
+  "tests/integration/test_blocking_warning_log_time_not_charged_to_next_operation.py": 24.69,
+  "tests/integration/test_build_info.py": 18.7,
+  "tests/integration/test_camera_mock.py": 16.23,
+  "tests/integration/test_climate_control_action.py": 21.14,
+  "tests/integration/test_climate_custom_modes.py": 20.74,
+  "tests/integration/test_continuation_actions.py": 16.81,
+  "tests/integration/test_cover_control_action.py": 20.34,
+  "tests/integration/test_crc8_helper.py": 9.36,
+  "tests/integration/test_device_id_in_state.py": 44.67,
+  "tests/integration/test_duplicate_entities.py": 23.58,
+  "tests/integration/test_entity_icon.py": 34.35,
+  "tests/integration/test_fan_turn_on_action.py": 24.23,
+  "tests/integration/test_fnv1_hash_object_id.py": 16.21,
+  "tests/integration/test_fnv1a_hash.py": 13.38,
+  "tests/integration/test_gpio_expander_cache.py": 13.06,
+  "tests/integration/test_host_logger_thread_safety.py": 23.66,
+  "tests/integration/test_host_mode_basic.py": 8.01,
+  "tests/integration/test_host_mode_batch_delay.py": 21.0,
+  "tests/integration/test_host_mode_climate_basic_state.py": 22.14,
+  "tests/integration/test_host_mode_climate_control.py": 19.39,
+  "tests/integration/test_host_mode_empty_string_options.py": 21.76,
+  "tests/integration/test_host_mode_entity_fields.py": 29.61,
+  "tests/integration/test_host_mode_fan_preset.py": 20.01,
+  "tests/integration/test_host_mode_many_entities.py": 39.08,
+  "tests/integration/test_host_mode_many_entities_multiple_connections.py": 23.92,
+  "tests/integration/test_host_mode_noise_encryption.py": 42.42,
+  "tests/integration/test_host_mode_reconnect.py": 3.41,
+  "tests/integration/test_host_mode_sensor.py": 22.96,
+  "tests/integration/test_host_ota.py": 29.5,
+  "tests/integration/test_host_preferences.py": 16.06,
+  "tests/integration/test_host_preferences_suspend_resume.py": 18.71,
+  "tests/integration/test_improv_serial_uart.py": 20.22,
+  "tests/integration/test_large_message_batching.py": 26.56,
+  "tests/integration/test_legacy_area.py": 22.72,
+  "tests/integration/test_legacy_climate_compat.py": 14.13,
+  "tests/integration/test_legacy_fan_compat.py": 14.33,
+  "tests/integration/test_light_automations.py": 18.81,
+  "tests/integration/test_light_binary_effect_off_phase.py": 8.38,
+  "tests/integration/test_light_calls.py": 21.88,
+  "tests/integration/test_light_constant_brightness.py": 59.45,
+  "tests/integration/test_light_control_action.py": 31.91,
+  "tests/integration/test_light_dim_relative_action.py": 14.43,
+  "tests/integration/test_light_effect_zero_brightness.py": 25.05,
+  "tests/integration/test_light_initial_state.py": 18.97,
+  "tests/integration/test_light_toggle_action.py": 17.44,
+  "tests/integration/test_lock_automations.py": 18.9,
+  "tests/integration/test_logger_buffered_recursion_guard.py": 18.2,
+  "tests/integration/test_loop_disable_enable.py": 63.35,
+  "tests/integration/test_loop_interval_decoupling.py": 17.7,
+  "tests/integration/test_loop_interval_default_not_pulled_forward.py": 21.56,
+  "tests/integration/test_micros_to_millis.py": 15.89,
+  "tests/integration/test_multi_click_trigger.py": 17.23,
+  "tests/integration/test_multi_device_preferences.py": 19.4,
+  "tests/integration/test_noise_encryption_key_protection.py": 72.59,
+  "tests/integration/test_object_id_api_verification.py": 19.22,
+  "tests/integration/test_object_id_friendly_name_no_mac_suffix.py": 16.77,
+  "tests/integration/test_object_id_no_friendly_name.py": 45.8,
+  "tests/integration/test_online_image_auto_detects_image_bmp_mime.py": 86.73,
+  "tests/integration/test_online_image_auto_detects_redirected_image_bmp_mime.py": 40.4,
+  "tests/integration/test_online_image_bmp.py": 37.24,
+  "tests/integration/test_oversized_payloads.py": 55.75,
+  "tests/integration/test_preference_key_stability.py": 25.49,
+  "tests/integration/test_runtime_stats.py": 29.81,
+  "tests/integration/test_safe_mode_loop_runs.py": 6.26,
+  "tests/integration/test_scheduler_blocking_warning.py": 37.98,
+  "tests/integration/test_scheduler_bulk_cleanup.py": 18.67,
+  "tests/integration/test_scheduler_defer_cancel.py": 18.46,
+  "tests/integration/test_scheduler_defer_cancel_regular.py": 16.34,
+  "tests/integration/test_scheduler_defer_fifo_simple.py": 18.26,
+  "tests/integration/test_scheduler_defer_stress.py": 17.74,
+  "tests/integration/test_scheduler_heap_stress.py": 3.89,
+  "tests/integration/test_scheduler_internal_id_no_collision.py": 20.01,
+  "tests/integration/test_scheduler_interval_reschedule.py": 16.29,
+  "tests/integration/test_scheduler_interval_zero_coerced.py": 16.09,
+  "tests/integration/test_scheduler_null_name.py": 14.69,
+  "tests/integration/test_scheduler_numeric_id_test.py": 17.08,
+  "tests/integration/test_scheduler_pool.py": 19.88,
+  "tests/integration/test_scheduler_rapid_cancellation.py": 4.42,
+  "tests/integration/test_scheduler_recursive_timeout.py": 4.3,
+  "tests/integration/test_scheduler_removed_item_race.py": 15.49,
+  "tests/integration/test_scheduler_self_keyed.py": 25.77,
+  "tests/integration/test_scheduler_simultaneous_callbacks.py": 14.84,
+  "tests/integration/test_scheduler_string_test.py": 15.42,
+  "tests/integration/test_script_array_params.py": 12.73,
+  "tests/integration/test_script_delay_params.py": 12.69,
+  "tests/integration/test_script_queued.py": 20.38,
+  "tests/integration/test_script_queued_idle_loop.py": 25.06,
+  "tests/integration/test_script_wait_on_boot.py": 15.67,
+  "tests/integration/test_select_stringref_trigger.py": 19.48,
+  "tests/integration/test_sensor_filters_delta.py": 27.62,
+  "tests/integration/test_sensor_filters_ring_buffer.py": 20.27,
+  "tests/integration/test_sensor_filters_sliding_window.py": 56.28,
+  "tests/integration/test_sensor_filters_value_list.py": 20.6,
+  "tests/integration/test_sensor_timeout_filter.py": 22.21,
+  "tests/integration/test_socket_wake_gate_tcp.py": 16.37,
+  "tests/integration/test_status_flags.py": 29.68,
+  "tests/integration/test_strftime_to.py": 17.42,
+  "tests/integration/test_syslog.py": 18.39,
+  "tests/integration/test_template_alarm_control_panel_many_sensors.py": 25.61,
+  "tests/integration/test_template_text_save.py": 19.16,
+  "tests/integration/test_text_command.py": 16.43,
+  "tests/integration/test_text_sensor_raw_state.py": 17.19,
+  "tests/integration/test_uart_mock_ld2410.py": 37.0,
+  "tests/integration/test_uart_mock_ld2412.py": 40.82,
+  "tests/integration/test_uart_mock_ld2420.py": 32.7,
+  "tests/integration/test_uart_mock_ld2450.py": 32.84,
+  "tests/integration/test_uart_mock_modbus.py": 548.87,
+  "tests/integration/test_udp.py": 16.67,
+  "tests/integration/test_use_address_runtime.py": 27.26,
+  "tests/integration/test_valve_control_action.py": 24.58,
+  "tests/integration/test_varint_five_byte_device_id.py": 22.5,
+  "tests/integration/test_wait_until_mid_loop_timing.py": 22.05,
+  "tests/integration/test_wait_until_on_boot.py": 10.37,
+  "tests/integration/test_wait_until_ordering.py": 18.23,
+  "tests/integration/test_wait_until_reentrant_restart.py": 19.35,
+  "tests/integration/test_wake_loop_forces_phase_b.py": 17.83,
+  "tests/integration/test_water_heater_template.py": 25.7
 }
@@ -19,23 +19,40 @@ from __future__ import annotations

 import asyncio
 from collections.abc import Callable
-from dataclasses import dataclass

 from aioesphomeapi import ButtonInfo, NumberInfo, SwitchInfo, TextSensorState
 import pytest

-from .state_utils import SensorTracker, find_entity, wait_for_state
+from .state_utils import SensorTracker, find_entity, require_entity, wait_for_state
 from .types import APIClientConnectedFactory, RunCompiledFunction


-@dataclass
-class RegisterTestCase:
-    """Test parameters for a single modbus register write/read round-trip."""
+def _swap16(value: int) -> int:
+    """Byte-swapped view of a 16-bit register as the raw U_WORD wire value."""
+    return ((value & 0xFF) << 8) | (value >> 8)

-    initial_value: object
-    write_number_name: str
-    write_value: float
-    post_write_value: object
+
+# Raw U_WORD view of reg_u_word_s's initial 0x1234
+MESH_RAW_U_WORD_S = _swap16(4660)
+
+# Initial values of the mesh fixture's address 1 registers; the
+# server_controller test reads them and the write test uses them as baseline.
+MESH_INITIAL_VALUES: dict[str, object] = {
+    "reg_u_word": 99,
+    "reg_u_word_s": 4660,
+    "reg_s_word": -99,
+    "reg_s_word_s": -2,
+    "reg_u_dword": 16909060,
+    "reg_s_dword": -16909060,
+    "reg_u_dword_r": pytest.approx(67305985),
+    "reg_s_dword_r": pytest.approx(-67305985),
+    "reg_u_qword": pytest.approx(72623859790382856),
+    "reg_s_qword": pytest.approx(-72623859790382856),
+    "reg_u_qword_r": pytest.approx(578437695752307201),
+    "reg_s_qword_r": pytest.approx(-578437695752307201),
+    "reg_fp32": pytest.approx(3.14),
+    "reg_fp32_r": pytest.approx(2.5),
+}


 # ---------------------------------------------------------------------------
@@ -310,23 +327,7 @@ async def test_uart_mock_modbus_server_controller(

    line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()

-    expected_values = {
-        "reg_u_word": 99,
-        "reg_u_word_s": 4660,
-        "reg_u_word_s_raw": 13330,
-        "reg_s_word": -99,
-        "reg_s_word_s": -2,
-        "reg_u_dword": 16909060,
-        "reg_s_dword": -16909060,
-        "reg_u_dword_r": pytest.approx(67305985),
-        "reg_s_dword_r": pytest.approx(-67305985),
-        "reg_u_qword": pytest.approx(72623859790382856),
-        "reg_s_qword": pytest.approx(-72623859790382856),
-        "reg_u_qword_r": pytest.approx(578437695752307201),
-        "reg_s_qword_r": pytest.approx(-578437695752307201),
-        "reg_fp32": pytest.approx(3.14),
-        "reg_fp32_r": pytest.approx(3.14),
-    }
+    expected_values = MESH_INITIAL_VALUES | {"reg_u_word_s_raw": MESH_RAW_U_WORD_S}
    tracker = SensorTracker(list(expected_values.keys()))
    futures = tracker.expect_all(expected_values)

@@ -334,14 +335,12 @@ async def test_uart_mock_modbus_server_controller(
        run_compiled(yaml_config, line_callback=line_callback),
        api_client_connected() as client,
    ):
-        # The controller polls from boot, so the first values can already be in
-        # the states the device sends on connect; matching them there saves
-        # waiting for the next poll
        await tracker.setup_and_start_scenario(client, match_initial_states=True)
        await tracker.await_all(futures)
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_write(
    yaml_config: str,
@@ -357,51 +356,47 @@ async def test_uart_mock_modbus_server_controller_write(

    line_callback, error_log_lines, warning_log_lines = _make_modbus_line_callback()

-    register_test_cases: dict[str, RegisterTestCase] = {
-        "reg_u_word": RegisterTestCase(11, "write_u_word", 42, 42),
-        "reg_u_word_s": RegisterTestCase(4660, "write_u_word_s", 17185, 17185),
-        "reg_s_word": RegisterTestCase(-11, "write_s_word", -42, -42),
-        "reg_s_word_s": RegisterTestCase(-2, "write_s_word_s", -257, -257),
-        "reg_u_dword": RegisterTestCase(1001, "write_u_dword", 2002, 2002),
-        "reg_s_dword": RegisterTestCase(-1001, "write_s_dword", -2002, -2002),
-        "reg_u_dword_r": RegisterTestCase(3003, "write_u_dword_r", 4004, 4004),
-        "reg_s_dword_r": RegisterTestCase(-3003, "write_s_dword_r", -4004, -4004),
-        "reg_u_qword": RegisterTestCase(5005, "write_u_qword", 6006, 6006),
-        "reg_s_qword": RegisterTestCase(-5005, "write_s_qword", -6006, -6006),
-        "reg_u_qword_r": RegisterTestCase(7007, "write_u_qword_r", 8008, 8008),
-        "reg_s_qword_r": RegisterTestCase(-7007, "write_s_qword_r", -8008, -8008),
-        "reg_fp32": RegisterTestCase(
-            pytest.approx(1.5, abs=0.01),
-            "write_fp32",
-            3.14,
-            pytest.approx(3.14, abs=0.01),
-        ),
-        "reg_fp32_r": RegisterTestCase(
-            pytest.approx(2.5, abs=0.01),
-            "write_fp32_r",
-            6.28,
-            pytest.approx(6.28, abs=0.01),
-        ),
+    # Per read-back sensor: the number entity to write through and the value;
+    # floats read back within tolerance, everything else exactly
+    register_writes: dict[str, tuple[str, int | float]] = {
+        "reg_u_word": ("write_u_word", 42),
+        "reg_u_word_s": ("write_u_word_s", 17185),
+        "reg_s_word": ("write_s_word", -42),
+        "reg_s_word_s": ("write_s_word_s", -257),
+        "reg_u_dword": ("write_u_dword", 2002),
+        "reg_s_dword": ("write_s_dword", -2002),
+        "reg_u_dword_r": ("write_u_dword_r", 4004),
+        "reg_s_dword_r": ("write_s_dword_r", -4004),
+        "reg_u_qword": ("write_u_qword", 6006),
+        "reg_s_qword": ("write_s_qword", -6006),
+        "reg_u_qword_r": ("write_u_qword_r", 8008),
+        "reg_s_qword_r": ("write_s_qword_r", -8008),
+        "reg_fp32": ("write_fp32", 6.28),
+        "reg_fp32_r": ("write_fp32_r", 9.42),
    }

-    tracker = SensorTracker(list(register_test_cases.keys()))
+    tracker = SensorTracker([*register_writes, "reg_u_word_s_raw"])

+    # The raw U_WORD view of 0x02 pins the byte swap on the write path: the
+    # round trip through write_u_word_s applies the swap an even number of
+    # times, so only the raw sensor can catch a symmetrically dropped swap.
    # Phase 1: expect initial baseline values
    initial_futures = tracker.expect_all(
-        {name: case.initial_value for name, case in register_test_cases.items()}
+        MESH_INITIAL_VALUES | {"reg_u_word_s_raw": MESH_RAW_U_WORD_S}
    )
    # Phase 2: expect post-write values (registered now so on_state can match them)
    written_futures = tracker.expect_all(
-        {name: case.post_write_value for name, case in register_test_cases.items()}
+        {
+            name: pytest.approx(value, abs=0.01) if isinstance(value, float) else value
+            for name, (_, value) in register_writes.items()
+        }
+        | {"reg_u_word_s_raw": _swap16(register_writes["reg_u_word_s"][1])}
    )

    async with (
        run_compiled(yaml_config, line_callback=line_callback),
        api_client_connected() as client,
    ):
-        # The controller polls from boot, so the baseline can already be in the
-        # states the device sends on connect; matching it there saves waiting for
-        # the next poll
        entities = await tracker.setup_and_start_scenario(
            client, match_initial_states=True
        )
@@ -410,19 +405,22 @@ async def test_uart_mock_modbus_server_controller_write(
        # connection is working before issuing writes
        await tracker.await_all(initial_futures, timeout=4.0)

-        # Issue write commands for all register types
-        for case in register_test_cases.values():
-            entity = find_entity(entities, case.write_number_name, NumberInfo)
-            assert entity is not None, (
-                f"{case.write_number_name} number entity not found"
-            )
-            client.number_command(entity.key, case.write_value)
+        # Issue write commands for all register types; exact object_id match,
+        # since several write_* names are prefixes of a sibling
+        numbers = {
+            e.object_id.lower(): e for e in entities if isinstance(e, NumberInfo)
+        }
+        for number_name, value in register_writes.values():
+            entity = numbers.get(number_name)
+            assert entity is not None, f"{number_name} number entity not found"
+            client.number_command(entity.key, value)

        # Wait for sensors to reflect the written values (round-trip write+read)
        await tracker.await_all(written_futures, timeout=4.0)
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)


+@pytest.mark.shared_yaml("uart_mock_modbus_mesh")
@pytest.mark.asyncio
 async def test_uart_mock_modbus_server_controller_bits(
    yaml_config: str,
@@ -468,8 +466,6 @@ async def test_uart_mock_modbus_server_controller_bits(
        run_compiled(yaml_config, line_callback=line_callback),
        api_client_connected() as client,
    ):
-        # The controller polls from boot and binary sensors drop repeats, so the
-        # baseline can arrive only in the states the device sends on connect
        entities = await tracker.setup_and_start_scenario(
            client, match_initial_states=True
        )
@@ -480,8 +476,7 @@ async def test_uart_mock_modbus_server_controller_bits(

        # Flip both writable bits: 0x02 false -> true, 0x03 true -> false
        for switch_name, value in (("write_bit_2", True), ("write_bit_3", False)):
-            entity = find_entity(entities, switch_name, SwitchInfo)
-            assert entity is not None, f"{switch_name} switch entity not found"
+            entity = require_entity(entities, switch_name, SwitchInfo)
            client.switch_command(entity.key, value)

        # Wait for both read views to reflect the written values
@@ -508,9 +503,6 @@ async def test_uart_mock_modbus_server_controller_multiple(
        run_compiled(yaml_config, line_callback=line_callback),
        api_client_connected() as client,
    ):
-        # The controller polls from boot, so the first values can already be in
-        # the states the device sends on connect; matching them there saves
-        # waiting for the next poll
        await tracker.setup_and_start_scenario(client, match_initial_states=True)
        await tracker.await_all(futures)
        _assert_no_modbus_errors(error_log_lines, warning_log_lines)
@@ -35,8 +35,8 @@ def _load_script():
 def test_spec_key_collapses_destinations() -> None:
    """Two specs delivering one package share a directory and one key."""
    mod = _load_script()
-    assert mod.spec_key("esphome/noise-c @ 0.1.26") == "noise-c"
-    assert mod.spec_key("esphome/noise-c@0.1.26") == "noise-c"
+    assert mod.spec_key("esphome/noise-c @ 0.1.24") == "noise-c"
+    assert mod.spec_key("esphome/noise-c@0.1.24") == "noise-c"
    assert mod.spec_key("ESP32Async/AsyncTCP @ ^3.4.10") == mod.spec_key(
        "esp32async/asynctcp @ 3.5.0"
    )
@@ -54,23 +54,23 @@ def test_parse_specs_and_cli_args(tmp_path: Path) -> None:
        "[env:a]\n"
        "platform = fake/platform@1\n"
        "lib_deps =\n"
-        "    esphome/noise-c @ 0.1.26\n"
+        "    esphome/noise-c @ 0.1.24\n"
        "    ${common.lib_deps}\n"
        "    internal_lib\n"
        "[env:b]\n"
        "lib_deps =\n"
-        "    esphome/noise-c @ 0.1.26\n"
+        "    esphome/noise-c @ 0.1.24\n"
    )
    mod = _load_script()
    args = Namespace(libraries=True, platforms=True, tools=False)
    libs, platforms, tools = mod.parse_specs(str(ini), args)
    # exact-string duplicates collapse; distinct version pins survive
-    assert libs == ["esphome/noise-c @ 0.1.26"]
+    assert libs == ["esphome/noise-c @ 0.1.24"]
    assert platforms == ["fake/platform@1"]
    assert tools == []
    assert mod.build_cli_args(libs, platforms, tools) == [
        "-l",
-        "esphome/noise-c @ 0.1.26",
+        "esphome/noise-c @ 0.1.24",
        "-p",
        "fake/platform@1",
    ]
@@ -162,13 +162,13 @@ def test_parallel_install_behavior(tmp_path: Path) -> None:
    mod.parallel_install(
        cls,
        [
-            "esphome/noise-c @ 0.1.26",
-            "esphome/noise-c @ 0.1.26",
+            "esphome/noise-c @ 0.1.24",
+            "esphome/noise-c @ 0.1.24",
            "esphome/already @ 1.0",
            "https://x/framework.tar.xz",
        ],
    )
-    assert cls.calls == ["esphome/noise-c @ 0.1.26"]
+    assert cls.calls == ["esphome/noise-c @ 0.1.24"]
    assert cls.lock_events == ["lock", "unlock"]


@@ -205,7 +205,7 @@ def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None:
    mod = _load_script()
    cls = _reset_fake(str(tmp_path))
    cls.deps = {
-        "esphome/noise-c @ 0.1.26": [
+        "esphome/noise-c @ 0.1.24": [
            {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
            {"name": "SPI"},
        ],
@@ -213,12 +213,12 @@ def test_parallel_install_runs_dependency_waves(tmp_path: Path) -> None:
            {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
        ],
    }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26", "esphome/wg @ 1.0"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24", "esphome/wg @ 1.0"])
    assert len(cls.calls) == 3  # the shared dep installs exactly once
    assert {mod.spec_key(c) for c in cls.calls} == {"noise-c", "wg", "libsodium"}
    # Wave-1 strings carry no compatibility; the dependency wave does
    compats = dict(cls.compat_calls)
-    assert compats["esphome/noise-c @ 0.1.26"] is None
+    assert compats["esphome/noise-c @ 0.1.24"] is None
    dep_compat = next(v for k, v in cls.compat_calls if "libsodium" in k)
    assert dep_compat is not None  # mirrors pio's install_dependency

@@ -229,11 +229,11 @@ def test_dependency_wave_excludes_url_specs(tmp_path: Path) -> None:
    mod = _load_script()
    cls = _reset_fake(str(tmp_path))
    cls.deps = {
-        "esphome/noise-c @ 0.1.26": [
+        "esphome/noise-c @ 0.1.24": [
            {"name": "vendored", "version": "https://github.com/x/y.git"},
        ],
    }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24"])
    assert {mod.spec_key(c) for c in cls.calls} == {"noise-c"}


@@ -348,13 +348,13 @@ def test_warm_store_still_walks_dependencies(tmp_path: Path) -> None:
    """Already-installed top-level packages still feed the dependency
    wave; a warm store can be missing a transitive dep."""
    mod = _load_script()
-    cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.26"})
+    cls = _reset_fake(str(tmp_path), installed={"esphome/noise-c @ 0.1.24"})
    cls.deps = {
-        "esphome/noise-c @ 0.1.26": [
+        "esphome/noise-c @ 0.1.24": [
            {"owner": "esphome", "name": "libsodium", "version": "^1.0"},
        ],
    }
-    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.26"])
+    mod.parallel_install(cls, ["esphome/noise-c @ 0.1.24"])
    assert [mod.spec_key(c) for c in cls.calls] == ["libsodium"]


@@ -416,9 +416,6 @@ def test_perform_ota_no_auth(
        "Update took 14.00 seconds (prepare 2.00, upload 5.00, commit 7.00)"
        in caplog.text
    )
-    # The data phase timeout must outlast the device's 105 s data timeout
-    mock_socket.settimeout.assert_any_call(espota2.DATA_PHASE_TIMEOUT)
-    assert espota2.DATA_PHASE_TIMEOUT > 105.0


@pytest.mark.usefixtures("mock_time")
@@ -1663,7 +1663,7 @@ def test_preinstall_runs_dependency_waves(tmp_path: Path) -> None:
        {"name": "SPI"},
    ]
    m.dependency_to_spec.side_effect = lambda dep: _FakeSpec(name=dep["name"])
-    pf._preinstall(m, [("noise-c@0.1.26", _FakeSpec(name="noise-c"))])
+    pf._preinstall(m, [("noise-c@0.1.24", _FakeSpec(name="noise-c"))])
    assert installed == ["noise-c", "libsodium"]  # dep deduped, SPI left out
    # The dep wave carries its compatibility so _install searches qualified
    dep_call = m._install.call_args_list[-1]
@@ -1683,7 +1683,7 @@ def test_preinstall_dependency_wave_skips_seen_names(tmp_path: Path) -> None:
    m._install.side_effect = lambda spec, skip_dependencies, compatibility=None: (
        installed.append(getattr(spec, "name", str(spec)))
    )
-    pf._preinstall(m, [("noise-c@0.1.26", _FakeSpec(name="noise-c"))])
+    pf._preinstall(m, [("noise-c@0.1.24", _FakeSpec(name="noise-c"))])
    assert installed == ["noise-c"]
Author	SHA1	Message	Date
J. Nick Koston	aa4107cee6	Derive both raw swap oracles from one helper	2026-09-08 18:11:11 +02:00
J. Nick Koston	4879d4b4e0	Diagnostic, case normalized number entity lookup	2026-09-08 18:11:10 +02:00
J. Nick Koston	c5e46c78cf	Address review: exact object_id lookup for the write numbers	2026-09-08 18:11:10 +02:00
J. Nick Koston	aabb534389	Address review: shared raw view constant, honest annotation, require_entity in the bits test	2026-09-08 18:11:10 +02:00
J. Nick Koston	90ca46e1d1	Apply simplify pass: derive write expectations from one table, reuse require_entity	2026-09-08 18:11:10 +02:00
J. Nick Koston	1e70d10172	Address review: raw sensor pins the byte swap on the write path	2026-09-08 18:11:10 +02:00
J. Nick Koston	a5edc62f8c	Note the number schema bound cap on the write numbers	2026-09-08 18:11:10 +02:00
J. Nick Koston	30fdbe07df	Address review: distinct fp32_r baseline, note the byte-swapped raw view	2026-09-08 18:11:10 +02:00
J. Nick Koston	b6fcb7fe73	Trim fixture comments	2026-09-08 18:11:10 +02:00
J. Nick Koston	bb982c58cf	Apply simplify pass: single source for the mesh baseline values	2026-09-08 18:11:10 +02:00
J. Nick Koston	b71c030fec	[core] Fold the modbus write and bits tests into the shared mesh fixture	2026-09-08 18:11:10 +02:00