TCP & TLS Socket API (#1374)

* TCP Socket API

* Wip

* Add snippet for StringDecoder

* Rename `close` to `stop`, replace `close` with `end`

* Add a tcp echo server test

* Some docs

* Update README.md

* Fix build

* Update README.md

Co-authored-by: Jarred Sumner <709451+Jarred-Sumner@users.noreply.github.com>

15 files changed, 3733 insertions, 8 deletions

diff --git a/src/bun.js/api/bun.zig b/src/bun.js/api/bun.zig
index ca84bbad0..a343730f8 100644
--- a/src/bun.js/api/bun.zig
+++ b/src/bun.js/api/bun.zig
@@ -1201,6 +1201,14 @@ pub const Class = NewClass(
         .spawnSync = .{
             .rfn = JSC.wrapWithHasContainer(JSC.Subprocess, "spawnSync", false, false, false),
         },
+
+        .listen = .{
+            .rfn = JSC.wrapWithHasContainer(JSC.API.Listener, "listen", false, false, false),
+        },
+
+        .connect = .{
+            .rfn = JSC.wrapWithHasContainer(JSC.API.Listener, "connect", false, false, false),
+        },
     },
     .{
         .main = .{
diff --git a/src/bun.js/api/bun/socket.zig b/src/bun.js/api/bun/socket.zig
new file mode 100644
index 000000000..8a4eca03b
--- /dev/null
+++ b/src/bun.js/api/bun/socket.zig
@@ -0,0 +1,1438 @@
+const default_allocator = @import("../../../global.zig").default_allocator;
+const bun = @import("../../../global.zig");
+const Environment = bun.Environment;
+const NetworkThread = @import("http").NetworkThread;
+const Global = bun.Global;
+const strings = bun.strings;
+const string = bun.string;
+const Output = @import("../../../global.zig").Output;
+const MutableString = @import("../../../global.zig").MutableString;
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+const JSC = @import("javascript_core");
+const JSValue = JSC.JSValue;
+const JSGlobalObject = JSC.JSGlobalObject;
+const Which = @import("../../../which.zig");
+const uws = @import("uws");
+const ZigString = JSC.ZigString;
+// const Corker = struct {
+//     ptr: ?*[16384]u8 = null,
+//     holder: ?*anyopaque = null,
+//     list: bun.ByteList = .{},
+
+//     pub fn write(this: *Corker, owner: *anyopaque, bytes: []const u8) usize {
+//         if (this.holder != null and this.holder.? != owner) {
+//             return 0;
+//         }
+
+//         this.holder = owner;
+//         if (this.ptr == null) {
+//             this.ptr = bun.default_allocator.alloc(u8, 16384) catch @panic("Out of memory allocating corker");
+//             std.debug.assert(this.list.cap == 0);
+//             std.debug.assert(this.list.len == 0);
+//             this.list.cap = 16384;
+//             this.list.ptr = this.ptr.?;
+//             this.list.len = 0;
+//         }
+//     }
+
+//     pub fn flushIfNecessary(this: *Corker, comptime ssl: bool, socket: uws.NewSocketHandler(ssl), owner: *anyopaque) void {
+//         if (this.holder == null or this.holder.? != owner) {
+//             return;
+//         }
+
+//         if (this.ptr == null) {
+//             return;
+//         }
+
+//         if (this.list.len == 0) {
+//             return;
+//         }
+
+//         const bytes = ths.list.slice();
+
+//         this.list.len = 0;
+//     }
+// };
+
+const Handlers = struct {
+    onOpen: JSC.JSValue = .zero,
+    onClose: JSC.JSValue = .zero,
+    onData: JSC.JSValue = .zero,
+    onWritable: JSC.JSValue = .zero,
+    onTimeout: JSC.JSValue = .zero,
+    onConnectError: JSC.JSValue = .zero,
+    onEnd: JSC.JSValue = .zero,
+    onError: JSC.JSValue = .zero,
+
+    encoding: JSC.Node.Encoding = .utf8,
+
+    vm: *JSC.VirtualMachine,
+    globalObject: *JSC.JSGlobalObject,
+    active_connections: u32 = 0,
+    is_server: bool = false,
+    promise: JSC.Strong = .{},
+
+    // corker: Corker = .{},
+
+    pub fn resolvePromise(this: *Handlers, value: JSValue) void {
+        var promise = this.promise.get() orelse return;
+        this.promise.deinit();
+        promise.asPromise().?.resolve(this.globalObject, value);
+    }
+
+    pub fn rejectPromise(this: *Handlers, value: JSValue) bool {
+        var promise = this.promise.get() orelse return false;
+        this.promise.deinit();
+        promise.asPromise().?.reject(this.globalObject, value);
+        return true;
+    }
+
+    pub fn markInactive(this: *Handlers, ssl: bool, ctx: *uws.SocketContext) void {
+        this.active_connections -= 1;
+        if (this.active_connections == 0 and this.is_server) {
+            var listen_socket: *Listener = @fieldParentPtr(Listener, "handlers", this);
+            // allow it to be GC'd once the last connection is closed and it's not listening anymore
+            if (listen_socket.listener == null) {
+                listen_socket.strong_self.clear();
+            }
+        } else if (this.active_connections == 0 and !this.is_server) {
+            this.unprotect();
+            ctx.deinit(ssl);
+            bun.default_allocator.destroy(this);
+        }
+    }
+
+    pub fn callErrorHandler(this: *Handlers, thisValue: JSValue, err: []const JSValue) bool {
+        const onError = this.onError;
+        if (onError == .zero) {
+            return false;
+        }
+
+        const result = onError.callWithThis(this.globalObject, thisValue, err);
+        if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(this.globalObject)) {
+            this.vm.runErrorHandler(result, null);
+        }
+
+        return true;
+    }
+
+    pub fn fromJS(globalObject: *JSC.JSGlobalObject, opts: JSC.JSValue, exception: JSC.C.ExceptionRef) ?Handlers {
+        var handlers = Handlers{
+            .vm = globalObject.bunVM(),
+            .globalObject = globalObject,
+        };
+
+        if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
+            exception.* = JSC.toInvalidArguments("Expected socket object", .{}, globalObject).asObjectRef();
+            return null;
+        }
+
+        const pairs = .{
+            .{ "onData", "data" },
+            .{ "onWritable", "drain" },
+            .{ "onOpen", "open" },
+            .{ "onClose", "close" },
+            .{ "onData", "data" },
+            .{ "onTimeout", "timeout" },
+            .{ "onConnectError", "connectError" },
+            .{ "onEnd", "end" },
+            .{ "onError", "error" },
+        };
+        inline for (pairs) |pair| {
+            if (opts.getTruthy(globalObject, pair.@"1")) |callback_value| {
+                if (!callback_value.isCell() or !callback_value.isCallable(globalObject.vm())) {
+                    exception.* = JSC.toInvalidArguments(comptime std.fmt.comptimePrint("Expected \"{s}\" callback to be a function", .{pair.@"1"}), .{}, globalObject).asObjectRef();
+                    return null;
+                }
+
+                @field(handlers, pair.@"0") = callback_value;
+            }
+        }
+
+        if (handlers.onData == .zero and handlers.onWritable == .zero) {
+            exception.* = JSC.toInvalidArguments("Expected at least \"data\" or \"drain\" callback", .{}, globalObject).asObjectRef();
+            return null;
+        }
+
+        return handlers;
+    }
+
+    pub fn unprotect(this: *Handlers) void {
+        this.onOpen.unprotect();
+        this.onClose.unprotect();
+        this.onData.unprotect();
+        this.onWritable.unprotect();
+        this.onTimeout.unprotect();
+        this.onConnectError.unprotect();
+        this.onEnd.unprotect();
+        this.onError.unprotect();
+    }
+
+    pub fn protect(this: *Handlers) void {
+        this.onOpen.protect();
+        this.onClose.protect();
+        this.onData.protect();
+        this.onWritable.protect();
+        this.onTimeout.protect();
+        this.onConnectError.protect();
+        this.onEnd.protect();
+        this.onError.protect();
+    }
+};
+
+pub const SocketConfig = struct {
+    hostname_or_unix: JSC.ZigString.Slice,
+    port: ?u16 = null,
+    ssl: ?JSC.API.ServerConfig.SSLConfig = null,
+    handlers: Handlers,
+    default_data: JSC.JSValue = .zero,
+
+    pub fn fromJS(
+        opts: JSC.JSValue,
+        globalObject: *JSC.JSGlobalObject,
+        exception: JSC.C.ExceptionRef,
+    ) ?SocketConfig {
+        var hostname_or_unix: JSC.ZigString.Slice = JSC.ZigString.Slice.empty;
+        var port: ?u16 = null;
+
+        var ssl: ?JSC.API.ServerConfig.SSLConfig = null;
+        var default_data = JSValue.zero;
+
+        if (JSC.API.ServerConfig.SSLConfig.inJS(globalObject, opts, exception)) |ssl_config| {
+            ssl = ssl_config;
+        } else if (exception.* != null) {
+            return null;
+        }
+
+        if (opts.getTruthy(globalObject, "hostname") orelse opts.getTruthy(globalObject, "host")) |hostname| {
+            if (hostname.isEmptyOrUndefinedOrNull() or !hostname.isString()) {
+                exception.* = JSC.toInvalidArguments("Expected \"hostname\" to be a string", .{}, globalObject).asObjectRef();
+                return null;
+            }
+
+            const port_value = opts.get(globalObject, "port") orelse JSValue.zero;
+            if (port_value.isEmptyOrUndefinedOrNull() or !port_value.isNumber() or port_value.toInt64() > std.math.maxInt(u16) or port_value.toInt64() < 0) {
+                exception.* = JSC.toInvalidArguments("Expected \"port\" to be a number between 0 and 65432", .{}, globalObject).asObjectRef();
+                return null;
+            }
+
+            hostname_or_unix = hostname.getZigString(globalObject).toSlice(bun.default_allocator);
+            port = port_value.toU16();
+
+            if (hostname_or_unix.len == 0) {
+                exception.* = JSC.toInvalidArguments("Expected \"hostname\" to be a non-empty string", .{}, globalObject).asObjectRef();
+                return null;
+            }
+        } else if (opts.getTruthy(globalObject, "unix")) |unix_socket| {
+            if (unix_socket.isEmptyOrUndefinedOrNull() or !unix_socket.isString()) {
+                exception.* = JSC.toInvalidArguments("Expected \"unix\" to be a string", .{}, globalObject).asObjectRef();
+                return null;
+            }
+
+            hostname_or_unix = unix_socket.getZigString(globalObject).toSlice(bun.default_allocator);
+
+            if (hostname_or_unix.len == 0) {
+                exception.* = JSC.toInvalidArguments("Expected \"unix\" to be a non-empty string", .{}, globalObject).asObjectRef();
+                return null;
+            }
+        } else {
+            exception.* = JSC.toInvalidArguments("Expected either \"hostname\" or \"unix\"", .{}, globalObject).asObjectRef();
+            return null;
+        }
+
+        const handlers = Handlers.fromJS(globalObject, opts.get(globalObject, "socket") orelse JSValue.zero, exception) orelse {
+            hostname_or_unix.deinit();
+            return null;
+        };
+
+        if (opts.getTruthy(globalObject, "data")) |default_data_value| {
+            default_data = default_data_value;
+        }
+
+        return SocketConfig{
+            .hostname_or_unix = hostname_or_unix,
+            .port = port,
+            .ssl = ssl,
+            .handlers = handlers,
+            .default_data = default_data,
+        };
+    }
+};
+
+pub const Listener = struct {
+    const log = Output.scoped(.Listener, false);
+
+    handlers: Handlers,
+    listener: ?*uws.ListenSocket = null,
+    poll_ref: JSC.PollRef = JSC.PollRef.init(),
+    connection: UnixOrHost,
+    socket_context: ?*uws.SocketContext = null,
+    ssl: bool = false,
+
+    strong_data: JSC.Strong = .{},
+    strong_self: JSC.Strong = .{},
+
+    pub usingnamespace JSC.Codegen.JSListener;
+
+    pub fn getData(
+        this: *Listener,
+        _: *JSC.JSGlobalObject,
+    ) callconv(.C) JSValue {
+        log("getData()", .{});
+        return this.strong_data.get() orelse JSValue.jsUndefined();
+    }
+
+    pub fn setData(
+        this: *Listener,
+        globalObject: *JSC.JSGlobalObject,
+        value: JSC.JSValue,
+    ) callconv(.C) bool {
+        log("setData()", .{});
+        this.strong_data.set(globalObject, value);
+        return true;
+    }
+
+    const UnixOrHost = union(enum) {
+        unix: []const u8,
+        host: struct {
+            host: []const u8,
+            port: u16,
+        },
+
+        pub fn deinit(this: UnixOrHost) void {
+            switch (this) {
+                .unix => |u| {
+                    bun.default_allocator.destroy(@intToPtr([*]u8, @ptrToInt(u.ptr)));
+                },
+                .host => |h| {
+                    bun.default_allocator.destroy(@intToPtr([*]u8, @ptrToInt(h.host.ptr)));
+                },
+            }
+        }
+    };
+
+    pub fn reload(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSValue {
+        const args = callframe.arguments(1);
+
+        if (args.len < 1 or (this.listener == null and this.handlers.active_connections == 0)) {
+            globalObject.throw("Expected 1 argument", .{});
+            return .zero;
+        }
+
+        const opts = args.ptr[0];
+        if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
+            globalObject.throwValue(JSC.toInvalidArguments("Expected options object", .{}, globalObject));
+            return .zero;
+        }
+
+        var exception: JSC.C.JSValueRef = null;
+
+        var socket_obj = opts.get(globalObject, "socket") orelse {
+            globalObject.throw("Expected \"socket\" object", .{});
+            return .zero;
+        };
+
+        const handlers = Handlers.fromJS(globalObject, socket_obj, &exception) orelse {
+            globalObject.throwValue(exception.?.value());
+            return .zero;
+        };
+
+        var prev_handlers = this.handlers;
+        prev_handlers.unprotect();
+        this.handlers = handlers; // TODO: this is a memory leak
+        this.handlers.protect();
+
+        return JSValue.jsUndefined();
+    }
+
+    pub fn listen(
+        globalObject: *JSC.JSGlobalObject,
+        opts: JSValue,
+        exception: JSC.C.ExceptionRef,
+    ) JSValue {
+        log("listen", .{});
+        if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
+            exception.* = JSC.toInvalidArguments("Expected object", .{}, globalObject).asObjectRef();
+            return .zero;
+        }
+
+        const socket_config = SocketConfig.fromJS(opts, globalObject, exception) orelse {
+            return .zero;
+        };
+        var hostname_or_unix = socket_config.hostname_or_unix;
+        var port = socket_config.port;
+        var ssl = socket_config.ssl;
+        var handlers = socket_config.handlers;
+        handlers.is_server = true;
+
+        const ssl_enabled = ssl != null;
+
+        var socket = Listener{
+            .handlers = handlers,
+            .connection = if (port) |port_| .{
+                .host = .{ .host = (hostname_or_unix.cloneIfNeeded() catch unreachable).slice(), .port = port_ },
+            } else .{
+                .unix = (hostname_or_unix.cloneIfNeeded() catch unreachable).slice(),
+            },
+            .ssl = ssl_enabled,
+        };
+
+        socket.handlers.protect();
+
+        if (socket_config.default_data != .zero) {
+            socket.strong_data = JSC.Strong.create(socket_config.default_data, globalObject);
+        }
+
+        const socket_flags: i32 = 0;
+
+        var ctx_opts: uws.us_socket_context_options_t = undefined;
+        @memset(@ptrCast([*]u8, &ctx_opts), 0, @sizeOf(uws.us_socket_context_options_t));
+
+        if (ssl) |ssl_config| {
+            ctx_opts.key_file_name = ssl_config.key_file_name;
+            ctx_opts.cert_file_name = ssl_config.cert_file_name;
+            ctx_opts.ca_file_name = ssl_config.ca_file_name;
+            ctx_opts.dh_params_file_name = ssl_config.dh_params_file_name;
+            ctx_opts.passphrase = ssl_config.passphrase;
+            ctx_opts.ssl_prefer_low_memory_usage = @boolToInt(ssl_config.low_memory_mode);
+        }
+
+        socket.socket_context = uws.us_create_socket_context(@boolToInt(ssl_enabled), uws.Loop.get().?, @sizeOf(usize), ctx_opts);
+
+        if (ssl) |ssl_config| {
+            uws.us_socket_context_add_server_name(1, socket.socket_context, ssl_config.server_name, ctx_opts, null);
+        }
+
+        var this: *Listener = handlers.vm.allocator.create(Listener) catch @panic("OOM");
+        this.* = socket;
+        this.socket_context.?.ext(ssl_enabled, *Listener).?.* = this;
+
+        var this_value = this.toJS(globalObject);
+        this.strong_self.set(globalObject, this_value);
+        this.poll_ref.ref(handlers.vm);
+
+        if (ssl_enabled) {
+            uws.NewSocketHandler(true).configure(
+                this.socket_context.?,
+                true,
+                *TLSSocket,
+                struct {
+                    pub const onOpen = NewSocket(true).onOpen;
+                    pub const onCreate = onCreateTLS;
+                    pub const onClose = NewSocket(true).onClose;
+                    pub const onData = NewSocket(true).onData;
+                    pub const onWritable = NewSocket(true).onWritable;
+                    pub const onTimeout = NewSocket(true).onTimeout;
+                    pub const onConnectError = NewSocket(true).onConnectError;
+                    pub const onEnd = NewSocket(true).onEnd;
+                },
+            );
+        } else {
+            uws.NewSocketHandler(false).configure(
+                this.socket_context.?,
+                true,
+                *TCPSocket,
+                struct {
+                    pub const onOpen = NewSocket(false).onOpen;
+                    pub const onCreate = onCreateTCP;
+                    pub const onClose = NewSocket(false).onClose;
+                    pub const onData = NewSocket(false).onData;
+                    pub const onWritable = NewSocket(false).onWritable;
+                    pub const onTimeout = NewSocket(false).onTimeout;
+                    pub const onConnectError = NewSocket(false).onConnectError;
+                    pub const onEnd = NewSocket(false).onEnd;
+                },
+            );
+        }
+
+        switch (this.connection) {
+            .host => |c| {
+                var host = bun.default_allocator.dupeZ(u8, c.host) catch unreachable;
+                defer bun.default_allocator.destroy(host.ptr);
+                this.listener = uws.us_socket_context_listen(@boolToInt(ssl_enabled), this.socket_context, host, c.port, socket_flags, 8) orelse {
+                    exception.* = JSC.toInvalidArguments(
+                        "Failed to listen at {s}:{d}",
+                        .{
+                            bun.span(host),
+                            c.port,
+                        },
+                        globalObject,
+                    ).asObjectRef();
+                    this.poll_ref.unref(handlers.vm);
+
+                    this.strong_self.clear();
+                    this.strong_data.clear();
+
+                    return .zero;
+                };
+            },
+            .unix => |u| {
+                var host = bun.default_allocator.dupeZ(u8, u) catch unreachable;
+                defer bun.default_allocator.destroy(host.ptr);
+                this.listener = uws.us_socket_context_listen_unix(@boolToInt(ssl_enabled), this.socket_context, host, socket_flags, 8) orelse {
+                    exception.* = JSC.toInvalidArguments(
+                        "Failed to listen on socket {s}",
+                        .{
+                            bun.span(host),
+                        },
+                        globalObject,
+                    ).asObjectRef();
+                    this.poll_ref.unref(handlers.vm);
+
+                    this.strong_self.clear();
+                    this.strong_data.clear();
+
+                    return .zero;
+                };
+            },
+        }
+
+        return this_value;
+    }
+
+    pub fn onCreateTLS(
+        socket: uws.NewSocketHandler(true),
+    ) void {
+        onCreate(true, socket);
+    }
+
+    pub fn onCreateTCP(
+        socket: uws.NewSocketHandler(false),
+    ) void {
+        onCreate(false, socket);
+    }
+
+    pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) ?*Listener {
+        globalObject.throw("Cannot construct Listener", .{});
+        return null;
+    }
+
+    pub fn onCreate(comptime ssl: bool, socket: uws.NewSocketHandler(ssl)) void {
+        JSC.markBinding(@src());
+        log("onCreate", .{});
+        var listener: *Listener = socket.context().ext(ssl, *Listener).?.*;
+        const Socket = NewSocket(ssl);
+        std.debug.assert(ssl == listener.ssl);
+
+        var this_socket = listener.handlers.vm.allocator.create(Socket) catch @panic("Out of memory");
+        this_socket.* = Socket{
+            .handlers = &listener.handlers,
+            .this_value = listener.strong_data.get() orelse JSValue.zero,
+            .socket = socket,
+        };
+        socket.ext(**anyopaque).?.* = bun.cast(**anyopaque, this_socket);
+        socket.timeout(120000);
+    }
+
+    pub fn stop(this: *Listener, _: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSValue {
+        log("close", .{});
+
+        var listener = this.listener orelse return JSValue.jsUndefined();
+        this.listener = null;
+        listener.close(this.ssl);
+        if (this.handlers.active_connections == 0) {
+            this.poll_ref.unref(this.handlers.vm);
+            this.handlers.unprotect();
+            this.socket_context.?.deinit(this.ssl);
+            this.socket_context = null;
+            this.strong_self.clear();
+            this.strong_data.clear();
+        }
+
+        return JSValue.jsUndefined();
+    }
+
+    pub fn finalize(this: *Listener) callconv(.C) void {
+        log("Finalize", .{});
+        this.deinit();
+    }
+
+    pub fn deinit(this: *Listener) void {
+        this.strong_self.deinit();
+        this.strong_data.deinit();
+        this.poll_ref.unref(this.handlers.vm);
+        std.debug.assert(this.listener == null);
+        std.debug.assert(this.handlers.active_connections == 0);
+
+        if (this.socket_context) |ctx| {
+            ctx.deinit(this.ssl);
+        }
+
+        this.handlers.unprotect();
+        this.connection.deinit();
+        bun.default_allocator.destroy(this);
+    }
+
+    pub fn getConnectionsCount(this: *Listener, _: *JSC.JSGlobalObject) callconv(.C) JSValue {
+        return JSValue.jsNumber(this.handlers.active_connections);
+    }
+
+    pub fn getUnix(this: *Listener, globalObject: *JSC.JSGlobalObject) callconv(.C) JSValue {
+        if (this.connection != .unix) {
+            return JSValue.jsUndefined();
+        }
+
+        return ZigString.init(this.connection.unix).withEncoding().toValueGC(globalObject);
+    }
+
+    pub fn getHostname(this: *Listener, globalObject: *JSC.JSGlobalObject) callconv(.C) JSValue {
+        if (this.connection != .host) {
+            return JSValue.jsUndefined();
+        }
+
+        return ZigString.init(this.connection.host.host).withEncoding().toValueGC(globalObject);
+    }
+
+    pub fn getPort(this: *Listener, _: *JSC.JSGlobalObject) callconv(.C) JSValue {
+        if (this.connection != .host) {
+            return JSValue.jsUndefined();
+        }
+
+        return JSValue.jsNumber(this.connection.host.port);
+    }
+
+    pub fn ref(this: *Listener, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSValue {
+        var this_value = callframe.this();
+        if (this.listener == null) return JSValue.jsUndefined();
+        this.poll_ref.ref(globalObject.bunVM());
+        this.strong_self.set(globalObject, this_value);
+        return JSValue.jsUndefined();
+    }
+
+    pub fn unref(this: *Listener, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSValue {
+        if (!this.poll_ref.isActive()) return JSValue.jsUndefined();
+
+        this.poll_ref.unref(globalObject.bunVM());
+        if (this.handlers.active_connections == 0) {
+            this.strong_self.clear();
+        }
+        return JSValue.jsUndefined();
+    }
+
+    pub fn connect(
+        globalObject: *JSC.JSGlobalObject,
+        opts: JSValue,
+        exception: JSC.C.ExceptionRef,
+    ) JSValue {
+        if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
+            exception.* = JSC.toInvalidArguments("Expected options object", .{}, globalObject).asObjectRef();
+            return .zero;
+        }
+
+        const socket_config = SocketConfig.fromJS(opts, globalObject, exception) orelse {
+            return .zero;
+        };
+        var hostname_or_unix = socket_config.hostname_or_unix;
+        var port = socket_config.port;
+        var ssl = socket_config.ssl;
+        var handlers = socket_config.handlers;
+        var default_data = socket_config.default_data;
+
+        const ssl_enabled = ssl != null;
+
+        handlers.protect();
+
+        var ctx_opts: uws.us_socket_context_options_t = undefined;
+        @memset(@ptrCast([*]u8, &ctx_opts), 0, @sizeOf(uws.us_socket_context_options_t));
+
+        if (ssl) |ssl_config| {
+            if (ssl_config.key_file_name != null)
+                ctx_opts.key_file_name = ssl_config.key_file_name;
+            if (ssl_config.cert_file_name != null)
+                ctx_opts.cert_file_name = ssl_config.cert_file_name;
+            if (ssl_config.ca_file_name != null)
+                ctx_opts.ca_file_name = ssl_config.ca_file_name;
+            if (ssl_config.dh_params_file_name != null)
+                ctx_opts.dh_params_file_name = ssl_config.dh_params_file_name;
+            if (ssl_config.passphrase != null)
+                ctx_opts.passphrase = ssl_config.passphrase;
+            ctx_opts.ssl_prefer_low_memory_usage = @boolToInt(ssl_config.low_memory_mode);
+        }
+
+        var socket_context = uws.us_create_socket_context(@boolToInt(ssl_enabled), uws.Loop.get().?, @sizeOf(usize), ctx_opts).?;
+        var connection: Listener.UnixOrHost = if (port) |port_| .{
+            .host = .{ .host = (hostname_or_unix.cloneIfNeeded() catch unreachable).slice(), .port = port_ },
+        } else .{
+            .unix = (hostname_or_unix.cloneIfNeeded() catch unreachable).slice(),
+        };
+
+        if (ssl_enabled) {
+            uws.NewSocketHandler(true).configure(
+                socket_context,
+                true,
+                *TLSSocket,
+                struct {
+                    pub const onOpen = NewSocket(true).onOpen;
+                    pub const onClose = NewSocket(true).onClose;
+                    pub const onData = NewSocket(true).onData;
+                    pub const onWritable = NewSocket(true).onWritable;
+                    pub const onTimeout = NewSocket(true).onTimeout;
+                    pub const onConnectError = NewSocket(true).onConnectError;
+                    pub const onEnd = NewSocket(true).onEnd;
+                },
+            );
+        } else {
+            uws.NewSocketHandler(false).configure(
+                socket_context,
+                true,
+                *TCPSocket,
+                struct {
+                    pub const onOpen = NewSocket(false).onOpen;
+                    pub const onClose = NewSocket(false).onClose;
+                    pub const onData = NewSocket(false).onData;
+                    pub const onWritable = NewSocket(false).onWritable;
+                    pub const onTimeout = NewSocket(false).onTimeout;
+                    pub const onConnectError = NewSocket(false).onConnectError;
+                    pub const onEnd = NewSocket(false).onEnd;
+                },
+            );
+        }
+
+        default_data.ensureStillAlive();
+
+        // const socket_flags: i32 = 0;
+
+        var handlers_ptr = handlers.vm.allocator.create(Handlers) catch @panic("OOM");
+        handlers_ptr.* = handlers;
+        handlers_ptr.is_server = false;
+
+        if (ssl_enabled) {
+            var tls = handlers.vm.allocator.create(TLSSocket) catch @panic("OOM");
+
+            tls.* = .{
+                .handlers = handlers_ptr,
+                .this_value = default_data,
+                .socket = undefined,
+            };
+
+            var promise = JSC.JSPromise.create(globalObject);
+            var promise_value = promise.asValue(globalObject);
+            handlers.promise.set(globalObject, promise_value);
+
+            tls.doConnect(connection, socket_context) catch {
+                handlers_ptr.unprotect();
+                socket_context.deinit(true);
+                handlers.vm.allocator.destroy(handlers_ptr);
+                handlers.promise.deinit();
+                bun.default_allocator.destroy(tls);
+                exception.* = ZigString.static("Failed to connect").toErrorInstance(globalObject).asObjectRef();
+                return .zero;
+            };
+
+            return promise_value;
+        } else {
+            var tcp = handlers.vm.allocator.create(TCPSocket) catch @panic("OOM");
+
+            tcp.* = .{
+                .handlers = handlers_ptr,
+                .this_value = default_data,
+                .socket = undefined,
+            };
+            var promise = JSC.JSPromise.create(globalObject);
+            var promise_value = promise.asValue(globalObject);
+            handlers.promise.set(globalObject, promise_value);
+
+            tcp.doConnect(connection, socket_context) catch {
+                handlers_ptr.unprotect();
+                socket_context.deinit(false);
+                handlers.vm.allocator.destroy(handlers_ptr);
+                handlers.promise.deinit();
+                bun.default_allocator.destroy(tcp);
+                exception.* = ZigString.static("Failed to connect").toErrorInstance(globalObject).asObjectRef();
+                return .zero;
+            };
+
+            return promise_value;
+        }
+    }
+};
+
+fn JSSocketType(comptime ssl: bool) type {
+    if (!ssl) {
+        return JSC.Codegen.JSTCPSocket;
+    } else {
+        return JSC.Codegen.JSTLSSocket;
+    }
+}
+
+fn NewSocket(comptime ssl: bool) type {
+    return struct {
+        pub const Socket = uws.NewSocketHandler(ssl);
+        socket: Socket,
+        detached: bool = false,
+        handlers: *Handlers,
+        this_value: JSC.JSValue = .zero,
+        poll_ref: JSC.PollRef = JSC.PollRef.init(),
+        reffer: JSC.Ref = JSC.Ref.init(),
+        last_4: [4]u8 = .{ 0, 0, 0, 0 },
+
+        const This = @This();
+        const log = Output.scoped(.Socket, false);
+
+        pub usingnamespace JSSocketType(ssl);
+
+        pub fn doConnect(this: *This, connection: Listener.UnixOrHost, socket_ctx: *uws.SocketContext) !void {
+            switch (connection) {
+                .host => |c| {
+                    _ = @This().Socket.connectPtr(
+                        c.host,
+                        c.port,
+                        socket_ctx,
+                        @This(),
+                        this,
+                        "socket",
+                    ) orelse return error.ConnectionFailed;
+                },
+                .unix => |u| {
+                    _ = @This().Socket.connectUnixPtr(
+                        u,
+                        socket_ctx,
+                        @This(),
+                        this,
+                        "socket",
+                    ) orelse return error.ConnectionFailed;
+                },
+            }
+        }
+
+        pub fn constructor(globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) ?*This {
+            globalObject.throw("Cannot construct Socket", .{});
+            return null;
+        }
+
+        pub fn onWritable(
+            this: *This,
+            _: Socket,
+        ) void {
+            JSC.markBinding(@src());
+            if (this.detached) return;
+            var handlers = this.handlers;
+            const callback = handlers.onWritable;
+            if (callback == .zero) {
+                return;
+            }
+
+            const this_value = this.getThisValue(handlers.globalObject);
+            const result = callback.callWithThis(handlers.globalObject, this_value, &[_]JSValue{
+                this_value,
+            });
+
+            if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(handlers.globalObject)) {
+                if (handlers.callErrorHandler(this_value, &[_]JSC.JSValue{ this_value, result })) {
+                    return;
+                }
+
+                handlers.vm.runErrorHandler(result, null);
+            }
+        }
+        pub fn onTimeout(
+            this: *This,
+            _: Socket,
+        ) void {
+            JSC.markBinding(@src());
+            if (this.detached) return;
+            this.detached = true;
+            var handlers = this.handlers;
+            this.poll_ref.unref(handlers.vm);
+            var globalObject = handlers.globalObject;
+            const callback = handlers.onTimeout;
+
+            this.markInactive();
+            if (callback == .zero) {
+                return;
+            }
+
+            const this_value = this.getThisValue(globalObject);
+            const result = callback.callWithThis(globalObject, this_value, &[_]JSValue{
+                this_value,
+            });
+
+            if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(globalObject)) {
+                if (handlers.callErrorHandler(this_value, &[_]JSC.JSValue{ this_value, result })) {
+                    return;
+                }
+
+                handlers.vm.runErrorHandler(result, null);
+            }
+        }
+        pub fn onConnectError(this: *This, socket: Socket, errno: c_int) void {
+            JSC.markBinding(@src());
+            log("onConnectError({d}", .{errno});
+            this.detached = true;
+            var handlers = this.handlers;
+            this.poll_ref.unref(handlers.vm);
+            var err = JSC.SystemError{
+                .errno = errno,
+                .message = ZigString.init("Failed to connect"),
+                .syscall = ZigString.init("connect"),
+            };
+            _ = handlers.rejectPromise(err.toErrorInstance(handlers.globalObject));
+            this.reffer.unref(handlers.vm);
+            handlers.markInactive(ssl, socket.context());
+            this.finalize();
+        }
+
+        pub fn markActive(this: *This) void {
+            if (!this.reffer.has) {
+                this.handlers.active_connections += 1;
+                this.reffer.ref(this.handlers.vm);
+            }
+        }
+
+        pub fn markInactive(this: *This) void {
+            if (this.reffer.has) {
+                var vm = this.handlers.vm;
+                this.handlers.markInactive(ssl, this.socket.context());
+                this.reffer.unref(vm);
+                this.poll_ref.unref(vm);
+            }
+
+            if (this.this_value != .zero) {
+                this.this_value.unprotect();
+            }
+        }
+
+        pub fn onOpen(this: *This, socket: Socket) void {
+            JSC.markBinding(@src());
+            log("onOpen", .{});
+            this.poll_ref.ref(this.handlers.vm);
+            this.detached = false;
+            this.socket = socket;
+            socket.ext(**anyopaque).?.* = bun.cast(**anyopaque, this);
+            var handlers = this.handlers;
+            const old_this_value = this.this_value;
+            this.this_value = .zero;
+            const this_value = this.getThisValue(handlers.globalObject);
+
+            if (old_this_value != .zero) {
+                This.dataSetCached(this_value, handlers.globalObject, old_this_value);
+            }
+
+            if (handlers.onOpen == .zero and old_this_value == .zero) {
+                this.markActive();
+                this.handlers.resolvePromise(this_value);
+                return;
+            }
+
+            handlers.resolvePromise(this_value);
+
+            const result = handlers.onOpen.callWithThis(handlers.globalObject, this_value, &[_]JSValue{
+                this_value,
+            });
+
+            if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(handlers.globalObject)) {
+                if (!this.socket.isClosed()) {
+                    log("Closing due to error", .{});
+                    this.detached = true;
+                    this.socket.close(0, null);
+                } else {
+                    log("Already closed", .{});
+                }
+
+                if (handlers.rejectPromise(this_value)) {
+                    return;
+                }
+
+                if (handlers.callErrorHandler(this_value, &[_]JSC.JSValue{ this_value, result })) {
+                    return;
+                }
+
+                handlers.vm.runErrorHandler(result, null);
+                return;
+            }
+
+            this.markActive();
+        }
+
+        pub fn getThisValue(this: *This, globalObject: *JSC.JSGlobalObject) JSValue {
+            if (this.this_value == .zero) {
+                const value = this.toJS(globalObject);
+                this.this_value = value;
+                value.protect();
+                return value;
+            }
+
+            return this.this_value;
+        }
+
+        pub fn onEnd(this: *This, _: Socket) void {
+            JSC.markBinding(@src());
+            log("onEnd", .{});
+            this.detached = true;
+            var handlers = this.handlers;
+            const callback = handlers.onEnd;
+
+            if (callback == .zero) {
+                return;
+            }
+
+            const this_value = this.getThisValue(handlers.globalObject);
+            const result = callback.callWithThis(handlers.globalObject, this_value, &[_]JSValue{
+                this_value,
+            });
+
+            if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(handlers.globalObject)) {
+                if (handlers.callErrorHandler(this_value, &[_]JSC.JSValue{ this_value, result })) {
+                    return;
+                }
+
+                handlers.vm.runErrorHandler(result, null);
+            }
+        }
+
+        pub fn onClose(this: *This, _: Socket, err: c_int, _: ?*anyopaque) void {
+            JSC.markBinding(@src());
+            log("onClose", .{});
+            this.detached = true;
+            var handlers = this.handlers;
+            this.poll_ref.unref(handlers.vm);
+
+            const callback = handlers.onClose;
+            var globalObject = handlers.globalObject;
+
+            if (callback == .zero) {
+                this.markInactive();
+                return;
+            }
+
+            const this_value = this.getThisValue(globalObject);
+
+            const result = callback.callWithThis(globalObject, this_value, &[_]JSValue{
+                this_value,
+                JSValue.jsNumber(@as(i32, err)),
+            });
+
+            if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(globalObject)) {
+                if (handlers.callErrorHandler(this_value, &[_]JSC.JSValue{ this_value, result })) {
+                    return;
+                }
+
+                handlers.vm.runErrorHandler(result, null);
+            }
+        }
+
+        pub fn onData(this: *This, _: Socket, data: []const u8) void {
+            JSC.markBinding(@src());
+            if (comptime Environment.allow_assert) {
+                log("onData({d})", .{data.len});
+            }
+
+            if (this.detached) return;
+            var handlers = this.handlers;
+            // const encoding = handlers.encoding;
+            const callback = handlers.onData;
+            if (callback == .zero) {
+                return;
+            }
+
+            const output_value = JSC.ArrayBuffer.create(handlers.globalObject, data, .Uint8Array);
+
+            const this_value = this.getThisValue(handlers.globalObject);
+            const result = callback.callWithThis(handlers.globalObject, this_value, &[_]JSValue{
+                this_value,
+                output_value,
+            });
+
+            if (!result.isEmptyOrUndefinedOrNull() and result.isAnyError(handlers.globalObject)) {
+                if (handlers.callErrorHandler(this_value, &[_]JSC.JSValue{ this_value, result })) {
+                    return;
+                }
+
+                handlers.vm.runErrorHandler(result, null);
+            }
+        }
+
+        pub fn getData(
+            _: *This,
+            _: *JSC.JSGlobalObject,
+        ) callconv(.C) JSValue {
+            log("getData()", .{});
+            return JSValue.jsUndefined();
+        }
+
+        pub fn setData(
+            this: *This,
+            globalObject: *JSC.JSGlobalObject,
+            value: JSC.JSValue,
+        ) callconv(.C) bool {
+            log("setData()", .{});
+            This.dataSetCached(this.this_value, globalObject, value);
+            return true;
+        }
+
+        pub fn getListener(
+            this: *This,
+            _: *JSC.JSGlobalObject,
+        ) callconv(.C) JSValue {
+            if (!this.handlers.is_server or this.detached) {
+                return JSValue.jsUndefined();
+            }
+
+            return @fieldParentPtr(Listener, "handlers", this.handlers).strong_self.get() orelse JSValue.jsUndefined();
+        }
+
+        pub fn getReadyState(
+            this: *This,
+            _: *JSC.JSGlobalObject,
+        ) callconv(.C) JSValue {
+            log("getReadyState()", .{});
+
+            if (this.detached) {
+                return JSValue.jsNumber(@as(i32, -1));
+            } else if (this.socket.isClosed()) {
+                return JSValue.jsNumber(@as(i32, 0));
+            } else if (this.socket.isEstablished()) {
+                return JSValue.jsNumber(@as(i32, 1));
+            } else if (this.socket.isShutdown()) {
+                return JSValue.jsNumber(@as(i32, -2));
+            } else {
+                return JSValue.jsNumber(@as(i32, 2));
+            }
+        }
+
+        pub fn timeout(
+            this: *This,
+            globalObject: *JSC.JSGlobalObject,
+            callframe: *JSC.CallFrame,
+        ) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+            const args = callframe.arguments(1);
+            if (this.detached) return JSValue.jsUndefined();
+            if (args.len == 0) {
+                globalObject.throw("Expected 1 argument, got 0", .{});
+                return .zero;
+            }
+            const t = args.ptr[0].toInt32();
+            if (t < 0) {
+                globalObject.throw("Timeout must be a positive integer", .{});
+                return .zero;
+            }
+
+            this.socket.timeout(@intCast(c_uint, t));
+
+            return JSValue.jsUndefined();
+        }
+
+        pub fn write(
+            this: *This,
+            globalObject: *JSC.JSGlobalObject,
+            callframe: *JSC.CallFrame,
+        ) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+
+            if (this.detached) {
+                return JSValue.jsNumber(@as(i32, -1));
+            }
+
+            const args = callframe.arguments(4);
+
+            if (args.len == 0) {
+                globalObject.throw("Expected 1 - 4 arguments, got 0", .{});
+                return .zero;
+            }
+
+            return this.writeOrEnd(globalObject, args.ptr[0..args.len], false);
+        }
+
+        pub fn getLocalPort(
+            this: *This,
+            _: *JSC.JSGlobalObject,
+        ) callconv(.C) JSValue {
+            if (this.detached) {
+                return JSValue.jsUndefined();
+            }
+
+            return JSValue.jsNumber(this.socket.localPort());
+        }
+
+        pub fn getRemoteAddress(
+            this: *This,
+            globalThis: *JSC.JSGlobalObject,
+        ) callconv(.C) JSValue {
+            if (this.detached) {
+                return JSValue.jsUndefined();
+            }
+
+            var buf: [512]u8 = undefined;
+            var length: i32 = 512;
+            this.socket.remoteAddress(&buf, &length);
+            const address = buf[0..@intCast(usize, @minimum(length, 0))];
+
+            if (address.len == 0) {
+                return JSValue.jsUndefined();
+            }
+
+            return ZigString.init(address).toValueGC(globalThis);
+        }
+
+        fn writeMaybeCorked(this: *This, buffer: []const u8, is_end: bool) i32 {
+            // we don't cork yet but we might later
+            return this.socket.write(buffer, is_end);
+        }
+
+        fn writeOrEnd(this: *This, globalObject: *JSC.JSGlobalObject, args: []const JSC.JSValue, is_end: bool) JSValue {
+            if (args.ptr[0].isEmptyOrUndefinedOrNull()) {
+                globalObject.throw("Expected an ArrayBufferView, a string, or a Blob", .{});
+                return .zero;
+            }
+
+            if (this.socket.isShutdown() or this.socket.isClosed()) {
+                return JSValue.jsNumber(@as(i32, -1));
+            }
+
+            if (args.ptr[0].asArrayBuffer(globalObject)) |array_buffer| {
+                var slice = array_buffer.slice();
+
+                if (args.len > 1) {
+                    if (!args.ptr[1].isAnyInt()) {
+                        globalObject.throw("Expected offset integer, got {any}", .{args.ptr[1].getZigString(globalObject)});
+                        return .zero;
+                    }
+
+                    const offset = @minimum(args.ptr[1].toUInt64NoTruncate(), slice.len);
+                    slice = slice[offset..];
+
+                    if (args.len > 2) {
+                        if (!args.ptr[2].isAnyInt()) {
+                            globalObject.throw("Expected length integer, got {any}", .{args.ptr[2].getZigString(globalObject)});
+                            return .zero;
+                        }
+
+                        const length = @minimum(args.ptr[2].toUInt64NoTruncate(), slice.len);
+                        slice = slice[0..length];
+                    }
+                }
+
+                if (slice.len == 0) {
+                    return JSValue.jsNumber(@as(i32, 0));
+                }
+
+                return JSValue.jsNumber(this.writeMaybeCorked(slice, is_end));
+            } else if (args.ptr[0].jsType() == .DOMWrapper) {
+                const blob: JSC.WebCore.AnyBlob = getter: {
+                    if (args.ptr[0].as(JSC.WebCore.Blob)) |blob| {
+                        break :getter JSC.WebCore.AnyBlob{ .Blob = blob.* };
+                    } else if (args.ptr[0].as(JSC.WebCore.Response)) |response| {
+                        response.body.value.toBlobIfPossible();
+
+                        if (response.body.value.tryUseAsAnyBlob()) |blob| {
+                            break :getter blob;
+                        }
+
+                        globalObject.throw("Only Blob/buffered bodies are supported for now", .{});
+                        return .zero;
+                    } else if (args.ptr[0].as(JSC.WebCore.Request)) |request| {
+                        request.body.toBlobIfPossible();
+                        if (request.body.tryUseAsAnyBlob()) |blob| {
+                            break :getter blob;
+                        }
+
+                        globalObject.throw("Only Blob/buffered bodies are supported for now", .{});
+                        return .zero;
+                    }
+
+                    globalObject.throw("Expected Blob, Request or Response", .{});
+                    return .zero;
+                };
+
+                if (!blob.needsToReadFile()) {
+                    var slice = blob.slice();
+
+                    if (args.len > 1) {
+                        if (!args.ptr[1].isAnyInt()) {
+                            globalObject.throw("Expected offset integer, got {any}", .{args.ptr[1].getZigString(globalObject)});
+                            return .zero;
+                        }
+
+                        const offset = @minimum(args.ptr[1].toUInt64NoTruncate(), slice.len);
+                        slice = slice[offset..];
+
+                        if (args.len > 2) {
+                            if (!args.ptr[2].isAnyInt()) {
+                                globalObject.throw("Expected length integer, got {any}", .{args.ptr[2].getZigString(globalObject)});
+                                return .zero;
+                            }
+
+                            const length = @minimum(args.ptr[2].toUInt64NoTruncate(), slice.len);
+                            slice = slice[0..length];
+                        }
+                    }
+
+                    if (slice.len == 0) {
+                        return JSValue.jsNumber(@as(i32, 0));
+                    }
+
+                    return JSValue.jsNumber(this.writeMaybeCorked(slice, is_end));
+                }
+
+                globalObject.throw("sendfile() not implemented yet", .{});
+                return .zero;
+            } else if (args.ptr[0].toStringOrNull(globalObject)) |jsstring| {
+                var zig_str = jsstring.toSlice(globalObject, globalObject.bunVM().allocator);
+                defer zig_str.deinit();
+
+                var slice = zig_str.slice();
+
+                if (args.len > 1) {
+                    if (!args.ptr[1].isAnyInt()) {
+                        globalObject.throw("Expected offset integer, got {any}", .{args.ptr[1].getZigString(globalObject)});
+                        return .zero;
+                    }
+
+                    const offset = @minimum(args.ptr[1].toUInt64NoTruncate(), slice.len);
+                    slice = slice[offset..];
+
+                    if (args.len > 2) {
+                        if (!args.ptr[2].isAnyInt()) {
+                            globalObject.throw("Expected length integer, got {any}", .{args.ptr[2].getZigString(globalObject)});
+                            return .zero;
+                        }
+
+                        const length = @minimum(args.ptr[2].toUInt64NoTruncate(), slice.len);
+                        slice = slice[0..length];
+                    }
+                }
+
+                return JSValue.jsNumber(this.writeMaybeCorked(slice, is_end));
+            } else {
+                globalObject.throw("Expected ArrayBufferView, a string, or a Blob", .{});
+                return .zero;
+            }
+        }
+
+        pub fn flush(
+            this: *This,
+            _: *JSC.JSGlobalObject,
+            _: *JSC.CallFrame,
+        ) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+            if (!this.detached)
+                this.socket.flush();
+
+            return JSValue.jsUndefined();
+        }
+
+        pub fn shutdown(
+            this: *This,
+            _: *JSC.JSGlobalObject,
+            callframe: *JSC.CallFrame,
+        ) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+            const args = callframe.arguments(1);
+            if (!this.detached) {
+                if (args.len > 0 and args.ptr[0].toBoolean()) {
+                    this.socket.shutdownRead();
+                } else {
+                    this.socket.shutdown();
+                }
+            }
+
+            return JSValue.jsUndefined();
+        }
+
+        pub fn end(
+            this: *This,
+            globalObject: *JSC.JSGlobalObject,
+            callframe: *JSC.CallFrame,
+        ) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+
+            const args = callframe.arguments(4);
+
+            if (args.len == 0) {
+                log("end()", .{});
+                if (!this.detached) {
+                    if (!this.socket.isClosed()) this.socket.flush();
+                    this.detached = true;
+                    this.markInactive();
+                    if (!this.socket.isClosed())
+                        this.socket.close(0, null);
+                }
+
+                return JSValue.jsUndefined();
+            }
+
+            log("end({d} args)", .{args.len});
+
+            if (this.detached) {
+                return JSValue.jsNumber(@as(i32, -1));
+            }
+
+            const result = this.writeOrEnd(globalObject, args.ptr[0..args.len], true);
+            if (result != .zero and result.toInt32() > 0) {
+                this.socket.flush();
+                this.detached = true;
+                this.markInactive();
+                if (!this.socket.isClosed())
+                    this.socket.close(0, null);
+            }
+
+            return result;
+        }
+
+        pub fn ref(this: *This, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+            if (this.detached) return JSValue.jsUndefined();
+            this.poll_ref.ref(globalObject.bunVM());
+            return JSValue.jsUndefined();
+        }
+
+        pub fn unref(this: *This, globalObject: *JSC.JSGlobalObject, _: *JSC.CallFrame) callconv(.C) JSValue {
+            JSC.markBinding(@src());
+            this.poll_ref.unref(globalObject.bunVM());
+            return JSValue.jsUndefined();
+        }
+
+        pub fn finalize(this: *This) callconv(.C) void {
+            log("finalize()", .{});
+            if (!this.detached and !this.socket.isClosed()) {
+                this.detached = true;
+                this.socket.close(0, null);
+            }
+            this.markInactive();
+            if (this.poll_ref.isActive()) this.poll_ref.unref(JSC.VirtualMachine.vm);
+        }
+
+        pub fn reload(this: *This, globalObject: *JSC.JSGlobalObject, callframe: *JSC.CallFrame) callconv(.C) JSValue {
+            const args = callframe.arguments(1);
+
+            if (args.len < 1) {
+                globalObject.throw("Expected 1 argument", .{});
+                return .zero;
+            }
+
+            if (this.detached) {
+                return JSValue.jsUndefined();
+            }
+
+            const opts = args.ptr[0];
+            if (opts.isEmptyOrUndefinedOrNull() or opts.isBoolean() or !opts.isObject()) {
+                globalObject.throw("Expected options object", .{});
+                return .zero;
+            }
+
+            var exception: JSC.C.JSValueRef = null;
+
+            var socket_obj = opts.get(globalObject, "socket") orelse {
+                globalObject.throw("Expected \"socket\" option", .{});
+                return .zero;
+            };
+
+            const handlers = Handlers.fromJS(globalObject, socket_obj, &exception) orelse {
+                globalObject.throwValue(exception.?.value());
+                return .zero;
+            };
+
+            var prev_handlers = this.handlers;
+            prev_handlers.unprotect();
+            this.handlers.* = handlers; // TODO: this is a memory leak
+            this.handlers.protect();
+
+            return JSValue.jsUndefined();
+        }
+    };
+}
+
+pub const TCPSocket = NewSocket(false);
+pub const TLSSocket = NewSocket(true);
diff --git a/src/bun.js/api/sockets.classes.ts b/src/bun.js/api/sockets.classes.ts
new file mode 100644
index 000000000..0c72d1d8d
--- /dev/null
+++ b/src/bun.js/api/sockets.classes.ts
@@ -0,0 +1,130 @@
+import { define } from "../scripts/class-definitions";
+
+function generate(ssl) {
+  return define({
+    name: ssl ? "TCPSocket" : "TLSSocket",
+    JSType: "0b11101110",
+    proto: {
+      write: {
+        fn: "write",
+        length: 3,
+      },
+      end: {
+        fn: "end",
+        length: 3,
+      },
+
+      //   },
+      listener: {
+        getter: "getListener",
+      },
+
+      timeout: {
+        fn: "timeout",
+        length: 1,
+      },
+
+      flush: {
+        fn: "flush",
+        length: 0,
+      },
+
+      shutdown: {
+        fn: "shutdown",
+        length: 1,
+      },
+
+      ref: {
+        fn: "ref",
+        length: 0,
+      },
+      unref: {
+        fn: "unref",
+        length: 0,
+      },
+
+      localPort: {
+        getter: "getLocalPort",
+      },
+      //   cork: {
+      //     fn: "cork",
+      //     length: 1,
+      //   },
+      data: {
+        getter: "getData",
+        cache: true,
+        setter: "setData",
+      },
+      readyState: {
+        getter: "getReadyState",
+      },
+
+      // topics: {
+      //   getter: "getTopics",
+      // },
+
+      remoteAddress: {
+        getter: "getRemoteAddress",
+        cache: true,
+      },
+
+      reload: {
+        fn: "reload",
+        length: 1,
+      },
+    },
+    finalize: true,
+    construct: true,
+    klass: {},
+  });
+}
+export default [
+  generate(true),
+  generate(false),
+  define({
+    name: "Listener",
+    JSType: "0b11101110",
+    proto: {
+      stop: {
+        fn: "stop",
+        length: 1,
+      },
+
+      ref: {
+        fn: "ref",
+        length: 0,
+      },
+      unref: {
+        fn: "unref",
+        length: 0,
+      },
+
+      port: {
+        getter: "getPort",
+      },
+
+      unix: {
+        getter: "getUnix",
+        cache: true,
+      },
+
+      reload: {
+        fn: "reload",
+        length: 1,
+      },
+
+      hostname: {
+        getter: "getHostname",
+        cache: true,
+      },
+
+      data: {
+        getter: "getData",
+        setter: "setData",
+      },
+    },
+    finalize: true,
+    construct: true,
+    klass: {},
+  }),
+];
diff --git a/src/bun.js/bindings/ZigGeneratedClasses+DOMClientIsoSubspaces.h b/src/bun.js/bindings/ZigGeneratedClasses+DOMClientIsoSubspaces.h
index 5014f0d4e..3ec74c09c 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses+DOMClientIsoSubspaces.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses+DOMClientIsoSubspaces.h
@@ -1,4 +1,7 @@
-std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForSubprocess;
+std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForTCPSocket;
+std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForTCPSocketConstructor;std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForTLSSocket;
+std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForTLSSocketConstructor;std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForListener;
+std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForListenerConstructor;std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForSubprocess;
 std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForSubprocessConstructor;std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForSHA1;
 std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForSHA1Constructor;std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMD5;
 std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMD5Constructor;std::unique_ptr<GCClient::IsoSubspace> m_clientSubspaceForMD4;
diff --git a/src/bun.js/bindings/ZigGeneratedClasses+DOMIsoSubspaces.h b/src/bun.js/bindings/ZigGeneratedClasses+DOMIsoSubspaces.h
index 149dfe8b8..11c6780ac 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses+DOMIsoSubspaces.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses+DOMIsoSubspaces.h
@@ -1,4 +1,7 @@
-std::unique_ptr<IsoSubspace> m_subspaceForSubprocess;
+std::unique_ptr<IsoSubspace> m_subspaceForTCPSocket;
+std::unique_ptr<IsoSubspace> m_subspaceForTCPSocketConstructor;std::unique_ptr<IsoSubspace> m_subspaceForTLSSocket;
+std::unique_ptr<IsoSubspace> m_subspaceForTLSSocketConstructor;std::unique_ptr<IsoSubspace> m_subspaceForListener;
+std::unique_ptr<IsoSubspace> m_subspaceForListenerConstructor;std::unique_ptr<IsoSubspace> m_subspaceForSubprocess;
 std::unique_ptr<IsoSubspace> m_subspaceForSubprocessConstructor;std::unique_ptr<IsoSubspace> m_subspaceForSHA1;
 std::unique_ptr<IsoSubspace> m_subspaceForSHA1Constructor;std::unique_ptr<IsoSubspace> m_subspaceForMD5;
 std::unique_ptr<IsoSubspace> m_subspaceForMD5Constructor;std::unique_ptr<IsoSubspace> m_subspaceForMD4;
diff --git a/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureHeader.h b/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureHeader.h
index 3de6262da..0ca7db3db 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureHeader.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureHeader.h
@@ -1,3 +1,21 @@
+JSC::Structure* JSTCPSocketStructure() { return m_JSTCPSocket.getInitializedOnMainThread(this); }
+        JSC::JSObject* JSTCPSocketConstructor() { return m_JSTCPSocket.constructorInitializedOnMainThread(this); }
+        JSC::JSValue JSTCPSocketPrototype() { return m_JSTCPSocket.prototypeInitializedOnMainThread(this); }
+  JSC::LazyClassStructure m_JSTCPSocket;
+  bool hasJSTCPSocketSetterValue { false };
+  mutable JSC::WriteBarrier<JSC::Unknown> m_JSTCPSocketSetterValue;
+JSC::Structure* JSTLSSocketStructure() { return m_JSTLSSocket.getInitializedOnMainThread(this); }
+        JSC::JSObject* JSTLSSocketConstructor() { return m_JSTLSSocket.constructorInitializedOnMainThread(this); }
+        JSC::JSValue JSTLSSocketPrototype() { return m_JSTLSSocket.prototypeInitializedOnMainThread(this); }
+  JSC::LazyClassStructure m_JSTLSSocket;
+  bool hasJSTLSSocketSetterValue { false };
+  mutable JSC::WriteBarrier<JSC::Unknown> m_JSTLSSocketSetterValue;
+JSC::Structure* JSListenerStructure() { return m_JSListener.getInitializedOnMainThread(this); }
+        JSC::JSObject* JSListenerConstructor() { return m_JSListener.constructorInitializedOnMainThread(this); }
+        JSC::JSValue JSListenerPrototype() { return m_JSListener.prototypeInitializedOnMainThread(this); }
+  JSC::LazyClassStructure m_JSListener;
+  bool hasJSListenerSetterValue { false };
+  mutable JSC::WriteBarrier<JSC::Unknown> m_JSListenerSetterValue;
 JSC::Structure* JSSubprocessStructure() { return m_JSSubprocess.getInitializedOnMainThread(this); }
         JSC::JSObject* JSSubprocessConstructor() { return m_JSSubprocess.constructorInitializedOnMainThread(this); }
         JSC::JSValue JSSubprocessPrototype() { return m_JSSubprocess.prototypeInitializedOnMainThread(this); }
diff --git a/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureImpl.h b/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureImpl.h
index e449c2904..b1144a1e8 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureImpl.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses+lazyStructureImpl.h
@@ -1,4 +1,22 @@
 void GlobalObject::initGeneratedLazyClasses() {
+    m_JSTCPSocket.initLater(
+              [](LazyClassStructure::Initializer& init) {
+                 init.setPrototype(WebCore::JSTCPSocket::createPrototype(init.vm, reinterpret_cast<Zig::GlobalObject*>(init.global)));
+                 init.setStructure(WebCore::JSTCPSocket::createStructure(init.vm, init.global, init.prototype));
+                 init.setConstructor(WebCore::JSTCPSocketConstructor::create(init.vm, init.global, WebCore::JSTCPSocketConstructor::createStructure(init.vm, init.global, init.global->functionPrototype()), jsCast<WebCore::JSTCPSocketPrototype*>(init.prototype)));
+              });
+    m_JSTLSSocket.initLater(
+              [](LazyClassStructure::Initializer& init) {
+                 init.setPrototype(WebCore::JSTLSSocket::createPrototype(init.vm, reinterpret_cast<Zig::GlobalObject*>(init.global)));
+                 init.setStructure(WebCore::JSTLSSocket::createStructure(init.vm, init.global, init.prototype));
+                 init.setConstructor(WebCore::JSTLSSocketConstructor::create(init.vm, init.global, WebCore::JSTLSSocketConstructor::createStructure(init.vm, init.global, init.global->functionPrototype()), jsCast<WebCore::JSTLSSocketPrototype*>(init.prototype)));
+              });
+    m_JSListener.initLater(
+              [](LazyClassStructure::Initializer& init) {
+                 init.setPrototype(WebCore::JSListener::createPrototype(init.vm, reinterpret_cast<Zig::GlobalObject*>(init.global)));
+                 init.setStructure(WebCore::JSListener::createStructure(init.vm, init.global, init.prototype));
+                 init.setConstructor(WebCore::JSListenerConstructor::create(init.vm, init.global, WebCore::JSListenerConstructor::createStructure(init.vm, init.global, init.global->functionPrototype()), jsCast<WebCore::JSListenerPrototype*>(init.prototype)));
+              });
     m_JSSubprocess.initLater(
               [](LazyClassStructure::Initializer& init) {
                  init.setPrototype(WebCore::JSSubprocess::createPrototype(init.vm, reinterpret_cast<Zig::GlobalObject*>(init.global)));
@@ -87,6 +105,9 @@ void GlobalObject::initGeneratedLazyClasses() {
 template<typename Visitor>
 void GlobalObject::visitGeneratedLazyClasses(GlobalObject *thisObject, Visitor& visitor)
 {
+      thisObject->m_JSTCPSocket.visit(visitor);  visitor.append(thisObject->m_JSTCPSocketSetterValue);
+      thisObject->m_JSTLSSocket.visit(visitor);  visitor.append(thisObject->m_JSTLSSocketSetterValue);
+      thisObject->m_JSListener.visit(visitor);  visitor.append(thisObject->m_JSListenerSetterValue);
       thisObject->m_JSSubprocess.visit(visitor);  visitor.append(thisObject->m_JSSubprocessSetterValue);
       thisObject->m_JSSHA1.visit(visitor);  visitor.append(thisObject->m_JSSHA1SetterValue);
       thisObject->m_JSMD5.visit(visitor);  visitor.append(thisObject->m_JSMD5SetterValue);
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.cpp b/src/bun.js/bindings/ZigGeneratedClasses.cpp
index 26fcec7b6..fad332acc 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.cpp
+++ b/src/bun.js/bindings/ZigGeneratedClasses.cpp
@@ -23,7 +23,1371 @@ namespace WebCore {
 using namespace JSC;
 using namespace Zig;
 
-extern "C" void* SubprocessClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+extern "C" void* TCPSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTCPSocketConstructor);
+extern "C" void TCPSocketClass__finalize(void*);
+
+extern "C" JSC::EncodedJSValue TCPSocketPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__dataGetterWrap);
+
+
+extern "C" bool TCPSocketPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
+JSC_DECLARE_CUSTOM_SETTER(TCPSocketPrototype__dataSetterWrap);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__end(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__endCallback);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__flush(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__flushCallback);
+
+
+extern "C" JSC::EncodedJSValue TCPSocketPrototype__getListener(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__listenerGetterWrap);
+
+
+extern "C" JSC::EncodedJSValue TCPSocketPrototype__getLocalPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__localPortGetterWrap);
+
+
+extern "C" JSC::EncodedJSValue TCPSocketPrototype__getReadyState(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__readyStateGetterWrap);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__ref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__refCallback);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__reloadCallback);
+
+
+extern "C" JSC::EncodedJSValue TCPSocketPrototype__getRemoteAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TCPSocketPrototype__remoteAddressGetterWrap);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__shutdown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__shutdownCallback);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__timeout(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__timeoutCallback);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__unref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__unrefCallback);
+
+
+extern "C" EncodedJSValue TCPSocketPrototype__write(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TCPSocketPrototype__writeCallback);
+
+
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTCPSocketPrototype, JSTCPSocketPrototype::Base);
+
+
+  static const HashTableValue JSTCPSocketPrototypeTableValues[] = {
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__dataGetterWrap, TCPSocketPrototype__dataSetterWrap } }  ,
+{ "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__endCallback, 3 } }  ,
+{ "flush"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__flushCallback, 0 } }  ,
+{ "listener"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__listenerGetterWrap, 0 } }  ,
+{ "localPort"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__localPortGetterWrap, 0 } }  ,
+{ "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__readyStateGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__refCallback, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__reloadCallback, 1 } }  ,
+{ "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TCPSocketPrototype__remoteAddressGetterWrap, 0 } }  ,
+{ "shutdown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__shutdownCallback, 1 } }  ,
+{ "timeout"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__timeoutCallback, 1 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__unrefCallback, 0 } }  ,
+{ "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TCPSocketPrototype__writeCallback, 3 } }
+  };
+
+
+
+const ClassInfo JSTCPSocketPrototype::s_info = { "TCPSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTCPSocketPrototype) };
+
+
+
+JSC_DEFINE_CUSTOM_GETTER(jsTCPSocketConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto* prototype = jsDynamicCast<JSTCPSocketPrototype*>(JSValue::decode(thisValue));
+
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(globalObject->JSTCPSocketConstructor());
+}    
+    
+
+
+JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    if (JSValue cachedValue = thisObject->m_data.get())
+        return JSValue::encode(cachedValue);
+    
+    JSC::JSValue result = JSC::JSValue::decode(
+        TCPSocketPrototype__getData(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_data.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+extern "C" void TCPSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+    thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
+}
+
+
+JSC_DEFINE_CUSTOM_SETTER(TCPSocketPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    auto result = TCPSocketPrototype__setData(thisObject->wrapped(), lexicalGlobalObject, encodedValue);
+
+    RELEASE_AND_RETURN(throwScope, result);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__endCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__end(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__flushCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__flush(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__listenerGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = TCPSocketPrototype__getListener(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__localPortGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = TCPSocketPrototype__getLocalPort(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__readyStateGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = TCPSocketPrototype__getReadyState(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(TCPSocketPrototype__remoteAddressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    if (JSValue cachedValue = thisObject->m_remoteAddress.get())
+        return JSValue::encode(cachedValue);
+    
+    JSC::JSValue result = JSC::JSValue::decode(
+        TCPSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_remoteAddress.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+extern "C" void TCPSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSTCPSocket*>(JSValue::decode(thisValue));
+    thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__shutdownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__shutdown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__timeoutCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__timeout(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TCPSocketPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTCPSocket* thisObject = jsDynamicCast<JSTCPSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TCPSocketPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+void JSTCPSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSTCPSocket::info(), JSTCPSocketPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSTCPSocketConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSTCPSocketPrototype* prototype)
+{
+    Base::finishCreation(vm, 0, "TCPSocket"_s, PropertyAdditionMode::WithoutStructureTransition);
+    
+    putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    ASSERT(inherits(info()));
+}
+
+JSTCPSocketConstructor* JSTCPSocketConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTCPSocketPrototype* prototype) {
+    JSTCPSocketConstructor* ptr = new (NotNull, JSC::allocateCell<JSTCPSocketConstructor>(vm)) JSTCPSocketConstructor(vm, structure, construct);
+    ptr->finishCreation(vm, globalObject, prototype);
+    return ptr;
+}
+
+JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSTCPSocketConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
+{
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
+    JSObject* newTarget = asObject(callFrame->newTarget());
+    auto* constructor = globalObject->JSTCPSocketConstructor();
+    Structure* structure = globalObject->JSTCPSocketStructure();
+    if (constructor != newTarget) {
+      auto scope = DECLARE_THROW_SCOPE(vm);
+
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSTCPSocketStructure()
+      );
+    }
+
+    void* ptr = TCPSocketClass__construct(globalObject, callFrame);
+
+    if (UNLIKELY(!ptr)) {
+      return JSValue::encode(JSC::jsUndefined());
+    }
+
+    JSTCPSocket* instance = JSTCPSocket::create(vm, globalObject, structure, ptr);
+  
+
+    return JSValue::encode(instance);
+}
+
+extern "C" EncodedJSValue TCPSocket__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTCPSocketStructure();
+  JSTCPSocket* instance = JSTCPSocket::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+
+void JSTCPSocketConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSTCPSocketPrototype* prototype)
+{
+
+}
+
+const ClassInfo JSTCPSocketConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTCPSocketConstructor) };
+
+
+  extern "C" EncodedJSValue TCPSocket__getConstructor(Zig::GlobalObject* globalObject) {
+    return JSValue::encode(globalObject->JSTCPSocketConstructor());
+  }
+
+JSTCPSocket::~JSTCPSocket()
+{
+    if (m_ctx) {
+        TCPSocketClass__finalize(m_ctx);
+    }
+}
+void JSTCPSocket::destroy(JSCell* cell)
+{
+    static_cast<JSTCPSocket*>(cell)->JSTCPSocket::~JSTCPSocket();
+}
+  
+const ClassInfo JSTCPSocket::s_info = { "TCPSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTCPSocket) };
+
+void JSTCPSocket::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+JSTCPSocket* JSTCPSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTCPSocket* ptr = new (NotNull, JSC::allocateCell<JSTCPSocket>(vm)) JSTCPSocket(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
+
+extern "C" void* TCPSocket__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSTCPSocket* object = JSC::jsDynamicCast<JSTCPSocket*>(decodedValue);
+
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
+}
+
+extern "C" bool TCPSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTCPSocket* object = JSC::jsDynamicCast<JSTCPSocket*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
+}
+
+
+extern "C" const size_t TCPSocket__ptrOffset = JSTCPSocket::offsetOfWrapped();
+
+void JSTCPSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSTCPSocket*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+JSObject* JSTCPSocket::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
+{
+    return JSTCPSocketPrototype::create(vm, globalObject, JSTCPSocketPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+}
+      
+template<typename Visitor>
+void JSTCPSocket::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    JSTCPSocket* thisObject = jsCast<JSTCPSocket*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    
+    
+    visitor.append(thisObject->m_data);
+    visitor.append(thisObject->m_remoteAddress);
+}
+
+DEFINE_VISIT_CHILDREN(JSTCPSocket);extern "C" void* TLSSocketClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsTLSSocketConstructor);
+extern "C" void TLSSocketClass__finalize(void*);
+
+extern "C" JSC::EncodedJSValue TLSSocketPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__dataGetterWrap);
+
+
+extern "C" bool TLSSocketPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
+JSC_DECLARE_CUSTOM_SETTER(TLSSocketPrototype__dataSetterWrap);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__end(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__endCallback);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__flush(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__flushCallback);
+
+
+extern "C" JSC::EncodedJSValue TLSSocketPrototype__getListener(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__listenerGetterWrap);
+
+
+extern "C" JSC::EncodedJSValue TLSSocketPrototype__getLocalPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__localPortGetterWrap);
+
+
+extern "C" JSC::EncodedJSValue TLSSocketPrototype__getReadyState(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__readyStateGetterWrap);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__ref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__refCallback);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__reloadCallback);
+
+
+extern "C" JSC::EncodedJSValue TLSSocketPrototype__getRemoteAddress(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(TLSSocketPrototype__remoteAddressGetterWrap);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__shutdown(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__shutdownCallback);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__timeout(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__timeoutCallback);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__unref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__unrefCallback);
+
+
+extern "C" EncodedJSValue TLSSocketPrototype__write(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(TLSSocketPrototype__writeCallback);
+
+
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSTLSSocketPrototype, JSTLSSocketPrototype::Base);
+
+
+  static const HashTableValue JSTLSSocketPrototypeTableValues[] = {
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__dataGetterWrap, TLSSocketPrototype__dataSetterWrap } }  ,
+{ "end"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__endCallback, 3 } }  ,
+{ "flush"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__flushCallback, 0 } }  ,
+{ "listener"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__listenerGetterWrap, 0 } }  ,
+{ "localPort"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__localPortGetterWrap, 0 } }  ,
+{ "readyState"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__readyStateGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__refCallback, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__reloadCallback, 1 } }  ,
+{ "remoteAddress"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, TLSSocketPrototype__remoteAddressGetterWrap, 0 } }  ,
+{ "shutdown"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__shutdownCallback, 1 } }  ,
+{ "timeout"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__timeoutCallback, 1 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__unrefCallback, 0 } }  ,
+{ "write"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, TLSSocketPrototype__writeCallback, 3 } }
+  };
+
+
+
+const ClassInfo JSTLSSocketPrototype::s_info = { "TLSSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTLSSocketPrototype) };
+
+
+
+JSC_DEFINE_CUSTOM_GETTER(jsTLSSocketConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto* prototype = jsDynamicCast<JSTLSSocketPrototype*>(JSValue::decode(thisValue));
+
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(globalObject->JSTLSSocketConstructor());
+}    
+    
+
+
+JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    if (JSValue cachedValue = thisObject->m_data.get())
+        return JSValue::encode(cachedValue);
+    
+    JSC::JSValue result = JSC::JSValue::decode(
+        TLSSocketPrototype__getData(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_data.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+extern "C" void TLSSocketPrototype__dataSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+    thisObject->m_data.set(vm, thisObject, JSValue::decode(value));
+}
+
+
+JSC_DEFINE_CUSTOM_SETTER(TLSSocketPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    auto result = TLSSocketPrototype__setData(thisObject->wrapped(), lexicalGlobalObject, encodedValue);
+
+    RELEASE_AND_RETURN(throwScope, result);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__endCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__end(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__flushCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__flush(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__listenerGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = TLSSocketPrototype__getListener(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__localPortGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = TLSSocketPrototype__getLocalPort(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__readyStateGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = TLSSocketPrototype__getReadyState(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(TLSSocketPrototype__remoteAddressGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    if (JSValue cachedValue = thisObject->m_remoteAddress.get())
+        return JSValue::encode(cachedValue);
+    
+    JSC::JSValue result = JSC::JSValue::decode(
+        TLSSocketPrototype__getRemoteAddress(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_remoteAddress.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+extern "C" void TLSSocketPrototype__remoteAddressSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSTLSSocket*>(JSValue::decode(thisValue));
+    thisObject->m_remoteAddress.set(vm, thisObject, JSValue::decode(value));
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__shutdownCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__shutdown(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__timeoutCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__timeout(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(TLSSocketPrototype__writeCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSTLSSocket* thisObject = jsDynamicCast<JSTLSSocket*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return TLSSocketPrototype__write(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+void JSTLSSocketPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSTLSSocket::info(), JSTLSSocketPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSTLSSocketConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSTLSSocketPrototype* prototype)
+{
+    Base::finishCreation(vm, 0, "TLSSocket"_s, PropertyAdditionMode::WithoutStructureTransition);
+    
+    putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    ASSERT(inherits(info()));
+}
+
+JSTLSSocketConstructor* JSTLSSocketConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTLSSocketPrototype* prototype) {
+    JSTLSSocketConstructor* ptr = new (NotNull, JSC::allocateCell<JSTLSSocketConstructor>(vm)) JSTLSSocketConstructor(vm, structure, construct);
+    ptr->finishCreation(vm, globalObject, prototype);
+    return ptr;
+}
+
+JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSTLSSocketConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
+{
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
+    JSObject* newTarget = asObject(callFrame->newTarget());
+    auto* constructor = globalObject->JSTLSSocketConstructor();
+    Structure* structure = globalObject->JSTLSSocketStructure();
+    if (constructor != newTarget) {
+      auto scope = DECLARE_THROW_SCOPE(vm);
+
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSTLSSocketStructure()
+      );
+    }
+
+    void* ptr = TLSSocketClass__construct(globalObject, callFrame);
+
+    if (UNLIKELY(!ptr)) {
+      return JSValue::encode(JSC::jsUndefined());
+    }
+
+    JSTLSSocket* instance = JSTLSSocket::create(vm, globalObject, structure, ptr);
+  
+
+    return JSValue::encode(instance);
+}
+
+extern "C" EncodedJSValue TLSSocket__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSTLSSocketStructure();
+  JSTLSSocket* instance = JSTLSSocket::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+
+void JSTLSSocketConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSTLSSocketPrototype* prototype)
+{
+
+}
+
+const ClassInfo JSTLSSocketConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTLSSocketConstructor) };
+
+
+  extern "C" EncodedJSValue TLSSocket__getConstructor(Zig::GlobalObject* globalObject) {
+    return JSValue::encode(globalObject->JSTLSSocketConstructor());
+  }
+
+JSTLSSocket::~JSTLSSocket()
+{
+    if (m_ctx) {
+        TLSSocketClass__finalize(m_ctx);
+    }
+}
+void JSTLSSocket::destroy(JSCell* cell)
+{
+    static_cast<JSTLSSocket*>(cell)->JSTLSSocket::~JSTLSSocket();
+}
+  
+const ClassInfo JSTLSSocket::s_info = { "TLSSocket"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSTLSSocket) };
+
+void JSTLSSocket::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+JSTLSSocket* JSTLSSocket::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSTLSSocket* ptr = new (NotNull, JSC::allocateCell<JSTLSSocket>(vm)) JSTLSSocket(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
+
+extern "C" void* TLSSocket__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSTLSSocket* object = JSC::jsDynamicCast<JSTLSSocket*>(decodedValue);
+
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
+}
+
+extern "C" bool TLSSocket__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSTLSSocket* object = JSC::jsDynamicCast<JSTLSSocket*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
+}
+
+
+extern "C" const size_t TLSSocket__ptrOffset = JSTLSSocket::offsetOfWrapped();
+
+void JSTLSSocket::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSTLSSocket*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+JSObject* JSTLSSocket::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
+{
+    return JSTLSSocketPrototype::create(vm, globalObject, JSTLSSocketPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+}
+      
+template<typename Visitor>
+void JSTLSSocket::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    JSTLSSocket* thisObject = jsCast<JSTLSSocket*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    
+    
+    visitor.append(thisObject->m_data);
+    visitor.append(thisObject->m_remoteAddress);
+}
+
+DEFINE_VISIT_CHILDREN(JSTLSSocket);extern "C" void* ListenerClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+JSC_DECLARE_CUSTOM_GETTER(jsListenerConstructor);
+extern "C" void ListenerClass__finalize(void*);
+
+extern "C" JSC::EncodedJSValue ListenerPrototype__getData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__dataGetterWrap);
+
+
+extern "C" bool ListenerPrototype__setData(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::EncodedJSValue value);
+JSC_DECLARE_CUSTOM_SETTER(ListenerPrototype__dataSetterWrap);
+
+
+extern "C" JSC::EncodedJSValue ListenerPrototype__getHostname(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__hostnameGetterWrap);
+
+
+extern "C" JSC::EncodedJSValue ListenerPrototype__getPort(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__portGetterWrap);
+
+
+extern "C" EncodedJSValue ListenerPrototype__ref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__refCallback);
+
+
+extern "C" EncodedJSValue ListenerPrototype__reload(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__reloadCallback);
+
+
+extern "C" EncodedJSValue ListenerPrototype__stop(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__stopCallback);
+
+
+extern "C" JSC::EncodedJSValue ListenerPrototype__getUnix(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject);
+JSC_DECLARE_CUSTOM_GETTER(ListenerPrototype__unixGetterWrap);
+
+
+extern "C" EncodedJSValue ListenerPrototype__unref(void* ptr, JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame);
+JSC_DECLARE_HOST_FUNCTION(ListenerPrototype__unrefCallback);
+
+
+STATIC_ASSERT_ISO_SUBSPACE_SHARABLE(JSListenerPrototype, JSListenerPrototype::Base);
+
+
+  static const HashTableValue JSListenerPrototypeTableValues[] = {
+{ "data"_s, static_cast<unsigned>(JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__dataGetterWrap, ListenerPrototype__dataSetterWrap } }  ,
+{ "hostname"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__hostnameGetterWrap, 0 } }  ,
+{ "port"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__portGetterWrap, 0 } }  ,
+{ "ref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__refCallback, 0 } }  ,
+{ "reload"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__reloadCallback, 1 } }  ,
+{ "stop"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__stopCallback, 1 } }  ,
+{ "unix"_s, static_cast<unsigned>(JSC::PropertyAttribute::ReadOnly | JSC::PropertyAttribute::CustomAccessor | JSC::PropertyAttribute::DOMAttribute), NoIntrinsic, { HashTableValue::GetterSetterType, ListenerPrototype__unixGetterWrap, 0 } }  ,
+{ "unref"_s, static_cast<unsigned>(JSC::PropertyAttribute::Function), NoIntrinsic, { HashTableValue::NativeFunctionType, ListenerPrototype__unrefCallback, 0 } }
+  };
+
+
+
+const ClassInfo JSListenerPrototype::s_info = { "Listener"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSListenerPrototype) };
+
+
+
+JSC_DEFINE_CUSTOM_GETTER(jsListenerConstructor, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName))
+{
+    VM& vm = JSC::getVM(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    auto* globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto* prototype = jsDynamicCast<JSListenerPrototype*>(JSValue::decode(thisValue));
+
+    if (UNLIKELY(!prototype))
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    return JSValue::encode(globalObject->JSListenerConstructor());
+}    
+    
+
+
+JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__dataGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = ListenerPrototype__getData(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_CUSTOM_SETTER(ListenerPrototype__dataSetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, EncodedJSValue encodedValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    auto result = ListenerPrototype__setData(thisObject->wrapped(), lexicalGlobalObject, encodedValue);
+
+    RELEASE_AND_RETURN(throwScope, result);
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__hostnameGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    if (JSValue cachedValue = thisObject->m_hostname.get())
+        return JSValue::encode(cachedValue);
+    
+    JSC::JSValue result = JSC::JSValue::decode(
+        ListenerPrototype__getHostname(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_hostname.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+extern "C" void ListenerPrototype__hostnameSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+    thisObject->m_hostname.set(vm, thisObject, JSValue::decode(value));
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__portGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    JSC::EncodedJSValue result = ListenerPrototype__getPort(thisObject->wrapped(), globalObject);
+    RETURN_IF_EXCEPTION(throwScope, {});
+    RELEASE_AND_RETURN(throwScope, result);
+}
+        
+
+JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__refCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return ListenerPrototype__ref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__reloadCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return ListenerPrototype__reload(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__stopCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return ListenerPrototype__stop(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+JSC_DEFINE_CUSTOM_GETTER(ListenerPrototype__unixGetterWrap, (JSGlobalObject * lexicalGlobalObject, EncodedJSValue thisValue, PropertyName attributeName))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    auto throwScope = DECLARE_THROW_SCOPE(vm);
+    JSListener* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+      JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    if (JSValue cachedValue = thisObject->m_unix.get())
+        return JSValue::encode(cachedValue);
+    
+    JSC::JSValue result = JSC::JSValue::decode(
+        ListenerPrototype__getUnix(thisObject->wrapped(), globalObject)
+    );
+    RETURN_IF_EXCEPTION(throwScope, {});
+    thisObject->m_unix.set(vm, thisObject, result);
+    RELEASE_AND_RETURN(throwScope, JSValue::encode(result));
+}
+extern "C" void ListenerPrototype__unixSetCachedValue(JSC::EncodedJSValue thisValue, JSC::JSGlobalObject *globalObject, JSC::EncodedJSValue value)
+{
+    auto& vm = globalObject->vm();
+    auto* thisObject = jsCast<JSListener*>(JSValue::decode(thisValue));
+    thisObject->m_unix.set(vm, thisObject, JSValue::decode(value));
+}
+
+
+JSC_DEFINE_HOST_FUNCTION(ListenerPrototype__unrefCallback, (JSGlobalObject * lexicalGlobalObject, CallFrame* callFrame))
+{
+    auto& vm = lexicalGlobalObject->vm();
+    
+    JSListener* thisObject = jsDynamicCast<JSListener*>(callFrame->thisValue());
+
+    if (UNLIKELY(!thisObject)) {
+        auto throwScope = DECLARE_THROW_SCOPE(vm);
+        return throwVMTypeError(lexicalGlobalObject, throwScope);
+    }
+
+    JSC::EnsureStillAliveScope thisArg = JSC::EnsureStillAliveScope(thisObject);
+    
+    return ListenerPrototype__unref(thisObject->wrapped(), lexicalGlobalObject, callFrame);
+}
+
+
+void JSListenerPrototype::finishCreation(JSC::VM& vm, JSC::JSGlobalObject* globalObject)
+{
+    Base::finishCreation(vm);
+    reifyStaticProperties(vm, JSListener::info(), JSListenerPrototypeTableValues, *this);
+    JSC_TO_STRING_TAG_WITHOUT_TRANSITION();
+}
+
+void JSListenerConstructor::finishCreation(VM& vm, JSC::JSGlobalObject* globalObject, JSListenerPrototype* prototype)
+{
+    Base::finishCreation(vm, 0, "Listener"_s, PropertyAdditionMode::WithoutStructureTransition);
+    
+    putDirectWithoutTransition(vm, vm.propertyNames->prototype, prototype, PropertyAttribute::DontEnum | PropertyAttribute::DontDelete | PropertyAttribute::ReadOnly);
+    ASSERT(inherits(info()));
+}
+
+JSListenerConstructor* JSListenerConstructor::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSListenerPrototype* prototype) {
+    JSListenerConstructor* ptr = new (NotNull, JSC::allocateCell<JSListenerConstructor>(vm)) JSListenerConstructor(vm, structure, construct);
+    ptr->finishCreation(vm, globalObject, prototype);
+    return ptr;
+}
+
+JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES JSListenerConstructor::construct(JSC::JSGlobalObject* lexicalGlobalObject, JSC::CallFrame* callFrame)
+{
+    Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject*>(lexicalGlobalObject);
+    JSC::VM &vm = globalObject->vm();
+    JSObject* newTarget = asObject(callFrame->newTarget());
+    auto* constructor = globalObject->JSListenerConstructor();
+    Structure* structure = globalObject->JSListenerStructure();
+    if (constructor != newTarget) {
+      auto scope = DECLARE_THROW_SCOPE(vm);
+
+      auto* functionGlobalObject = reinterpret_cast<Zig::GlobalObject*>(
+        // ShadowRealm functions belong to a different global object.
+        getFunctionRealm(globalObject, newTarget)
+      );
+      RETURN_IF_EXCEPTION(scope, {});
+      structure = InternalFunction::createSubclassStructure(
+        globalObject,
+        newTarget,
+        functionGlobalObject->JSListenerStructure()
+      );
+    }
+
+    void* ptr = ListenerClass__construct(globalObject, callFrame);
+
+    if (UNLIKELY(!ptr)) {
+      return JSValue::encode(JSC::jsUndefined());
+    }
+
+    JSListener* instance = JSListener::create(vm, globalObject, structure, ptr);
+  
+
+    return JSValue::encode(instance);
+}
+
+extern "C" EncodedJSValue Listener__create(Zig::GlobalObject* globalObject, void* ptr) {
+  auto &vm = globalObject->vm();
+  JSC::Structure* structure = globalObject->JSListenerStructure();
+  JSListener* instance = JSListener::create(vm, globalObject, structure, ptr);
+  
+  return JSValue::encode(instance);
+}
+
+void JSListenerConstructor::initializeProperties(VM& vm, JSC::JSGlobalObject* globalObject, JSListenerPrototype* prototype)
+{
+
+}
+
+const ClassInfo JSListenerConstructor::s_info = { "Function"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSListenerConstructor) };
+
+
+  extern "C" EncodedJSValue Listener__getConstructor(Zig::GlobalObject* globalObject) {
+    return JSValue::encode(globalObject->JSListenerConstructor());
+  }
+
+JSListener::~JSListener()
+{
+    if (m_ctx) {
+        ListenerClass__finalize(m_ctx);
+    }
+}
+void JSListener::destroy(JSCell* cell)
+{
+    static_cast<JSListener*>(cell)->JSListener::~JSListener();
+}
+  
+const ClassInfo JSListener::s_info = { "Listener"_s, &Base::s_info, nullptr, nullptr, CREATE_METHOD_TABLE(JSListener) };
+
+void JSListener::finishCreation(VM& vm)
+{
+    Base::finishCreation(vm);
+    ASSERT(inherits(info()));
+}
+
+JSListener* JSListener::create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx) {
+  JSListener* ptr = new (NotNull, JSC::allocateCell<JSListener>(vm)) JSListener(vm, structure, ctx);
+  ptr->finishCreation(vm);
+  return ptr;
+}
+
+extern "C" void* Listener__fromJS(JSC::EncodedJSValue value) {
+  JSC::JSValue decodedValue = JSC::JSValue::decode(value);
+  if (!decodedValue || decodedValue.isUndefinedOrNull()) 
+    return nullptr;
+
+  JSListener* object = JSC::jsDynamicCast<JSListener*>(decodedValue);
+
+  if (!object)
+      return nullptr;
+      
+  return object->wrapped();
+}
+
+extern "C" bool Listener__dangerouslySetPtr(JSC::EncodedJSValue value, void* ptr) {
+  JSListener* object = JSC::jsDynamicCast<JSListener*>(JSValue::decode(value));
+  if (!object)
+      return false;
+  
+  object->m_ctx = ptr;
+  return true;
+}
+
+
+extern "C" const size_t Listener__ptrOffset = JSListener::offsetOfWrapped();
+
+void JSListener::analyzeHeap(JSCell* cell, HeapAnalyzer& analyzer)
+{
+    auto* thisObject = jsCast<JSListener*>(cell);
+    if (void* wrapped = thisObject->wrapped()) {
+        // if (thisObject->scriptExecutionContext())
+        //     analyzer.setLabelForCell(cell, "url " + thisObject->scriptExecutionContext()->url().string());
+    }
+    Base::analyzeHeap(cell, analyzer);
+}
+
+JSObject* JSListener::createPrototype(VM& vm, JSDOMGlobalObject* globalObject)
+{
+    return JSListenerPrototype::create(vm, globalObject, JSListenerPrototype::createStructure(vm, globalObject, globalObject->objectPrototype()));
+}
+      
+template<typename Visitor>
+void JSListener::visitChildrenImpl(JSCell* cell, Visitor& visitor)
+{
+    JSListener* thisObject = jsCast<JSListener*>(cell);
+    ASSERT_GC_OBJECT_INHERITS(thisObject, info());
+    Base::visitChildren(thisObject, visitor);
+    
+    
+    visitor.append(thisObject->m_hostname);
+    visitor.append(thisObject->m_unix);
+}
+
+DEFINE_VISIT_CHILDREN(JSListener);extern "C" void* SubprocessClass__construct(JSC::JSGlobalObject*, JSC::CallFrame*);
 JSC_DECLARE_CUSTOM_GETTER(jsSubprocessConstructor);
 extern "C" void SubprocessClass__finalize(void*);
 
diff --git a/src/bun.js/bindings/ZigGeneratedClasses.h b/src/bun.js/bindings/ZigGeneratedClasses.h
index 45e47f81a..c344437cc 100644
--- a/src/bun.js/bindings/ZigGeneratedClasses.h
+++ b/src/bun.js/bindings/ZigGeneratedClasses.h
@@ -15,6 +15,381 @@ namespace WebCore {
 using namespace Zig;
 using namespace JSC;
 
+class JSTCPSocket final : public JSC::JSDestructibleObject {
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTCPSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTCPSocket, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTCPSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTCPSocket = WTFMove(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTCPSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTCPSocket = WTFMove(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+    
+        ~JSTCPSocket();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTCPSocket, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTCPSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+        }
+    
+        void finishCreation(JSC::VM&);
+
+        DECLARE_VISIT_CHILDREN;
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
+    };
+class JSTCPSocketPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTCPSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTCPSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSTCPSocketPrototype>(vm)) JSTCPSocketPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTCPSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
+    
+  class JSTCPSocketConstructor final : public JSC::InternalFunction {
+    public:
+        using Base = JSC::InternalFunction;
+        static JSTCPSocketConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTCPSocketPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTCPSocketConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTCPSocketConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTCPSocketConstructor = WTFMove(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTCPSocketConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTCPSocketConstructor = WTFMove(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSTCPSocketPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+        DECLARE_EXPORT_INFO;
+    private:
+        JSTCPSocketConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)
+            : Base(vm, structure, nativeFunction, nativeFunction)
+    
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSTCPSocketPrototype* prototype);
+    };
+class JSTLSSocket final : public JSC::JSDestructibleObject {
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSTLSSocket* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTLSSocket, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTLSSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTLSSocket = WTFMove(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTLSSocket.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTLSSocket = WTFMove(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+    
+        ~JSTLSSocket();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSTLSSocket, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSTLSSocket(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+        }
+    
+        void finishCreation(JSC::VM&);
+
+        DECLARE_VISIT_CHILDREN;
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_data;
+mutable JSC::WriteBarrier<JSC::Unknown> m_remoteAddress;
+    };
+class JSTLSSocketPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSTLSSocketPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSTLSSocketPrototype* ptr = new (NotNull, JSC::allocateCell<JSTLSSocketPrototype>(vm)) JSTLSSocketPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSTLSSocketPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
+    
+  class JSTLSSocketConstructor final : public JSC::InternalFunction {
+    public:
+        using Base = JSC::InternalFunction;
+        static JSTLSSocketConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSTLSSocketPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSTLSSocketConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForTLSSocketConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForTLSSocketConstructor = WTFMove(space); },
+                [](auto& spaces) { return spaces.m_subspaceForTLSSocketConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForTLSSocketConstructor = WTFMove(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSTLSSocketPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+        DECLARE_EXPORT_INFO;
+    private:
+        JSTLSSocketConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)
+            : Base(vm, structure, nativeFunction, nativeFunction)
+    
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSTLSSocketPrototype* prototype);
+    };
+class JSListener final : public JSC::JSDestructibleObject {
+    public:
+        using Base = JSC::JSDestructibleObject;
+        static JSListener* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, void* ctx);
+    
+        DECLARE_EXPORT_INFO;
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSListener, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForListener.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForListener = WTFMove(space); },
+                [](auto& spaces) { return spaces.m_subspaceForListener.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForListener = WTFMove(space); });
+        }
+    
+        static void destroy(JSC::JSCell*);
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(static_cast<JSC::JSType>(0b11101110), StructureFlags), info());
+        }
+    
+        static JSObject* createPrototype(VM& vm, JSDOMGlobalObject* globalObject);
+    
+        ~JSListener();
+    
+        void* wrapped() const { return m_ctx; }
+    
+        void detach()
+        {
+            m_ctx = nullptr;
+        }
+    
+        static void analyzeHeap(JSCell*, JSC::HeapAnalyzer&);
+        static ptrdiff_t offsetOfWrapped() { return OBJECT_OFFSETOF(JSListener, m_ctx); }
+    
+        void* m_ctx { nullptr };
+
+            
+        JSListener(JSC::VM& vm, JSC::Structure* structure, void* sinkPtr)
+            : Base(vm, structure)
+        {
+            m_ctx = sinkPtr;
+        }
+    
+        void finishCreation(JSC::VM&);
+
+        DECLARE_VISIT_CHILDREN;
+
+        mutable JSC::WriteBarrier<JSC::Unknown> m_hostname;
+mutable JSC::WriteBarrier<JSC::Unknown> m_unix;
+    };
+class JSListenerPrototype final : public JSC::JSNonFinalObject {
+    public:
+        using Base = JSC::JSNonFinalObject;
+    
+        static JSListenerPrototype* create(JSC::VM& vm, JSGlobalObject* globalObject, JSC::Structure* structure)
+        {
+            JSListenerPrototype* ptr = new (NotNull, JSC::allocateCell<JSListenerPrototype>(vm)) JSListenerPrototype(vm, globalObject, structure);
+            ptr->finishCreation(vm, globalObject);
+            return ptr;
+        }
+    
+        DECLARE_INFO;
+        template<typename CellType, JSC::SubspaceAccess>
+        static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            return &vm.plainObjectSpace();
+        }
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::ObjectType, StructureFlags), info());
+        }
+    
+    private:
+        JSListenerPrototype(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure)
+            : Base(vm, structure)
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject*);
+    };
+    
+  class JSListenerConstructor final : public JSC::InternalFunction {
+    public:
+        using Base = JSC::InternalFunction;
+        static JSListenerConstructor* create(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::Structure* structure, JSListenerPrototype* prototype);
+    
+        static constexpr unsigned StructureFlags = Base::StructureFlags;
+        static constexpr bool needsDestruction = false;
+    
+        static JSC::Structure* createStructure(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSC::JSValue prototype)
+        {
+            return JSC::Structure::create(vm, globalObject, prototype, JSC::TypeInfo(JSC::InternalFunctionType, StructureFlags), info());
+        }
+
+        template<typename, JSC::SubspaceAccess mode> static JSC::GCClient::IsoSubspace* subspaceFor(JSC::VM& vm)
+        {
+            if constexpr (mode == JSC::SubspaceAccess::Concurrently)
+                return nullptr;
+            return WebCore::subspaceForImpl<JSListenerConstructor, WebCore::UseCustomHeapCellType::No>(
+                vm,
+                [](auto& spaces) { return spaces.m_clientSubspaceForListenerConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_clientSubspaceForListenerConstructor = WTFMove(space); },
+                [](auto& spaces) { return spaces.m_subspaceForListenerConstructor.get(); },
+                [](auto& spaces, auto&& space) { spaces.m_subspaceForListenerConstructor = WTFMove(space); });
+        }
+    
+
+        void initializeProperties(JSC::VM& vm, JSC::JSGlobalObject* globalObject, JSListenerPrototype* prototype);
+    
+        // Must be defined for each specialization class.
+        static JSC::EncodedJSValue JSC_HOST_CALL_ATTRIBUTES construct(JSC::JSGlobalObject*, JSC::CallFrame*);
+        DECLARE_EXPORT_INFO;
+    private:
+        JSListenerConstructor(JSC::VM& vm, JSC::Structure* structure, JSC::NativeFunction nativeFunction)
+            : Base(vm, structure, nativeFunction, nativeFunction)
+    
+        {
+        }
+    
+        void finishCreation(JSC::VM&, JSC::JSGlobalObject* globalObject, JSListenerPrototype* prototype);
+    };
 class JSSubprocess final : public JSC::JSDestructibleObject {
     public:
         using Base = JSC::JSDestructibleObject;
diff --git a/src/bun.js/bindings/ZigGlobalObject.cpp b/src/bun.js/bindings/ZigGlobalObject.cpp
index c19d3888b..7918e9197 100644
--- a/src/bun.js/bindings/ZigGlobalObject.cpp
+++ b/src/bun.js/bindings/ZigGlobalObject.cpp
@@ -163,8 +163,8 @@ using JSBuffer = WebCore::JSBuffer;
 #include "DOMJITHelpers.h"
 #include <JavaScriptCore/DFGAbstractHeap.h>
 
-#include "JSCryptoKey.h"
-#include "JSSubtleCrypto.h"
+#include "webcrypto/JSCryptoKey.h"
+#include "webcrypto/JSSubtleCrypto.h"
 
 #include "OnigurumaRegExp.h"
 
diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 6a89db7b9..6d5f87662 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -1486,7 +1486,7 @@ pub const JSPromise = extern struct {
     ) JSValue {
         if (value.isEmpty()) {
             return resolvedPromiseValue(globalObject, JSValue.jsUndefined());
-        } else if (value.isEmptyOrUndefinedOrNull()) {
+        } else if (value.isEmptyOrUndefinedOrNull() or !value.isCell()) {
             return resolvedPromiseValue(globalObject, value);
         }
 
diff --git a/src/bun.js/bindings/generated_classes.zig b/src/bun.js/bindings/generated_classes.zig
index 5cb04779a..062372efe 100644
--- a/src/bun.js/bindings/generated_classes.zig
+++ b/src/bun.js/bindings/generated_classes.zig
@@ -7,6 +7,365 @@ pub const StaticGetterType = fn (*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue)
 pub const StaticSetterType = fn (*JSC.JSGlobalObject, JSC.JSValue, JSC.JSValue, JSC.JSValue) callconv(.C) bool;
 pub const StaticCallbackType = fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
 
+pub const JSTCPSocket = struct {
+    const TCPSocket = Classes.TCPSocket;
+    const GetterType = fn (*TCPSocket, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
+    const SetterType = fn (*TCPSocket, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
+    const CallbackType = fn (*TCPSocket, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
+
+    /// Return the pointer to the wrapped object.
+    /// If the object does not match the type, return null.
+    pub fn fromJS(value: JSC.JSValue) ?*TCPSocket {
+        JSC.markBinding(@src());
+        return TCPSocket__fromJS(value);
+    }
+
+    extern fn TCPSocketPrototype__dataSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    /// Set the cached value for data on TCPSocket
+    /// This value will be visited by the garbage collector.
+    pub fn dataSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        TCPSocketPrototype__dataSetCachedValue(thisValue, globalObject, value);
+    }
+
+    extern fn TCPSocketPrototype__remoteAddressSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    /// Set the cached value for remoteAddress on TCPSocket
+    /// This value will be visited by the garbage collector.
+    pub fn remoteAddressSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        TCPSocketPrototype__remoteAddressSetCachedValue(thisValue, globalObject, value);
+    }
+
+    /// Get the TCPSocket constructor value.
+    /// This loads lazily from the global object.
+    pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        JSC.markBinding(@src());
+        return TCPSocket__getConstructor(globalObject);
+    }
+
+    /// Create a new instance of TCPSocket
+    pub fn toJS(this: *TCPSocket, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        JSC.markBinding(@src());
+        if (comptime Environment.allow_assert) {
+            const value__ = TCPSocket__create(globalObject, this);
+            std.debug.assert(value__.as(TCPSocket).? == this); // If this fails, likely a C ABI issue.
+            return value__;
+        } else {
+            return TCPSocket__create(globalObject, this);
+        }
+    }
+
+    /// Modify the internal ptr to point to a new instance of TCPSocket.
+    pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*TCPSocket) bool {
+        JSC.markBinding(@src());
+        return TCPSocket__dangerouslySetPtr(value, ptr);
+    }
+
+    extern fn TCPSocket__fromJS(JSC.JSValue) ?*TCPSocket;
+    extern fn TCPSocket__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
+
+    extern fn TCPSocket__create(globalObject: *JSC.JSGlobalObject, ptr: ?*TCPSocket) JSC.JSValue;
+
+    extern fn TCPSocket__dangerouslySetPtr(JSC.JSValue, ?*TCPSocket) bool;
+
+    comptime {
+        if (@TypeOf(TCPSocket.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*TCPSocket)) {
+            @compileLog("TCPSocket.constructor is not a constructor");
+        }
+
+        if (@TypeOf(TCPSocket.finalize) != (fn (*TCPSocket) callconv(.C) void)) {
+            @compileLog("TCPSocket.finalize is not a finalizer");
+        }
+
+        if (@TypeOf(TCPSocket.getData) != GetterType)
+            @compileLog("Expected TCPSocket.getData to be a getter");
+
+        if (@TypeOf(TCPSocket.setData) != SetterType)
+            @compileLog("Expected TCPSocket.setData to be a setter");
+        if (@TypeOf(TCPSocket.end) != CallbackType)
+            @compileLog("Expected TCPSocket.end to be a callback");
+        if (@TypeOf(TCPSocket.flush) != CallbackType)
+            @compileLog("Expected TCPSocket.flush to be a callback");
+        if (@TypeOf(TCPSocket.getListener) != GetterType)
+            @compileLog("Expected TCPSocket.getListener to be a getter");
+
+        if (@TypeOf(TCPSocket.getLocalPort) != GetterType)
+            @compileLog("Expected TCPSocket.getLocalPort to be a getter");
+
+        if (@TypeOf(TCPSocket.getReadyState) != GetterType)
+            @compileLog("Expected TCPSocket.getReadyState to be a getter");
+
+        if (@TypeOf(TCPSocket.ref) != CallbackType)
+            @compileLog("Expected TCPSocket.ref to be a callback");
+        if (@TypeOf(TCPSocket.reload) != CallbackType)
+            @compileLog("Expected TCPSocket.reload to be a callback");
+        if (@TypeOf(TCPSocket.getRemoteAddress) != GetterType)
+            @compileLog("Expected TCPSocket.getRemoteAddress to be a getter");
+
+        if (@TypeOf(TCPSocket.shutdown) != CallbackType)
+            @compileLog("Expected TCPSocket.shutdown to be a callback");
+        if (@TypeOf(TCPSocket.timeout) != CallbackType)
+            @compileLog("Expected TCPSocket.timeout to be a callback");
+        if (@TypeOf(TCPSocket.unref) != CallbackType)
+            @compileLog("Expected TCPSocket.unref to be a callback");
+        if (@TypeOf(TCPSocket.write) != CallbackType)
+            @compileLog("Expected TCPSocket.write to be a callback");
+        if (!JSC.is_bindgen) {
+            @export(TCPSocket.constructor, .{ .name = "TCPSocketClass__construct" });
+            @export(TCPSocket.end, .{ .name = "TCPSocketPrototype__end" });
+            @export(TCPSocket.finalize, .{ .name = "TCPSocketClass__finalize" });
+            @export(TCPSocket.flush, .{ .name = "TCPSocketPrototype__flush" });
+            @export(TCPSocket.getData, .{ .name = "TCPSocketPrototype__getData" });
+            @export(TCPSocket.getListener, .{ .name = "TCPSocketPrototype__getListener" });
+            @export(TCPSocket.getLocalPort, .{ .name = "TCPSocketPrototype__getLocalPort" });
+            @export(TCPSocket.getReadyState, .{ .name = "TCPSocketPrototype__getReadyState" });
+            @export(TCPSocket.getRemoteAddress, .{ .name = "TCPSocketPrototype__getRemoteAddress" });
+            @export(TCPSocket.ref, .{ .name = "TCPSocketPrototype__ref" });
+            @export(TCPSocket.reload, .{ .name = "TCPSocketPrototype__reload" });
+            @export(TCPSocket.setData, .{ .name = "TCPSocketPrototype__setData" });
+            @export(TCPSocket.shutdown, .{ .name = "TCPSocketPrototype__shutdown" });
+            @export(TCPSocket.timeout, .{ .name = "TCPSocketPrototype__timeout" });
+            @export(TCPSocket.unref, .{ .name = "TCPSocketPrototype__unref" });
+            @export(TCPSocket.write, .{ .name = "TCPSocketPrototype__write" });
+        }
+    }
+};
+pub const JSTLSSocket = struct {
+    const TLSSocket = Classes.TLSSocket;
+    const GetterType = fn (*TLSSocket, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
+    const SetterType = fn (*TLSSocket, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
+    const CallbackType = fn (*TLSSocket, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
+
+    /// Return the pointer to the wrapped object.
+    /// If the object does not match the type, return null.
+    pub fn fromJS(value: JSC.JSValue) ?*TLSSocket {
+        JSC.markBinding(@src());
+        return TLSSocket__fromJS(value);
+    }
+
+    extern fn TLSSocketPrototype__dataSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    /// Set the cached value for data on TLSSocket
+    /// This value will be visited by the garbage collector.
+    pub fn dataSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        TLSSocketPrototype__dataSetCachedValue(thisValue, globalObject, value);
+    }
+
+    extern fn TLSSocketPrototype__remoteAddressSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    /// Set the cached value for remoteAddress on TLSSocket
+    /// This value will be visited by the garbage collector.
+    pub fn remoteAddressSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        TLSSocketPrototype__remoteAddressSetCachedValue(thisValue, globalObject, value);
+    }
+
+    /// Get the TLSSocket constructor value.
+    /// This loads lazily from the global object.
+    pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        JSC.markBinding(@src());
+        return TLSSocket__getConstructor(globalObject);
+    }
+
+    /// Create a new instance of TLSSocket
+    pub fn toJS(this: *TLSSocket, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        JSC.markBinding(@src());
+        if (comptime Environment.allow_assert) {
+            const value__ = TLSSocket__create(globalObject, this);
+            std.debug.assert(value__.as(TLSSocket).? == this); // If this fails, likely a C ABI issue.
+            return value__;
+        } else {
+            return TLSSocket__create(globalObject, this);
+        }
+    }
+
+    /// Modify the internal ptr to point to a new instance of TLSSocket.
+    pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*TLSSocket) bool {
+        JSC.markBinding(@src());
+        return TLSSocket__dangerouslySetPtr(value, ptr);
+    }
+
+    extern fn TLSSocket__fromJS(JSC.JSValue) ?*TLSSocket;
+    extern fn TLSSocket__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
+
+    extern fn TLSSocket__create(globalObject: *JSC.JSGlobalObject, ptr: ?*TLSSocket) JSC.JSValue;
+
+    extern fn TLSSocket__dangerouslySetPtr(JSC.JSValue, ?*TLSSocket) bool;
+
+    comptime {
+        if (@TypeOf(TLSSocket.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*TLSSocket)) {
+            @compileLog("TLSSocket.constructor is not a constructor");
+        }
+
+        if (@TypeOf(TLSSocket.finalize) != (fn (*TLSSocket) callconv(.C) void)) {
+            @compileLog("TLSSocket.finalize is not a finalizer");
+        }
+
+        if (@TypeOf(TLSSocket.getData) != GetterType)
+            @compileLog("Expected TLSSocket.getData to be a getter");
+
+        if (@TypeOf(TLSSocket.setData) != SetterType)
+            @compileLog("Expected TLSSocket.setData to be a setter");
+        if (@TypeOf(TLSSocket.end) != CallbackType)
+            @compileLog("Expected TLSSocket.end to be a callback");
+        if (@TypeOf(TLSSocket.flush) != CallbackType)
+            @compileLog("Expected TLSSocket.flush to be a callback");
+        if (@TypeOf(TLSSocket.getListener) != GetterType)
+            @compileLog("Expected TLSSocket.getListener to be a getter");
+
+        if (@TypeOf(TLSSocket.getLocalPort) != GetterType)
+            @compileLog("Expected TLSSocket.getLocalPort to be a getter");
+
+        if (@TypeOf(TLSSocket.getReadyState) != GetterType)
+            @compileLog("Expected TLSSocket.getReadyState to be a getter");
+
+        if (@TypeOf(TLSSocket.ref) != CallbackType)
+            @compileLog("Expected TLSSocket.ref to be a callback");
+        if (@TypeOf(TLSSocket.reload) != CallbackType)
+            @compileLog("Expected TLSSocket.reload to be a callback");
+        if (@TypeOf(TLSSocket.getRemoteAddress) != GetterType)
+            @compileLog("Expected TLSSocket.getRemoteAddress to be a getter");
+
+        if (@TypeOf(TLSSocket.shutdown) != CallbackType)
+            @compileLog("Expected TLSSocket.shutdown to be a callback");
+        if (@TypeOf(TLSSocket.timeout) != CallbackType)
+            @compileLog("Expected TLSSocket.timeout to be a callback");
+        if (@TypeOf(TLSSocket.unref) != CallbackType)
+            @compileLog("Expected TLSSocket.unref to be a callback");
+        if (@TypeOf(TLSSocket.write) != CallbackType)
+            @compileLog("Expected TLSSocket.write to be a callback");
+        if (!JSC.is_bindgen) {
+            @export(TLSSocket.constructor, .{ .name = "TLSSocketClass__construct" });
+            @export(TLSSocket.end, .{ .name = "TLSSocketPrototype__end" });
+            @export(TLSSocket.finalize, .{ .name = "TLSSocketClass__finalize" });
+            @export(TLSSocket.flush, .{ .name = "TLSSocketPrototype__flush" });
+            @export(TLSSocket.getData, .{ .name = "TLSSocketPrototype__getData" });
+            @export(TLSSocket.getListener, .{ .name = "TLSSocketPrototype__getListener" });
+            @export(TLSSocket.getLocalPort, .{ .name = "TLSSocketPrototype__getLocalPort" });
+            @export(TLSSocket.getReadyState, .{ .name = "TLSSocketPrototype__getReadyState" });
+            @export(TLSSocket.getRemoteAddress, .{ .name = "TLSSocketPrototype__getRemoteAddress" });
+            @export(TLSSocket.ref, .{ .name = "TLSSocketPrototype__ref" });
+            @export(TLSSocket.reload, .{ .name = "TLSSocketPrototype__reload" });
+            @export(TLSSocket.setData, .{ .name = "TLSSocketPrototype__setData" });
+            @export(TLSSocket.shutdown, .{ .name = "TLSSocketPrototype__shutdown" });
+            @export(TLSSocket.timeout, .{ .name = "TLSSocketPrototype__timeout" });
+            @export(TLSSocket.unref, .{ .name = "TLSSocketPrototype__unref" });
+            @export(TLSSocket.write, .{ .name = "TLSSocketPrototype__write" });
+        }
+    }
+};
+pub const JSListener = struct {
+    const Listener = Classes.Listener;
+    const GetterType = fn (*Listener, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
+    const SetterType = fn (*Listener, *JSC.JSGlobalObject, JSC.JSValue) callconv(.C) bool;
+    const CallbackType = fn (*Listener, *JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) JSC.JSValue;
+
+    /// Return the pointer to the wrapped object.
+    /// If the object does not match the type, return null.
+    pub fn fromJS(value: JSC.JSValue) ?*Listener {
+        JSC.markBinding(@src());
+        return Listener__fromJS(value);
+    }
+
+    extern fn ListenerPrototype__hostnameSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    /// Set the cached value for hostname on Listener
+    /// This value will be visited by the garbage collector.
+    pub fn hostnameSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        ListenerPrototype__hostnameSetCachedValue(thisValue, globalObject, value);
+    }
+
+    extern fn ListenerPrototype__unixSetCachedValue(JSC.JSValue, *JSC.JSGlobalObject, JSC.JSValue) void;
+
+    /// Set the cached value for unix on Listener
+    /// This value will be visited by the garbage collector.
+    pub fn unixSetCached(thisValue: JSC.JSValue, globalObject: *JSC.JSGlobalObject, value: JSC.JSValue) void {
+        JSC.markBinding(@src());
+        ListenerPrototype__unixSetCachedValue(thisValue, globalObject, value);
+    }
+
+    /// Get the Listener constructor value.
+    /// This loads lazily from the global object.
+    pub fn getConstructor(globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        JSC.markBinding(@src());
+        return Listener__getConstructor(globalObject);
+    }
+
+    /// Create a new instance of Listener
+    pub fn toJS(this: *Listener, globalObject: *JSC.JSGlobalObject) JSC.JSValue {
+        JSC.markBinding(@src());
+        if (comptime Environment.allow_assert) {
+            const value__ = Listener__create(globalObject, this);
+            std.debug.assert(value__.as(Listener).? == this); // If this fails, likely a C ABI issue.
+            return value__;
+        } else {
+            return Listener__create(globalObject, this);
+        }
+    }
+
+    /// Modify the internal ptr to point to a new instance of Listener.
+    pub fn dangerouslySetPtr(value: JSC.JSValue, ptr: ?*Listener) bool {
+        JSC.markBinding(@src());
+        return Listener__dangerouslySetPtr(value, ptr);
+    }
+
+    extern fn Listener__fromJS(JSC.JSValue) ?*Listener;
+    extern fn Listener__getConstructor(*JSC.JSGlobalObject) JSC.JSValue;
+
+    extern fn Listener__create(globalObject: *JSC.JSGlobalObject, ptr: ?*Listener) JSC.JSValue;
+
+    extern fn Listener__dangerouslySetPtr(JSC.JSValue, ?*Listener) bool;
+
+    comptime {
+        if (@TypeOf(Listener.constructor) != (fn (*JSC.JSGlobalObject, *JSC.CallFrame) callconv(.C) ?*Listener)) {
+            @compileLog("Listener.constructor is not a constructor");
+        }
+
+        if (@TypeOf(Listener.finalize) != (fn (*Listener) callconv(.C) void)) {
+            @compileLog("Listener.finalize is not a finalizer");
+        }
+
+        if (@TypeOf(Listener.getData) != GetterType)
+            @compileLog("Expected Listener.getData to be a getter");
+
+        if (@TypeOf(Listener.setData) != SetterType)
+            @compileLog("Expected Listener.setData to be a setter");
+        if (@TypeOf(Listener.getHostname) != GetterType)
+            @compileLog("Expected Listener.getHostname to be a getter");
+
+        if (@TypeOf(Listener.getPort) != GetterType)
+            @compileLog("Expected Listener.getPort to be a getter");
+
+        if (@TypeOf(Listener.ref) != CallbackType)
+            @compileLog("Expected Listener.ref to be a callback");
+        if (@TypeOf(Listener.reload) != CallbackType)
+            @compileLog("Expected Listener.reload to be a callback");
+        if (@TypeOf(Listener.stop) != CallbackType)
+            @compileLog("Expected Listener.stop to be a callback");
+        if (@TypeOf(Listener.getUnix) != GetterType)
+            @compileLog("Expected Listener.getUnix to be a getter");
+
+        if (@TypeOf(Listener.unref) != CallbackType)
+            @compileLog("Expected Listener.unref to be a callback");
+        if (!JSC.is_bindgen) {
+            @export(Listener.constructor, .{ .name = "ListenerClass__construct" });
+            @export(Listener.finalize, .{ .name = "ListenerClass__finalize" });
+            @export(Listener.getData, .{ .name = "ListenerPrototype__getData" });
+            @export(Listener.getHostname, .{ .name = "ListenerPrototype__getHostname" });
+            @export(Listener.getPort, .{ .name = "ListenerPrototype__getPort" });
+            @export(Listener.getUnix, .{ .name = "ListenerPrototype__getUnix" });
+            @export(Listener.ref, .{ .name = "ListenerPrototype__ref" });
+            @export(Listener.reload, .{ .name = "ListenerPrototype__reload" });
+            @export(Listener.setData, .{ .name = "ListenerPrototype__setData" });
+            @export(Listener.stop, .{ .name = "ListenerPrototype__stop" });
+            @export(Listener.unref, .{ .name = "ListenerPrototype__unref" });
+        }
+    }
+};
 pub const JSSubprocess = struct {
     const Subprocess = Classes.Subprocess;
     const GetterType = fn (*Subprocess, *JSC.JSGlobalObject) callconv(.C) JSC.JSValue;
@@ -1392,6 +1751,9 @@ pub const JSBlob = struct {
 };
 
 comptime {
+    _ = JSTCPSocket;
+    _ = JSTLSSocket;
+    _ = JSListener;
     _ = JSSubprocess;
     _ = JSSHA1;
     _ = JSMD5;
diff --git a/src/bun.js/bindings/generated_classes_list.zig b/src/bun.js/bindings/generated_classes_list.zig
index 0f74343f6..acae606e3 100644
--- a/src/bun.js/bindings/generated_classes_list.zig
+++ b/src/bun.js/bindings/generated_classes_list.zig
@@ -15,4 +15,7 @@ pub const Classes = struct {
     pub const Blob = JSC.WebCore.Blob;
     pub const Subprocess = JSC.Subprocess;
     pub const ServerWebSocket = JSC.API.ServerWebSocket;
+    pub const TCPSocket = JSC.API.TCPSocket;
+    pub const TLSSocket = JSC.API.TLSSocket;
+    pub const Listener = JSC.API.Listener;
 };
diff --git a/src/bun.js/bindings/headers-cpp.h b/src/bun.js/bindings/headers-cpp.h
index 539e71afc..47ca7ef31 100644
--- a/src/bun.js/bindings/headers-cpp.h
+++ b/src/bun.js/bindings/headers-cpp.h
@@ -1,4 +1,4 @@
-//-- AUTOGENERATED FILE -- 1666254195
+//-- AUTOGENERATED FILE -- 1666335003
 // clang-format off
 #pragma once
 
diff --git a/src/bun.js/bindings/headers.h b/src/bun.js/bindings/headers.h
index de4eb42d4..d0b3cc938 100644
--- a/src/bun.js/bindings/headers.h
+++ b/src/bun.js/bindings/headers.h
@@ -1,5 +1,5 @@
 // clang-format off
-//-- AUTOGENERATED FILE -- 1666254195
+//-- AUTOGENERATED FILE -- 1666335003
 #pragma once
 
 #include <stddef.h>