@@ -6,6 +6,15 @@
 
 ## [Unreleased]
 
+## [v12.9.2-3946-pre]
+
+### Added
+- **FakeTLS TCP fragmentation:** ClientHello split into 5-byte TLS record header + body (30 ms delay) — DPI boxes waiting for a complete record no longer see SNI/ECH in the first segment.
+- **MTProxy mirrors:** jsDelivr + gitmirror CDN fallbacks before GitHub; DoH TXT resolver (Google/Cloudflare/Mozilla) for proxy lists; hardcoded seed placeholder.
+- **WS front / CF Worker support:** `WebSocketFrontTemplate`, `WebSocketEndpointPlanConfig`, `WebSocketEndpointPlanner.candidates(config:)` — planner now accepts operator-provided CF Worker front hostnames; HTTP `Host` header and TLS SNI use the front's own domain while cert validation stays on.
+- **WEB proxy catalog:** `WebProxyCatalog` with bootstrap + HTTPS directory fetch; "Choose WEB Proxy" sheet with catalog entries + "Enter manually…" fallback.
+- **WEB proxy background keepalive:** session PING sent from a `UIBackgroundTask` on entering background; active carrier with recent activity skips full rebuild on foreground resume.
+
 ## [v12.9.2-3945-pre] — 2026-09-03
 
 Pre-release: WEB hang/path recovery + Messages chrome nits.
 
@@ -24,27 +24,158 @@ public enum WebSocketDatacenter {
     public static func path(isTestingEnvironment: Bool) -> String {
         return isTestingEnvironment ? WebSocketDatacenter.testPath : WebSocketDatacenter.productionPath
     }
+
+    public static func foldedDatacenterId(_ datacenterId: Int) -> Int {
+        var dc = abs(datacenterId)
+        if dc == 203 {
+            dc = 2
+        }
+        return dc
+    }
+}
+
+/// Alternate front (CF Worker / custom origin) that terminates TLS on its own hostname and proxies
+/// WebSocket bytes to `kws{N}.web.telegram.org`. SNI on the phone is the front host — not Telegram.
+public struct WebSocketFrontTemplate: Equatable, Codable {
+    /// Connect host. May contain `"{dc}"`. Example: `"front.example.com"` or `"kws{dc}.front.example.com"`.
+    public var host: String
+    public var port: UInt16
+    /// Path. May contain `"{dc}"`. Example: `"/dc/{dc}/apiws"`. Trailing `/apiws` becomes `/apiws_test` in test env.
+    public var pathTemplate: String
+    public var httpHostTemplate: String?
+    public var tlsServerNameTemplate: String?
+
+    public init(host: String, port: UInt16 = 443, pathTemplate: String, httpHostTemplate: String? = nil, tlsServerNameTemplate: String? = nil) {
+        self.host = host
+        self.port = port
+        self.pathTemplate = pathTemplate
+        self.httpHostTemplate = httpHostTemplate
+        self.tlsServerNameTemplate = tlsServerNameTemplate
+    }
+}
+
+public enum WebSocketEndpointKind: Equatable {
+    case telegramGateway
+    case front
 }
 
 public struct WebSocketEndpointCandidate: Equatable {
     public let host: String
     public let port: UInt16
     public let path: String
+    public let httpHost: String
+    public let tlsServerName: String
+    public let kind: WebSocketEndpointKind
 
-    public init(host: String, port: UInt16 = 443, path: String) {
+    public init(host: String, port: UInt16 = 443, path: String, httpHost: String? = nil, tlsServerName: String? = nil, kind: WebSocketEndpointKind = .telegramGateway) {
         self.host = host
         self.port = port
         self.path = path
+        self.httpHost = httpHost ?? host
+        self.tlsServerName = tlsServerName ?? host
+        self.kind = kind
     }
 }
 
+public struct WebSocketEndpointPlanConfig: Equatable {
+    public enum Order: Equatable {
+        case frontsFirst
+        case telegramFirst
+    }
+
+    public var fronts: [WebSocketFrontTemplate]
+    public var order: Order
+
+    public init(fronts: [WebSocketFrontTemplate] = [], order: Order = .frontsFirst) {
+        self.fronts = fronts
+        self.order = order
+    }
+
+    public static let telegramOnly = WebSocketEndpointPlanConfig(fronts: [], order: .telegramFirst)
+}
+
+/// Hardcoded bootstrap fronts + directory URLs. Operator fills real Worker hostnames before shipping;
+/// empty templates keep the planner on Telegram gateways only.
+public enum WebSocketFrontBootstrap {
+    public static let templates: [WebSocketFrontTemplate] = [
+        // WebSocketFrontTemplate(host: "front.example.com", pathTemplate: "/dc/{dc}/apiws"),
+    ]
+
+    public static let directoryURLs: [String] = [
+        // "https://front.example.com/fronts.json",
+    ]
+}
+
 /// Combines `WebSocketDatacenter`'s hostname ordering and path selection into the ordered candidate
-/// list a connection attempt should walk through.
+/// list a connection attempt should walk through. Optional fronts (CF Worker) are tried first by default.
 public enum WebSocketEndpointPlanner {
-    public static func candidates(datacenterId: Int, isMedia: Bool, isTestingEnvironment: Bool) -> [WebSocketEndpointCandidate] {
+    public static func candidates(datacenterId: Int, isMedia: Bool, isTestingEnvironment: Bool, config: WebSocketEndpointPlanConfig = .telegramOnly) -> [WebSocketEndpointCandidate] {
+        let telegram = telegramCandidates(datacenterId: datacenterId, isMedia: isMedia, isTestingEnvironment: isTestingEnvironment)
+        let fronts = frontCandidates(datacenterId: datacenterId, isTestingEnvironment: isTestingEnvironment, templates: config.fronts)
+        let combined: [WebSocketEndpointCandidate]
+        switch config.order {
+        case .frontsFirst:
+            combined = fronts + telegram
+        case .telegramFirst:
+            combined = telegram + fronts
+        }
+        return dedupe(combined, limit: 8)
+    }
+
+    private static func telegramCandidates(datacenterId: Int, isMedia: Bool, isTestingEnvironment: Bool) -> [WebSocketEndpointCandidate] {
         let path = WebSocketDatacenter.path(isTestingEnvironment: isTestingEnvironment)
         return WebSocketDatacenter.hostnames(datacenterId: datacenterId, isMedia: isMedia).map {
-            WebSocketEndpointCandidate(host: $0, path: path)
+            WebSocketEndpointCandidate(host: $0, path: path, kind: .telegramGateway)
+        }
+    }
+
+    private static func frontCandidates(datacenterId: Int, isTestingEnvironment: Bool, templates: [WebSocketFrontTemplate]) -> [WebSocketEndpointCandidate] {
+        let dc = WebSocketDatacenter.foldedDatacenterId(datacenterId)
+        var result: [WebSocketEndpointCandidate] = []
+        for template in templates {
+            let host = expand(template.host, dc: dc)
+            guard !host.isEmpty else {
+                continue
+            }
+            var path = expand(template.pathTemplate, dc: dc)
+            if path.isEmpty {
+                path = WebSocketDatacenter.path(isTestingEnvironment: isTestingEnvironment)
+            } else if isTestingEnvironment {
+                path = path.replacingOccurrences(of: "/apiws_test", with: "/apiws")
+                if path.hasSuffix("/apiws") {
+                    path = String(path.dropLast("/apiws".count)) + WebSocketDatacenter.testPath
+                }
+            }
+            let httpHost = expand(template.httpHostTemplate ?? template.host, dc: dc)
+            let tlsName = expand(template.tlsServerNameTemplate ?? template.host, dc: dc)
+            result.append(WebSocketEndpointCandidate(
+                host: host,
+                port: template.port == 0 ? 443 : template.port,
+                path: path,
+                httpHost: httpHost.isEmpty ? host : httpHost,
+                tlsServerName: tlsName.isEmpty ? host : tlsName,
+                kind: .front
+            ))
+        }
+        return result
+    }
+
+    private static func expand(_ template: String, dc: Int) -> String {
+        return template.replacingOccurrences(of: "{dc}", with: "\(dc)")
+    }
+
+    private static func dedupe(_ candidates: [WebSocketEndpointCandidate], limit: Int) -> [WebSocketEndpointCandidate] {
+        var seen = Set<String>()
+        var out: [WebSocketEndpointCandidate] = []
+        for candidate in candidates {
+            let key = "\(candidate.host)|\(candidate.port)|\(candidate.path)"
+            if seen.insert(key).inserted {
+                out.append(candidate)
+                if out.count >= limit {
+                    break
+                }
+            }
         }
+        return out
     }
 }
@@ -38,13 +38,42 @@ final class WebSocketDatacenterMappingTests: XCTestCase {
     func testEndpointPlannerCombinesHostsAndPath() {
         let candidates = WebSocketEndpointPlanner.candidates(datacenterId: 4, isMedia: true, isTestingEnvironment: true)
         XCTAssertEqual(candidates, [
-            WebSocketEndpointCandidate(host: "kws4-1.web.telegram.org", path: "/apiws_test"),
-            WebSocketEndpointCandidate(host: "kws4.web.telegram.org", path: "/apiws_test"),
+            WebSocketEndpointCandidate(host: "kws4-1.web.telegram.org", path: "/apiws_test", kind: .telegramGateway),
+            WebSocketEndpointCandidate(host: "kws4.web.telegram.org", path: "/apiws_test", kind: .telegramGateway),
         ])
     }
 
     func testEndpointPlannerDefaultPortIs443() {
         let candidates = WebSocketEndpointPlanner.candidates(datacenterId: 1, isMedia: false, isTestingEnvironment: false)
         XCTAssertEqual(candidates.map { $0.port }, [443, 443])
     }
+
+    func testEndpointPlannerTelegramCandidatesHaveIdenticalHttpHostAndTlsName() {
+        let candidates = WebSocketEndpointPlanner.candidates(datacenterId: 2, isMedia: false, isTestingEnvironment: false)
+        for c in candidates {
+            XCTAssertEqual(c.httpHost, c.host)
+            XCTAssertEqual(c.tlsServerName, c.host)
+            XCTAssertEqual(c.kind, .telegramGateway)
+        }
+    }
+
+    func testEndpointPlannerFrontCandidateOverridesHttpHostAndSNI() {
+        let template = WebSocketFrontTemplate(
+            host: "worker.example.com",
+            port: 443,
+            pathTemplate: "/dc/{dc}/apiws",
+            httpHostTemplate: "worker.example.com",
+            tlsServerNameTemplate: "worker.example.com"
+        )
+        let config = WebSocketEndpointPlanConfig(fronts: [template], order: .frontsFirst)
+        let candidates = WebSocketEndpointPlanner.candidates(datacenterId: 1, isMedia: false, isTestingEnvironment: false, config: config)
+        guard let front = candidates.first else {
+            return XCTFail("expected front candidate first")
+        }
+        XCTAssertEqual(front.kind, .front)
+        XCTAssertEqual(front.httpHost, "worker.example.com")
+        XCTAssertEqual(front.tlsServerName, "worker.example.com")
+        // Remaining candidates are Telegram gateways
+        XCTAssertTrue(candidates.dropFirst().allSatisfy { $0.kind == .telegramGateway })
+    }
 }
@@ -1057,7 +1057,26 @@ - (void)start
                             _helloRandom = [[NSData alloc] initWithBytes:cHMAC length:CC_SHA256_DIGEST_LENGTH];
                             memcpy(((uint8_t *)helloData.mutableBytes) + 11, cHMAC, CC_SHA256_DIGEST_LENGTH);
 
-                            [strongSelf->_socket writeData:helloData];
+                            // TCP-split the FakeTLS ClientHello so a DPI midbox that waits for a
+                            // complete record does not see SNI/ECH in the first segment. HMAC was
+                            // already taken over the full record; fragments must concatenate to
+                            // those exact bytes (never emit a second TLS record header).
+                            static const NSUInteger kFakeTlsHelloFirstFragment = 5;
+                            static const NSTimeInterval kFakeTlsHelloFragmentDelay = 0.03;
+                            if (helloData.length > kFakeTlsHelloFirstFragment) {
+                                NSData *part0 = [helloData subdataWithRange:NSMakeRange(0, kFakeTlsHelloFirstFragment)];
+                                NSData *part1 = [helloData subdataWithRange:NSMakeRange(kFakeTlsHelloFirstFragment, helloData.length - kFakeTlsHelloFirstFragment)];
+                                [strongSelf->_socket writeData:part0];
+                                [[MTTcpConnection tcpQueue] dispatchAfter:kFakeTlsHelloFragmentDelay block:^{
+                                    __strong MTTcpConnection *innerSelf = strongSelf;
+                                    if (innerSelf == nil || innerSelf->_closed) {
+                                        return;
+                                    }
+                                    [innerSelf->_socket writeData:part1];
+                                }];
+                            } else {
+                                [strongSelf->_socket writeData:helloData];
+                            }
                             [strongSelf->_socket readDataToLength:5 withTimeout:-1 tag:MTTcpSocksReceiveHelloResponse];
                         } else {
                             strongSelf->_readyToSendData = true;
 
@@ -11,6 +11,7 @@ import PresentationDataUtils
 import AccountContext
 import ShareController
 import UrlEscaping
+import WebProxyTransport
 
 private final class ProxySettingsControllerArguments {
     let toggleEnabled: (Bool) -> Void
@@ -850,9 +851,53 @@ public func proxySettingsController(accountManager: AccountManager<TelegramAccou
                 actionSheet?.dismissAnimated()
                 addServer(.mtp)
             }),
-            ActionSheetButtonItem(title: ForkWebProxyStrings.proxyType, color: .accent, action: { [weak actionSheet] in
+            ActionSheetButtonItem(title: ForkWebProxyStrings.proxyType, color: .accent, action: { [weak actionSheet, weak strongController] in
                 actionSheet?.dismissAnimated()
-                addServer(.web)
+                // If there are catalog entries, offer a pick sheet; otherwise go straight to manual.
+                let bootstrap = WebProxyCatalog.bootstrapEntries
+                if bootstrap.isEmpty {
+                    addServer(.web)
+                    return
+                }
+                // Offer catalog + manual option.
+                WebProxyCatalog.load { entries in
+                    guard let controller = strongController else { return }
+                    let sheet = ActionSheetController(presentationData: presentationData)
+                    var items: [ActionSheetItem] = []
+                    for entry in entries {
+                        items.append(ActionSheetButtonItem(title: entry.title, color: .accent, action: { [weak sheet] in
+                            sheet?.dismissAnimated()
+                            guard let parsedSecret = MTProxySecret.parse(entry.secretHex),
+                                  isSupportedWebProxySecret(parsedSecret.serialize()) else {
+                                addServer(.web)
+                                return
+                            }
+                            let server = ProxyServerSettings(host: entry.host, port: 443, connection: .web(secret: parsedSecret.serialize()))
+                            let _ = updateProxySettingsInteractively(accountManager: accountManager, { current in
+                                var current = current
+                                if !current.servers.contains(server) {
+                                    current.servers.insert(server, at: 0)
+                                }
+                                current.activeServer = server
+                                current.enabled = true
+                                return current
+                            }).start()
+                        }))
+                    }
+                    items.append(ActionSheetButtonItem(title: ForkWebProxyStrings.catalogManual, color: .accent, action: { [weak sheet] in
+                        sheet?.dismissAnimated()
+                        addServer(.web)
+                    }))
+                    sheet.setItemGroups([
+                        ActionSheetItemGroup(items: items),
+                        ActionSheetItemGroup(items: [
+                            ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak sheet] in
+                                sheet?.dismissAnimated()
+                            })
+                        ])
+                    ])
+                    controller.present(sheet, in: .window(.root))
+                }
             })
         ]), ActionSheetItemGroup(items: [
             ActionSheetButtonItem(title: presentationData.strings.Common_Cancel, color: .accent, font: .bold, action: { [weak actionSheet] in
 
@@ -209,6 +209,8 @@ final class MTWebSocketConnectionInterface: NSObject, MTTcpConnectionInterface {
         private var endpointSelector: WebSocketEndpointSelector
         private var currentCandidateHost: String?
         private var currentCandidatePath: String?
+        private var currentCandidateHttpHost: String?
+        private var currentCandidateTlsServerName: String?
 
         private var handshakeState: HandshakeState = .tcpConnecting
         private var handshakeResponseBuffer = Data()
@@ -344,6 +346,8 @@ final class MTWebSocketConnectionInterface: NSObject, MTTcpConnectionInterface {
             self.readBufferOffset = 0
             self.currentCandidateHost = candidate.host
             self.currentCandidatePath = candidate.path
+            self.currentCandidateHttpHost = candidate.httpHost
+            self.currentCandidateTlsServerName = candidate.tlsServerName
 
             let host = NWEndpoint.Host(candidate.host)
             guard let port = NWEndpoint.Port(rawValue: candidate.port) else {
@@ -359,11 +363,15 @@ final class MTWebSocketConnectionInterface: NSObject, MTTcpConnectionInterface {
             tcpOptions.keepaliveInterval = 5
             tcpOptions.enableFastOpen = false
 
-            // Default sec_protocol_options: full certificate-chain + hostname validation, with SNI
-            // derived by Network.framework from `host`. Deliberately NOT weakened — see the "TLS /
-            // security" section of docs/websocket-transport.md for why tg-ws-proxy's CERT_NONE /
-            // check_hostname=False pattern was not ported.
+            // TLS SNI. For Telegram-gateway candidates, SNI is derived from `host` automatically.
+            // For CF-Worker / custom-front candidates, `tlsServerName` may differ from `host`
+            // (the Worker's own hostname) — use sec_protocol_options to override it while keeping
+            // full certificate-chain validation against that Worker cert (NOT weakened).
             let tlsOptions = NWProtocolTLS.Options()
+            let effectiveSNI = self.currentCandidateTlsServerName ?? candidate.host
+            if effectiveSNI != candidate.host {
+                sec_protocol_options_set_tls_server_name(tlsOptions.securityProtocolOptions, effectiveSNI)
+            }
 
             let parameters = NWParameters(tls: tlsOptions, tcp: tcpOptions)
             let connection = NWConnection(host: host, port: port, using: parameters)
@@ -449,10 +457,13 @@ final class MTWebSocketConnectionInterface: NSObject, MTTcpConnectionInterface {
             guard let connection = self.connection, let host = self.currentCandidateHost, let path = self.currentCandidatePath else {
                 return
             }
+            // HTTP Host header: for CF-Worker fronts this is the Worker domain (same as httpHost),
+            // not the Telegram gateway. For plain Telegram candidates they are identical.
+            let httpHost = self.currentCandidateHttpHost ?? host
 
             let key = Impl.makeSecWebSocketKey()
             var request = "GET \(path) HTTP/1.1\r\n"
-            request += "Host: \(host)\r\n"
+            request += "Host: \(httpHost)\r\n"
             request += "Upgrade: websocket\r\n"
             request += "Connection: Upgrade\r\n"
             request += "Sec-WebSocket-Key: \(key)\r\n"