fix

esphome/components/captive_portal/__init__.py

@@ -101,19 +101,23 @@ async def to_code(config):
     if config[CONF_COMPRESSION] == "gzip":
         cg.add_define("USE_CAPTIVE_PORTAL_GZIP")
 
-    if CORE.using_arduino:
-        if CORE.is_esp8266:
-            cg.add_library("DNSServer", None)
-        if CORE.is_libretiny:
-            cg.add_library("DNSServer", None)
+    # All platforms now use our custom DNS server implementations
 
 
-# Only compile the ESP-IDF DNS server when using ESP-IDF framework
+# Compile platform-specific DNS server implementations
+# ESP32 Arduino uses IDF components, so both use dns_server_esp32_idf.cpp
 FILTER_SOURCE_FILES = filter_source_files_from_platform(
     {
         "dns_server_esp32_idf.cpp": {
             PlatformFramework.ESP32_ARDUINO,
             PlatformFramework.ESP32_IDF,
         },
+        "dns_server_arduino.cpp": {
+            PlatformFramework.ESP8266_ARDUINO,
+            PlatformFramework.RP2040_ARDUINO,
+            PlatformFramework.BK72XX_ARDUINO,
+            PlatformFramework.RTL87XX_ARDUINO,
+            PlatformFramework.LN882X_ARDUINO,
+        },
     }
 )

esphome/components/captive_portal/captive_index.h

@@ -7,145 +7,162 @@ namespace esphome::captive_portal {
 
 #ifdef USE_CAPTIVE_PORTAL_GZIP
 const uint8_t INDEX_GZ[] PROGMEM = {
-    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x95, 0x56, 0xeb, 0x6f, 0xd4, 0x38, 0x10, 0xff, 0xce,
-    0x5f, 0xe1, 0x33, 0x8f, 0x26, 0xd0, 0x3c, 0xb7, 0xdb, 0x96, 0x6c, 0x12, 0x04, 0xdc, 0x21, 0x90, 0x28, 0x20, 0xb5,
-    0x70, 0x1f, 0x10, 0x52, 0xbd, 0xc9, 0x64, 0x63, 0x9a, 0x38, 0x39, 0xdb, 0xfb, 0x62, 0xb5, 0xf7, 0xb7, 0xdf, 0x38,
-    0xc9, 0x6e, 0xb7, 0x15, 0x9c, 0xee, 0x5a, 0x35, 0x1d, 0xdb, 0xf3, 0xf8, 0xcd, 0x78, 0x1e, 0x8e, 0x7f, 0xcb, 0x9b,
-    0x4c, 0xaf, 0x5b, 0x20, 0xa5, 0xae, 0xab, 0x34, 0x36, 0x5f, 0x52, 0x31, 0x31, 0x4b, 0x40, 0xe0, 0x0a, 0x58, 0x9e,
-    0xc6, 0x35, 0x68, 0x46, 0xb2, 0x92, 0x49, 0x05, 0x3a, 0xf9, 0x7c, 0xf5, 0xc6, 0x39, 0x4f, 0xe3, 0x8a, 0x8b, 0x1b,
-    0x22, 0xa1, 0x4a, 0x78, 0xd6, 0x08, 0x52, 0x4a, 0x28, 0x92, 0x9c, 0x69, 0x16, 0xf1, 0x9a, 0xcd, 0x60, 0x10, 0x11,
-    0xac, 0x86, 0x64, 0xc1, 0x61, 0xd9, 0x36, 0x52, 0x13, 0xe4, 0xd3, 0x20, 0x74, 0x42, 0x97, 0x3c, 0xd7, 0x65, 0x92,
-    0xc3, 0x82, 0x67, 0xe0, 0x74, 0x8b, 0x63, 0x2e, 0xb8, 0xe6, 0xac, 0x72, 0x54, 0xc6, 0x2a, 0x48, 0x82, 0xe3, 0xb9,
-    0x02, 0xd9, 0x2d, 0xd8, 0x14, 0xd7, 0xa2, 0xa1, 0x69, 0xac, 0x32, 0xc9, 0x5b, 0x4d, 0x0c, 0xd4, 0xa4, 0x6e, 0xf2,
-    0x79, 0x05, 0xa9, 0xe7, 0x31, 0x85, 0x90, 0x94, 0xc7, 0x45, 0x0e, 0x2b, 0x77, 0xea, 0x67, 0x99, 0x0f, 0xe7, 0xe7,
-    0xee, 0x77, 0xf5, 0x00, 0x9d, 0x9a, 0xd7, 0x68, 0xcd, 0xad, 0x9a, 0x8c, 0x69, 0xde, 0x08, 0x57, 0x01, 0x93, 0x59,
-    0x99, 0x24, 0x09, 0x7d, 0xa1, 0xd8, 0x02, 0xe8, 0x93, 0x27, 0xd6, 0x9e, 0x69, 0x06, 0xfa, 0x8f, 0x0a, 0x0c, 0xa9,
-    0x5e, 0xad, 0xaf, 0xd8, 0xec, 0x03, 0x02, 0xb7, 0x28, 0x53, 0x3c, 0x07, 0x6a, 0x7f, 0xf5, 0xbf, 0xb9, 0x4a, 0xaf,
-    0x2b, 0x70, 0x73, 0xae, 0xda, 0x8a, 0xad, 0x13, 0x3a, 0x45, 0xad, 0x37, 0xd4, 0x9e, 0x14, 0x73, 0x91, 0x19, 0xe5,
-    0x44, 0x59, 0x60, 0x6f, 0x2a, 0x40, 0x78, 0xc9, 0x05, 0xd3, 0xa5, 0x5b, 0xb3, 0x95, 0xd5, 0x13, 0x5c, 0x58, 0xe1,
-    0x53, 0x0b, 0x9e, 0x05, 0xbe, 0x6f, 0x1f, 0x77, 0x1f, 0xdf, 0xf6, 0xf0, 0xff, 0x44, 0x82, 0x9e, 0x4b, 0x41, 0x98,
-    0x75, 0x1d, 0xb7, 0xc8, 0x49, 0xf2, 0x84, 0x5e, 0x04, 0x21, 0x09, 0x9e, 0xbb, 0xe1, 0xf8, 0xbd, 0x7b, 0x46, 0x4e,
-    0xf0, 0x7f, 0x76, 0xe6, 0x8c, 0x49, 0x70, 0x82, 0x9f, 0x30, 0x74, 0xc7, 0xc4, 0xff, 0x41, 0x49, 0xc1, 0xab, 0x2a,
-    0xa1, 0xa2, 0x11, 0x40, 0x89, 0xd2, 0xb2, 0xb9, 0x81, 0x84, 0x66, 0x73, 0x29, 0x11, 0xfb, 0xeb, 0xa6, 0x6a, 0x24,
-    0xf5, 0xd2, 0x07, 0xff, 0x4b, 0xa1, 0x96, 0x4c, 0xa8, 0xa2, 0x91, 0x75, 0x42, 0xbb, 0xe8, 0x5b, 0x8f, 0x36, 0x7a,
-    0x4b, 0xcc, 0xc7, 0x3e, 0x38, 0x74, 0x1a, 0xc9, 0x67, 0x5c, 0x24, 0xd4, 0x68, 0x3c, 0x47, 0x23, 0xd7, 0xf6, 0x76,
-    0xef, 0x3d, 0x33, 0xde, 0x0f, 0xfe, 0x34, 0xd6, 0xd7, 0xeb, 0x58, 0x2d, 0x66, 0x64, 0x55, 0x57, 0x42, 0x25, 0xb4,
-    0xd4, 0xba, 0x8d, 0x3c, 0x6f, 0xb9, 0x5c, 0xba, 0xcb, 0x91, 0xdb, 0xc8, 0x99, 0x17, 0xfa, 0xbe, 0xef, 0x21, 0x07,
-    0x25, 0x7d, 0x22, 0xd0, 0xf0, 0x84, 0x92, 0x12, 0xf8, 0xac, 0xd4, 0x1d, 0x9d, 0x3e, 0xda, 0xc0, 0x36, 0x36, 0x1c,
-    0xe9, 0xf5, 0xb7, 0x03, 0x2b, 0xfc, 0xc0, 0x0a, 0xbc, 0x60, 0x16, 0xdd, 0xb9, 0x79, 0xd4, 0xb9, 0x79, 0xc6, 0x42,
-    0x12, 0x12, 0xbf, 0xfb, 0x0d, 0x1d, 0x43, 0x0f, 0x2b, 0xe7, 0xde, 0x8a, 0x1c, 0xac, 0x0c, 0x55, 0x9f, 0x3a, 0xcf,
-    0xf7, 0xb2, 0x81, 0xd9, 0x59, 0x04, 0xfe, 0xed, 0x86, 0x11, 0x78, 0x7b, 0x7a, 0xb8, 0x76, 0xc2, 0x2f, 0x87, 0x0c,
-    0xc6, 0x5a, 0x19, 0x7c, 0x39, 0x65, 0x63, 0x32, 0x1e, 0x76, 0xc6, 0x8e, 0xa1, 0xf7, 0x2b, 0x32, 0x5e, 0x20, 0x47,
-    0xed, 0x9c, 0x3a, 0x63, 0x36, 0x22, 0xa3, 0x01, 0x08, 0x52, 0xb8, 0x7d, 0x8a, 0x82, 0x07, 0x7b, 0xce, 0xe8, 0xc7,
-    0x91, 0x97, 0x52, 0x3b, 0xa2, 0xf4, 0xd6, 0xf3, 0xe6, 0xd0, 0x73, 0xf7, 0x7b, 0x83, 0x39, 0x45, 0x29, 0x46, 0x06,
-    0x74, 0x56, 0x5a, 0xd4, 0xc3, 0xc2, 0x2a, 0xf8, 0x0c, 0xb3, 0xbe, 0x11, 0xd4, 0x76, 0x75, 0x09, 0xc2, 0xda, 0x89,
-    0x1a, 0x41, 0xe8, 0x4e, 0xac, 0xfb, 0x27, 0xda, 0xde, 0xec, 0xf3, 0x5f, 0x73, 0x8d, 0x65, 0xa6, 0x5d, 0x53, 0xb0,
-    0xc7, 0xfb, 0xdd, 0x69, 0x93, 0xaf, 0x7f, 0x51, 0x1a, 0x65, 0xd0, 0xd7, 0x05, 0x17, 0x02, 0xe4, 0x15, 0xac, 0xf0,
-    0xe6, 0x2e, 0x5e, 0xbe, 0x26, 0x2f, 0xf3, 0x5c, 0x82, 0x52, 0x11, 0xa1, 0xcf, 0x34, 0xd6, 0x40, 0xf6, 0xdf, 0x75,
-    0x05, 0x77, 0x74, 0xfd, 0xc9, 0xdf, 0x70, 0xf2, 0x01, 0xf4, 0xb2, 0x91, 0x37, 0x83, 0x36, 0x03, 0x6d, 0x62, 0x2a,
-    0x4c, 0x22, 0x4e, 0xd6, 0x2a, 0x57, 0x55, 0xd8, 0x3e, 0xac, 0xc0, 0x46, 0x3b, 0xed, 0xad, 0x57, 0x62, 0x17, 0xa8,
-    0xeb, 0x38, 0xe7, 0x0b, 0x92, 0x55, 0xd8, 0x21, 0xb0, 0x5c, 0x7a, 0x55, 0x94, 0x3c, 0x20, 0xdd, 0x4f, 0x23, 0x32,
-    0x94, 0xbe, 0x49, 0xe8, 0x4f, 0x3a, 0xc0, 0xab, 0xf5, 0xbb, 0xdc, 0x3a, 0x52, 0x58, 0xfb, 0x47, 0xb6, 0xbb, 0x60,
-    0xd5, 0x1c, 0x48, 0x42, 0x74, 0xc9, 0xd5, 0x2d, 0xc0, 0xc9, 0x2f, 0xc5, 0x5a, 0x75, 0x83, 0x52, 0x05, 0x1e, 0x2b,
-    0xcb, 0xa6, 0xe9, 0x60, 0x2e, 0x66, 0x7d, 0x83, 0xa4, 0x0f, 0xe9, 0x3d, 0x44, 0x4e, 0x05, 0x85, 0xde, 0xf3, 0x11,
-    0x2c, 0x3b, 0x65, 0x09, 0x57, 0xa2, 0x75, 0x7b, 0xbb, 0xdf, 0x8c, 0x55, 0xcb, 0xc4, 0x7d, 0x41, 0x03, 0xd0, 0x94,
-    0x0a, 0x36, 0x36, 0xa4, 0x4c, 0xbd, 0x20, 0xd3, 0xde, 0xa0, 0xc7, 0x76, 0xe4, 0xa3, 0x0d, 0x47, 0x8d, 0xa6, 0x5f,
-    0xed, 0x35, 0xc6, 0x1e, 0x86, 0x26, 0xbd, 0xde, 0xda, 0xb7, 0x7e, 0xfc, 0x35, 0x07, 0xb9, 0xbe, 0x84, 0x0a, 0x32,
-    0xdd, 0x48, 0x8b, 0x3e, 0x44, 0x2b, 0x98, 0x4a, 0x9d, 0xc3, 0x6f, 0xaf, 0x2e, 0xde, 0x27, 0x8d, 0x25, 0xed, 0xe3,
-    0x5f, 0x71, 0x9b, 0x51, 0xf0, 0x15, 0x47, 0xc1, 0xdf, 0xc9, 0x91, 0x19, 0x06, 0x47, 0xdf, 0x50, 0xb4, 0xf3, 0xf7,
-    0xfa, 0x76, 0x22, 0x98, 0x72, 0x7e, 0x86, 0x2d, 0xe1, 0xd8, 0x78, 0xe8, 0x9c, 0x8e, 0xed, 0x2d, 0xda, 0x47, 0x04,
-    0x88, 0xbb, 0xeb, 0xeb, 0xd8, 0xdf, 0x4d, 0x8b, 0x4d, 0x9f, 0x6e, 0xa6, 0xcd, 0xca, 0x51, 0xfc, 0x07, 0x17, 0xb3,
-    0x88, 0x8b, 0x12, 0x24, 0xd7, 0x5b, 0x84, 0x8b, 0x13, 0xa2, 0x9d, 0xeb, 0x4d, 0xcb, 0xf2, 0xdc, 0x9c, 0x8c, 0xdb,
-    0xd5, 0xa4, 0xc0, 0x79, 0x62, 0x38, 0x21, 0x0a, 0xa0, 0xde, 0xf6, 0xe7, 0x5d, 0x47, 0x89, 0x9e, 0x8f, 0x1f, 0x6f,
-    0x4d, 0xc2, 0x6d, 0x34, 0x5e, 0x96, 0xc3, 0x2a, 0x3e, 0x13, 0x51, 0x86, 0xc0, 0x41, 0xf6, 0x42, 0x05, 0xab, 0x79,
-    0xb5, 0x8e, 0x14, 0xf6, 0x36, 0x07, 0x07, 0x0d, 0x2f, 0xb6, 0xd3, 0xb9, 0xd6, 0x8d, 0x40, 0xdb, 0x32, 0x07, 0x19,
-    0xf9, 0x93, 0x9e, 0x70, 0x24, 0xcb, 0xf9, 0x5c, 0x45, 0xee, 0x48, 0x42, 0x3d, 0x99, 0xb2, 0xec, 0x66, 0x26, 0x9b,
-    0xb9, 0xc8, 0x9d, 0xcc, 0x74, 0xda, 0xe8, 0x61, 0x50, 0xb0, 0x11, 0x64, 0x93, 0x61, 0x55, 0x14, 0xc5, 0x04, 0x43,
-    0x01, 0x4e, 0xdf, 0xcb, 0xa2, 0xd0, 0x3d, 0x31, 0x62, 0x07, 0x30, 0xdd, 0xd0, 0x6c, 0xf4, 0x18, 0x71, 0x04, 0x3c,
-    0x9e, 0xec, 0xdc, 0xf1, 0x27, 0xd8, 0xc2, 0x15, 0x2a, 0x69, 0xb1, 0xb6, 0x11, 0xe6, 0xb6, 0x66, 0x5c, 0x1c, 0xa2,
-    0x37, 0x69, 0x32, 0x19, 0xc6, 0x0f, 0x86, 0xa5, 0x33, 0xd3, 0x0d, 0xa1, 0x09, 0x0e, 0x98, 0x7e, 0x86, 0x46, 0xe1,
-    0xa9, 0xdf, 0xae, 0xb6, 0xee, 0x90, 0x20, 0x9b, 0x1d, 0x77, 0x51, 0xc1, 0x6a, 0xf2, 0x7d, 0xae, 0x34, 0x2f, 0xd6,
-    0xce, 0x30, 0x83, 0x23, 0x4c, 0x16, 0x9c, 0xbd, 0x53, 0x64, 0x05, 0x10, 0x93, 0xce, 0x86, 0xc3, 0x35, 0xd4, 0x6a,
-    0x88, 0xd3, 0x5e, 0x4d, 0x97, 0xa0, 0x77, 0x75, 0xfd, 0x1b, 0xb7, 0xc9, 0xc5, 0x4d, 0xcd, 0x24, 0x8e, 0x0a, 0x67,
-    0xda, 0x60, 0x4c, 0xeb, 0xc8, 0x39, 0xc3, 0xbb, 0x1a, 0xb6, 0x8c, 0x32, 0xf4, 0x1c, 0x61, 0x76, 0xb3, 0x75, 0x17,
-    0xef, 0xa0, 0x5d, 0x11, 0xd5, 0x54, 0x3c, 0x1f, 0xf8, 0x3a, 0x16, 0xe2, 0xef, 0xc3, 0x13, 0xe0, 0x75, 0x13, 0xb3,
-    0xb7, 0x0b, 0xf5, 0x49, 0x71, 0xce, 0x02, 0xff, 0x27, 0x37, 0x92, 0x17, 0x45, 0x38, 0x2d, 0xf6, 0x91, 0x32, 0x63,
-    0xd2, 0x94, 0x46, 0x97, 0x5a, 0xb1, 0xd7, 0xbf, 0x66, 0x4c, 0x66, 0xe0, 0x03, 0x05, 0x23, 0x8c, 0xef, 0x9b, 0x80,
-    0xf0, 0x3c, 0xc1, 0x4e, 0x95, 0x1e, 0xb4, 0x2f, 0x64, 0x0c, 0x76, 0x47, 0x48, 0xdd, 0x69, 0x46, 0xfd, 0x59, 0x87,
-    0x3e, 0x7d, 0xdd, 0x60, 0x7d, 0x60, 0xdb, 0x11, 0x33, 0xa2, 0x1b, 0x32, 0x84, 0xc0, 0x75, 0xdd, 0x78, 0x2a, 0xd3,
-    0x4f, 0x15, 0x30, 0x05, 0x64, 0xc9, 0xb8, 0x76, 0xb1, 0x1a, 0x3b, 0xfe, 0xbe, 0x8e, 0x51, 0x29, 0xb2, 0xa6, 0x43,
-    0xc1, 0xc6, 0xe5, 0xa8, 0x37, 0x70, 0x09, 0xda, 0x68, 0x32, 0x06, 0x46, 0x69, 0x6c, 0x46, 0x2e, 0x61, 0x5d, 0x4b,
-    0x4b, 0xbc, 0x25, 0x2f, 0xb8, 0x79, 0xb2, 0xa4, 0x71, 0x97, 0xe4, 0x46, 0x83, 0x89, 0x73, 0xff, 0xbc, 0xea, 0xa8,
-    0x0a, 0xc4, 0x0c, 0x27, 0xe9, 0x28, 0x24, 0xe8, 0x76, 0x06, 0x65, 0x53, 0x61, 0x58, 0x93, 0xcb, 0xcb, 0x77, 0xbf,
-    0xa7, 0x06, 0xcc, 0xad, 0x1c, 0xf6, 0xa7, 0x5e, 0xcc, 0x10, 0x83, 0xd4, 0xe9, 0x49, 0xff, 0xa8, 0x6a, 0xb1, 0xbf,
-    0xa0, 0x07, 0xf9, 0x1d, 0x1d, 0x9f, 0x86, 0xcd, 0x5e, 0x4f, 0xf7, 0xd7, 0x95, 0x4a, 0x7a, 0x89, 0x80, 0x62, 0x6f,
-    0x58, 0xc4, 0x9e, 0x01, 0xdc, 0x9f, 0x97, 0x03, 0x1f, 0xc6, 0xe9, 0xe3, 0xd5, 0x4b, 0xf2, 0xb9, 0xc5, 0x26, 0x00,
-    0x7d, 0xd8, 0x3a, 0xaf, 0xf0, 0x65, 0x58, 0x36, 0x79, 0xf2, 0xe9, 0xe3, 0xe5, 0xd5, 0xde, 0xc3, 0x79, 0xc7, 0x44,
-    0x40, 0x64, 0xfd, 0xf3, 0x6e, 0x5e, 0x69, 0xde, 0x32, 0xa9, 0x3b, 0xb5, 0x8e, 0xe9, 0x22, 0x3b, 0x1f, 0xba, 0x73,
-    0x7c, 0x03, 0x41, 0xef, 0x46, 0x2f, 0x98, 0x92, 0x1d, 0xaa, 0x9d, 0xb5, 0x7b, 0xb8, 0xbc, 0xfe, 0xb6, 0xbd, 0xfe,
-    0xea, 0xbd, 0xee, 0xa5, 0xfb, 0x0f, 0x53, 0x58, 0x46, 0xb2, 0xf9, 0x0a, 0x00, 0x00};
+    0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x13, 0x95, 0x57, 0x6d, 0x6f, 0xdb, 0x36, 0x10, 0xfe, 0xde,
+    0x5f, 0xc1, 0xb1, 0xdd, 0x2c, 0xad, 0x91, 0x64, 0x29, 0xb1, 0xdb, 0xda, 0x92, 0x8a, 0xae, 0xdb, 0xb0, 0x02, 0xeb,
+    0x5a, 0x20, 0xd9, 0xf6, 0xa1, 0x28, 0x66, 0x5a, 0x3a, 0x59, 0x6c, 0x24, 0x4a, 0x23, 0xe9, 0xb7, 0x1a, 0xde, 0x6f,
+    0xdf, 0x91, 0x92, 0x15, 0x27, 0x58, 0x87, 0x2d, 0x41, 0x6c, 0xbe, 0xdc, 0x3b, 0xef, 0x9e, 0xbb, 0xc4, 0x5f, 0xe5,
+    0x4d, 0xa6, 0xf7, 0x2d, 0x90, 0x52, 0xd7, 0x55, 0x1a, 0x9b, 0x4f, 0x52, 0x31, 0xb1, 0x4a, 0x40, 0xe0, 0x0e, 0x58,
+    0x9e, 0xc6, 0x35, 0x68, 0x46, 0xb2, 0x92, 0x49, 0x05, 0x3a, 0xf9, 0xf5, 0xe6, 0x47, 0xef, 0x79, 0x1a, 0x57, 0x5c,
+    0xdc, 0x12, 0x09, 0x55, 0xc2, 0xb3, 0x46, 0x90, 0x52, 0x42, 0x91, 0xe4, 0x4c, 0xb3, 0x19, 0xaf, 0xd9, 0x0a, 0x7a,
+    0x16, 0xc1, 0x6a, 0x48, 0x36, 0x1c, 0xb6, 0x6d, 0x23, 0x35, 0x41, 0x3a, 0x0d, 0x42, 0x27, 0x74, 0xcb, 0x73, 0x5d,
+    0x26, 0x39, 0x6c, 0x78, 0x06, 0x9e, 0xdd, 0x5c, 0x70, 0xc1, 0x35, 0x67, 0x95, 0xa7, 0x32, 0x56, 0x41, 0x12, 0x5e,
+    0xac, 0x15, 0x48, 0xbb, 0x61, 0x4b, 0xdc, 0x8b, 0x86, 0xa6, 0xb1, 0xca, 0x24, 0x6f, 0x35, 0x31, 0xa6, 0x26, 0x75,
+    0x93, 0xaf, 0x2b, 0x48, 0x83, 0x80, 0x29, 0x34, 0x49, 0x05, 0x5c, 0xe4, 0xb0, 0xf3, 0x27, 0xe1, 0x34, 0x7a, 0x3e,
+    0x99, 0xbe, 0xf0, 0x3f, 0xa9, 0x47, 0xe8, 0xd4, 0xba, 0x46, 0x6d, 0x7e, 0xd5, 0x64, 0x4c, 0xf3, 0x46, 0xf8, 0x0a,
+    0x98, 0xcc, 0xca, 0x24, 0x49, 0xe8, 0x4b, 0xc5, 0x36, 0x40, 0xbf, 0xf9, 0xc6, 0x19, 0x88, 0x56, 0xa0, 0x7f, 0xa8,
+    0xc0, 0x2c, 0xd5, 0x77, 0xfb, 0x1b, 0xb6, 0xfa, 0x05, 0x0d, 0x77, 0x28, 0x53, 0x3c, 0x07, 0xea, 0x7e, 0x18, 0x7f,
+    0xf4, 0x95, 0xde, 0x57, 0xe0, 0xe7, 0x5c, 0xb5, 0x15, 0xdb, 0x27, 0x74, 0x89, 0x52, 0x6f, 0xa9, 0x3b, 0x2f, 0xd6,
+    0x22, 0x33, 0xc2, 0x89, 0x74, 0xc0, 0x3d, 0x54, 0x80, 0xe6, 0x25, 0x6f, 0x99, 0x2e, 0xfd, 0x9a, 0xed, 0x9c, 0x6e,
+    0xc1, 0x85, 0x13, 0x7d, 0xeb, 0xc0, 0xd3, 0x70, 0x3c, 0x76, 0x2f, 0xec, 0xc7, 0xd8, 0x0d, 0xf0, 0x7b, 0x2e, 0x41,
+    0xaf, 0xa5, 0x20, 0x8d, 0xb3, 0x88, 0x5b, 0xa4, 0x24, 0x79, 0x42, 0xdf, 0x86, 0x11, 0x09, 0x5f, 0xf8, 0xd1, 0xe4,
+    0x67, 0xff, 0x19, 0xb9, 0xc2, 0xef, 0xec, 0x99, 0x37, 0x21, 0xe1, 0x15, 0x7e, 0x44, 0x91, 0x3f, 0x21, 0xe3, 0xcf,
+    0x94, 0x14, 0xbc, 0xaa, 0x12, 0x2a, 0x1a, 0x01, 0x94, 0x28, 0x2d, 0x9b, 0x5b, 0x48, 0x68, 0xb6, 0x96, 0x12, 0x6d,
+    0x7f, 0xdd, 0x54, 0x8d, 0xa4, 0x41, 0xfa, 0xe8, 0x7f, 0x09, 0xd4, 0x92, 0x09, 0x55, 0x34, 0xb2, 0x4e, 0xa8, 0x8d,
+    0xbe, 0xf3, 0xe4, 0xa0, 0x8f, 0xc4, 0x7c, 0xb8, 0x67, 0x97, 0x5e, 0x23, 0xf9, 0x8a, 0x8b, 0x84, 0x1a, 0x89, 0xcf,
+    0x51, 0xc9, 0xc2, 0x3d, 0x0e, 0xde, 0x37, 0xc6, 0xfb, 0xde, 0x1f, 0xe5, 0x7c, 0x58, 0xc4, 0x6a, 0xb3, 0x22, 0xbb,
+    0xba, 0x12, 0x2a, 0xa1, 0xa5, 0xd6, 0xed, 0x2c, 0x08, 0xb6, 0xdb, 0xad, 0xbf, 0xbd, 0xf4, 0x1b, 0xb9, 0x0a, 0xa2,
+    0xf1, 0x78, 0x1c, 0x20, 0x05, 0x25, 0x5d, 0x22, 0xd0, 0xe8, 0x8a, 0x92, 0x12, 0xf8, 0xaa, 0xd4, 0x76, 0x9d, 0x3e,
+    0x39, 0xc0, 0x31, 0x36, 0x14, 0xe9, 0xe2, 0xe3, 0x99, 0x16, 0x7e, 0xa6, 0x05, 0x5e, 0x36, 0x0e, 0x3d, 0xb9, 0x39,
+    0xb2, 0x6e, 0x3e, 0x63, 0x11, 0x89, 0xc8, 0xd8, 0xfe, 0x46, 0x9e, 0x59, 0xf7, 0x3b, 0xef, 0xc1, 0x8e, 0x9c, 0xed,
+    0xcc, 0xaa, 0x9e, 0x7a, 0x2f, 0x06, 0xde, 0xd0, 0x9c, 0x6c, 0xc2, 0xf1, 0xdd, 0x81, 0x61, 0xf8, 0x69, 0x7a, 0xbe,
+    0xf7, 0xa2, 0xdf, 0xce, 0x09, 0x8c, 0xb6, 0x32, 0xfc, 0x6d, 0xca, 0x26, 0x64, 0xd2, 0x9f, 0x4c, 0x3c, 0xb3, 0x1e,
+    0x76, 0x64, 0xb2, 0x41, 0x8a, 0xda, 0x9b, 0x7a, 0x13, 0x76, 0x49, 0x2e, 0x7b, 0x43, 0x70, 0x85, 0xc7, 0x53, 0x64,
+    0x3c, 0x3b, 0xf3, 0x2e, 0x3f, 0x8f, 0x82, 0x94, 0xba, 0x33, 0x4a, 0xef, 0x3c, 0x57, 0xe7, 0x9e, 0xfb, 0x9f, 0x1a,
+    0xcc, 0x29, 0x4a, 0x31, 0x32, 0xa0, 0xb3, 0xd2, 0xa1, 0x01, 0x16, 0x56, 0xc1, 0x57, 0x98, 0xf5, 0x8d, 0xa0, 0xae,
+    0xaf, 0x4b, 0x10, 0xce, 0x89, 0xd5, 0x30, 0x82, 0xbd, 0x71, 0x1e, 0xde, 0x68, 0xf7, 0x30, 0xe4, 0xbf, 0xe6, 0x1a,
+    0xcb, 0x4c, 0xfb, 0xa6, 0x60, 0x2f, 0x86, 0xd3, 0x65, 0x93, 0xef, 0xbf, 0x50, 0x1a, 0x65, 0xd8, 0xd5, 0x05, 0x17,
+    0x02, 0xe4, 0x0d, 0xec, 0xf0, 0xe5, 0xde, 0xbe, 0x7a, 0x4d, 0x5e, 0xe5, 0xb9, 0x04, 0xa5, 0x66, 0x84, 0x3e, 0xd5,
+    0x58, 0x03, 0xd9, 0x7f, 0x97, 0x15, 0xde, 0x93, 0xf5, 0x3b, 0xff, 0x91, 0x93, 0x5f, 0x40, 0x6f, 0x1b, 0x79, 0xdb,
+    0x4b, 0x33, 0xa6, 0xcd, 0x4d, 0x85, 0x31, 0xb4, 0x93, 0xb5, 0xca, 0x57, 0x15, 0xc2, 0x87, 0x13, 0xba, 0xa8, 0xa7,
+    0xbd, 0xf3, 0x4a, 0x9c, 0x02, 0xb5, 0x88, 0x73, 0xbe, 0x21, 0x59, 0x85, 0x08, 0x81, 0xe5, 0xd2, 0x89, 0xa2, 0xe4,
+    0x11, 0xb1, 0x3f, 0x8d, 0xc8, 0x90, 0xfb, 0x36, 0xa1, 0xff, 0x80, 0x00, 0xdf, 0xed, 0xdf, 0xe4, 0xce, 0x48, 0x61,
+    0xed, 0x8f, 0x5c, 0x7f, 0xc3, 0xaa, 0x35, 0x90, 0x84, 0xe8, 0x92, 0xab, 0x3b, 0x03, 0xe7, 0x5f, 0x64, 0x6b, 0xd5,
+    0x2d, 0x72, 0x15, 0x78, 0xad, 0x1c, 0x97, 0xa6, 0xbd, 0xba, 0x98, 0x75, 0x00, 0x49, 0x1f, 0xd3, 0x07, 0x16, 0x79,
+    0x15, 0x14, 0x7a, 0xa0, 0x23, 0x58, 0x76, 0xd2, 0x11, 0xbe, 0x44, 0xed, 0xee, 0x71, 0x38, 0x8c, 0x55, 0xcb, 0xc4,
+    0x43, 0x46, 0x63, 0xa0, 0x29, 0x15, 0x04, 0x36, 0x5c, 0x99, 0x7a, 0x41, 0xa2, 0x41, 0x61, 0xc0, 0x4e, 0xcb, 0x27,
+    0x07, 0x8e, 0x12, 0x0d, 0x5e, 0x0d, 0x12, 0xe3, 0x00, 0x43, 0x93, 0x2e, 0x8e, 0xee, 0x9c, 0x17, 0x77, 0x18, 0xf8,
+    0xe7, 0x1a, 0xe4, 0xfe, 0x1a, 0x2a, 0xc8, 0x74, 0x23, 0x1d, 0xfa, 0x18, 0x15, 0x61, 0x36, 0x59, 0x9f, 0x7f, 0xba,
+    0x79, 0xfb, 0x73, 0xa2, 0x1c, 0xe6, 0x5e, 0x7c, 0x89, 0xda, 0x74, 0x83, 0x0f, 0xd8, 0x0d, 0xfe, 0x4a, 0x46, 0xa6,
+    0x1f, 0x8c, 0x3e, 0x22, 0xab, 0x75, 0x79, 0x71, 0xd7, 0x14, 0x4c, 0x45, 0x3f, 0x45, 0x54, 0xb8, 0x30, 0x4e, 0x7a,
+    0xd3, 0x89, 0x7b, 0x5c, 0x5c, 0x68, 0x7f, 0x0b, 0xcb, 0x3f, 0x10, 0xec, 0x37, 0x20, 0x3b, 0x00, 0x15, 0xc9, 0xa0,
+    0x23, 0x93, 0xc0, 0x34, 0xf4, 0xf1, 0x75, 0x28, 0x1a, 0x8d, 0x90, 0x2b, 0xce, 0x4c, 0x5a, 0xc4, 0xe5, 0x65, 0xfa,
+    0xbd, 0xed, 0x23, 0xe4, 0x35, 0x76, 0x17, 0xd9, 0x54, 0x71, 0x80, 0x47, 0x43, 0xbc, 0x83, 0x97, 0x77, 0xe2, 0x93,
+    0x10, 0xe1, 0x8c, 0x49, 0x7c, 0xb1, 0x84, 0xfe, 0xb1, 0xc4, 0x0e, 0x87, 0xe9, 0x30, 0xe4, 0xc1, 0x16, 0x3b, 0x48,
+    0xb3, 0xf5, 0x9b, 0x16, 0x2b, 0x64, 0x74, 0x9f, 0x6b, 0x74, 0x31, 0xea, 0xc8, 0x47, 0xee, 0x09, 0xb3, 0x0b, 0x56,
+    0x29, 0x98, 0xd3, 0xf4, 0x1d, 0x92, 0x93, 0xdf, 0x61, 0x49, 0xae, 0x2d, 0xad, 0x89, 0x7a, 0xdc, 0x12, 0xdb, 0x2b,
+    0x12, 0x5a, 0xa0, 0x41, 0x9e, 0xe2, 0x9f, 0x61, 0x16, 0x46, 0xed, 0x6e, 0x9e, 0x19, 0x70, 0x9e, 0x3d, 0x9e, 0x4e,
+    0xa7, 0xc8, 0xf8, 0xa6, 0xb0, 0x19, 0x45, 0xf2, 0x06, 0x94, 0x18, 0x69, 0x62, 0xf4, 0x5e, 0x90, 0x9a, 0x89, 0x35,
+    0xab, 0xaa, 0x3d, 0x59, 0xca, 0x66, 0xab, 0x80, 0xe8, 0x06, 0x5f, 0xaf, 0xb7, 0x6c, 0x68, 0x63, 0x1d, 0x0e, 0x1f,
+    0xef, 0xdb, 0x18, 0x07, 0x2d, 0xf6, 0x6a, 0x99, 0xc6, 0x4b, 0x99, 0x2e, 0xfe, 0x7b, 0xd1, 0x45, 0x1f, 0xfd, 0x25,
+    0x20, 0xba, 0x03, 0x96, 0xcd, 0xf1, 0xe8, 0x62, 0x42, 0x60, 0x1a, 0xd9, 0x36, 0x8b, 0xed, 0xd6, 0x78, 0x91, 0x7e,
+    0x7b, 0x58, 0x36, 0x3b, 0xe3, 0x05, 0x17, 0xab, 0x19, 0x17, 0x25, 0x48, 0xae, 0x8f, 0xf8, 0x10, 0xd8, 0xb0, 0xdb,
+    0xb5, 0x3e, 0xb4, 0x2c, 0xcf, 0xcd, 0xcd, 0x04, 0x1d, 0x3c, 0xf3, 0x17, 0xea, 0x63, 0x77, 0x6f, 0x01, 0x7e, 0xf6,
+    0x62, 0xf2, 0xf5, 0xd1, 0x98, 0x72, 0xd0, 0x58, 0x3b, 0x1e, 0xab, 0xf8, 0x4a, 0xcc, 0x32, 0xb4, 0x07, 0x64, 0xc7,
+    0x54, 0xb0, 0x9a, 0x57, 0xfb, 0x99, 0xc2, 0x56, 0xe3, 0xa1, 0x47, 0xbc, 0x38, 0x2e, 0xd7, 0x5a, 0x37, 0x02, 0x75,
+    0xcb, 0x1c, 0xe4, 0x6c, 0x3c, 0xef, 0x16, 0x9e, 0x64, 0x39, 0x5f, 0xab, 0x99, 0x7f, 0x29, 0xa1, 0x9e, 0x2f, 0x59,
+    0x76, 0xbb, 0x92, 0xcd, 0x5a, 0xe4, 0x5e, 0x1f, 0xdb, 0xb0, 0x60, 0x97, 0x90, 0x9d, 0x22, 0x5d, 0x14, 0xc5, 0x1c,
+    0xd3, 0x12, 0xbc, 0xae, 0xb5, 0xcc, 0x22, 0xff, 0xca, 0xb0, 0x9d, 0x99, 0xe9, 0x47, 0xe6, 0xa0, 0xb3, 0x11, 0x3b,
+    0xf2, 0xd7, 0xf3, 0x93, 0x3b, 0xe3, 0x39, 0x76, 0x54, 0x85, 0x42, 0x5a, 0x84, 0x5a, 0x34, 0xf3, 0x58, 0x33, 0x2e,
+    0xce, 0xad, 0x37, 0x55, 0x3b, 0xef, 0xa7, 0x01, 0x0c, 0x8b, 0x55, 0x63, 0x67, 0x82, 0x39, 0xf6, 0xfb, 0x6e, 0xa4,
+    0x99, 0x45, 0xd3, 0x71, 0xbb, 0x3b, 0xfa, 0x7d, 0xbd, 0x1e, 0x4e, 0xd4, 0x45, 0x05, 0xbb, 0xf9, 0xa7, 0xb5, 0xd2,
+    0xbc, 0xd8, 0x7b, 0xfd, 0x48, 0x34, 0xc3, 0xda, 0xc5, 0x51, 0x68, 0x89, 0xa4, 0x00, 0x62, 0x6e, 0x75, 0x78, 0x5c,
+    0x43, 0xad, 0xfa, 0x38, 0x0d, 0x62, 0x2c, 0x5e, 0xdc, 0x97, 0xf5, 0x6f, 0xd4, 0x06, 0x1a, 0x0e, 0x35, 0x26, 0x3d,
+    0x5a, 0xb5, 0x6c, 0x30, 0xa6, 0xf5, 0xcc, 0x7b, 0x86, 0x6f, 0xd5, 0x1f, 0x19, 0x61, 0xe8, 0x39, 0x9a, 0x69, 0x47,
+    0x9d, 0x53, 0xbc, 0xc3, 0x76, 0x47, 0x54, 0x53, 0xf1, 0xbc, 0xa7, 0xb3, 0x24, 0x64, 0x3c, 0x84, 0x27, 0xc4, 0xe7,
+    0x26, 0xe6, 0xec, 0x14, 0xea, 0xab, 0xe2, 0x39, 0x0b, 0xc7, 0xff, 0xf0, 0x22, 0x79, 0x51, 0x44, 0xcb, 0x62, 0x88,
+    0x94, 0x99, 0x5a, 0x0c, 0x52, 0xd9, 0xd4, 0xc2, 0x4a, 0xb5, 0xc3, 0xa5, 0xc9, 0x0c, 0x9c, 0x17, 0x31, 0xc2, 0x98,
+    0xc2, 0x21, 0xe1, 0x79, 0x82, 0x8d, 0x23, 0x3d, 0xeb, 0x26, 0x48, 0x18, 0x9e, 0xae, 0x70, 0x75, 0xaf, 0x37, 0x74,
+    0x77, 0xd6, 0xfa, 0x14, 0x11, 0x40, 0x20, 0x1c, 0xa1, 0x85, 0xa6, 0x72, 0xfa, 0x10, 0xf8, 0xbe, 0x6f, 0x8a, 0xe2,
+    0x7d, 0x05, 0x0c, 0x2b, 0x6a, 0xcb, 0xb8, 0xf6, 0xb1, 0x4c, 0x2d, 0x7d, 0x07, 0xab, 0x28, 0x14, 0x49, 0xd3, 0x1e,
+    0x3f, 0x0d, 0xa0, 0x58, 0x05, 0xd7, 0xa0, 0x8d, 0x24, 0xd5, 0xe1, 0x89, 0x99, 0x80, 0x08, 0xb3, 0x1d, 0x26, 0x09,
+    0xb6, 0xbc, 0xe0, 0x66, 0x82, 0x4c, 0x63, 0x9b, 0xe4, 0x46, 0x82, 0x89, 0x73, 0x37, 0xed, 0xda, 0x55, 0x05, 0x62,
+    0x85, 0x83, 0xcd, 0x65, 0x44, 0xd0, 0xed, 0x0c, 0xca, 0xa6, 0xc2, 0xb0, 0x26, 0xd7, 0xd7, 0x6f, 0xbe, 0xb7, 0x15,
+    0x7a, 0xc7, 0x87, 0xed, 0xa2, 0x63, 0x33, 0x8b, 0x9e, 0x6b, 0x7a, 0xd5, 0xcd, 0xb8, 0x2d, 0xc2, 0x3d, 0x7a, 0x90,
+    0xdf, 0x93, 0xf1, 0xbe, 0x3f, 0xec, 0xe4, 0xd8, 0x3f, 0x5b, 0x2a, 0xe9, 0x35, 0x1a, 0x14, 0x07, 0xfd, 0x26, 0x0e,
+    0x8c, 0xc1, 0xdd, 0x7d, 0x8f, 0x0a, 0x18, 0xbf, 0xf4, 0xdd, 0xcd, 0x2b, 0xf2, 0x6b, 0x8b, 0x80, 0x0c, 0x5d, 0xd8,
+    0xac, 0x57, 0x38, 0xa8, 0x97, 0x4d, 0x9e, 0xbc, 0x7f, 0x77, 0x7d, 0x33, 0x78, 0xb8, 0xb6, 0x44, 0x04, 0x44, 0xd6,
+    0x4d, 0xdb, 0xeb, 0x4a, 0xf3, 0x96, 0x49, 0x6d, 0xc5, 0x7a, 0x06, 0xd1, 0x4f, 0x3e, 0xd8, 0x7b, 0x1c, 0x49, 0xa1,
+    0x73, 0xa3, 0x63, 0x4c, 0xc9, 0xc9, 0xaa, 0x93, 0xb6, 0x07, 0x76, 0x05, 0xdd, 0x6b, 0x07, 0xdd, 0xd3, 0x07, 0xf6,
+    0x1f, 0x8f, 0xbf, 0x01, 0x7d, 0x9a, 0x47, 0xb5, 0x88, 0x0c, 0x00, 0x00};
 
 #else  // Brotli (default, smaller)
 const uint8_t INDEX_BR[] PROGMEM = {
-    0x1b, 0xf8, 0x0a, 0x00, 0x64, 0x5a, 0xd3, 0xfa, 0xe7, 0xf3, 0x62, 0xd8, 0x06, 0x1b, 0xe9, 0x6a, 0x8a, 0x81, 0x2b,
-    0xb5, 0x49, 0x14, 0x37, 0xdc, 0x9e, 0x1a, 0xcb, 0x56, 0x87, 0xfb, 0xff, 0xf7, 0x73, 0x75, 0x12, 0x0a, 0xd6, 0x48,
-    0x84, 0xc6, 0x21, 0xa4, 0x6d, 0xb5, 0x71, 0xef, 0x13, 0xbe, 0x4e, 0x54, 0xf1, 0x64, 0x8f, 0x3f, 0xcc, 0x9a, 0x78,
-    0xa5, 0x89, 0x25, 0xb3, 0xda, 0x2c, 0xa2, 0x32, 0x9c, 0x57, 0x07, 0x56, 0xbc, 0x34, 0x13, 0xff, 0x5c, 0x0a, 0xa1,
-    0x67, 0x82, 0xb8, 0x6b, 0x4c, 0x76, 0x31, 0x6c, 0xe3, 0x40, 0x46, 0xea, 0xb0, 0xd4, 0xf4, 0x3b, 0x02, 0x65, 0x18,
-    0xa4, 0xaf, 0xac, 0x6d, 0x55, 0xd6, 0xbe, 0x59, 0x66, 0x7a, 0x7c, 0x60, 0xb2, 0x83, 0x33, 0x23, 0xc9, 0x79, 0x82,
-    0x47, 0xb4, 0x28, 0xf4, 0x24, 0xb5, 0x23, 0x5a, 0x44, 0xe1, 0xc3, 0x27, 0x04, 0xe8, 0x0c, 0xdd, 0xb4, 0xd0, 0x8c,
-    0xfb, 0x10, 0x39, 0x93, 0x04, 0x2a, 0x66, 0x18, 0x4b, 0x74, 0xca, 0x31, 0x7f, 0xb2, 0xe5, 0x45, 0xc1, 0xdd, 0x72,
-    0x49, 0xff, 0x0e, 0xb3, 0xf0, 0x93, 0x18, 0xab, 0x68, 0xad, 0xe1, 0x9d, 0xe4, 0x29, 0xc0, 0xe3, 0x63, 0x54, 0x61,
-    0x1b, 0x45, 0xb9, 0x6c, 0x23, 0x0f, 0x99, 0x7f, 0x8e, 0x69, 0xaa, 0xc1, 0xb8, 0x4e, 0x42, 0x9c, 0xc5, 0x6e, 0x69,
-    0x40, 0x0e, 0x4f, 0x97, 0xd3, 0x23, 0x18, 0xf5, 0xc8, 0x75, 0x73, 0xb5, 0xbd, 0x46, 0x8a, 0x97, 0x7d, 0x83, 0xe4,
-    0x29, 0x72, 0x73, 0xc1, 0x39, 0x8e, 0x7e, 0x84, 0x39, 0x66, 0x57, 0xc6, 0x85, 0x19, 0x8b, 0xf2, 0x4d, 0xd9, 0xfe,
-    0x75, 0xa9, 0xe1, 0x2b, 0x21, 0x81, 0x58, 0x51, 0x99, 0xbc, 0xa4, 0x0b, 0x10, 0x6f, 0x86, 0x17, 0x0b, 0x92, 0x00,
-    0x11, 0x6f, 0x3b, 0xa4, 0xa4, 0x11, 0x7e, 0x0b, 0x97, 0x85, 0x23, 0x0c, 0x01, 0x6f, 0x2a, 0x18, 0xc6, 0xbe, 0x3d,
-    0x77, 0x1a, 0xe6, 0x00, 0x5c, 0x1a, 0x14, 0x47, 0xc6, 0xcc, 0xcc, 0x52, 0xbe, 0x04, 0x19, 0x31, 0x05, 0x46, 0xa0,
-    0xc3, 0x69, 0x0c, 0x60, 0xb7, 0x14, 0x57, 0xa0, 0x92, 0xbf, 0xb7, 0x0c, 0xd8, 0x3a, 0x79, 0x09, 0x99, 0xc9, 0x71,
-    0x88, 0x01, 0x8b, 0xa5, 0x61, 0x0a, 0xb5, 0xe8, 0xc7, 0x71, 0xe7, 0x70, 0x79, 0xb6, 0xe4, 0x01, 0xfc, 0x1a, 0x4a,
-    0x7b, 0x60, 0x6e, 0xef, 0x95, 0x62, 0x59, 0x28, 0xb5, 0x25, 0x56, 0x15, 0xe7, 0xca, 0xad, 0x32, 0xe6, 0xf7, 0x01,
-    0x31, 0x34, 0x87, 0x93, 0x0b, 0x9b, 0x9d, 0x26, 0xff, 0xe5, 0x92, 0xad, 0x6f, 0xb8, 0x3b, 0x16, 0xc1, 0xa0, 0x5a,
-    0x4f, 0x52, 0x0b, 0x2b, 0xc1, 0xa7, 0x95, 0x7b, 0x24, 0x51, 0xd3, 0xb3, 0x23, 0x62, 0x0b, 0xcc, 0xa0, 0x58, 0xa7,
-    0x64, 0x45, 0x2f, 0x0b, 0xdd, 0x1d, 0x97, 0x82, 0x1f, 0xcc, 0x64, 0xdb, 0xd3, 0xf4, 0xb0, 0x8b, 0xc8, 0xcf, 0x15,
-    0x81, 0x8b, 0xa1, 0x9d, 0xf8, 0xfc, 0xec, 0x49, 0x40, 0x12, 0x01, 0x09, 0x51, 0xf3, 0x73, 0x18, 0x24, 0x97, 0x55,
-    0x85, 0x6a, 0x92, 0x1a, 0xf5, 0x5a, 0x05, 0x54, 0x1f, 0x27, 0x0a, 0xa8, 0xa1, 0x94, 0x58, 0x78, 0x7d, 0x87, 0xa8,
-    0xdb, 0x13, 0x66, 0x20, 0x5e, 0x43, 0x18, 0x7a, 0xbb, 0x16, 0x16, 0x07, 0xc8, 0xab, 0x10, 0xe2, 0x50, 0xb9, 0xb1,
-    0xd8, 0x21, 0xc8, 0x4a, 0x2e, 0x99, 0x0e, 0x23, 0x52, 0xc6, 0xcb, 0x29, 0x84, 0x91, 0x03, 0xb1, 0xe2, 0x4c, 0x1d,
-    0x22, 0xd3, 0xc8, 0x79, 0x00, 0x8b, 0x8b, 0x88, 0x1e, 0x29, 0xd3, 0xae, 0x10, 0x15, 0x22, 0x6d, 0xb0, 0x87, 0x6f,
-    0x27, 0x2e, 0x7c, 0xc2, 0x7a, 0x61, 0xbd, 0x22, 0xe5, 0x5f, 0xdd, 0x7b, 0x00, 0x04, 0xf2, 0x7d, 0x5a, 0x03, 0x38,
-    0x1f, 0x69, 0x6d, 0x0b, 0xfb, 0xec, 0x45, 0xfe, 0x8b, 0x7f, 0xec, 0x7b, 0xad, 0xc2, 0x33, 0xf1, 0x9e, 0x9c, 0x71,
-    0xd9, 0xe8, 0x5e, 0x8f, 0xd4, 0xee, 0x87, 0x45, 0x6c, 0xe2, 0x12, 0xf8, 0xb8, 0xc5, 0xee, 0x43, 0xa6, 0x37, 0x91,
-    0xb5, 0x2c, 0x2f, 0xe9, 0xe8, 0x24, 0xd0, 0x45, 0xc1, 0x0c, 0x7c, 0xf0, 0xb2, 0xb5, 0x2d, 0x10, 0x36, 0x7e, 0x18,
-    0x7c, 0x79, 0x82, 0x69, 0x3d, 0x35, 0xca, 0x52, 0xee, 0xc9, 0xb5, 0x65, 0xa4, 0xa1, 0xfd, 0x70, 0x7e, 0xe0, 0x7d,
-    0x67, 0xf9, 0xa1, 0x71, 0xd2, 0x08, 0x74, 0x33, 0x5f, 0x69, 0xa4, 0x59, 0x03, 0xfd, 0xf8, 0xf0, 0x70, 0x1a, 0x50,
-    0x43, 0xfb, 0x61, 0xf0, 0x38, 0x18, 0x88, 0x85, 0x36, 0x23, 0x06, 0x4f, 0x02, 0xbb, 0x78, 0x1a, 0xaa, 0xd2, 0x02,
-    0x5e, 0xa0, 0x74, 0x30, 0xc8, 0x7a, 0x66, 0xab, 0xd9, 0x43, 0x99, 0x45, 0xb7, 0x0c, 0x5c, 0xec, 0xc8, 0x03, 0x0e,
-    0x0b, 0xca, 0x4a, 0x22, 0x48, 0xfb, 0xb7, 0x3d, 0x82, 0x07, 0x8d, 0x1b, 0x21, 0x87, 0x4d, 0x57, 0xa4, 0x5b, 0xd4,
-    0xe3, 0x88, 0x02, 0xc4, 0x81, 0xf9, 0x47, 0xe4, 0xbf, 0x3e, 0x39, 0xbb, 0x4f, 0x7e, 0x91, 0x63, 0x98, 0x97, 0xe4,
-    0x52, 0x01, 0x58, 0xba, 0x32, 0xbf, 0xae, 0xff, 0x45, 0xa1, 0xbc, 0x9b, 0xa4, 0x09, 0x0e, 0x79, 0xc0, 0x41, 0x86,
-    0x52, 0x88, 0x55, 0x39, 0x9d, 0xb6, 0xed, 0x35, 0x68, 0x29, 0xfa, 0xe6, 0x6c, 0x3d, 0x0a, 0xcd, 0x6a, 0x28, 0xfd,
-    0x65, 0x24, 0xce, 0x38, 0x98, 0x01, 0xd9, 0x3f, 0x1b, 0x4c, 0xc4, 0x5c, 0x1d, 0xaa, 0x21, 0x78, 0x67, 0xaf, 0x55,
-    0x72, 0x34, 0xf8, 0x1b, 0x03, 0x21, 0x27, 0x08, 0xbd, 0x59, 0x60, 0x48, 0x0d, 0xe2, 0x56, 0x9b, 0x30, 0x92, 0x8f,
-    0x67, 0x8a, 0x7f, 0x20, 0xbd, 0x2d, 0xfd, 0xc5, 0xb0, 0xa6, 0xaa, 0x77, 0x75, 0x26, 0x33, 0x2f, 0x20, 0x2a, 0xab,
-    0x5c, 0xd1, 0x3b, 0xda, 0xb2, 0x4c, 0xa4, 0x86, 0x25, 0x8d, 0x49, 0x05, 0xaf, 0x7a, 0xa8, 0xd4, 0x9c, 0x0d, 0xd3,
-    0x38, 0xa6, 0x5c, 0x29, 0x6b, 0x16, 0x27, 0x07, 0xf1, 0xbe, 0xe2, 0x24, 0xc1, 0x8d, 0x25, 0x76, 0xbc, 0xf6, 0x0d,
-    0xc2, 0x94, 0x25, 0xb8, 0xf3, 0x07, 0x9a, 0x49, 0xf4, 0x89, 0x82, 0x4d, 0x51, 0xb1, 0x96, 0x61, 0x62, 0x8d, 0xc8,
-    0x61, 0x65, 0x0d, 0x14, 0x34, 0x02, 0x65, 0x94, 0xcc, 0x1d, 0x85, 0x00, 0x0f, 0x1a, 0x57, 0x68, 0x15, 0xcf, 0xa4,
-    0xa2, 0x7d, 0x6d, 0x53, 0x60, 0xce, 0x5c, 0x61, 0x82, 0x17, 0x32, 0xc1, 0x87, 0x02, 0x0c, 0x91, 0x85, 0x57, 0x51,
-    0xbe, 0xb2, 0x38, 0x9f, 0x3d, 0x2a, 0x52, 0x5a, 0xad, 0xba, 0x46, 0x9e, 0x3c, 0x8a, 0xa0, 0x46, 0x15, 0xf4, 0x59,
-    0x74, 0x5f, 0x2a, 0xae, 0x96, 0x56, 0xf0, 0x54, 0x39, 0xaf, 0xac, 0x2a, 0xb9, 0xad, 0x32, 0x50, 0xc9, 0xc1, 0xee,
-    0xd2, 0x0d, 0x34, 0xaa, 0x98, 0x4d, 0x6d, 0x3d, 0xc6, 0xb9, 0x5b, 0x00, 0x5f, 0xea, 0xda, 0x16, 0xa6, 0x08, 0x43,
-    0x58, 0x4d, 0x8d, 0x07, 0x55, 0x62, 0x81, 0x44, 0xcc, 0x31, 0x04, 0x4b, 0x4c, 0x8b, 0x3e, 0xff, 0xd8, 0xf6, 0x65,
-    0x19, 0xa1, 0x94, 0x62, 0x65, 0x0a, 0xdd, 0x60, 0x38, 0xd3, 0xbe, 0x0d, 0xa3, 0x99, 0xd5, 0x37, 0x68, 0xa1, 0x71,
-    0xa3, 0x41, 0xe7, 0xbe, 0x9d, 0x72, 0x84, 0x75, 0xb6, 0x8d, 0x98, 0xd6, 0xb8, 0x2d, 0x43, 0x85, 0x5d, 0xf9, 0xca,
-    0xc3, 0x96, 0xa5, 0xa6, 0xe7, 0x50, 0x88, 0x6b, 0x84, 0x58, 0x44, 0x45, 0x20, 0xdf, 0x1e, 0x5a, 0xc9, 0xce, 0x42,
-    0x2a, 0x1f, 0x3e, 0x3c, 0x7b, 0x68, 0x3c, 0x34, 0x8b, 0x36, 0xba, 0x1f, 0xce, 0x0f, 0xa0, 0x60, 0x37, 0x5f, 0x1a,
-    0x03, 0x2b, 0x86, 0x29, 0x45, 0x7b, 0xb4, 0xb7, 0x06, 0x68, 0x17, 0x7e, 0x13, 0x76, 0x91, 0x4d, 0x27, 0xee, 0xbc,
-    0x7e, 0x80, 0xc2, 0x66, 0xac, 0xc6, 0xbf, 0xeb, 0x7f, 0xd7, 0x84, 0x79, 0xf3, 0xf1, 0xde, 0xec, 0xa6, 0x93, 0xa8,
-    0x13, 0x3b, 0x4a, 0x81, 0xfa, 0x11, 0x1e, 0x4a, 0xd2, 0x50, 0x2a, 0xea, 0x9a, 0xc2, 0x37, 0x08, 0xed, 0x01, 0xf5,
-    0xa2, 0xd5, 0x32, 0x29, 0x49, 0xc4, 0x1a, 0x11, 0xc0, 0xda, 0x24, 0x28, 0x84, 0x38, 0x60, 0x80, 0xcf, 0xd0, 0x45,
-    0x83, 0xa7, 0xca, 0x52, 0x5c, 0xac, 0x23, 0x01};
+    0x1b, 0x87, 0x0c, 0x00, 0x64, 0x5a, 0xd3, 0xfa, 0xe7, 0xf3, 0x62, 0x48, 0x83, 0x8d, 0xa0, 0x60, 0x49, 0x51, 0xb8,
+    0x52, 0x9b, 0x44, 0x71, 0xc3, 0xe5, 0xc4, 0x8c, 0xb8, 0xd5, 0xe1, 0xfc, 0x6a, 0x2d, 0xdf, 0x92, 0x04, 0x76, 0x51,
+    0xb1, 0x51, 0xa9, 0x08, 0x05, 0xd6, 0xe5, 0x75, 0xf7, 0x74, 0x08, 0x41, 0xa5, 0x6a, 0xe6, 0xf6, 0xc4, 0xde, 0x86,
+    0x59, 0x38, 0x40, 0x45, 0xf0, 0xad, 0x23, 0xf9, 0xfd, 0x21, 0x5b, 0x7f, 0x3f, 0x73, 0xc1, 0x4a, 0x60, 0x0f, 0x75,
+    0xea, 0x45, 0x28, 0x87, 0x33, 0x98, 0xa0, 0x4d, 0x5b, 0xc9, 0x2e, 0x9e, 0x4b, 0x1c, 0x78, 0xa7, 0x0e, 0x7e, 0x39,
+    0x76, 0x04, 0x75, 0x08, 0xb1, 0xb7, 0x5b, 0xa4, 0x5a, 0xb2, 0x2b, 0x4d, 0x84, 0x1c, 0xf8, 0x60, 0x78, 0xc7, 0x2a,
+    0x1c, 0x73, 0x9e, 0x53, 0x90, 0xb2, 0xa0, 0xf6, 0x3c, 0xb5, 0x9b, 0x05, 0x0b, 0xea, 0x47, 0x5f, 0xa8, 0xd0, 0xb8,
+    0xb0, 0x1d, 0x94, 0x63, 0x43, 0x68, 0xc1, 0x1c, 0x57, 0xaa, 0x55, 0x86, 0xe1, 0x44, 0x17, 0x89, 0xf9, 0x27, 0x29,
+    0xcb, 0xf8, 0x26, 0xcd, 0xb6, 0xf4, 0xaf, 0x9b, 0xd4, 0x9f, 0x5b, 0x6c, 0x58, 0x08, 0x01, 0xef, 0x4c, 0x9e, 0x7e,
+    0xb8, 0x58, 0xa0, 0x88, 0x61, 0xa8, 0xf2, 0x62, 0xd5, 0x78, 0x24, 0xfc, 0x21, 0x8e, 0xa9, 0x86, 0xda, 0xba, 0x03,
+    0xe2, 0xbc, 0x75, 0x07, 0x7b, 0xa4, 0xf1, 0xf8, 0x7a, 0x71, 0x00, 0x83, 0xd8, 0xb9, 0x6e, 0x6f, 0xab, 0xae, 0x91,
+    0xe3, 0x7d, 0x63, 0x11, 0x3f, 0x43, 0x7a, 0xc5, 0xa2, 0x08, 0x07, 0xff, 0x34, 0x45, 0x38, 0x7c, 0x33, 0x52, 0xd8,
+    0xdd, 0xa1, 0xb2, 0xd0, 0xed, 0xbf, 0xae, 0x05, 0x7c, 0xc5, 0x38, 0x60, 0x5b, 0xca, 0xd3, 0x97, 0x74, 0x0d, 0x92,
+    0xd3, 0xd4, 0x6a, 0x4d, 0x52, 0xc0, 0x92, 0xbb, 0x64, 0xce, 0x69, 0x73, 0x74, 0x0b, 0x2f, 0x0b, 0x47, 0x6c, 0x01,
+    0x6f, 0x31, 0x70, 0x43, 0xdf, 0x1d, 0xb5, 0x80, 0x1c, 0x40, 0x97, 0x06, 0xc5, 0xa9, 0x85, 0x72, 0x92, 0xa8, 0x5e,
+    0x82, 0x8c, 0x34, 0x05, 0xa6, 0xa1, 0xd9, 0x38, 0x78, 0x70, 0xef, 0xc7, 0x11, 0x4a, 0xc9, 0xcd, 0x5b, 0x06, 0xa9,
+    0x2e, 0xdc, 0xc0, 0x50, 0x96, 0xd8, 0xb7, 0x40, 0x4c, 0x27, 0x75, 0x7a, 0xd4, 0xa1, 0x1f, 0x65, 0xe1, 0x2e, 0xcf,
+    0x2f, 0x79, 0x80, 0x3a, 0x01, 0x7b, 0x7b, 0x08, 0x77, 0xcd, 0x55, 0x2c, 0xb2, 0xd0, 0xda, 0x45, 0x61, 0x2c, 0x95,
+    0xca, 0xf5, 0x3c, 0x91, 0xf7, 0x1c, 0x09, 0x94, 0xb3, 0x51, 0xfb, 0x62, 0xbf, 0x2c, 0x7f, 0xe5, 0x94, 0xdb, 0x8c,
+    0xeb, 0x3b, 0x1d, 0x82, 0x55, 0x8d, 0x5d, 0x76, 0xae, 0x15, 0x07, 0xbf, 0x63, 0xa3, 0x6a, 0x4e, 0xdc, 0xf2, 0x92,
+    0x1f, 0xc9, 0x0d, 0xa2, 0xc1, 0x40, 0x9b, 0x91, 0x2d, 0x7d, 0x31, 0xf3, 0xdd, 0x77, 0xc9, 0xa2, 0xc7, 0x68, 0xb2,
+    0xe1, 0x69, 0xf6, 0x78, 0x80, 0xf0, 0xcf, 0x91, 0x90, 0x63, 0xe3, 0x81, 0x7d, 0xfe, 0x4a, 0x4f, 0x41, 0xda, 0x0c,
+    0x52, 0xe2, 0xd6, 0x97, 0x26, 0x90, 0x5e, 0xc6, 0x6a, 0x6c, 0x49, 0x16, 0x94, 0xa1, 0x62, 0x10, 0x67, 0x46, 0x24,
+    0x06, 0x71, 0x61, 0x46, 0xec, 0x7c, 0xff, 0x0e, 0x89, 0x6f, 0x97, 0xa1, 0x84, 0x78, 0x07, 0x61, 0xed, 0xf3, 0x38,
+    0x5c, 0x1c, 0x20, 0x1f, 0x42, 0x88, 0x7d, 0xa3, 0x87, 0xea, 0x80, 0x60, 0x78, 0xe4, 0x92, 0xd8, 0x46, 0x64, 0x31,
+    0xbe, 0x9c, 0x42, 0x0c, 0x39, 0x88, 0x4b, 0x74, 0x68, 0xbe, 0x28, 0x6a, 0x50, 0x19, 0x20, 0x75, 0xd1, 0x2c, 0x06,
+    0x2a, 0xb4, 0x01, 0x81, 0x12, 0x09, 0x43, 0x3c, 0x6a, 0x0f, 0xec, 0x55, 0x0f, 0xac, 0x17, 0xd7, 0x2b, 0x52, 0xdb,
+    0xab, 0x7b, 0x0f, 0xc6, 0xe3, 0x3d, 0xa5, 0x1d, 0x80, 0xab, 0x81, 0xb6, 0xaa, 0x4a, 0x2f, 0x2f, 0xeb, 0xfb, 0x62,
+    0x1e, 0x9b, 0xa1, 0x55, 0xf4, 0xc2, 0xc5, 0x2b, 0xce, 0xa5, 0x6c, 0xa6, 0x12, 0x03, 0x55, 0x27, 0x77, 0x11, 0x9b,
+    0x5c, 0xc2, 0x30, 0x6d, 0xd5, 0xa9, 0x66, 0xe5, 0xb6, 0xb1, 0x22, 0x4a, 0x4d, 0x27, 0x87, 0x40, 0xd7, 0x02, 0x26,
+    0xe0, 0x97, 0xea, 0xd6, 0xb0, 0x40, 0xd8, 0x5c, 0xe7, 0x4c, 0xbd, 0xc4, 0xd4, 0xa6, 0xa6, 0xbe, 0x54, 0x0b, 0xb9,
+    0xbc, 0x9c, 0xb4, 0xf1, 0xe4, 0x8e, 0x8f, 0x3a, 0x3a, 0xab, 0x16, 0xca, 0x2c, 0xbd, 0x30, 0x87, 0x94, 0xaa, 0x8c,
+    0xcc, 0x6b, 0x90, 0x5f, 0xdf, 0xce, 0xc6, 0x1e, 0x59, 0xda, 0x3b, 0x67, 0xb0, 0x0f, 0x70, 0x95, 0xb6, 0x21, 0x46,
+    0x21, 0x21, 0x2e, 0xd5, 0x96, 0xba, 0xca, 0x3c, 0x5e, 0x10, 0x3a, 0x6c, 0xb2, 0xde, 0xa4, 0x1a, 0x6d, 0xa0, 0xb3,
+    0xe4, 0xce, 0x80, 0x8b, 0x9a, 0xd2, 0x23, 0x01, 0xad, 0x0e, 0x75, 0x97, 0xdc, 0x97, 0x66, 0xef, 0x7a, 0x04, 0xa7,
+    0x56, 0x0f, 0x50, 0x91, 0xd3, 0x2d, 0x09, 0x87, 0x14, 0x0e, 0x28, 0xd0, 0x23, 0x44, 0xff, 0x68, 0xfe, 0x2f, 0x96,
+    0x2f, 0x55, 0xcb, 0x5f, 0xe4, 0x54, 0x6d, 0x5f, 0xd9, 0x31, 0x40, 0xaa, 0x87, 0x57, 0xd7, 0xed, 0xbf, 0xa0, 0xa2,
+    0x1f, 0x93, 0x2c, 0xc5, 0xbe, 0x0c, 0x06, 0x7a, 0xa5, 0xf7, 0x7f, 0x7a, 0x2e, 0x56, 0xa2, 0xcb, 0xb2, 0xc0, 0xe7,
+    0xf2, 0xda, 0x5c, 0x42, 0x9c, 0xdb, 0x62, 0x15, 0x97, 0xd0, 0x87, 0xd7, 0x9d, 0x93, 0xee, 0x99, 0x20, 0x81, 0xd5,
+    0x6b, 0xfa, 0xee, 0x64, 0xb1, 0x85, 0x60, 0x1d, 0x9e, 0xf2, 0x82, 0x73, 0x6c, 0x5c, 0x21, 0x28, 0xdb, 0x96, 0xc1,
+    0x12, 0x43, 0x6e, 0x86, 0xf3, 0xfe, 0x14, 0xf3, 0xd2, 0x0b, 0xbf, 0xc4, 0x8f, 0x03, 0x1f, 0xd0, 0xf2, 0x5b, 0x15,
+    0xa7, 0x8e, 0x18, 0x08, 0x43, 0x80, 0x61, 0x53, 0x96, 0x65, 0xc4, 0x35, 0xcf, 0x1a, 0xae, 0x92, 0x05, 0x4b, 0x18,
+    0x94, 0xcf, 0xd7, 0x63, 0x38, 0x1f, 0x6c, 0xd0, 0x66, 0xb3, 0x71, 0x49, 0x1d, 0xeb, 0xe2, 0x00, 0x5f, 0x4e, 0xc0,
+    0xc4, 0xee, 0xe2, 0xd0, 0x4b, 0x94, 0xb6, 0x4a, 0xa5, 0xe0, 0x45, 0x71, 0xc6, 0x28, 0x57, 0x21, 0x8b, 0xbd, 0xc7,
+    0x1e, 0x68, 0x50, 0x4d, 0xb2, 0xc8, 0xb3, 0x71, 0xdf, 0x5d, 0x0f, 0x18, 0x7b, 0xbe, 0xdb, 0xa3, 0xe9, 0x88, 0xaf,
+    0xcd, 0x65, 0x80, 0x2e, 0x14, 0x5b, 0x02, 0x8a, 0xd9, 0x75, 0x6e, 0xd5, 0xad, 0x8f, 0xc3, 0xf0, 0xf3, 0xb0, 0x6d,
+    0x3a, 0xdf, 0x1a, 0x91, 0x07, 0xe6, 0x70, 0x30, 0x88, 0x85, 0x4d, 0x4b, 0x3d, 0xfa, 0x29, 0x1b, 0x21, 0x6b, 0x6d,
+    0x94, 0x3b, 0xfe, 0x03, 0xe9, 0x55, 0x6d, 0x2e, 0xdc, 0x8e, 0xc6, 0xbd, 0x6e, 0x73, 0x08, 0x73, 0x0d, 0xd6, 0xa8,
+    0x58, 0x57, 0xa3, 0x03, 0x23, 0x72, 0x84, 0xd3, 0xcc, 0x69, 0x42, 0x6a, 0x17, 0xb5, 0x9a, 0x72, 0x4f, 0x1b, 0x35,
+    0x2b, 0xc4, 0x0f, 0xca, 0x67, 0x8d, 0x16, 0x7b, 0xb4, 0x15, 0x38, 0x02, 0x2a, 0x6f, 0x00, 0xd5, 0xd6, 0x1a, 0x0b,
+    0xf8, 0x8b, 0x39, 0xd6, 0xae, 0xf3, 0x54, 0x66, 0xcb, 0x47, 0x0a, 0x73, 0x80, 0xcb, 0x65, 0xb9, 0x89, 0x52, 0x46,
+    0xae, 0x86, 0x21, 0xc2, 0x6d, 0x65, 0x04, 0x59, 0x96, 0xe4, 0xf9, 0x94, 0x10, 0x1c, 0x28, 0x6d, 0x45, 0x49, 0xa9,
+    0xce, 0x70, 0xd3, 0x0b, 0x9f, 0x02, 0xea, 0x21, 0x60, 0x44, 0x7b, 0xc5, 0x04, 0xae, 0x3b, 0xa8, 0xb0, 0x98, 0x15,
+    0x95, 0xe0, 0x8e, 0x69, 0x73, 0x7b, 0xcf, 0xb0, 0x12, 0xb7, 0x74, 0x67, 0x08, 0x68, 0x13, 0x61, 0xbe, 0x01, 0xfc,
+    0x4d, 0x73, 0xdf, 0x28, 0x69, 0x36, 0x8a, 0x45, 0x53, 0xe5, 0xaa, 0xba, 0x69, 0xf8, 0xbe, 0xc9, 0x31, 0xbe, 0xda,
+    0x1e, 0xfe, 0x02, 0xa9, 0x0e, 0xcb, 0xa2, 0x55, 0x06, 0x72, 0x3e, 0xce, 0x80, 0xa9, 0x45, 0xab, 0x2a, 0xd9, 0xa3,
+    0x90, 0x95, 0x23, 0xc1, 0x05, 0x2e, 0xb7, 0x7f, 0xe0, 0x70, 0xaa, 0x81, 0x4f, 0x8e, 0xbb, 0x80, 0xf4, 0x48, 0x33,
+    0x34, 0x53, 0x4a, 0x05, 0x43, 0x90, 0x34, 0x60, 0x7f, 0x2b, 0x2d, 0x42, 0x1a, 0x6b, 0x70, 0x6e, 0xbf, 0xd5, 0x83,
+    0x34, 0x96, 0x6a, 0x0f, 0x71, 0x26, 0x66, 0x2d, 0x7a, 0xd2, 0x29, 0xde, 0x0b, 0x7d, 0x86, 0xc3, 0x2b, 0xd3, 0x18,
+    0x14, 0xe9, 0x97, 0x63, 0x75, 0xd1, 0xd6, 0x84, 0x78, 0xd9, 0xc5, 0x08, 0xfc, 0x10, 0x11, 0xf3, 0xb5, 0x74, 0xba,
+    0x3f, 0x7c, 0x78, 0xf6, 0x50, 0x4a, 0x6d, 0xda, 0xd6, 0x93, 0x3b, 0x3e, 0xc2, 0x21, 0xef, 0xb5, 0x59, 0x82, 0x73,
+    0x0d, 0xc4, 0x77, 0xd3, 0x31, 0xeb, 0xfd, 0x23, 0x2d, 0xfe, 0xcb, 0xe2, 0x52, 0x2c, 0x47, 0x1c, 0xa8, 0x79, 0x26,
+    0x56, 0x0c, 0xc5, 0x11, 0xcd, 0x00, 0x73, 0xb2, 0xf5, 0xcd, 0xc7, 0x7b, 0xe7, 0xfe, 0x9d, 0x9b, 0xce, 0x5d, 0x47,
+    0x08, 0xe6, 0xa1, 0xd6, 0x92, 0xe7, 0x11, 0xb6, 0x68, 0x5b, 0x95, 0x86, 0x2c, 0x2d, 0x18, 0x21, 0x94, 0x74, 0x31,
+    0xd1, 0xea, 0xae, 0x5d, 0x08, 0xd3, 0x87, 0xab, 0xc2, 0xc4, 0xf5, 0x12, 0x94, 0x8c, 0x72, 0xf4, 0xf8, 0x2a, 0x0d,
+    0xa7, 0xb8, 0x6b, 0x20, 0x02};
 
 // Backwards compatibility alias
 #define INDEX_GZ INDEX_BR

esphome/components/captive_portal/captive_portal.cpp

@@ -43,7 +43,11 @@ void CaptivePortal::handle_config(AsyncWebServerRequest *request) {
                    scan.get_with_auth());
 #endif
   }
+#ifdef USE_WEBSERVER
+  stream->print(ESPHOME_F("],\"web_server\":true}"));
+#else
   stream->print(ESPHOME_F("]}"));
+#endif
   request->send(stream);
 }
 void CaptivePortal::handle_wifisave(AsyncWebServerRequest *request) {
@@ -76,15 +80,9 @@ void CaptivePortal::start() {
 
   network::IPAddress ip = wifi::global_wifi_component->wifi_soft_ap_ip();
 
-#if defined(USE_ESP32)
-  // Create DNS server instance for ESP-IDF
+  // Create DNS server instance with domain allowlisting support
   this->dns_server_ = make_unique<DNSServer>();
   this->dns_server_->start(ip);
-#elif defined(USE_ARDUINO)
-  this->dns_server_ = make_unique<DNSServer>();
-  this->dns_server_->setErrorReplyCode(DNSReplyCode::NoError);
-  this->dns_server_->start(53, ESPHOME_F("*"), ip);
-#endif
 
   this->initialized_ = true;
   this->active_ = true;
@@ -127,6 +125,10 @@ float CaptivePortal::get_setup_priority() const {
 }
 void CaptivePortal::dump_config() { ESP_LOGCONFIG(TAG, "Captive Portal:"); }
 
+bool CaptivePortal::canHandle(AsyncWebServerRequest *request) const {
+  return this->active_ && request->method() == HTTP_GET;
+}
+
 CaptivePortal *global_captive_portal = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 }  // namespace captive_portal

esphome/components/captive_portal/captive_portal.h

@@ -4,8 +4,8 @@
 #include <memory>
 #if defined(USE_ESP32)
 #include "dns_server_esp32_idf.h"
-#elif defined(USE_ARDUINO)
-#include <DNSServer.h>
+#elif defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY)
+#include "dns_server_arduino.h"
 #endif
 #include "esphome/core/component.h"
 #include "esphome/core/helpers.h"
@@ -22,15 +22,9 @@ class CaptivePortal : public AsyncWebHandler, public Component {
   void setup() override;
   void dump_config() override;
   void loop() override {
-#if defined(USE_ESP32)
     if (this->dns_server_ != nullptr) {
       this->dns_server_->process_next_request();
     }
-#elif defined(USE_ARDUINO)
-    if (this->dns_server_ != nullptr) {
-      this->dns_server_->processNextRequest();
-    }
-#endif
   }
   float get_setup_priority() const override;
   void start();
@@ -45,12 +39,7 @@ class CaptivePortal : public AsyncWebHandler, public Component {
     }
   }
 
-  bool canHandle(AsyncWebServerRequest *request) const override {
-    // Handle all GET requests when captive portal is active
-    // This allows us to respond with the portal page for any URL,
-    // triggering OS captive portal detection
-    return this->active_ && request->method() == HTTP_GET;
-  }
+  bool canHandle(AsyncWebServerRequest *request) const override;
 
   void handle_config(AsyncWebServerRequest *request);
 

esphome/components/captive_portal/dns_server_arduino.cpp

@@ -0,0 +1,130 @@
+#include "dns_server_arduino.h"
+#if defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY)
+
+#include "dns_server_common.h"
+#include "esphome/core/log.h"
+#include <lwip/def.h>
+
+namespace esphome::captive_portal {
+
+static const char *const TAG = "captive_portal.dns";
+
+void DNSServer::start(const network::IPAddress &ip) {
+  this->server_ip_ = ip;
+  ESP_LOGV(TAG, "Starting DNS server");
+
+  this->udp_ = make_unique<WiFiUDP>();
+  if (!this->udp_->begin(DNS_PORT)) {
+    ESP_LOGE(TAG, "Failed to start UDP on port %d", DNS_PORT);
+    this->udp_ = nullptr;
+    return;
+  }
+  ESP_LOGV(TAG, "Bound to port %d", DNS_PORT);
+}
+
+void DNSServer::stop() {
+  if (this->udp_ != nullptr) {
+    this->udp_->stop();
+    this->udp_ = nullptr;
+  }
+  ESP_LOGV(TAG, "Stopped");
+}
+
+void DNSServer::process_next_request() {
+  if (this->udp_ == nullptr) {
+    return;
+  }
+
+  int packet_size = this->udp_->parsePacket();
+  if (packet_size == 0) {
+    return;
+  }
+
+  if (packet_size > static_cast<int>(sizeof(this->buffer_))) {
+    // Packet too large, skip it
+    while (this->udp_->available()) {
+      this->udp_->read();
+    }
+    return;
+  }
+
+  int len = this->udp_->read(this->buffer_, sizeof(this->buffer_));
+  if (len < static_cast<int>(sizeof(DNSHeader) + 1)) {
+    ESP_LOGV(TAG, "Request too short: %d", len);
+    return;
+  }
+
+  // Parse DNS header
+  DNSHeader *header = (DNSHeader *) this->buffer_;
+  uint16_t flags = ntohs(header->flags);
+  uint16_t qd_count = ntohs(header->qd_count);
+
+  // Check if it's a standard query
+  if ((flags & DNS_QR_FLAG) || (flags & DNS_OPCODE_MASK) || qd_count != 1) {
+    ESP_LOGV(TAG, "Not a standard query: flags=0x%04X, qd_count=%d", flags, qd_count);
+    return;
+  }
+
+  // Parse domain name
+  uint8_t *ptr = this->buffer_ + sizeof(DNSHeader);
+  uint8_t *end = this->buffer_ + len;
+  char domain[128];
+
+  ptr = parse_dns_domain(ptr, end, domain, sizeof(domain));
+  if (ptr == nullptr) {
+    return;  // Invalid domain name
+  }
+
+  // Check allowlist and send REFUSED if needed
+  if (is_allowlisted_domain(domain)) {
+    ESP_LOGV(TAG, "Allowlisted domain, sending REFUSED: %s", domain);
+    build_dns_refused_header(header);
+    this->udp_->beginPacket(this->udp_->remoteIP(), this->udp_->remotePort());
+    this->udp_->write(this->buffer_, len);
+    this->udp_->endPacket();
+    return;
+  }
+
+  ESP_LOGV(TAG, "Redirecting DNS query for: %s", domain);
+
+  // Check we have room for the question
+  if (ptr + sizeof(DNSQuestion) > end) {
+    return;
+  }
+
+  // Parse DNS question
+  DNSQuestion *question = (DNSQuestion *) ptr;
+  uint16_t qtype = ntohs(question->type);
+  uint16_t qclass = ntohs(question->dns_class);
+
+  if (qtype != DNS_QTYPE_A || qclass != DNS_QCLASS_IN) {
+    ESP_LOGV(TAG, "Not an A query: type=0x%04X, class=0x%04X", qtype, qclass);
+    return;
+  }
+
+  // Build DNS response
+  build_dns_response_header(header);
+
+  // Add answer section after the question
+  size_t question_end_offset = (ptr + sizeof(DNSQuestion)) - this->buffer_;
+  if (build_dns_answer(this->buffer_, sizeof(this->buffer_), question_end_offset,
+                       static_cast<uint32_t>(this->server_ip_)) == nullptr) {
+    ESP_LOGW(TAG, "Response too large");
+    return;
+  }
+
+  size_t response_len = question_end_offset + sizeof(DNSAnswer);
+
+  // Send response
+  this->udp_->beginPacket(this->udp_->remoteIP(), this->udp_->remotePort());
+  this->udp_->write(this->buffer_, response_len);
+  if (!this->udp_->endPacket()) {
+    ESP_LOGV(TAG, "Send failed");
+  } else {
+    ESP_LOGV(TAG, "Sent %d bytes", response_len);
+  }
+}
+
+}  // namespace esphome::captive_portal
+
+#endif  // USE_ESP8266 || USE_RP2040 || USE_LIBRETINY

esphome/components/captive_portal/dns_server_arduino.h

@@ -0,0 +1,26 @@
+#pragma once
+#if defined(USE_ESP8266) || defined(USE_RP2040) || defined(USE_LIBRETINY)
+
+#include <memory>
+#include "dns_server_common.h"
+#include "esphome/core/helpers.h"
+#include "esphome/components/network/ip_address.h"
+#include <WiFiUdp.h>
+
+namespace esphome::captive_portal {
+
+class DNSServer {
+ public:
+  void start(const network::IPAddress &ip);
+  void stop();
+  void process_next_request();
+
+ protected:
+  std::unique_ptr<WiFiUDP> udp_{nullptr};
+  network::IPAddress server_ip_;
+  uint8_t buffer_[DNS_BUFFER_SIZE];
+};
+
+}  // namespace esphome::captive_portal
+
+#endif  // USE_ESP8266 || USE_RP2040 || USE_LIBRETINY

esphome/components/captive_portal/dns_server_common.h

@@ -0,0 +1,133 @@
+#pragma once
+#include <cstdint>
+#include <cstring>
+#include <lwip/def.h>
+#include "esphome/core/defines.h"
+#include "esphome/core/progmem.h"
+
+namespace esphome::captive_portal {
+
+// DNS constants
+static constexpr uint16_t DNS_PORT = 53;
+static constexpr uint16_t DNS_QR_FLAG = 1 << 15;
+static constexpr uint16_t DNS_OPCODE_MASK = 0x7800;
+static constexpr uint16_t DNS_QTYPE_A = 0x0001;
+static constexpr uint16_t DNS_QCLASS_IN = 0x0001;
+static constexpr uint16_t DNS_ANSWER_TTL = 300;
+static constexpr size_t DNS_BUFFER_SIZE = 192;
+
+// DNS Header structure
+struct DNSHeader {
+  uint16_t id;
+  uint16_t flags;
+  uint16_t qd_count;
+  uint16_t an_count;
+  uint16_t ns_count;
+  uint16_t ar_count;
+} __attribute__((packed));
+
+// DNS Question structure
+struct DNSQuestion {
+  uint16_t type;
+  uint16_t dns_class;
+} __attribute__((packed));
+
+// DNS Answer structure
+struct DNSAnswer {
+  uint16_t ptr_offset;
+  uint16_t type;
+  uint16_t dns_class;
+  uint32_t ttl;
+  uint16_t addr_len;
+  uint32_t ip_addr;
+} __attribute__((packed));
+
+/// Check if domain is allowlisted (web_server CDN domains)
+/// Returns true if the domain should NOT be redirected
+inline bool is_allowlisted_domain([[maybe_unused]] const char *domain) {
+#ifdef USE_WEBSERVER
+#ifdef WEBSERVER_CDN_DOMAIN_0
+  if (ESPHOME_strcasecmp_P(domain, ESPHOME_F(WEBSERVER_CDN_DOMAIN_0)) == 0)
+    return true;
+#endif
+#ifdef WEBSERVER_CDN_DOMAIN_1
+  if (ESPHOME_strcasecmp_P(domain, ESPHOME_F(WEBSERVER_CDN_DOMAIN_1)) == 0)
+    return true;
+#endif
+#endif
+  return false;
+}
+
+/// Parse DNS domain name from packet into string buffer
+/// Returns pointer past the domain name (after null terminator), or nullptr on error
+inline uint8_t *parse_dns_domain(uint8_t *ptr, const uint8_t *end, char *domain, size_t domain_size) {
+  size_t domain_len = 0;
+
+  while (ptr < end && *ptr != 0) {
+    uint8_t label_len = *ptr;
+    if (label_len > 63) {  // Check for invalid label length
+      return nullptr;
+    }
+    // Check if we have room for this label plus the length byte
+    if (ptr + label_len + 1 > end) {
+      return nullptr;  // Would overflow
+    }
+    // Add dot separator if not first label
+    if (domain_len > 0 && domain_len < domain_size - 1) {
+      domain[domain_len++] = '.';
+    }
+    // Copy label to domain string
+    for (uint8_t i = 0; i < label_len && domain_len < domain_size - 1; i++) {
+      domain[domain_len++] = ptr[1 + i];
+    }
+    ptr += label_len + 1;
+  }
+  domain[domain_len] = '\0';
+
+  // Check if we reached a proper null terminator
+  if (ptr >= end || *ptr != 0) {
+    return nullptr;  // Name not terminated or truncated
+  }
+  return ptr + 1;  // Skip the null terminator
+}
+
+/// Build DNS response header for A record query
+/// Modifies header in place, returns true if successful
+inline void build_dns_response_header(DNSHeader *header) {
+  header->flags = htons(DNS_QR_FLAG | 0x8000);  // Response + Authoritative
+  header->an_count = htons(1);                  // One answer
+}
+
+/// Build DNS REFUSED response header
+/// Used when domain is allowlisted to trigger fallback to other DNS
+inline void build_dns_refused_header(DNSHeader *header) {
+  header->flags = htons(DNS_QR_FLAG | 0x8005);  // Response + REFUSED
+  header->an_count = 0;
+  header->ns_count = 0;
+  header->ar_count = 0;
+}
+
+/// Build DNS answer section
+/// Returns the answer pointer, or nullptr if buffer too small
+inline DNSAnswer *build_dns_answer(uint8_t *buffer, size_t buffer_size, size_t question_end_offset, uint32_t ip_addr) {
+  size_t answer_offset = question_end_offset;
+
+  // Check if we have room for the answer
+  if (answer_offset + sizeof(DNSAnswer) > buffer_size) {
+    return nullptr;
+  }
+
+  DNSAnswer *answer = reinterpret_cast<DNSAnswer *>(buffer + answer_offset);
+
+  // Pointer to name in question (offset from start of packet)
+  answer->ptr_offset = htons(0xC000 | sizeof(DNSHeader));
+  answer->type = htons(DNS_QTYPE_A);
+  answer->dns_class = htons(DNS_QCLASS_IN);
+  answer->ttl = htonl(DNS_ANSWER_TTL);
+  answer->addr_len = htons(4);
+  answer->ip_addr = ip_addr;
+
+  return answer;
+}
+
+}  // namespace esphome::captive_portal

esphome/components/captive_portal/dns_server_esp32_idf.cpp

@@ -1,8 +1,8 @@
 #include "dns_server_esp32_idf.h"
 #ifdef USE_ESP32
 
+#include "dns_server_common.h"
 #include "esphome/core/log.h"
-#include "esphome/core/hal.h"
 #include "esphome/components/socket/socket.h"
 #include <lwip/sockets.h>
 #include <lwip/inet.h>
@@ -11,40 +11,6 @@ namespace esphome::captive_portal {
 
 static const char *const TAG = "captive_portal.dns";
 
-// DNS constants
-static constexpr uint16_t DNS_PORT = 53;
-static constexpr uint16_t DNS_QR_FLAG = 1 << 15;
-static constexpr uint16_t DNS_OPCODE_MASK = 0x7800;
-static constexpr uint16_t DNS_QTYPE_A = 0x0001;
-static constexpr uint16_t DNS_QCLASS_IN = 0x0001;
-static constexpr uint16_t DNS_ANSWER_TTL = 300;
-
-// DNS Header structure
-struct DNSHeader {
-  uint16_t id;
-  uint16_t flags;
-  uint16_t qd_count;
-  uint16_t an_count;
-  uint16_t ns_count;
-  uint16_t ar_count;
-} __attribute__((packed));
-
-// DNS Question structure
-struct DNSQuestion {
-  uint16_t type;
-  uint16_t dns_class;
-} __attribute__((packed));
-
-// DNS Answer structure
-struct DNSAnswer {
-  uint16_t ptr_offset;
-  uint16_t type;
-  uint16_t dns_class;
-  uint32_t ttl;
-  uint16_t addr_len;
-  uint32_t ip_addr;
-} __attribute__((packed));
-
 void DNSServer::start(const network::IPAddress &ip) {
   this->server_ip_ = ip;
 #if ESPHOME_LOG_LEVEL >= ESPHOME_LOG_LEVEL_VERBOSE
@@ -126,27 +92,28 @@ void DNSServer::process_next_request() {
     return;  // Not a standard query
   }
 
-  // Parse domain name (we don't actually care about it - redirect everything)
+  // Parse domain name
   uint8_t *ptr = this->buffer_ + sizeof(DNSHeader);
   uint8_t *end = this->buffer_ + len;
+  char domain[128];
 
-  while (ptr < end && *ptr != 0) {
-    uint8_t label_len = *ptr;
-    if (label_len > 63) {  // Check for invalid label length
-      return;
-    }
-    // Check if we have room for this label plus the length byte
-    if (ptr + label_len + 1 > end) {
-      return;  // Would overflow
-    }
-    ptr += label_len + 1;
+  ptr = parse_dns_domain(ptr, end, domain, sizeof(domain));
+  if (ptr == nullptr) {
+    return;  // Invalid domain name
   }
 
-  // Check if we reached a proper null terminator
-  if (ptr >= end || *ptr != 0) {
-    return;  // Name not terminated or truncated
+  // Check allowlist and send REFUSED if needed
+  if (is_allowlisted_domain(domain)) {
+    ESP_LOGV(TAG, "Allowlisted domain, sending REFUSED: %s", domain);
+    build_dns_refused_header(header);
+    ssize_t sent = this->socket_->sendto(this->buffer_, len, 0, (struct sockaddr *) &client_addr, client_addr_len);
+    if (sent < 0) {
+      ESP_LOGV(TAG, "Send REFUSED failed: %d", errno);
+    }
+    return;
   }
-  ptr++;  // Skip the null terminator
+
+  ESP_LOGV(TAG, "Redirecting DNS query for: %s", domain);
 
   // Check we have room for the question
   if (ptr + sizeof(DNSQuestion) > end) {
@@ -164,34 +131,18 @@ void DNSServer::process_next_request() {
     return;  // Not an A query
   }
 
-  // Build DNS response by modifying the request in-place
-  header->flags = htons(DNS_QR_FLAG | 0x8000);  // Response + Authoritative
-  header->an_count = htons(1);                  // One answer
+  // Build DNS response
+  build_dns_response_header(header);
 
   // Add answer section after the question
-  size_t question_len = (ptr + sizeof(DNSQuestion)) - this->buffer_ - sizeof(DNSHeader);
-  size_t answer_offset = sizeof(DNSHeader) + question_len;
-
-  // Check if we have room for the answer
-  if (answer_offset + sizeof(DNSAnswer) > sizeof(this->buffer_)) {
+  size_t question_end_offset = (ptr + sizeof(DNSQuestion)) - this->buffer_;
+  ip4_addr_t addr = this->server_ip_;
+  if (build_dns_answer(this->buffer_, sizeof(this->buffer_), question_end_offset, addr.addr) == nullptr) {
     ESP_LOGW(TAG, "Response too large");
     return;
   }
 
-  DNSAnswer *answer = (DNSAnswer *) (this->buffer_ + answer_offset);
-
-  // Pointer to name in question (offset from start of packet)
-  answer->ptr_offset = htons(0xC000 | sizeof(DNSHeader));
-  answer->type = htons(DNS_QTYPE_A);
-  answer->dns_class = htons(DNS_QCLASS_IN);
-  answer->ttl = htonl(DNS_ANSWER_TTL);
-  answer->addr_len = htons(4);
-
-  // Get the raw IP address
-  ip4_addr_t addr = this->server_ip_;
-  answer->ip_addr = addr.addr;
-
-  size_t response_len = answer_offset + sizeof(DNSAnswer);
+  size_t response_len = question_end_offset + sizeof(DNSAnswer);
 
   // Send response
   ssize_t sent =

esphome/components/captive_portal/dns_server_esp32_idf.h

@@ -2,6 +2,7 @@
 #ifdef USE_ESP32
 
 #include <memory>
+#include "dns_server_common.h"
 #include "esphome/core/helpers.h"
 #include "esphome/components/network/ip_address.h"
 #include "esphome/components/socket/socket.h"
@@ -15,8 +16,6 @@ class DNSServer {
   void process_next_request();
 
  protected:
-  static constexpr size_t DNS_BUFFER_SIZE = 192;
-
   std::unique_ptr<socket::Socket> socket_{nullptr};
   network::IPAddress server_ip_;
   uint8_t buffer_[DNS_BUFFER_SIZE];

esphome/components/espnow/__init__.py

@@ -17,7 +17,7 @@ from esphome.core import CORE, HexInt
 from esphome.types import ConfigType
 
 CODEOWNERS = ["@jesserockz"]
-AUTO_LOAD = ["socket"]
+AUTO_LOAD = ["network", "socket"]
 
 byte_vector = cg.std_vector.template(cg.uint8)
 peer_address_t = cg.std_ns.class_("array").template(cg.uint8, 6)

esphome/components/espnow/espnow_component.cpp

@@ -149,12 +149,6 @@ bool ESPNowComponent::is_wifi_enabled() {
 }
 
 void ESPNowComponent::setup() {
-#ifndef USE_WIFI
-  // Initialize LwIP stack for wake_loop_threadsafe() socket support
-  // When WiFi component is present, it handles esp_netif_init()
-  ESP_ERROR_CHECK(esp_netif_init());
-#endif
-
   if (this->enable_on_boot_) {
     this->enable_();
   } else {
@@ -174,8 +168,6 @@ void ESPNowComponent::enable() {
 
 void ESPNowComponent::enable_() {
   if (!this->is_wifi_enabled()) {
-    esp_event_loop_create_default();
-
     wifi_init_config_t cfg = WIFI_INIT_CONFIG_DEFAULT();
 
     ESP_ERROR_CHECK(esp_wifi_init(&cfg));

esphome/components/ethernet/ethernet_component.cpp

@@ -102,11 +102,6 @@ void EthernetComponent::setup() {
   ESPHL_ERROR_CHECK(err, "SPI bus initialize error");
 #endif
 
-  err = esp_netif_init();
-  ESPHL_ERROR_CHECK(err, "ETH netif init error");
-  err = esp_event_loop_create_default();
-  ESPHL_ERROR_CHECK(err, "ETH event loop error");
-
   esp_netif_config_t cfg = ESP_NETIF_DEFAULT_ETH();
   this->eth_netif_ = esp_netif_new(&cfg);
 

esphome/components/network/__init__.py

@@ -5,7 +5,7 @@ import esphome.codegen as cg
 from esphome.components.esp32 import add_idf_sdkconfig_option
 from esphome.components.psram import is_guaranteed as psram_is_guaranteed
 import esphome.config_validation as cv
-from esphome.const import CONF_ENABLE_IPV6, CONF_MIN_IPV6_ADDR_COUNT
+from esphome.const import CONF_ENABLE_IPV6, CONF_ID, CONF_MIN_IPV6_ADDR_COUNT
 from esphome.core import CORE, CoroPriority, coroutine_with_priority
 
 CODEOWNERS = ["@esphome/core"]
@@ -20,6 +20,7 @@ CONF_ENABLE_HIGH_PERFORMANCE = "enable_high_performance"
 
 network_ns = cg.esphome_ns.namespace("network")
 IPAddress = network_ns.class_("IPAddress")
+NetworkComponent = network_ns.class_("NetworkComponent", cg.Component)
 
 
 def ip_address_literal(ip: str | int | None) -> cg.MockObj:
@@ -107,6 +108,7 @@ def has_high_performance_networking() -> bool:
 
 CONFIG_SCHEMA = cv.Schema(
     {
+        cv.GenerateID(): cv.declare_id(NetworkComponent),
         cv.SplitDefault(
             CONF_ENABLE_IPV6,
             esp8266=False,
@@ -140,6 +142,12 @@ async def to_code(config):
     if CORE.using_arduino and CORE.is_esp32:
         cg.add_library("Networking", None)
 
+    # Register NetworkComponent to initialize network stack early (ESP32 only)
+    # This ensures esp_netif_init() is called before web_server binds
+    if CORE.is_esp32:
+        var = cg.new_Pvariable(config[CONF_ID])
+        await cg.register_component(var, config)
+
     # Apply high performance networking settings
     # Config can explicitly enable/disable, or default to component-driven behavior
     enable_high_perf = config.get(CONF_ENABLE_HIGH_PERFORMANCE)

esphome/components/network/network_component.cpp

@@ -0,0 +1,32 @@
+#include "network_component.h"
+#ifdef USE_ESP32
+#include "esphome/core/log.h"
+#include "esp_event.h"
+#include "esp_netif.h"
+
+namespace esphome::network {
+
+static const char *const TAG = "network";
+
+void NetworkComponent::setup() {
+  // Initialize network stack early - required before web_server can bind.
+  // This must run before WiFi/Ethernet setup so web_server can register
+  // its handlers before captive_portal.
+  esp_err_t err = esp_netif_init();
+  if (err != ESP_OK) {
+    ESP_LOGE(TAG, "esp_netif_init failed: %s", esp_err_to_name(err));
+  }
+  err = esp_event_loop_create_default();
+  if (err != ESP_OK && err != ESP_ERR_INVALID_STATE) {
+    // ESP_ERR_INVALID_STATE means it was already created
+    ESP_LOGE(TAG, "esp_event_loop_create_default failed: %s", esp_err_to_name(err));
+  }
+}
+
+float NetworkComponent::get_setup_priority() const {
+  // Run before web_server (WIFI + 0.5) and WiFi (WIFI)
+  return setup_priority::WIFI + 2.0f;
+}
+
+}  // namespace esphome::network
+#endif

esphome/components/network/network_component.h

@@ -0,0 +1,16 @@
+#pragma once
+#ifdef USE_ESP32
+#include "esphome/core/component.h"
+
+namespace esphome::network {
+
+/// Component that initializes the network stack early.
+/// This allows web_server to bind before WiFi/Ethernet setup.
+class NetworkComponent : public Component {
+ public:
+  void setup() override;
+  float get_setup_priority() const override;
+};
+
+}  // namespace esphome::network
+#endif

esphome/components/openthread/openthread_esp.cpp

@@ -35,8 +35,6 @@ void OpenThreadComponent::setup() {
       .max_fds = 3,
   };
   ESP_ERROR_CHECK(nvs_flash_init());
-  ESP_ERROR_CHECK(esp_event_loop_create_default());
-  ESP_ERROR_CHECK(esp_netif_init());
   ESP_ERROR_CHECK(esp_vfs_eventfd_register(&eventfd_config));
 
   xTaskCreate(

esphome/components/web_server/__init__.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import gzip
+from urllib.parse import urlparse
 
 import esphome.codegen as cg
 from esphome.components import web_server_base
@@ -42,6 +43,8 @@ CONF_SORTING_GROUP_ID = "sorting_group_id"
 CONF_SORTING_GROUPS = "sorting_groups"
 CONF_SORTING_WEIGHT = "sorting_weight"
 
+# CDN host for web_server assets - used for default URLs and DNS allowlisting
+CDN_HOST = "oi.esphome.io"
 
 web_server_ns = cg.esphome_ns.namespace("web_server")
 WebServer = web_server_ns.class_("WebServer", cg.Component, cg.Controller)
@@ -53,19 +56,19 @@ def default_url(config: ConfigType) -> ConfigType:
     config = config.copy()
     if config[CONF_VERSION] == 1:
         if CONF_CSS_URL not in config:
-            config[CONF_CSS_URL] = "https://oi.esphome.io/v1/webserver-v1.min.css"
+            config[CONF_CSS_URL] = f"https://{CDN_HOST}/v1/webserver-v1.min.css"
         if CONF_JS_URL not in config:
-            config[CONF_JS_URL] = "https://oi.esphome.io/v1/webserver-v1.min.js"
+            config[CONF_JS_URL] = f"https://{CDN_HOST}/v1/webserver-v1.min.js"
     if config[CONF_VERSION] == 2:
         if CONF_CSS_URL not in config:
             config[CONF_CSS_URL] = ""
         if CONF_JS_URL not in config:
-            config[CONF_JS_URL] = "https://oi.esphome.io/v2/www.js"
+            config[CONF_JS_URL] = f"https://{CDN_HOST}/v2/www.js"
     if config[CONF_VERSION] == 3:
         if CONF_CSS_URL not in config:
             config[CONF_CSS_URL] = ""
         if CONF_JS_URL not in config:
-            config[CONF_JS_URL] = "https://oi.esphome.io/v3/www.js"
+            config[CONF_JS_URL] = f"https://{CDN_HOST}/v3/www.js"
     return config
 
 
@@ -335,6 +338,24 @@ async def to_code(config):
     if config[CONF_COMPRESSION] == "gzip":
         cg.add_define("USE_WEBSERVER_GZIP")
 
+    # Extract domains from CDN URLs for DNS allowlisting (used by captive_portal)
+    # This handles both default URLs (using CDN_HOST) and custom user URLs
+    cdn_domains: set[str] = set()
+    for url_key in (CONF_CSS_URL, CONF_JS_URL):
+        url = config.get(url_key, "")
+        if url:
+            try:
+                parsed = urlparse(url)
+                if parsed.netloc:
+                    cdn_domains.add(parsed.netloc.lower())
+            except Exception:  # pylint: disable=broad-except
+                pass
+
+    # Generate defines for each CDN domain (used by captive_portal DNS allowlist)
+    for i, domain in enumerate(sorted(cdn_domains)):
+        cg.add_define(f"WEBSERVER_CDN_DOMAIN_{i}", domain)
+    cg.add_define("WEBSERVER_CDN_DOMAIN_COUNT", len(cdn_domains))
+
     if (sorting_group_config := config.get(CONF_SORTING_GROUPS)) is not None:
         cg.add_define("USE_WEBSERVER_SORTING")
         add_sorting_groups(var, sorting_group_config)

esphome/components/web_server/web_server.cpp

@@ -24,6 +24,10 @@
 #include "esphome/components/logger/logger.h"
 #endif
 
+#ifdef USE_CAPTIVE_PORTAL
+#include "esphome/components/captive_portal/captive_portal.h"
+#endif
+
 #ifdef USE_CLIMATE
 #include "esphome/components/climate/climate.h"
 #endif
@@ -413,7 +417,10 @@ void WebServer::dump_config() {
                 "  Address: %s:%u",
                 network::get_use_address(), this->base_->get_port());
 }
-float WebServer::get_setup_priority() const { return setup_priority::WIFI - 1.0f; }
+float WebServer::get_setup_priority() const {
+  // Run before WiFi so handlers are registered before captive_portal
+  return setup_priority::WIFI + 0.5f;
+}
 
 #ifdef USE_WEBSERVER_LOCAL
 void WebServer::handle_index_request(AsyncWebServerRequest *request) {
@@ -1959,9 +1966,20 @@ bool WebServer::canHandle(AsyncWebServerRequest *request) const {
   const auto &url = request->url();
   const auto method = request->method();
 
-  // Static URL checks
+  // Handle root URL
+  if (url == ESPHOME_F("/")) {
+#ifdef USE_CAPTIVE_PORTAL
+    // When captive portal is active, only handle "/" if ?web_server param is present
+    // This lets captive_portal show its page at "/" while web_server handles /?web_server
+    if (captive_portal::global_captive_portal != nullptr && captive_portal::global_captive_portal->is_active()) {
+      return request->hasParam(ESPHOME_F("web_server"));
+    }
+#endif
+    return true;
+  }
+
+  // Other static URL checks
   static const char *const STATIC_URLS[] = {
-    "/",
 #if !defined(USE_ESP32) && defined(USE_ARDUINO)
     "/events",
 #endif

esphome/components/web_server_base/web_server_base.cpp

@@ -12,8 +12,6 @@ static const char *const TAG = "web_server_base";
 WebServerBase *global_web_server_base = nullptr;  // NOLINT(cppcoreguidelines-avoid-non-const-global-variables)
 
 void WebServerBase::add_handler(AsyncWebHandler *handler) {
-  // remove all handlers
-
 #ifdef USE_WEBSERVER_AUTH
   if (!credentials_.username.empty()) {
     handler = new internal::AuthMiddlewareHandler(handler, &credentials_);

esphome/components/wifi/wifi_component.cpp

@@ -414,9 +414,6 @@ void WiFiComponent::setup() {
   if (this->enable_on_boot_) {
     this->start();
   } else {
-#ifdef USE_ESP32
-    esp_netif_init();
-#endif
     this->state_ = WIFI_COMPONENT_STATE_DISABLED;
   }
 }

esphome/components/wifi/wifi_component_esp_idf.cpp

@@ -137,11 +137,6 @@ void WiFiComponent::wifi_pre_setup_() {
     get_mac_address_raw(mac);
     set_mac_address(mac);
   }
-  esp_err_t err = esp_netif_init();
-  if (err != ERR_OK) {
-    ESP_LOGE(TAG, "esp_netif_init failed: %s", esp_err_to_name(err));
-    return;
-  }
   s_wifi_event_group = xEventGroupCreate();
   if (s_wifi_event_group == nullptr) {
     ESP_LOGE(TAG, "xEventGroupCreate failed");
@@ -153,11 +148,7 @@ void WiFiComponent::wifi_pre_setup_() {
     ESP_LOGE(TAG, "xQueueCreate failed");
     return;
   }
-  err = esp_event_loop_create_default();
-  if (err != ERR_OK) {
-    ESP_LOGE(TAG, "esp_event_loop_create_default failed: %s", esp_err_to_name(err));
-    return;
-  }
+  esp_err_t err;
   esp_event_handler_instance_t instance_wifi_id, instance_ip_id;
   err = esp_event_handler_instance_register(WIFI_EVENT, ESP_EVENT_ANY_ID, &event_handler, nullptr, &instance_wifi_id);
   if (err != ERR_OK) {

esphome/core/progmem.h

@@ -10,9 +10,11 @@
 #define ESPHOME_PGM_P PGM_P
 #define ESPHOME_strncpy_P strncpy_P
 #define ESPHOME_strncat_P strncat_P
+#define ESPHOME_strcasecmp_P strcasecmp_P
 #else
 #define ESPHOME_F(string_literal) (string_literal)
 #define ESPHOME_PGM_P const char *
 #define ESPHOME_strncpy_P strncpy
 #define ESPHOME_strncat_P strncat
+#define ESPHOME_strcasecmp_P strcasecmp
 #endif

esphome/coroutine.py

@@ -67,14 +67,14 @@ class CoroPriority(enum.IntEnum):
     # Examples: esp32, esp8266, rp2040
     PLATFORM = 1000
 
-    # Network infrastructure setup
-    # Examples: network (201)
-    NETWORK = 201
-
     # Network transport layer
     # Examples: async_tcp (200)
     NETWORK_TRANSPORT = 200
 
+    # Network infrastructure setup - must run after CORE which adds 'using namespace esphome;'
+    # Examples: network (99)
+    NETWORK = 99
+
     # Core system components
     # Examples: esphome core, most entity base components (cover, update, datetime,
     # valve, alarm_control_panel, lock, event, binary_sensor, button, climate, fan,

tests/unit_tests/test_coroutine.py

@@ -8,9 +8,9 @@ from esphome.coroutine import CoroPriority, FakeEventLoop, coroutine_with_priori
 def test_coro_priority_enum_values() -> None:
     """Test that CoroPriority enum values match expected priorities."""
     assert CoroPriority.PLATFORM == 1000
-    assert CoroPriority.NETWORK == 201
     assert CoroPriority.NETWORK_TRANSPORT == 200
     assert CoroPriority.CORE == 100
+    assert CoroPriority.NETWORK == 99
     assert CoroPriority.DIAGNOSTICS == 90
     assert CoroPriority.STATUS == 80
     assert CoroPriority.WEB_SERVER_BASE == 65
@@ -70,9 +70,9 @@ def test_float_and_enum_are_interchangeable() -> None:
     ("enum_value", "float_value"),
     [
         (CoroPriority.PLATFORM, 1000.0),
-        (CoroPriority.NETWORK, 201.0),
         (CoroPriority.NETWORK_TRANSPORT, 200.0),
         (CoroPriority.CORE, 100.0),
+        (CoroPriority.NETWORK, 99.0),
         (CoroPriority.DIAGNOSTICS, 90.0),
         (CoroPriority.STATUS, 80.0),
         (CoroPriority.WEB_SERVER_BASE, 65.0),
@@ -169,10 +169,10 @@ def test_mixed_float_and_enum_priorities() -> None:
 
 def test_enum_priority_comparison() -> None:
     """Test that enum priorities can be compared directly."""
-    assert CoroPriority.PLATFORM > CoroPriority.NETWORK
-    assert CoroPriority.NETWORK > CoroPriority.NETWORK_TRANSPORT
+    assert CoroPriority.PLATFORM > CoroPriority.NETWORK_TRANSPORT
     assert CoroPriority.NETWORK_TRANSPORT > CoroPriority.CORE
-    assert CoroPriority.CORE > CoroPriority.DIAGNOSTICS
+    assert CoroPriority.CORE > CoroPriority.NETWORK
+    assert CoroPriority.NETWORK > CoroPriority.DIAGNOSTICS
     assert CoroPriority.DIAGNOSTICS > CoroPriority.STATUS
     assert CoroPriority.STATUS > CoroPriority.WEB_SERVER_BASE
     assert CoroPriority.WEB_SERVER_BASE > CoroPriority.CAPTIVE_PORTAL