This is the last of the big changes to the js code

src/browser/ScriptManager.zig

@@ -663,7 +663,7 @@ const Script = struct {
             .cacheable = cacheable,
         });
 
-        const js_context = page.main_context;
+        const js_context = page.js;
         var try_catch: js.TryCatch = undefined;
         try_catch.init(js_context);
         defer try_catch.deinit();
@@ -707,10 +707,10 @@ const Script = struct {
         switch (callback) {
             .string => |str| {
                 var try_catch: js.TryCatch = undefined;
-                try_catch.init(page.main_context);
+                try_catch.init(page.js);
                 defer try_catch.deinit();
 
-                _ = page.main_context.exec(str, typ) catch |err| {
+                _ = page.js.exec(str, typ) catch |err| {
                     const msg = try_catch.err(page.arena) catch @errorName(err) orelse "unknown";
                     log.warn(.user_script, "script callback", .{
                         .url = self.url,

src/browser/cssom/CSSStyleSheet.zig

@@ -79,9 +79,7 @@ pub fn _replace(self: *CSSStyleSheet, text: []const u8, page: *Page) !js.Promise
     // TODO: clear self.css_rules
     // parse text and re-populate self.css_rules
 
-    const resolver = page.main_context.createPromiseResolver();
-    try resolver.resolve({});
-    return resolver.promise();
+    return page.js.resolvePromise({});
 }
 
 pub fn _replaceSync(self: *CSSStyleSheet, text: []const u8) !void {

src/browser/dom/Animation.zig

@@ -49,7 +49,7 @@ pub fn get_pending(self: *const Animation) bool {
 
 pub fn get_finished(self: *Animation, page: *Page) !js.Promise {
     if (self.finished_resolver == null) {
-        const resolver = page.main_context.createPromiseResolver();
+        const resolver = page.js.createPromiseResolver(.none);
         try resolver.resolve(self);
         self.finished_resolver = resolver;
     }
@@ -59,7 +59,7 @@ pub fn get_finished(self: *Animation, page: *Page) !js.Promise {
 pub fn get_ready(self: *Animation, page: *Page) !js.Promise {
     // never resolved, because we're always "finished"
     if (self.ready_resolver == null) {
-        const resolver = page.main_context.createPromiseResolver();
+        const resolver = page.js.createPromiseResolver(.none);
         self.ready_resolver = resolver;
     }
     return self.ready_resolver.?.promise();

src/browser/dom/document.zig

@@ -304,7 +304,7 @@ pub const Document = struct {
             return obj;
         }
 
-        const obj = try page.main_context.newArray(0).persist();
+        const obj = try page.js.createArray(0).persist();
         state.adopted_style_sheets = obj;
         return obj;
     }

src/browser/dom/shadow_root.zig

@@ -50,7 +50,7 @@ pub const ShadowRoot = struct {
             return obj;
         }
 
-        const obj = try page.main_context.newArray(0).persist();
+        const obj = try page.js.createArray(0).persist();
         self.adopted_style_sheets = obj;
         return obj;
     }

src/browser/fetch/Headers.zig

@@ -24,7 +24,6 @@ const Page = @import("../page.zig").Page;
 
 const iterator = @import("../iterator/iterator.zig");
 
-const v8 = @import("v8");
 // https://developer.mozilla.org/en-US/docs/Web/API/Headers
 const Headers = @This();
 

src/browser/fetch/Request.zig

@@ -27,8 +27,6 @@ const Response = @import("./Response.zig");
 const Http = @import("../../http/Http.zig");
 const ReadableStream = @import("../streams/ReadableStream.zig");
 
-const v8 = @import("v8");
-
 const Headers = @import("Headers.zig");
 const HeadersInit = @import("Headers.zig").HeadersInit;
 
@@ -245,20 +243,15 @@ pub fn _bytes(self: *Response, page: *Page) !js.Promise {
     if (self.body_used) {
         return error.TypeError;
     }
-
-    const resolver = page.main_context.createPromiseResolver();
-
-    try resolver.resolve(self.body);
     self.body_used = true;
-    return resolver.promise();
+    return page.js.resolvePromise(self.body);
 }
 
 pub fn _json(self: *Response, page: *Page) !js.Promise {
     if (self.body_used) {
         return error.TypeError;
     }
-
-    const resolver = page.main_context.createPromiseResolver();
+    self.body_used = true;
 
     if (self.body) |body| {
         const p = std.json.parseFromSliceLeaky(
@@ -271,25 +264,17 @@ pub fn _json(self: *Response, page: *Page) !js.Promise {
             return error.SyntaxError;
         };
 
-        try resolver.resolve(p);
-    } else {
-        try resolver.resolve(null);
+        return page.js.resolvePromise(p);
     }
-
-    self.body_used = true;
-    return resolver.promise();
+    return page.js.resolvePromise(null);
 }
 
 pub fn _text(self: *Response, page: *Page) !js.Promise {
     if (self.body_used) {
         return error.TypeError;
     }
-
-    const resolver = page.main_context.createPromiseResolver();
-
-    try resolver.resolve(self.body);
     self.body_used = true;
-    return resolver.promise();
+    return page.js.resolvePromise(self.body);
 }
 
 const testing = @import("../../testing.zig");

src/browser/fetch/Response.zig

@@ -20,8 +20,6 @@ const std = @import("std");
 const js = @import("../js/js.zig");
 const log = @import("../../log.zig");
 
-const v8 = @import("v8");
-
 const HttpClient = @import("../../http/Client.zig");
 const Http = @import("../../http/Http.zig");
 const URL = @import("../../url.zig").URL;
@@ -170,24 +168,17 @@ pub fn _bytes(self: *Response, page: *Page) !js.Promise {
         return error.TypeError;
     }
 
-    const resolver = js.PromiseResolver{
-        .context = page.main_context,
-        .resolver = v8.PromiseResolver.init(page.main_context.v8_context),
-    };
-
-    try resolver.resolve(self.body);
     self.body_used = true;
-    return resolver.promise();
+    return page.js.resolvePromise(self.body);
 }
 
 pub fn _json(self: *Response, page: *Page) !js.Promise {
     if (self.body_used) {
         return error.TypeError;
     }
 
-    const resolver = page.main_context.createPromiseResolver();
-
     if (self.body) |body| {
+        self.body_used = true;
         const p = std.json.parseFromSliceLeaky(
             std.json.Value,
             page.call_arena,
@@ -198,25 +189,18 @@ pub fn _json(self: *Response, page: *Page) !js.Promise {
             return error.SyntaxError;
         };
 
-        try resolver.resolve(p);
-    } else {
-        try resolver.resolve(null);
+        return page.js.resolvePromise(p);
     }
-
-    self.body_used = true;
-    return resolver.promise();
+    return page.js.resolvePromise(null);
 }
 
 pub fn _text(self: *Response, page: *Page) !js.Promise {
     if (self.body_used) {
         return error.TypeError;
     }
-
-    const resolver = page.main_context.createPromiseResolver();
-
-    try resolver.resolve(self.body);
     self.body_used = true;
-    return resolver.promise();
+
+    return page.js.resolvePromise(self.body);
 }
 
 const testing = @import("../../testing.zig");

src/browser/fetch/fetch.zig

@@ -131,7 +131,7 @@ pub fn fetch(input: RequestInput, options: ?RequestInit, page: *Page) !js.Promis
 
     try page.requestCookie(.{}).headersForRequest(arena, req.url, &headers);
 
-    const resolver = try page.main_context.createPersistentPromiseResolver(.page);
+    const resolver = try page.js.createPromiseResolver(.page);
 
     const fetch_ctx = try arena.create(FetchContext);
     fetch_ctx.* = .{

src/browser/html/AbortController.zig

@@ -118,7 +118,7 @@ pub const AbortSignal = struct {
     };
     pub fn _throwIfAborted(self: *const AbortSignal, page: *Page) ThrowIfAborted {
         if (self.aborted) {
-            const ex = page.main_context.throw(self.reason orelse DEFAULT_REASON);
+            const ex = page.js.throw(self.reason orelse DEFAULT_REASON);
             return .{ .exception = ex };
         }
         return .{ .undefined = {} };

src/browser/html/History.zig

@@ -71,7 +71,7 @@ pub fn get_state(self: *History, page: *Page) !?js.Value {
     if (self.current) |curr| {
         const entry = self.stack.items[curr];
         if (entry.state) |state| {
-            const value = try js.Value.fromJson(page.main_context, state);
+            const value = try js.Value.fromJson(page.js, state);
             return value;
         } else {
             return null;
@@ -201,7 +201,7 @@ pub const PopStateEvent = struct {
 
     pub fn get_state(self: *const PopStateEvent, page: *Page) !?js.Value {
         if (self.state) |state| {
-            const value = try js.Value.fromJson(page.main_context, state);
+            const value = try js.Value.fromJson(page.js, state);
             return value;
         } else {
             return null;

src/browser/html/window.zig

@@ -37,7 +37,6 @@ const domcss = @import("../dom/css.zig");
 const Css = @import("../css/css.zig").Css;
 const EventHandler = @import("../events/event.zig").EventHandler;
 
-const v8 = @import("v8");
 const Request = @import("../fetch/Request.zig");
 const fetchFn = @import("../fetch/fetch.zig").fetch;
 

src/browser/js/Caller.zig

@@ -77,9 +77,9 @@ pub fn constructor(self: *Caller, comptime Struct: type, comptime named_function
     const this = info.getThis();
     if (@typeInfo(ReturnType) == .error_union) {
         const non_error_res = res catch |err| return err;
-        _ = try Context.mapZigInstanceToJs(self.v8_context, this, non_error_res);
+        _ = try self.context.mapZigInstanceToJs(this, non_error_res);
     } else {
-        _ = try Context.mapZigInstanceToJs(self.v8_context, this, res);
+        _ = try self.context.mapZigInstanceToJs(this, res);
     }
     info.getReturnValue().set(this);
 }
@@ -209,7 +209,7 @@ fn namedSetOrDeleteCall(res: anytype, has_value: bool) !u8 {
 }
 
 fn nameToString(self: *Caller, name: v8.Name) ![]const u8 {
-    return js.valueToString(self.call_arena, .{ .handle = name.handle }, self.isolate, self.v8_context);
+    return self.context.valueToString(.{ .handle = name.handle }, .{});
 }
 
 fn isSelfReceiver(comptime Struct: type, comptime named_function: NamedFunction) bool {
@@ -258,7 +258,7 @@ pub fn handleError(self: *Caller, comptime Struct: type, comptime named_function
 
     if (comptime @import("builtin").mode == .Debug and @hasDecl(@TypeOf(info), "length")) {
         if (log.enabled(.js, .warn)) {
-            logFunctionCallError(self.call_arena, self.isolate, self.v8_context, err, named_function.full_name, info);
+            self.logFunctionCallError(err, named_function.full_name, info);
         }
     }
 
@@ -461,6 +461,38 @@ fn getArgs(self: *const Caller, comptime Struct: type, comptime named_function:
     return args;
 }
 
+// This is extracted to speed up compilation. When left inlined in handleError,
+// this can add as much as 10 seconds of compilation time.
+fn logFunctionCallError(self: *Caller, err: anyerror, function_name: []const u8, info: v8.FunctionCallbackInfo) void {
+    const args_dump = self.serializeFunctionArgs(info) catch "failed to serialize args";
+    log.info(.js, "function call error", .{
+        .name = function_name,
+        .err = err,
+        .args = args_dump,
+        .stack = self.context.stackTrace() catch |err1| @errorName(err1),
+    });
+}
+
+fn serializeFunctionArgs(self: *Caller, info: v8.FunctionCallbackInfo) ![]const u8 {
+    const separator = log.separator();
+    const js_parameter_count = info.length();
+
+    const context = self.context;
+    var arr: std.ArrayListUnmanaged(u8) = .{};
+    for (0..js_parameter_count) |i| {
+        const js_value = info.getArg(@intCast(i));
+        const value_string = try context.valueToDetailString(js_value);
+        const value_type = try context.jsStringToZig(try js_value.typeOf(self.isolate), .{});
+        try std.fmt.format(arr.writer(context.call_arena), "{s}{d}: {s} ({s})", .{
+            separator,
+            i + 1,
+            value_string,
+            value_type,
+        });
+    }
+    return arr.items;
+}
+
 // We want the function name, or more precisely, the "Struct.function" for
 // displaying helpful @compileError.
 // However, there's no way to get the name from a std.Builtin.Fn, so we create
@@ -524,37 +556,6 @@ fn isPage(comptime T: type) bool {
     return T == *Page or T == *const Page;
 }
 
-// This is extracted to speed up compilation. When left inlined in handleError,
-// this can add as much as 10 seconds of compilation time.
-fn logFunctionCallError(arena: Allocator, isolate: v8.Isolate, context: v8.Context, err: anyerror, function_name: []const u8, info: v8.FunctionCallbackInfo) void {
-    const args_dump = serializeFunctionArgs(arena, isolate, context, info) catch "failed to serialize args";
-    log.info(.js, "function call error", .{
-        .name = function_name,
-        .err = err,
-        .args = args_dump,
-        .stack = Context.stackForLogs(arena, isolate) catch |err1| @errorName(err1),
-    });
-}
-
-fn serializeFunctionArgs(arena: Allocator, isolate: v8.Isolate, context: v8.Context, info: v8.FunctionCallbackInfo) ![]const u8 {
-    const separator = log.separator();
-    const js_parameter_count = info.length();
-
-    var arr: std.ArrayListUnmanaged(u8) = .{};
-    for (0..js_parameter_count) |i| {
-        const js_value = info.getArg(@intCast(i));
-        const value_string = try js.valueToDetailString(arena, js_value, isolate, context);
-        const value_type = try js.stringToZig(arena, try js_value.typeOf(isolate), isolate);
-        try std.fmt.format(arr.writer(arena), "{s}{d}: {s} ({s})", .{
-            separator,
-            i + 1,
-            value_string,
-            value_type,
-        });
-    }
-    return arr.items;
-}
-
 fn createTypeException(isolate: v8.Isolate, msg: []const u8) v8.Value {
     return v8.Exception.initTypeError(v8.String.initUtf8(isolate, msg));
 }