diff --git a/src/ArenaPool.zig b/src/ArenaPool.zig
index 6adbac564..053d55bbe 100644
--- a/src/ArenaPool.zig
+++ b/src/ArenaPool.zig
@@ -34,6 +34,7 @@ const SAFETY = Arena.SAFETY;
 pub const BucketSize = enum { tiny, small, medium, large };
 
 pub const Bucket = struct {
+    size: BucketSize,
     free_list: ?*Arena = null,
     free_list_len: u16 = 0,
     free_list_max: u16,
@@ -66,10 +67,10 @@ pub fn init(allocator: Allocator, config: Config) ArenaPool {
     return .{
         .allocator = allocator,
         .entry_pool = .empty,
-        .tiny = .{ .free_list_max = config.tiny.max, .retain_bytes = config.tiny.retain },
-        .small = .{ .free_list_max = config.small.max, .retain_bytes = config.small.retain },
-        .medium = .{ .free_list_max = config.medium.max, .retain_bytes = config.medium.retain },
-        .large = .{ .free_list_max = config.large.max, .retain_bytes = config.large.retain },
+        .tiny = .{ .size = .tiny, .free_list_max = config.tiny.max, .retain_bytes = config.tiny.retain },
+        .small = .{ .size = .small, .free_list_max = config.small.max, .retain_bytes = config.small.retain },
+        .medium = .{ .size = .medium, .free_list_max = config.medium.max, .retain_bytes = config.medium.retain },
+        .large = .{ .size = .large, .free_list_max = config.large.max, .retain_bytes = config.large.retain },
     };
 }
 
@@ -100,6 +101,13 @@ pub fn deinit(self: *ArenaPool) void {
     self.entry_pool.deinit(self.allocator);
 }
 
+pub fn bucketFor(self: *const ArenaPool, size: usize) BucketSize {
+    if (size <= self.tiny.retain_bytes) return .tiny;
+    if (size <= self.small.retain_bytes) return .small;
+    if (size <= self.medium.retain_bytes) return .medium;
+    return .large;
+}
+
 // Acquire an arena from the pool.
 // - Pass a BucketSize (.tiny, .small, .medium, .large) for explicit bucket selection
 // - Pass a usize for automatic bucket selection based on expected size
@@ -120,10 +128,7 @@ fn _acquire(self: *ArenaPool, account: ?*Arena.Account, size_or_bucket: anytype,
             break :blk @as(BucketSize, size_or_bucket);
         }
         if (T == usize or T == comptime_int) {
-            if (size_or_bucket <= self.tiny.retain_bytes) break :blk .tiny;
-            if (size_or_bucket <= self.small.retain_bytes) break :blk .small;
-            if (size_or_bucket <= self.medium.retain_bytes) break :blk .medium;
-            break :blk .large;
+            break :blk self.bucketFor(size_or_bucket);
         }
         @compileError("acquire expects BucketSize or usize, got " ++ @typeName(T));
     };
@@ -135,6 +140,8 @@ fn _acquire(self: *ArenaPool, account: ?*Arena.Account, size_or_bucket: anytype,
         .large => &self.large,
     };
 
+    lp.metrics.arena_inflight.incr(bucket_size);
+
     self.mutex.lockUncancelable(lp.io);
     defer self.mutex.unlock(lp.io);
 
@@ -186,6 +193,8 @@ pub fn release(self: *ArenaPool, entry: *Arena) void {
     const arena = &entry._arena;
     const bucket = entry.bucket;
 
+    lp.metrics.arena_inflight.decr(bucket.size);
+
     if (IS_DEBUG) {
         self.mutex.lockUncancelable(lp.io);
         defer self.mutex.unlock(lp.io);
diff --git a/src/Metrics.zig b/src/Metrics.zig
index 53fbc9eef..0791e4031 100644
--- a/src/Metrics.zig
+++ b/src/Metrics.zig
@@ -31,6 +31,7 @@ script_errors: Counter = .{},
 js_errors: CounterEnum("kind", enum { js_exception, other }) = .{},
 arena_hit: CounterEnum("size", @import("ArenaPool.zig").BucketSize) = .{},
 arena_miss: CounterEnum("size", @import("ArenaPool.zig").BucketSize) = .{},
+arena_inflight: GaugeEnum("size", @import("ArenaPool.zig").BucketSize) = .{},
 arena_memory_bytes: Gauge = .{},
 navigate: CounterEnum("type", @import("telemetry/telemetry.zig").Event.Navigate.Context) = .{},
 js_heap_size_bytes: Histogram(&.{
@@ -87,6 +88,7 @@ const help = .{
     .js_errors = "Uncaught JS errors (script exceptions, listener/callback throws, unhandled promise rejections); kind=js_exception is a thrown JS value, other is an internal failure (e.g. compilation error, terminated execution)",
     .arena_hit = "Arena pool acquisitions served from the free list",
     .arena_miss = "Arena pool acquisitions that had to allocate a new arena",
+    .arena_inflight = "Arenas currently checked out of the pool. Above the bucket's max, every acquisition is a miss and every release is discarded",
     .arena_memory_bytes = "Backing memory held by pooled arenas, including capacity retained on the free list",
     .navigate = "Navigations by initiating frame type",
     .js_heap_size_bytes = "V8 heap physical size, sampled when a page is closed",
@@ -164,6 +166,33 @@ const Gauge = struct {
     }
 };
 
+fn GaugeEnum(comptime label: []const u8, comptime T: type) type {
+    return struct {
+        values: std.enums.EnumArray(T, Gauge) = .initFill(.{}),
+
+        pub const Tag = T;
+        pub const label_name = label;
+
+        const Self = @This();
+
+        pub fn incr(self: *Self, tag: T) void {
+            self.values.getPtr(tag).incr();
+        }
+
+        pub fn decr(self: *Self, tag: T) void {
+            self.values.getPtr(tag).decr();
+        }
+
+        fn write(self: *const Self, comptime name: []const u8, comptime help_text: []const u8, writer: *std.Io.Writer) !void {
+            try writer.writeAll("# HELP " ++ name ++ " " ++ help_text ++ "\n" ++ "# TYPE " ++ name ++ " gauge\n");
+            inline for (comptime std.enums.values(Tag)) |tag| {
+                const value = @atomicLoad(isize, &self.values.getPtrConst(tag).value, .monotonic);
+                try writer.print(name ++ "{{" ++ label ++ "=\"" ++ @tagName(tag) ++ "\"}} {d}\n", .{value});
+            }
+        }
+    };
+}
+
 fn CounterEnum(comptime label: []const u8, comptime T: type) type {
     return struct {
         counts: std.enums.EnumArray(T, Counter) = .initFill(.{}),
diff --git a/src/browser/Factory.zig b/src/browser/Factory.zig
index 4c0a5a4a0..3dd35c56d 100644
--- a/src/browser/Factory.zig
+++ b/src/browser/Factory.zig
@@ -526,12 +526,10 @@ pub fn destroy(self: *Factory, value: anytype) void {
 
     if (comptime IS_DEBUG) {
         // We should always destroy from the leaf down.
-        if (@hasDecl(S, "_prototype_root")) {
-            // A Event{._type == .generic} (or any other similar types)
-            // _should_ be destroyed directly. The _type = .generic is a pseudo
-            // child
-            if (S != Event or value._type != .generic) {
-                log.fatal(.bug, "factory.destroy.event", .{ .type = @typeName(S) });
+        if (comptime @hasDecl(S, "_prototype_root")) {
+            const is_leaf = if (comptime @hasField(S, "_type")) value._type == .generic else false;
+            if (!is_leaf) {
+                log.fatal(.bug, "factory.destroy.root", .{ .type = @typeName(S) });
                 unreachable;
             }
         }
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 30bc1769e..77dad6cd0 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -2180,7 +2180,8 @@ pub fn loadExternalStylesheet(self: *Frame, link: *Element.Html.Link, href: []co
     }
     const element = link.asElement();
 
-    const arena = try session.getArena(.medium, "Frame.loadExternalStylesheet");
+    // HttpClient will take out a larger arena for the body, if necessary
+    const arena = try session.getArena(.small, "Frame.loadExternalStylesheet");
     defer arena.release();
 
     const resolved = URL.resolve(arena.allocator(), self.base(), href, .{ .encoding = self.charset }) catch |err| {
@@ -2212,7 +2213,7 @@ pub fn loadExternalStylesheet(self: *Frame, link: *Element.Html.Link, href: []co
     sm.is_evaluating = true;
     defer sm.endEvaluationWindow(was_evaluating);
 
-    var response = http_client.syncRequest(arena.allocator(), .{
+    var response = http_client.syncRequest(.{
         .url = resolved,
         .method = .GET,
         .frame_id = self._frame_id,
@@ -2227,7 +2228,7 @@ pub fn loadExternalStylesheet(self: *Frame, link: *Element.Html.Link, href: []co
         log.warn(.http, "external stylesheet fetch", .{ .err = err, .url = resolved });
         return self.fireElementEvent(element, comptime .wrap("error"));
     };
-    defer response.deinit(arena.allocator());
+    defer response.deinit();
 
     if (response.status < 200 or response.status >= 300) {
         log.info(.http, "external stylesheet status", .{ .status = response.status, .url = resolved });
diff --git a/src/browser/ScriptManager.zig b/src/browser/ScriptManager.zig
index 952b82934..a0b4ae485 100644
--- a/src/browser/ScriptManager.zig
+++ b/src/browser/ScriptManager.zig
@@ -112,7 +112,7 @@ pub fn preloadScript(self: *ScriptManager, element: ?*Element.Html, url: []const
     }
 
     const frame = self.frame;
-    const arena = try frame.getArena(.large, "SM.preloadScript");
+    const arena = try frame.getArena(.small, "SM.preloadScript");
     errdefer arena.release();
 
     const owned_url = try arena.dupeZ(u8, url);
@@ -240,7 +240,7 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
     // released early on the adoption path — so the errdefer can't double-free.
     var handover = false;
 
-    const arena = try frame.getArena(.large, "SM.addFromElement");
+    const arena = try frame.getArena(.small, "SM.addFromElement");
     errdefer if (handover == false) {
         arena.release();
     };
@@ -354,7 +354,7 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
                 script.status = pre.status;
                 script.complete = true;
             } else {
-                const response = try self.base.client.syncRequest(arena.allocator(), .{
+                const response = try self.base.client.syncRequest(.{
                     .url = remote_url,
                     .method = .GET,
                     .frame_id = frame._frame_id,
@@ -367,6 +367,9 @@ pub fn addFromElement(self: *ScriptManager, comptime from_parser: bool, script_e
                     .shutdown_callback = HttpClient.noopShutdown, // syncRequest installs its own
                 }, &frame._http_owner);
 
+                // Take the body's arena rather than releasing it: `source`
+                // has to outlive this call, up to script.deinit().
+                script.source_arena = response.arena;
                 script.source = .{ .remote = response.body };
                 script.status = response.status;
                 script.complete = true;
diff --git a/src/browser/ScriptManagerBase.zig b/src/browser/ScriptManagerBase.zig
index 2069bfee7..be2e9a7a5 100644
--- a/src/browser/ScriptManagerBase.zig
+++ b/src/browser/ScriptManagerBase.zig
@@ -234,7 +234,7 @@ pub fn preloadImport(self: *ScriptManagerBase, url: [:0]const u8, referrer: []co
     }
     errdefer _ = self.imported_modules.remove(url);
 
-    const arena = try self.acquireArena(.large, "SM.preloadImport");
+    const arena = try self.acquireArena(.small, "SM.preloadImport");
     errdefer arena.release();
 
     const script = try arena.create(Script);
@@ -426,7 +426,7 @@ pub fn getAsyncImport(self: *ScriptManagerBase, url: [:0]const u8, cb: ImportAsy
         }
     }
 
-    const arena = try self.acquireArena(.large, "SM.getAsyncImport");
+    const arena = try self.acquireArena(.small, "SM.getAsyncImport");
     errdefer arena.release();
 
     const script = try arena.create(Script);
@@ -611,6 +611,13 @@ pub const Script = struct {
     source: Source,
     url: []const u8,
     arena: *lp.Arena,
+
+    // Where `source` lives, when it isn't `arena`. The double-arena lets us
+    // use a .small arena for the Script itself, and then a properly sized one
+    // for the body, when we know its size. This avoids eager-usage of our
+    // limited .large arena pool
+    source_arena: ?*lp.Arena = null,
+
     extra: Extra,
     node: std.DoublyLinkedList.Node,
     manager: *ScriptManagerBase,
@@ -687,9 +694,18 @@ pub const Script = struct {
     };
 
     pub fn deinit(self: *Script) void {
+        if (self.source_arena) |source_arena| {
+            source_arena.release();
+        }
         self.arena.release();
     }
 
+    // The allocator `source` grows from. Falls back to the control arena when
+    // no header callback ran to size a dedicated one.
+    fn sourceAllocator(self: *Script) Allocator {
+        return (self.source_arena orelse self.arena).allocator();
+    }
+
     pub fn startCallback(transfer: *HttpClient.Transfer) !void {
         log.debug(.http, "script fetch start", .{ .req = transfer });
     }
@@ -748,9 +764,19 @@ pub const Script = struct {
         }
 
         lp.assert(self.source.remote.capacity == 0, "ScriptManagerBase.Header buffer", .{ .capacity = self.source.remote.capacity });
+
+        const content_length = transfer.getContentLength();
+        if (self.source_arena == null) {
+            // A redirect re-runs this callback; keep the arena we already have.
+            self.source_arena = if (content_length) |cl|
+                try self.manager.acquireArena(cl, "SM.source")
+            else
+                try self.manager.acquireArena(.large, "SM.source");
+        }
+
         var buffer: std.ArrayList(u8) = .empty;
-        if (transfer.getContentLength()) |cl| {
-            try buffer.ensureTotalCapacity(self.arena.allocator(), cl);
+        if (content_length) |cl| {
+            try buffer.ensureTotalCapacity(self.sourceAllocator(), cl);
         }
         self.source = .{ .remote = buffer };
         return .proceed;
@@ -765,7 +791,7 @@ pub const Script = struct {
     }
 
     fn _dataCallback(self: *Script, _: *HttpClient.Transfer, data: []const u8) !void {
-        try self.source.remote.appendSlice(self.arena.allocator(), data);
+        try self.source.remote.appendSlice(self.sourceAllocator(), data);
     }
 
     pub fn doneCallback(ctx: *anyopaque) !void {
diff --git a/src/browser/tests/encoding/text_decoder.html b/src/browser/tests/encoding/text_decoder.html
index 665e651ba..4f5574f40 100644
--- a/src/browser/tests/encoding/text_decoder.html
+++ b/src/browser/tests/encoding/text_decoder.html
@@ -49,6 +49,20 @@
   testing.expectEqual('♥', d3.decode(new Uint8Array([165]), { stream: true }));
 </script>
 
+<script id=stream_many>
+  // Each decode's output lives on the caller's call_arena, which resets under
+  // the decoder between calls. Reusing one decoder across many chunks must
+  // still return only the chunk just decoded.
+  let d5 = new TextDecoder();
+  let out = '';
+  for (let i = 0; i < 500; i++) {
+    out += d5.decode(new Uint8Array([104, 105]), { stream: true });
+  }
+  testing.expectEqual(1000, out.length);
+  testing.expectEqual('hihi', out.slice(0, 4));
+  testing.expectEqual('', d5.decode());
+</script>
+
 <script id=slice>
   const buf1 = new ArrayBuffer(7);
   const arr1 = new Uint8Array(buf1)
diff --git a/src/browser/webapi/DOMPoint.zig b/src/browser/webapi/DOMPoint.zig
index 7692f96e2..c33eb5c95 100644
--- a/src/browser/webapi/DOMPoint.zig
+++ b/src/browser/webapi/DOMPoint.zig
@@ -18,7 +18,6 @@
 
 const js = @import("../js/js.zig");
 const Page = @import("../Page.zig");
-const Factory = @import("../Factory.zig");
 const RO = @import("DOMPointReadOnly.zig");
 
 const DOMPoint = @This();
@@ -32,11 +31,8 @@ pub fn init(x_: ?f64, y_: ?f64, z_: ?f64, w_: ?f64, exec: *const js.Execution) !
 }
 
 pub fn create(x: f64, y: f64, z: f64, w: f64, page: *Page) !*DOMPoint {
-    const arena = try page.getArena(.tiny, "DOMPoint");
-    errdefer arena.release();
-
-    const self = try Factory.chainedWithAllocator(arena.allocator(), .{
-        RO.buildValue(arena, x, y, z, w),
+    const self = try page.factory.chained(.{
+        RO.buildValue(x, y, z, w),
         DOMPoint{ ._proto = undefined },
     });
     self._proto._type = .{ .mutable = self };
diff --git a/src/browser/webapi/DOMPointReadOnly.zig b/src/browser/webapi/DOMPointReadOnly.zig
index f1d453871..f8ecd2606 100644
--- a/src/browser/webapi/DOMPointReadOnly.zig
+++ b/src/browser/webapi/DOMPointReadOnly.zig
@@ -30,7 +30,6 @@ pub const _prototype_root = true;
 
 _type: Type,
 _rc: lp.RC,
-_arena: *lp.Arena,
 
 _x: f64,
 _y: f64,
@@ -70,8 +69,11 @@ pub fn init(x_: ?f64, y_: ?f64, z_: ?f64, w_: ?f64, exec: *const js.Execution) !
     return createBare(x_ orelse 0, y_ orelse 0, z_ orelse 0, w_ orelse 1, exec.page);
 }
 
-pub fn deinit(self: *DOMPointReadOnly, _: *Page) void {
-    self._arena.release();
+pub fn deinit(self: *DOMPointReadOnly, page: *Page) void {
+    switch (self._type) {
+        .generic => page.factory.destroy(self),
+        .mutable => |point| page.factory.destroy(point),
+    }
 }
 
 pub fn acquireRef(self: *DOMPointReadOnly) void {
@@ -83,18 +85,12 @@ pub fn releaseRef(self: *DOMPointReadOnly, page: *Page) void {
 }
 
 pub fn createBare(x: f64, y: f64, z: f64, w: f64, page: *Page) !*DOMPointReadOnly {
-    const arena = try page.getArena(.tiny, "DOMPoint");
-    errdefer arena.release();
-
-    const self = try arena.create(DOMPointReadOnly);
-    self.* = buildValue(arena, x, y, z, w);
-    return self;
+    return page.factory.create(buildValue(x, y, z, w));
 }
 
-pub fn buildValue(arena: *lp.Arena, x: f64, y: f64, z: f64, w: f64) DOMPointReadOnly {
+pub fn buildValue(x: f64, y: f64, z: f64, w: f64) DOMPointReadOnly {
     return .{
         ._rc = .{},
-        ._arena = arena,
         ._type = .generic,
         ._x = x,
         ._y = y,
diff --git a/src/browser/webapi/WorkerGlobalScope.zig b/src/browser/webapi/WorkerGlobalScope.zig
index 84ae1ba34..3fdc44f5f 100644
--- a/src/browser/webapi/WorkerGlobalScope.zig
+++ b/src/browser/webapi/WorkerGlobalScope.zig
@@ -396,7 +396,8 @@ pub fn importScripts(self: *WorkerGlobalScope, urls: []const [:0]const u8) !void
     }
 
     const session = self._session;
-    const arena = try session.getArena(.large, "importScript");
+    // HttpClient will take out a larger arena for the body, if necessary
+    const arena = try session.getArena(.small, "importScript");
     defer arena.release();
 
     for (urls) |url| {
@@ -415,7 +416,7 @@ fn importScript(self: *WorkerGlobalScope, arena: Allocator, url: [:0]const u8) !
     var headers = try http_client.newHeaders();
     try self.headersForRequest(&headers);
 
-    const response = http_client.syncRequest(arena, .{
+    var response = http_client.syncRequest(.{
         .url = resolved_url,
         .method = .GET,
         .frame_id = self._frame_id,
@@ -431,6 +432,7 @@ fn importScript(self: *WorkerGlobalScope, arena: Allocator, url: [:0]const u8) !
         log.warn(.http, "importScript", .{ .url = resolved_url, .err = err });
         return error.NetworkError;
     };
+    defer response.deinit();
 
     if (response.status != 200) {
         log.warn(.http, "importScript", .{ .url = resolved_url, .status = response.status });
diff --git a/src/browser/webapi/encoding/TextDecoder.zig b/src/browser/webapi/encoding/TextDecoder.zig
index 89969febf..2beec9a42 100644
--- a/src/browser/webapi/encoding/TextDecoder.zig
+++ b/src/browser/webapi/encoding/TextDecoder.zig
@@ -55,7 +55,9 @@ pub fn init(label_: ?[]const u8, opts_: ?InitOpts, page: *Page) !*TextDecoder {
         return error.RangeError;
     }
 
-    const arena = try page.getArena(.large, "TextDecoder");
+    // Only ever holds the decoder itself and the lazily-lowercased encoding
+    // name; decode output comes from the caller's call_arena.
+    const arena = try page.getArena(.tiny, "TextDecoder");
     errdefer arena.release();
 
     const opts = opts_ orelse InitOpts{};
@@ -110,7 +112,7 @@ const DecodeOpts = struct {
     stream: bool = false,
 };
 
-pub fn decode(self: *TextDecoder, input_: ?[]const u8, opts_: ?DecodeOpts) ![]const u8 {
+pub fn decode(self: *TextDecoder, input_: ?[]const u8, opts_: ?DecodeOpts, exec: *const js.Execution) ![]const u8 {
     const opts: DecodeOpts = opts_ orelse .{};
     const input = input_ orelse "";
 
@@ -122,12 +124,12 @@ pub fn decode(self: *TextDecoder, input_: ?[]const u8, opts_: ?DecodeOpts) ![]co
                 return error.OutOfMemory;
             }
         }
-        return self._decode(input, self._decoder, false);
+        return self._decode(exec.call_arena, input, self._decoder, false);
     }
 
     if (self._decoder) |decoder| {
         // Non-streaming with existing decoder: flush with is_last=true, then free
-        const result = try self._decode(input, decoder, true);
+        const result = try self._decode(exec.call_arena, input, decoder, true);
 
         // on error, _decode will free the decoder. So we only free it on non-error
         html5ever.encoding_decoder_free(decoder);
@@ -136,10 +138,10 @@ pub fn decode(self: *TextDecoder, input_: ?[]const u8, opts_: ?DecodeOpts) ![]co
     }
 
     // non-streaming, no existing decoder
-    return self._decode(input, null, true);
+    return self._decode(exec.call_arena, input, null, true);
 }
 
-fn _decode(self: *TextDecoder, input: []const u8, streaming_decoder: ?*anyopaque, is_last: bool) ![]const u8 {
+fn _decode(self: *TextDecoder, arena: std.mem.Allocator, input: []const u8, streaming_decoder: ?*anyopaque, is_last: bool) ![]const u8 {
     if (input.len == 0 and !is_last) {
         return "";
     }
@@ -155,7 +157,7 @@ fn _decode(self: *TextDecoder, input: []const u8, streaming_decoder: ?*anyopaque
     }
 
     // Allocate output buffer
-    const output = try self._arena.alloc(u8, max_out);
+    const output = try arena.alloc(u8, max_out);
 
     // Decode using either streaming or one-shot decoder
     const result = if (streaming_decoder) |decoder|
diff --git a/src/browser/webapi/net/Fetch.zig b/src/browser/webapi/net/Fetch.zig
index 0664b50ac..a0cd111f8 100644
--- a/src/browser/webapi/net/Fetch.zig
+++ b/src/browser/webapi/net/Fetch.zig
@@ -69,7 +69,7 @@ pub fn init(input: Input, options: ?InitOpts, exec: *const Execution) !js.Promis
         }
     }
 
-    const response = try Response.init(null, .{ .status = 0 }, exec);
+    const response = try Response.initPending(exec);
     errdefer response.deinit(exec.page);
 
     const fetch = try response._arena.create(Fetch);
diff --git a/src/browser/webapi/net/Response.zig b/src/browser/webapi/net/Response.zig
index 4e9e0f0ee..272f60c71 100644
--- a/src/browser/webapi/net/Response.zig
+++ b/src/browser/webapi/net/Response.zig
@@ -75,9 +75,30 @@ pub const BodyInit = body_init.BodyInit;
 
 pub fn init(body_: ?BodyInit, opts_: ?InitOpts, exec: *const Execution) !*Response {
     const session = exec.session;
-    const arena = try session.getPinnedArena(.large, "Response");
-    errdefer arena.release();
 
+    const bucket: lp.ArenaPool.BucketSize = blk: {
+        const body = body_ orelse break :blk .small;
+        if (body == .stream) {
+            // A stream body is referenced below, never copied into the arena.
+            break :blk .small;
+        }
+        const hint = body.sizeHint() orelse break :blk .large;
+        break :blk session.arena_pool.bucketFor(hint + 512);
+    };
+
+    const arena = try session.getPinnedArena(bucket, "Response");
+    errdefer arena.release();
+    return initWithArena(arena, body_, opts_, exec);
+}
+
+// fetch()'s response shell.
+pub fn initPending(exec: *const Execution) !*Response {
+    const arena = try exec.session.getPinnedArena(.large, "Response.pending");
+    errdefer arena.release();
+    return initWithArena(arena, null, .{ .status = 0 }, exec);
+}
+
+fn initWithArena(arena: *lp.Arena, body_: ?BodyInit, opts_: ?InitOpts, exec: *const Execution) !*Response {
     const opts = opts_ orelse InitOpts{};
     const status_text = if (opts.statusText) |st| try arena.dupe(u8, st) else "";
 
@@ -118,7 +139,7 @@ pub fn init(body_: ?BodyInit, opts_: ?InitOpts, exec: *const Execution) !*Respon
 
 pub fn createError(exec: *const Execution) !*Response {
     const session = exec.session;
-    const arena = try session.getPinnedArena(.large, "Response.error");
+    const arena = try session.getPinnedArena(.tiny, "Response.error");
     errdefer arena.release();
 
     const self = try arena.create(Response);
@@ -144,7 +165,7 @@ pub fn createRedirect(url_: []const u8, status_: ?u16, exec: *const Execution) !
     }
 
     const session = exec.session;
-    const arena = try session.getPinnedArena(.large, "Response.redirect");
+    const arena = try session.getPinnedArena(.small, "Response.redirect");
     errdefer arena.release();
 
     const location = try URL.resolve(arena.allocator(), exec.base(), url_, .{ .encoding = exec.charset.* });
diff --git a/src/browser/webapi/net/body_init.zig b/src/browser/webapi/net/body_init.zig
index be318e166..1b04fbe56 100644
--- a/src/browser/webapi/net/body_init.zig
+++ b/src/browser/webapi/net/body_init.zig
@@ -49,6 +49,16 @@ pub const BodyInit = union(enum) {
     buffer: js.TypedArray(u8),
     bytes: []const u8, // must be last, js.Bridge will map anything to a string
 
+    // How much a call to `extract` will dupe. Used for ArenaPool size selection.
+    pub fn sizeHint(self: BodyInit) ?usize {
+        return switch (self) {
+            .bytes => |b| b.len,
+            .buffer => |b| b.values.len,
+            .blob => |b| b._slice.len + b._mime.len,
+            .form_data, .url_search_params, .stream => null,
+        };
+    }
+
     pub fn extract(self: BodyInit, arena: Allocator) !Extracted {
         switch (self) {
             .bytes => |b| {
diff --git a/src/cdp/CDP.zig b/src/cdp/CDP.zig
index 7b6e09fff..981aa5c63 100644
--- a/src/cdp/CDP.zig
+++ b/src/cdp/CDP.zig
@@ -1489,7 +1489,7 @@ test "cdp: syncRequest short-circuits after disconnect" {
     // per-test leak check, so it's verified by review. The latch check returns
     // before any other req field is read, so the rest are placeholders.
     const headers = try client.newHeaders();
-    try testing.expectError(error.ClientDisconnected, client.syncRequest(testing.allocator, .{
+    try testing.expectError(error.ClientDisconnected, client.syncRequest(.{
         .frame_id = 0,
         .loader_id = 0,
         .method = .GET,
diff --git a/src/lightpanda.zig b/src/lightpanda.zig
index 53a5502e2..4d747acf3 100644
--- a/src/lightpanda.zig
+++ b/src/lightpanda.zig
@@ -22,6 +22,7 @@ pub const log = @import("log.zig");
 pub const datetime = @import("datetime.zig");
 pub const App = @import("App.zig");
 pub const Arena = @import("Arena.zig");
+pub const ArenaPool = @import("ArenaPool.zig");
 pub const Network = @import("network/Network.zig");
 pub const Server = @import("Server.zig");
 pub const Config = @import("Config.zig");
diff --git a/src/network/HttpClient.zig b/src/network/HttpClient.zig
index 10229cff3..e08315bf5 100644
--- a/src/network/HttpClient.zig
+++ b/src/network/HttpClient.zig
@@ -1069,7 +1069,7 @@ fn cacheStore(self: *Client, transfer: *Transfer) void {
 }
 
 const SyncContext = struct {
-    allocator: Allocator,
+    client: *Client,
     completion: union(enum) {
         in_progress: void,
         done: void,
@@ -1080,19 +1080,35 @@ const SyncContext = struct {
     status: u16 = 0,
     body: std.ArrayList(u8),
 
+    // Acquired on the first byte we have to buffer, so a bodyless response
+    // never takes one. Ownership moves to the SyncResponse.
+    arena: ?*lp.Arena = null,
+
     fn headerCallback(transfer: *Transfer) anyerror!Transfer.HeaderResult {
         const self: *SyncContext = @ptrCast(@alignCast(transfer.req.ctx));
         lp.assert(transfer.responseStatus() != null, "HttpClient.SyncRequest.headerCallback", .{ .value = transfer.responseStatus() });
         self.status = transfer.responseStatus().?;
         if (transfer.getContentLength()) |cl| {
-            try self.body.ensureTotalCapacity(self.allocator, cl);
+            try self.body.ensureTotalCapacity(try self.bodyAllocator(cl), cl);
         }
         return .proceed;
     }
 
+    fn bodyAllocator(self: *SyncContext, content_length: ?usize) !Allocator {
+        if (self.arena) |arena| {
+            return arena.allocator();
+        }
+        const arena = if (content_length) |cl|
+            try self.client.arena_pool.acquire(cl, "syncRequest.body")
+        else
+            try self.client.arena_pool.acquire(.large, "syncRequest.body");
+        self.arena = arena;
+        return arena.allocator();
+    }
+
     fn dataCallback(transfer: *Transfer, data: []const u8) anyerror!void {
         const self: *SyncContext = @ptrCast(@alignCast(transfer.req.ctx));
-        try self.body.appendSlice(self.allocator, data);
+        try self.body.appendSlice(try self.bodyAllocator(null), data);
     }
 
     fn doneCallback(ctx: *anyopaque) anyerror!void {
@@ -1111,7 +1127,8 @@ const SyncContext = struct {
     }
 };
 
-pub fn syncRequest(self: *Client, allocator: Allocator, req: Request, owner: *Owner) !SyncResponse {
+// Caller must deinit SyncResponse or otherwise take ownership of its optional arena
+pub fn syncRequest(self: *Client, req: Request, owner: *Owner) !SyncResponse {
     if (self.inbox.terminated) {
         // request() takes ownership of req.headers on every path; we return
         // before calling it, so free the curl_slist here to avoid leaking it.
@@ -1126,8 +1143,8 @@ pub fn syncRequest(self: *Client, allocator: Allocator, req: Request, owner: *Ow
         return error.SyncWaitInterrupted;
     }
 
-    var sync_ctx = SyncContext{ .allocator = allocator, .body = .empty };
-    errdefer sync_ctx.body.deinit(allocator);
+    var sync_ctx = SyncContext{ .client = self, .body = .empty };
+    errdefer if (sync_ctx.arena) |arena| arena.release();
 
     var r = req;
     r.sync = true;
@@ -1168,6 +1185,7 @@ pub fn syncRequest(self: *Client, allocator: Allocator, req: Request, owner: *Ow
         .done, .shutdown => return .{
             .status = sync_ctx.status,
             .body = sync_ctx.body,
+            .arena = sync_ctx.arena,
         },
         .err => |e| return e,
     }
@@ -1705,8 +1723,14 @@ pub const SyncResponse = struct {
     status: u16,
     body: std.ArrayList(u8),
 
-    pub fn deinit(self: *SyncResponse, allocator: Allocator) void {
-        self.body.deinit(allocator);
+    // Owns `body`. Null when the response had nothing to buffer. Callers that
+    // keep `body` past this call take the arena instead of releasing it.
+    arena: ?*lp.Arena,
+
+    pub fn deinit(self: *SyncResponse) void {
+        if (self.arena) |arena| {
+            arena.release();
+        }
     }
 };