the events, they loop

src/javascript/jsc/api/bun.zig

@@ -954,6 +954,10 @@ pub const Class = NewClass(
             .rfn = Bun.readAllStdinSync,
             .ts = d.ts{},
         },
+        .startServer = .{
+            .rfn = Bun.startServer,
+            .ts = d.ts{},
+        },
     },
     .{
         .main = .{
@@ -1001,6 +1005,28 @@ pub const Class = NewClass(
     },
 );
 
+pub fn startServer(
+    _: void,
+    ctx: js.JSContextRef,
+    _: js.JSObjectRef,
+    _: js.JSObjectRef,
+    arguments: []const js.JSValueRef,
+    _: js.ExceptionRef,
+) js.JSValueRef {
+    var vm = JSC.VirtualMachine.vm;
+    const handler = if (arguments.len > 0) JSC.JSValue.fromRef(arguments[0]) else JSC.JSValue.zero;
+    if (handler.isEmpty() or handler.isUndefinedOrNull() or !handler.isCell() or !handler.isCallable(ctx.ptr().vm())) {
+        Output.prettyWarnln("\"serverless\" export should be a function", .{});
+        Output.flush();
+        return JSC.JSValue.jsUndefined().asObjectRef();
+    }
+
+    JSC.C.JSValueProtect(ctx.ptr().ref(), handler.asObjectRef());
+    var server = JSC.API.Server.init(vm.bundler.options.origin.getPortAuto(), handler, ctx.ptr());
+    server.listen();
+    return JSC.JSValue.jsUndefined().asObjectRef();
+}
+
 pub fn allocUnsafe(
     _: void,
     ctx: js.JSContextRef,

src/javascript/jsc/api/server.zig

@@ -0,0 +1,320 @@
+const Bun = @This();
+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 IdentityContext = @import("../../../identity_context.zig").IdentityContext;
+const Fs = @import("../../../fs.zig");
+const Resolver = @import("../../../resolver/resolver.zig");
+const ast = @import("../../../import_record.zig");
+const NodeModuleBundle = @import("../../../node_module_bundle.zig").NodeModuleBundle;
+const MacroEntryPoint = @import("../../../bundler.zig").MacroEntryPoint;
+const logger = @import("../../../logger.zig");
+const Api = @import("../../../api/schema.zig").Api;
+const options = @import("../../../options.zig");
+const Bundler = @import("../../../bundler.zig").Bundler;
+const ServerEntryPoint = @import("../../../bundler.zig").ServerEntryPoint;
+const js_printer = @import("../../../js_printer.zig");
+const js_parser = @import("../../../js_parser.zig");
+const js_ast = @import("../../../js_ast.zig");
+const hash_map = @import("../../../hash_map.zig");
+const http = @import("../../../http.zig");
+const NodeFallbackModules = @import("../../../node_fallbacks.zig");
+const ImportKind = ast.ImportKind;
+const Analytics = @import("../../../analytics/analytics_thread.zig");
+const ZigString = @import("../../../jsc.zig").ZigString;
+const Runtime = @import("../../../runtime.zig");
+const Router = @import("./router.zig");
+const ImportRecord = ast.ImportRecord;
+const DotEnv = @import("../../../env_loader.zig");
+const ParseResult = @import("../../../bundler.zig").ParseResult;
+const PackageJSON = @import("../../../resolver/package_json.zig").PackageJSON;
+const MacroRemap = @import("../../../resolver/package_json.zig").MacroMap;
+const WebCore = @import("../../../jsc.zig").WebCore;
+const Request = WebCore.Request;
+const Response = WebCore.Response;
+const Headers = WebCore.Headers;
+const Fetch = WebCore.Fetch;
+const HTTP = @import("http");
+const FetchEvent = WebCore.FetchEvent;
+const js = @import("../../../jsc.zig").C;
+const JSC = @import("../../../jsc.zig");
+const JSError = @import("../base.zig").JSError;
+const d = @import("../base.zig").d;
+const MarkedArrayBuffer = @import("../base.zig").MarkedArrayBuffer;
+const getAllocator = @import("../base.zig").getAllocator;
+const JSValue = @import("../../../jsc.zig").JSValue;
+const NewClass = @import("../base.zig").NewClass;
+const Microtask = @import("../../../jsc.zig").Microtask;
+const JSGlobalObject = @import("../../../jsc.zig").JSGlobalObject;
+const ExceptionValueRef = @import("../../../jsc.zig").ExceptionValueRef;
+const JSPrivateDataPtr = @import("../../../jsc.zig").JSPrivateDataPtr;
+const ZigConsoleClient = @import("../../../jsc.zig").ZigConsoleClient;
+const Node = @import("../../../jsc.zig").Node;
+const ZigException = @import("../../../jsc.zig").ZigException;
+const ZigStackTrace = @import("../../../jsc.zig").ZigStackTrace;
+const ErrorableResolvedSource = @import("../../../jsc.zig").ErrorableResolvedSource;
+const ResolvedSource = @import("../../../jsc.zig").ResolvedSource;
+const JSPromise = @import("../../../jsc.zig").JSPromise;
+const JSInternalPromise = @import("../../../jsc.zig").JSInternalPromise;
+const JSModuleLoader = @import("../../../jsc.zig").JSModuleLoader;
+const JSPromiseRejectionOperation = @import("../../../jsc.zig").JSPromiseRejectionOperation;
+const Exception = @import("../../../jsc.zig").Exception;
+const ErrorableZigString = @import("../../../jsc.zig").ErrorableZigString;
+const ZigGlobalObject = @import("../../../jsc.zig").ZigGlobalObject;
+const VM = @import("../../../jsc.zig").VM;
+const JSFunction = @import("../../../jsc.zig").JSFunction;
+const Config = @import("../config.zig");
+const URL = @import("../../../url.zig").URL;
+const Transpiler = @import("./transpiler.zig");
+const VirtualMachine = @import("../javascript.zig").VirtualMachine;
+const IOTask = JSC.IOTask;
+const is_bindgen = JSC.is_bindgen;
+const uws = @import("uws");
+
+pub fn NewServer(comptime ssl_enabled: bool) type {
+    return struct {
+        const ThisServer = @This();
+        const RequestContextStackAllocator = std.heap.StackFallbackAllocator(@sizeOf(RequestContext) * 2048 + 4096);
+
+        pub const App = uws.NewApp(ssl_enabled);
+
+        listener: ?*App.ListenSocket = null,
+        callback: JSC.JSValue = JSC.JSValue.zero,
+        port: u16 = 3000,
+        app: *App = undefined,
+        globalThis: *JSGlobalObject,
+        default_server: URL = URL{ .host = "localhost", .port = "3000" },
+
+        request_pool_allocator: std.mem.Allocator = undefined,
+
+        pub fn init(port: u16, callback: JSC.JSValue, globalThis: *JSGlobalObject) *ThisServer {
+            var server = bun.default_allocator.create(ThisServer) catch @panic("Out of memory!");
+            server.* = .{
+                .port = port,
+                .callback = callback,
+                .globalThis = globalThis,
+            };
+            RequestContext.pool = bun.default_allocator.create(RequestContextStackAllocator) catch @panic("Out of memory!");
+            server.request_pool_allocator = RequestContext.pool.get();
+            return server;
+        }
+
+        pub fn onListen(this: *ThisServer, socket: ?*App.ListenSocket, _: uws.uws_app_listen_config_t) void {
+            if (socket == null) {
+                Output.prettyErrorln("Failed to start socket", .{});
+                Output.flush();
+                return;
+            }
+
+            this.listener = socket;
+            VirtualMachine.vm.uws_event_loop = uws.Loop.get();
+            this.app.run();
+        }
+
+        pub const RequestContext = struct {
+            server: *ThisServer,
+            resp: *App.Response,
+            req: *uws.Request,
+            url: string,
+            method: HTTP.Method,
+            aborted: bool = false,
+            response_jsvalue: JSC.JSValue = JSC.JSValue.zero,
+            blob: JSC.WebCore.Blob = JSC.WebCore.Blob{},
+            promise: ?*JSC.JSValue = null,
+            response_headers: ?*JSC.WebCore.Headers.RefCountedHeaders = null,
+
+            pub threadlocal var pool: *RequestContextStackAllocator = undefined;
+
+            pub fn onResolve(
+                ctx: *RequestContext,
+                _: *JSC.JSGlobalObject,
+                arguments: []const JSC.JSValue,
+            ) void {
+                if (ctx.aborted) {
+                    ctx.finalize();
+                    return;
+                }
+
+                if (arguments.len == 0) {
+                    ctx.req.setYield(true);
+                    ctx.finalize();
+                    return;
+                }
+
+                var response = arguments[0].as(JSC.WebCore.Response) orelse {
+                    Output.prettyErrorln("Expected serverless to return a Response", .{});
+                    ctx.req.setYield(true);
+                    ctx.finalize();
+                    return;
+                };
+                ctx.render(response);
+            }
+
+            pub fn onReject(
+                ctx: *RequestContext,
+                _: *JSC.JSGlobalObject,
+                arguments: []const JSC.JSValue,
+            ) void {
+                if (ctx.aborted) {
+                    ctx.finalize();
+                    return;
+                }
+
+                JSC.VirtualMachine.vm.defaultErrorHandler(arguments[0], null);
+                ctx.req.setYield(true);
+                ctx.finalize();
+            }
+
+            pub fn create(this: *RequestContext, server: *ThisServer, req: *uws.Request, resp: *App.Response) void {
+                this.* = .{
+                    .resp = resp,
+                    .req = req,
+                    .url = req.url(),
+                    .method = HTTP.Method.which(req.method()) orelse .GET,
+                    .server = server,
+                };
+                resp.onAborted(*RequestContext, onAbort, this);
+            }
+
+            pub fn onAbort(this: *RequestContext, _: *App.Response) void {
+                this.aborted = true;
+                this.req = undefined;
+                if (!this.response_jsvalue.isEmpty()) {
+                    JSC.C.JSValueUnprotect(this.server.globalThis.ref(), this.response_jsvalue.asObjectRef());
+                    this.response_jsvalue = JSC.JSValue.zero;
+                }
+            }
+
+            pub fn finalize(this: *RequestContext) void {
+                this.blob.detach();
+                if (!this.response_jsvalue.isEmpty()) {
+                    JSC.C.JSValueUnprotect(this.server.globalThis.ref(), this.response_jsvalue.asObjectRef());
+                    this.response_jsvalue = JSC.JSValue.zero;
+                }
+
+                if (this.promise != null) {
+                    JSC.C.JSValueUnprotect(this.server.globalThis.ref(), this.promise.?.asObjectRef());
+                    this.promise = null;
+                }
+
+                if (this.response_headers != null) {
+                    this.response_headers.?.deref();
+                    this.response_headers = null;
+                }
+
+                this.server.request_pool_allocator.destroy(this);
+            }
+
+            pub fn render(this: *RequestContext, response: *JSC.WebCore.Response) void {
+                if (this.aborted) {
+                    return;
+                }
+
+                this.blob = response.body.use();
+                const status = response.statusCode();
+
+                if (response.body.init.headers) |headers_| {
+                    var headers: *JSC.WebCore.Headers = headers_.get();
+                    defer headers_.deref();
+                    var entries = headers.entries.slice();
+                    const names = entries.items(.name);
+                    const values = entries.items(.value);
+
+                    var status_text_buf: [48]u8 = undefined;
+
+                    if (status == 302) {
+                        this.resp.writeStatus("302 Found");
+                    } else {
+                        this.resp.writeStatus(std.fmt.bufPrint(&status_text_buf, "{d} HM", .{response.body.init.status_code}) catch unreachable);
+                    }
+
+                    for (names) |name, i| {
+                        this.resp.writeHeader(headers.asStr(name), headers.asStr(values[i]));
+                    }
+                }
+
+                if (status == 302 or status == 202 or this.blob.size == 0) {
+                    this.resp.endWithoutBody();
+                    this.finalize();
+                    return;
+                }
+
+                this.resp.end(this.blob.sharedView(), false);
+                this.finalize();
+            }
+        };
+
+        pub fn onRequest(this: *ThisServer, req: *uws.Request, resp: *App.Response) void {
+            req.setYield(false);
+            var ctx = this.request_pool_allocator.create(RequestContext) catch @panic("ran out of memory");
+            ctx.create(this, req, resp);
+
+            var request_object = bun.default_allocator.create(JSC.WebCore.Request) catch unreachable;
+            request_object.* = .{
+                .url = JSC.ZigString.init(ctx.url),
+                .method = ctx.method,
+            };
+            var args = [_]JSC.C.JSValueRef{JSC.WebCore.Request.Class.make(this.globalThis.ref(), request_object)};
+            ctx.response_jsvalue = JSC.C.JSObjectCallAsFunctionReturnValue(this.globalThis.ref(), this.callback.asObjectRef(), null, 1, &args);
+            defer JSC.VirtualMachine.vm.tick();
+            if (ctx.aborted) {
+                ctx.finalize();
+
+                return;
+            }
+
+            if (ctx.response_jsvalue.isUndefinedOrNull()) {
+                req.setYield(true);
+                ctx.finalize();
+                return;
+            }
+
+            JSC.C.JSValueProtect(this.globalThis.ref(), ctx.response_jsvalue.asObjectRef());
+
+            if (ctx.response_jsvalue.as(JSC.WebCore.Response)) |response| {
+                ctx.render(response);
+
+                return;
+            }
+
+            if (ctx.response_jsvalue.jsTypeLoose() == .JSPromise) {
+                JSC.VirtualMachine.vm.tick();
+
+                ctx.response_jsvalue.then(
+                    this.globalThis,
+                    RequestContext,
+                    ctx,
+                    RequestContext.onResolve,
+                    RequestContext.onReject,
+                );
+            }
+
+            // switch (ctx.response_jsvalue.jsTypeLoose()) {
+            //     .JSPromise => {
+            //         JSPromise.
+            //     },
+            // }
+        }
+
+        pub fn listen(this: *ThisServer) void {
+            this.app = App.create(.{});
+            this.app.any("/*", *ThisServer, this, onRequest);
+            this.app.listenWithConfig(*ThisServer, this, onListen, .{
+                .port = this.default_server.getPort().?,
+                .host = bun.default_allocator.dupeZ(u8, this.default_server.displayHostname()) catch unreachable,
+                .options = 0,
+            });
+        }
+    };
+}
+
+pub const Server = NewServer(false);
+pub const SSLServer = NewServer(true);

src/javascript/jsc/bindings/BunBuiltinNames.h

@@ -72,6 +72,14 @@ using namespace JSC;
     macro(delimiter) \
     macro(toNamespacedPath) \
     macro(isWindows) \
+    macro(get) \
+    macro(put) \
+    macro(post) \
+    macro(patch) \
+    macro(trace) \
+    macro(connect) \
+    macro(options) \
+    macro(port) \
     BUN_ADDITIONAL_PRIVATE_IDENTIFIERS(macro) \
 
 class BunBuiltinNames {

src/javascript/jsc/bindings/ZigGlobalObject.cpp

@@ -557,7 +557,8 @@ static JSC_DEFINE_HOST_FUNCTION(functionImportMeta__resolve,
     }
 }
 
-extern "C" void Bun__reportError(JSC::JSGlobalObject*, JSC__JSValue);
+extern "C" void Bun__reportError(JSC__JSGlobalObject*, JSC__JSValue);
+
 static JSC_DECLARE_HOST_FUNCTION(functionReportError);
 static JSC_DEFINE_HOST_FUNCTION(functionReportError,
     (JSC::JSGlobalObject * globalObject, JSC::CallFrame* callFrame))

src/javascript/jsc/bindings/bindings.cpp

@@ -246,6 +246,45 @@ unsigned char JSC__JSValue__jsType(JSC__JSValue JSValue0)
     return 0;
 }
 
+// TODO: prevent this from allocating so much memory
+void JSC__JSValue___then(JSC__JSValue JSValue0, JSC__JSGlobalObject* globalObject, void* ctx, void (*ArgFn3)(JSC__JSGlobalObject* arg0, void* arg1, JSC__JSValue arg2, size_t arg3), void (*ArgFn4)(JSC__JSGlobalObject* arg0, void* arg1, JSC__JSValue arg2, size_t arg3))
+{
+
+    JSC::JSNativeStdFunction* resolverFunction = JSC::JSNativeStdFunction::create(
+        globalObject->vm(), globalObject, 1, String(), [ctx, ArgFn3](JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) -> JSC::EncodedJSValue {
+            auto argCount = static_cast<uint16_t>(callFrame->argumentCount());
+            WTF::Vector<JSC::EncodedJSValue, 16> arguments;
+            arguments.reserveInitialCapacity(argCount);
+            if (argCount) {
+                for (uint16_t i = 0; i < argCount; ++i) {
+                    arguments.uncheckedAppend(JSC::JSValue::encode(callFrame->uncheckedArgument(i)));
+                }
+            }
+
+            ArgFn3(globalObject, ctx, reinterpret_cast<JSC__JSValue>(arguments.data()), argCount);
+            return JSC::JSValue::encode(JSC::jsUndefined());
+        });
+    JSC::JSNativeStdFunction* rejecterFunction = JSC::JSNativeStdFunction::create(
+        globalObject->vm(), globalObject, 1, String(),
+        [ctx, ArgFn4](JSC::JSGlobalObject* globalObject, JSC::CallFrame* callFrame) -> JSC::EncodedJSValue {
+            auto argCount = static_cast<uint16_t>(callFrame->argumentCount());
+            WTF::Vector<JSC::EncodedJSValue, 16> arguments;
+            arguments.reserveInitialCapacity(argCount);
+            if (argCount) {
+                for (uint16_t i = 0; i < argCount; ++i) {
+                    arguments.uncheckedAppend(JSC::JSValue::encode(callFrame->uncheckedArgument(i)));
+                }
+            }
+
+            ArgFn4(globalObject, ctx, reinterpret_cast<JSC__JSValue>(arguments.data()), argCount);
+            return JSC::JSValue::encode(JSC::jsUndefined());
+        });
+
+    globalObject->vm().drainMicrotasks();
+    JSC::JSPromise* promise = JSC::jsDynamicCast<JSC::JSPromise*>(globalObject->vm(), JSC::JSValue::decode(JSValue0).asCell());
+    promise->performPromiseThen(globalObject, resolverFunction, rejecterFunction, JSC::jsUndefined());
+}
+
 JSC__JSValue JSC__JSValue__parseJSON(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1)
 {
     JSC::JSValue jsValue = JSC::JSValue::decode(JSValue0);
@@ -728,10 +767,8 @@ JSC__JSValue JSC__JSGlobalObject__createAggregateError(JSC__JSGlobalObject* glob
     }
 
     JSC::Structure* errorStructure = globalObject->errorStructure(JSC::ErrorType::AggregateError);
-    scope.release();
 
-    return JSC::JSValue::encode(JSC::createAggregateError(
-        globalObject, vm, errorStructure, array, message, options, nullptr, JSC::TypeNothing, false));
+    RELEASE_AND_RETURN(scope, JSC::JSValue::encode(JSC::createAggregateError(globalObject, vm, errorStructure, array, message, options, nullptr, JSC::TypeNothing, false)));
 }
 // static JSC::JSNativeStdFunction* resolverFunction;
 // static JSC::JSNativeStdFunction* rejecterFunction;

src/javascript/jsc/bindings/bindings.zig

@@ -2179,6 +2179,48 @@ pub const JSValue = enum(u64) {
         return cppFn("symbolKeyFor", .{ this, global, str });
     }
 
+    const Thenable = fn (
+        global: [*c]JSGlobalObject,
+        ctx: ?*anyopaque,
+        arguments_ptr: JSC.JSValue,
+        arguments_len: usize,
+    ) callconv(.C) void;
+    pub fn _then(this: JSValue, global: *JSGlobalObject, ctx: ?*anyopaque, resolve: Thenable, reject: Thenable) void {
+        return cppFn("_then", .{ this, global, ctx, resolve, reject });
+    }
+    pub fn then(this: JSValue, global: *JSGlobalObject, comptime Then: type, ctx: *Then, comptime onResolve: fn (*Then, globalThis: *JSGlobalObject, args: []const JSC.JSValue) void, comptime onReject: fn (*Then, globalThis: *JSGlobalObject, args: []const JSC.JSValue) void) void {
+        const Handler = struct {
+            fn resolve(
+                globalThis: [*c]JSGlobalObject,
+                ptr: ?*anyopaque,
+                arguments_ptr_: JSC.JSValue,
+                arguments_len: usize,
+            ) callconv(.C) void {
+                @setRuntimeSafety(false);
+                var arguments_ptr = @intToPtr([*]const JSC.JSValue, @enumToInt(arguments_ptr_));
+                onResolve(bun.cast(*Then, ptr.?), globalThis, arguments_ptr[0..arguments_len]);
+            }
+
+            pub fn reject(
+                globalThis: [*c]JSGlobalObject,
+                ptr: ?*anyopaque,
+                arguments_ptr_: JSC.JSValue,
+                arguments_len: usize,
+            ) callconv(.C) void {
+                @setRuntimeSafety(false);
+                var arguments_ptr = @intToPtr([*]const JSC.JSValue, @enumToInt(arguments_ptr_));
+                onReject(bun.cast(*Then, ptr.?), globalThis, arguments_ptr[0..arguments_len]);
+            }
+        };
+
+        this._then(
+            global,
+            ctx,
+            Handler.resolve,
+            Handler.reject,
+        );
+    }
+
     pub fn getDescription(this: JSValue, global: *JSGlobalObject) ZigString {
         var zig_str = ZigString.init("");
         getSymbolDescription(this, global, &zig_str);
@@ -2314,7 +2356,7 @@ pub const JSValue = enum(u64) {
         return @intToPtr(*anyopaque, @enumToInt(this));
     }
 
-    pub const Extern = [_][]const u8{ "put", "makeWithNameAndPrototype", "parseJSON", "symbolKeyFor", "symbolFor", "getSymbolDescription", "createInternalPromise", "asInternalPromise", "asArrayBuffer_", "getReadableStreamState", "getWritableStreamState", "fromEntries", "createTypeError", "createRangeError", "createObject2", "getIfPropertyExistsImpl", "jsType", "jsonStringify", "kind_", "isTerminationException", "isSameValue", "getLengthOfArray", "toZigString", "createStringArray", "createEmptyObject", "putRecord", "asPromise", "isClass", "getNameProperty", "getClassName", "getErrorsProperty", "toInt32", "toBoolean", "isInt32", "isIterable", "forEach", "isAggregateError", "toZigException", "isException", "toWTFString", "hasProperty", "getPropertyNames", "getDirect", "putDirect", "getIfExists", "asString", "asObject", "asNumber", "isError", "jsNull", "jsUndefined", "jsTDZValue", "jsBoolean", "jsDoubleNumber", "jsNumberFromDouble", "jsNumberFromChar", "jsNumberFromU16", "jsNumberFromInt32", "jsNumberFromInt64", "jsNumberFromUint64", "isBoolean", "isAnyInt", "isUInt32AsAnyInt", "isInt32AsAnyInt", "isNumber", "isString", "isBigInt", "isHeapBigInt", "isBigInt32", "isSymbol", "isPrimitive", "isGetterSetter", "isCustomGetterSetter", "isObject", "isCell", "asCell", "toString", "toStringOrNull", "toPropertyKey", "toPropertyKeyValue", "toObject", "toString", "getPrototype", "getPropertyByPropertyName", "eqlValue", "eqlCell", "isCallable" };
+    pub const Extern = [_][]const u8{ "_then", "put", "makeWithNameAndPrototype", "parseJSON", "symbolKeyFor", "symbolFor", "getSymbolDescription", "createInternalPromise", "asInternalPromise", "asArrayBuffer_", "getReadableStreamState", "getWritableStreamState", "fromEntries", "createTypeError", "createRangeError", "createObject2", "getIfPropertyExistsImpl", "jsType", "jsonStringify", "kind_", "isTerminationException", "isSameValue", "getLengthOfArray", "toZigString", "createStringArray", "createEmptyObject", "putRecord", "asPromise", "isClass", "getNameProperty", "getClassName", "getErrorsProperty", "toInt32", "toBoolean", "isInt32", "isIterable", "forEach", "isAggregateError", "toZigException", "isException", "toWTFString", "hasProperty", "getPropertyNames", "getDirect", "putDirect", "getIfExists", "asString", "asObject", "asNumber", "isError", "jsNull", "jsUndefined", "jsTDZValue", "jsBoolean", "jsDoubleNumber", "jsNumberFromDouble", "jsNumberFromChar", "jsNumberFromU16", "jsNumberFromInt32", "jsNumberFromInt64", "jsNumberFromUint64", "isBoolean", "isAnyInt", "isUInt32AsAnyInt", "isInt32AsAnyInt", "isNumber", "isString", "isBigInt", "isHeapBigInt", "isBigInt32", "isSymbol", "isPrimitive", "isGetterSetter", "isCustomGetterSetter", "isObject", "isCell", "asCell", "toString", "toStringOrNull", "toPropertyKey", "toPropertyKeyValue", "toObject", "toString", "getPrototype", "getPropertyByPropertyName", "eqlValue", "eqlCell", "isCallable" };
 };
 
 extern "c" fn Microtask__run(*Microtask, *JSGlobalObject) void;

src/javascript/jsc/bindings/headers-cpp.h

@@ -1,4 +1,4 @@
-//-- AUTOGENERATED FILE -- 1647600299
+//-- AUTOGENERATED FILE -- 1647769923
 // clang-format off
 #pragma once
 

src/javascript/jsc/bindings/headers.h

@@ -1,5 +1,5 @@
 // clang-format: off
-//-- AUTOGENERATED FILE -- 1647600299
+//-- AUTOGENERATED FILE -- 1647769923
 #pragma once
 
 #include <stddef.h>
@@ -426,6 +426,7 @@ CPP_DECL size_t WTF__String__length(WTF__String* arg0);
 
 #pragma mark - JSC::JSValue
 
+CPP_DECL void JSC__JSValue___then(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, void* arg2, void (* ArgFn3)(JSC__JSGlobalObject* arg0, void* arg1, JSC__JSValue arg2, size_t arg3), void (* ArgFn4)(JSC__JSGlobalObject* arg0, void* arg1, JSC__JSValue arg2, size_t arg3));
 CPP_DECL bool JSC__JSValue__asArrayBuffer_(JSC__JSValue JSValue0, JSC__JSGlobalObject* arg1, Bun__ArrayBuffer* arg2);
 CPP_DECL JSC__JSCell* JSC__JSValue__asCell(JSC__JSValue JSValue0);
 CPP_DECL JSC__JSInternalPromise* JSC__JSValue__asInternalPromise(JSC__JSValue JSValue0);

src/javascript/jsc/bindings/headers.zig

@@ -274,6 +274,7 @@ pub extern fn WTF__String__isEmpty(arg0: [*c]WTF__String) bool;
 pub extern fn WTF__String__isExternal(arg0: [*c]WTF__String) bool;
 pub extern fn WTF__String__isStatic(arg0: [*c]WTF__String) bool;
 pub extern fn WTF__String__length(arg0: [*c]WTF__String) usize;
+pub extern fn JSC__JSValue___then(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: ?*anyopaque, ArgFn3: ?fn ([*c]JSC__JSGlobalObject, ?*anyopaque, JSC__JSValue, usize) callconv(.C) void, ArgFn4: ?fn ([*c]JSC__JSGlobalObject, ?*anyopaque, JSC__JSValue, usize) callconv(.C) void) void;
 pub extern fn JSC__JSValue__asArrayBuffer_(JSValue0: JSC__JSValue, arg1: [*c]JSC__JSGlobalObject, arg2: [*c]Bun__ArrayBuffer) bool;
 pub extern fn JSC__JSValue__asCell(JSValue0: JSC__JSValue) [*c]JSC__JSCell;
 pub extern fn JSC__JSValue__asInternalPromise(JSValue0: JSC__JSValue) [*c]JSC__JSInternalPromise;

src/javascript/jsc/javascript.zig

@@ -422,6 +422,7 @@ pub const SavedSourceMap = struct {
         return SourceMap.Mapping.find(mappings, line, column);
     }
 };
+const uws = @import("uws");
 
 // If you read JavascriptCore/API/JSVirtualMachine.mm - https://github.com/WebKit/WebKit/blob/acff93fb303baa670c055cb24c2bad08691a01a0/Source/JavaScriptCore/API/JSVirtualMachine.mm#L101
 // We can see that it's sort of like std.mem.Allocator but for JSGlobalContextRef, to support Automatic Reference Counting
@@ -450,6 +451,7 @@ pub const VirtualMachine = struct {
     node_fs: ?*Node.NodeFS = null,
     has_loaded_node_modules: bool = false,
     timer: Bun.Timer = Bun.Timer{},
+    uws_event_loop: ?*uws.Loop = null,
 
     arena: *Arena = undefined,
     has_loaded: bool = false,
@@ -596,6 +598,9 @@ pub const VirtualMachine = struct {
             this.concurrent_lock.lock();
             defer this.concurrent_lock.unlock();
             this.concurrent_tasks.writeItem(task) catch unreachable;
+            if (this.virtual_machine.uws_event_loop) |loop| {
+                loop.nextTick(*EventLoop, this, EventLoop.tick);
+            }
             _ = this.ready_tasks_count.fetchAdd(1, .Monotonic);
         }
     };
@@ -728,7 +733,6 @@ pub const VirtualMachine = struct {
             .origin_timer = std.time.Timer.start() catch @panic("Please don't mess with timers."),
             .ref_strings = JSC.RefString.Map.init(allocator),
         };
-
         VirtualMachine.vm.regular_event_loop.tasks = EventLoop.Queue.init(
             default_allocator,
         );

src/javascript/jsc/node/node_fs.zig

@@ -2168,7 +2168,7 @@ const Arguments = struct {
     };
 };
 
-pub const Constants = struct {
+const Constants = struct {
     // File Access Constants
     /// Constant for fs.access(). File is visible to the calling process.
     pub const F_OK = std.os.F_OK;