diff --git a/.gitignore b/.gitignore
index 1b5e822..abb3d59 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,3 +13,10 @@ scripts/validate/.venv/
 # Note: assets/adblock/*.txt and assets/ubo-resources.json ARE committed so the
 # native ad blocker builds self-contained in CI (gen-adblock-dump.py needs them
 # at `make dir` time; there is no networked list-fetch step in the release job).
+
+# --- AI hybrid-build workflow scratch (local only, never pushed) ---
+# The Strong/Weak-AI playbook, the GROK.md handoff artifact it prescribes, and
+# the helper-agent directions/handoffs are working scratch — not repo content.
+AI cowork.md
+GROK.md
+docs/agents/
diff --git a/PLAN_OF_ACTION.md b/PLAN_OF_ACTION.md
index 3250b4a..8a49291 100644
--- a/PLAN_OF_ACTION.md
+++ b/PLAN_OF_ACTION.md
@@ -113,7 +113,7 @@ Shields panel). M4–M6 (farbling, picker, stripping) are unaffected.
 - **`$csp`**: wire `engine.get_csp_directives()` → inject via `nsIHttpChannel.setResponseHeader()`.
 - **domCollapser**: hide leftover placeholders (iframe/img/script) for blocked network resources.
 - **Live list updates**: today lists are dump-only (`rs-blocker.patch` + `gen-adblock-dump.py`) because network sync would *delete* the bundled dump. Add a safe periodic refresh that updates without tripping the sync-delete hazard (keep dump as offline fallback).
-- **Done when:** **>95% d3ward in a real GUI**, validated by the Part 2 harness — the headline goal.
+- **Done when:** **>95% on adblock.turtlecute.org in a real GUI** (d3ward was archived in 2026 — turtlecute is the maintained d3ward-style replacement), validated by the Part 2 harness — the headline goal. *Progress 2026-07-08: first live run scored 116/133 (87%); the 9 missed network hosts (TikTok ads APIs, Yahoo ad-tech, Yandex Metrika) are being closed by the bundled `neonwolf-extra` supplement list.*
 
 ### M3 — Shields panel + logger (give the engine a face and an audit trail)
 *The dead `neonwolf-shields.*` stub becomes a real per-site control surface.*
@@ -135,10 +135,14 @@ Shields panel). M4–M6 (farbling, picker, stripping) are unaffected.
 - **Highest rebase fragility** — these touch hot, frequently-refactored Gecko code. Mark accordingly in `patches/native/MANIFEST.md`; lean on `replace_or_die`-style fail-loud anchors so a bad rebase fails CI instead of silently shipping.
 - **Done when:** browserleaks shows site-varying canvas/audio/WebGL hashes; coveryourtracks reports no obvious "this is a privacy browser" tell.
 
+> **Progress 2026-07-08 (PR #20):** M4 shipped and validated as *FPP-forward farbling* — Firefox 152's native fingerprintingProtection (per-eTLD+1 + per-session deterministic canvas/WebGL noise, verified against a plain control) rather than from-scratch Gecko noise patches; RFP is off (mutually exclusive). WebGL required also disabling LibreWolf's hidden `librewolf.webgl.prompt` silent-deny gate. Dark mode unlocked (RFP was forcing light). Shields integration done: the fingerprinting toggle drives FPP, and a per-site "Farble on this site" row writes `-AllTargets` granular overrides to **both** the FPP and baseline tiers (canvas rides `privacy.baselineFingerprintingProtection`). Known gap: audio readback is NOT farbled (FPP has no audio noise target — that was RFP-only); a native audio-farbling patch is the remaining M4 item. CoverYourTracks: "strong protection against Web tracking".
+
 ### M5 — Element picker + custom filters (complete the uBO replacement)
 - **Element picker**: privileged browser chrome with an SVG highlight overlay, candidate filter generation (network URL + cosmetic selector), specificity/depth controls; write to user filter storage and rebuild the engine.
 - **Custom filters page** (`chrome://neonwolf/content/shields-filters.xhtml`): editable rules, validation, rebuild-on-save.
 
+> **Progress 2026-07-08:** element picker shipped with a uBO-style selector generator (unique-id fast path, stable-class paths, :nth-of-type disambiguation); custom-filters page shipped earlier (editor, lint, import/export); list subscriptions shipped end-to-end (lists-page manager UI + UBONetFilter fetching `neonwolf.shields.lists.subscriptions` on live refresh). M5 is functionally complete.
+
 ### M6 — Binary-level stripping (attack-surface reduction; sequenced last because it's destructive)
 *Convert "hidden + policy" into actually-not-compiled. Risky for build stability — do once features are stable.*
 
@@ -164,7 +168,7 @@ Shields panel). M4–M6 (farbling, picker, stripping) are unaffected.
 1. `make dir && make check-patchfail` — all patches (incl. `patches/native/*`) apply clean.
 2. `make build` (or `make build-tests`) — compiles; run mochitests for the cosmetic/scriptlet/farbling chains in a tests-enabled build.
 3. Launch the dist binary with a fresh profile (`LANG=en_US.UTF-8 MOZ_ENABLE_WAYLAND=1 … --no-remote --profile /tmp/nw-profile`) and run the automated scorecard:
-   - **d3ward** adblock score (M1/M2 target: >95%)
+   - **adblock.turtlecute.org** adblock score (M1/M2 target: >95%; d3ward is archived)
    - **browserleaks** + **coveryourtracks** (M4 target: site-varying hashes, no privacy-browser tell)
    - Shields per-site toggles change behavior live; logger records blocks (M3)
    - Stripped components absent from `about:buildconfig` / fail to instantiate (M6)
diff --git a/README.md b/README.md
index d64de01..af662bc 100644
--- a/README.md
+++ b/README.md
@@ -21,6 +21,12 @@ page).
 > It holds patches, branding, theme CSS, build config, and a Python orchestrator;
 > the Firefox source tarball is downloaded and patched at build time.
 
+## Beta downloads
+
+A public beta for Linux and Windows is available on the
+[Releases page](https://github.com/neon798/neonwolf/releases). See
+[docs/BETA.md](docs/BETA.md) for install steps and known issues.
+
 ## How it's built
 
 ```mermaid
diff --git a/assets/adblock/neonwolf-extra.txt b/assets/adblock/neonwolf-extra.txt
new file mode 100644
index 0000000..a420384
--- /dev/null
+++ b/assets/adblock/neonwolf-extra.txt
@@ -0,0 +1,23 @@
+! Title: Neonwolf Extra
+! Description: Curated Neonwolf supplement closing tracker/ad-host gaps left by
+!   the bundled lists. Every rule uses $third-party so first-party use of the
+!   host (e.g. logging in to an analytics dashboard, running an ads-manager
+!   console) keeps working; only cross-site tracking is blocked.
+! Maintainer: Neonwolf (assets/adblock/neonwolf-extra.txt — bundled-only, no
+!   canonical fetch URL; the live refresh serves it from the dump)
+! Provenance: gaps found 2026-07-08 by probing every host on
+!   adblock.turtlecute.org (the maintained d3ward replacement) against the
+!   engine — these hosts were unmatched by all ten bundled lists.
+!
+! TikTok advertising / marketing-events APIs (Events API pixel on 3p sites)
+||ads-api.tiktok.com^$third-party
+||ads-sg.tiktok.com^$third-party
+||business-api.tiktok.com^$third-party
+! Yahoo ad-tech and DMP hosts
+||udcm.yahoo.com^$third-party
+||log.fc.yahoo.com^$third-party
+||gemini.yahoo.com^$third-party
+||adtech.yahooinc.com^$third-party
+! Yandex analytics (bundled lists only cover paths/subdomains of these)
+||metrika.yandex.ru^$third-party
+||appmetrica.yandex.ru^$third-party
diff --git a/assets/neonwolf.overrides.cfg b/assets/neonwolf.overrides.cfg
index e4268ed..2ad8833 100644
--- a/assets/neonwolf.overrides.cfg
+++ b/assets/neonwolf.overrides.cfg
@@ -39,7 +39,7 @@ defaultPref(
 defaultPref("privacy.trackingprotection.content.protection.enabled", true);
 defaultPref(
   "privacy.trackingprotection.content.protection.list_names",
-  "easylist,easyprivacy,peterlowe,ubo-filters,ubo-badware,ubo-privacy,ubo-quickfixes,adguard-mobile,adguard-base,adguard-tracking"
+  "easylist,easyprivacy,peterlowe,ubo-filters,ubo-badware,ubo-privacy,ubo-quickfixes,adguard-mobile,adguard-base,adguard-tracking,neonwolf-extra"
 );
 
 // Live filter-list refresh (UBONetFilter): periodically re-fetch the lists from
@@ -108,13 +108,53 @@ defaultPref("browser.send_pings", false);                        // disable <a p
 defaultPref("network.http.referer.defaultPolicy", 0);            // send no referer at all
 defaultPref("privacy.clearOnShutdown_v2.cookiesAndStorage", true); // actually clear cookies on shutdown
 defaultPref("dom.security.mixed_content.block_active_content", true); // belt-and-suspenders with HTTPS-only
-defaultPref("webgl.disabled", true);                             // major fingerprint vector (override in about:config if needed)
+defaultPref("webgl.disabled", false);                            // re-enabled so FPP farbles it (+WebGLRandomization); WebGL-OFF is itself a conspicuous tell (see FPP section below)
+// LibreWolf's webgl-permission.patch ALSO gates content WebGL behind a per-site
+// "webgl" permission (librewolf.webgl.prompt, compiled default true) and ships
+// with the doorhanger hidden (prompt.hide=true) — i.e. WebGL is SILENTLY DENIED
+// everywhere, which is the exact same tell as webgl.disabled. Under the
+// FPP-forward posture WebGL must actually run so +WebGLRandomization can farble
+// it (empirically verified: context creation fails until this is off).
+defaultPref("librewolf.webgl.prompt", false);
 defaultPref("device.sensors.enabled", false);                    // device-motion/orientation, fingerprint surface, no desktop use
 defaultPref("dom.battery.enabled", false);                       // battery-status API, fingerprint surface
 defaultPref("dom.gamepad.enabled", false);                       // gamepad API, fingerprint surface
 defaultPref("dom.netinfo.enabled", false);                       // Network Information API, fingerprint surface
 defaultPref("media.peerconnection.ice.no_host", true);           // prevent local-IP leak via WebRTC (still allows STUN/TURN relay)
 
+// --- Anti-fingerprinting: FPP-forward farbling (supersedes RFP) ---
+// Neonwolf presents a CONVINCING, common fingerprint via per-origin farbling,
+// not RFP's uniform "hardened" spoof that stands out. Firefox's three FP modes
+// (resistFingerprinting / fingerprintingProtection / baseline...) are MUTUALLY
+// EXCLUSIVE and priority-ordered: RFP, when on, shadows FPP entirely. So we turn
+// RFP OFF and drive FPP, which gives DETERMINISTIC per-origin canvas/WebGL noise
+// (Brave-style, un-averageable) instead of RFP's per-read randomization.
+//
+// This also unlocks DARK MODE: RFP forces prefers-color-scheme=light
+// (CSSPrefersColorScheme target). FPP's default set omits it, so websites see the
+// real (dark) scheme and Firefox's native "Website appearance" setting works.
+//
+// FPP's default set is only 7 targets; `.overrides` (+Name/-Name) adds coverage.
+// Only Canvas/EfficientCanvas/WebGL truly randomize per-origin; the rest are
+// uniform spoofs. We add WebGL randomization, re-home the fork's hw-concurrency
+// pin (rfp-pin-hardware-concurrency.patch -> +NavigatorHWConcurrency, verified
+// -> 4), and add audio/font/timer protection. UA/screen-geometry uniform spoofs
+// are deliberately NOT added (real-for-platform is more "common" than a faked
+// hardened value). TIMEZONE is intentionally left REAL: verified that the JS
+// timezone override is gated on the resistFingerprinting *pref* (not the
+// JSDateTimeUTC target), so it can't be re-homed onto FPP by override — and a
+// spoofed timezone that mismatches IP/locale is itself a tell, so coherent real
+// timezone is the more "convincing" choice. This set is a starting point —
+// tuned against browserleaks/coveryourtracks.
+defaultPref("privacy.resistFingerprinting", false);
+defaultPref("privacy.fingerprintingProtection", true);
+defaultPref("privacy.fingerprintingProtection.remoteOverrides.enabled", false); // Mozilla can't relax the posture per-site
+defaultPref(
+  "privacy.fingerprintingProtection.overrides",
+  "+WebGLRandomization,+WebGLRenderInfo,+NavigatorHWConcurrency,+AudioContext,+AudioSampleRate,+FontVisibilityBaseSystem,+ReduceTimerPrecision"
+);
+defaultPref("layout.css.prefers-color-scheme.content-override", 2); // 2 = auto/follow-theme; guard so dark mode follows the synthwave chrome
+
 // Neonwolf: the native content-classifier ad/tracker blocker is only invoked
 // via the deferred-annotation channel path; without this it never runs network
 // blocking. Required for native ClassifyForCancel to execute.
@@ -139,3 +179,17 @@ defaultPref("privacy.trackingprotection.ubo.cosmetic.enabled", true);
 // wins that race, so ad-blocking quality is identical. Flip to true once
 // synchronous injection lands.
 defaultPref("privacy.trackingprotection.ubo.scriptlet.enabled", false);
+
+// --- Google Safe Browsing: disable the residual providers (privacy decision) ---
+// The LibreWolf baseline (settings/librewolf.cfg) already disables the
+// malware/phishing/blockedURIs/downloads SB features and blanks the google4 +
+// legacy-google gethash/update URLs. It does NOT touch the newer google5
+// provider (stock FF152 still ships it enabled) or the google4 dataSharing
+// toggle, so a residual safebrowsing.googleapis.com phone-home remains until
+// these are off too. Neonwolf disables Google Safe Browsing entirely — malware
+// and phishing coverage instead comes from the bundled uBO lists (ubo-badware
+// et al.) served by the native engine, with no Google lookup.
+defaultPref("browser.safebrowsing.provider.google5.enabled", false);
+defaultPref("browser.safebrowsing.provider.google5.updateURL", "");
+defaultPref("browser.safebrowsing.provider.google5.gethashURL", "");
+defaultPref("browser.safebrowsing.provider.google4.dataSharing.enabled", false);
diff --git a/docs/BETA.md b/docs/BETA.md
new file mode 100644
index 0000000..aed9e79
--- /dev/null
+++ b/docs/BETA.md
@@ -0,0 +1,48 @@
+# Neonwolf Beta
+
+Neonwolf is a privacy-first Firefox fork. This is a public beta for Linux and Windows. Feedback is welcome via GitHub issues.
+
+## Download
+
+Beta builds are on the [GitHub Releases page](https://github.com/neon798/neonwolf/releases).
+
+- **Linux:** `Neonwolf-x86_64.AppImage` (portable) or `*.linux-x86_64.tar.xz`
+- **Windows:** `*.win64.installer.exe` (installer) or `*.win64.zip` (portable)
+- **macOS:** no build yet (planned for a later beta)
+
+## Installing (the builds are unsigned)
+
+Beta builds are **not code-signed**, so the OS will show a warning. That is expected for a beta.
+
+### Linux (AppImage)
+
+1. Make the AppImage executable: `chmod +x Neonwolf-x86_64.AppImage`
+2. Run it.
+
+If it will not start, install FUSE (`libfuse2` on Debian/Ubuntu).
+
+### Linux (tar.xz)
+
+Extract the archive and run the `neonwolf` binary inside.
+
+### Windows
+
+SmartScreen may show **Windows protected your PC**. Click **More info**, then **Run anyway**, and continue through the installer.
+
+## Updates
+
+- Neonwolf checks GitHub for a newer build about once a day and shows a banner when one is available.
+- There is **no automatic update** and **no background downloader** — by design. To update, download the new build from the Releases page and reinstall (Windows) or replace the AppImage / extracted folder (Linux).
+
+## Known issues (beta)
+
+- Ad and tracker **network** blocking is complete, but a few cosmetic / in-page ad-script checks do not pass yet (script-injection "scriptlets" are disabled pending a fix), so third-party ad-blocker test sites score around 94%, not 100%.
+- Anti-fingerprinting randomizes **canvas and WebGL** per site, but **audio** fingerprinting is not randomized yet.
+- **No macOS build** in this beta.
+- Builds are **unsigned** (see install steps above).
+- **No built-in password manager** — by design. Neonwolf recommends Bitwarden, 1Password, Proton Pass, or KeePassXC (the first-run wizard links these).
+- **Windows is less tested than Linux**; please report anything odd.
+
+## Reporting bugs
+
+Please open a [GitHub issue](https://github.com/neon798/neonwolf/issues) with your OS, what you did, and what happened.
diff --git a/patches/native/native-ubo-snfe.patch b/patches/native/native-ubo-snfe.patch
index 23c276e..4ced7d4 100644
--- a/patches/native/native-ubo-snfe.patch
+++ b/patches/native/native-ubo-snfe.patch
@@ -81,8 +81,8 @@ diff -ruN a/toolkit/components/content-classifier/moz.build b/toolkit/components
  XPCOM_MANIFESTS += [
 diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit/components/content-classifier/UBONetFilter.sys.mjs
 --- a/toolkit/components/content-classifier/UBONetFilter.sys.mjs	1969-12-31 17:00:00.000000000 -0700
-+++ b/toolkit/components/content-classifier/UBONetFilter.sys.mjs	2026-07-01 20:31:20.638795139 -0600
-@@ -0,0 +1,753 @@
++++ b/toolkit/components/content-classifier/UBONetFilter.sys.mjs	2026-07-08 23:30:00.000000000 -0600
+@@ -0,0 +1,794 @@
 +/* This Source Code Form is subject to the terms of the Mozilla Public
 + * License, v. 2.0. If a copy of the MPL was not distributed with this
 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
@@ -145,6 +145,15 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +const LIVE_STARTUP_DELAY_MS = 120000;
 +const LIVE_MIN_INTERVAL_MS = 3600000;
 +const LIVE_MIN_LIST_BYTES = 10000;
++// User-subscribed extra lists (newline-separated https:// URLs, managed by the
++// Shields lists/filters pages). Fetch-only — no bundled fallback: a failed
++// fetch just drops that subscription until the next refresh cycle. Personal
++// lists can be tiny, so only a 1-byte floor, but cap the size so a hostile
++// URL can't balloon the compile.
++const SUBSCRIPTIONS_PREF = "neonwolf.shields.lists.subscriptions";
++const SUB_LIST_PREFIX = "neonwolf-sub:";
++const SUB_MIN_LIST_BYTES = 1;
++const LIST_MAX_BYTES = 20 * 1024 * 1024;
 +// record.Name -> canonical source URL (mirrors scripts/fetch-adblock-lists.sh).
 +const LIST_URLS = new Map([
 +  ["easylist", "https://ublockorigin.github.io/uAssetsCDN/thirdparties/easylist.txt"],
@@ -289,6 +298,8 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +    // Manual "refresh now" trigger + auto-refresh toggle for live list refresh.
 +    Services.prefs.addObserver(LIVE_REFRESHNOW_PREF, this);
 +    Services.prefs.addObserver(LIVE_AUTOREFRESH_PREF, this);
++    // Subscribing/unsubscribing a list takes effect via an immediate refresh.
++    Services.prefs.addObserver(SUBSCRIPTIONS_PREF, this);
 +    this._observing = true;
 +    this._prefObserving = true;
 +    this._scheduleLiveRefresh();
@@ -298,6 +309,22 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +    return Services.prefs.getStringPref(USER_FILTERS_PREF, "").trim();
 +  },
 +
++  // Valid https:// subscription URLs from the pref; anything else is ignored
++  // (the pages validate on write, but the pref is user-editable).
++  _subscriptionUrls() {
++    return Services.prefs
++      .getStringPref(SUBSCRIPTIONS_PREF, "")
++      .split("\n")
++      .map(line => line.trim())
++      .filter(line => {
++        try {
++          return new URL(line).protocol === "https:";
++        } catch (e) {
++          return false;
++        }
++      });
++  },
++
 +  // Cheap non-cryptographic string hash (djb2) for cache-keying only.
 +  _hashString(str) {
 +    let h = 5381;
@@ -442,6 +469,15 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +        lists.push({ name: record.Name, raw });
 +      }
 +    }
++    const subUrls = this._subscriptionUrls();
++    let subFresh = 0;
++    for (const url of subUrls) {
++      const raw = await this._fetchListText(url, SUB_MIN_LIST_BYTES);
++      if (raw) {
++        subFresh++;
++        lists.push({ name: SUB_LIST_PREFIX + url, raw });
++      }
++    }
 +    const userText = this._userFilters();
 +    if (userText) {
 +      lists.push({ name: USER_FILTERS_LIST_NAME, raw: userText });
@@ -450,18 +486,20 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +      return;
 +    }
 +    // In-memory only: no selfie write, so the bundled-dump selfie keeps warm
-+    // starts fast and this refresh isn't persisted across restarts.
++    // starts fast and this refresh isn't persisted across restarts. That also
++    // means subscriptions only apply once the first live refresh has run.
 +    await this._snfe.useLists(lists);
 +    Services.prefs.setIntPref(
 +      LIVE_LASTREFRESH_PREF,
 +      Math.floor(Date.now() / 1000)
 +    );
 +    lazy.log.info(
-+      `lists refreshed: ${fresh}/${records.length} fresh (${Date.now() - t0}ms)`
++      `lists refreshed: ${fresh}/${records.length} fresh, ` +
++        `${subFresh}/${subUrls.length} subscriptions (${Date.now() - t0}ms)`
 +    );
 +  },
 +
-+  async _fetchListText(url) {
++  async _fetchListText(url, minBytes = LIVE_MIN_LIST_BYTES) {
 +    try {
 +      const resp = await fetch(url, { cache: "no-store" });
 +      if (!resp.ok) {
@@ -469,7 +507,7 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +      }
 +      const text = await resp.text();
 +      // Sanity floor (matches fetch-adblock-lists.sh): reject truncated bodies.
-+      if (!text || text.length < LIVE_MIN_LIST_BYTES) {
++      if (!text || text.length < minBytes || text.length > LIST_MAX_BYTES) {
 +        return null;
 +      }
 +      return text;
@@ -496,6 +534,8 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +          }
 +        } else if (data === LIVE_AUTOREFRESH_PREF) {
 +          this._scheduleLiveRefresh();
++        } else if (data === SUBSCRIPTIONS_PREF) {
++          this._enqueueLiveRefresh();
 +        } else {
 +          this._onUserFiltersChanged();
 +        }
@@ -513,6 +553,7 @@ diff -ruN a/toolkit/components/content-classifier/UBONetFilter.sys.mjs b/toolkit
 +          Services.prefs.removeObserver(USER_FILTERS_PREF, this);
 +          Services.prefs.removeObserver(LIVE_REFRESHNOW_PREF, this);
 +          Services.prefs.removeObserver(LIVE_AUTOREFRESH_PREF, this);
++          Services.prefs.removeObserver(SUBSCRIPTIONS_PREF, this);
 +          this._prefObserving = false;
 +        }
 +        if (this._observing) {
diff --git a/scripts/gen-adblock-dump.py b/scripts/gen-adblock-dump.py
index c7da685..28f4bd9 100644
--- a/scripts/gen-adblock-dump.py
+++ b/scripts/gen-adblock-dump.py
@@ -52,6 +52,7 @@
     ("adguard-mobile", "adguard-mobile.txt"),
     ("adguard-base", "adguard-base.txt"),
     ("adguard-tracking", "adguard-tracking.txt"),
+    ("neonwolf-extra", "neonwolf-extra.txt"),
 ]
 
 
diff --git a/themes/browser/base/content/NeonwolfUpdateCheck.sys.mjs b/themes/browser/base/content/NeonwolfUpdateCheck.sys.mjs
index da8eff3..8fa01f7 100644
--- a/themes/browser/base/content/NeonwolfUpdateCheck.sys.mjs
+++ b/themes/browser/base/content/NeonwolfUpdateCheck.sys.mjs
@@ -32,7 +32,7 @@ const LASTCHECK_PREF = "neonwolf.update.lastCheckSeconds";
 // (e.g. "152.0.1-3"); Services.appinfo.version only carries the FF version.
 const FULLVERSION_PREF = "neonwolf.version.full";
 const RELEASES_API =
-  "https://api.github.com/repos/neon798/neonwolf/releases/latest";
+  "https://api.github.com/repos/neon798/neonwolf/releases?per_page=30";
 
 const STARTUP_DELAY_MS = 90 * 1000;
 const INTERVAL_MS = 24 * 60 * 60 * 1000;
@@ -86,12 +86,28 @@ export const NeonwolfUpdateCheck = {
       return;
     }
     Services.prefs.setIntPref(LASTCHECK_PREF, nowSec);
-    const latest = String(data.tag_name || "").replace(/^v/, "");
-    const url = String(data.html_url || "");
-    if (latest && this._isNewer(latest, this._current())) {
-      Services.prefs.setStringPref(AVAILABLE_PREF, latest);
-      Services.prefs.setStringPref(URL_PREF, url);
-      lazy.log.info(`update available: ${latest}`);
+    if (!Array.isArray(data)) {
+      return;
+    }
+    let best = "";
+    let bestUrl = "";
+    for (const release of data) {
+      if (release.draft === true) {
+        continue;
+      }
+      const candidate = String(release.tag_name || "").replace(/^v/, "");
+      if (!candidate) {
+        continue;
+      }
+      if (!best || this._isNewer(candidate, best)) {
+        best = candidate;
+        bestUrl = String(release.html_url || "");
+      }
+    }
+    if (best && this._isNewer(best, this._current())) {
+      Services.prefs.setStringPref(AVAILABLE_PREF, best);
+      Services.prefs.setStringPref(URL_PREF, bestUrl);
+      lazy.log.info(`update available: ${best}`);
     } else {
       // Clear any stale "available" state once we're current again.
       Services.prefs.setStringPref(AVAILABLE_PREF, "");
diff --git a/themes/browser/base/content/neonwolf-element-picker-content.js b/themes/browser/base/content/neonwolf-element-picker-content.js
index d889c84..01449f8 100644
--- a/themes/browser/base/content/neonwolf-element-picker-content.js
+++ b/themes/browser/base/content/neonwolf-element-picker-content.js
@@ -7,9 +7,9 @@
 /**
  * Neonwolf element picker frame script (content process).
  *
- * Injected per pick session. Highlights hovered elements and builds a simple
- * cosmetic filter candidate. Selector generation stays chrome-side of trust
- * (never a page-provided hook); Claude wires a smarter generator later.
+ * Injected per pick session. Highlights hovered elements and builds a
+ * cosmetic filter candidate via a uBO-style selector generator. Selector
+ * generation stays chrome-side of trust (never a page-provided hook).
  */
 (function () {
   if (content.window.__nwPickerSession) {
@@ -19,6 +19,8 @@
   const HIGHLIGHT_ID = "neonwolf-picker-highlight";
   const PANEL_ID = "neonwolf-picker-panel";
   const STYLE_ID = "neonwolf-picker-style";
+  const STABLE_CLASS_RE = /^[A-Za-z_][A-Za-z0-9_-]{1,29}$/;
+  const MAX_PATH_SEGMENTS = 4;
 
   let active = false;
   let selectedElement = null;
@@ -45,10 +47,156 @@
     return tag;
   }
 
+  /** True iff sel matches exactly one node in the document (invalid → false). */
+  function unique(sel) {
+    try {
+      return content.document.querySelectorAll(sel).length === 1;
+    } catch (e) {
+      return false;
+    }
+  }
+
+  /** Stable classes: identifier-like, <3 digits (filters hashed CSS modules). Cap 2. */
+  function stableClasses(el) {
+    let out = [];
+    if (!el.classList) {
+      return out;
+    }
+    for (let c of el.classList) {
+      if (!STABLE_CLASS_RE.test(c)) {
+        continue;
+      }
+      let digits = 0;
+      for (let i = 0; i < c.length; i++) {
+        let ch = c.charCodeAt(i);
+        if (ch >= 48 && ch <= 57) {
+          digits++;
+        }
+      }
+      if (digits >= 3) {
+        continue;
+      }
+      out.push(c);
+      if (out.length >= 2) {
+        break;
+      }
+    }
+    return out;
+  }
+
+  /** :nth-of-type index: same-tag preceding siblings + 1. */
+  function nthOfTypeIndex(el) {
+    let n = 1;
+    let tag = el.tagName;
+    for (let sib = el.previousElementSibling; sib; sib = sib.previousElementSibling) {
+      if (sib.tagName == tag) {
+        n++;
+      }
+    }
+    return n;
+  }
+
+  /**
+   * True if more than one same-parent sibling matches `segment` (tag+classes).
+   * Only same-tag siblings are considered for ambiguity.
+   */
+  function segmentAmbiguousAmongSiblings(el, segment) {
+    let parent = el.parentElement;
+    if (!parent) {
+      return false;
+    }
+    let matches = 0;
+    let tag = el.tagName;
+    for (
+      let child = parent.firstElementChild;
+      child;
+      child = child.nextElementSibling
+    ) {
+      if (child.tagName != tag) {
+        continue;
+      }
+      try {
+        if (child.matches(segment)) {
+          matches++;
+          if (matches > 1) {
+            return true;
+          }
+        }
+      } catch (e) {
+        // invalid segment — treat as non-ambiguous
+      }
+    }
+    return false;
+  }
+
+  /**
+   * Build one path segment for `el`. Returns `{ segment, stopClimb }`.
+   * Unique id → `tag#id` and stop climbing; else tag + stable classes +
+   * optional :nth-of-type when ambiguous among siblings.
+   */
+  function pathSegment(el) {
+    let tag = el.tagName.toLowerCase();
+    if (el.id) {
+      let idCandidate = "#" + cssEscape(el.id);
+      if (unique(idCandidate)) {
+        return { segment: tag + "#" + cssEscape(el.id), stopClimb: true };
+      }
+    }
+
+    let segment = tag;
+    for (let c of stableClasses(el)) {
+      segment += "." + cssEscape(c);
+    }
+    if (segmentAmbiguousAmongSiblings(el, segment)) {
+      segment += ":nth-of-type(" + nthOfTypeIndex(el) + ")";
+    }
+    return { segment, stopClimb: false };
+  }
+
+  /**
+   * uBO-style selector generator. Pure DOM reads only — never call page
+   * functions or hostile content.window hooks.
+   */
   function generateSelector(el) {
-    // Selector generation stays chrome-side of trust: never defer to a
-    // page-defined hook (content.window is attacker-controlled). Claude wires a
-    // smarter generator later.
+    if (!el || el.nodeType != 1) {
+      return "";
+    }
+
+    // Prefer bare #id when unique in the document.
+    if (el.id) {
+      let idSel = "#" + cssEscape(el.id);
+      if (unique(idSel)) {
+        return idSel;
+      }
+    }
+
+    // Bottom-up descendant path, max 4 segments, joined with " > ".
+    let parts = [];
+    let node = el;
+    for (let depth = 0; node && node.nodeType == 1 && depth < MAX_PATH_SEGMENTS; depth++) {
+      let { segment, stopClimb } = pathSegment(node);
+      parts.unshift(segment);
+      let sel = parts.join(" > ");
+      if (unique(sel)) {
+        return sel;
+      }
+      if (stopClimb) {
+        break;
+      }
+      node = node.parentElement;
+    }
+
+    // Deepest path if it still matches the pick; else simple fallback.
+    let deepest = parts.join(" > ");
+    if (deepest) {
+      try {
+        if (el.matches(deepest)) {
+          return deepest;
+        }
+      } catch (e) {
+        // fall through to simpleSelector
+      }
+    }
     return simpleSelector(el);
   }
 
diff --git a/themes/browser/base/content/neonwolf-shields-lists.js b/themes/browser/base/content/neonwolf-shields-lists.js
index e0785b4..484e317 100644
--- a/themes/browser/base/content/neonwolf-shields-lists.js
+++ b/themes/browser/base/content/neonwolf-shields-lists.js
@@ -11,6 +11,7 @@ var gNeonwolfShieldsLists = {
   PREF_LAST_REFRESH: "neonwolf.shields.lists.lastRefresh",
   PREF_AUTO_REFRESH: "neonwolf.shields.lists.autoRefresh",
   PREF_REFRESH_NOW: "neonwolf.shields.lists.refreshNow",
+  PREF_SUBSCRIPTIONS: "neonwolf.shields.lists.subscriptions",
   OBS_BRANCH: "neonwolf.shields.lists.",
 
   BUNDLED_LISTS: [
@@ -24,6 +25,7 @@ var gNeonwolfShieldsLists = {
     "adguard-base",
     "adguard-mobile",
     "adguard-tracking",
+    "neonwolf-extra",
   ],
 
   _refreshPending: false,
@@ -49,6 +51,25 @@ var gNeonwolfShieldsLists = {
     ));
   },
 
+  get _subRows() {
+    delete this._subRows;
+    return (this._subRows = document.getElementById("neonwolf-lists-sub-rows"));
+  },
+
+  get _subInput() {
+    delete this._subInput;
+    return (this._subInput = document.getElementById(
+      "neonwolf-lists-sub-input"
+    ));
+  },
+
+  get _subError() {
+    delete this._subError;
+    return (this._subError = document.getElementById(
+      "neonwolf-lists-sub-error"
+    ));
+  },
+
   _getLastRefresh() {
     return Services.prefs.getIntPref(this.PREF_LAST_REFRESH, 0);
   },
@@ -61,6 +82,110 @@ var gNeonwolfShieldsLists = {
     return new Date(seconds * 1000).toLocaleString();
   },
 
+  _loadSubscriptions() {
+    return Services.prefs
+      .getStringPref(this.PREF_SUBSCRIPTIONS, "")
+      .split("\n")
+      .map(line => line.trim())
+      .filter(Boolean);
+  },
+
+  _saveSubscriptions(urls) {
+    Services.prefs.setStringPref(this.PREF_SUBSCRIPTIONS, urls.join("\n"));
+  },
+
+  _setSubError(msg) {
+    let err = this._subError;
+    if (!err) {
+      return;
+    }
+    err.setAttribute("value", msg || "");
+  },
+
+  _renderSubscriptions() {
+    let container = this._subRows;
+    if (!container) {
+      return;
+    }
+    container.textContent = "";
+    let urls = this._loadSubscriptions();
+    if (!urls.length) {
+      let empty = document.createXULElement("label");
+      empty.className = "neonwolf-filters-subscribe-empty";
+      empty.setAttribute("value", "No subscribed lists.");
+      container.appendChild(empty);
+      return;
+    }
+    for (let url of urls) {
+      let row = document.createXULElement("hbox");
+      row.className = "neonwolf-lists-row";
+      row.setAttribute("align", "center");
+
+      // textContent (not innerHTML) — URL is user/pref-derived.
+      let urlLabel = document.createXULElement("label");
+      urlLabel.className = "neonwolf-filters-subscribe-item";
+      urlLabel.setAttribute("flex", "1");
+      urlLabel.setAttribute("crop", "end");
+      urlLabel.setAttribute("value", url);
+      row.appendChild(urlLabel);
+
+      let removeBtn = document.createXULElement("button");
+      removeBtn.className = "neonwolf-lists-btn";
+      removeBtn.setAttribute("label", "Remove");
+      removeBtn.addEventListener("command", () =>
+        this._onSubscribeRemove(url)
+      );
+      row.appendChild(removeBtn);
+
+      container.appendChild(row);
+    }
+  },
+
+  _onSubscribeRemove(url) {
+    let urls = this._loadSubscriptions().filter(u => u !== url);
+    this._saveSubscriptions(urls);
+    this._setSubError("");
+    this._renderSubscriptions();
+  },
+
+  _onSubscribeAdd() {
+    let input = this._subInput;
+    if (!input) {
+      return;
+    }
+    let raw = input.value.trim();
+    this._setSubError("");
+
+    if (!raw) {
+      this._setSubError("Enter a URL.");
+      return;
+    }
+
+    let parsed;
+    try {
+      parsed = new URL(raw);
+    } catch (e) {
+      this._setSubError("Invalid URL.");
+      return;
+    }
+
+    if (parsed.protocol !== "https:") {
+      this._setSubError("Only https:// URLs are allowed.");
+      return;
+    }
+
+    let urls = this._loadSubscriptions();
+    if (urls.includes(raw)) {
+      this._setSubError("Already subscribed.");
+      return;
+    }
+
+    urls.push(raw);
+    this._saveSubscriptions(urls);
+    input.value = "";
+    this._renderSubscriptions();
+  },
+
   _scheduleRender() {
     if (this._renderPending) {
       return;
@@ -147,6 +272,9 @@ var gNeonwolfShieldsLists = {
     ) {
       this._scheduleRender();
     }
+    if (aPrefName == this.PREF_SUBSCRIPTIONS) {
+      this._renderSubscriptions();
+    }
   },
 
   _onUnload() {
@@ -171,14 +299,20 @@ var gNeonwolfShieldsLists = {
       refreshBtn.addEventListener("command", () => this._onRefreshNow());
     }
 
+    let subAdd = document.getElementById("neonwolf-lists-sub-add");
+    if (subAdd) {
+      subAdd.addEventListener("command", () => this._onSubscribeAdd());
+    }
+
     window.addEventListener("unload", () => this._onUnload(), { once: true });
 
     this._lastRefreshSeen = this._getLastRefresh();
     this._syncAutoRefresh();
     this._render();
+    this._renderSubscriptions();
   },
 };
 
 window.addEventListener("load", () => gNeonwolfShieldsLists.init(), {
   once: true,
-});
\ No newline at end of file
+});
diff --git a/themes/browser/base/content/neonwolf-shields-lists.xhtml b/themes/browser/base/content/neonwolf-shields-lists.xhtml
index a03fa2a..b7ae3dd 100644
--- a/themes/browser/base/content/neonwolf-shields-lists.xhtml
+++ b/themes/browser/base/content/neonwolf-shields-lists.xhtml
@@ -42,6 +42,20 @@
         </hbox>
         <vbox id="neonwolf-lists-rows"/>
       </vbox>
+
+      <vbox id="neonwolf-lists-subscriptions" class="neonwolf-filters-subscriptions">
+        <label class="neonwolf-filters-section-title" value="Subscribed lists"/>
+        <vbox id="neonwolf-lists-sub-rows" class="neonwolf-filters-subscribe-list"/>
+        <hbox class="neonwolf-filters-subscribe-row" align="center">
+          <html:input id="neonwolf-lists-sub-input"
+                      class="neonwolf-filters-subscribe-input"
+                      type="url"
+                      placeholder="https://example.com/filters.txt"
+                      flex="1"/>
+          <button id="neonwolf-lists-sub-add" class="neonwolf-lists-btn" label="Subscribe"/>
+        </hbox>
+        <label id="neonwolf-lists-sub-error" class="neonwolf-filters-lint"/>
+      </vbox>
     </scrollbox>
   </vbox>
 </window>
\ No newline at end of file
diff --git a/themes/browser/base/content/neonwolf-shields-panel.js b/themes/browser/base/content/neonwolf-shields-panel.js
index 503815f..861016e 100644
--- a/themes/browser/base/content/neonwolf-shields-panel.js
+++ b/themes/browser/base/content/neonwolf-shields-panel.js
@@ -23,6 +23,11 @@ var gNeonwolfShieldsHandler = {
   // Shared contract with the backend / CosmeticFilterParent.
   PERMISSION_TYPE: "neonwolf-shields",
 
+  // FPP + baseline FPP each have their own granularOverrides (same JSON schema).
+  FP_GRANULAR_PREF: "privacy.fingerprintingProtection.granularOverrides",
+  BASELINE_FP_GRANULAR_PREF:
+    "privacy.baselineFingerprintingProtection.granularOverrides",
+
   _categories: ["ads", "trackers", "fingerprinting", "cookies", "httpsUpgrade"],
 
   /**
@@ -67,9 +72,15 @@ var gNeonwolfShieldsHandler = {
     },
     fingerprinting: {
       get: () =>
-        Services.prefs.getBoolPref("privacy.resistFingerprinting", true),
+        Services.prefs.getBoolPref(
+          "privacy.fingerprintingProtection",
+          true
+        ),
       set: enabled =>
-        Services.prefs.setBoolPref("privacy.resistFingerprinting", enabled),
+        Services.prefs.setBoolPref(
+          "privacy.fingerprintingProtection",
+          enabled
+        ),
     },
     cookies: {
       get: () =>
@@ -375,6 +386,8 @@ var gNeonwolfShieldsHandler = {
       }
     }
 
+    this._syncFpSiteRow();
+
     // Real blocked-count from the native content classifier, keyed by the
     // current page's site (see _currentSiteKey / getBlockedCount).
     let countEl = document.getElementById("neonwolf-shields-count");
@@ -385,6 +398,146 @@ var gNeonwolfShieldsHandler = {
     this.updateButton();
   },
 
+  /**
+   * eTLD+1 for the current content principal, or null when unavailable.
+   * Used as firstPartyDomain in granularOverrides.
+   * Note: exemption keys on eTLD+1 and will not match sites whose eTLD+1 is
+   * itself a public-suffix-listed host (e.g. foo.github.io) — known edge, accepted.
+   */
+  _fpSiteDomain() {
+    if (!this._principal) {
+      return null;
+    }
+    try {
+      return Services.eTLD.getBaseDomain(this._principal.URI);
+    } catch (e) {
+      return null;
+    }
+  },
+
+  /**
+   * Parse a granularOverrides string pref (FPP or baseline FPP).
+   * Returns the array, or null if unreadable / not an array (do not touch).
+   */
+  _readGranularOverrides(prefName) {
+    let raw;
+    try {
+      raw = Services.prefs.getStringPref(prefName, "[]");
+    } catch (e) {
+      return null;
+    }
+    try {
+      let parsed = JSON.parse(raw);
+      if (!Array.isArray(parsed)) {
+        return null;
+      }
+      return parsed;
+    } catch (e) {
+      return null;
+    }
+  },
+
+  /**
+   * True if domain has an -AllTargets farbling exemption entry.
+   * Canonical source: FPP granularOverrides only.
+   */
+  _isFpSiteExempt(domain) {
+    let arr = this._readGranularOverrides(this.FP_GRANULAR_PREF);
+    if (!arr) {
+      return false;
+    }
+    return arr.some(
+      e =>
+        e &&
+        e.firstPartyDomain === domain &&
+        e.overrides === "-AllTargets"
+    );
+  },
+
+  /**
+   * Add or remove the -AllTargets exemption for domain on BOTH FPP and
+   * baseline FPP granular prefs (canvas rides the baseline tier). Each pref
+   * is read-modify-written independently. All-or-nothing: if either pref is
+   * unreadable, write neither. Never mutates foreign entries.
+   */
+  _setFpSiteExempt(domain, exempt) {
+    if (!domain) {
+      return;
+    }
+    let fppArr = this._readGranularOverrides(this.FP_GRANULAR_PREF);
+    let baselineArr = this._readGranularOverrides(
+      this.BASELINE_FP_GRANULAR_PREF
+    );
+    if (fppArr === null || baselineArr === null) {
+      return;
+    }
+
+    let apply = arr => {
+      if (exempt) {
+        let present = arr.some(
+          e =>
+            e &&
+            e.firstPartyDomain === domain &&
+            e.overrides === "-AllTargets"
+        );
+        if (!present) {
+          arr.push({ firstPartyDomain: domain, overrides: "-AllTargets" });
+        }
+        return arr;
+      }
+      return arr.filter(
+        e =>
+          !(
+            e &&
+            e.firstPartyDomain === domain &&
+            e.overrides === "-AllTargets"
+          )
+      );
+    };
+
+    fppArr = apply(fppArr);
+    baselineArr = apply(baselineArr);
+    Services.prefs.setStringPref(
+      this.FP_GRANULAR_PREF,
+      JSON.stringify(fppArr)
+    );
+    Services.prefs.setStringPref(
+      this.BASELINE_FP_GRANULAR_PREF,
+      JSON.stringify(baselineArr)
+    );
+  },
+
+  /**
+   * Sync the per-site "Farble on this site" row: hide when no domain or
+   * either granularOverrides pref is unreadable; disable when global FPP is
+   * off; otherwise checked means farbling is ON for this site.
+   */
+  _syncFpSiteRow() {
+    let row = document.getElementById("neonwolf-shields-fp-site");
+    if (!row) {
+      return;
+    }
+    let available = !!this._principal;
+    let domain = this._fpSiteDomain();
+    let fppOverrides = this._readGranularOverrides(this.FP_GRANULAR_PREF);
+    let baselineOverrides = this._readGranularOverrides(
+      this.BASELINE_FP_GRANULAR_PREF
+    );
+    if (
+      !available ||
+      !domain ||
+      fppOverrides === null ||
+      baselineOverrides === null
+    ) {
+      row.hidden = true;
+      return;
+    }
+    row.hidden = false;
+    let globalOn = this._categoryPrefs.fingerprinting.get();
+    row.disabled = !globalOn;
+    row.checked = !this._isFpSiteExempt(domain);
+  },
+
   /**
    * Master toggle handler: shields up (true) means blocking enabled.
    */
@@ -508,6 +661,18 @@ var gNeonwolfShieldsHandler = {
       }
     }
 
+    let fpSite = document.getElementById("neonwolf-shields-fp-site");
+    if (fpSite) {
+      fpSite.addEventListener("command", () => {
+        let domain = this._fpSiteDomain();
+        if (!domain) {
+          return;
+        }
+        // checked = farbling ON here → not exempt; unchecked → exempt.
+        this._setFpSiteExempt(domain, !fpSite.checked);
+      });
+    }
+
     let loggerLink = document.getElementById("neonwolf-shields-open-logger");
     if (loggerLink) {
       loggerLink.addEventListener("click", () => this.openLogger());
diff --git a/themes/browser/base/content/neonwolf-shields.css b/themes/browser/base/content/neonwolf-shields.css
index 8d691ef..b9eb77e 100644
--- a/themes/browser/base/content/neonwolf-shields.css
+++ b/themes/browser/base/content/neonwolf-shields.css
@@ -78,6 +78,12 @@
   background: rgba(255, 0, 255, 0.05) !important;
 }
 
+/* Per-site farbling sub-row under the global FPP toggle */
+.shields-subrow {
+  margin-inline-start: 16px !important;
+  color: var(--neonwolf-text-dim) !important;
+}
+
 .shields-toggle-label {
   color: var(--neonwolf-text-secondary) !important;
 }
diff --git a/themes/browser/base/content/neonwolf-shields.xhtml b/themes/browser/base/content/neonwolf-shields.xhtml
index 70b6621..ccbf121 100644
--- a/themes/browser/base/content/neonwolf-shields.xhtml
+++ b/themes/browser/base/content/neonwolf-shields.xhtml
@@ -36,7 +36,12 @@
 
     <checkbox id="neonwolf-shields-fingerprinting"
               class="shields-toggle-row"
-              label="Block fingerprinting"/>
+              label="Farble fingerprinting"/>
+
+    <checkbox id="neonwolf-shields-fp-site"
+              class="shields-toggle-row shields-subrow"
+              label="Farble on this site"
+              tooltiptext="Reload the page for changes to take effect."/>
 
     <checkbox id="neonwolf-shields-cookies"
               class="shields-toggle-row"