diff --git a/src/browser/HttpClient.zig b/src/browser/HttpClient.zig
index 7e4f091f..cb8b3ac6 100644
--- a/src/browser/HttpClient.zig
+++ b/src/browser/HttpClient.zig
@@ -376,8 +376,10 @@ fn fetchRobotsThenProcessRequest(self: *Client, robots_url: [:0]const u8, req: R
     try entry.value_ptr.append(self.allocator, req);
 }
 
-fn robotsHeaderCallback(transfer: *LiveTransfer) !bool {
-    const ctx: *RobotsRequestContext = @ptrCast(@alignCast(transfer.ctx));
+fn robotsHeaderCallback(response: Response) !bool {
+    const ctx: *RobotsRequestContext = @ptrCast(@alignCast(response.ctx));
+    // Robots callbacks only happen on real live requests.
+    const transfer = response.inner.live;
 
     if (transfer.response_header) |hdr| {
         log.debug(.browser, "robots status", .{ .status = hdr.status, .robots_url = ctx.robots_url });
@@ -391,8 +393,8 @@ fn robotsHeaderCallback(transfer: *LiveTransfer) !bool {
     return true;
 }
 
-fn robotsDataCallback(transfer: *LiveTransfer, data: []const u8) !void {
-    const ctx: *RobotsRequestContext = @ptrCast(@alignCast(transfer.ctx));
+fn robotsDataCallback(response: Response, data: []const u8) !void {
+    const ctx: *RobotsRequestContext = @ptrCast(@alignCast(response.ctx));
     try ctx.buffer.appendSlice(ctx.client.allocator, data);
 }
 
@@ -611,7 +613,6 @@ fn makeTransfer(self: *Client, req: Request) !*LiveTransfer {
         .id = id,
         .url = req.url,
         .req = req,
-        .ctx = req.ctx,
         .client = self,
         .max_response_size = self.network.config.httpMaxResponseSize(),
     };
@@ -634,9 +635,9 @@ fn requestFailed(transfer: *LiveTransfer, err: anyerror, comptime execute_callba
     });
 
     if (execute_callback) {
-        transfer.req.error_callback(transfer.ctx, err);
+        transfer.req.error_callback(transfer.req.ctx, err);
     } else if (transfer.req.shutdown_callback) |cb| {
-        cb(transfer.ctx);
+        cb(transfer.req.ctx);
     }
 }
 
@@ -743,7 +744,7 @@ fn makeRequest(self: *Client, conn: *Net.Connection, transfer: *LiveTransfer) an
     };
 
     if (req.start_callback) |cb| {
-        cb(transfer) catch |err| {
+        cb(Response.fromLive(transfer)) catch |err| {
             transfer.deinit();
             return err;
         };
@@ -875,7 +876,7 @@ fn processMessages(self: *Client) !bool {
                     break :blk;
                 }
             }
-            transfer.req.done_callback(transfer.ctx) catch |err| {
+            transfer.req.done_callback(transfer.req.ctx) catch |err| {
                 // transfer isn't valid at this point, don't use it.
                 log.err(.http, "done_callback", .{ .err = err });
                 requestFailed(transfer, err, true);
@@ -962,9 +963,9 @@ pub const Request = struct {
     // arbitrary data that can be associated with this request
     ctx: *anyopaque = undefined,
 
-    start_callback: ?*const fn (transfer: *LiveTransfer) anyerror!void = null,
-    header_callback: *const fn (transfer: *LiveTransfer) anyerror!bool,
-    data_callback: *const fn (transfer: *LiveTransfer, data: []const u8) anyerror!void,
+    start_callback: ?*const fn (response: Response) anyerror!void = null,
+    header_callback: *const fn (response: Response) anyerror!bool,
+    data_callback: *const fn (response: Response, data: []const u8) anyerror!void,
     done_callback: *const fn (ctx: *anyopaque) anyerror!void,
     error_callback: *const fn (ctx: *anyopaque, err: anyerror) void,
     shutdown_callback: ?*const fn (ctx: *anyopaque) void = null,
@@ -992,40 +993,41 @@ pub const Request = struct {
 
 const AuthChallenge = Net.AuthChallenge;
 
-pub const Transfer = struct {
+pub const Response = struct {
+    ctx: *anyopaque,
     inner: union(enum) {
-        live: LiveTransfer,
+        live: *LiveTransfer,
     },
 
-    pub fn fromLive(transfer: *LiveTransfer) Transfer {
+    pub fn fromLive(transfer: *LiveTransfer) Response {
         return .{ .ctx = transfer.req.ctx, .inner = .{ .live = transfer } };
     }
 
-    pub fn status(self: Transfer) ?u16 {
+    pub fn status(self: Response) ?u16 {
         return switch (self.inner) {
             .live => |live| if (live.response_header) |rh| rh.status else null,
         };
     }
 
-    pub fn contentType(self: Transfer) ?[]const u8 {
+    pub fn contentType(self: Response) ?[]const u8 {
         return switch (self.inner) {
             .live => |live| if (live.response_header) |*rh| rh.contentType() else null,
         };
     }
 
-    pub fn contentLength(self: Transfer) ?u32 {
+    pub fn contentLength(self: Response) ?u32 {
         return switch (self.inner) {
             .live => |live| live.getContentLength(),
         };
     }
 
-    pub fn redirectCount(self: Transfer) ?u32 {
+    pub fn redirectCount(self: Response) ?u32 {
         return switch (self.inner) {
             .live => |live| if (live.response_header) |rh| rh.redirect_count else null,
         };
     }
 
-    pub fn url(self: Transfer) [:0]const u8 {
+    pub fn url(self: Response) [:0]const u8 {
         return switch (self.inner) {
             .live => |live| live.url,
         };
@@ -1033,13 +1035,13 @@ pub const Transfer = struct {
 
     // TODO: Headers Iterator.
 
-    pub fn abort(self: Transfer, err: anyerror) void {
+    pub fn abort(self: Response, err: anyerror) void {
         switch (self.inner) {
             .live => |live| live.abort(err),
         }
     }
 
-    pub fn terminate(self: Transfer) void {
+    pub fn terminate(self: Response) void {
         switch (self.inner) {
             .live => |live| live.terminate(),
         }
@@ -1047,7 +1049,6 @@ pub const Transfer = struct {
 };
 
 pub const LiveTransfer = struct {
-    ctx: *anyopaque,
     arena: ArenaAllocator,
     id: u32 = 0,
     req: Request,
@@ -1215,7 +1216,7 @@ pub const LiveTransfer = struct {
             self.client.endTransfer(self);
         }
         if (self.req.shutdown_callback) |cb| {
-            cb(self.ctx);
+            cb(self.req.ctx);
         }
         self.deinit();
     }
@@ -1317,7 +1318,7 @@ pub const LiveTransfer = struct {
             }
         }
 
-        const proceed = transfer.req.header_callback(transfer) catch |err| {
+        const proceed = transfer.req.header_callback(Response.fromLive(transfer)) catch |err| {
             log.err(.http, "header_callback", .{ .err = err, .req = transfer });
             return err;
         };
@@ -1482,7 +1483,7 @@ pub const LiveTransfer = struct {
         }
 
         const chunk = buffer[0..chunk_len];
-        transfer.req.data_callback(transfer, chunk) catch |err| {
+        transfer.req.data_callback(Response.fromLive(transfer), chunk) catch |err| {
             log.err(.http, "data_callback", .{ .err = err, .req = transfer });
             return Net.writefunc_error;
         };
@@ -1534,7 +1535,7 @@ pub const LiveTransfer = struct {
     fn _fulfill(transfer: *LiveTransfer, status: u16, headers: []const Net.Header, body: ?[]const u8) !void {
         const req = &transfer.req;
         if (req.start_callback) |cb| {
-            try cb(transfer);
+            try cb(Response.fromLive(transfer));
         }
 
         transfer.response_header = .{
@@ -1553,13 +1554,13 @@ pub const LiveTransfer = struct {
         }
 
         lp.assert(transfer._header_done_called == false, "Transfer.fulfill header_done_called", .{});
-        if (try req.header_callback(transfer) == false) {
+        if (try req.header_callback(Response.fromLive(transfer)) == false) {
             transfer.abort(error.Abort);
             return;
         }
 
         if (body) |b| {
-            try req.data_callback(transfer, b);
+            try req.data_callback(Response.fromLive(transfer), b);
         }
 
         try req.done_callback(req.ctx);
diff --git a/src/browser/Page.zig b/src/browser/Page.zig
index aae7f5e3..9f05aee4 100644
--- a/src/browser/Page.zig
+++ b/src/browser/Page.zig
@@ -821,12 +821,10 @@ fn notifyParentLoadComplete(self: *Page) void {
     parent.iframeCompletedLoading(self.iframe.?);
 }
 
-fn pageHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
-    var self: *Page = @ptrCast(@alignCast(transfer.ctx));
+fn pageHeaderDoneCallback(response: HttpClient.Response) !bool {
+    var self: *Page = @ptrCast(@alignCast(response.ctx));
 
-    const header = &transfer.response_header.?;
-
-    const response_url = std.mem.span(header.url);
+    const response_url = response.url();
     if (std.mem.eql(u8, response_url, self.url) == false) {
         // would be different than self.url in the case of a redirect
         self.url = try self.arena.dupeZ(u8, response_url);
@@ -840,8 +838,8 @@ fn pageHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
     if (comptime IS_DEBUG) {
         log.debug(.page, "navigate header", .{
             .url = self.url,
-            .status = header.status,
-            .content_type = header.contentType(),
+            .status = response.status(),
+            .content_type = response.contentType(),
             .type = self._type,
         });
     }
@@ -849,14 +847,14 @@ fn pageHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
     return true;
 }
 
-fn pageDataCallback(transfer: *HttpClient.LiveTransfer, data: []const u8) !void {
-    var self: *Page = @ptrCast(@alignCast(transfer.ctx));
+fn pageDataCallback(response: HttpClient.Response, data: []const u8) !void {
+    var self: *Page = @ptrCast(@alignCast(response.ctx));
 
     if (self._parse_state == .pre) {
         // we lazily do this, because we might need the first chunk of data
         // to sniff the content type
         var mime: Mime = blk: {
-            if (transfer.response_header.?.contentType()) |ct| {
+            if (response.contentType()) |ct| {
                 break :blk try Mime.parse(ct);
             }
             break :blk Mime.sniff(data);
diff --git a/src/browser/ScriptManager.zig b/src/browser/ScriptManager.zig
index 671bb908..6a5b725f 100644
--- a/src/browser/ScriptManager.zig
+++ b/src/browser/ScriptManager.zig
@@ -694,85 +694,85 @@ pub const Script = struct {
         self.manager.page.releaseArena(self.arena);
     }
 
-    fn startCallback(transfer: *HttpClient.LiveTransfer) !void {
-        log.debug(.http, "script fetch start", .{ .req = transfer });
+    fn startCallback(response: HttpClient.Response) !void {
+        log.debug(.http, "script fetch start", .{ .req = response });
     }
 
-    fn headerCallback(transfer: *HttpClient.LiveTransfer) !bool {
-        const self: *Script = @ptrCast(@alignCast(transfer.ctx));
-        const header = &transfer.response_header.?;
-        self.status = header.status;
-        if (header.status != 200) {
+    fn headerCallback(response: HttpClient.Response) !bool {
+        const self: *Script = @ptrCast(@alignCast(response.ctx));
+
+        self.status = response.status().?;
+        if (response.status() != 200) {
             log.info(.http, "script header", .{
-                .req = transfer,
-                .status = header.status,
-                .content_type = header.contentType(),
+                .req = response,
+                .status = response.status(),
+                .content_type = response.contentType(),
             });
             return false;
         }
 
         if (comptime IS_DEBUG) {
             log.debug(.http, "script header", .{
-                .req = transfer,
-                .status = header.status,
-                .content_type = header.contentType(),
+                .req = response,
+                .status = response.status(),
+                .content_type = response.contentType(),
             });
         }
 
-        {
-            // temp debug, trying to figure out why the next assert sometimes
-            // fails. Is the buffer just corrupt or is headerCallback really
-            // being called twice?
-            lp.assert(self.header_callback_called == false, "ScriptManager.Header recall", .{
-                .m = @tagName(std.meta.activeTag(self.mode)),
-                .a1 = self.debug_transfer_id,
-                .a2 = self.debug_transfer_tries,
-                .a3 = self.debug_transfer_aborted,
-                .a4 = self.debug_transfer_bytes_received,
-                .a5 = self.debug_transfer_notified_fail,
-                .a6 = self.debug_transfer_redirecting,
-                .a7 = self.debug_transfer_intercept_state,
-                .a8 = self.debug_transfer_auth_challenge,
-                .a9 = self.debug_transfer_easy_id,
-                .b1 = transfer.id,
-                .b2 = transfer._tries,
-                .b3 = transfer.aborted,
-                .b4 = transfer.bytes_received,
-                .b5 = transfer._notified_fail,
-                .b6 = transfer._redirecting,
-                .b7 = @intFromEnum(transfer._intercept_state),
-                .b8 = transfer._auth_challenge != null,
-                .b9 = if (transfer._conn) |c| @intFromPtr(c.easy) else 0,
-            });
-            self.header_callback_called = true;
-            self.debug_transfer_id = transfer.id;
-            self.debug_transfer_tries = transfer._tries;
-            self.debug_transfer_aborted = transfer.aborted;
-            self.debug_transfer_bytes_received = transfer.bytes_received;
-            self.debug_transfer_notified_fail = transfer._notified_fail;
-            self.debug_transfer_redirecting = transfer._redirecting;
-            self.debug_transfer_intercept_state = @intFromEnum(transfer._intercept_state);
-            self.debug_transfer_auth_challenge = transfer._auth_challenge != null;
-            self.debug_transfer_easy_id = if (transfer._conn) |c| @intFromPtr(c.easy) else 0;
-        }
+        // {
+        //     // temp debug, trying to figure out why the next assert sometimes
+        //     // fails. Is the buffer just corrupt or is headerCallback really
+        //     // being called twice?
+        //     lp.assert(self.header_callback_called == false, "ScriptManager.Header recall", .{
+        //         .m = @tagName(std.meta.activeTag(self.mode)),
+        //         .a1 = self.debug_transfer_id,
+        //         .a2 = self.debug_transfer_tries,
+        //         .a3 = self.debug_transfer_aborted,
+        //         .a4 = self.debug_transfer_bytes_received,
+        //         .a5 = self.debug_transfer_notified_fail,
+        //         .a6 = self.debug_transfer_redirecting,
+        //         .a7 = self.debug_transfer_intercept_state,
+        //         .a8 = self.debug_transfer_auth_challenge,
+        //         .a9 = self.debug_transfer_easy_id,
+        //         .b1 = transfer.id,
+        //         .b2 = transfer._tries,
+        //         .b3 = transfer.aborted,
+        //         .b4 = transfer.bytes_received,
+        //         .b5 = transfer._notified_fail,
+        //         .b6 = transfer._redirecting,
+        //         .b7 = @intFromEnum(transfer._intercept_state),
+        //         .b8 = transfer._auth_challenge != null,
+        //         .b9 = if (transfer._conn) |c| @intFromPtr(c.easy) else 0,
+        //     });
+        //     self.header_callback_called = true;
+        //     self.debug_transfer_id = transfer.id;
+        //     self.debug_transfer_tries = transfer._tries;
+        //     self.debug_transfer_aborted = transfer.aborted;
+        //     self.debug_transfer_bytes_received = transfer.bytes_received;
+        //     self.debug_transfer_notified_fail = transfer._notified_fail;
+        //     self.debug_transfer_redirecting = transfer._redirecting;
+        //     self.debug_transfer_intercept_state = @intFromEnum(transfer._intercept_state);
+        //     self.debug_transfer_auth_challenge = transfer._auth_challenge != null;
+        //     self.debug_transfer_easy_id = if (transfer._conn) |c| @intFromPtr(c.easy) else 0;
+        // }
 
         lp.assert(self.source.remote.capacity == 0, "ScriptManager.Header buffer", .{ .capacity = self.source.remote.capacity });
         var buffer: std.ArrayList(u8) = .empty;
-        if (transfer.getContentLength()) |cl| {
+        if (response.contentLength()) |cl| {
             try buffer.ensureTotalCapacity(self.arena, cl);
         }
         self.source = .{ .remote = buffer };
         return true;
     }
 
-    fn dataCallback(transfer: *HttpClient.LiveTransfer, data: []const u8) !void {
-        const self: *Script = @ptrCast(@alignCast(transfer.ctx));
-        self._dataCallback(transfer, data) catch |err| {
-            log.err(.http, "SM.dataCallback", .{ .err = err, .transfer = transfer, .len = data.len });
+    fn dataCallback(response: HttpClient.Response, data: []const u8) !void {
+        const self: *Script = @ptrCast(@alignCast(response.ctx));
+        self._dataCallback(response, data) catch |err| {
+            log.err(.http, "SM.dataCallback", .{ .err = err, .transfer = response, .len = data.len });
             return err;
         };
     }
-    fn _dataCallback(self: *Script, _: *HttpClient.LiveTransfer, data: []const u8) !void {
+    fn _dataCallback(self: *Script, _: HttpClient.Response, data: []const u8) !void {
         try self.source.remote.appendSlice(self.arena, data);
     }
 
diff --git a/src/browser/webapi/net/Fetch.zig b/src/browser/webapi/net/Fetch.zig
index 3b3ec7cb..9f39ef76 100644
--- a/src/browser/webapi/net/Fetch.zig
+++ b/src/browser/webapi/net/Fetch.zig
@@ -126,16 +126,16 @@ fn handleBlobUrl(url: []const u8, resolver: js.PromiseResolver, page: *Page) !js
     return resolver.promise();
 }
 
-fn httpStartCallback(transfer: *HttpClient.LiveTransfer) !void {
-    const self: *Fetch = @ptrCast(@alignCast(transfer.ctx));
+fn httpStartCallback(response: HttpClient.Response) !void {
+    const self: *Fetch = @ptrCast(@alignCast(response.ctx));
     if (comptime IS_DEBUG) {
         log.debug(.http, "request start", .{ .url = self._url, .source = "fetch" });
     }
-    self._response._transfer = transfer;
+    self._response._http_response = response;
 }
 
-fn httpHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
-    const self: *Fetch = @ptrCast(@alignCast(transfer.ctx));
+fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
+    const self: *Fetch = @ptrCast(@alignCast(response.ctx));
 
     if (self._signal) |signal| {
         if (signal._aborted) {
@@ -144,25 +144,24 @@ fn httpHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
     }
 
     const arena = self._response._arena;
-    if (transfer.getContentLength()) |cl| {
+    if (response.contentLength()) |cl| {
         try self._buf.ensureTotalCapacity(arena, cl);
     }
 
     const res = self._response;
-    const header = transfer.response_header.?;
 
     if (comptime IS_DEBUG) {
         log.debug(.http, "request header", .{
             .source = "fetch",
             .url = self._url,
-            .status = header.status,
+            .status = response.status(),
         });
     }
 
-    res._status = header.status;
-    res._status_text = std.http.Status.phrase(@enumFromInt(header.status)) orelse "";
-    res._url = try arena.dupeZ(u8, std.mem.span(header.url));
-    res._is_redirected = header.redirect_count > 0;
+    res._status = response.status().?;
+    res._status_text = std.http.Status.phrase(@enumFromInt(response.status().?)) orelse "";
+    res._url = try arena.dupeZ(u8, response.url());
+    res._is_redirected = response.redirectCount().? > 0;
 
     // Determine response type based on origin comparison
     const page_origin = URL.getOrigin(arena, self._page.url) catch null;
@@ -182,16 +181,17 @@ fn httpHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
         res._type = .basic;
     }
 
-    var it = transfer.responseHeaderIterator();
-    while (it.next()) |hdr| {
-        try res._headers.append(hdr.name, hdr.value, self._page);
-    }
+    // TODO: Header Iterator
+    // var it = transfer.responseHeaderIterator();
+    // while (it.next()) |hdr| {
+    //     try res._headers.append(hdr.name, hdr.value, self._page);
+    // }
 
     return true;
 }
 
-fn httpDataCallback(transfer: *HttpClient.LiveTransfer, data: []const u8) !void {
-    const self: *Fetch = @ptrCast(@alignCast(transfer.ctx));
+fn httpDataCallback(response: HttpClient.Response, data: []const u8) !void {
+    const self: *Fetch = @ptrCast(@alignCast(response.ctx));
 
     // Check if aborted
     if (self._signal) |signal| {
@@ -206,7 +206,7 @@ fn httpDataCallback(transfer: *HttpClient.LiveTransfer, data: []const u8) !void
 fn httpDoneCallback(ctx: *anyopaque) !void {
     const self: *Fetch = @ptrCast(@alignCast(ctx));
     var response = self._response;
-    response._transfer = null;
+    response._http_response = null;
     response._body = self._buf.items;
 
     log.info(.http, "request complete", .{
@@ -229,7 +229,7 @@ fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
     const self: *Fetch = @ptrCast(@alignCast(ctx));
 
     var response = self._response;
-    response._transfer = null;
+    response._http_response = null;
     // the response is only passed on v8 on success, if we're here, it's safe to
     // clear this. (defer since `self is in the response's arena).
 
@@ -255,7 +255,7 @@ fn httpShutdownCallback(ctx: *anyopaque) void {
 
     if (self._owns_response) {
         var response = self._response;
-        response._transfer = null;
+        response._http_response = null;
         response.deinit(true, self._page._session);
         // Do not access `self` after this point: the Fetch struct was
         // allocated from response._arena which has been released.
diff --git a/src/browser/webapi/net/Response.zig b/src/browser/webapi/net/Response.zig
index 7520ba50..97572912 100644
--- a/src/browser/webapi/net/Response.zig
+++ b/src/browser/webapi/net/Response.zig
@@ -46,7 +46,7 @@ _type: Type,
 _status_text: []const u8,
 _url: [:0]const u8,
 _is_redirected: bool,
-_transfer: ?*HttpClient.LiveTransfer = null,
+_http_response: ?HttpClient.Response = null,
 
 const InitOpts = struct {
     status: u16 = 200,
@@ -79,13 +79,13 @@ pub fn init(body_: ?[]const u8, opts_: ?InitOpts, page: *Page) !*Response {
 }
 
 pub fn deinit(self: *Response, shutdown: bool, session: *Session) void {
-    if (self._transfer) |transfer| {
+    if (self._http_response) |resp| {
         if (shutdown) {
-            transfer.terminate();
+            resp.terminate();
         } else {
-            transfer.abort(error.Abort);
+            resp.abort(error.Abort);
         }
-        self._transfer = null;
+        self._http_response = null;
     }
     session.releaseArena(self._arena);
 }
@@ -185,7 +185,7 @@ pub fn clone(self: *const Response, page: *Page) !*Response {
         ._type = self._type,
         ._is_redirected = self._is_redirected,
         ._headers = try Headers.init(.{ .obj = self._headers }, page),
-        ._transfer = null,
+        ._http_response = null,
     };
     return cloned;
 }
diff --git a/src/browser/webapi/net/XMLHttpRequest.zig b/src/browser/webapi/net/XMLHttpRequest.zig
index 308facd6..1a6f9a13 100644
--- a/src/browser/webapi/net/XMLHttpRequest.zig
+++ b/src/browser/webapi/net/XMLHttpRequest.zig
@@ -42,7 +42,7 @@ const XMLHttpRequest = @This();
 _page: *Page,
 _proto: *XMLHttpRequestEventTarget,
 _arena: Allocator,
-_transfer: ?*HttpClient.LiveTransfer = null,
+_http_response: ?HttpClient.Response = null,
 
 _url: [:0]const u8 = "",
 _method: net_http.Method = .GET,
@@ -97,13 +97,13 @@ pub fn init(page: *Page) !*XMLHttpRequest {
 }
 
 pub fn deinit(self: *XMLHttpRequest, shutdown: bool, session: *Session) void {
-    if (self._transfer) |transfer| {
+    if (self._http_response) |transfer| {
         if (shutdown) {
             transfer.terminate();
         } else {
             transfer.abort(error.Abort);
         }
-        self._transfer = null;
+        self._http_response = null;
     }
 
     if (self._on_ready_state_change) |func| {
@@ -169,9 +169,9 @@ pub fn setWithCredentials(self: *XMLHttpRequest, value: bool) !void {
 // TODO: url should be a union, as it can be multiple things
 pub fn open(self: *XMLHttpRequest, method_: []const u8, url: [:0]const u8) !void {
     // Abort any in-progress request
-    if (self._transfer) |transfer| {
+    if (self._http_response) |transfer| {
         transfer.abort(error.Abort);
-        self._transfer = null;
+        self._http_response = null;
     }
 
     // Reset internal state
@@ -382,34 +382,32 @@ pub fn getResponseXML(self: *XMLHttpRequest, page: *Page) !?*Node.Document {
     };
 }
 
-fn httpStartCallback(transfer: *HttpClient.LiveTransfer) !void {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
+fn httpStartCallback(response: HttpClient.Response) !void {
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
     if (comptime IS_DEBUG) {
         log.debug(.http, "request start", .{ .method = self._method, .url = self._url, .source = "xhr" });
     }
-    self._transfer = transfer;
+    self._http_response = response;
 }
 
-fn httpHeaderCallback(transfer: *HttpClient.LiveTransfer, header: net_http.Header) !void {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
+fn httpHeaderCallback(response: HttpClient.Response, header: net_http.Header) !void {
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
     const joined = try std.fmt.allocPrint(self._arena, "{s}: {s}", .{ header.name, header.value });
     try self._response_headers.append(self._arena, joined);
 }
 
-fn httpHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
-
-    const header = &transfer.response_header.?;
+fn httpHeaderDoneCallback(response: HttpClient.Response) !bool {
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
 
     if (comptime IS_DEBUG) {
         log.debug(.http, "request header", .{
             .source = "xhr",
             .url = self._url,
-            .status = header.status,
+            .status = response.status(),
         });
     }
 
-    if (header.contentType()) |ct| {
+    if (response.contentType()) |ct| {
         self._response_mime = Mime.parse(ct) catch |e| {
             log.info(.http, "invalid content type", .{
                 .content_Type = ct,
@@ -420,18 +418,19 @@ fn httpHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
         };
     }
 
-    var it = transfer.responseHeaderIterator();
-    while (it.next()) |hdr| {
-        const joined = try std.fmt.allocPrint(self._arena, "{s}: {s}", .{ hdr.name, hdr.value });
-        try self._response_headers.append(self._arena, joined);
-    }
+    // TODO: Header Iterator
+    // var it = transfer.responseHeaderIterator();
+    // while (it.next()) |hdr| {
+    //     const joined = try std.fmt.allocPrint(self._arena, "{s}: {s}", .{ hdr.name, hdr.value });
+    //     try self._response_headers.append(self._arena, joined);
+    // }
 
-    self._response_status = header.status;
-    if (transfer.getContentLength()) |cl| {
+    self._response_status = response.status().?;
+    if (response.contentLength()) |cl| {
         self._response_len = cl;
         try self._response_data.ensureTotalCapacity(self._arena, cl);
     }
-    self._response_url = try self._arena.dupeZ(u8, std.mem.span(header.url));
+    self._response_url = try self._arena.dupeZ(u8, response.url());
 
     const page = self._page;
 
@@ -446,8 +445,8 @@ fn httpHeaderDoneCallback(transfer: *HttpClient.LiveTransfer) !bool {
     return true;
 }
 
-fn httpDataCallback(transfer: *HttpClient.LiveTransfer, data: []const u8) !void {
-    const self: *XMLHttpRequest = @ptrCast(@alignCast(transfer.ctx));
+fn httpDataCallback(response: HttpClient.Response, data: []const u8) !void {
+    const self: *XMLHttpRequest = @ptrCast(@alignCast(response.ctx));
     try self._response_data.appendSlice(self._arena, data);
 
     const page = self._page;
@@ -470,7 +469,7 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
 
     // Not that the request is done, the http/client will free the transfer
     // object. It isn't safe to keep it around.
-    self._transfer = null;
+    self._http_response = null;
 
     const page = self._page;
 
@@ -492,21 +491,21 @@ fn httpDoneCallback(ctx: *anyopaque) !void {
 fn httpErrorCallback(ctx: *anyopaque, err: anyerror) void {
     const self: *XMLHttpRequest = @ptrCast(@alignCast(ctx));
     // http client will close it after an error, it isn't safe to keep around
-    self._transfer = null;
+    self._http_response = null;
     self.handleError(err);
     self._page.js.weakRef(self);
 }
 
 fn httpShutdownCallback(ctx: *anyopaque) void {
     const self: *XMLHttpRequest = @ptrCast(@alignCast(ctx));
-    self._transfer = null;
+    self._http_response = null;
 }
 
 pub fn abort(self: *XMLHttpRequest) void {
     self.handleError(error.Abort);
-    if (self._transfer) |transfer| {
+    if (self._http_response) |transfer| {
         transfer.abort(error.Abort);
-        self._transfer = null;
+        self._http_response = null;
     }
     self._page.js.weakRef(self);
 }