diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 7298a2150..8c1d7bcad 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -154,6 +154,10 @@ _queued_events: *std.ArrayList(QueuedEvent) = undefined,
 _focus_fixup_pending: bool = false,
 
 _style_manager: StyleManager,
+
+// Element.documentHeight, valid while the style version and viewport height
+// it was computed for hold.
+_document_height: ?struct { version: usize, viewport: u32, value: f64 } = null,
 _script_manager: ScriptManager,
 
 _http_owner: HttpClient.Owner,
diff --git a/src/browser/tests/element/position.html b/src/browser/tests/element/position.html
index 17568d68c..eeeace6bc 100644
--- a/src/browser/tests/element/position.html
+++ b/src/browser/tests/element/position.html
@@ -337,17 +337,17 @@
   testing.expectEqual(0, panel.clientHeight);
   testing.expectTrue(panel.scrollHeight > 0);
 
-  // The root containers keep their synthetic size rather than summing
-  // children. The root element's clientHeight is the viewport (CSSOM View):
-  // jstracker tiles clientWidth/10 cells over clientHeight and calls
-  // elementFromPoint per cell, which the 100M px box turned into ~5M walks.
+  // The root containers span the document rather than summing children.
+  // The root element's clientHeight is the viewport (CSSOM View): jstracker
+  // tiles clientWidth/10 cells over clientHeight and calls elementFromPoint
+  // per cell, which a document-sized box turned into ~5M walks.
   testing.expectEqual(document.body.clientHeight, document.body.scrollHeight);
   testing.expectEqual(window.innerHeight, document.documentElement.clientHeight);
   testing.expectEqual(
     document.documentElement.offsetHeight,
     document.documentElement.scrollHeight,
   );
-  testing.expectTrue(document.documentElement.scrollHeight > document.documentElement.clientHeight);
+  testing.expectTrue(document.documentElement.scrollHeight >= document.documentElement.clientHeight);
 }
 </script>
 
@@ -578,6 +578,11 @@
   deep.id = 'deep';
   document.body.appendChild(deep);
 
+  // Room below it, or the viewport couldn't bring its top up
+  const room = document.createElement('div');
+  room.style.height = '10000px';
+  document.body.appendChild(room);
+
   const targetY = deep.getBoundingClientRect().y;
   testing.expectTrue(targetY > 0);
 
diff --git a/src/browser/tests/mcp_actions.html b/src/browser/tests/mcp_actions.html
index c6e409ce5..75bda144f 100644
--- a/src/browser/tests/mcp_actions.html
+++ b/src/browser/tests/mcp_actions.html
@@ -70,5 +70,7 @@
         document.getElementById('rad').addEventListener('click', function() { window.radClicked = true; });
         document.getElementById('rad').addEventListener('change', function() { window.radChanged = true; });
     </script>
+    <!-- Room to scroll the window: the document can't scroll past its bottom -->
+    <div style="height: 10000px"></div>
 </body>
 </html>
diff --git a/src/browser/tests/window_scroll.html b/src/browser/tests/window_scroll.html
index 6d16dc0c3..dda8a1d51 100644
--- a/src/browser/tests/window_scroll.html
+++ b/src/browser/tests/window_scroll.html
@@ -1,6 +1,9 @@
 <!DOCTYPE html>
 <script src="testing.js"></script>
 
+<!-- Room to scroll: the document can't scroll past its bottom -->
+<div style="height: 10000px"></div>
+
 <script id=scrollBy_exists>
   testing.expectEqual('function', typeof window.scrollBy);
 </script>
@@ -45,6 +48,28 @@
   testing.expectEqual(0, window.scrollY);
 </script>
 
+<script id=scrollTo_clamps_to_document>
+  const max = document.documentElement.scrollHeight - window.innerHeight;
+  testing.expectTrue(max > 0);
+  window.scrollTo(0, 99999999);
+  testing.expectEqual(max, window.scrollY);
+  window.scrollBy(0, 100);
+  testing.expectEqual(max, window.scrollY);
+
+  // The document has no honest width, so x isn't bounded
+  window.scrollTo(99999, 0);
+  testing.expectEqual(99999, window.scrollX);
+
+  // Content added at the bottom extends the limit
+  const more = document.createElement('div');
+  more.style.height = '5000px';
+  document.body.appendChild(more);
+  window.scrollTo(0, 99999999);
+  testing.expectEqual(max + 5000, window.scrollY);
+  more.remove();
+  window.scrollTo(0, 0);
+</script>
+
 <script id=element_scroll_events_coalesce_and_preserve_reentrancy type=module>
   const state = await testing.async();
   const element = document.createElement('div');
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 373e142e1..25e37a6d4 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1500,12 +1500,12 @@ pub fn getElementAxis(self: *Element, frame: *Frame, comptime axis: Axis) Axis.S
         }
     }
 
-    // Root containers get large default size to contain descendant positions.
-    // With calculateDocumentPosition using linear depth scaling (100px per level),
-    // even very deep trees (100 levels) stay within 10,000px.
-    // 100M pixels is plausible for very long documents.
+    // Root containers span the document, see documentHeight.
     if (root) {
-        return .{ .value = if (axis == .width) 1920.0 else 100_000_000.0 };
+        return .{ .value = switch (axis) {
+            .width => 1920.0,
+            .height => if (self.ownerFrame(frame)) |owner| documentHeight(owner) else 0.0,
+        } };
     }
 
     // Presentational attributes lose to CSS sizes.
@@ -1679,8 +1679,7 @@ pub fn getScrollHeight(self: *Element, frame: *Frame) f64 {
     const height = self.getElementAxis(frame, .height).value;
 
     const tag = self.getTag();
-    // As in getScrollWidth: the root containers carry artificial giant
-    // defaults, and page-level overflow checks read them.
+    // The root containers already span the document.
     if (tag == .html or tag == .body) {
         return height;
     }
@@ -1696,9 +1695,9 @@ pub fn getScrollWidth(self: *Element, frame: *Frame) f64 {
     const width = self.getElementAxis(frame, .width).value;
 
     const tag = self.getTag();
-    // The root containers carry artificial giant defaults (1920 and
-    // 100_000_000, see getElementAxis). Stacking their children on
-    // top would inflate a value sites read to detect page overflow.
+    // The root containers span the document (see getElementAxis), and
+    // their children don't lie side by side on one row: stacking them
+    // would inflate a value sites read to detect page overflow.
     if (tag == .html or tag == .body) {
         return width;
     }
@@ -1708,9 +1707,9 @@ pub fn getScrollWidth(self: *Element, frame: *Frame) f64 {
 
 /// Null where we can't prove a limit, which leaves the offset unbounded:
 /// without an explicit size the client and content measurements collapse onto
-/// the same sum, and html and body carry giant defaults that would fabricate
-/// an extent against the real viewport. Refusing a scroll we can't prove
-/// impossible is worse than allowing one too many.
+/// the same sum. html and body scroll the viewport, which Window.scrollTo
+/// clamps. Refusing a scroll we can't prove impossible is worse than allowing
+/// one too many.
 fn scrollExtent(self: *Element, frame: *Frame, comptime axis: Axis) ?f64 {
     if (self.scrollsViewport() or !self.getElementAxis(frame, axis).explicit) {
         return null;
@@ -1781,8 +1780,8 @@ fn contentAxis(self: *Element, frame: *Frame, comptime axis: Axis) f64 {
     return total;
 }
 
-// Unlike clientHeight, the root's offsetHeight is its box (the document
-// extent), so it stays on the synthetic root default.
+// Unlike clientHeight, the root's offsetHeight is its box: the document
+// height.
 pub fn getOffsetHeight(self: *Element, frame: *Frame) f64 {
     if (!self.isVisible(frame)) {
         return 0.0;
@@ -1913,6 +1912,37 @@ fn calculateDocumentPosition(node: *Node) f64 {
     return position * 5.0; // 5px per node
 }
 
+/// The document's height, which html and body span and the viewport scrolls
+/// over. Tall enough for every synthetic position (calculateDocumentPosition's
+/// 5px per node), for body's children stacked on top of each other, and never
+/// shorter than the viewport, like the root's scrollHeight.
+pub fn documentHeight(frame: *Frame) f64 {
+    const version = frame.page.style_version;
+    const viewport = frame.page.getViewport().height;
+    if (frame._document_height) |cached| {
+        if (cached.version == version and cached.viewport == viewport) {
+            return cached.value;
+        }
+    }
+
+    const doc = frame.document;
+    var height = @max(@as(f64, @floatFromInt(viewport)), countSubtreeNodes(doc.asNode()) * 5.0);
+    if (doc.getDocumentElement()) |root| {
+        var child = root.asNode().firstChild();
+        while (child) |node| : (child = node.nextSibling()) {
+            if (node.is(Html.Body)) |body| {
+                height = @max(height, body.asElement().contentAxis(frame, .height));
+                break;
+            }
+        }
+    }
+
+    // Whole pixels, like the scroll offsets clamped against it
+    height = @ceil(height);
+    frame._document_height = .{ .version = version, .viewport = viewport, .value = height };
+    return height;
+}
+
 // Counts total nodes in a subtree (node + all descendants)
 fn countSubtreeNodes(node: *Node) f64 {
     var count: f64 = 1.0; // Count this node
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 44f99b2e5..bffa6c04e 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -952,7 +952,12 @@ fn getDevicePixelRatio(_: *const Window, frame: *Frame) f32 {
 pub fn scrollTo(self: *Window, opts: Element.ScrollToOpts, y: ?i32, frame: *Frame) !void {
     const o = opts.offsets(y);
     const new_x: u32 = if (o.left) |left| @intCast(@max(0, left)) else self._scroll_pos.x;
-    const new_y: u32 = if (o.top) |top| @intCast(@max(0, top)) else self._scroll_pos.y;
+    var new_y: u32 = if (o.top) |top| @intCast(@max(0, top)) else self._scroll_pos.y;
+
+    // The document can't scroll past its bottom. It has no honest width
+    // (children don't lie side by side), so x stays unbounded.
+    const max_y = Element.documentHeight(self._frame) - @as(f64, @floatFromInt(self.getInnerHeight(self._frame)));
+    new_y = @min(new_y, @as(u32, @intFromFloat(@max(0, @min(max_y, std.math.maxInt(u32))))));
 
     if (new_x == self._scroll_pos.x and new_y == self._scroll_pos.y) {
         return;