diff --git a/cef_paths2.gypi b/cef_paths2.gypi
index 05e3a2b7a..4211cfcd2 100644
--- a/cef_paths2.gypi
+++ b/cef_paths2.gypi
@@ -550,6 +550,7 @@
     'ceftests_sources_common': [
       'tests/ceftests/api_version_unittest.cc',
       'tests/ceftests/audio_output_unittest.cc',
+      'tests/ceftests/ax_viewport_collapse_unittest.cc',
       'tests/ceftests/base/atomic_flag_unittest.cc',
       'tests/ceftests/base/bind_unittest.cc',
       'tests/ceftests/base/callback_helpers_unittest.cc',
diff --git a/include/cef_browser.h b/include/cef_browser.h
index beea4a164..7d5cb6290 100644
--- a/include/cef_browser.h
+++ b/include/cef_browser.h
@@ -1072,6 +1072,23 @@ class CefBrowserHost : public virtual CefBaseRefCounted {
   ///
   /*--cef(default_retval=CEF_RUNTIME_STYLE_DEFAULT)--*/
   virtual cef_runtime_style_t GetRuntimeStyle() = 0;
+
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+  ///
+  /// Enable or disable CDP accessibility tree viewport collapse for this
+  /// browser. When enabled, off-screen landmarks and headings are serialized
+  /// as summaries and other off-screen nodes are pruned. Overrides the
+  /// CefBrowserSettings.ax_viewport_collapse value. If called on the UI thread
+  /// the change will be applied immediately. Otherwise, the change will be
+  /// applied asynchronously on the UI thread.
+  /// WARNING: This collapses the CDP accessibility tree and disables CDP
+  /// dynamic tree updates (nodesUpdated events). The DevTools Accessibility
+  /// panel will show an incomplete tree. Platform screen readers (NVDA, JAWS,
+  /// VoiceOver) are unaffected — they use a separate code path.
+  ///
+  /*--cef(added=experimental)--*/
+  virtual void SetAxViewportCollapse(bool enabled) = 0;
+#endif
 };
 
 #endif  // CEF_INCLUDE_CEF_BROWSER_H_
diff --git a/include/internal/cef_types.h b/include/internal/cef_types.h
index 98858a45d..4cc4b1e7f 100644
--- a/include/internal/cef_types.h
+++ b/include/internal/cef_types.h
@@ -721,6 +721,22 @@ typedef struct _cef_browser_settings_t {
   /// supported with Chrome style.
   ///
   cef_state_t chrome_zoom_bubble;
+
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+  ///
+  /// Controls whether CDP accessibility tree serialization collapses off-screen
+  /// nodes. When enabled, off-screen landmarks and headings are serialized as
+  /// summaries (role + name only) and other off-screen nodes are pruned.
+  /// This reduces snapshot size for AI agents using Playwright ariaSnapshot().
+  /// WARNING: This collapses the CDP accessibility tree and disables CDP
+  /// dynamic tree updates (nodesUpdated events). The DevTools Accessibility
+  /// panel will show an incomplete tree. Platform screen readers (NVDA, JAWS,
+  /// VoiceOver) are unaffected — they use a separate code path.
+  /// Can also be configured at runtime using
+  /// CefBrowserHost::SetAxViewportCollapse.
+  ///
+  cef_state_t ax_viewport_collapse;
+#endif
 } cef_browser_settings_t;
 
 ///
diff --git a/include/internal/cef_types_wrappers.h b/include/internal/cef_types_wrappers.h
index 86d620843..c514b5ecc 100644
--- a/include/internal/cef_types_wrappers.h
+++ b/include/internal/cef_types_wrappers.h
@@ -580,6 +580,9 @@ struct CefBrowserSettingsTraits {
 
     target->chrome_status_bubble = src->chrome_status_bubble;
     target->chrome_zoom_bubble = src->chrome_zoom_bubble;
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+    target->ax_viewport_collapse = src->ax_viewport_collapse;
+#endif
   }
 };
 
diff --git a/libcef/browser/browser_host_base.cc b/libcef/browser/browser_host_base.cc
index d8f6b040d..c9f84e503 100644
--- a/libcef/browser/browser_host_base.cc
+++ b/libcef/browser/browser_host_base.cc
@@ -976,6 +976,20 @@ cef_runtime_style_t CefBrowserHostBase::GetRuntimeStyle() {
   return IsAlloyStyle() ? CEF_RUNTIME_STYLE_ALLOY : CEF_RUNTIME_STYLE_CHROME;
 }
 
+void CefBrowserHostBase::SetAxViewportCollapse(bool enabled) {
+  if (!CEF_CURRENTLY_ON_UIT()) {
+    CEF_POST_TASK(CEF_UIT,
+                  base::BindOnce(&CefBrowserHostBase::SetAxViewportCollapse,
+                                 this, enabled));
+    return;
+  }
+
+  ax_viewport_collapse_ = enabled;
+  if (auto* web_contents = GetWebContents()) {
+    web_contents->OnWebPreferencesChanged();
+  }
+}
+
 void CefBrowserHostBase::ReplaceMisspelling(const CefString& word) {
   if (!CEF_CURRENTLY_ON_UIT()) {
     CEF_POST_TASK(
diff --git a/libcef/browser/browser_host_base.h b/libcef/browser/browser_host_base.h
index 069dbc21d..f984a1542 100644
--- a/libcef/browser/browser_host_base.h
+++ b/libcef/browser/browser_host_base.h
@@ -279,6 +279,7 @@ class CefBrowserHostBase : public CefBrowserHost,
   void ExitFullscreen(bool will_cause_resize) override;
   bool IsRenderProcessUnresponsive() override;
   cef_runtime_style_t GetRuntimeStyle() override;
+  void SetAxViewportCollapse(bool enabled) override;
 
   // CefBrowser methods:
   bool IsValid() override;
@@ -385,6 +386,9 @@ class CefBrowserHostBase : public CefBrowserHost,
   }
   bool is_views_hosted() const { return is_views_hosted_; }
   SkColor GetBackgroundColor() const;
+  std::optional<bool> ax_viewport_collapse() const {
+    return ax_viewport_collapse_;
+  }
 
   // Returns true if windowless rendering is enabled.
   virtual bool IsWindowless() const = 0;
@@ -518,6 +522,9 @@ class CefBrowserHostBase : public CefBrowserHost,
   };
   std::optional<AutoResizeConstraints> auto_resize_;
 
+  // Runtime override for CDP accessibility tree viewport collapse.
+  std::optional<bool> ax_viewport_collapse_;
+
  private:
   IMPLEMENT_REFCOUNTING(CefBrowserHostBase);
 };
diff --git a/libcef/browser/chrome/chrome_content_browser_client_cef.cc b/libcef/browser/chrome/chrome_content_browser_client_cef.cc
index f39ba1551..06b6f8954 100644
--- a/libcef/browser/chrome/chrome_content_browser_client_cef.cc
+++ b/libcef/browser/chrome/chrome_content_browser_client_cef.cc
@@ -426,6 +426,12 @@ void ChromeContentBrowserClientCef::OverrideWebPreferences(
   if (browser) {
     renderer_prefs::SetCefPrefs(browser->settings(), *prefs);
 
+    // Runtime override takes precedence over CefBrowserSettings.
+    if (browser->ax_viewport_collapse().has_value()) {
+      prefs->accessibility_viewport_collapse =
+          browser->ax_viewport_collapse().value();
+    }
+
     // Set the background color for the WebView.
     base_background_color = browser->GetBackgroundColor();
   } else {
diff --git a/libcef/browser/prefs/renderer_prefs.cc b/libcef/browser/prefs/renderer_prefs.cc
index e60f6043e..a2e02f3ab 100644
--- a/libcef/browser/prefs/renderer_prefs.cc
+++ b/libcef/browser/prefs/renderer_prefs.cc
@@ -5,6 +5,7 @@
 #include "cef/libcef/browser/prefs/renderer_prefs.h"
 
 #include "base/command_line.h"
+#include "cef/libcef/common/api_version_util.h"
 #include "cef/libcef/common/cef_switches.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/blink/public/common/web_preferences/web_preferences.h"
@@ -94,6 +95,10 @@ void SetCefPrefs(const CefBrowserSettings& cef,
   SET_STATE(cef.tab_to_links, web.tabs_to_links);
   SET_STATE(cef.local_storage, web.local_storage_enabled);
 
+  if (CEF_API_IS_ADDED(CEF_EXPERIMENTAL)) {
+    SET_STATE(cef.ax_viewport_collapse, web.accessibility_viewport_collapse);
+  }
+
   // Never explicitly enable GPU-related functions in this method because the
   // GPU blacklist is not being checked here.
   if (cef.webgl == STATE_DISABLED) {
diff --git a/libcef/renderer/accessibility/build_collapsed_summary_node.inc b/libcef/renderer/accessibility/build_collapsed_summary_node.inc
new file mode 100644
index 000000000..b82d0604b
--- /dev/null
+++ b/libcef/renderer/accessibility/build_collapsed_summary_node.inc
@@ -0,0 +1,61 @@
+// Copyright (c) 2026 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+// Included from inspector_type_builder_helper.cc via patch.
+// Builds a minimal AXNode for off-screen landmarks and headings:
+// role, name, and heading level (if applicable). No children.
+
+#include "ui/accessibility/ax_role_properties.h"
+
+namespace blink {
+
+std::unique_ptr<AXNode> BuildCollapsedSummaryNode(AXObject& ax_object) {
+  auto node = AXNode::create()
+                  .setNodeId(String::Number(ax_object.AXObjectID()))
+                  .setIgnored(false)
+                  .build();
+
+  ax::mojom::blink::Role role = ax_object.RoleValue();
+  node->setRole(CreateRoleNameValue(role));
+  node->setChromeRole(CreateInternalRoleValue(role));
+
+  // Accessible name.
+  ax::mojom::blink::NameFrom name_from;
+  String computed_name = ax_object.GetName(name_from, nullptr, nullptr);
+  node->setName(CreateValue(computed_name, AXValueTypeEnum::ComputedString));
+
+  // Heading level.
+  if (ui::IsHeading(static_cast<ax::mojom::Role>(role))) {
+    auto properties = std::make_unique<protocol::Array<AXProperty>>();
+    int level = ax_object.HeadingLevel();
+    if (level > 0) {
+      properties->emplace_back(
+          CreateProperty(AXPropertyNameEnum::Level, CreateValue(level)));
+    }
+    node->setProperties(std::move(properties));
+  }
+
+  // Empty children.
+  node->setChildIds(std::make_unique<protocol::Array<AXNodeId>>());
+
+  // DOM node reference.
+  Node* dom_node = ax_object.GetNode();
+  if (dom_node) {
+    node->setBackendDOMNodeId(IdentifiersFactory::IntIdForNode(dom_node));
+  }
+
+  // Parent reference.
+  const AXObject* parent = ax_object.ParentObjectIncludedInTree();
+  if (parent) {
+    node->setParentId(String::Number(parent->AXObjectID()));
+  } else if (ax_object.GetDocument() && ax_object.GetDocument()->GetFrame()) {
+    auto& frame_token =
+        ax_object.GetDocument()->GetFrame()->GetDevToolsFrameToken();
+    node->setFrameId(IdentifiersFactory::IdFromToken(frame_token));
+  }
+
+  return node;
+}
+
+}  // namespace blink
diff --git a/libcef/renderer/accessibility/viewport_collapse.cc b/libcef/renderer/accessibility/viewport_collapse.cc
new file mode 100644
index 000000000..b4a3833c0
--- /dev/null
+++ b/libcef/renderer/accessibility/viewport_collapse.cc
@@ -0,0 +1,62 @@
+// Copyright (c) 2026 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+#include "cef/libcef/renderer/accessibility/viewport_collapse.h"
+
+#include "third_party/blink/renderer/core/dom/document.h"
+#include "third_party/blink/renderer/core/frame/local_frame_view.h"
+#include "third_party/blink/renderer/core/frame/settings.h"
+#include "third_party/blink/renderer/core/frame/visual_viewport.h"
+#include "third_party/blink/renderer/core/page/page.h"
+#include "third_party/blink/renderer/core/paint/paint_layer_scrollable_area.h"
+#include "third_party/blink/renderer/modules/accessibility/ax_object.h"
+#include "ui/accessibility/ax_role_properties.h"
+
+namespace cef {
+
+bool IsViewportCollapseEnabled(blink::Document& document) {
+  auto* settings = document.GetSettings();
+  return settings && settings->GetAccessibilityViewportCollapse();
+}
+
+blink::PhysicalRect ComputeViewportRect(blink::Document& document) {
+  blink::LocalFrameView* frame_view = document.View();
+
+  // The visual viewport's VisibleContentRect accounts for pinch-zoom scroll
+  // but not layout viewport scroll. For a normal (non-zoomed) page, the
+  // visual viewport offset is (0,0) and all scrolling is on the layout
+  // viewport. We need the full visible area in document coordinates, so
+  // combine both: start from the visual viewport rect (which has the correct
+  // size and visual viewport offset) and add the layout viewport scroll.
+  auto rect = blink::PhysicalRect(
+      frame_view->GetPage()->GetVisualViewport().VisibleContentRect());
+  if (auto* layout_viewport = frame_view->LayoutViewport()) {
+    blink::ScrollOffset scroll = layout_viewport->GetScrollOffset();
+    rect.offset.left += blink::LayoutUnit(scroll.x());
+    rect.offset.top += blink::LayoutUnit(scroll.y());
+  }
+  return rect;
+}
+
+bool IsNodeInViewport(const blink::AXObject& ax_object,
+                      const blink::PhysicalRect& viewport_rect) {
+  blink::PhysicalRect bounds = ax_object.GetBoundsInFrameCoordinates();
+  return bounds.Intersects(viewport_rect);
+}
+
+ViewportCollapseAction ClassifyOffScreenNode(ax::mojom::blink::Role role) {
+  ax::mojom::Role r = static_cast<ax::mojom::Role>(role);
+  if (ui::IsLandmark(r) || ui::IsHeading(r)) {
+    return ViewportCollapseAction::kSummary;
+  }
+  // Chromium maps <footer> to kFooter and <header> to kHeader, which are
+  // distinct from kContentInfo/kBanner used by IsLandmark(). Treat them
+  // as landmarks for collapsing purposes.
+  if (r == ax::mojom::Role::kFooter || r == ax::mojom::Role::kHeader) {
+    return ViewportCollapseAction::kSummary;
+  }
+  return ViewportCollapseAction::kPrune;
+}
+
+}  // namespace cef
diff --git a/libcef/renderer/accessibility/viewport_collapse.h b/libcef/renderer/accessibility/viewport_collapse.h
new file mode 100644
index 000000000..32bb7dabe
--- /dev/null
+++ b/libcef/renderer/accessibility/viewport_collapse.h
@@ -0,0 +1,36 @@
+// Copyright (c) 2026 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+#ifndef CEF_LIBCEF_RENDERER_ACCESSIBILITY_VIEWPORT_COLLAPSE_H_
+#define CEF_LIBCEF_RENDERER_ACCESSIBILITY_VIEWPORT_COLLAPSE_H_
+
+#include "third_party/blink/renderer/core/layout/geometry/physical_rect.h"
+#include "ui/accessibility/ax_enums.mojom-blink.h"
+
+namespace blink {
+class AXObject;
+class Document;
+}  // namespace blink
+
+namespace cef {
+
+enum class ViewportCollapseAction { kSummary, kPrune };
+
+// Check if viewport collapse is enabled for this document (reads Blink
+// Settings).
+bool IsViewportCollapseEnabled(blink::Document& document);
+
+// Compute viewport rect from the document's visual viewport.
+blink::PhysicalRect ComputeViewportRect(blink::Document& document);
+
+// Check if a node intersects the viewport.
+bool IsNodeInViewport(const blink::AXObject& ax_object,
+                      const blink::PhysicalRect& viewport_rect);
+
+// Classify an off-screen node by role.
+ViewportCollapseAction ClassifyOffScreenNode(ax::mojom::blink::Role role);
+
+}  // namespace cef
+
+#endif  // CEF_LIBCEF_RENDERER_ACCESSIBILITY_VIEWPORT_COLLAPSE_H_
diff --git a/libcef/renderer/accessibility/walk_ax_nodes_with_collapse.inc b/libcef/renderer/accessibility/walk_ax_nodes_with_collapse.inc
new file mode 100644
index 000000000..1e4d7a0ce
--- /dev/null
+++ b/libcef/renderer/accessibility/walk_ax_nodes_with_collapse.inc
@@ -0,0 +1,170 @@
+// Copyright 2026 The Chromium Embedded Framework Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Included from inspector_accessibility_agent.cc via patch (anonymous
+// namespace). Viewport-collapse-aware variants of AddChildren and
+// WalkAXNodesToDepth.
+
+// Check if a node might be in-viewport despite having an off-screen parent.
+// Only position:fixed and position:sticky elements can escape their parent's
+// off-screen bounds. This is much cheaper than GetBoundsInFrameCoordinates().
+bool MayBeVisibleDespiteOffscreenParent(const AXObject& ax_object) {
+  auto* layout = ax_object.GetLayoutObject();
+  return layout &&
+         (layout->IsFixedPositioned() || layout->IsStickyPositioned());
+}
+
+struct BfsEntry {
+  AXID id;
+  int depth;
+  bool parent_offscreen;
+};
+
+void AddChildrenWithCollapse(AXObject& ax_object,
+                             bool follow_ignored,
+                             std::unique_ptr<protocol::Array<AXNode>>& nodes,
+                             AXObjectCacheImpl& cache,
+                             const PhysicalRect& viewport_rect,
+                             HashSet<AXID>& serialized_ids,
+                             HashSet<AXID>& in_viewport_ids,
+                             bool parent_offscreen,
+                             Deque<BfsEntry>* queue,
+                             int depth,
+                             int max_depth) {
+  // Track IDs of nodes reached via pruned off-screen parents. If such a
+  // node turns out to be in-viewport (e.g. position:fixed), it must be
+  // enqueued in the BFS since the normal child-enqueue loop won't find it.
+  HashSet<AXID> from_pruned_ids;
+
+  HeapVector<Member<AXObject>> reachable;
+  reachable.Append(ax_object.ChildrenIncludingIgnored().rbegin(),
+                   ax_object.ChildrenIncludingIgnored().rend());
+
+  while (!reachable.empty()) {
+    AXObject* descendant = reachable.back();
+    reachable.pop_back();
+    if (descendant->IsDetached()) {
+      continue;
+    }
+
+    bool from_pruned = from_pruned_ids.Contains(descendant->AXObjectID());
+
+    if (follow_ignored &&
+        (descendant->IsIgnoredButIncludedInTree() || !descendant->GetNode())) {
+      const auto& children = descendant->ChildrenIncludingIgnored();
+      reachable.Append(children.rbegin(), children.rend());
+      if (from_pruned) {
+        for (const auto& child : children) {
+          from_pruned_ids.insert(child->AXObjectID());
+        }
+      }
+    }
+
+    // Determine viewport status. If parent is off-screen, skip the expensive
+    // bounds check unless this node has fixed/sticky positioning.
+    bool effectively_offscreen = parent_offscreen || from_pruned;
+    bool in_viewport;
+    if (effectively_offscreen &&
+        !MayBeVisibleDespiteOffscreenParent(*descendant)) {
+      in_viewport = false;
+    } else {
+      in_viewport = cef::IsNodeInViewport(*descendant, viewport_rect);
+    }
+
+    if (!in_viewport) {
+      auto action = cef::ClassifyOffScreenNode(descendant->RoleValue());
+      if (action == cef::ViewportCollapseAction::kSummary) {
+        // Landmark/heading: emit summary, cut subtree entirely.
+        nodes->emplace_back(BuildCollapsedSummaryNode(*descendant));
+        serialized_ids.insert(descendant->AXObjectID());
+      } else {
+        // Pruned generic node: still visit children so that position:fixed
+        // or position:sticky descendants can escape the off-screen parent.
+        const auto& children = descendant->ChildrenIncludingIgnored();
+        reachable.Append(children.rbegin(), children.rend());
+        for (const auto& child : children) {
+          from_pruned_ids.insert(child->AXObjectID());
+        }
+      }
+      continue;
+    }
+
+    in_viewport_ids.insert(descendant->AXObjectID());
+    auto child_node = BuildProtocolAXNodeForAXObject(*descendant);
+    serialized_ids.insert(descendant->AXObjectID());
+    nodes->emplace_back(std::move(child_node));
+
+    // If this in-viewport node was discovered via a pruned off-screen parent,
+    // it won't be enqueued by the normal BFS child loop (which only checks
+    // direct unignored children). Enqueue it here so its subtree is visited.
+    if (from_pruned && queue && (max_depth == -1 || depth < max_depth)) {
+      queue->emplace_back(BfsEntry{descendant->AXObjectID(), depth + 1, false});
+    }
+  }
+}
+
+std::unique_ptr<protocol::Array<AXNode>> WalkAXNodesToDepthWithCollapse(
+    AXObjectCacheImpl& cache,
+    int max_depth) {
+  auto nodes = std::make_unique<protocol::Array<AXNode>>();
+  HashSet<AXID> serialized_ids;
+  HashSet<AXID> in_viewport_ids;  // Tracks which nodes passed bounds check
+  PhysicalRect viewport_rect = cef::ComputeViewportRect(cache.GetDocument());
+
+  Deque<BfsEntry> queue;
+  queue.emplace_back(BfsEntry{cache.Root()->AXObjectID(), 1, false});
+  nodes->emplace_back(BuildProtocolAXNodeForAXObject(*cache.Root()));
+  serialized_ids.insert(cache.Root()->AXObjectID());
+  in_viewport_ids.insert(cache.Root()->AXObjectID());
+
+  while (!queue.empty()) {
+    auto [id, depth, parent_offscreen] = queue.front();
+    queue.pop_front();
+    AXObject* ax_object = cache.ObjectFromAXID(id);
+    if (!ax_object) {
+      continue;
+    }
+
+    // Serialize children — records viewport status in in_viewport_ids.
+    // Passes queue so that in-viewport nodes found under pruned parents
+    // can be enqueued for further traversal.
+    AddChildrenWithCollapse(*ax_object, true, nodes, cache, viewport_rect,
+                            serialized_ids, in_viewport_ids, parent_offscreen,
+                            &queue, depth, max_depth);
+
+    // Enqueue in-viewport unignored children for depth traversal.
+    // Uses in_viewport_ids instead of recomputing bounds.
+    const auto& children = ax_object->UnignoredChildrenSlow();
+    for (auto& child : children) {
+      bool child_in_viewport = in_viewport_ids.Contains(child->AXObjectID());
+      if (!child_in_viewport) {
+        // Already handled (serialized as summary or pruned) in
+        // AddChildrenWithCollapse. Don't recurse.
+        continue;
+      }
+      if (max_depth == -1 || depth < max_depth) {
+        queue.emplace_back(BfsEntry{child->AXObjectID(), depth + 1, false});
+      }
+    }
+  }
+
+  // Filter childIds to only reference serialized nodes.
+  // Summary nodes already have empty childIds so this only matters for
+  // full nodes whose children were partially pruned.
+  for (auto& node : *nodes) {
+    auto* child_ids = node->getChildIds(nullptr);
+    if (!child_ids || child_ids->empty()) {
+      continue;
+    }
+    auto filtered = std::make_unique<protocol::Array<AXNodeId>>();
+    for (const auto& child_id : *child_ids) {
+      if (serialized_ids.Contains(StringToIntStrict(child_id).value_or(0))) {
+        filtered->emplace_back(child_id);
+      }
+    }
+    node->setChildIds(std::move(filtered));
+  }
+
+  return nodes;
+}
diff --git a/patch/patch.cfg b/patch/patch.cfg
index 5e24c84af..5012b63aa 100644
--- a/patch/patch.cfg
+++ b/patch/patch.cfg
@@ -850,5 +850,11 @@ patches = [
     # Support CEF component updater API.
     # https://github.com/chromiumembedded/cef/issues/4087
     'name': 'component_updater_4087'
+  },
+  {
+    # Support per-browser accessibility viewport collapse for CDP tree collapsing.
+    # Collapses off-screen nodes in CDP accessibility serialization to reduce
+    # snapshot size for AI agents. Controlled via CefBrowserSettings.
+    'name': 'blink_ax_viewport_collapse',
   }
 ]
diff --git a/patch/patches/blink_ax_viewport_collapse.patch b/patch/patches/blink_ax_viewport_collapse.patch
new file mode 100644
index 000000000..167358928
--- /dev/null
+++ b/patch/patches/blink_ax_viewport_collapse.patch
@@ -0,0 +1,271 @@
+diff --git third_party/blink/common/web_preferences/web_preferences_mojom_traits.cc third_party/blink/common/web_preferences/web_preferences_mojom_traits.cc
+index 23672617af41f1d88b551da7b4ad0a19e39a2092..6e9b90bad48d090a7f52b3598d0e57c7cbb66713 100644
+--- third_party/blink/common/web_preferences/web_preferences_mojom_traits.cc
++++ third_party/blink/common/web_preferences/web_preferences_mojom_traits.cc
+@@ -232,6 +232,7 @@ bool StructTraits<blink::mojom::WebPreferencesDataView,
+   out->lazy_load_enabled = data.lazy_load_enabled();
+   out->allow_mixed_content_upgrades = data.allow_mixed_content_upgrades();
+   out->always_show_focus = data.always_show_focus();
++  out->accessibility_viewport_collapse = data.accessibility_viewport_collapse();
+   out->touch_drag_drop_enabled = data.touch_drag_drop_enabled();
+   out->touch_dragend_context_menu = data.touch_dragend_context_menu();
+   out->webxr_immersive_ar_allowed = data.webxr_immersive_ar_allowed();
+diff --git third_party/blink/public/common/web_preferences/web_preferences.h third_party/blink/public/common/web_preferences/web_preferences.h
+index cd34e8f534e86d4ff11ea1d8020d215f37cd730b..c2218516b5e09fae2629db13ca8f9f83d30f617a 100644
+--- third_party/blink/public/common/web_preferences/web_preferences.h
++++ third_party/blink/public/common/web_preferences/web_preferences.h
+@@ -423,6 +423,9 @@ struct BLINK_COMMON_EXPORT WebPreferences {
+   // forcing :focus-visible to match regardless of focus method).
+   bool always_show_focus = false;
+ 
++  // Whether CDP accessibility tree serialization collapses off-screen nodes.
++  bool accessibility_viewport_collapse = false;
++
+   // Whether touch input can trigger HTML drag-and-drop operations. The
+   // default value depends on the platform.
+   bool touch_drag_drop_enabled = false;
+diff --git third_party/blink/public/common/web_preferences/web_preferences_mojom_traits.h third_party/blink/public/common/web_preferences/web_preferences_mojom_traits.h
+index 9bb06fb430cbf31b6fc1343229191565a62421a8..0656126a6ae01ce603cc56247b79a40f53dccc07 100644
+--- third_party/blink/public/common/web_preferences/web_preferences_mojom_traits.h
++++ third_party/blink/public/common/web_preferences/web_preferences_mojom_traits.h
+@@ -785,6 +785,11 @@ struct BLINK_COMMON_EXPORT StructTraits<blink::mojom::WebPreferencesDataView,
+     return r.always_show_focus;
+   }
+ 
++  static bool accessibility_viewport_collapse(
++      const blink::web_pref::WebPreferences& r) {
++    return r.accessibility_viewport_collapse;
++  }
++
+   static bool touch_drag_drop_enabled(
+       const blink::web_pref::WebPreferences& r) {
+     return r.touch_drag_drop_enabled;
+diff --git third_party/blink/public/mojom/webpreferences/web_preferences.mojom third_party/blink/public/mojom/webpreferences/web_preferences.mojom
+index ec6f13d3924cf861c505ed6d3abde0371fd65475..195d7a3a6c464c959239b55bd114f9c1a0b65131 100644
+--- third_party/blink/public/mojom/webpreferences/web_preferences.mojom
++++ third_party/blink/public/mojom/webpreferences/web_preferences.mojom
+@@ -482,6 +482,9 @@ struct WebPreferences {
+   // forcing :focus-visible to match regardless of focus method).
+   bool always_show_focus;
+ 
++  // Whether CDP accessibility tree serialization collapses off-screen nodes.
++  bool accessibility_viewport_collapse;
++
+   // Whether touch input can trigger HTML drag-and-drop operations. The
+   // default value depends on the platform.
+   bool touch_drag_drop_enabled;
+diff --git third_party/blink/public/web/web_settings.h third_party/blink/public/web/web_settings.h
+index 42dcdc73fd3255fc4af472ddcc885dd9444f9bae..d21caf62ce8f7175f9ffbd7432013b9b48680d57 100644
+--- third_party/blink/public/web/web_settings.h
++++ third_party/blink/public/web/web_settings.h
+@@ -228,6 +228,7 @@ class WebSettings {
+   virtual void SetAccessibilityFontScaleFactor(float) = 0;
+   virtual void SetAccessibilityTextSizeContrastFactor(int) = 0;
+   virtual void SetAccessibilityAlwaysShowFocus(bool) = 0;
++  virtual void SetAccessibilityViewportCollapse(bool) = 0;
+   virtual void SetTextTrackKindUserPreference(TextTrackKindUserPreference) = 0;
+   virtual void SetTextTrackBackgroundColor(const WebString&) = 0;
+   virtual void SetTextTrackFontFamily(const WebString&) = 0;
+diff --git third_party/blink/renderer/core/exported/web_settings_impl.cc third_party/blink/renderer/core/exported/web_settings_impl.cc
+index e3532e382addf2efde5e60d0f4ae985cac8232a0..3a6551e8aeaba43d4c91b94211b99e5e620dbf10 100644
+--- third_party/blink/renderer/core/exported/web_settings_impl.cc
++++ third_party/blink/renderer/core/exported/web_settings_impl.cc
+@@ -175,6 +175,10 @@ void WebSettingsImpl::SetAccessibilityAlwaysShowFocus(bool always_show_focus) {
+   settings_->SetAccessibilityAlwaysShowFocus(always_show_focus);
+ }
+ 
++void WebSettingsImpl::SetAccessibilityViewportCollapse(bool enabled) {
++  settings_->SetAccessibilityViewportCollapse(enabled);
++}
++
+ void WebSettingsImpl::SetAccessibilityPasswordValuesEnabled(bool enabled) {
+   settings_->SetAccessibilityPasswordValuesEnabled(enabled);
+ }
+diff --git third_party/blink/renderer/core/exported/web_settings_impl.h third_party/blink/renderer/core/exported/web_settings_impl.h
+index 333634ea2567af0114a951ae47535ec42435cc9e..28bf3e044d69c8be0fed3d63f778bc551ce3797b 100644
+--- third_party/blink/renderer/core/exported/web_settings_impl.h
++++ third_party/blink/renderer/core/exported/web_settings_impl.h
+@@ -174,6 +174,7 @@ class CORE_EXPORT WebSettingsImpl final : public WebSettings {
+   void SetAccessibilityFontScaleFactor(float) override;
+   void SetAccessibilityTextSizeContrastFactor(int) override;
+   void SetAccessibilityAlwaysShowFocus(bool) override;
++  void SetAccessibilityViewportCollapse(bool) override;
+   void SetTextTrackKindUserPreference(TextTrackKindUserPreference) override;
+   void SetTextTrackBackgroundColor(const WebString&) override;
+   void SetTextTrackFontFamily(const WebString&) override;
+diff --git third_party/blink/renderer/core/exported/web_view_impl.cc third_party/blink/renderer/core/exported/web_view_impl.cc
+index f5bdcb8176a94705a3710ba5dbc536a96b35fed9..742ac4bcc69f02779535c376e2897f706a671eec 100644
+--- third_party/blink/renderer/core/exported/web_view_impl.cc
++++ third_party/blink/renderer/core/exported/web_view_impl.cc
+@@ -1834,6 +1834,8 @@ void WebView::ApplyWebPreferences(const web_pref::WebPreferences& prefs,
+   settings->SetForceDarkModeEnabled(prefs.force_dark_mode_enabled);
+ 
+   settings->SetAccessibilityAlwaysShowFocus(prefs.always_show_focus);
++  settings->SetAccessibilityViewportCollapse(
++      prefs.accessibility_viewport_collapse);
+   settings->SetAutoplayPolicy(prefs.autoplay_policy);
+   settings->SetRequireTransientActivationForGetDisplayMedia(
+       prefs.require_transient_activation_for_get_display_media);
+@@ -3250,6 +3252,7 @@ void WebViewImpl::OnWindowShowStateChanged(
+         WasRestored();
+       }
+       break;
++    case WindowShowState::kHidden:
+     case WindowShowState::kInactive:
+     case WindowShowState::kFullscreen:
+     case WindowShowState::kEnd:
+diff --git third_party/blink/renderer/core/frame/settings.json5 third_party/blink/renderer/core/frame/settings.json5
+index d9d3a09b53e250b7a019195214186add0b85d562..9de56e24eca711dc82700ad3f49ed92a32ee4c75 100644
+--- third_party/blink/renderer/core/frame/settings.json5
++++ third_party/blink/renderer/core/frame/settings.json5
+@@ -1231,6 +1231,10 @@
+       name: "accessibilityIncludeSvgGElement",
+       initial: false,
+     },
++    {
++      name: "accessibilityViewportCollapse",
++      initial: false,
++    },
+     {
+       name: "bypassCSP",
+       initial: false,
+diff --git third_party/blink/renderer/modules/accessibility/BUILD.gn third_party/blink/renderer/modules/accessibility/BUILD.gn
+index f9de92e534a5eaaa012633b72e593a3075bbf48c..50bd9bac40ab76c1eda9eb3bc964ca41a087918f 100644
+--- third_party/blink/renderer/modules/accessibility/BUILD.gn
++++ third_party/blink/renderer/modules/accessibility/BUILD.gn
+@@ -2,6 +2,7 @@
+ # Use of this source code is governed by a BSD-style license that can be
+ # found in the LICENSE file.
+ 
++import("//cef/libcef/features/features.gni")
+ import("//third_party/blink/renderer/modules/modules.gni")
+ 
+ blink_modules_sources("accessibility") {
+@@ -74,6 +75,17 @@ blink_modules_sources("accessibility") {
+     ]
+   }
+ 
++  if (enable_cef) {
++    sources += [
++      "//cef/libcef/renderer/accessibility/build_collapsed_summary_node.inc",
++      "//cef/libcef/renderer/accessibility/viewport_collapse.cc",
++      "//cef/libcef/renderer/accessibility/viewport_collapse.h",
++      "//cef/libcef/renderer/accessibility/walk_ax_nodes_with_collapse.inc",
++    ]
++    configs += [ "//cef/libcef/features:config" ]
++    deps += [ "//cef/libcef/features:deps" ]
++  }
++
+   if (is_android) {
+     defines = [ "REDUCE_AX_INLINE_TEXTBOXES" ]
+   }
+diff --git third_party/blink/renderer/modules/accessibility/inspector_accessibility_agent.cc third_party/blink/renderer/modules/accessibility/inspector_accessibility_agent.cc
+index e7f9651c0865b36aecf96a44c1061a7a40aabf43..91f0feb8e2f31c53f9425b5d874b6dc71d0544c1 100644
+--- third_party/blink/renderer/modules/accessibility/inspector_accessibility_agent.cc
++++ third_party/blink/renderer/modules/accessibility/inspector_accessibility_agent.cc
+@@ -7,6 +7,7 @@
+ #include <memory>
+ 
+ #include "base/containers/adapters.h"
++#include "cef/libcef/features/features.h"
+ #include "third_party/blink/renderer/core/accessibility/ax_object_cache.h"
+ #include "third_party/blink/renderer/core/dom/dom_node_ids.h"
+ #include "third_party/blink/renderer/core/dom/element.h"
+@@ -30,6 +31,10 @@
+ #include "ui/accessibility/ax_mode.h"
+ #include "ui/accessibility/ax_node_data.h"
+ 
++#if BUILDFLAG(ENABLE_CEF)
++#include "cef/libcef/renderer/accessibility/viewport_collapse.h"
++#endif
++
+ namespace blink {
+ 
+ namespace {
+@@ -132,6 +137,10 @@ std::unique_ptr<protocol::Array<AXNode>> WalkAXNodesToDepth(
+   return nodes;
+ }
+ 
++#if BUILDFLAG(ENABLE_CEF)
++#include "cef/libcef/renderer/accessibility/walk_ax_nodes_with_collapse.inc"
++#endif
++
+ }  // namespace
+ 
+ using EnabledAgentsMultimap =
+@@ -245,7 +254,14 @@ protocol::Response InspectorAccessibilityAgent::getFullAXTree(
+   cache.UpdateAXForAllDocuments();
+   ScopedFreezeAXCache freeze(cache);
+ 
+-  *nodes = WalkAXNodesToDepth(cache, depth.value_or(-1));
++#if BUILDFLAG(ENABLE_CEF)
++  if (cef::IsViewportCollapseEnabled(cache.GetDocument())) {
++    *nodes = WalkAXNodesToDepthWithCollapse(cache, depth.value_or(-1));
++  } else
++#endif
++  {
++    *nodes = WalkAXNodesToDepth(cache, depth.value_or(-1));
++  }
+ 
+   return protocol::Response::Success();
+ }
+@@ -509,6 +525,15 @@ void InspectorAccessibilityAgent::AXReadyCallback(Document& document) {
+ }
+ 
+ void InspectorAccessibilityAgent::ProcessPendingDirtyNodes(Document& document) {
++#if BUILDFLAG(ENABLE_CEF)
++  // Suppress nodesUpdated events when viewport collapse is active.
++  // These events send uncollapsed data, creating an inconsistent tree.
++  // AI agents call getFullAXTree() directly without enable(), so they
++  // never receive these events anyway.
++  if (cef::IsViewportCollapseEnabled(document))
++    return;
++#endif
++
+   auto now = base::Time::Now();
+ 
+   if (!last_sync_times_.Contains(&document))
+diff --git third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.cc third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.cc
+index ad0547c3c362ea975bca43b53592d88afbd15603..6dac1c010b2b3a694d1c0c87b335f2009fa30079 100644
+--- third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.cc
++++ third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.cc
+@@ -4,6 +4,7 @@
+ 
+ #include "third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.h"
+ 
++#include "cef/libcef/features/features.h"
+ #include "third_party/blink/renderer/core/dom/dom_node_ids.h"
+ #include "third_party/blink/renderer/core/frame/local_frame.h"
+ #include "third_party/blink/renderer/core/inspector/identifiers_factory.h"
+@@ -922,3 +923,7 @@ std::unique_ptr<AXNode> BuildProtocolAXNodeForUnignoredAXObject(
+ }
+ 
+ }  // namespace blink
++
++#if BUILDFLAG(ENABLE_CEF)
++#include "cef/libcef/renderer/accessibility/build_collapsed_summary_node.inc"
++#endif
+diff --git third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.h third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.h
+index 2c8d5a8aada7230bc141feed9e1af2e6e95d3664..ee1829e828b30eb33e9f4834db7ed3f81280862c 100644
+--- third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.h
++++ third_party/blink/renderer/modules/accessibility/inspector_type_builder_helper.h
+@@ -8,6 +8,8 @@
+ #include "third_party/blink/renderer/core/accessibility/axid.h"
+ #include "third_party/blink/renderer/core/inspector/protocol/accessibility.h"
+ 
++#include "cef/libcef/features/features.h"
++
+ namespace blink {
+ 
+ class AXObject;
+@@ -25,6 +27,10 @@ std::unique_ptr<AXNode> BuildProtocolAXNodeForIgnoredAXObject(
+     bool force_name_and_role);
+ std::unique_ptr<AXNode> BuildProtocolAXNodeForUnignoredAXObject(AXObject&);
+ 
++#if BUILDFLAG(ENABLE_CEF)
++std::unique_ptr<AXNode> BuildCollapsedSummaryNode(AXObject& ax_object);
++#endif
++
+ }  // namespace blink
+ 
+ #endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_ACCESSIBILITY_INSPECTOR_TYPE_BUILDER_HELPER_H_
diff --git a/patch/patches/views_widget.patch b/patch/patches/views_widget.patch
index bb15c54b5..2f975629b 100644
--- a/patch/patches/views_widget.patch
+++ b/patch/patches/views_widget.patch
@@ -214,18 +214,6 @@ index c87f079a6541866fa00cc96e7dfed11d743ba182..17c949f873124021ae69b2fe9d469913
  #if BUILDFLAG(IS_MAC)
    // Set the view's active state (i.e., tint state of controls).
    virtual void SetActive(bool active) = 0;
-diff --git third_party/blink/renderer/core/exported/web_view_impl.cc third_party/blink/renderer/core/exported/web_view_impl.cc
-index f5bdcb8176a94705a3710ba5dbc536a96b35fed9..09122a6fdc4dbdc61fb580110473265c6ee2c661 100644
---- third_party/blink/renderer/core/exported/web_view_impl.cc
-+++ third_party/blink/renderer/core/exported/web_view_impl.cc
-@@ -3250,6 +3250,7 @@ void WebViewImpl::OnWindowShowStateChanged(
-         WasRestored();
-       }
-       break;
-+    case WindowShowState::kHidden:
-     case WindowShowState::kInactive:
-     case WindowShowState::kFullscreen:
-     case WindowShowState::kEnd:
 diff --git ui/aura/native_window_occlusion_tracker_win.cc ui/aura/native_window_occlusion_tracker_win.cc
 index 883f23810672adf94c8b86f8ec54dc6ac9e7acbb..5d1a2b11c2cea3b247077f96c35780e40efa70f5 100644
 --- ui/aura/native_window_occlusion_tracker_win.cc
diff --git a/tests/cefclient/browser/main_context_impl.cc b/tests/cefclient/browser/main_context_impl.cc
index dee74603d..f93a81583 100644
--- a/tests/cefclient/browser/main_context_impl.cc
+++ b/tests/cefclient/browser/main_context_impl.cc
@@ -241,6 +241,12 @@ void MainContextImpl::PopulateBrowserSettings(CefBrowserSettings* settings) {
     settings->chrome_status_bubble = STATE_DISABLED;
     settings->chrome_zoom_bubble = STATE_DISABLED;
   }
+
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+  if (command_line_->HasSwitch(switches::kAxViewportCollapse)) {
+    settings->ax_viewport_collapse = STATE_ENABLED;
+  }
+#endif
 }
 
 void MainContextImpl::PopulateOsrSettings(OsrRendererSettings* settings) {
diff --git a/tests/ceftests/ax_viewport_collapse_unittest.cc b/tests/ceftests/ax_viewport_collapse_unittest.cc
new file mode 100644
index 000000000..648860ab4
--- /dev/null
+++ b/tests/ceftests/ax_viewport_collapse_unittest.cc
@@ -0,0 +1,1047 @@
+// Copyright (c) 2026 The Chromium Embedded Framework Authors. All rights
+// reserved. Use of this source code is governed by a BSD-style license that
+// can be found in the LICENSE file.
+
+#include <string>
+
+#include "include/base/cef_callback.h"
+#include "include/cef_devtools_message_observer.h"
+#include "include/cef_parser.h"
+#include "include/wrapper/cef_closure_task.h"
+#include "tests/ceftests/test_handler.h"
+#include "tests/gtest/include/gtest/gtest.h"
+
+namespace {
+
+// Helper: parse a CDP JSON response into a CefDictionaryValue.
+CefRefPtr<CefDictionaryValue> ParseResponse(const void* data, size_t size) {
+  std::string json(static_cast<const char*>(data), size);
+  CefRefPtr<CefValue> value =
+      CefParseJSON(json.data(), json.size(), JSON_PARSER_RFC);
+  if (value && value->GetType() == VTYPE_DICTIONARY) {
+    return value->GetDictionary();
+  }
+  return nullptr;
+}
+
+// Helper: find a node in the AX tree response by string property.
+// Searches nodes array for a node whose "name.value" matches |name|.
+CefRefPtr<CefDictionaryValue> FindNodeByName(CefRefPtr<CefListValue> nodes,
+                                             const std::string& name) {
+  for (size_t i = 0; i < nodes->GetSize(); i++) {
+    auto node = nodes->GetDictionary(i);
+    if (node->HasKey("name")) {
+      auto name_val = node->GetDictionary("name");
+      if (name_val && name_val->HasKey("value") &&
+          name_val->GetString("value").ToString() == name) {
+        return node;
+      }
+    }
+  }
+  return nullptr;
+}
+
+// Helper: check if a node with the given name exists in the tree.
+bool HasNodeWithName(CefRefPtr<CefListValue> nodes, const std::string& name) {
+  return FindNodeByName(nodes, name) != nullptr;
+}
+
+// Helper: count nodes in tree.
+size_t NodeCount(CefRefPtr<CefListValue> nodes) {
+  return nodes->GetSize();
+}
+
+// Helper: get the "level" property from a node's properties array.
+int GetLevelProperty(CefRefPtr<CefDictionaryValue> node) {
+  if (!node->HasKey("properties")) {
+    return -1;
+  }
+  auto props = node->GetList("properties");
+  for (size_t i = 0; i < props->GetSize(); i++) {
+    auto prop = props->GetDictionary(i);
+    if (prop->GetString("name").ToString() == "level") {
+      auto val = prop->GetDictionary("value");
+      if (val) {
+        return val->GetInt("value");
+      }
+    }
+  }
+  return -1;
+}
+
+// Helper: check if a node has empty childIds.
+bool HasEmptyChildIds(CefRefPtr<CefDictionaryValue> node) {
+  if (!node->HasKey("childIds")) {
+    return true;
+  }
+  return node->GetList("childIds")->GetSize() == 0;
+}
+
+// Base class for viewport collapse tests.
+class AxViewportCollapseTestHandler : public TestHandler {
+ public:
+  AxViewportCollapseTestHandler(cef_state_t collapse_state,
+                                const char* url,
+                                const char* html)
+      : collapse_state_(collapse_state), url_(url), html_(html) {}
+
+  AxViewportCollapseTestHandler(const AxViewportCollapseTestHandler&) = delete;
+  AxViewportCollapseTestHandler& operator=(
+      const AxViewportCollapseTestHandler&) = delete;
+
+  void RunTest() override {
+    AddResource(url_, html_, "text/html");
+
+    CefBrowserSettings settings;
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+    settings.ax_viewport_collapse = collapse_state_;
+#endif
+    CreateBrowserWithSettings(url_, settings);
+    SetTestTimeout();
+  }
+
+  void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
+    TestHandler::OnAfterCreated(browser);
+    registration_ =
+        browser->GetHost()->AddDevToolsMessageObserver(new Observer(this));
+  }
+
+  void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+                            bool isLoading,
+                            bool canGoBack,
+                            bool canGoForward) override {
+    if (!isLoading) {
+      // Page loaded. Fetch the full AX tree.
+      GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+          ++next_message_id_, "Accessibility.getFullAXTree", nullptr);
+    }
+  }
+
+  // Subclasses implement this to verify the AX tree.
+  virtual void VerifyTree(CefRefPtr<CefListValue> nodes) = 0;
+
+  void DestroyTest() override {
+    registration_ = nullptr;
+    EXPECT_TRUE(got_result_);
+    TestHandler::DestroyTest();
+  }
+
+ protected:
+  class Observer : public CefDevToolsMessageObserver {
+   public:
+    explicit Observer(AxViewportCollapseTestHandler* handler)
+        : handler_(handler) {}
+
+    Observer(const Observer&) = delete;
+    Observer& operator=(const Observer&) = delete;
+
+    void OnDevToolsMethodResult(CefRefPtr<CefBrowser> browser,
+                                int message_id,
+                                bool success,
+                                const void* result,
+                                size_t result_size) override {
+      EXPECT_TRUE(success) << "CDP method failed: "
+                           << std::string(static_cast<const char*>(result),
+                                          result_size);
+      if (!success) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto dict = ParseResponse(result, result_size);
+      EXPECT_TRUE(dict.get());
+      if (!dict) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto nodes = dict->GetList("nodes");
+      EXPECT_TRUE(nodes.get());
+      if (!nodes) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      handler_->got_result_ = true;
+      handler_->VerifyTree(nodes);
+      handler_->OnTreeVerified();
+    }
+
+   private:
+    AxViewportCollapseTestHandler* handler_;
+    IMPLEMENT_REFCOUNTING(Observer);
+  };
+
+  // Called after VerifyTree. Default: destroy. Subclasses can override.
+  virtual void OnTreeVerified() { DestroyTest(); }
+
+  cef_state_t collapse_state_;
+  const char* url_;
+  const char* html_;
+  int next_message_id_ = 0;
+  bool got_result_ = false;
+  CefRefPtr<CefRegistration> registration_;
+
+  IMPLEMENT_REFCOUNTING(AxViewportCollapseTestHandler);
+};
+
+// Test page with landmarks, headings, and interactive elements.
+// A large spacer pushes the "offscreen" section out of the viewport.
+const char kTestUrl[] = "https://tests/AxViewportCollapse";
+
+const char kTestHtml[] = R"(
+<html>
+<body style="margin:0;padding:0;">
+  <nav aria-label="Main Navigation">
+    <a href="#">Home</a>
+  </nav>
+  <main>
+    <h1>In Viewport Heading</h1>
+    <button id="btn-visible">Visible Button</button>
+  </main>
+  <div style="height:10000px;"></div>
+  <footer aria-label="Footer Info">
+    <h2>Offscreen Heading</h2>
+    <button id="btn-offscreen">Offscreen Button</button>
+    <input type="text" id="input-offscreen" value="offscreen">
+  </footer>
+  <nav aria-label="Offscreen Nav">
+    <a href="#">Offscreen Link</a>
+  </nav>
+</body>
+</html>
+)";
+
+// Test: STATE_DEFAULT or STATE_DISABLED → full tree, no collapsing.
+class CollapseOffHandler : public AxViewportCollapseTestHandler {
+ public:
+  explicit CollapseOffHandler(cef_state_t state)
+      : AxViewportCollapseTestHandler(state, kTestUrl, kTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    // All nodes should be present, including off-screen ones.
+    EXPECT_TRUE(HasNodeWithName(nodes, "Offscreen Button"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Offscreen Heading"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Visible Button"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "In Viewport Heading"));
+
+    // Off-screen landmarks should be fully serialized (with children),
+    // not collapsed summaries.
+    auto footer = FindNodeByName(nodes, "Footer Info");
+    EXPECT_TRUE(footer.get());
+    if (footer) {
+      EXPECT_FALSE(HasEmptyChildIds(footer));
+    }
+  }
+};
+
+// Test: STATE_ENABLED → off-screen landmarks summarized, interactive pruned.
+class CollapseEnabledHandler : public AxViewportCollapseTestHandler {
+ public:
+  CollapseEnabledHandler()
+      : AxViewportCollapseTestHandler(STATE_ENABLED, kTestUrl, kTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    // In-viewport nodes: fully serialized.
+    EXPECT_TRUE(HasNodeWithName(nodes, "In Viewport Heading"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Visible Button"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Main Navigation"));
+
+    // Off-screen landmarks: should be present as summaries (role + name).
+    auto footer = FindNodeByName(nodes, "Footer Info");
+    EXPECT_TRUE(footer.get());
+    if (footer) {
+      EXPECT_TRUE(HasEmptyChildIds(footer));
+    }
+
+    auto offscreen_nav = FindNodeByName(nodes, "Offscreen Nav");
+    EXPECT_TRUE(offscreen_nav.get());
+    if (offscreen_nav) {
+      EXPECT_TRUE(HasEmptyChildIds(offscreen_nav));
+    }
+
+    // Off-screen heading inside a landmark: pruned along with the landmark's
+    // subtree (landmark is summarized with empty childIds).
+    EXPECT_FALSE(HasNodeWithName(nodes, "Offscreen Heading"));
+
+    // Off-screen interactive elements: should be pruned (absent).
+    EXPECT_FALSE(HasNodeWithName(nodes, "Offscreen Button"));
+    EXPECT_FALSE(HasNodeWithName(nodes, "Offscreen Link"));
+  }
+};
+
+// Page with headings at different levels off-screen.
+const char kHeadingTestUrl[] = "https://tests/AxViewportCollapseHeading";
+
+const char kHeadingTestHtml[] = R"(
+<html>
+<body style="margin:0;padding:0;">
+  <main>
+    <p>In viewport content</p>
+  </main>
+  <div style="height:10000px;"></div>
+  <h1>Offscreen H1</h1>
+  <h2>Offscreen H2</h2>
+  <h3>Offscreen H3</h3>
+</body>
+</html>
+)";
+
+// Test: Off-screen headings include correct level property.
+class OffscreenHeadingLevelHandler : public AxViewportCollapseTestHandler {
+ public:
+  OffscreenHeadingLevelHandler()
+      : AxViewportCollapseTestHandler(STATE_ENABLED,
+                                      kHeadingTestUrl,
+                                      kHeadingTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    auto h1 = FindNodeByName(nodes, "Offscreen H1");
+    EXPECT_TRUE(h1.get());
+    if (h1) {
+      EXPECT_EQ(1, GetLevelProperty(h1));
+      EXPECT_TRUE(HasEmptyChildIds(h1));
+    }
+
+    auto h2 = FindNodeByName(nodes, "Offscreen H2");
+    EXPECT_TRUE(h2.get());
+    if (h2) {
+      EXPECT_EQ(2, GetLevelProperty(h2));
+    }
+
+    auto h3 = FindNodeByName(nodes, "Offscreen H3");
+    EXPECT_TRUE(h3.get());
+    if (h3) {
+      EXPECT_EQ(3, GetLevelProperty(h3));
+    }
+  }
+};
+
+// Test: In-viewport parent's childIds don't reference pruned off-screen nodes.
+class ChildIdsFilteredHandler : public AxViewportCollapseTestHandler {
+ public:
+  ChildIdsFilteredHandler()
+      : AxViewportCollapseTestHandler(STATE_ENABLED, kTestUrl, kTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    // Collect all nodeIds in the response.
+    std::set<std::string> all_ids;
+    for (size_t i = 0; i < nodes->GetSize(); i++) {
+      auto node = nodes->GetDictionary(i);
+      all_ids.insert(node->GetString("nodeId").ToString());
+    }
+
+    // Every childId reference should point to a serialized node.
+    for (size_t i = 0; i < nodes->GetSize(); i++) {
+      auto node = nodes->GetDictionary(i);
+      if (node->HasKey("childIds")) {
+        auto child_ids = node->GetList("childIds");
+        for (size_t j = 0; j < child_ids->GetSize(); j++) {
+          std::string child_id = child_ids->GetString(j).ToString();
+          EXPECT_TRUE(all_ids.count(child_id) > 0)
+              << "childId " << child_id << " references a non-serialized node";
+        }
+      }
+    }
+  }
+};
+
+// Page with position:fixed child inside off-screen parent.
+const char kFixedTestUrl[] = "https://tests/AxViewportCollapseFixed";
+
+const char kFixedTestHtml[] = R"(
+<html>
+<body style="margin:0;padding:0;">
+  <main><p>Viewport content</p></main>
+  <div style="height:10000px;"></div>
+  <div id="offscreen-parent" aria-label="Offscreen Parent">
+    <div id="fixed-child" style="position:fixed;top:0;left:0;width:100px;height:30px;">
+      <button id="fixed-btn">Fixed Button</button>
+    </div>
+  </div>
+</body>
+</html>
+)";
+
+// Test: position:fixed child visible despite off-screen parent.
+class FixedPositionVisibleHandler : public AxViewportCollapseTestHandler {
+ public:
+  FixedPositionVisibleHandler()
+      : AxViewportCollapseTestHandler(STATE_ENABLED,
+                                      kFixedTestUrl,
+                                      kFixedTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    // The fixed-position button should be fully serialized even though
+    // its parent is off-screen, because position:fixed places it in viewport.
+    EXPECT_TRUE(HasNodeWithName(nodes, "Fixed Button"));
+
+    // The off-screen parent itself should be pruned (not serialized).
+    EXPECT_FALSE(HasNodeWithName(nodes, "Offscreen Parent"));
+  }
+};
+
+// Page with nested off-screen structure.
+const char kNestedTestUrl[] = "https://tests/AxViewportCollapseNested";
+
+const char kNestedTestHtml[] = R"(
+<html>
+<body style="margin:0;padding:0;">
+  <main><p>Viewport content</p></main>
+  <div style="height:10000px;"></div>
+  <nav aria-label="Deep Nav">
+    <h3>Nested Heading</h3>
+    <button>Nested Button 1</button>
+    <button>Nested Button 2</button>
+  </nav>
+</body>
+</html>
+)";
+
+// Test: Deeply nested off-screen structure — landmark summarized, subtree
+// pruned.
+class NestedOffscreenHandler : public AxViewportCollapseTestHandler {
+ public:
+  NestedOffscreenHandler()
+      : AxViewportCollapseTestHandler(STATE_ENABLED,
+                                      kNestedTestUrl,
+                                      kNestedTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    // Off-screen landmark should be present as summary.
+    auto nav = FindNodeByName(nodes, "Deep Nav");
+    EXPECT_TRUE(nav.get());
+    if (nav) {
+      EXPECT_TRUE(HasEmptyChildIds(nav));
+    }
+
+    // Children of the off-screen landmark should be pruned entirely.
+    EXPECT_FALSE(HasNodeWithName(nodes, "Nested Heading"));
+    EXPECT_FALSE(HasNodeWithName(nodes, "Nested Button 1"));
+    EXPECT_FALSE(HasNodeWithName(nodes, "Nested Button 2"));
+  }
+};
+
+// Test: Runtime toggle via SetAxViewportCollapse.
+class RuntimeToggleHandler : public AxViewportCollapseTestHandler {
+ public:
+  RuntimeToggleHandler()
+      : AxViewportCollapseTestHandler(STATE_DEFAULT, kTestUrl, kTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    verify_ct_++;
+    if (!toggled_) {
+      // First fetch: full tree (setting is default/off).
+      EXPECT_TRUE(HasNodeWithName(nodes, "Offscreen Button"));
+      first_node_count_ = NodeCount(nodes);
+    } else {
+      // Second fetch: collapsed tree.
+      EXPECT_FALSE(HasNodeWithName(nodes, "Offscreen Button"));
+      EXPECT_TRUE(HasNodeWithName(nodes, "Footer Info"));
+      EXPECT_LT(NodeCount(nodes), first_node_count_);
+    }
+  }
+
+  void OnTreeVerified() override {
+    if (!toggled_) {
+      toggled_ = true;
+      // Enable viewport collapse at runtime and re-fetch.
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+      GetBrowser()->GetHost()->SetAxViewportCollapse(true);
+#endif
+      // Re-fetch after a short delay to allow prefs to propagate.
+      CefPostDelayedTask(
+          TID_UI, base::BindOnce(&RuntimeToggleHandler::FetchTreeAgain, this),
+          200);
+    } else {
+      EXPECT_EQ(2, verify_ct_);
+      DestroyTest();
+    }
+  }
+
+  void FetchTreeAgain() {
+    got_result_ = false;
+    GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+        ++next_message_id_, "Accessibility.getFullAXTree", nullptr);
+  }
+
+ private:
+  bool toggled_ = false;
+  int verify_ct_ = 0;
+  size_t first_node_count_ = 0;
+};
+
+// Small page that fits entirely in the viewport.
+const char kAllVisibleTestUrl[] = "https://tests/AxViewportCollapseAllVisible";
+
+const char kAllVisibleTestHtml[] = R"(
+<html>
+<body style="margin:0;padding:0;">
+  <nav aria-label="Site Nav">
+    <a href="#">Home</a>
+  </nav>
+  <main>
+    <h1>Main Heading</h1>
+    <button>Click Me</button>
+  </main>
+  <footer aria-label="Site Footer">
+    <p>Footer text</p>
+  </footer>
+</body>
+</html>
+)";
+
+// Test: Collapse enabled but all content fits in viewport — no-op.
+class AllVisibleHandler : public AxViewportCollapseTestHandler {
+ public:
+  AllVisibleHandler()
+      : AxViewportCollapseTestHandler(STATE_ENABLED,
+                                      kAllVisibleTestUrl,
+                                      kAllVisibleTestHtml) {}
+
+  void VerifyTree(CefRefPtr<CefListValue> nodes) override {
+    // Everything fits in viewport, so all nodes should be fully serialized.
+    EXPECT_TRUE(HasNodeWithName(nodes, "Site Nav"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Main Heading"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Click Me"));
+    EXPECT_TRUE(HasNodeWithName(nodes, "Site Footer"));
+
+    // Nav should have children (not collapsed).
+    auto nav = FindNodeByName(nodes, "Site Nav");
+    EXPECT_TRUE(nav.get());
+    if (nav) {
+      EXPECT_FALSE(HasEmptyChildIds(nav));
+    }
+  }
+};
+
+// Page with a landmark at 400px down. TestHandler creates an 800x600 window
+// (~550px content height). At 100% zoom the nav is visible. At 300% zoom the
+// viewport shrinks to ~183 CSS pixels tall, pushing the nav off-screen.
+const char kZoomTestUrl[] = "https://tests/AxViewportCollapseZoom";
+
+const char kZoomTestHtml[] = R"(
+<html>
+<body style="margin:0;padding:0;">
+  <main>
+    <h1>Top Content</h1>
+  </main>
+  <div style="height:400px;" aria-hidden="true"></div>
+  <nav aria-label="Edge Nav">
+    <a href="#">Edge Link</a>
+  </nav>
+</body>
+</html>
+)";
+
+// Test: Zooming in pushes a near-viewport-edge landmark off-screen.
+// Verifies coordinate spaces are correctly scaled.
+class ZoomedCollapseHandler : public TestHandler {
+ public:
+  ZoomedCollapseHandler() = default;
+  ZoomedCollapseHandler(const ZoomedCollapseHandler&) = delete;
+  ZoomedCollapseHandler& operator=(const ZoomedCollapseHandler&) = delete;
+
+  void RunTest() override {
+    AddResource(kZoomTestUrl, kZoomTestHtml, "text/html");
+
+    CefBrowserSettings settings;
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+    settings.ax_viewport_collapse = STATE_ENABLED;
+#endif
+    CreateBrowserWithSettings(kZoomTestUrl, settings);
+    SetTestTimeout();
+  }
+
+  void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
+    TestHandler::OnAfterCreated(browser);
+    registration_ =
+        browser->GetHost()->AddDevToolsMessageObserver(new Observer(this));
+  }
+
+  void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+                            bool isLoading,
+                            bool canGoBack,
+                            bool canGoForward) override {
+    if (!isLoading) {
+      // Step 1: Fetch tree at default zoom. "Edge Nav" should be in viewport.
+      GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+          ++next_message_id_, "Accessibility.getFullAXTree", nullptr);
+    }
+  }
+
+  void DestroyTest() override {
+    registration_ = nullptr;
+    EXPECT_EQ(2, tree_fetch_ct_);
+    TestHandler::DestroyTest();
+  }
+
+ private:
+  enum Step { kDefaultZoom = 1, kZoomedIn = 2 };
+
+  class Observer : public CefDevToolsMessageObserver {
+   public:
+    explicit Observer(ZoomedCollapseHandler* handler) : handler_(handler) {}
+    Observer(const Observer&) = delete;
+    Observer& operator=(const Observer&) = delete;
+
+    void OnDevToolsMethodResult(CefRefPtr<CefBrowser> browser,
+                                int message_id,
+                                bool success,
+                                const void* result,
+                                size_t result_size) override {
+      EXPECT_TRUE(success) << "Step " << message_id << " failed: "
+                           << std::string(static_cast<const char*>(result),
+                                          result_size);
+      if (!success) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto dict = ParseResponse(result, result_size);
+      EXPECT_TRUE(dict.get());
+      if (!dict) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto nodes = dict->GetList("nodes");
+      EXPECT_TRUE(nodes.get());
+      if (!nodes) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      switch (static_cast<Step>(message_id)) {
+        case kDefaultZoom: {
+          // At default zoom, "Edge Nav" at ~400px is within the ~550px
+          // content area. Fully serialized with children.
+          auto nav = FindNodeByName(nodes, "Edge Nav");
+          EXPECT_TRUE(nav.get());
+          if (nav) {
+            EXPECT_FALSE(HasEmptyChildIds(nav));
+          }
+          EXPECT_TRUE(HasNodeWithName(nodes, "Edge Link"));
+
+          handler_->tree_fetch_ct_++;
+
+          // Zoom in heavily (level 5.0 ≈ 300%). Viewport in CSS pixels
+          // shrinks to ~183px tall, pushing "Edge Nav" at ~400px off-screen.
+          browser->GetHost()->SetZoomLevel(5.0);
+          CefPostDelayedTask(
+              TID_UI,
+              base::BindOnce(&ZoomedCollapseHandler::FetchTreeAgain, handler_),
+              200);
+          break;
+        }
+
+        case kZoomedIn: {
+          // After zoom, "Edge Nav" should now be off-screen and collapsed.
+          auto nav = FindNodeByName(nodes, "Edge Nav");
+          EXPECT_TRUE(nav.get());
+          if (nav) {
+            EXPECT_TRUE(HasEmptyChildIds(nav));
+          }
+
+          // Its child should be pruned.
+          EXPECT_FALSE(HasNodeWithName(nodes, "Edge Link"));
+
+          // Top content should still be visible.
+          EXPECT_TRUE(HasNodeWithName(nodes, "Top Content"));
+
+          handler_->tree_fetch_ct_++;
+          handler_->DestroyTest();
+          break;
+        }
+      }
+    }
+
+   private:
+    ZoomedCollapseHandler* handler_;
+    IMPLEMENT_REFCOUNTING(Observer);
+  };
+
+  void FetchTreeAgain() {
+    GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+        ++next_message_id_, "Accessibility.getFullAXTree", nullptr);
+  }
+
+  int next_message_id_ = 0;
+  int tree_fetch_ct_ = 0;
+  CefRefPtr<CefRegistration> registration_;
+  IMPLEMENT_REFCOUNTING(ZoomedCollapseHandler);
+};
+
+// Test: queryAXTree still returns off-screen nodes when collapse is enabled.
+// Agents use queryAXTree for scroll targeting — filtering would break that.
+class QueryAXTreeHandler : public TestHandler {
+ public:
+  QueryAXTreeHandler() = default;
+  QueryAXTreeHandler(const QueryAXTreeHandler&) = delete;
+  QueryAXTreeHandler& operator=(const QueryAXTreeHandler&) = delete;
+
+  void RunTest() override {
+    AddResource(kTestUrl, kTestHtml, "text/html");
+
+    CefBrowserSettings settings;
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+    settings.ax_viewport_collapse = STATE_ENABLED;
+#endif
+    CreateBrowserWithSettings(kTestUrl, settings);
+    SetTestTimeout();
+  }
+
+  void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
+    TestHandler::OnAfterCreated(browser);
+    registration_ =
+        browser->GetHost()->AddDevToolsMessageObserver(new Observer(this));
+  }
+
+  void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+                            bool isLoading,
+                            bool canGoBack,
+                            bool canGoForward) override {
+    if (!isLoading) {
+      // Get the document root node (also enables the DOM domain).
+      GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+          ++next_message_id_, "DOM.getDocument", nullptr);
+    }
+  }
+
+  void DestroyTest() override {
+    registration_ = nullptr;
+    EXPECT_TRUE(got_result_);
+    TestHandler::DestroyTest();
+  }
+
+ protected:
+  class Observer : public CefDevToolsMessageObserver {
+   public:
+    explicit Observer(QueryAXTreeHandler* handler) : handler_(handler) {}
+    Observer(const Observer&) = delete;
+    Observer& operator=(const Observer&) = delete;
+
+    void OnDevToolsMethodResult(CefRefPtr<CefBrowser> browser,
+                                int message_id,
+                                bool success,
+                                const void* result,
+                                size_t result_size) override {
+      if (message_id == 1) {
+        // DOM.getDocument succeeded. Extract root nodeId and query.
+        EXPECT_TRUE(success)
+            << "DOM.getDocument failed: "
+            << std::string(static_cast<const char*>(result), result_size);
+        if (!success) {
+          handler_->DestroyTest();
+          return;
+        }
+        auto dict = ParseResponse(result, result_size);
+        auto root = dict ? dict->GetDictionary("root") : nullptr;
+        int node_id = root ? root->GetInt("nodeId") : 0;
+        EXPECT_GT(node_id, 0);
+        if (node_id <= 0) {
+          handler_->DestroyTest();
+          return;
+        }
+
+        CefRefPtr<CefDictionaryValue> params = CefDictionaryValue::Create();
+        params->SetInt("nodeId", node_id);
+        params->SetString("accessibleName", "Offscreen Button");
+        browser->GetHost()->ExecuteDevToolsMethod(
+            ++handler_->next_message_id_, "Accessibility.queryAXTree", params);
+        return;
+      }
+
+      // queryAXTree result.
+      EXPECT_TRUE(success) << "Accessibility.queryAXTree failed: "
+                           << std::string(static_cast<const char*>(result),
+                                          result_size);
+      if (!success) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto dict = ParseResponse(result, result_size);
+      EXPECT_TRUE(dict.get());
+      if (!dict) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto nodes = dict->GetList("nodes");
+      EXPECT_TRUE(nodes.get());
+      if (!nodes) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      // queryAXTree should still find the off-screen button even with
+      // collapse enabled, because queryAXTree is not filtered.
+      EXPECT_TRUE(HasNodeWithName(nodes, "Offscreen Button"));
+      handler_->got_result_ = true;
+      handler_->DestroyTest();
+    }
+
+   private:
+    QueryAXTreeHandler* handler_;
+    IMPLEMENT_REFCOUNTING(Observer);
+  };
+
+  int next_message_id_ = 0;
+  bool got_result_ = false;
+  CefRefPtr<CefRegistration> registration_;
+  IMPLEMENT_REFCOUNTING(QueryAXTreeHandler);
+};
+
+// Test: Full agentic workflow — get collapsed tree, find off-screen landmark,
+// scroll to it, re-get tree and verify it's now fully serialized.
+class AgenticWorkflowHandler : public TestHandler {
+ public:
+  AgenticWorkflowHandler() = default;
+  AgenticWorkflowHandler(const AgenticWorkflowHandler&) = delete;
+  AgenticWorkflowHandler& operator=(const AgenticWorkflowHandler&) = delete;
+
+  void RunTest() override {
+    AddResource(kTestUrl, kTestHtml, "text/html");
+
+    CefBrowserSettings settings;
+#if CEF_API_ADDED(CEF_EXPERIMENTAL)
+    settings.ax_viewport_collapse = STATE_ENABLED;
+#endif
+    CreateBrowserWithSettings(kTestUrl, settings);
+    SetTestTimeout();
+  }
+
+  void OnAfterCreated(CefRefPtr<CefBrowser> browser) override {
+    TestHandler::OnAfterCreated(browser);
+    registration_ =
+        browser->GetHost()->AddDevToolsMessageObserver(new Observer(this));
+  }
+
+  void OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
+                            bool isLoading,
+                            bool canGoBack,
+                            bool canGoForward) override {
+    if (!isLoading) {
+      // Step 1: Get the collapsed AX tree.
+      GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+          ++next_message_id_, "Accessibility.getFullAXTree", nullptr);
+    }
+  }
+
+  void DestroyTest() override {
+    registration_ = nullptr;
+    EXPECT_EQ(2, tree_fetch_ct_);
+    TestHandler::DestroyTest();
+  }
+
+ private:
+  // CDP call sequence:
+  //   1: Accessibility.getFullAXTree (collapsed)
+  //   2: DOM.scrollIntoViewIfNeeded (scroll to off-screen landmark)
+  //   3: Accessibility.getFullAXTree (after scroll)
+  enum Step { kInitialTree = 1, kScroll = 2, kPostScrollTree = 3 };
+
+  class Observer : public CefDevToolsMessageObserver {
+   public:
+    explicit Observer(AgenticWorkflowHandler* handler) : handler_(handler) {}
+    Observer(const Observer&) = delete;
+    Observer& operator=(const Observer&) = delete;
+
+    void OnDevToolsMethodResult(CefRefPtr<CefBrowser> browser,
+                                int message_id,
+                                bool success,
+                                const void* result,
+                                size_t result_size) override {
+      EXPECT_TRUE(success) << "Step " << message_id << " failed: "
+                           << std::string(static_cast<const char*>(result),
+                                          result_size);
+      if (!success) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      auto dict = ParseResponse(result, result_size);
+      if (!dict) {
+        handler_->DestroyTest();
+        return;
+      }
+
+      switch (static_cast<Step>(message_id)) {
+        case kInitialTree: {
+          auto nodes = dict->GetList("nodes");
+          EXPECT_TRUE(nodes.get());
+          if (!nodes) {
+            handler_->DestroyTest();
+            return;
+          }
+
+          // Top nav should be in-viewport and fully serialized.
+          auto nav = FindNodeByName(nodes, "Main Navigation");
+          EXPECT_TRUE(nav.get());
+          if (nav) {
+            EXPECT_FALSE(HasEmptyChildIds(nav));
+          }
+
+          // Off-screen landmark should be a collapsed summary.
+          auto footer = FindNodeByName(nodes, "Footer Info");
+          EXPECT_TRUE(footer.get());
+          if (footer) {
+            EXPECT_TRUE(HasEmptyChildIds(footer));
+            // Extract backendDOMNodeId to scroll to it.
+            handler_->target_backend_node_id_ =
+                footer->GetInt("backendDOMNodeId");
+            EXPECT_GT(handler_->target_backend_node_id_, 0);
+          }
+
+          // Off-screen interactive nodes should be pruned.
+          EXPECT_FALSE(HasNodeWithName(nodes, "Offscreen Button"));
+
+          handler_->tree_fetch_ct_++;
+
+          // Step 2: Scroll the off-screen landmark into view.
+          CefRefPtr<CefDictionaryValue> params = CefDictionaryValue::Create();
+          params->SetInt("backendNodeId", handler_->target_backend_node_id_);
+          browser->GetHost()->ExecuteDevToolsMethod(
+              ++handler_->next_message_id_, "DOM.scrollIntoViewIfNeeded",
+              params);
+          break;
+        }
+
+        case kScroll: {
+          // Scroll succeeded. Wait for layout update, then re-fetch tree.
+          CefPostDelayedTask(
+              TID_UI,
+              base::BindOnce(&AgenticWorkflowHandler::FetchTreeAgain, handler_),
+              200);
+          break;
+        }
+
+        case kPostScrollTree: {
+          auto nodes = dict->GetList("nodes");
+          EXPECT_TRUE(nodes.get());
+          if (!nodes) {
+            handler_->DestroyTest();
+            return;
+          }
+
+          // After scrolling, the footer landmark should now be fully
+          // serialized with children (no longer a collapsed summary).
+          auto footer = FindNodeByName(nodes, "Footer Info");
+          EXPECT_TRUE(footer.get());
+          if (footer) {
+            EXPECT_FALSE(HasEmptyChildIds(footer));
+          }
+
+          // The heading and button inside the footer should now be visible.
+          EXPECT_TRUE(HasNodeWithName(nodes, "Offscreen Heading"));
+          EXPECT_TRUE(HasNodeWithName(nodes, "Offscreen Button"));
+
+          // The top nav that was previously in-viewport should now be
+          // collapsed (scrolled out of view).
+          auto nav = FindNodeByName(nodes, "Main Navigation");
+          EXPECT_TRUE(nav.get());
+          if (nav) {
+            EXPECT_TRUE(HasEmptyChildIds(nav));
+          }
+
+          handler_->tree_fetch_ct_++;
+          handler_->DestroyTest();
+          break;
+        }
+      }
+    }
+
+   private:
+    AgenticWorkflowHandler* handler_;
+    IMPLEMENT_REFCOUNTING(Observer);
+  };
+
+  void FetchTreeAgain() {
+    GetBrowser()->GetHost()->ExecuteDevToolsMethod(
+        ++next_message_id_, "Accessibility.getFullAXTree", nullptr);
+  }
+
+  int next_message_id_ = 0;
+  int tree_fetch_ct_ = 0;
+  int target_backend_node_id_ = 0;
+  CefRefPtr<CefRegistration> registration_;
+  IMPLEMENT_REFCOUNTING(AgenticWorkflowHandler);
+};
+
+}  // namespace
+
+TEST(AxViewportCollapseTest, CollapseDefault) {
+  CefRefPtr<CollapseOffHandler> handler = new CollapseOffHandler(STATE_DEFAULT);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, CollapseDisabled) {
+  CefRefPtr<CollapseOffHandler> handler =
+      new CollapseOffHandler(STATE_DISABLED);
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, CollapseEnabled) {
+  CefRefPtr<CollapseEnabledHandler> handler = new CollapseEnabledHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, OffscreenHeadingLevel) {
+  CefRefPtr<OffscreenHeadingLevelHandler> handler =
+      new OffscreenHeadingLevelHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, ChildIdsFiltered) {
+  CefRefPtr<ChildIdsFilteredHandler> handler = new ChildIdsFilteredHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, FixedPositionVisible) {
+  CefRefPtr<FixedPositionVisibleHandler> handler =
+      new FixedPositionVisibleHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, NestedOffscreen) {
+  CefRefPtr<NestedOffscreenHandler> handler = new NestedOffscreenHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, RuntimeToggle) {
+  CefRefPtr<RuntimeToggleHandler> handler = new RuntimeToggleHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, AllVisible) {
+  CefRefPtr<AllVisibleHandler> handler = new AllVisibleHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, ZoomedCollapse) {
+  CefRefPtr<ZoomedCollapseHandler> handler = new ZoomedCollapseHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, QueryAXTreeUnfiltered) {
+  CefRefPtr<QueryAXTreeHandler> handler = new QueryAXTreeHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
+
+TEST(AxViewportCollapseTest, AgenticWorkflow) {
+  CefRefPtr<AgenticWorkflowHandler> handler = new AgenticWorkflowHandler();
+  handler->ExecuteTest();
+  ReleaseAndWaitForDestructor(handler);
+}
diff --git a/tests/shared/common/client_switches.cc b/tests/shared/common/client_switches.cc
index 779fcb35d..9d8088d9f 100644
--- a/tests/shared/common/client_switches.cc
+++ b/tests/shared/common/client_switches.cc
@@ -65,5 +65,6 @@ const char kUseChromeStyleWindow[] = "use-chrome-style-window";
 const char kShowOverlayBrowser[] = "show-overlay-browser";
 const char kUseAngle[] = "use-angle";
 const char kOzonePlatform[] = "ozone-platform";
+const char kAxViewportCollapse[] = "ax-viewport-collapse";
 
 }  // namespace client::switches
diff --git a/tests/shared/common/client_switches.h b/tests/shared/common/client_switches.h
index b07666c6b..936833abc 100644
--- a/tests/shared/common/client_switches.h
+++ b/tests/shared/common/client_switches.h
@@ -59,6 +59,7 @@ extern const char kUseChromeStyleWindow[];
 extern const char kShowOverlayBrowser[];
 extern const char kUseAngle[];
 extern const char kOzonePlatform[];
+extern const char kAxViewportCollapse[];
 
 }  // namespace client::switches
 
diff --git a/tools/debug/ax_viewport_collapse/README.md b/tools/debug/ax_viewport_collapse/README.md
new file mode 100644
index 000000000..34cf02cf3
--- /dev/null
+++ b/tools/debug/ax_viewport_collapse/README.md
@@ -0,0 +1,87 @@
+# ax_viewport_collapse Debug Tools
+
+Manual verification tools for the `ax_viewport_collapse` CefBrowserSettings feature.
+These connect to a running cefclient via CDP to inspect the accessibility tree.
+
+## Prerequisites
+
+```
+python3 -m pip install websocket-client
+```
+
+## Usage
+
+### 1. Launch cefclient with remote debugging
+
+```
+cefclient.exe --remote-debugging-port=9222 --remote-allow-origins=* --ax-viewport-collapse
+```
+
+The `--ax-viewport-collapse` flag maps to `CefBrowserSettings.ax_viewport_collapse = STATE_ENABLED` in cefclient.
+
+To load the test page directly:
+
+```
+cefclient.exe --remote-debugging-port=9222 --remote-allow-origins=* --ax-viewport-collapse --url=file:///<path>/test_viewport_collapse.html
+```
+
+### 2. Run the verification script
+
+```
+python3 verify_viewport_collapse.py
+```
+
+Or navigate to a URL first:
+
+```
+python3 verify_viewport_collapse.py --url https://example.com
+```
+
+### Options
+
+| Flag | Description |
+|------|-------------|
+| `--host` | CDP host (default: `127.0.0.1`) |
+| `--port` | CDP port (default: `9222`) |
+| `--url` | Navigate to URL before fetching tree |
+| `--raw` | Print full JSON response instead of summary |
+
+### Comparing with/without collapse
+
+Run two cefclient instances on different ports:
+
+```
+cefclient.exe --cache-path=<path1> --remote-debugging-port=9222 --remote-allow-origins=* --ax-viewport-collapse
+cefclient.exe --cache-path=<path2> --remote-debugging-port=9223 --remote-allow-origins=*
+```
+
+```
+python3 verify_viewport_collapse.py --port 9222 --raw > with.json
+python3 verify_viewport_collapse.py --port 9223 --raw > without.json
+diff with.json without.json
+```
+
+### Expected output (with collapse enabled)
+
+```
+AX Tree Summary
+============================================================
+Total nodes returned:  77
+  Ignored:             3
+  Full (with children):70
+  Summary (collapsed): 4
+
+Collapsed summary nodes (off-screen landmarks/headings):
+------------------------------------------------------------
+  region: "Content preferences"
+  region: "Audio quality"
+  region: "Display"
+  region: "Storage"
+```
+
+Off-screen landmark sections appear as leaf nodes with role + name only. In-viewport nodes are fully serialized with children.
+
+## Files
+
+- `verify_viewport_collapse.py` — CDP script that calls `Accessibility.getFullAXTree()` and prints a summary or raw JSON
+- `test_viewport_collapse.html` — Test page with 6 landmark sections, 2 in viewport and 4 pushed off-screen by a spacer
diff --git a/tools/debug/ax_viewport_collapse/test_viewport_collapse.html b/tools/debug/ax_viewport_collapse/test_viewport_collapse.html
new file mode 100644
index 000000000..90a5314e5
--- /dev/null
+++ b/tools/debug/ax_viewport_collapse/test_viewport_collapse.html
@@ -0,0 +1,100 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>Viewport Collapse Test Page</title>
+  <style>
+    body { font-family: sans-serif; margin: 0; padding: 20px; }
+    section { margin: 20px 0; padding: 20px; border: 1px solid #ccc; border-radius: 8px; }
+    h2 { margin-top: 0; }
+    .spacer { height: 200vh; } /* Push later sections well off-screen */
+  </style>
+</head>
+<body>
+
+<header role="banner">
+  <h1>Viewport Collapse Test</h1>
+  <nav role="navigation" aria-label="Main navigation">
+    <a href="#account">Account</a> |
+    <a href="#language">Language</a> |
+    <a href="#content">Content</a> |
+    <a href="#audio">Audio Quality</a> |
+    <a href="#display">Display</a> |
+    <a href="#storage">Storage</a>
+  </nav>
+</header>
+
+<main role="main">
+
+  <!-- These two sections should be IN the viewport -->
+  <section id="account" role="region" aria-label="Account">
+    <h2>Account</h2>
+    <p>Manage your account settings.</p>
+    <button>Edit login methods</button>
+    <button>Change password</button>
+    <label>Email: <input type="text" value="user@example.com"></label>
+  </section>
+
+  <section id="language" role="region" aria-label="Language">
+    <h2>Language</h2>
+    <label>Choose language:
+      <select>
+        <option selected>English</option>
+        <option>Spanish</option>
+        <option>French</option>
+        <option>German</option>
+        <option>Japanese</option>
+      </select>
+    </label>
+  </section>
+
+  <!-- Spacer to push remaining sections off-screen -->
+  <div class="spacer" aria-hidden="true"></div>
+
+  <!-- These sections should be OFF-screen and collapsed -->
+  <section id="content" role="region" aria-label="Content preferences">
+    <h2>Content preferences</h2>
+    <label><input type="checkbox" checked> Allow explicit content</label>
+    <p>When off, explicit music won't be played.</p>
+  </section>
+
+  <section id="audio" role="region" aria-label="Audio quality">
+    <h2>Audio quality</h2>
+    <label>Streaming quality:
+      <select>
+        <option>Automatic</option>
+        <option selected>High</option>
+        <option>Very high</option>
+      </select>
+    </label>
+    <label>Download quality:
+      <select>
+        <option selected>Normal</option>
+        <option>High</option>
+      </select>
+    </label>
+    <label><input type="checkbox"> Auto adjust quality</label>
+  </section>
+
+  <section id="display" role="region" aria-label="Display">
+    <h2>Display</h2>
+    <label><input type="checkbox"> Use compact library layout</label>
+    <label><input type="checkbox" checked> Show album art</label>
+    <button>Reset display settings</button>
+  </section>
+
+  <section id="storage" role="region" aria-label="Storage">
+    <h2>Storage</h2>
+    <p>Cache size: 2.4 GB</p>
+    <button>Clear cache</button>
+    <button>Manage downloads</button>
+  </section>
+
+</main>
+
+<footer role="contentinfo">
+  <p>&copy; 2026 Test App. All rights reserved.</p>
+</footer>
+
+</body>
+</html>
diff --git a/tools/debug/ax_viewport_collapse/verify_viewport_collapse.py b/tools/debug/ax_viewport_collapse/verify_viewport_collapse.py
new file mode 100644
index 000000000..c7851e86b
--- /dev/null
+++ b/tools/debug/ax_viewport_collapse/verify_viewport_collapse.py
@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""
+Verify --ax-viewport-collapse behavior via raw CDP.
+
+Usage:
+  1. Launch cefclient with:
+     out\\Debug_GN_x64\\cefclient.exe --remote-debugging-port=9222 --ax-viewport-collapse
+
+  2. Navigate to a page with scrollable content, e.g. the test page:
+     out\\Debug_GN_x64\\cefclient.exe --remote-debugging-port=9222 --ax-viewport-collapse \\
+       --url=file:///path/to/cef/tools/debug/ax_viewport_collapse/test_viewport_collapse.html
+
+  3. Run this script:
+     python cef/tools/debug/ax_viewport_collapse/verify_viewport_collapse.py [--port 9222]
+
+  The script connects via CDP, optionally navigates, calls Accessibility.getFullAXTree(),
+  and prints a summary showing which nodes were serialized as full, summary, or absent.
+"""
+
+import argparse
+import json
+import sys
+import http.client
+import websocket  # pip install websocket-client
+
+
+def get_ws_url(host, port):
+  """Get the first available CDP target's websocket URL."""
+  conn = http.client.HTTPConnection(host, port)
+  conn.request("GET", "/json")
+  resp = conn.getresponse()
+  targets = json.loads(resp.read())
+  conn.close()
+  for t in targets:
+    if t.get("type") == "page" and "webSocketDebuggerUrl" in t:
+      return t["webSocketDebuggerUrl"]
+  raise RuntimeError(
+      f"No page target found on {host}:{port}. Targets: {json.dumps(targets, indent=2)}"
+  )
+
+
+def cdp_send(ws, method, params=None, id_counter=[0]):
+  id_counter[0] += 1
+  msg = {"id": id_counter[0], "method": method, "params": params or {}}
+  ws.send(json.dumps(msg))
+  while True:
+    resp = json.loads(ws.recv())
+    if resp.get("id") == id_counter[0]:
+      if "error" in resp:
+        raise RuntimeError(f"CDP error: {resp['error']}")
+      return resp.get("result", {})
+
+
+def navigate_and_wait(ws, url):
+  """Navigate to URL and wait for load."""
+  cdp_send(ws, "Page.enable")
+  cdp_send(ws, "Page.navigate", {"url": url})
+  # Wait for loadEventFired
+  while True:
+    resp = json.loads(ws.recv())
+    if resp.get("method") == "Page.loadEventFired":
+      break
+
+
+LANDMARK_ROLES = {
+    "banner", "complementary", "contentinfo", "form", "main", "navigation",
+    "region", "search"
+}
+HEADING_ROLES = {"heading"}
+INTERACTIVE_ROLES = {
+    "button", "checkbox", "link", "textbox", "combobox", "listbox", "menuitem",
+    "radio", "slider", "switch", "tab", "searchbox", "spinbutton", "tree"
+}
+
+
+def classify_role(role_value):
+  """Classify a CDP role string."""
+  r = (role_value or "").lower()
+  if r in LANDMARK_ROLES:
+    return "landmark"
+  if r in HEADING_ROLES:
+    return "heading"
+  if r in INTERACTIVE_ROLES:
+    return "interactive"
+  return "structural"
+
+
+def analyze_tree(nodes):
+  """Analyze the AX tree and print a summary."""
+  total = len(nodes)
+  ignored = 0
+  full_nodes = []
+  summary_nodes = []  # Has role+name but empty children
+
+  for node in nodes:
+    if node.get("ignored"):
+      ignored += 1
+      continue
+
+    child_ids = node.get("childIds", [])
+    role_obj = node.get("role", {})
+    role_value = role_obj.get("value", "") if isinstance(role_obj, dict) else ""
+    name_obj = node.get("name", {})
+    name_value = name_obj.get("value", "") if isinstance(name_obj, dict) else ""
+    properties = node.get("properties", [])
+
+    has_name = bool(name_value)
+    has_children = len(child_ids) > 0
+    has_full_props = len(properties) > 2  # More than just level
+
+    cat = classify_role(role_value)
+
+    if cat in ("landmark", "heading") and has_name and not has_children:
+      summary_nodes.append(node)
+    else:
+      full_nodes.append(node)
+
+  print(f"\n{'='*60}")
+  print(f"AX Tree Summary")
+  print(f"{'='*60}")
+  print(f"Total nodes returned:  {total}")
+  print(f"  Ignored:             {ignored}")
+  print(f"  Full (with children):{len(full_nodes)}")
+  print(f"  Summary (collapsed): {len(summary_nodes)}")
+  print()
+
+  if summary_nodes:
+    print("Collapsed summary nodes (off-screen landmarks/headings):")
+    print("-" * 60)
+    for node in summary_nodes:
+      role_obj = node.get("role", {})
+      role_val = role_obj.get("value", "?") if isinstance(role_obj,
+                                                          dict) else "?"
+      name_obj = node.get("name", {})
+      name_val = name_obj.get("value", "") if isinstance(name_obj, dict) else ""
+      props = node.get("properties", [])
+      level_str = ""
+      for p in props:
+        if isinstance(p, dict) and p.get("name") == "level":
+          lv = p.get("value", {})
+          level_str = f" [level={lv.get('value', '?')}]"
+      print(f"  {role_val}: \"{name_val}\"{level_str}")
+    print()
+
+  # Print the tree structure (first 50 non-ignored nodes)
+  print("First 50 non-ignored nodes:")
+  print("-" * 60)
+  node_map = {n.get("nodeId"): n for n in nodes}
+  count = 0
+  for node in nodes:
+    if node.get("ignored"):
+      continue
+    if count >= 50:
+      print("  ... (truncated)")
+      break
+    count += 1
+
+    role_obj = node.get("role", {})
+    role_val = role_obj.get("value", "?") if isinstance(role_obj, dict) else "?"
+    name_obj = node.get("name", {})
+    name_val = name_obj.get("value", "") if isinstance(name_obj, dict) else ""
+    child_ids = node.get("childIds", [])
+
+    name_str = f" \"{name_val}\"" if name_val else ""
+    children_str = f" [{len(child_ids)} children]" if child_ids else " [leaf]"
+    is_summary = node in summary_nodes
+    tag = " <-- COLLAPSED" if is_summary else ""
+
+    print(f"  {role_val}{name_str}{children_str}{tag}")
+
+  print()
+
+
+def main():
+  parser = argparse.ArgumentParser(
+      description="Verify CDP accessibility viewport collapse")
+  parser.add_argument("--host", default="127.0.0.1")
+  parser.add_argument("--port", type=int, default=9222)
+  parser.add_argument("--url", help="URL to navigate to before fetching tree")
+  parser.add_argument(
+      "--raw", action="store_true", help="Print raw JSON response")
+  args = parser.parse_args()
+
+  print(f"Connecting to CDP at {args.host}:{args.port}...")
+  ws_url = get_ws_url(args.host, args.port)
+  print(f"WebSocket: {ws_url}")
+
+  ws = websocket.create_connection(ws_url)
+
+  if args.url:
+    print(f"Navigating to {args.url}...")
+    navigate_and_wait(ws, args.url)
+    print("Page loaded.")
+
+  print("Enabling accessibility domain...")
+  cdp_send(ws, "Accessibility.enable")
+
+  print("Fetching full AX tree...")
+  result = cdp_send(ws, "Accessibility.getFullAXTree")
+  nodes = result.get("nodes", [])
+
+  if args.raw:
+    print(json.dumps(nodes, indent=2))
+  else:
+    analyze_tree(nodes)
+
+  ws.close()
+
+
+if __name__ == "__main__":
+  main()
diff --git a/tools/fix_style.py b/tools/fix_style.py
index 71729a50a..5a4454aa3 100644
--- a/tools/fix_style.py
+++ b/tools/fix_style.py
@@ -12,7 +12,7 @@ from git_util import get_changed_files
 from yapf_util import yapf_format
 
 # File extensions that can be formatted.
-DEFAULT_LINT_WHITELIST_REGEX = r"(.*\.cpp|.*\.cc|.*\.c|.*\.h|.*\.java|.*\.mm|.*\.m|.*\.py)$"
+DEFAULT_LINT_WHITELIST_REGEX = r"(.*\.cpp|.*\.cc|.*\.c|.*\.h|.*\.inc|.*\.java|.*\.mm|.*\.m|.*\.py)$"
 DEFAULT_LINT_BLACKLIST_REGEX = r"$^"
 
 # Directories containing these path components will be ignored.