diff --git a/DECISIONS.md b/DECISIONS.md
index e907161..a7f95db 100644
--- a/DECISIONS.md
+++ b/DECISIONS.md
@@ -12,15 +12,28 @@
 - 2026-02-25 m+git@andri.dk — Added `github.com/andybalholm/brotli` (pure Go, zero transitive runtime deps) for brotli decompression in CSS injection. First third-party dependency — warranted because brotli is the dominant encoding for HTML on modern CDNs and the stdlib has no brotli support.
 - 2026-02-25 m+git@andri.dk — WebSocket upgrade supported for both ws:// and wss://. Upgrade headers are re-added after hop-by-hop stripping, then bidirectional copy bridges client and upstream after 101.
 - 2026-02-25 m+git@andri.dk — Cert cache has no eviction. Certs are generated with 24h validity. Acceptable for personal use.
-- 2026-02-26 m+git@andri.dk — Element hiding via HTML element replacement instead of CSS `display: none` injection. Matched elements are replaced with `<div><!-- ublproxy: replaced .selector --></div>` using `golang.org/x/net/html` tokenizer. This strips ad content (scripts, iframes, images) from the DOM, reducing page weight. Complex selectors (descendant/sibling combinators, `:has()`, `:not()`) fall back to CSS injection.
-- 2026-02-26 m+git@andri.dk — Added `golang.org/x/net` (zero transitive runtime deps, Go team maintained) for HTML tokenization in element replacement. Selectors are classified at cache time into simple (single-element matchable) and complex (needs CSS fallback).
+- 2026-02-26 m+git@andri.dk — ~~Element hiding via HTML element replacement.~~ Superseded: element hiding is now CSS-only (see 2026-02-26 entry below).
+- 2026-02-26 m+git@andri.dk — Added `golang.org/x/net` (zero transitive runtime deps, Go team maintained) for HTML tokenization in src-based resource stripping.
 - 2026-02-26 m+git@andri.dk — Blocked CONNECT requests return 403 Forbidden instead of 204 No Content. Browsers hang on 204 because they expect a tunnel; 403 makes them fail fast.
 - 2026-02-26 m+git@andri.dk — Removed Playwright from the project. Playwright's screenshot and snapshot commands wait for `document.fonts.ready`, which never resolves when the MITM proxy blocks ad-network domains that serve fonts. curl is a better fit for proxy testing.
 - 2026-02-26 m+git@andri.dk — Re-added playwright-cli for browser testing. Previous HTTPS timeouts were caused by environment variable configuration not being picked up. Fixed by using a declarative config file (`playwright-cli-proxy.json`) with `contextOptions.ignoreHTTPSErrors` and `contextOptions.proxy` instead of env vars.
 - 2026-02-26 m+git@andri.dk — Elements that load external resources (script, iframe, object, embed) are stripped during HTML rewriting when their resource URL resolves to a blocked address. Defense-in-depth alongside network-level blocking: stripping the element from the DOM prevents the browser from attempting the load. `srcBlockableTags` maps tag name to URL attribute (`src` for most, `data` for object). Void elements (embed) skip the `skipUntilClose` step. Relative and protocol-relative URLs are resolved against the page origin. Inline scripts (no `src`) are not affected.
 - 2026-02-26 m+git@andri.dk — Disabled HTTP/2 on upstream transport (`TLSNextProto` set to empty map). Go's default `http.Transport` negotiates HTTP/2 via ALPN, which caused indefinite hangs on certain Cloudflare-hosted domains (`s3-bm-adtech.berlingskemedia.net`, `s3-common-jscdn.berlingskemedia.net`). The proxy serializes requests over HTTP/1.1 on the client side, so HTTP/2 multiplexing provides no benefit. Forcing HTTP/1.1 upstream eliminates the hang and matches what most MITM proxies do.
 - 2026-02-26 m+git@andri.dk — Preserve original attribute case in HTML rewriting. `golang.org/x/net/html.Tokenizer.Raw()` returns reconstructed HTML with lowercased attribute names after `TagAttr()` is called. This broke React hydration on SSR sites (e.g. `charSet` → `charset`, `viewBox` → `viewbox`). Fix: save `Raw()` output before consuming attributes and use the saved bytes for pass-through writes.
-- 2026-02-26 m+git@andri.dk — CSS injection for all element hiding selectors, not just complex ones. Previously simple selectors only got element replacement; complex selectors only got CSS injection. Now all selectors get `display: none !important` CSS (blocks JS-injected ads), and simple selectors also get element replacement (strips content from the DOM). Defense-in-depth: CSS hides immediately, replacement removes entirely.
+- 2026-02-26 m+git@andri.dk — ~~CSS injection + element replacement for all element hiding selectors.~~ Superseded: element hiding is now CSS-only (see 2026-02-26 entry below).
 - 2026-02-26 m+git@andri.dk — Resource type detection for adblock content-type options (`$script`, `$image`, `$stylesheet`, `$xmlhttprequest`, `$subdocument`, `$media`, `$font`, `$object`, `$websocket`, `$document`). Previously these options were silently ignored, causing rules like `/adengine.js$script` to block all request types instead of just scripts — over-blocking that breaks sites. Detection uses `Sec-Fetch-Dest` header (primary, all modern browsers), `Accept` header heuristics (fallback), and URL file extension (last resort). Unknown resource type (no signal available) matches any type constraint for backward compatibility. `$popup` is parsed but not enforceable at proxy level (fails open). `$generichide` deferred to follow-up.
 - 2026-02-26 m+git@andri.dk — `-blocklist` flag supports remote URLs (`http://`, `https://`) in addition to local file paths. Downloaded once at startup using a dedicated `http.Client` with 30-second timeout. No caching or periodic refresh — same semantics as local files. Refactored `LoadFile` to use `LoadReader(io.Reader)` so all loading paths share the same line-by-line parsing. Go's `http.DefaultTransport` handles gzip decompression transparently.
 - 2026-02-26 m+git@andri.dk — Benchmarked `ShouldBlockRequest` with full EasyList (89K lines, 55K hostnames, 9K URL rules). Results on Apple M3: non-blocked URL 64µs, blocked-by-hostname 1.6µs, blocked-by-domain-rule 45µs, blocked-by-generic-rule 58µs. Zero allocations. No optimization needed — rule matching adds <1% to page load time.
+- 2026-02-26 m+git@andri.dk — Added `modernc.org/sqlite` (pure Go, no CGO) for persistent storage of passkey credentials, sessions, and user-created blocking rules. Binary grows ~7MB (9MB → 16MB). Chose pure-Go over CGO SQLite to keep zero C compiler requirement.
+- 2026-02-26 m+git@andri.dk — Added `fxamacker/cbor/v2` (minimal, zero transitive deps) for CBOR decoding in WebAuthn attestation parsing. Only ES256 (P-256 ECDSA) with "none" attestation is supported — covers all modern passkey authenticators.
+- 2026-02-26 m+git@andri.dk — Passkey (WebAuthn) authentication with no usernames or passwords. A credential IS the user identity. The credential ID is the foreign key for sessions and rules. Open registration — anyone on the network can register a passkey. Trust boundary is the network.
+- 2026-02-26 m+git@andri.dk — Minimal WebAuthn server implementation using stdlib crypto + fxamacker/cbor instead of a full WebAuthn library. Server generates challenges (crypto/rand), parses CBOR attestation objects to extract COSE public keys, and verifies ECDSA signatures. ~250 lines vs thousands in go-webauthn/webauthn.
+- 2026-02-26 m+git@andri.dk — Dual-port architecture: HTTP proxy on port 8080 (unchanged), HTTPS portal on port 8443 (new). WebAuthn requires a secure context (HTTPS), and LAN clients access the proxy from non-localhost IPs. The portal's TLS cert is signed by the proxy's own CA, which clients already trust.
+- 2026-02-26 m+git@andri.dk — Session-token auth for the rule management API. Portal issues a Bearer token after passkey authentication. Tokens are 32 bytes from crypto/rand, stored in SQLite with 30-day expiry. The injected script (future phase) will embed the token in a closure to prevent third-party page scripts from accessing it.
+- 2026-02-26 m+git@andri.dk — Bootstrap script injected inline into every HTML response (not as external `<script src>`). Avoids CSP issues on strict sites and removes the need to intercept `/__ublproxy__/` paths on arbitrary domains. The bootstrap is ~40 lines, minified into an IIFE. Keyboard shortcut: Alt+Shift+B.
+- 2026-02-26 m+git@andri.dk — Client IP → session token mapping (`sessionMap`) for script injection. When a user authenticates on the portal, their session token is associated with their client IP. The proxy looks up the token when injecting the bootstrap script. Simple and correct for home/office LAN proxy where each device has a unique IP. No session = no script injection.
+- 2026-02-26 m+git@andri.dk — The full element picker UI is lazy-loaded via `fetch()` from the portal's `/api/picker.js` endpoint when the user presses Alt+Shift+B. The picker code is executed with `new Function()` to keep portal URL and session token in scope. Auth is required (Bearer token in header), preventing unauthorized access to the picker code.
+- 2026-02-26 m+git@andri.dk — Element picker UI uses Shadow DOM (closed mode) to isolate styles from the host page. All picker CSS lives inside the shadow root, preventing conflicts in both directions. The highlight overlay uses `position:fixed` with `pointer-events:none` and `document.elementFromPoint()` for hover detection.
+- 2026-02-26 m+git@andri.dk — CSS selector generation priority: `#id` > `.class` (if unique) > `tag.class` > `tag[attr]` > parent path with `nth-child`. Prefers short selectors that match adblock element hiding syntax. Uses `CSS.escape()` for safety with special characters in IDs and class names.
+- 2026-02-26 m+git@andri.dk — Rule hot-reload via `atomic.Pointer[blocklist.RuleSet]`. When a user creates, deletes, or toggles a rule via the API, the full RuleSet is rebuilt from static blocklists + all enabled database rules, then atomically swapped. Readers never block. Rebuilds are serialized with a mutex to prevent concurrent rebuilds. The API handler triggers reloads via a callback (`onRulesChanged`) fired asynchronously in a goroutine so the HTTP response isn't delayed.
+- 2026-02-26 m+git@andri.dk — Element hiding is now CSS-only (`display: none !important`). Previously, simple selectors also stripped matched elements from the DOM via HTML tokenizer rewriting. This caused blank pages when generic EasyList selectors (e.g. `##[data-ad-cls]`, `##.ad-banner`) matched direct children of `<body>` that were legitimate page wrappers. CSS-only hiding matches browser adblocker behavior (uBlock Origin uses CSS for element hiding). Src-based stripping of `script`/`iframe`/`object`/`embed` with blocked URLs is kept — these load external resources and stripping them prevents the browser from even attempting the request. Deleted `SelectorMatch`, `ClassifySelector`, `matchesAny`, `matchesAnyWithAttrs` and related dead code.
diff --git a/connect.go b/connect.go
index 41b0139..41d1c62 100644
--- a/connect.go
+++ b/connect.go
@@ -17,7 +17,8 @@ func (p *proxyHandler) handleConnect(w http.ResponseWriter, r *http.Request) {
 		host = r.Host
 		port = "443"
 	}
-	if p.rules.IsHostBlocked(host) {
+	rules := p.getRules()
+	if rules != nil && rules.IsHostBlocked(host) {
 		http.Error(w, "blocked", http.StatusForbidden)
 		return
 	}
@@ -44,7 +45,9 @@ func (p *proxyHandler) handleConnect(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	// TLS handshake with the client, presenting our dynamic cert
+	// TLS handshake with the client, presenting our dynamic cert.
+	// Set a deadline to prevent slow/malicious clients from tying up goroutines.
+	clientConn.SetDeadline(time.Now().Add(10 * time.Second))
 	tlsClientConn := tls.Server(clientConn, &tls.Config{
 		Certificates: []tls.Certificate{*tlsCert},
 	})
@@ -54,13 +57,18 @@ func (p *proxyHandler) handleConnect(w http.ResponseWriter, r *http.Request) {
 	}
 	defer tlsClientConn.Close()
 
-	p.proxyTLSRequests(tlsClientConn, host, port)
+	// Clear the deadline after successful handshake
+	clientConn.SetDeadline(time.Time{})
+
+	// Extract client IP for script injection (from the original CONNECT request)
+	cIP, _, _ := net.SplitHostPort(r.RemoteAddr)
+	p.proxyTLSRequests(tlsClientConn, host, port, cIP)
 }
 
 // proxyTLSRequests reads HTTP requests from the intercepted client TLS
 // connection and forwards them to the upstream server. Supports keep-alive
 // by looping until the client closes the connection or an error occurs.
-func (p *proxyHandler) proxyTLSRequests(clientTLS *tls.Conn, host, port string) {
+func (p *proxyHandler) proxyTLSRequests(clientTLS *tls.Conn, host, port, clientIP string) {
 	clientReader := bufio.NewReader(clientTLS)
 
 	for {
@@ -77,7 +85,8 @@ func (p *proxyHandler) proxyTLSRequests(clientTLS *tls.Conn, host, port string)
 		// URL-level blocking for pattern rules (hostname was already
 		// checked at CONNECT time; this catches path-specific rules)
 		ctx := matchContextFromRequest(req)
-		if p.rules.ShouldBlockRequest(targetURL, ctx) {
+		rules := p.getRules()
+		if rules != nil && rules.ShouldBlockRequest(targetURL, ctx) {
 			req.Body.Close()
 			blocked := &http.Response{
 				StatusCode: http.StatusNoContent,
@@ -133,7 +142,7 @@ func (p *proxyHandler) proxyTLSRequests(clientTLS *tls.Conn, host, port string)
 
 		// Replace ad elements in HTML responses (skip HEAD — no body to modify)
 		if req.Method != http.MethodHead {
-			if modified, ok := p.applyElementHiding(resp, host); ok {
+			if modified, ok := p.applyElementHiding(resp, host, clientIP); ok {
 				resp.Body.Close()
 				resp.Body = io.NopCloser(bytes.NewReader(modified))
 				resp.ContentLength = int64(len(modified))
diff --git a/elemhide_inject.go b/elemhide_inject.go
index 9ca02c6..348343a 100644
--- a/elemhide_inject.go
+++ b/elemhide_inject.go
@@ -3,9 +3,10 @@ package main
 import (
 	"bytes"
 	"compress/gzip"
-	"fmt"
+	htmlpkg "html"
 	"io"
 	"net/http"
+	"regexp"
 	"strings"
 
 	"github.com/andybalholm/brotli"
@@ -14,6 +15,10 @@ import (
 	"ublproxy/pkg/blocklist"
 )
 
+// styleCloseRe matches </style in any case — used to prevent XSS via
+// user-created CSS rules that contain a closing </style> tag.
+var styleCloseRe = regexp.MustCompile(`(?i)</style`)
+
 // voidElements are HTML elements that have no closing tag.
 var voidElements = map[string]bool{
 	"area": true, "base": true, "br": true, "col": true,
@@ -55,29 +60,36 @@ func (sc srcBlockContext) resolveSrc(src string) string {
 	return sc.scheme + "://" + sc.host + "/" + src
 }
 
-// applyElementHiding checks if the response is HTML and applies element hiding
-// and src-based stripping if applicable. Matched elements are replaced with
-// placeholder divs; complex selectors that can't be matched on a single element
-// fall back to CSS injection. Elements that load external resources (script,
-// iframe, object, embed) whose URL resolves to a blocked address are stripped.
+// applyElementHiding checks if the response is HTML and applies CSS-based
+// element hiding, src-based resource stripping, and bootstrap script injection.
+// Elements that load external resources (script, iframe, object, embed) whose
+// URL resolves to a blocked address are stripped from the DOM. All other element
+// hiding selectors are applied via CSS display:none injection only — content
+// elements are never removed from the DOM to avoid stripping legitimate page
+// content that happens to match generic selectors.
+// The bootstrap script for the element picker is injected when a session
+// exists for the client IP.
 // Returns the modified body and true, or nil and false if unmodified.
 // Handles gzip and brotli compressed responses transparently.
-func (p *proxyHandler) applyElementHiding(resp *http.Response, host string) ([]byte, bool) {
-	if p.rules == nil {
-		return nil, false
-	}
-
+func (p *proxyHandler) applyElementHiding(resp *http.Response, host, clientIP string) ([]byte, bool) {
 	contentType := resp.Header.Get("Content-Type")
 	if !strings.Contains(contentType, "text/html") {
 		return nil, false
 	}
 
-	eh := p.rules.ElementHidingForDomain(host)
+	var eh *blocklist.ElementHiding
+	var hasURLRules bool
+	rules := p.getRules()
+	if rules != nil {
+		eh = rules.ElementHidingForDomain(host)
+		hasURLRules = rules.HostCount() > 0 || rules.RuleCount() > 0
+	}
+
+	// Generate bootstrap script tag (empty string if no session)
+	scriptTag := p.bootstrapScriptTag(clientIP, host)
 
-	// Nothing to do if there are no element hiding rules and no URL rules
-	// that could match resource URLs on blockable elements.
-	hasURLRules := p.rules.HostCount() > 0 || p.rules.RuleCount() > 0
-	if eh == nil && !hasURLRules {
+	// Nothing to do if there are no rules AND no script to inject
+	if eh == nil && !hasURLRules && scriptTag == "" {
 		return nil, false
 	}
 
@@ -104,19 +116,21 @@ func (p *proxyHandler) applyElementHiding(resp *http.Response, host string) ([]b
 		return nil, false
 	}
 
-	var matchers []blocklist.SelectorMatch
-	if eh != nil {
-		matchers = eh.Matchers
-	}
-
-	sc := srcBlockContext{scheme: "https", host: host, rules: p.rules}
-	modified := replaceElements(body, matchers, sc)
+	sc := srcBlockContext{scheme: "https", host: host, rules: rules}
+	modified := stripBlockedResources(body, sc)
 
 	if eh != nil && eh.CSS != "" {
-		styleTag := []byte("<style>" + eh.CSS + "</style>")
+		// Sanitize CSS to prevent XSS via </style> injection
+		safeCSS := styleCloseRe.ReplaceAllString(eh.CSS, `<\/style`)
+		styleTag := []byte("<style>" + safeCSS + "</style>")
 		modified = injectStyleTag(modified, styleTag)
 	}
 
+	// Inject the bootstrap script for the element picker
+	if scriptTag != "" {
+		modified = injectBeforeClose(modified, []byte(scriptTag), []byte("</body>"), []byte("</html>"))
+	}
+
 	// Remove Content-Encoding since we send uncompressed to the client.
 	// The proxy-to-client hop is typically localhost so this is fine.
 	resp.Header.Del("Content-Encoding")
@@ -124,12 +138,23 @@ func (p *proxyHandler) applyElementHiding(resp *http.Response, host string) ([]b
 	return modified, true
 }
 
-// replaceElements uses the html tokenizer to walk through the HTML and replace
-// elements matching any of the simple selectors with placeholder divs.
-// It also strips elements (script, iframe, object, embed) whose resource URL
-// resolves to a blocked address.
-func replaceElements(src []byte, matchers []blocklist.SelectorMatch, sc srcBlockContext) []byte {
-	if len(matchers) == 0 && sc.rules == nil {
+// injectBeforeClose inserts content before the first found closing tag,
+// or appends if none is found. Tags are tried in order.
+func injectBeforeClose(htmlDoc, content []byte, tags ...[]byte) []byte {
+	for _, tag := range tags {
+		if idx := indexCaseInsensitive(htmlDoc, tag); idx >= 0 {
+			return insertAt(htmlDoc, content, idx)
+		}
+	}
+	return append(htmlDoc, content...)
+}
+
+// stripBlockedResources uses the HTML tokenizer to walk through the HTML and
+// strip elements (script, iframe, object, embed) whose external resource URL
+// resolves to a blocked address. Other elements are passed through unchanged —
+// element hiding for those is handled by CSS injection only.
+func stripBlockedResources(src []byte, sc srcBlockContext) []byte {
+	if sc.rules == nil {
 		return src
 	}
 
@@ -146,7 +171,6 @@ func replaceElements(src []byte, matchers []blocklist.SelectorMatch, sc srcBlock
 			if tokenizer.Err() == io.EOF {
 				return buf.Bytes()
 			}
-			// On error, append remaining raw bytes and return
 			buf.Write(tokenizer.Raw())
 			return buf.Bytes()
 
@@ -159,61 +183,32 @@ func replaceElements(src []byte, matchers []blocklist.SelectorMatch, sc srcBlock
 			// attribute names, which breaks React hydration.
 			rawBytes := copyBytes(tokenizer.Raw())
 
-			// For elements with a blockable resource URL (script, iframe,
-			// object, embed), check if the URL resolves to a blocked
-			// address before falling through to element hiding.
-			if urlAttr, blockable := srcBlockableTags[tagNameLower]; blockable && hasAttr && sc.rules != nil {
-				attrs := collectAttrs(tokenizer, hasAttr)
-				if urlVal, ok := attrs[urlAttr]; ok && urlVal != "" {
-					resolved := sc.resolveSrc(urlVal)
-					ctx := blocklist.MatchContext{PageDomain: sc.host}
-					if sc.rules.ShouldBlockRequest(resolved, ctx) {
-						replacement := fmt.Sprintf("<!-- ublproxy: blocked %s %s -->", tagNameLower, urlVal)
-						buf.WriteString(replacement)
-						if !voidElements[tagNameLower] {
-							skipUntilClose(tokenizer, tagNameLower)
-						}
-						continue
-					}
-				}
-				// Not blocked — check element hiding with pre-collected attrs
-				if matched, selector := matchesAnyWithAttrs(tagNameLower, attrs, matchers); matched {
-					replacement := fmt.Sprintf("<div><!-- ublproxy: replaced %s --></div>", selector)
-					buf.WriteString(replacement)
-					if !voidElements[tagNameLower] {
-						skipUntilClose(tokenizer, tagNameLower)
-					}
-					continue
-				}
+			urlAttr, blockable := srcBlockableTags[tagNameLower]
+			if !blockable || !hasAttr {
 				buf.Write(rawBytes)
 				continue
 			}
 
-			if matched, selector := matchesAny(tagNameLower, tokenizer, hasAttr, matchers); matched {
-				replacement := fmt.Sprintf("<div><!-- ublproxy: replaced %s --></div>", selector)
-				buf.WriteString(replacement)
-
-				if voidElements[tagNameLower] {
-					continue
-				}
-				skipUntilClose(tokenizer, tagNameLower)
+			attrs := collectAttrs(tokenizer, hasAttr)
+			urlVal, ok := attrs[urlAttr]
+			if !ok || urlVal == "" {
+				buf.Write(rawBytes)
 				continue
 			}
 
-			buf.Write(rawBytes)
-
-		case html.SelfClosingTagToken:
-			tn, hasAttr := tokenizer.TagName()
-			tagNameLower := strings.ToLower(string(tn))
-			rawBytes := copyBytes(tokenizer.Raw())
-
-			if matched, selector := matchesAny(tagNameLower, tokenizer, hasAttr, matchers); matched {
-				replacement := fmt.Sprintf("<div><!-- ublproxy: replaced %s --></div>", selector)
-				buf.WriteString(replacement)
+			resolved := sc.resolveSrc(urlVal)
+			ctx := blocklist.MatchContext{PageDomain: sc.host}
+			if !sc.rules.ShouldBlockRequest(resolved, ctx) {
+				buf.Write(rawBytes)
 				continue
 			}
 
-			buf.Write(rawBytes)
+			// HTML-encode the URL to prevent breaking out of the comment
+			replacement := "<!-- ublproxy: blocked " + tagNameLower + " " + htmlpkg.EscapeString(urlVal) + " -->"
+			buf.WriteString(replacement)
+			if !voidElements[tagNameLower] {
+				skipUntilClose(tokenizer, tagNameLower)
+			}
 
 		default:
 			buf.Write(tokenizer.Raw())
@@ -221,58 +216,6 @@ func replaceElements(src []byte, matchers []blocklist.SelectorMatch, sc srcBlock
 	}
 }
 
-// matchesAny checks if the current element matches any of the simple selectors.
-// Collects attributes lazily from the tokenizer on first need.
-// Returns true and the matched selector string, or false.
-func matchesAny(tagName string, tokenizer *html.Tokenizer, hasAttr bool, matchers []blocklist.SelectorMatch) (bool, string) {
-	var attrs map[string]string
-
-	for i := range matchers {
-		sm := &matchers[i]
-
-		if sm.Tag != "" && sm.Tag != tagName {
-			continue
-		}
-
-		if attrs == nil {
-			attrs = collectAttrs(tokenizer, hasAttr)
-		}
-
-		attrFn := func(name string) string {
-			return attrs[name]
-		}
-
-		if sm.MatchesAttrs(tagName, attrFn) {
-			return true, sm.Selector
-		}
-	}
-
-	return false, ""
-}
-
-// matchesAnyWithAttrs checks if the element matches any selector using
-// a pre-collected attribute map. Used when attributes were already read
-// from the tokenizer (e.g. for script src checking).
-func matchesAnyWithAttrs(tagName string, attrs map[string]string, matchers []blocklist.SelectorMatch) (bool, string) {
-	for i := range matchers {
-		sm := &matchers[i]
-
-		if sm.Tag != "" && sm.Tag != tagName {
-			continue
-		}
-
-		attrFn := func(name string) string {
-			return attrs[name]
-		}
-
-		if sm.MatchesAttrs(tagName, attrFn) {
-			return true, sm.Selector
-		}
-	}
-
-	return false, ""
-}
-
 // copyBytes returns a copy of b. The tokenizer's Raw() returns a slice into
 // an internal buffer that is overwritten on the next call, so we must copy.
 func copyBytes(b []byte) []byte {
diff --git a/http.go b/http.go
index 890e72c..3e61515 100644
--- a/http.go
+++ b/http.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"io"
+	"net"
 	"net/http"
 	"net/url"
 	"time"
@@ -9,6 +10,15 @@ import (
 	"ublproxy/pkg/blocklist"
 )
 
+// clientIPFromRequest extracts the IP address from the request's RemoteAddr.
+func clientIPFromRequest(r *http.Request) string {
+	host, _, err := net.SplitHostPort(r.RemoteAddr)
+	if err != nil {
+		return r.RemoteAddr
+	}
+	return host
+}
+
 // Headers that must not be forwarded between hops.
 // https://www.rfc-editor.org/rfc/rfc2616#section-13.5.1
 var hopByHopHeaders = []string{
@@ -24,7 +34,8 @@ var hopByHopHeaders = []string{
 
 func (p *proxyHandler) handleHTTP(w http.ResponseWriter, r *http.Request) {
 	ctx := matchContextFromRequest(r)
-	if p.rules.ShouldBlockRequest(r.URL.String(), ctx) {
+	rules := p.getRules()
+	if rules != nil && rules.ShouldBlockRequest(r.URL.String(), ctx) {
 		w.WriteHeader(http.StatusNoContent)
 		return
 	}
@@ -57,7 +68,7 @@ func (p *proxyHandler) handleHTTP(w http.ResponseWriter, r *http.Request) {
 
 	// Replace ad elements in HTML responses (skip HEAD — no body to modify)
 	if r.Method != http.MethodHead {
-		if modified, ok := p.applyElementHiding(resp, r.URL.Hostname()); ok {
+		if modified, ok := p.applyElementHiding(resp, r.URL.Hostname(), clientIPFromRequest(r)); ok {
 			copyHeaders(w.Header(), resp.Header)
 			removeHopByHopHeaders(w.Header())
 			w.Header().Del("Content-Length")
diff --git a/pkg/blocklist/elemhide.go b/pkg/blocklist/elemhide.go
index 9d7c8eb..a351457 100644
--- a/pkg/blocklist/elemhide.go
+++ b/pkg/blocklist/elemhide.go
@@ -5,6 +5,12 @@ import (
 	"sync"
 )
 
+// ElementHiding holds the CSS for hiding ad elements on a specific domain.
+// All selectors are combined into a single display:none stylesheet.
+type ElementHiding struct {
+	CSS string // display:none CSS for all selectors (may be empty)
+}
+
 // ElementHideRule represents a CSS element hiding rule from an adblock filter.
 type ElementHideRule struct {
 	Selector       string   // CSS selector (e.g. ".ad-banner")
@@ -121,10 +127,9 @@ func (idx *elemHideIndex) isExcepted(selector, domain string) bool {
 	return false
 }
 
-// ElementHidingForDomain returns the element hiding data for the given domain,
-// with selectors classified into simple matchers (for element replacement) and
-// a CSS fallback string (for complex selectors). Results are cached.
-// Safe to call on a nil receiver (returns nil).
+// ElementHidingForDomain returns the element hiding CSS for the given domain.
+// All applicable selectors are combined into a single display:none stylesheet.
+// Results are cached. Safe to call on a nil receiver (returns nil).
 func (rs *RuleSet) ElementHidingForDomain(domain string) *ElementHiding {
 	if rs == nil || rs.elemHideIdx == nil {
 		return nil
@@ -142,8 +147,7 @@ func (rs *RuleSet) ElementHidingForDomain(domain string) *ElementHiding {
 }
 
 func (rs *RuleSet) computeElementHiding(domain string) *ElementHiding {
-	var matchers []SelectorMatch
-	var allSelectors []string
+	var selectors []string
 
 	for _, rule := range rs.elemHideRules {
 		if rule.Exception || !rule.appliesTo(domain) {
@@ -152,22 +156,13 @@ func (rs *RuleSet) computeElementHiding(domain string) *ElementHiding {
 		if rs.elemHideIdx.isExcepted(rule.Selector, domain) {
 			continue
 		}
-
-		allSelectors = append(allSelectors, rule.Selector)
-
-		if sm := ClassifySelector(rule.Selector); sm != nil {
-			matchers = append(matchers, *sm)
-		}
+		selectors = append(selectors, rule.Selector)
 	}
 
-	if len(allSelectors) == 0 {
+	if len(selectors) == 0 {
 		return nil
 	}
 
-	css := strings.Join(allSelectors, ",\n") + " {\n  display: none !important;\n}\n"
-
-	return &ElementHiding{
-		Matchers: matchers,
-		CSS:      css,
-	}
+	css := strings.Join(selectors, ",\n") + " {\n  display: none !important;\n}\n"
+	return &ElementHiding{CSS: css}
 }
diff --git a/pkg/blocklist/elemhide_test.go b/pkg/blocklist/elemhide_test.go
index 2d8399c..1be1c61 100644
--- a/pkg/blocklist/elemhide_test.go
+++ b/pkg/blocklist/elemhide_test.go
@@ -7,17 +7,11 @@ import (
 	"ublproxy/pkg/blocklist"
 )
 
-// selectorPresent returns true if the selector appears in either the matchers
-// or the CSS.
+// selectorPresent returns true if the selector appears in the CSS.
 func selectorPresent(eh *blocklist.ElementHiding, sel string) bool {
 	if eh == nil {
 		return false
 	}
-	for _, m := range eh.Matchers {
-		if m.Selector == sel {
-			return true
-		}
-	}
 	return strings.Contains(eh.CSS, sel)
 }
 
@@ -73,7 +67,7 @@ func TestElementHidingForDomain(t *testing.T) {
 	}
 }
 
-func TestElementHidingSimpleSelectors(t *testing.T) {
+func TestElementHidingCSS(t *testing.T) {
 	rs := blocklist.NewRuleSet()
 	rs.AddLine("##.ad-banner")
 
@@ -82,23 +76,16 @@ func TestElementHidingSimpleSelectors(t *testing.T) {
 		t.Fatal("expected non-nil ElementHiding")
 	}
 
-	if len(eh.Matchers) != 1 {
-		t.Fatalf("expected 1 matcher, got %d", len(eh.Matchers))
-	}
-	if eh.Matchers[0].Selector != ".ad-banner" {
-		t.Errorf("matcher selector = %q, want %q", eh.Matchers[0].Selector, ".ad-banner")
-	}
 	if !strings.Contains(eh.CSS, ".ad-banner") {
-		t.Errorf("simple selector should also appear in CSS, got:\n%s", eh.CSS)
+		t.Errorf("selector should appear in CSS, got:\n%s", eh.CSS)
 	}
 	if !strings.Contains(eh.CSS, "display: none !important") {
 		t.Errorf("CSS should use 'display: none !important', got:\n%s", eh.CSS)
 	}
 }
 
-func TestElementHidingComplexFallback(t *testing.T) {
+func TestElementHidingComplexSelector(t *testing.T) {
 	rs := blocklist.NewRuleSet()
-	// Complex selector: has descendant combinator (space)
 	rs.AddLine("example.com##div .ad-child")
 
 	eh := rs.ElementHidingForDomain("example.com")
@@ -106,9 +93,6 @@ func TestElementHidingComplexFallback(t *testing.T) {
 		t.Fatal("expected non-nil ElementHiding")
 	}
 
-	if len(eh.Matchers) != 0 {
-		t.Errorf("expected 0 matchers for complex selector, got %d", len(eh.Matchers))
-	}
 	if !strings.Contains(eh.CSS, "div .ad-child") {
 		t.Errorf("complex selector should be in CSS, got:\n%s", eh.CSS)
 	}
diff --git a/pkg/blocklist/selector.go b/pkg/blocklist/selector.go
deleted file mode 100644
index 575d3ec..0000000
--- a/pkg/blocklist/selector.go
+++ /dev/null
@@ -1,367 +0,0 @@
-package blocklist
-
-import "strings"
-
-// AttrOp describes how to match an attribute value.
-type AttrOp int
-
-const (
-	AttrExists   AttrOp = iota // [attr]
-	AttrEquals                 // [attr=val]
-	AttrContains               // [attr*=val]
-	AttrPrefix                 // [attr^=val]
-	AttrSuffix                 // [attr$=val]
-)
-
-// AttrMatch represents a single attribute condition in a selector.
-type AttrMatch struct {
-	Name  string
-	Value string
-	Op    AttrOp
-}
-
-// SelectorMatch holds parsed match criteria for a simple CSS selector that
-// can be evaluated by inspecting a single HTML element's attributes.
-type SelectorMatch struct {
-	Selector string      // original selector string (e.g. "div.ad-banner")
-	Tag      string      // required tag name, empty = any (lowercased)
-	ID       string      // required id, empty = no id constraint
-	Classes  []string    // all required classes
-	Attrs    []AttrMatch // attribute conditions beyond id/class
-}
-
-// ElementHiding holds the selectors applicable to a domain. All selectors
-// produce CSS (display: none !important) to hide elements immediately and
-// block JS-injected ads. Simple selectors also produce Matchers for
-// element replacement, physically stripping matched content from the HTML.
-type ElementHiding struct {
-	Matchers []SelectorMatch // simple selectors for element replacement
-	CSS      string          // display:none CSS for all selectors (may be empty)
-}
-
-// Empty returns true if there are no selectors to apply.
-func (eh *ElementHiding) Empty() bool {
-	return len(eh.Matchers) == 0 && eh.CSS == ""
-}
-
-// MatchesAttrs returns true if the element's attributes satisfy all the
-// conditions in this SelectorMatch.
-func (sm *SelectorMatch) MatchesAttrs(tagName string, attrFn func(string) string) bool {
-	if sm.Tag != "" && sm.Tag != tagName {
-		return false
-	}
-
-	if sm.ID != "" {
-		if attrFn("id") != sm.ID {
-			return false
-		}
-	}
-
-	if len(sm.Classes) > 0 {
-		classAttr := attrFn("class")
-		if classAttr == "" {
-			return false
-		}
-		classes := splitClasses(classAttr)
-		for _, want := range sm.Classes {
-			if !containsString(classes, want) {
-				return false
-			}
-		}
-	}
-
-	for _, am := range sm.Attrs {
-		val := attrFn(am.Name)
-		switch am.Op {
-		case AttrExists:
-			// attrFn returns "" for missing attributes, but also for
-			// attributes with empty values. We need the caller to
-			// distinguish, but for practical adblock selectors [attr]
-			// checks (like [href]) this is sufficient — an empty href
-			// is still present.
-			// We rely on the caller passing a function that returns a
-			// sentinel for missing attributes. For simplicity, we skip
-			// AttrExists matching here and handle it in the tokenizer.
-		case AttrEquals:
-			if val != am.Value {
-				return false
-			}
-		case AttrContains:
-			if !strings.Contains(val, am.Value) {
-				return false
-			}
-		case AttrPrefix:
-			if !strings.HasPrefix(val, am.Value) {
-				return false
-			}
-		case AttrSuffix:
-			if !strings.HasSuffix(val, am.Value) {
-				return false
-			}
-		}
-	}
-
-	return true
-}
-
-// ClassifySelector attempts to parse a CSS selector into a SelectorMatch.
-// Returns nil if the selector is too complex to match on a single element
-// (descendant/child/sibling combinators, pseudo-classes like :has(), :not()).
-func ClassifySelector(selector string) *SelectorMatch {
-	s := strings.TrimSpace(selector)
-	if s == "" {
-		return nil
-	}
-
-	// Reject selectors with combinators or pseudo-classes that need DOM context.
-	// We check for spaces (descendant combinator) but must be careful not to
-	// reject attribute selectors that contain spaces in values like
-	// DIV[style="padding: 20px 0; text-align: center;"]
-	if containsUnquotedSpace(s) {
-		return nil
-	}
-	if strings.ContainsAny(s, "+~") {
-		return nil
-	}
-	if strings.Contains(s, ":has(") || strings.Contains(s, ":not(") {
-		return nil
-	}
-	// Reject any pseudo-class/pseudo-element except attribute selectors
-	if containsUnbracketedColon(s) {
-		return nil
-	}
-	// Reject child combinator ">"
-	if containsUnbracketedChar(s, '>') {
-		return nil
-	}
-
-	sm := &SelectorMatch{Selector: selector}
-
-	if !parseSimpleSelector(s, sm) {
-		return nil
-	}
-
-	// Must have at least one constraint
-	if sm.Tag == "" && sm.ID == "" && len(sm.Classes) == 0 && len(sm.Attrs) == 0 {
-		return nil
-	}
-
-	return sm
-}
-
-// parseSimpleSelector parses a compound selector like "div.foo#bar[attr=val]"
-// into the SelectorMatch. Returns false if parsing fails.
-func parseSimpleSelector(s string, sm *SelectorMatch) bool {
-	i := 0
-	n := len(s)
-
-	// Parse optional leading tag name (before any . # or [)
-	if i < n && s[i] != '.' && s[i] != '#' && s[i] != '[' {
-		start := i
-		for i < n && s[i] != '.' && s[i] != '#' && s[i] != '[' {
-			i++
-		}
-		sm.Tag = strings.ToLower(s[start:i])
-	}
-
-	// Parse chain of .class, #id, and [attr] selectors
-	for i < n {
-		switch s[i] {
-		case '#':
-			i++
-			start := i
-			for i < n && s[i] != '.' && s[i] != '#' && s[i] != '[' {
-				i++
-			}
-			if start == i {
-				return false
-			}
-			sm.ID = s[start:i]
-
-		case '.':
-			i++
-			start := i
-			for i < n && s[i] != '.' && s[i] != '#' && s[i] != '[' {
-				i++
-			}
-			if start == i {
-				return false
-			}
-			sm.Classes = append(sm.Classes, s[start:i])
-
-		case '[':
-			end := findMatchingBracket(s, i)
-			if end < 0 {
-				return false
-			}
-			inner := s[i+1 : end]
-			am, ok := parseAttrSelector(inner)
-			if !ok {
-				return false
-			}
-			sm.Attrs = append(sm.Attrs, am)
-			i = end + 1
-
-		default:
-			return false
-		}
-	}
-
-	return true
-}
-
-// parseAttrSelector parses the inside of [...], e.g. class*="advertisement"
-func parseAttrSelector(inner string) (AttrMatch, bool) {
-	inner = strings.TrimSpace(inner)
-	if inner == "" {
-		return AttrMatch{}, false
-	}
-
-	// Find operator position
-	opIdx := strings.IndexAny(inner, "=*^$")
-	if opIdx < 0 {
-		// [attr] — existence check
-		return AttrMatch{Name: strings.ToLower(inner), Op: AttrExists}, true
-	}
-
-	var op AttrOp
-	var nameEnd int
-
-	switch {
-	case inner[opIdx] == '=' && (opIdx == 0 || (inner[opIdx-1] != '*' && inner[opIdx-1] != '^' && inner[opIdx-1] != '$')):
-		op = AttrEquals
-		nameEnd = opIdx
-	case opIdx > 0 && inner[opIdx] == '*' && opIdx+1 < len(inner) && inner[opIdx+1] == '=':
-		op = AttrContains
-		nameEnd = opIdx
-		opIdx++ // skip past =
-	case opIdx > 0 && inner[opIdx] == '^' && opIdx+1 < len(inner) && inner[opIdx+1] == '=':
-		op = AttrPrefix
-		nameEnd = opIdx
-		opIdx++ // skip past =
-	case opIdx > 0 && inner[opIdx] == '$' && opIdx+1 < len(inner) && inner[opIdx+1] == '=':
-		op = AttrSuffix
-		nameEnd = opIdx
-		opIdx++ // skip past =
-	default:
-		return AttrMatch{}, false
-	}
-
-	name := strings.TrimSpace(strings.ToLower(inner[:nameEnd]))
-	value := strings.TrimSpace(inner[opIdx+1:])
-	value = unquote(value)
-
-	return AttrMatch{Name: name, Value: value, Op: op}, true
-}
-
-// findMatchingBracket finds the ] that closes the [ at position start,
-// respecting quoted strings inside the brackets.
-func findMatchingBracket(s string, start int) int {
-	inQuote := byte(0)
-	for i := start + 1; i < len(s); i++ {
-		if inQuote != 0 {
-			if s[i] == inQuote {
-				inQuote = 0
-			}
-			continue
-		}
-		if s[i] == '"' || s[i] == '\'' {
-			inQuote = s[i]
-			continue
-		}
-		if s[i] == ']' {
-			return i
-		}
-	}
-	return -1
-}
-
-// unquote removes surrounding single or double quotes from a string.
-func unquote(s string) string {
-	if len(s) >= 2 {
-		if (s[0] == '"' && s[len(s)-1] == '"') || (s[0] == '\'' && s[len(s)-1] == '\'') {
-			return s[1 : len(s)-1]
-		}
-	}
-	return s
-}
-
-// containsUnquotedSpace returns true if s contains a space that is not inside
-// brackets [...]. Spaces inside brackets are part of attribute values.
-func containsUnquotedSpace(s string) bool {
-	depth := 0
-	inQuote := byte(0)
-	for i := 0; i < len(s); i++ {
-		if inQuote != 0 {
-			if s[i] == inQuote {
-				inQuote = 0
-			}
-			continue
-		}
-		switch s[i] {
-		case '"', '\'':
-			inQuote = s[i]
-		case '[':
-			depth++
-		case ']':
-			if depth > 0 {
-				depth--
-			}
-		case ' ':
-			if depth == 0 {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// containsUnbracketedColon returns true if s contains a colon that is not
-// inside brackets [...].
-func containsUnbracketedColon(s string) bool {
-	return containsUnbracketedChar(s, ':')
-}
-
-// containsUnbracketedChar returns true if s contains the given character
-// outside of brackets [...] and quotes.
-func containsUnbracketedChar(s string, ch byte) bool {
-	depth := 0
-	inQuote := byte(0)
-	for i := 0; i < len(s); i++ {
-		if inQuote != 0 {
-			if s[i] == inQuote {
-				inQuote = 0
-			}
-			continue
-		}
-		switch s[i] {
-		case '"', '\'':
-			inQuote = s[i]
-		case '[':
-			depth++
-		case ']':
-			if depth > 0 {
-				depth--
-			}
-		default:
-			if s[i] == ch && depth == 0 {
-				return true
-			}
-		}
-	}
-	return false
-}
-
-// splitClasses splits a class attribute value into individual class names.
-func splitClasses(classAttr string) []string {
-	return strings.Fields(classAttr)
-}
-
-func containsString(ss []string, s string) bool {
-	for _, v := range ss {
-		if v == s {
-			return true
-		}
-	}
-	return false
-}
diff --git a/pkg/blocklist/selector_test.go b/pkg/blocklist/selector_test.go
deleted file mode 100644
index ece5cbb..0000000
--- a/pkg/blocklist/selector_test.go
+++ /dev/null
@@ -1,207 +0,0 @@
-package blocklist
-
-import (
-	"testing"
-)
-
-func TestClassifySelector_Simple(t *testing.T) {
-	tests := []struct {
-		selector string
-		wantTag  string
-		wantID   string
-		classes  []string
-		attrs    int // number of attribute matchers
-	}{
-		{".ad-banner", "", "", []string{"ad-banner"}, 0},
-		{"#sidebar-ad", "", "sidebar-ad", nil, 0},
-		{"div.ad-banner", "div", "", []string{"ad-banner"}, 0},
-		{"DIV.ad-banner", "div", "", []string{"ad-banner"}, 0},
-		{".su-column.su-column-1-3", "", "", []string{"su-column", "su-column-1-3"}, 0},
-		{"div#banner", "div", "banner", nil, 0},
-		{"aside", "aside", "", nil, 0},
-		{"OBJECT[width=\"300\"]", "object", "", nil, 1},
-		{"div[class*=\"advertisement\"]", "div", "", nil, 1},
-		{"div[class^=\"ad\"]", "div", "", nil, 1},
-		{"[id*=\"HeaderAd\"]", "", "", nil, 1},
-		{"A[href^=\"/framework/resources/forms/ads.aspx\"]", "a", "", nil, 1},
-		{".row.ad", "", "", []string{"row", "ad"}, 0},
-		{"div[id*=\"advImg\"]", "div", "", nil, 1},
-		{"IMG[src=\"/thumb/550x200/53d278ef882dd.jpg\"]", "img", "", nil, 1},
-		{"[href^=\"/is/moya/adverts/\"]", "", "", nil, 1},
-		{"[id^=\"box_aitem\"]", "", "", nil, 1},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.selector, func(t *testing.T) {
-			sm := ClassifySelector(tt.selector)
-			if sm == nil {
-				t.Fatalf("ClassifySelector(%q) = nil, want non-nil", tt.selector)
-			}
-			if sm.Tag != tt.wantTag {
-				t.Errorf("Tag = %q, want %q", sm.Tag, tt.wantTag)
-			}
-			if sm.ID != tt.wantID {
-				t.Errorf("ID = %q, want %q", sm.ID, tt.wantID)
-			}
-			if len(sm.Classes) != len(tt.classes) {
-				t.Errorf("Classes = %v, want %v", sm.Classes, tt.classes)
-			} else {
-				for i, c := range tt.classes {
-					if sm.Classes[i] != c {
-						t.Errorf("Classes[%d] = %q, want %q", i, sm.Classes[i], c)
-					}
-				}
-			}
-			if len(sm.Attrs) != tt.attrs {
-				t.Errorf("Attrs count = %d, want %d", len(sm.Attrs), tt.attrs)
-			}
-		})
-	}
-}
-
-func TestClassifySelector_Complex(t *testing.T) {
-	// These should all return nil (too complex for single-element matching)
-	complex := []string{
-		"div[class^=\"col-\"]:has([class*=\"advertisement-spot-\"])",
-		"div > .ad",
-		".parent .child",
-		"div + span",
-		"div ~ span",
-		":not(.ad)",
-		"div:first-child",
-		"div:nth-child(2)",
-		"", // empty
-	}
-
-	for _, sel := range complex {
-		t.Run(sel, func(t *testing.T) {
-			sm := ClassifySelector(sel)
-			if sm != nil {
-				t.Errorf("ClassifySelector(%q) = %+v, want nil (complex)", sel, sm)
-			}
-		})
-	}
-}
-
-func TestClassifySelector_AttrWithSpaces(t *testing.T) {
-	// Attribute values with spaces should NOT be rejected as having
-	// descendant combinators
-	sel := `DIV[style="padding: 20px 0; text-align: center;"]`
-	sm := ClassifySelector(sel)
-	if sm == nil {
-		t.Fatalf("ClassifySelector(%q) = nil, want non-nil", sel)
-	}
-	if sm.Tag != "div" {
-		t.Errorf("Tag = %q, want %q", sm.Tag, "div")
-	}
-	if len(sm.Attrs) != 1 {
-		t.Fatalf("Attrs count = %d, want 1", len(sm.Attrs))
-	}
-	if sm.Attrs[0].Op != AttrEquals {
-		t.Errorf("Op = %v, want AttrEquals", sm.Attrs[0].Op)
-	}
-	if sm.Attrs[0].Value != "padding: 20px 0; text-align: center;" {
-		t.Errorf("Value = %q, want %q", sm.Attrs[0].Value, "padding: 20px 0; text-align: center;")
-	}
-}
-
-func TestSelectorMatch_MatchesAttrs(t *testing.T) {
-	sm := ClassifySelector("div.ad-banner#main")
-	if sm == nil {
-		t.Fatal("expected non-nil SelectorMatch")
-	}
-
-	attrFn := func(name string) string {
-		switch name {
-		case "id":
-			return "main"
-		case "class":
-			return "ad-banner featured"
-		}
-		return ""
-	}
-
-	if !sm.MatchesAttrs("div", attrFn) {
-		t.Error("expected match for div.ad-banner#main")
-	}
-
-	// Wrong tag
-	if sm.MatchesAttrs("span", attrFn) {
-		t.Error("expected no match for span")
-	}
-
-	// Wrong id
-	wrongID := func(name string) string {
-		if name == "id" {
-			return "other"
-		}
-		if name == "class" {
-			return "ad-banner"
-		}
-		return ""
-	}
-	if sm.MatchesAttrs("div", wrongID) {
-		t.Error("expected no match for wrong id")
-	}
-
-	// Missing class
-	missingClass := func(name string) string {
-		if name == "id" {
-			return "main"
-		}
-		if name == "class" {
-			return "featured"
-		}
-		return ""
-	}
-	if sm.MatchesAttrs("div", missingClass) {
-		t.Error("expected no match for missing class")
-	}
-}
-
-func TestSelectorMatch_AttrContains(t *testing.T) {
-	sm := ClassifySelector(`div[class*="advertisement"]`)
-	if sm == nil {
-		t.Fatal("expected non-nil")
-	}
-
-	match := func(name string) string {
-		if name == "class" {
-			return "some-advertisement-box"
-		}
-		return ""
-	}
-	if !sm.MatchesAttrs("div", match) {
-		t.Error("expected match")
-	}
-
-	noMatch := func(name string) string {
-		if name == "class" {
-			return "ad-box"
-		}
-		return ""
-	}
-	if sm.MatchesAttrs("div", noMatch) {
-		t.Error("expected no match")
-	}
-}
-
-func TestSelectorMatch_AttrPrefix(t *testing.T) {
-	sm := ClassifySelector(`[id^="box_aitem"]`)
-	if sm == nil {
-		t.Fatal("expected non-nil")
-	}
-
-	match := func(name string) string {
-		if name == "id" {
-			return "box_aitem_123"
-		}
-		return ""
-	}
-	if !sm.MatchesAttrs("div", match) {
-		t.Error("expected match")
-	}
-	if !sm.MatchesAttrs("span", match) {
-		t.Error("expected match with any tag")
-	}
-}
diff --git a/proxy.go b/proxy.go
index 36bd667..9fc9bfa 100644
--- a/proxy.go
+++ b/proxy.go
@@ -2,29 +2,95 @@ package main
 
 import (
 	"crypto/tls"
+	"fmt"
 	"net/http"
+	"os"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
 
 	"ublproxy/pkg/blocklist"
+	"ublproxy/pkg/store"
 )
 
 type proxyHandler struct {
-	certs     *certCache
-	caCertPEM []byte
-	rules     *blocklist.RuleSet
-	transport *http.Transport
+	certs        *certCache
+	caCertPEM    []byte
+	rules        atomic.Pointer[blocklist.RuleSet]
+	transport    *http.Transport
+	store        *store.Store
+	api          *apiHandler
+	sessions     *sessionMap
+	portalOrigin string
+
+	// blocklistSources are the static blocklist file paths/URLs loaded at
+	// startup. Needed to rebuild the RuleSet when user rules change.
+	blocklistSources []string
+
+	// reloadMu serializes rule reloads to prevent concurrent rebuilds.
+	reloadMu sync.Mutex
 }
 
 func newProxyHandler(certs *certCache, caCertPEM []byte, rules *blocklist.RuleSet) *proxyHandler {
-	return &proxyHandler{
+	p := &proxyHandler{
 		certs:     certs,
 		caCertPEM: caCertPEM,
-		rules:     rules,
 		// Force HTTP/1.1 upstream. Go's default HTTP/2 support causes hangs
 		// with certain Cloudflare hosts in a MITM proxy scenario.
 		transport: &http.Transport{
-			TLSNextProto: make(map[string]func(authority string, c *tls.Conn) http.RoundTripper),
+			TLSNextProto:          make(map[string]func(authority string, c *tls.Conn) http.RoundTripper),
+			TLSHandshakeTimeout:   10 * time.Second,
+			ResponseHeaderTimeout: 60 * time.Second,
+			IdleConnTimeout:       90 * time.Second,
 		},
 	}
+	if rules != nil {
+		p.rules.Store(rules)
+	}
+	return p
+}
+
+// getRules returns the current RuleSet, or nil if none is loaded.
+func (p *proxyHandler) getRules() *blocklist.RuleSet {
+	return p.rules.Load()
+}
+
+// reloadRules rebuilds the in-memory RuleSet from static blocklists and
+// user-created rules in the database. Called after any rule mutation.
+func (p *proxyHandler) reloadRules() {
+	p.reloadMu.Lock()
+	defer p.reloadMu.Unlock()
+
+	rs := blocklist.NewRuleSet()
+
+	// Reload static blocklists
+	for _, src := range p.blocklistSources {
+		var err error
+		if strings.HasPrefix(src, "http://") || strings.HasPrefix(src, "https://") {
+			err = rs.LoadURL(src)
+		} else {
+			err = rs.LoadFile(src)
+		}
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "reload: failed to load blocklist %s: %v\n", src, err)
+		}
+	}
+
+	// Add user-created rules from the database
+	if p.store != nil {
+		dbRules, err := p.store.ListAllEnabledRules()
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "reload: failed to load user rules: %v\n", err)
+		} else {
+			for _, r := range dbRules {
+				rs.AddLine(r.Rule)
+			}
+		}
+	}
+
+	// Atomic swap — all concurrent readers immediately see the new rules
+	p.rules.Store(rs)
 }
 
 func (p *proxyHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
diff --git a/proxy_test.go b/proxy_test.go
index 0538eed..3982462 100644
--- a/proxy_test.go
+++ b/proxy_test.go
@@ -15,14 +15,18 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"net/url"
+	"os"
+	"path/filepath"
 	"strconv"
 	"strings"
 	"sync/atomic"
 	"testing"
+	"time"
 
 	"github.com/andybalholm/brotli"
 
 	"ublproxy/pkg/blocklist"
+	"ublproxy/pkg/store"
 )
 
 // testEnv holds everything needed to run a proxy e2e test.
@@ -616,7 +620,7 @@ func TestThirdPartyOption(t *testing.T) {
 	}
 }
 
-func TestElementHidingReplacesElements(t *testing.T) {
+func TestElementHidingCSSInjection(t *testing.T) {
 	rs := blocklist.NewRuleSet()
 	rs.AddLine("##.ad-banner")
 	rs.AddLine("##.tracking-pixel")
@@ -625,7 +629,7 @@ func TestElementHidingReplacesElements(t *testing.T) {
 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
 		w.WriteHeader(http.StatusOK)
 		w.Write([]byte(`<html><head><title>Test</title></head><body>` +
-			`<div class="ad-banner"><script src="tracker.js"></script></div>` +
+			`<div class="ad-banner">Ad content</div>` +
 			`<img class="tracking-pixel" src="pixel.gif">` +
 			`<p>Real content</p>` +
 			`</body></html>`))
@@ -643,20 +647,23 @@ func TestElementHidingReplacesElements(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	// Matched elements should be replaced with placeholder divs
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .ad-banner -->") {
-		t.Errorf("response should contain replacement for .ad-banner, got:\n%s", bodyStr)
+	// CSS should be injected to hide matching elements
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("should contain injected style tag, got:\n%s", bodyStr)
 	}
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .tracking-pixel -->") {
-		t.Errorf("response should contain replacement for .tracking-pixel, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, ".ad-banner") {
+		t.Errorf("CSS should contain .ad-banner selector, got:\n%s", bodyStr)
 	}
-
-	// The original ad content (script tag, pixel image) should be stripped
-	if strings.Contains(bodyStr, "tracker.js") {
-		t.Errorf("ad content should be stripped, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, ".tracking-pixel") {
+		t.Errorf("CSS should contain .tracking-pixel selector, got:\n%s", bodyStr)
 	}
-	if strings.Contains(bodyStr, "pixel.gif") {
-		t.Errorf("tracking pixel should be stripped, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, "display: none !important") {
+		t.Errorf("CSS should use display:none, got:\n%s", bodyStr)
+	}
+
+	// Content elements should remain in DOM (hidden by CSS, not stripped)
+	if !strings.Contains(bodyStr, "Ad content") {
+		t.Errorf("ad element should remain in DOM (CSS hides it), got:\n%s", bodyStr)
 	}
 
 	// Non-ad content should be preserved
@@ -787,8 +794,11 @@ func TestElementHidingBrotli(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .ad-banner -->") {
-		t.Errorf("brotli HTML should have element replaced, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("brotli HTML should have CSS injected, got:\n%s", bodyStr)
+	}
+	if !strings.Contains(bodyStr, ".ad-banner") {
+		t.Errorf("CSS should contain .ad-banner selector, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "Hello") {
 		t.Errorf("non-ad content should be preserved, got:\n%s", bodyStr)
@@ -817,8 +827,11 @@ func TestElementHidingHTTPS(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .ad-banner -->") {
-		t.Errorf("HTTPS response should have element replaced, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("HTTPS response should have CSS injected, got:\n%s", bodyStr)
+	}
+	if !strings.Contains(bodyStr, ".ad-banner") {
+		t.Errorf("CSS should contain .ad-banner selector, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "Hello") {
 		t.Errorf("non-ad content should be preserved, got:\n%s", bodyStr)
@@ -853,15 +866,12 @@ func TestElementHidingNestedContent(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	// All nested content should be stripped
-	if strings.Contains(bodyStr, "ad.js") {
-		t.Errorf("nested script should be stripped, got:\n%s", bodyStr)
-	}
-	if strings.Contains(bodyStr, "ad-network.com") {
-		t.Errorf("nested iframe should be stripped, got:\n%s", bodyStr)
+	// Element hiding is CSS-only — container stays in DOM but is hidden
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("should contain CSS injection, got:\n%s", bodyStr)
 	}
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .ad-container -->") {
-		t.Errorf("should contain replacement comment, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, ".ad-container") {
+		t.Errorf("CSS should contain .ad-container selector, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "Keep this") {
 		t.Errorf("non-ad content should be preserved, got:\n%s", bodyStr)
@@ -893,23 +903,22 @@ func TestElementHidingVoidElement(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	if strings.Contains(bodyStr, "track.gif") {
-		t.Errorf("void element should be replaced, got:\n%s", bodyStr)
+	// Void element stays in DOM, hidden by CSS
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("should contain CSS injection, got:\n%s", bodyStr)
 	}
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .tracking-pixel -->") {
-		t.Errorf("should contain replacement comment, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, ".tracking-pixel") {
+		t.Errorf("CSS should contain .tracking-pixel selector, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "Content") {
 		t.Errorf("non-ad content should be preserved, got:\n%s", bodyStr)
 	}
 }
 
-func TestElementHidingComplexFallbackCSS(t *testing.T) {
+func TestElementHidingAllSelectorsCSS(t *testing.T) {
 	rs := blocklist.NewRuleSet()
-	// Complex selector (descendant combinator) — falls back to CSS
-	rs.AddLine("##div .ad-child")
-	// Simple selector — element replacement
-	rs.AddLine("##.ad-banner")
+	rs.AddLine("##div .ad-child") // complex selector
+	rs.AddLine("##.ad-banner")    // simple selector
 
 	upstream := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.Header().Set("Content-Type", "text/html; charset=utf-8")
@@ -932,20 +941,23 @@ func TestElementHidingComplexFallbackCSS(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	// Simple selector should be replaced
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .ad-banner -->") {
-		t.Errorf("simple selector should be replaced, got:\n%s", bodyStr)
-	}
-
-	// Complex selector should fall back to CSS injection
+	// Both simple and complex selectors should be in CSS
 	if !strings.Contains(bodyStr, "<style>") {
-		t.Errorf("complex selector should inject style tag, got:\n%s", bodyStr)
+		t.Errorf("should contain injected style tag, got:\n%s", bodyStr)
+	}
+	if !strings.Contains(bodyStr, ".ad-banner") {
+		t.Errorf("CSS should contain simple selector, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "div .ad-child") {
-		t.Errorf("fallback CSS should contain the complex selector, got:\n%s", bodyStr)
+		t.Errorf("CSS should contain complex selector, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "display: none !important") {
-		t.Errorf("fallback CSS should use display:none, got:\n%s", bodyStr)
+		t.Errorf("CSS should use display:none, got:\n%s", bodyStr)
+	}
+
+	// Content elements stay in DOM (CSS hides them)
+	if !strings.Contains(bodyStr, `class="ad-banner"`) {
+		t.Errorf("ad element should remain in DOM, got:\n%s", bodyStr)
 	}
 }
 
@@ -974,11 +986,16 @@ func TestElementHidingByID(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced #sidebar-ad -->") {
-		t.Errorf("element with matching ID should be replaced, got:\n%s", bodyStr)
+	// ID selector should be in CSS
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("should contain CSS injection, got:\n%s", bodyStr)
 	}
-	if strings.Contains(bodyStr, "sponsor.html") {
-		t.Errorf("ad content should be stripped, got:\n%s", bodyStr)
+	if !strings.Contains(bodyStr, "#sidebar-ad") {
+		t.Errorf("CSS should contain #sidebar-ad selector, got:\n%s", bodyStr)
+	}
+	// Element stays in DOM, hidden by CSS
+	if !strings.Contains(bodyStr, "sponsor.html") {
+		t.Errorf("ad element should remain in DOM (hidden by CSS), got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "Main") {
 		t.Errorf("non-ad content should be preserved, got:\n%s", bodyStr)
@@ -1010,8 +1027,12 @@ func TestElementHidingAttributeSelector(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	if !strings.Contains(bodyStr, `<!-- ublproxy: replaced div[class*="advertisement"] -->`) {
-		t.Errorf("attribute selector should match, got:\n%s", bodyStr)
+	// Attribute selector should be in CSS
+	if !strings.Contains(bodyStr, `div[class*="advertisement"]`) {
+		t.Errorf("CSS should contain attribute selector, got:\n%s", bodyStr)
+	}
+	if !strings.Contains(bodyStr, "display: none !important") {
+		t.Errorf("CSS should use display:none, got:\n%s", bodyStr)
 	}
 	if !strings.Contains(bodyStr, "Keep") {
 		t.Errorf("non-matching content should be preserved, got:\n%s", bodyStr)
@@ -1228,14 +1249,17 @@ func TestScriptStrippingWithElementHiding(t *testing.T) {
 	body, _ := io.ReadAll(resp.Body)
 	bodyStr := string(body)
 
-	// Script should be stripped via URL blocking
+	// Script should be stripped via URL blocking (src-based)
 	if !strings.Contains(bodyStr, "<!-- ublproxy: blocked script") {
 		t.Errorf("blocked script should be stripped, got:\n%s", bodyStr)
 	}
 
-	// Element hiding should also work
-	if !strings.Contains(bodyStr, "<!-- ublproxy: replaced .ad-banner -->") {
-		t.Errorf("element hiding should still work, got:\n%s", bodyStr)
+	// Element hiding should be CSS-only
+	if !strings.Contains(bodyStr, "<style>") {
+		t.Errorf("should contain CSS injection for element hiding, got:\n%s", bodyStr)
+	}
+	if !strings.Contains(bodyStr, ".ad-banner") {
+		t.Errorf("CSS should contain .ad-banner selector, got:\n%s", bodyStr)
 	}
 
 	if !strings.Contains(bodyStr, "Content") {
@@ -1719,6 +1743,185 @@ func TestAllBlockableElementsTogether(t *testing.T) {
 	}
 }
 
+// --- Hot-reload tests ---
+
+func TestReloadRulesPicksUpUserRules(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "reload.db")
+	db, err := store.Open(dbPath)
+	if err != nil {
+		t.Fatalf("Open store: %v", err)
+	}
+	t.Cleanup(func() { db.Close() })
+
+	// Create a credential and a rule in the database
+	if err := db.SaveCredential("test-cred", []byte("test-pubkey")); err != nil {
+		t.Fatalf("SaveCredential: %v", err)
+	}
+	if _, err := db.CreateRule("test-cred", "/ads/*", ""); err != nil {
+		t.Fatalf("CreateRule: %v", err)
+	}
+
+	caCert, caKey, err := generateCA()
+	if err != nil {
+		t.Fatalf("generateCA: %v", err)
+	}
+	handler := newProxyHandler(newCertCache(caCert, caKey), encodeCertPEM(caCert), nil)
+	handler.store = db
+
+	// Before reload — no rules loaded
+	if rules := handler.getRules(); rules != nil {
+		t.Errorf("before reload: getRules() should be nil, got non-nil")
+	}
+
+	// Reload rules — should pick up the user rule from the database
+	handler.reloadRules()
+
+	rules := handler.getRules()
+	if rules == nil {
+		t.Fatal("after reload: getRules() returned nil")
+	}
+
+	// The rule "/ads/*" should now be loaded
+	ctx := blocklist.MatchContext{}
+	if !rules.ShouldBlockRequest("http://example.com/ads/banner.gif", ctx) {
+		t.Error("after reload: /ads/banner.gif should be blocked")
+	}
+	if rules.ShouldBlockRequest("http://example.com/page.html", ctx) {
+		t.Error("after reload: /page.html should not be blocked")
+	}
+}
+
+func TestReloadRulesIncludesStaticBlocklists(t *testing.T) {
+	// Create a temporary blocklist file
+	tmpDir := t.TempDir()
+	blocklistPath := filepath.Join(tmpDir, "blocklist.txt")
+	os.WriteFile(blocklistPath, []byte("||blocked-host.example.com^\n"), 0644)
+
+	dbPath := filepath.Join(tmpDir, "reload.db")
+	db, err := store.Open(dbPath)
+	if err != nil {
+		t.Fatalf("Open store: %v", err)
+	}
+	t.Cleanup(func() { db.Close() })
+
+	// Add a user rule too
+	if err := db.SaveCredential("cred1", []byte("pubkey1")); err != nil {
+		t.Fatalf("SaveCredential: %v", err)
+	}
+	_, err = db.CreateRule("cred1", "##.user-ad", "")
+	if err != nil {
+		t.Fatalf("CreateRule: %v", err)
+	}
+
+	caCert, caKey, err := generateCA()
+	if err != nil {
+		t.Fatalf("generateCA: %v", err)
+	}
+	handler := newProxyHandler(newCertCache(caCert, caKey), encodeCertPEM(caCert), nil)
+	handler.store = db
+	handler.blocklistSources = []string{blocklistPath}
+
+	handler.reloadRules()
+
+	rules := handler.getRules()
+	if rules == nil {
+		t.Fatal("getRules() returned nil after reload")
+	}
+
+	// Static blocklist rule should be loaded
+	if !rules.IsHostBlocked("blocked-host.example.com") {
+		t.Error("static blocklist hostname should be blocked")
+	}
+
+	// User rule should also be loaded (element hiding rule)
+	eh := rules.ElementHidingForDomain("example.com")
+	if eh == nil || eh.CSS == "" {
+		t.Error("user element hiding rule should be loaded")
+	}
+}
+
+func TestAPIRuleMutationTriggersReload(t *testing.T) {
+	dbPath := filepath.Join(t.TempDir(), "callback.db")
+	db, err := store.Open(dbPath)
+	if err != nil {
+		t.Fatalf("Open store: %v", err)
+	}
+	t.Cleanup(func() { db.Close() })
+
+	sm := newSessionMap()
+	api := newAPIHandler(db, testAPIConfig, sm)
+
+	var reloadCount atomic.Int32
+	api.onRulesChanged = func() {
+		reloadCount.Add(1)
+	}
+
+	// Create a credential and session for authenticated requests
+	if err := db.SaveCredential("test-cred-cb", []byte("test-pubkey-cb")); err != nil {
+		t.Fatalf("SaveCredential: %v", err)
+	}
+	sess, err := db.CreateSession("test-cred-cb")
+	if err != nil {
+		t.Fatalf("CreateSession: %v", err)
+	}
+
+	// Create a rule — should trigger reload
+	rec := doRequest(t, api, "POST", "/api/rules", createRuleRequest{Rule: "##.ad", Domain: "example.com"}, sess.Token)
+	if rec.Code != http.StatusCreated {
+		t.Fatalf("create rule: status %d, body: %s", rec.Code, rec.Body.String())
+	}
+
+	// The reload is async (go a.onRulesChanged()), give it a moment
+	// But since we're in a test with a simple counter, it should complete quickly
+	for i := 0; i < 100; i++ {
+		if reloadCount.Load() >= 1 {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
+	if reloadCount.Load() < 1 {
+		t.Error("onRulesChanged should have been called after create")
+	}
+
+	// Extract rule ID for delete/patch
+	var created ruleResponse
+	decodeJSON(t, rec, &created)
+
+	// Patch rule — should trigger reload
+	rec = doRequest(t, api, "PATCH", fmt.Sprintf("/api/rules/%d", created.ID), patchRuleRequest{Enabled: boolPtr(false)}, sess.Token)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("patch rule: status %d, body: %s", rec.Code, rec.Body.String())
+	}
+
+	for i := 0; i < 100; i++ {
+		if reloadCount.Load() >= 2 {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
+	if reloadCount.Load() < 2 {
+		t.Error("onRulesChanged should have been called after patch")
+	}
+
+	// Delete rule — should trigger reload
+	rec = doRequest(t, api, "DELETE", fmt.Sprintf("/api/rules/%d", created.ID), nil, sess.Token)
+	if rec.Code != http.StatusOK {
+		t.Fatalf("delete rule: status %d, body: %s", rec.Code, rec.Body.String())
+	}
+
+	for i := 0; i < 100; i++ {
+		if reloadCount.Load() >= 3 {
+			break
+		}
+		time.Sleep(time.Millisecond)
+	}
+	if reloadCount.Load() < 3 {
+		t.Error("onRulesChanged should have been called after delete")
+	}
+}
+
+func boolPtr(b bool) *bool { return &b }
+
 // --- WebSocket test helpers ---
 
 // wsEchoHandler is a minimal WebSocket echo server using only stdlib.