Extension Pulse, week of November 16: Chrome 159 carries a fast lane for blocker traffic, off by default, and November 30 gates Chrome 160
Chrome 159 carries a high-priority lane for requests your blocker intercepts, off by default. The null-headers crash fix merged. November 30 gates Chrome 160.

For years the honest answer to "do ad blockers slow Chrome down?" was: a little, structurally. When a webRequest or declarativeNetRequest extension is installed, Chrome intercepts every subresource load on the browser's UI thread — and that interception traffic queued behind whatever else the browser was doing. On November 7 Chrome merged a fix (CL 8494031): a dedicated high-priority lane for exactly that traffic. The code rides Chrome 159, stable December 8, but behind a feature that is disabled by default, so nothing changes for your users that day. What 159 gives you is a switch you can flip to test it, including one documented race.
And that's not the only date that matters. November 30 is the Chrome 160 branch point, and as of this week three stacks are racing it: a crash fix that merged and made the cut, a getDynamicRules() rework that was abandoned and restarted mid-week, and the Cross-Origin Storage family, which woke up and grew a third API.
Chrome 159: a high-priority lane for the requests your blocker touches, behind a flag
Here's the mechanics. When a webRequest or DNR extension is installed, RenderFrameHostImpl creates a proxying URL-loader factory on the browser UI thread that intercepts every subresource request in the frame. Under congestion — replaceState() IPC bursts, tab-model observers, omnibox callbacks during a page load — the interception IPCs (CreateLoaderAndStart, OnBeforeSendHeaders, OnHeadersReceived, OnReceiveResponse) got delayed behind unrelated default-queue work. That delay is what the CL sets out to remove.
The fix adds a new high-priority browser task type for those loader proxies. It merged November 7, two days before M159's November 9 branch point, so the code is in Chrome 159, stable December 8 (schedule). Three scoping details from the CL. It covers the subresource requests of the main frame only, not iframes. By default it applies only to visible tabs and leaves prerendered pages out, so background prerenders can't preempt the page you're actually looking at.
And the whole thing sits behind the SubresourceLoaderProxyTaskQueue feature, which the CL declares FEATURE_DISABLED_BY_DEFAULT. A follow-up CL, merged November 11, adds a field-trial testing config for desktop platforms with an experiment named Enabled_VisibleOnly_20261111_CANARY_DEV. I read that as an experiment starting in Canary and Dev. Neither CL says when the lane reaches stable users; bug 578355574 is the place to track that.
Now the part that could bite once it's on. Cross-document navigations keep their ordering guarantees, but same-document ones (history.pushState() / replaceState()) still commit on the default queue. The commit message documents the race: under UI-thread congestion, a subresource request issued immediately after a same-document navigation can be processed before Chrome updates URL-dependent per-frame state, and it names declarativeNetRequest allowAllRequests rules as the example. In that window the frame's allowAllRequests state can still reflect the URL from before the pushState().
Who cares? Extensions whose allow-rules look at the page path and not just the domain (a pushState() can't change the origin): consent managers, privacy tools with per-page allowlists. Nothing needs adopting. If that's your shape, you can test now: start Chrome 159 beta (in beta since November 11) with --enable-features=SubresourceLoaderProxyTaskQueue and fire a request right after pushState(). The SPA navigation guide is the refresher on why same-document navigations are their own beast.
My take: this is Chrome treating the blocker tax as a scheduling problem instead of architectural weather. The MV3 ad-blocking study already showed DNR didn't kill blocking effectiveness; the speed half of the argument now has a patch, waiting on a switch.
The browser-crash fix merged: relief ships January 5
Last week's nastiest watch item is now a dated fact. CL 8716376 — the browser-process crash W46 flagged — merged November 12 (main@{#1742520}, Fixed: 581338044), three days after M159's branch. As of November 18 Gerrit shows no cherry-pick to the 159 branch. First train: Chrome 160, beta December 2, stable January 5, 2027 (schedule).
The recap, one paragraph: with extraHeaders, a proxy-auth challenge on a CORS preflight can leave onHeadersReceived dispatched with null original response headers; a blocking listener returning responseHeaders — even unmodified — dereferenced null and crashed the whole browser process. A DNR modifyHeaders rule on response headers was enough to reach the same path with no webRequest listener anywhere. The fix returns early on null headers, mirroring an earlier DNR fix. The merged commit adds one detail: in the null case the Activity Log no longer records a redirect URL — a request without headers can't be redirected anyway.
Two practical consequences. Until M160 stable ships, the crashing pattern remains live in current stable — if your crash reports correlate with proxy-authenticated networks, that was never your bug, and relief now has a date (December 2 beta for early validation). And no, still don't rip out your response-header rules.
getDynamicRules() with 30,000 rules: the rework restarted, and November 30 is close
This one changed while the issue was being written. The first attempt, CL 8779792 (November 10), made declarativeNetRequest.getDynamicRules() return the persisted rule dicts directly. Its author abandoned it on November 16, writing in the review that "a simpler, stricter and faster approach exists". The replacement is a three-CL stack, all unmerged as of November 18: CL 8824615 (1/3, opened November 17), CL 8818470 (2/3) and CL 8805476 (3/3).
Why bother? Per the commit message, preparing the getDynamicRules() response accounts for 0.94% of browser main-thread congestion on Windows x86_64 stable (September 18 to November 1). Today the UI thread filters up to 30,000 parsed rules, converts them to a list, serializes that list for IPC and destroys both copies. Large responses also cause browser out-of-memory crashes while the message is copied into large contiguous IPC buffers.
The new stack serializes the response to JSON on the extension file task runner, one rule at a time, and the UI thread only forwards a buffer handle. The renderer parses the JSON straight into a V8 value. The audience is who you'd expect: content blockers, privacy tools, header-rewriters, the extensions that carry the biggest rulesets and call getDynamicRules() for UI sync, rule export and update-or-append flows.
What changes in your code: nothing. The commit states that error handling and rule ID filtering are unchanged, and the path is guarded by kExtensionGetDynamicRulesOffThread, disabled by default, so a merge alone changes nothing for users. The validation side effects of the abandoned CL (non-conforming entries skipped from results) went away with it.
Unmerged means the November 30 branch is this stack's gate too; the earliest train is Chrome 160 (stable January 5), flag off. Watch, don't build. Two things you can do meanwhile. If you only need a few rules, pass { ruleIds } to getDynamicRules() (Chrome 111+). And if IDs alone would do, WECG #1202, filed November 17 and nominated for triage on November 19, proposes ID-only getters for dynamic and session rules, so nobody pays for serializing thousands of full rules to read their IDs.
The Cross-Origin Storage family wakes up — and grows a third API
W46 reported chrome.crossOriginStorage idle for two weeks after missing the M158 and M159 branches. Well: on November 12 both CLs — 8605006 (the API) and 8605007 (DNR blocking by hash) — picked up their first activity since October 28, and a brand-new sibling landed the same day: CL 8802433 adds chrome.publicHash, a third MV3 API for querying the Public Hash List — the list of widely used files Cross-Origin Storage may disclose to every origin — "as chrome.publicSuffix does for the Public Suffix List," per the commit message. All three remain NEW/unmerged as of November 18, on bug 547675864.
The publicHash surface, from the CL: isListed({algorithm, hash}), getEntry(...), getEntries(hashes) (up to 1,000 results), getListInfo(), and parseIntegrity(integrity) — which extracts the SHA-256 hashes from SRI metadata, because integrity attributes and DNR speak SRI strings while lookups take hex digests. Entries tell you which upstream section lists the digest (core, manual, or a Hugging Face model-hub section), whether user agents must or should honor it, and provenance. The API is available only while the Cross-Origin Storage feature itself is enabled. It gets a publicHash permission with no install warning — "the list is public data, and a lookup reveals nothing about the user" — and one design note wrapper authors should internalize: unlike sync publicSuffix, every method is async, because the PHL is a ~19 MB memory-mapped file rather than something compiled into the renderer. Lookups even work in Incognito, where Cross-Origin Storage itself is off.
That completes the family's shape: observe and manage COS entries (crossOriginStorage, with its paged getEntries, hash-based removeEntry and payload-free onChanged), block them declaratively (DNR by hash), and now classify hashes against the public list (publicHash). The webRequest-visibility variant stays abandoned — the direction is declarative, permission-scoped control, not observation. The crossOriginStorage permission keeps its install-prompt wording: "Read and delete files that sites share with each other."
Same gate as everything else: merge by November 30 or the earliest ship slips from M160 (stable January 5 expected) to M161 (branch December 14, stable January 19). Still watch-don't-build — but if you ship a privacy or cleaner tool, this is the moment to do the math on whether parseIntegrity() + isListed() replaces your hand-rolled CDN or model-file allowlists, and to budget for that install-prompt wording in your listing.
Firefox 160's quiet breaker, one more time: arch says arm64
One shipped change keeps earning re-mentions because it fails silently. Since Firefox 160 (stable November 10), runtime.getPlatformInfo().arch returns "arm64" where it previously returned "aarch64" on ARM64 platforms — Apple Silicon, Windows-on-ARM, ARM64 Linux — aligning Firefox with the value Chrome reports (MDN, bug 2080310). No exception is thrown. if (info.arch === "aarch64") branches just stop running: native-messaging host selection, bundled-binary picking, telemetry bucketing — dead paths, not crashes.
If W45's checklist already got you, skip ahead. If not, the fix is one line — ["arm64", "aarch64"].includes(info.arch) keeps Firefox ≤159 and 160+ both working — and the arch rename plus MessageSender.windowId are the only two add-on-facing changes MDN lists for Firefox 160. windowId has been live for users since the 10th, as W46 covered; Chrome remains the holdout (bug 579968332, no CL), so keep the "windowId" in sender detection.
One calendar note: Mozilla's two feeds disagree on Firefox 161. product-details lists the next release date as November 20. The release calendar has 161 on November 24, with the release-candidate build on the 19th. The 24th is a Tuesday exactly 14 days after 160, like the last three steps (158 → 159 → 160), so that's the date I'd plan on. Firefox 160.0.1 went out November 17, and 161 is at beta 4.
The rest of the frame
- Two twin WECG proposals want
nullto clear action state. #1197 (action.setIcon({ path: null })falls back to the manifest icon) and #1198 (action.setPopup({ popup: null })removes the API override), filed November 14 by carlosjeurissen. Safari and Firefox already treat null as "clear" (implemented:labels); Chrome is the holdout atneeds-triage. Related open threads: #1165 (what shouldpath: ""do?) and #876 (an explicitrestorePopup()). #1165, #1197 and #1198 are all nominated for first triage at the November 19 WECG meeting (agenda #1184). Until Chrome takes a position, keep re-applying explicit restore values yourself — code written to null-clears breaks silently there. - Should activeTab cover the iframe the user actually clicked in? #1195, filed November 13: when a context-menu item is chosen inside a cross-origin subframe, the grant covers only the top-level document's origin, so translators, script injectors and clippers operating on embedded widgets silently fail — or fall back to the broad host permissions activeTab exists to avoid. All three vendors
needs-triage; long-standing upstream bugs linked (Firefox 1838753, Chromium 523572). It's a question, not a decision, so keep your host-permission fallbacks. As of November 18 it isn't on the nomination list for the November 19 meeting. - Chrome's dated calendar now runs twelve milestones deep. Schedules for M171 (branch 2027-05-17, stable 2027-06-08) and M172 (branch 2027-05-31, stable 2027-06-22) are on Chromium Dash, holding the 14-day cadence — M161 through M172 ship between 2027-01-19 and 2027-06-22. M172 carries the long-term-support dates (LTC 2027-06-30, LTR 2027-09-15, last refresh 2028-03-08), like M160: if you sell to managed ChromeOS fleets, that's a version some of them will stay on into 2028.
- Where the platforms stand as of November 18: Chrome 158 is stable everywhere. Windows, Mac and iOS have had it since November 12 (158.0.8127.35–.37), and the Linux build landed on the scheduled date, November 17. It carries the three changes from W45's checklist: DNR response-header value matching now needs host permissions,
blob:andfilesystem:URLs are rejected as popups, andweb_accessible_resources: "*"no longer exposes_favicon. Chrome 159 is in beta (final beta November 18, stable December 8). Firefox is on 160.0.1, with 161 next.
What I'd do this week
- Test the SPA race behind the flag if your allow-rules look at the page path. The fast lane is off by default in Chrome 159, so nothing changes for users on December 8. If
allowAllRequestsrules gate your blocking around same-document navigation, run 159 beta with--enable-features=SubresourceLoaderProxyTaskQueue, fire a subresource right afterhistory.pushState()and confirm your rules follow the new URL. - Big dynamic rulesets: change nothing, and weigh in. The
getDynamicRules()rework is internal and flag-off. If ID-only getters would save you work, WECG #1202 is up for triage on November 19; add your use case there. - Firefox + ARM64: grep for
"aarch64"today. Accept both values (["arm64", "aarch64"].includes(info.arch)) and exercise the ARM path on Firefox 160. The rename has been live in stable since November 10 and fails silently. - Privacy/cleaner tools: do the publicHash math, write no code. If the COS stack merges by November 30,
parseIntegrity()+isListed()could replace hand-rolled CDN/model-file allowlists — all-async, so your syncpublicSuffixpatterns won't port. Watch CLs 8605006 / 8605007 / 8802433. - Swap action icons or popups at runtime? Watch the November 19 WECG meeting, where #1197/#1198 (null clears state) are nominated for triage. #1195 (context menus inside cross-origin iframes) is not on the list yet. Explicit restore values remain the only safe cross-browser pattern until Chrome triages.
- Check your code against this week's changes.
npx @extenshi/cli@latest advise .finds them in your extension with the file and line — it runs locally and needs no account. Every change we track is listed at cli.extenshi.io/changes. And if you want the full second pair of eyes before your next store upload,npx @extenshi/cli scangets you 3 scans + 10 reads free with a free account (one-time); prepaid packs past that.
Sources
- Chromium CL 8494031 — high-priority browser UI queue for subresource loader proxies (MERGED 2026-11-07, main@{#1738400}, before the M159 branch position 1739869; Bug: 578355574): main-frame scope, visible-only/prerender-excluded defaults, cross-document ordering rationale and the same-document-navigation race from the commit message;
FEATURE_DISABLED_BY_DEFAULTfromcontent/common/features.ccin the same CL. CL 8793947 (MERGED 2026-11-11, main@{#1741539}) — the field-trial testing config and its experiment name - Chromium Dash milestone schedules (re-fetched 2026-11-18): M159 (branch 2026-11-09, earliest beta 2026-11-11, final beta 2026-11-18, stable 2026-12-08), M160 (branch 2026-11-30, earliest beta 2026-12-02, final beta 2026-12-09, stable cut 2026-12-15, stable 2027-01-05), M171 (branch 2027-05-17, stable 2027-06-08), M172 (feature freeze 2027-05-10, branch 2027-05-31, stable 2027-06-22; LTC 2027-06-30, LTR 2027-09-15, last refresh 2028-03-08)
- Chromium CL 8716376 — null-response-headers browser-process crash fix (MERGED 2026-11-12 03:55 UTC, main@{#1742520}; Fixed: 581338044), mirroring crrev.com/c/7014893; Activity-Log redirect-URL detail from the merged commit message; no cherry-pick of its Change-Id on any release branch as of 2026-11-18
getDynamicRules()rework (Gerrit, re-checked 2026-11-18; Bug: 568824848): CL 8779792 — ABANDONED 2026-11-16, with the author's review comment quoted above; the replacement stack, all NEW: CL 8824615 (1/3, created 2026-11-17), CL 8818470 (2/3) and CL 8805476 (3/3, both created 2026-11-14) — the 0.94% congestion figure and its measurement window, the out-of-memory note, the off-thread JSON design, the unchanged error handling and ID filtering, and thekExtensionGetDynamicRulesOffThreadgate from the commit messages;GetRulesFilter(Chrome 111+) from the declarativeNetRequest reference; WECG #1202 — ID-only getters, filed 2026-11-17- Cross-Origin Storage family (Gerrit, re-checked 2026-11-18): CL 8605006 + CL 8605007 — NEW, both updated 2026-11-12 (first activity since 2026-10-28); CL 8802433 —
chrome.publicHash, NEW, created 2026-11-12, same Bug: 547675864; API surface, permission names, install-prompt wording, no-install-warning quote, async/memory-mapped-PHL design and section semantics from the commit messages; CL 8606266 — webRequest variant, still ABANDONED 2026-10-18 - Firefox 160 for developers — MDN: the two add-on-facing changes,
arch→arm64(bug 2080310) andMessageSender.windowId(bug 2072133) - Mozilla release data (fetched 2026-11-18): major releases — 158.0 on 2026-10-13, 159.0 on 2026-10-27, 160.0 on 2026-11-10; versions —
LATEST_FIREFOX_VERSION=160.0.1(released 2026-11-17), devel 161.0b4,NEXT_RELEASE_DATE=2026-11-20; release calendar for 161 —rc_gtb2026-11-19,release2026-11-24 - WECG issues (labels fetched 2026-11-18): #1197 + #1198 — filed 2026-11-14,
implemented: safari+implemented: firefox,needs-triage: chrome; #1165 (filed 2026-10-30,spec clarification); #876 (restorePopup()); #1195 — filed 2026-11-13,needs-triageat all three vendors, referencing #1152, Firefox bug 1838753 and Chromium 523572; #1077 — windowId, with Chromium bug 579968332 open and no CL; #1184 — agenda for the 2026-11-19 meeting; the triage nominations (#1165, #1197, #1198, #1202) are in its 2026-11-11 comment - Chromium Dash release feed (fetched 2026-11-18): Stable 158.0.8127.37 on Windows and Mac and 158.0.8127.35 on iOS since 2026-11-12, 158.0.8127.36 on Linux since 2026-11-17; Beta 159.0.8154.6. The three Chrome 158 changes are in our advisories, sourced in W45
- WECG #1056 — "Inconsistency: runtime.getPlatformInfo()", cross-browser context for the arm64 convergence
- Extension Pulse 2026-W46 and 2026-W45 — the earlier coverage this issue updates
Methodology
The generator's window for this issue returned twenty-four forecast-pipeline signals: thirteen fetched 2026-11-09, covered by W46 and present here only where this week's scan updated them, and eleven fetched 2026-11-16 from primary sources: Chromium Dash release and schedule feeds, Gerrit CL status checks, WECG issue state, MDN and Mozilla product-details. I re-checked every claim against those sources on 2026-11-18. That check rewrote two sections: the getDynamicRules() CL the signals pointed at had been abandoned, and the Chrome 159 fast lane turned out to be disabled by default. The open-CL rule applies throughout: the getDynamicRules() stack and the whole Cross-Origin Storage family were unmerged as of 2026-11-18, so their dates are expectations gated on the 2026-11-30 branch point. Scheduled dates move; treat November 19, November 24, November 30, December 8 and January 5 as calendars, not promises.
This issue of Extension Pulse is compiled from Chromium Dash and Chromium Gerrit, W3C WebExtensions Community Group issues, MDN and Mozilla release data. We don't independently verify every upstream claim, and references to specific projects or companies reflect the findings of the cited sources — not accusations of intentional wrongdoing. If something here is off, tell us at [email protected].
Related Articles

Extension Pulse, week of November 9: Chrome 157 and Firefox 160 are live, and AMO has a new agreement to accept
Chrome 157's four extension changes are live in stable, Firefox 160 shipped November 10, and AMO's enterprise channel opens December 1 with a new agreement.

declarativeNetRequest in browser extensions: what a peer-reviewed study says about MV3 ad blocking
A peer-reviewed study found Manifest V3 ad blocking matches MV2 effectiveness. Here's what declarativeNetRequest really changes if you build content filters.

Content scripts in single-page apps: how to survive a route change in MV3
Your content script runs once on YouTube and never again. Fix Chrome extension SPA navigation with webNavigation — or without a new permission. Full MV3 code.