prefer URL instead of std.Uri everywhere

2025-10-28 22:53:28 +00:00 · 2025-10-13 16:35:35 +03:00
parent cecdd47bbc
commit cf9ecbd9fd
9 changed files with 358 additions and 259 deletions
--- a/src/browser/html/document.zig
+++ b/src/browser/html/document.zig
@@ -85,7 +85,7 @@ pub const HTMLDocument = struct {

    pub fn get_cookie(_: *parser.DocumentHTML, page: *Page) ![]const u8 {
        var buf: std.ArrayListUnmanaged(u8) = .{};
-        try page.cookie_jar.forRequest(&page.url.uri, buf.writer(page.arena), .{
+        try page.cookie_jar.forRequest(page.url, buf.writer(page.arena), .{
            .is_http = false,
            .is_navigation = true,
        });
@@ -95,7 +95,7 @@ pub const HTMLDocument = struct {
    pub fn set_cookie(_: *parser.DocumentHTML, cookie_str: []const u8, page: *Page) ![]const u8 {
        // we use the cookie jar's allocator to parse the cookie because it
        // outlives the page's arena.
-        const c = try Cookie.parse(page.cookie_jar.allocator, &page.url.uri, cookie_str);
+        const c = try Cookie.parse(page.cookie_jar.allocator, page.url, cookie_str);
        errdefer c.deinit();
        if (c.http_only) {
            c.deinit();
--- a/src/browser/page.zig
+++ b/src/browser/page.zig
@@ -150,6 +150,7 @@ pub const Page = struct {
        try self.registerBackgroundTasks();
    }

+    // FIXME: Deinit self.url.
    pub fn deinit(self: *Page) void {
        self.script_manager.shutdown = true;

@@ -239,7 +240,7 @@ pub const Page = struct {

        const doc = parser.documentHTMLToDocument(self.window.document);

-        // if the base si requested, add the base's node in the document's headers.
+        // if the base is requested, add the base's node in the document's headers.
        if (opts.with_base) {
            try self.addDOMTreeBase();
        }
@@ -525,10 +526,11 @@ pub const Page = struct {
        is_http: bool = true,
        is_navigation: bool = false,
    };
+
    pub fn requestCookie(self: *const Page, opts: RequestCookieOpts) Http.Client.RequestCookie {
        return .{
-            .jar = self.cookie_jar,
-            .origin = &self.url.uri,
+            .cookie_jar = self.cookie_jar,
+            .origin_url = self.url,
            .is_http = opts.is_http,
            .is_navigation = opts.is_navigation,
        };
@@ -859,7 +861,7 @@ pub const Page = struct {
        self.window.setStorageShelf(
            try self.session.storage_shed.getOrPut(try self.origin(self.arena)),
        );
-        try self.window.replaceLocation(.{ .url = try self.url.toWebApi(self.arena) });
+        //try self.window.replaceLocation(.{ .url = try self.url.toWebApi(self.arena) });
    }

    pub const MouseEvent = struct {
--- a/src/browser/storage/cookie.zig
+++ b/src/browser/storage/cookie.zig
@@ -6,14 +6,7 @@ const ArenaAllocator = std.heap.ArenaAllocator;
 const log = @import("../../log.zig");
 const DateTime = @import("../../datetime.zig").DateTime;
 const public_suffix_list = @import("../../data/public_suffix_list.zig").lookup;
-
-pub const LookupOpts = struct {
-    request_time: ?i64 = null,
-    origin_uri: ?*const Uri = null,
-    is_http: bool,
-    is_navigation: bool = true,
-    prefix: ?[]const u8 = null,
-};
+const URL = @import("../../url.zig").URL;

 pub const Jar = struct {
    allocator: Allocator,
@@ -80,13 +73,21 @@ pub const Jar = struct {
        }
    }

-    pub fn forRequest(self: *Jar, target_uri: *const Uri, writer: anytype, opts: LookupOpts) !void {
+    pub const LookupOpts = struct {
+        request_time: ?i64 = null,
+        origin_url: ?URL = null,
+        is_http: bool,
+        is_navigation: bool = true,
+        prefix: ?[]const u8 = null,
+    };
+
+    pub fn forRequest(self: *Jar, target_url: URL, writer: anytype, opts: LookupOpts) !void {
        const target = PreparedUri{
-            .host = (target_uri.host orelse return error.InvalidURI).percent_encoded,
-            .path = target_uri.path.percent_encoded,
-            .secure = std.mem.eql(u8, target_uri.scheme, "https"),
+            .host = target_url.host(),
+            .path = target_url.getPath(),
+            .secure = target_url.isSecure(),
        };
-        const same_site = try areSameSite(opts.origin_uri, target.host);
+        const same_site = try areSameSite(opts.origin_url, target.host);

        removeExpired(self, opts.request_time);

@@ -109,8 +110,8 @@ pub const Jar = struct {
        }
    }

-    pub fn populateFromResponse(self: *Jar, uri: *const Uri, set_cookie: []const u8) !void {
-        const c = Cookie.parse(self.allocator, uri, set_cookie) catch |err| {
+    pub fn populateFromResponse(self: *Jar, url: URL, set_cookie: []const u8) !void {
+        const c = Cookie.parse(self.allocator, url, set_cookie) catch |err| {
            log.warn(.web_api, "cookie parse failed", .{ .raw = set_cookie, .err = err });
            return;
        };
@@ -148,9 +149,9 @@ fn areCookiesEqual(a: *const Cookie, b: *const Cookie) bool {
    return true;
 }

-fn areSameSite(origin_uri_: ?*const std.Uri, target_host: []const u8) !bool {
-    const origin_uri = origin_uri_ orelse return true;
-    const origin_host = (origin_uri.host orelse return error.InvalidURI).percent_encoded;
+fn areSameSite(maybe_origin_url: ?URL, target_host: []const u8) !bool {
+    const origin_url = maybe_origin_url orelse return true;
+    const origin_host = origin_url.host();

    // common case
    if (std.mem.eql(u8, target_host, origin_host)) {
@@ -161,6 +162,7 @@ fn areSameSite(origin_uri_: ?*const std.Uri, target_host: []const u8) !bool {
 }

 fn findSecondLevelDomain(host: []const u8) []const u8 {
+    // TODO: maybe reverseIterator?
    var i = std.mem.lastIndexOfScalar(u8, host, '.') orelse return host;
    while (true) {
        i = std.mem.lastIndexOfScalar(u8, host[0..i], '.') orelse return host;
@@ -269,8 +271,8 @@ pub const Cookie = struct {
        const aa = arena.allocator();
        const owned_name = try aa.dupe(u8, cookie_name);
        const owned_value = try aa.dupe(u8, cookie_value);
-        const owned_path = try parsePath(aa, uri, path);
-        const owned_domain = try parseDomain(aa, uri, domain);
+        const owned_path = try parsePath(aa, url, path);
+        const owned_domain = try parseDomain(aa, url, domain);

        var normalized_expires: ?f64 = null;
        if (max_age) |ma| {
@@ -362,37 +364,35 @@ pub const Cookie = struct {
        }
    }

-    pub fn parsePath(arena: Allocator, uri: ?*const std.Uri, explicit_path: ?[]const u8) ![]const u8 {
+    pub fn parsePath(arena: Allocator, maybe_url: ?URL, maybe_explicit_path: ?[]const u8) ![]const u8 {
        // path attribute value either begins with a '/' or we
        // ignore it and use the "default-path" algorithm
-        if (explicit_path) |path| {
+        if (maybe_explicit_path) |path| {
            if (path.len > 0 and path[0] == '/') {
-                return try arena.dupe(u8, path);
+                return arena.dupe(u8, path);
            }
        }

-        // default-path
-        const url_path = (uri orelse return "/").path;
+        const url_path = blk: {
+            if (maybe_url) |url| {
+                break :blk url.getPath();
+            }

-        const either = url_path.percent_encoded;
-        if (either.len == 0 or (either.len == 1 and either[0] == '/')) {
+            return "/";
+        };
+
+        if (url_path.len == 0 or (url_path.len == 1 and url_path[0] == '/')) {
            return "/";
        }

-        var owned_path: []const u8 = try percentEncode(arena, url_path, isPathChar);
-        const last = std.mem.lastIndexOfScalar(u8, owned_path[1..], '/') orelse {
-            return "/";
-        };
-        return try arena.dupe(u8, owned_path[0 .. last + 1]);
+        return arena.dupe(u8, url_path);
    }

-    pub fn parseDomain(arena: Allocator, uri: ?*const std.Uri, explicit_domain: ?[]const u8) ![]const u8 {
+    pub fn parseDomain(arena: Allocator, maybe_url: ?URL, explicit_domain: ?[]const u8) ![]const u8 {
        var encoded_host: ?[]const u8 = null;
-        if (uri) |uri_| {
-            const uri_host = uri_.host orelse return error.InvalidURI;
-            const host = try percentEncode(arena, uri_host, isHostChar);
-            _ = toLower(host);
-            encoded_host = host;
+        if (maybe_url) |url| {
+            const url_host = url.hostname();
+            encoded_host = url_host;
        }

        if (explicit_domain) |domain| {
@@ -421,19 +421,6 @@ pub const Cookie = struct {
        return encoded_host orelse return error.InvalidDomain; // default-domain
    }

-    pub fn percentEncode(arena: Allocator, component: std.Uri.Component, comptime isValidChar: fn (u8) bool) ![]u8 {
-        switch (component) {
-            .raw => |str| {
-                var aw = try std.Io.Writer.Allocating.initCapacity(arena, str.len);
-                try std.Uri.Component.percentEncode(&aw.writer, str, isValidChar);
-                return aw.written(); // @memory retains memory used before growing
-            },
-            .percent_encoded => |str| {
-                return try arena.dupe(u8, str);
-            },
-        }
-    }
-
    pub fn isHostChar(c: u8) bool {
        return switch (c) {
            'A'...'Z', 'a'...'z', '0'...'9', '-', '.', '_', '~' => true,
@@ -601,37 +588,40 @@ test "Jar: add" {
    defer jar.deinit();
    try expectCookies(&.{}, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "over=9000;Max-Age=0"), now);
+    const test_url = try URL.parse("http://lightpanda.io/", null);
+    defer test_url.deinit();
+
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "over=9000;Max-Age=0"), now);
    try expectCookies(&.{}, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "over=9000"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "over=9000"), now);
    try expectCookies(&.{.{ "over", "9000" }}, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "over=9000!!"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "over=9000!!"), now);
    try expectCookies(&.{.{ "over", "9000!!" }}, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "spice=flow"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "spice=flow"), now);
    try expectCookies(&.{ .{ "over", "9000!!" }, .{ "spice", "flow" } }, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "spice=flows;Path=/"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "spice=flows;Path=/"), now);
    try expectCookies(&.{ .{ "over", "9000!!" }, .{ "spice", "flows" } }, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "over=9001;Path=/other"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "over=9001;Path=/other"), now);
    try expectCookies(&.{ .{ "over", "9000!!" }, .{ "spice", "flows" }, .{ "over", "9001" } }, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "over=9002;Path=/;Domain=lightpanda.io"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "over=9002;Path=/;Domain=lightpanda.io"), now);
    try expectCookies(&.{ .{ "over", "9000!!" }, .{ "spice", "flows" }, .{ "over", "9001" }, .{ "over", "9002" } }, jar);

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "over=x;Path=/other;Max-Age=-200"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "over=x;Path=/other;Max-Age=-200"), now);
    try expectCookies(&.{ .{ "over", "9000!!" }, .{ "spice", "flows" }, .{ "over", "9002" } }, jar);
 }

 test "Jar: forRequest" {
    const expectCookies = struct {
-        fn expect(expected: []const u8, jar: *Jar, target_uri: Uri, opts: LookupOpts) !void {
+        fn expect(expected: []const u8, jar: *Jar, target_url: URL, opts: Jar.LookupOpts) !void {
            var arr: std.ArrayListUnmanaged(u8) = .empty;
            defer arr.deinit(testing.allocator);
-            try jar.forRequest(&target_uri, arr.writer(testing.allocator), opts);
+            try jar.forRequest(target_url, arr.writer(testing.allocator), opts);
            try testing.expectEqual(expected, arr.items);
        }
    }.expect;
@@ -641,131 +631,142 @@ test "Jar: forRequest" {
    var jar = Jar.init(testing.allocator);
    defer jar.deinit();

-    const test_uri_2 = Uri.parse("http://test.lightpanda.io/") catch unreachable;
+    const test_url = try URL.parse("http://lightpanda.io/", null);
+    defer test_url.deinit();
+
+    const test_url_2 = try URL.parse("http://test.lightpanda.io/", null);
+    defer test_url_2.deinit();

    {
        // test with no cookies
-        try expectCookies("", &jar, test_uri, .{ .is_http = true });
+        try expectCookies("", &jar, test_url, .{ .is_http = true });
    }

-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "global1=1"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "global2=2;Max-Age=30;domain=lightpanda.io"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "path1=3;Path=/about"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "path2=4;Path=/docs/"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "secure=5;Secure"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "sitenone=6;SameSite=None;Path=/x/;Secure"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "sitelax=7;SameSite=Lax;Path=/x/"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri, "sitestrict=8;SameSite=Strict;Path=/x/"), now);
-    try jar.add(try Cookie.parse(testing.allocator, &test_uri_2, "domain1=9;domain=test.lightpanda.io"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "global1=1"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "global2=2;Max-Age=30;domain=lightpanda.io"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "path1=3;Path=/about"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "path2=4;Path=/docs/"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "secure=5;Secure"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "sitenone=6;SameSite=None;Path=/x/;Secure"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "sitelax=7;SameSite=Lax;Path=/x/"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url, "sitestrict=8;SameSite=Strict;Path=/x/"), now);
+    try jar.add(try Cookie.parse(testing.allocator, test_url_2, "domain1=9;domain=test.lightpanda.io"), now);

    // nothing fancy here
-    try expectCookies("global1=1; global2=2", &jar, test_uri, .{ .is_http = true });
-    try expectCookies("global1=1; global2=2", &jar, test_uri, .{ .origin_uri = &test_uri, .is_navigation = false, .is_http = true });
+    try expectCookies("global1=1; global2=2", &jar, test_url, .{ .is_http = true });
+    try expectCookies("global1=1; global2=2", &jar, test_url, .{ .origin_url = test_url, .is_navigation = false, .is_http = true });
+
+    // We reuse this URL to reparse.
+    const reuse_url = try URL.parse("http://anothersitelightpanda.io/", null);
+    defer reuse_url.deinit();

    // We have a cookie where Domain=lightpanda.io
    // This should _not_ match xyxlightpanda.io
-    try expectCookies("", &jar, try std.Uri.parse("http://anothersitelightpanda.io/"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("", &jar, reuse_url, .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // matching path without trailing /
-    try expectCookies("global1=1; global2=2; path1=3", &jar, try std.Uri.parse("http://lightpanda.io/about"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2; path1=3", &jar, try reuse_url.reparse("http://lightpanda.io/about"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // incomplete prefix path
-    try expectCookies("global1=1; global2=2", &jar, try std.Uri.parse("http://lightpanda.io/abou"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2", &jar, try reuse_url.reparse("http://lightpanda.io/abou"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // path doesn't match
-    try expectCookies("global1=1; global2=2", &jar, try std.Uri.parse("http://lightpanda.io/aboutus"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2", &jar, try reuse_url.reparse("http://lightpanda.io/aboutus"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // path doesn't match cookie directory
-    try expectCookies("global1=1; global2=2", &jar, try std.Uri.parse("http://lightpanda.io/docs"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2", &jar, try reuse_url.reparse("http://lightpanda.io/docs"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // exact directory match
-    try expectCookies("global1=1; global2=2; path2=4", &jar, try std.Uri.parse("http://lightpanda.io/docs/"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2; path2=4", &jar, try reuse_url.reparse("http://lightpanda.io/docs/"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // sub directory match
-    try expectCookies("global1=1; global2=2; path2=4", &jar, try std.Uri.parse("http://lightpanda.io/docs/more"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2; path2=4", &jar, try reuse_url.reparse("http://lightpanda.io/docs/more"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // secure
-    try expectCookies("global1=1; global2=2; secure=5", &jar, try std.Uri.parse("https://lightpanda.io/"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global1=1; global2=2; secure=5", &jar, try reuse_url.reparse("https://lightpanda.io/"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // navigational cross domain, secure
-    try expectCookies("global1=1; global2=2; secure=5; sitenone=6; sitelax=7", &jar, try std.Uri.parse("https://lightpanda.io/x/"), .{
-        .origin_uri = &(try std.Uri.parse("https://example.com/")),
+    const example_com_url = try URL.parse("https://example.com/", null);
+    defer example_com_url.deinit();
+
+    try expectCookies("global1=1; global2=2; secure=5; sitenone=6; sitelax=7", &jar, try reuse_url.reparse("https://lightpanda.io/x/"), .{
+        .origin_url = example_com_url,
        .is_http = true,
    });

    // navigational cross domain, insecure
-    try expectCookies("global1=1; global2=2; sitelax=7", &jar, try std.Uri.parse("http://lightpanda.io/x/"), .{
-        .origin_uri = &(try std.Uri.parse("https://example.com/")),
+    try expectCookies("global1=1; global2=2; sitelax=7", &jar, try reuse_url.reparse("http://lightpanda.io/x/"), .{
+        .origin_url = example_com_url,
        .is_http = true,
    });

    // non-navigational cross domain, insecure
-    try expectCookies("", &jar, try std.Uri.parse("http://lightpanda.io/x/"), .{
-        .origin_uri = &(try std.Uri.parse("https://example.com/")),
+    try expectCookies("", &jar, try reuse_url.reparse("http://lightpanda.io/x/"), .{
+        .origin_url = example_com_url,
        .is_http = true,
        .is_navigation = false,
    });

    // non-navigational cross domain, secure
-    try expectCookies("sitenone=6", &jar, try std.Uri.parse("https://lightpanda.io/x/"), .{
-        .origin_uri = &(try std.Uri.parse("https://example.com/")),
+    try expectCookies("sitenone=6", &jar, try reuse_url.reparse("https://lightpanda.io/x/"), .{
+        .origin_url = example_com_url,
        .is_http = true,
        .is_navigation = false,
    });

    // non-navigational same origin
-    try expectCookies("global1=1; global2=2; sitelax=7; sitestrict=8", &jar, try std.Uri.parse("http://lightpanda.io/x/"), .{
-        .origin_uri = &(try std.Uri.parse("https://lightpanda.io/")),
+    try expectCookies("global1=1; global2=2; sitelax=7; sitestrict=8", &jar, try reuse_url.reparse("http://lightpanda.io/x/"), .{
+        .origin_url = test_url,
        .is_http = true,
        .is_navigation = false,
    });

    // exact domain match + suffix
-    try expectCookies("global2=2; domain1=9", &jar, try std.Uri.parse("http://test.lightpanda.io/"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global2=2; domain1=9", &jar, try reuse_url.reparse("http://test.lightpanda.io/"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // domain suffix match + suffix
-    try expectCookies("global2=2; domain1=9", &jar, try std.Uri.parse("http://1.test.lightpanda.io/"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global2=2; domain1=9", &jar, try reuse_url.reparse("http://1.test.lightpanda.io/"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    // non-matching domain
-    try expectCookies("global2=2", &jar, try std.Uri.parse("http://other.lightpanda.io/"), .{
-        .origin_uri = &test_uri,
+    try expectCookies("global2=2", &jar, try reuse_url.reparse("http://other.lightpanda.io/"), .{
+        .origin_url = test_url,
        .is_http = true,
    });

    const l = jar.cookies.items.len;
-    try expectCookies("global1=1", &jar, test_uri, .{
+    try expectCookies("global1=1", &jar, test_url, .{
        .request_time = now + 100,
-        .origin_uri = &test_uri,
+        .origin_url = test_url,
        .is_http = true,
    });
    try testing.expectEqual(l - 1, jar.cookies.items.len);
@@ -961,9 +962,11 @@ const ExpectedCookie = struct {
    same_site: Cookie.SameSite = .lax,
 };

-fn expectCookie(expected: ExpectedCookie, url: []const u8, set_cookie: []const u8) !void {
-    const uri = try Uri.parse(url);
-    var cookie = try Cookie.parse(testing.allocator, &uri, set_cookie);
+fn expectCookie(expected: ExpectedCookie, url_str: []const u8, set_cookie: []const u8) !void {
+    const url = try URL.parse(url_str, null);
+    defer url.deinit();
+
+    var cookie = try Cookie.parse(testing.allocator, url, set_cookie);
    defer cookie.deinit();

    try testing.expectEqual(expected.name, cookie.name);
@@ -977,9 +980,11 @@ fn expectCookie(expected: ExpectedCookie, url: []const u8, set_cookie: []const u
    try testing.expectDelta(expected.expires, cookie.expires, 2.0);
 }

-fn expectAttribute(expected: anytype, url: ?[]const u8, set_cookie: []const u8) !void {
-    const uri = if (url) |u| try Uri.parse(u) else test_uri;
-    var cookie = try Cookie.parse(testing.allocator, &uri, set_cookie);
+fn expectAttribute(expected: anytype, maybe_url_str: ?[]const u8, set_cookie: []const u8) !void {
+    const url = try URL.parse(if (maybe_url_str) |url_str| url_str else "https://lightpanda.io/", null);
+    defer url.deinit();
+
+    var cookie = try Cookie.parse(testing.allocator, url, set_cookie);
    defer cookie.deinit();

    inline for (@typeInfo(@TypeOf(expected)).@"struct".fields) |f| {
@@ -994,9 +999,7 @@ fn expectAttribute(expected: anytype, url: ?[]const u8, set_cookie: []const u8)
    }
 }

-fn expectError(expected: anyerror, url: ?[]const u8, set_cookie: []const u8) !void {
-    const uri = if (url) |u| try Uri.parse(u) else test_uri;
-    try testing.expectError(expected, Cookie.parse(testing.allocator, &uri, set_cookie));
+fn expectError(expected: anyerror, maybe_url_str: ?[]const u8, set_cookie: []const u8) !void {
+    const url = try URL.parse(if (maybe_url_str) |url_str| url_str else "https://lightpanda.io/", null);
+    try testing.expectError(expected, Cookie.parse(testing.allocator, url, set_cookie));
 }
-
-const test_uri = Uri.parse("http://lightpanda.io/") catch unreachable;
--- a/src/browser/url/url.zig
+++ b/src/browser/url/url.zig
@@ -84,20 +84,10 @@ pub const URL = struct {
            break :blk ada.parse(url_str);
        };

-        // Prepare search_params.
-        const params: URLSearchParams = blk: {
-            const search = ada.getSearch(internal);
-            if (search.data == null) {
-                break :blk .{};
-            }
-
-            break :blk try .initFromString(page.arena, search.data[0..search.length]);
+        return .{
+            .internal = internal,
+            .search_params = try prepareSearchParams(page.arena, internal),
        };
-
-        // We're doing this since we track search params separately.
-        ada.clearSearch(internal);
-
-        return .{ .internal = internal, .search_params = params };
    }

    pub fn destructor(self: *const URL) void {
@@ -105,8 +95,37 @@ pub const URL = struct {
        return ada.free(self.internal);
    }

-    pub fn initWithoutSearchParams(uri: std.Uri) URL {
-        return .{ .uri = uri, .search_params = .{} };
+    /// Initializes a `URL` from given `internal`.
+    /// Note that this copies the given `internal`; meaning 2 instances
+    /// of it has to be tracked separately.
+    pub fn constructFromInternal(arena: Allocator, internal: ada.URL) !URL {
+        const copy = ada.copy(internal);
+
+        return .{
+            .internal = copy,
+            .search_params = try prepareSearchParams(arena, copy),
+        };
+    }
+
+    /// Prepares a `URLSearchParams` from given `internal`.
+    /// Resets `search` of `internal`.
+    fn prepareSearchParams(arena: Allocator, internal: ada.URL) !URLSearchParams {
+        const search = ada.getSearch(internal);
+        // Empty.
+        if (search.data == null) return .{};
+
+        const slice = search.data[0..search.length];
+        const search_params = URLSearchParams.initFromString(arena, slice);
+        // After a call to this function, search params are tracked by
+        // `search_params`. So we reset the internal's search.
+        ada.clearSearch(internal);
+
+        return search_params;
+    }
+
+    // Alias to get_href.
+    pub fn _toString(self: *const URL, page: *Page) ![]const u8 {
+        return self.get_href(page);
    }
    pub fn _toString(self: *const URL) []const u8 {
        return ada.getHref(self.internal);
@@ -178,7 +197,13 @@ pub const URL = struct {
    }

    pub fn get_pathname(self: *const URL) []const u8 {
-        return ada.getPathname(self.internal);
+        const path = ada.getPathnameNullable(self.internal);
+        // Return a slash if path is null.
+        if (path.data == null) {
+            return "/";
+        }
+
+        return path.data[0..path.length];
    }

    // get_search depends on the current state of `search_params`.
--- a/src/cdp/domains/fetch.zig
+++ b/src/cdp/domains/fetch.zig
@@ -208,7 +208,7 @@ pub fn requestIntercept(arena: Allocator, bc: anytype, intercept: *const Notific
    log.debug(.cdp, "request intercept", .{
        .state = "paused",
        .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
    });
    // Await either continueRequest, failRequest or fulfillRequest

@@ -237,7 +237,7 @@ fn continueRequest(cmd: anytype) !void {
    log.debug(.cdp, "request intercept", .{
        .state = "continue",
        .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
        .new_url = params.url,
    });

@@ -342,7 +342,7 @@ fn fulfillRequest(cmd: anytype) !void {
    log.debug(.cdp, "request intercept", .{
        .state = "fulfilled",
        .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
        .status = params.responseCode,
        .body = params.body != null,
    });
@@ -376,7 +376,7 @@ fn failRequest(cmd: anytype) !void {
    log.info(.cdp, "request intercept", .{
        .state = "fail",
        .id = request_id,
-        .url = transfer.uri,
+        .url = transfer.url,
        .reason = params.errorReason,
    });
    return cmd.sendResult(null, .{});
@@ -420,7 +420,7 @@ pub fn requestAuthRequired(arena: Allocator, bc: anytype, intercept: *const Noti
    log.debug(.cdp, "request auth required", .{
        .state = "paused",
        .id = transfer.id,
-        .url = transfer.uri,
+        .url = transfer.url,
    });
    // Await continueWithAuth

--- a/src/cdp/domains/network.zig
+++ b/src/cdp/domains/network.zig
@@ -22,6 +22,7 @@ const Allocator = std.mem.Allocator;
 const CdpStorage = @import("storage.zig");
 const Transfer = @import("../../http/Client.zig").Transfer;
 const Notification = @import("../../notification.zig").Notification;
+const URL = @import("../../url.zig").URL;

 pub fn processMessage(cmd: anytype) !void {
    const action = std.meta.stringToEnum(enum {
@@ -117,15 +118,20 @@ fn deleteCookies(cmd: anytype) !void {
    const bc = cmd.browser_context orelse return error.BrowserContextNotLoaded;
    const cookies = &bc.session.cookie_jar.cookies;

-    const uri = if (params.url) |url| std.Uri.parse(url) catch return error.InvalidParams else null;
-    const uri_ptr = if (uri) |u| &u else null;
+    const maybe_url: ?URL = blk: {
+        if (params.url) |url| {
+            break :blk URL.parse(url, null) catch return error.InvalidParams;
+        }
+
+        break :blk null;
+    };

    var index = cookies.items.len;
    while (index > 0) {
        index -= 1;
        const cookie = &cookies.items[index];
-        const domain = try Cookie.parseDomain(cmd.arena, uri_ptr, params.domain);
-        const path = try Cookie.parsePath(cmd.arena, uri_ptr, params.path);
+        const domain = try Cookie.parseDomain(cmd.arena, maybe_url, params.domain);
+        const path = try Cookie.parsePath(cmd.arena, maybe_url, params.path);

        // We do not want to use Cookie.appliesTo here. As a Cookie with a shorter path would match.
        // Similar to deduplicating with areCookiesEqual, except domain and path are optional.
@@ -133,6 +139,12 @@ fn deleteCookies(cmd: anytype) !void {
            cookies.swapRemove(index).deinit();
        }
    }
+
+    // Deinit URL if we had.
+    if (maybe_url) |url| {
+        url.deinit();
+    }
+
    return cmd.sendResult(null, .{});
 }

@@ -177,13 +189,14 @@ fn getCookies(cmd: anytype) !void {
    const param_urls = params.urls orelse &[_][]const u8{page_url orelse return error.InvalidParams};

    var urls = try std.ArrayListUnmanaged(CdpStorage.PreparedUri).initCapacity(cmd.arena, param_urls.len);
-    for (param_urls) |url| {
-        const uri = std.Uri.parse(url) catch return error.InvalidParams;
+    for (param_urls) |url_str| {
+        const url = URL.parse(url_str, null) catch return error.InvalidParams;
+        defer url.deinit();

        urls.appendAssumeCapacity(.{
-            .host = try Cookie.parseDomain(cmd.arena, &uri, null),
-            .path = try Cookie.parsePath(cmd.arena, &uri, null),
-            .secure = std.mem.eql(u8, uri.scheme, "https"),
+            .host = try Cookie.parseDomain(cmd.arena, url, null),
+            .path = try Cookie.parsePath(cmd.arena, url, null),
+            .secure = url.isSecure(),
        });
    }

@@ -247,7 +260,7 @@ pub fn httpRequestStart(arena: Allocator, bc: anytype, msg: *const Notification.
        .requestId = try std.fmt.allocPrint(arena, "REQ-{d}", .{transfer.id}),
        .frameId = target_id,
        .loaderId = bc.loader_id,
-        .documentUrl = DocumentUrlWriter.init(&page.url.uri),
+        .documentUrl = DocumentUrlWriter.init(page.url),
        .request = TransferAsRequestWriter.init(transfer),
        .initiator = .{ .type = "other" },
    }, .{ .session_id = session_id });
@@ -300,23 +313,17 @@ pub const TransferAsRequestWriter = struct {
            try jws.objectField("url");
            try jws.beginWriteRaw();
            try writer.writeByte('\"');
-            try transfer.uri.writeToStream(writer, .{
-                .scheme = true,
-                .authentication = true,
-                .authority = true,
-                .path = true,
-                .query = true,
-            });
+            try transfer.url.writeToStream(writer);
            try writer.writeByte('\"');
            jws.endWriteRaw();
        }

        {
-            if (transfer.uri.fragment) |frag| {
+            if (transfer.url.getFragment()) |frag| {
                try jws.objectField("urlFragment");
                try jws.beginWriteRaw();
                try writer.writeAll("\"#");
-                try writer.writeAll(frag.percent_encoded);
+                try writer.writeAll(frag);
                try writer.writeByte('\"');
                jws.endWriteRaw();
            }
@@ -370,13 +377,7 @@ const TransferAsResponseWriter = struct {
            try jws.objectField("url");
            try jws.beginWriteRaw();
            try writer.writeByte('\"');
-            try transfer.uri.writeToStream(writer, .{
-                .scheme = true,
-                .authentication = true,
-                .authority = true,
-                .path = true,
-                .query = true,
-            });
+            try transfer.url.writeToStream(writer);
            try writer.writeByte('\"');
            jws.endWriteRaw();
        }
@@ -417,29 +418,22 @@ const TransferAsResponseWriter = struct {
 };

 const DocumentUrlWriter = struct {
-    uri: *std.Uri,
+    url: URL,

-    fn init(uri: *std.Uri) DocumentUrlWriter {
-        return .{
-            .uri = uri,
-        };
+    fn init(url: URL) DocumentUrlWriter {
+        return .{ .url = url };
    }

    pub fn jsonStringify(self: *const DocumentUrlWriter, jws: anytype) !void {
        self._jsonStringify(jws) catch return error.WriteFailed;
    }
+
    fn _jsonStringify(self: *const DocumentUrlWriter, jws: anytype) !void {
        const writer = jws.writer;

        try jws.beginWriteRaw();
        try writer.writeByte('\"');
-        try self.uri.writeToStream(writer, .{
-            .scheme = true,
-            .authentication = true,
-            .authority = true,
-            .path = true,
-            .query = true,
-        });
+        try self.url.writeToStream(writer);
        try writer.writeByte('\"');
        jws.endWriteRaw();
    }
--- a/src/cdp/domains/storage.zig
+++ b/src/cdp/domains/storage.zig
@@ -21,6 +21,7 @@ const std = @import("std");
 const log = @import("../../log.zig");
 const Cookie = @import("../../browser/storage/storage.zig").Cookie;
 const CookieJar = @import("../../browser/storage/storage.zig").CookieJar;
+const URL = @import("../../url.zig").URL;
 pub const PreparedUri = @import("../../browser/storage/cookie.zig").PreparedUri;

 pub fn processMessage(cmd: anytype) !void {
@@ -136,12 +137,25 @@ pub fn setCdpCookie(cookie_jar: *CookieJar, param: CdpCookie) !void {
    const a = arena.allocator();

    // NOTE: The param.url can affect the default domain, (NOT path), secure, source port, and source scheme.
-    const uri = if (param.url) |url| std.Uri.parse(url) catch return error.InvalidParams else null;
-    const uri_ptr = if (uri) |*u| u else null;
-    const domain = try Cookie.parseDomain(a, uri_ptr, param.domain);
+    const maybe_url: ?URL = blk: {
+        if (param.url) |url| {
+            break :blk URL.parse(url, null) catch return error.InvalidParams;
+        }
+
+        break :blk null;
+    };
+
+    const domain = try Cookie.parseDomain(a, maybe_url, param.domain);
    const path = if (param.path == null) "/" else try Cookie.parsePath(a, null, param.path);

-    const secure = if (param.secure) |s| s else if (uri) |uri_| std.mem.eql(u8, uri_.scheme, "https") else false;
+    const secure: bool = blk: {
+        // Check if params indicate security.
+        if (param.secure) |s| break :blk s;
+        // Check if protocol is secure.
+        if (maybe_url) |url| break :blk url.isSecure();
+        // If all fails, insecure.
+        break :blk false;
+    };

    const cookie = Cookie{
        .arena = arena,
@@ -158,6 +172,12 @@ pub fn setCdpCookie(cookie_jar: *CookieJar, param: CdpCookie) !void {
            .None => .none,
        },
    };
+
+    // Free if we had.
+    if (maybe_url) |url| {
+        url.deinit();
+    }
+
    try cookie_jar.add(cookie, std.time.timestamp());
 }

--- a/src/http/Client.zig
+++ b/src/http/Client.zig
@@ -22,9 +22,9 @@ const builtin = @import("builtin");

 const Http = @import("Http.zig");
 const Notification = @import("../notification.zig").Notification;
-const CookieJar = @import("../browser/storage/storage.zig").CookieJar;
-
-const urlStitch = @import("../url.zig").stitch;
+const CookieJar = @import("../browser/storage/cookie.zig").Jar;
+const URL = @import("../url.zig").URL;
+const urlStitch = URL.stitch;

 const c = Http.c;
 const posix = std.posix;
@@ -259,7 +259,7 @@ fn makeTransfer(self: *Client, req: Request) !*Transfer {
    errdefer req.headers.deinit();

    // we need this for cookies
-    const uri = std.Uri.parse(req.url) catch |err| {
+    const url = URL.parse(req.url, null) catch |err| {
        log.warn(.http, "invalid url", .{ .err = err, .url = req.url });
        return err;
    };
@@ -272,7 +272,7 @@ fn makeTransfer(self: *Client, req: Request) !*Transfer {
    transfer.* = .{
        .arena = ArenaAllocator.init(self.allocator),
        .id = id,
-        .uri = uri,
+        .url = url,
        .req = req,
        .ctx = req.ctx,
        .client = self,
@@ -595,20 +595,20 @@ pub const Handle = struct {
 pub const RequestCookie = struct {
    is_http: bool,
    is_navigation: bool,
-    origin: *const std.Uri,
-    jar: *@import("../browser/storage/cookie.zig").Jar,
+    origin_url: URL,
+    cookie_jar: *CookieJar,

-    pub fn headersForRequest(self: *const RequestCookie, temp: Allocator, url: [:0]const u8, headers: *Http.Headers) !void {
-        const uri = std.Uri.parse(url) catch |err| {
-            log.warn(.http, "invalid url", .{ .err = err, .url = url });
+    pub fn headersForRequest(self: *const RequestCookie, temp: Allocator, url_str: [:0]const u8, headers: *Http.Headers) !void {
+        const url = URL.parse(url_str, null) catch |err| {
+            log.warn(.http, "invalid url", .{ .err = err, .url = url_str });
            return error.InvalidUrl;
        };

        var arr: std.ArrayListUnmanaged(u8) = .{};
-        try self.jar.forRequest(&uri, arr.writer(temp), .{
+        try self.cookie_jar.forRequest(url, arr.writer(temp), .{
            .is_http = self.is_http,
            .is_navigation = self.is_navigation,
-            .origin_uri = self.origin,
+            .origin_url = self.origin_url,
        });

        if (arr.items.len > 0) {
@@ -688,7 +688,7 @@ pub const Transfer = struct {
    arena: ArenaAllocator,
    id: usize = 0,
    req: Request,
-    uri: std.Uri, // used for setting/getting the cookie
+    url: URL, // used for setting/getting the cookie
    ctx: *anyopaque, // copied from req.ctx to make it easier for callback handlers
    client: *Client,
    // total bytes received in the response, including the response status line,
@@ -774,7 +774,7 @@ pub const Transfer = struct {

    pub fn updateURL(self: *Transfer, url: [:0]const u8) !void {
        // for cookies
-        self.uri = try std.Uri.parse(url);
+        self.url = try self.url.reparse(url);

        // for the request itself
        self.req.url = url;
@@ -833,7 +833,7 @@ pub const Transfer = struct {
        while (true) {
            const ct = getResponseHeader(easy, "set-cookie", i);
            if (ct == null) break;
-            try req.cookie_jar.populateFromResponse(&transfer.uri, ct.?.value);
+            try req.cookie_jar.populateFromResponse(transfer.url, ct.?.value);
            i += 1;
            if (i >= ct.?.amount) break;
        }
@@ -847,14 +847,16 @@ pub const Transfer = struct {
        var baseurl: [*c]u8 = undefined;
        try errorCheck(c.curl_easy_getinfo(easy, c.CURLINFO_EFFECTIVE_URL, &baseurl));

-        const url = try urlStitch(arena, hlocation.?.value, std.mem.span(baseurl), .{});
-        const uri = try std.Uri.parse(url);
-        transfer.uri = uri;
+        const stitched = try urlStitch(arena, hlocation.?.value, std.mem.span(baseurl), .{});
+        // Since we're being redirected, we know url is valid.
+        // An assertation won't hurt, though.
+        std.debug.assert(transfer.url.isValid());
+        _ = try transfer.url.reparse(stitched);

        var cookies: std.ArrayListUnmanaged(u8) = .{};
-        try req.cookie_jar.forRequest(&uri, cookies.writer(arena), .{
+        try req.cookie_jar.forRequest(transfer.url, cookies.writer(arena), .{
            .is_http = true,
-            .origin_uri = &transfer.uri,
+            .origin_url = transfer.url,
            // used to enforce samesite cookie rules
            .is_navigation = req.resource_type == .document,
        });
@@ -883,7 +885,7 @@ pub const Transfer = struct {
        while (true) {
            const ct = getResponseHeader(easy, "set-cookie", i);
            if (ct == null) break;
-            transfer.req.cookie_jar.populateFromResponse(&transfer.uri, ct.?.value) catch |err| {
+            transfer.req.cookie_jar.populateFromResponse(transfer.url, ct.?.value) catch |err| {
                log.err(.http, "set cookie", .{ .err = err, .req = transfer });
                return err;
            };
--- a/src/url.zig
+++ b/src/url.zig
@@ -1,82 +1,135 @@
 const std = @import("std");

-const Uri = std.Uri;
 const Allocator = std.mem.Allocator;
 const WebApiURL = @import("browser/url/url.zig").URL;

+const ada = @import("ada");
+
 pub const stitch = URL.stitch;

 pub const URL = struct {
-    uri: Uri,
+    internal: ada.URL,
+    /// This must outlive the URL structure.
    raw: []const u8,

-    pub const empty = URL{ .uri = .{ .scheme = "" }, .raw = "" };
-    pub const about_blank = URL{ .uri = .{ .scheme = "" }, .raw = "about:blank" };
+    pub const empty = URL{ .internal = null, .raw = "" };
+    pub const invalid = URL{ .internal = null, .raw = "" };
+    pub const blank = parse("about:blank", null) catch unreachable;

-    // We assume str will last as long as the URL
-    // In some cases, this is safe to do, because we know the URL is short lived.
-    // In most cases though, we assume the caller will just dupe the string URL
-    // into an arena
-    pub fn parse(str: []const u8, default_scheme: ?[]const u8) !URL {
-        var uri = Uri.parse(str) catch try Uri.parseAfterScheme(default_scheme orelse "https", str);
+    pub const ParseError = ada.ParseError;

-        // special case, url scheme is about, like about:blank.
-        // Use an empty string as host.
-        if (std.mem.eql(u8, uri.scheme, "about")) {
-            uri.host = .{ .percent_encoded = "" };
-        }
-
-        if (uri.host == null) {
-            return error.MissingHost;
-        }
-
-        std.debug.assert(uri.host.? == .percent_encoded);
-
-        return .{
-            .uri = uri,
-            .raw = str,
+    /// We assume str will last as long as the URL
+    /// In some cases, this is safe to do, because we know the URL is short lived.
+    /// In most cases though, we assume the caller will just dupe the string URL
+    /// into an arena.
+    /// If `str` does not contain a scheme, `fallback_scheme` be used instead.
+    /// `fallback_scheme` is `https` if not provided.
+    pub fn parse(str: []const u8, fallback_scheme: ?[]const u8) ParseError!URL {
+        // Try parsing directly; if it fails, we might have to provide a base.
+        const internal = ada.parse(str) catch blk: {
+            break :blk try ada.parseWithBase(fallback_scheme orelse "https", str);
        };
+
+        return .{ .internal = internal, .raw = str };
    }

-    pub fn fromURI(arena: Allocator, uri: *const Uri) !URL {
-        // This is embarrassing.
-        var buf: std.ArrayListUnmanaged(u8) = .{};
-        try uri.writeToStream(.{
-            .scheme = true,
-            .authentication = true,
-            .authority = true,
-            .path = true,
-            .query = true,
-            .fragment = true,
-        }, buf.writer(arena));
+    /// Uses the same URL to parse in-place.
+    /// Assumes `internal` is valid.
+    pub fn reparse(self: URL, str: []const u8) ParseError!URL {
+        std.debug.assert(self.internal != null);

-        return parse(buf.items, null);
+        _ = ada.setHref(self.internal, str);
+        if (!ada.isValid(self.internal)) {
+            return error.Invalid;
+        }
+        //self.raw = str;
+
+        return self;
    }

-    // Above, in `parse`, we error if a host doesn't exist
-    // In other words, we can't have a URL with a null host.
-    pub fn host(self: *const URL) []const u8 {
-        return self.uri.host.?.percent_encoded;
+    /// Deinitializes internal url.
+    pub fn deinit(self: URL) void {
+        std.debug.assert(self.internal != null);
+        ada.free(self.internal);
    }

-    pub fn port(self: *const URL) ?u16 {
-        return self.uri.port;
+    /// Returns true if `internal` is initialized.
+    pub fn isValid(self: URL) bool {
+        return ada.isValid(self.internal);
    }

-    pub fn scheme(self: *const URL) []const u8 {
-        return self.uri.scheme;
+    /// Above, in `parse`, we error if a host doesn't exist
+    /// In other words, we can't have a URL with a null host.
+    pub fn host(self: URL) []const u8 {
+        const str = ada.getHostNullable(self.internal);
+        return str.data[0..str.length];
    }

-    pub fn origin(self: *const URL, writer: *std.Io.Writer) !void {
-        return self.uri.writeToStream(writer, .{ .scheme = true, .authority = true });
+    pub fn href(self: URL) []const u8 {
+        return ada.getHref(self.internal);
    }

-    pub fn format(self: *const URL, writer: *std.Io.Writer) !void {
+    pub fn hostname(self: URL) []const u8 {
+        return ada.getHostname(self.internal);
+    }
+
+    pub fn getFragment(self: URL) ?[]const u8 {
+        // Ada calls it "hash" instead of "fragment".
+        const hash = ada.getHashNullable(self.internal);
+        if (hash.data == null) return null;
+
+        return hash.data[0..hash.length];
+    }
+
+    pub fn getProtocol(self: URL) []const u8 {
+        return ada.getProtocol(self.internal);
+    }
+
+    pub fn getScheme(self: URL) []const u8 {
+        const proto = self.getProtocol();
+        std.debug.assert(proto[proto.len - 1] == ':');
+
+        return proto.ptr[0 .. proto.len - 1];
+    }
+
+    /// Returns the path.
+    pub fn getPath(self: URL) []const u8 {
+        const pathname = ada.getPathnameNullable(self.internal);
+        // Return a slash if path is null.
+        if (pathname.data == null) {
+            return "/";
+        }
+
+        return pathname.data[0..pathname.length];
+    }
+
+    /// Returns true if the URL's protocol is secure.
+    pub fn isSecure(self: URL) bool {
+        const scheme = ada.getSchemeType(self.internal);
+        return scheme == ada.Scheme.https or scheme == ada.Scheme.wss;
+    }
+
+    pub fn writeToStream(self: URL, writer: anytype) !void {
+        return writer.writeAll(self.href());
+    }
+
+    // TODO: Skip unnecessary allocation by writing url parts directly to stream.
+    pub fn origin(self: URL, writer: *std.Io.Writer) !void {
+        // Ada manages its own memory for origin.
+        // Here we write it to stream and free it afterwards.
+        const proto = ada.getOrigin(self.internal);
+        defer ada.freeOwnedString(.{ .data = proto.ptr, .length = proto.len });
+
+        return writer.writeAll(proto);
+    }
+
+    pub fn format(self: URL, writer: *std.Io.Writer) !void {
        return writer.writeAll(self.raw);
    }

-    pub fn toWebApi(self: *const URL, allocator: Allocator) !WebApiURL {
-        return WebApiURL.init(allocator, self.uri);
+    /// Converts `URL` to `WebApiURL`.
+    pub fn toWebApi(self: URL, allocator: Allocator) !WebApiURL {
+        return WebApiURL.constructFromInternal(allocator, self.internal);
    }

    /// Properly stitches two URL fragments together.