wip

Makefile

@@ -727,7 +727,7 @@ build-obj-wasm:
 
 .PHONY: build-obj-wasm-small
 build-obj-wasm-small:
-	$(ZIG) build bun-wasm -Doptimize=ReleaseFast -Dtarget=wasm32-freestanding
+	$(ZIG) build obj -Doptimize=ReleaseFast -Dtarget=wasm32-freestanding
 	emcc -sEXPORTED_FUNCTIONS="['_bun_free', '_cycleStart', '_cycleEnd', '_bun_malloc', '_scan', '_transform', '_init', '_getTests']" \
 		-Oz -s ERROR_ON_UNDEFINED_SYMBOLS=0  -DNDEBUG  \
 		$(BUN_DEPS_DIR)/$(MIMALLOC_FILE).wasm  \
@@ -829,8 +829,7 @@ fmt: fmt-cpp fmt-zig
 
 .PHONY: api
 api:
-	./node_modules/.bin/peechy --schema src/api/schema.peechy --esm src/api/schema.js --ts src/api/schema.d.ts --zig src/api/schema.zig
-	$(ZIG) fmt src/api/schema.zig
+	
 
 .PHONY: node-fallbacks
 node-fallbacks:

root_wasm.zig

@@ -10,6 +10,9 @@ pub const JavaScriptCore = struct {
     }
 
     pub const ZigString = struct {};
+    pub const JSGlobalObject = struct {};
+    pub const JSValue = enum(i64) {};
+    pub const RuntimeTranspilerCache = struct {};
 };
 
 pub const C = struct {};

src/Global.zig

@@ -112,9 +112,9 @@ pub fn isExiting() bool {
 /// Flushes stdout and stderr (in exit/quick_exit callback) and exits with the given code.
 pub fn exit(code: u32) noreturn {
     is_exiting.store(true, .monotonic);
-
-    // If we are crashing, allow the crash handler to finish it's work.
-    bun.crash_handler.sleepForeverIfAnotherThreadIsCrashing();
+    if (comptime Environment.isNative)
+        // If we are crashing, allow the crash handler to finish it's work.
+        bun.crash_handler.sleepForeverIfAnotherThreadIsCrashing();
 
     switch (Environment.os) {
         .mac => std.c.exit(@bitCast(code)),
@@ -122,6 +122,9 @@ pub fn exit(code: u32) noreturn {
             Bun__onExit();
             std.os.windows.kernel32.ExitProcess(code);
         },
+        .wasm => {
+            @panic("Bun has crashed");
+        },
         else => bun.C.quick_exit(@bitCast(code)),
     }
 }

src/api/schema.js

@@ -148,9 +148,14 @@ function encodeStackFrame(message, bb) {
 function decodeStackFramePosition(bb) {
   var result = {};
 
+  result["source_offset"] = bb.readInt32();
   result["line"] = bb.readInt32();
-  result["column"] = bb.readInt32();
-
+  result["line_start"] = bb.readInt32();
+  result["line_stop"] = bb.readInt32();
+  result["column_start"] = bb.readInt32();
+  result["column_stop"] = bb.readInt32();
+  result["expression_start"] = bb.readInt32();
+  result["expression_stop"] = bb.readInt32();
   return result;
 }
 
@@ -3434,159 +3439,157 @@ function encodeGetTestsResponse(message, bb) {
   }
 }
 
-export {
-  CSSInJSBehavior,
-  CSSInJSBehaviorKeys,
-  DotEnvBehavior,
-  DotEnvBehaviorKeys,
-  FallbackStep,
-  FallbackStepKeys,
-  FrameworkEntryPointType,
-  FrameworkEntryPointTypeKeys,
-  ImportKind,
-  ImportKindKeys,
-  JSXRuntime,
-  JSXRuntimeKeys,
-  Loader,
-  LoaderKeys,
-  MessageLevel,
-  MessageLevelKeys,
-  ModuleImportType,
-  ModuleImportTypeKeys,
-  Reloader,
-  ReloaderKeys,
-  ResolveMode,
-  ResolveModeKeys,
-  ScanDependencyMode,
-  ScanDependencyModeKeys,
-  SourceMapMode,
-  SourceMapModeKeys,
-  StackFrameScope,
-  StackFrameScopeKeys,
-  Target,
-  TargetKeys,
-  TestKind,
-  TestKindKeys,
-  TransformResponseStatus,
-  TransformResponseStatusKeys,
-  WebsocketCommandKind,
-  WebsocketCommandKindKeys,
-  WebsocketMessageKind,
-  WebsocketMessageKindKeys,
-  decodeBunInstall,
-  decodeClientServerModule,
-  decodeClientServerModuleManifest,
-  decodeEnvConfig,
-  decodeFallbackMessageContainer,
-  decodeFileHandle,
-  decodeFrameworkConfig,
-  decodeFrameworkEntryPoint,
-  decodeFrameworkEntryPointMap,
-  decodeFrameworkEntryPointMessage,
-  decodeGetTestsRequest,
-  decodeGetTestsResponse,
-  decodeJSException,
-  decodeJSX,
-  decodeJavascriptBundle,
-  decodeJavascriptBundleContainer,
-  decodeJavascriptBundledModule,
-  decodeJavascriptBundledPackage,
-  decodeLoadedEnvConfig,
-  decodeLoadedFramework,
-  decodeLoadedRouteConfig,
-  decodeLoaderMap,
-  decodeLocation,
-  decodeLog,
-  decodeMessage,
-  decodeMessageData,
-  decodeMessageMeta,
-  decodeModule,
-  decodeModuleImportRecord,
-  decodeNPMRegistry,
-  decodeNPMRegistryMap,
-  decodeOutputFile,
-  decodeProblems,
-  decodeRouteConfig,
-  decodeRouter,
-  decodeScan,
-  decodeScanResult,
-  decodeScannedImport,
-  decodeSourceLine,
-  decodeStackFrame,
-  decodeStackFramePosition,
-  decodeStackTrace,
-  decodeStringMap,
-  decodeStringPointer,
-  decodeTestResponseItem,
-  decodeTransform,
-  decodeTransformOptions,
-  decodeTransformResponse,
-  decodeWebsocketCommand,
-  decodeWebsocketCommandBuild,
-  decodeWebsocketCommandBuildWithFilePath,
-  decodeWebsocketCommandManifest,
-  decodeWebsocketMessage,
-  decodeWebsocketMessageBuildFailure,
-  decodeWebsocketMessageBuildSuccess,
-  decodeWebsocketMessageFileChangeNotification,
-  decodeWebsocketMessageResolveID,
-  decodeWebsocketMessageWelcome,
-  encodeBunInstall,
-  encodeClientServerModule,
-  encodeClientServerModuleManifest,
-  encodeEnvConfig,
-  encodeFallbackMessageContainer,
-  encodeFileHandle,
-  encodeFrameworkConfig,
-  encodeFrameworkEntryPoint,
-  encodeFrameworkEntryPointMap,
-  encodeFrameworkEntryPointMessage,
-  encodeGetTestsRequest,
-  encodeGetTestsResponse,
-  encodeJSException,
-  encodeJSX,
-  encodeJavascriptBundle,
-  encodeJavascriptBundleContainer,
-  encodeJavascriptBundledModule,
-  encodeJavascriptBundledPackage,
-  encodeLoadedEnvConfig,
-  encodeLoadedFramework,
-  encodeLoadedRouteConfig,
-  encodeLoaderMap,
-  encodeLocation,
-  encodeLog,
-  encodeMessage,
-  encodeMessageData,
-  encodeMessageMeta,
-  encodeModule,
-  encodeModuleImportRecord,
-  encodeNPMRegistry,
-  encodeNPMRegistryMap,
-  encodeOutputFile,
-  encodeProblems,
-  encodeRouteConfig,
-  encodeRouter,
-  encodeScan,
-  encodeScanResult,
-  encodeScannedImport,
-  encodeSourceLine,
-  encodeStackFrame,
-  encodeStackFramePosition,
-  encodeStackTrace,
-  encodeStringMap,
-  encodeStringPointer,
-  encodeTestResponseItem,
-  encodeTransform,
-  encodeTransformOptions,
-  encodeTransformResponse,
-  encodeWebsocketCommand,
-  encodeWebsocketCommandBuild,
-  encodeWebsocketCommandBuildWithFilePath,
-  encodeWebsocketCommandManifest,
-  encodeWebsocketMessage,
-  encodeWebsocketMessageBuildFailure,
-  encodeWebsocketMessageBuildSuccess,
-  encodeWebsocketMessageFileChangeNotification,
-  encodeWebsocketMessageResolveID,
-  encodeWebsocketMessageWelcome,
-};
+export { Loader };
+export { LoaderKeys };
+export { FrameworkEntryPointType };
+export { FrameworkEntryPointTypeKeys };
+export { StackFrameScope };
+export { StackFrameScopeKeys };
+export { decodeStackFrame };
+export { encodeStackFrame };
+export { decodeStackFramePosition };
+export { encodeStackFramePosition };
+export { decodeSourceLine };
+export { encodeSourceLine };
+export { decodeStackTrace };
+export { encodeStackTrace };
+export { decodeJSException };
+export { encodeJSException };
+export { FallbackStep };
+export { FallbackStepKeys };
+export { decodeProblems };
+export { encodeProblems };
+export { decodeRouter };
+export { encodeRouter };
+export { decodeFallbackMessageContainer };
+export { encodeFallbackMessageContainer };
+export { ResolveMode };
+export { ResolveModeKeys };
+export { Target };
+export { TargetKeys };
+export { CSSInJSBehavior };
+export { CSSInJSBehaviorKeys };
+export { JSXRuntime };
+export { JSXRuntimeKeys };
+export { decodeJSX };
+export { encodeJSX };
+export { decodeStringPointer };
+export { encodeStringPointer };
+export { decodeJavascriptBundledModule };
+export { encodeJavascriptBundledModule };
+export { decodeJavascriptBundledPackage };
+export { encodeJavascriptBundledPackage };
+export { decodeJavascriptBundle };
+export { encodeJavascriptBundle };
+export { decodeJavascriptBundleContainer };
+export { encodeJavascriptBundleContainer };
+export { ScanDependencyMode };
+export { ScanDependencyModeKeys };
+export { ModuleImportType };
+export { ModuleImportTypeKeys };
+export { decodeModuleImportRecord };
+export { encodeModuleImportRecord };
+export { decodeModule };
+export { encodeModule };
+export { decodeStringMap };
+export { encodeStringMap };
+export { decodeLoaderMap };
+export { encodeLoaderMap };
+export { DotEnvBehavior };
+export { DotEnvBehaviorKeys };
+export { decodeEnvConfig };
+export { encodeEnvConfig };
+export { decodeLoadedEnvConfig };
+export { encodeLoadedEnvConfig };
+export { decodeFrameworkConfig };
+export { encodeFrameworkConfig };
+export { decodeFrameworkEntryPoint };
+export { encodeFrameworkEntryPoint };
+export { decodeFrameworkEntryPointMap };
+export { encodeFrameworkEntryPointMap };
+export { decodeFrameworkEntryPointMessage };
+export { encodeFrameworkEntryPointMessage };
+export { decodeLoadedFramework };
+export { encodeLoadedFramework };
+export { decodeLoadedRouteConfig };
+export { encodeLoadedRouteConfig };
+export { decodeRouteConfig };
+export { encodeRouteConfig };
+export { decodeTransformOptions };
+export { encodeTransformOptions };
+export { SourceMapMode };
+export { SourceMapModeKeys };
+export { decodeFileHandle };
+export { encodeFileHandle };
+export { decodeTransform };
+export { encodeTransform };
+export { decodeScan };
+export { encodeScan };
+export { decodeScanResult };
+export { encodeScanResult };
+export { decodeScannedImport };
+export { encodeScannedImport };
+export { ImportKind };
+export { ImportKindKeys };
+export { TransformResponseStatus };
+export { TransformResponseStatusKeys };
+export { decodeOutputFile };
+export { encodeOutputFile };
+export { decodeTransformResponse };
+export { encodeTransformResponse };
+export { MessageLevel };
+export { MessageLevelKeys };
+export { decodeLocation };
+export { encodeLocation };
+export { decodeMessageData };
+export { encodeMessageData };
+export { decodeMessageMeta };
+export { encodeMessageMeta };
+export { decodeMessage };
+export { encodeMessage };
+export { decodeLog };
+export { encodeLog };
+export { Reloader };
+export { ReloaderKeys };
+export { WebsocketMessageKind };
+export { WebsocketMessageKindKeys };
+export { WebsocketCommandKind };
+export { WebsocketCommandKindKeys };
+export { decodeWebsocketMessage };
+export { encodeWebsocketMessage };
+export { decodeWebsocketMessageWelcome };
+export { encodeWebsocketMessageWelcome };
+export { decodeWebsocketMessageFileChangeNotification };
+export { encodeWebsocketMessageFileChangeNotification };
+export { decodeWebsocketCommand };
+export { encodeWebsocketCommand };
+export { decodeWebsocketCommandBuild };
+export { encodeWebsocketCommandBuild };
+export { decodeWebsocketCommandManifest };
+export { encodeWebsocketCommandManifest };
+export { decodeWebsocketMessageBuildSuccess };
+export { encodeWebsocketMessageBuildSuccess };
+export { decodeWebsocketMessageBuildFailure };
+export { encodeWebsocketMessageBuildFailure };
+export { decodeWebsocketCommandBuildWithFilePath };
+export { encodeWebsocketCommandBuildWithFilePath };
+export { decodeWebsocketMessageResolveID };
+export { encodeWebsocketMessageResolveID };
+export { decodeNPMRegistry };
+export { encodeNPMRegistry };
+export { decodeNPMRegistryMap };
+export { encodeNPMRegistryMap };
+export { decodeBunInstall };
+export { encodeBunInstall };
+export { decodeClientServerModule };
+export { encodeClientServerModule };
+export { decodeClientServerModuleManifest };
+export { encodeClientServerModuleManifest };
+export { decodeGetTestsRequest };
+export { encodeGetTestsRequest };
+export { TestKind };
+export { TestKindKeys };
+export { decodeTestResponseItem };
+export { encodeTestResponseItem };
+export { decodeGetTestsResponse };
+export { encodeGetTestsResponse };

src/api/schema.zig

@@ -117,7 +117,7 @@ pub const Reader = struct {
     pub inline fn readInt(this: *Self, comptime T: type) !T {
         const slice = try this.read(@sizeOf(T));
 
-        return std.mem.readIntSliceNative(T, slice);
+        return std.mem.readInt(T, slice, .little);
     }
 
     pub inline fn readBool(this: *Self) !bool {

src/bun.zig

@@ -3003,7 +3003,11 @@ pub const Dirname = struct {
 
 pub noinline fn outOfMemory() noreturn {
     @setCold(true);
-    crash_handler.crashHandler(.out_of_memory, null, @returnAddress());
+    if (comptime Environment.isNative) {
+        crash_handler.crashHandler(.out_of_memory, null, @returnAddress());
+    } else {
+        @panic("Bun has crashed");
+    }
 }
 
 pub fn todoPanic(src: std.builtin.SourceLocation, comptime format: string, args: anytype) noreturn {

src/feature_flags.zig

@@ -156,7 +156,7 @@ pub fn isLibdeflateEnabled() bool {
 }
 
 /// Enable Bun Kit's experimental bundler tools
-pub const bake = env.is_canary or env.isDebug;
+pub const bake = bun.Environment.isNative and (env.is_canary or env.isDebug);
 
 /// Additional debugging features for Bake, such as the incremental visualizer.
 pub const bake_debugging_features = bake and (env.is_canary or env.isDebug);

src/js_ast.zig

@@ -1809,7 +1809,7 @@ pub const E = struct {
         pub fn toStringFromF64(value: f64, allocator: std.mem.Allocator) ?string {
             if (value == @trunc(value) and (value < std.math.maxInt(i32) and value > std.math.minInt(i32))) {
                 const int_value = @as(i64, @intFromFloat(value));
-                const abs = @as(u64, @intCast(@abs(int_value)));
+                const abs = @as(usize, @intCast(@abs(int_value)));
 
                 // do not allocate for a small set of constant numbers: -100 through 100
                 if (abs < double_digit.len) {

src/js_parser.zig

@@ -4035,10 +4035,12 @@ pub const Parser = struct {
             for (p.import_records.items) |*item| {
                 // skip if they did import it
                 if (strings.eqlComptime(item.path.text, "bun:test") or strings.eqlComptime(item.path.text, "@jest/globals") or strings.eqlComptime(item.path.text, "vitest")) {
-                    if (p.options.features.runtime_transpiler_cache) |cache| {
-                        // If we rewrote import paths, we need to disable the runtime transpiler cache
-                        if (!strings.eqlComptime(item.path.text, "bun:test")) {
-                            cache.input_hash = null;
+                    if (Environment.isNative) {
+                        if (p.options.features.runtime_transpiler_cache) |cache| {
+                            // If we rewrote import paths, we need to disable the runtime transpiler cache
+                            if (!strings.eqlComptime(item.path.text, "bun:test")) {
+                                cache.input_hash = null;
+                            }
                         }
                     }
 
@@ -4099,9 +4101,11 @@ pub const Parser = struct {
                 .tag = .bun_test,
             }) catch unreachable;
 
-            // If we injected jest globals, we need to disable the runtime transpiler cache
-            if (p.options.features.runtime_transpiler_cache) |cache| {
-                cache.input_hash = null;
+            if (comptime Environment.isNative) {
+                // If we injected jest globals, we need to disable the runtime transpiler cache
+                if (p.options.features.runtime_transpiler_cache) |cache| {
+                    cache.input_hash = null;
+                }
             }
         }
 

src/js_printer.zig

@@ -912,7 +912,7 @@ fn NewPrinter(
             const written = @call(
                 .always_inline,
                 std.fmt.bufPrint,
-                .{ ptr[0..len], str, args },
+                .{ ptr[0..@intCast(len)], str, args },
             ) catch unreachable;
 
             p.writer.advance(written.len);
@@ -5564,7 +5564,7 @@ pub const BufferWriter = struct {
         return ctx.last_bytes[0];
     }
 
-    pub fn reserveNext(ctx: *BufferWriter, count: u64) anyerror![*]u8 {
+    pub fn reserveNext(ctx: *BufferWriter, count: usize) anyerror![*]u8 {
         try ctx.buffer.growIfNeeded(count);
         return @as([*]u8, @ptrCast(&ctx.buffer.list.items.ptr[ctx.buffer.list.items.len]));
     }

src/jsc_stub.zig

@@ -9,3 +9,5 @@ pub const API = struct {
 pub const Node = struct {};
 
 pub const VirtualMachine = struct {};
+pub const JSGlobalObject = struct {};
+pub const RuntimeTranspilerCache = struct {};

src/logger.zig

@@ -276,7 +276,7 @@ pub const Data = struct {
                 const line_text_right_trimmed = std.mem.trimRight(u8, line_text_, " \r\n\t");
                 const line_text = std.mem.trimLeft(u8, line_text_right_trimmed, "\n\r");
                 if (location.column > -1 and line_text.len > 0) {
-                    var line_offset_for_second_line: usize = @intCast(location.column - 1);
+                    var line_offset_for_second_line: u64 = @intCast(location.column - 1);
 
                     if (location.line > -1) {
                         switch (kind == .err or kind == .warn) {
@@ -300,7 +300,7 @@ pub const Data = struct {
                         .redact_sensitive_information = redact_sensitive_information,
                     })});
 
-                    try to.writeByteNTimes(' ', line_offset_for_second_line);
+                    try to.writeByteNTimes(' ', @intCast(line_offset_for_second_line));
                     if ((comptime enable_ansi_colors) and message_color.len > 0) {
                         try to.writeAll(message_color);
                         try to.writeAll(color_name);

src/main_wasm.zig

@@ -193,12 +193,12 @@ export fn init(heapsize: u32) void {
         Mimalloc.mi_option_set(.limit_os_alloc, 1);
         _ = Mimalloc.mi_reserve_os_memory(heapsize, false, true);
 
-        JSAst.Stmt.Data.Store.create(default_allocator);
-        JSAst.Expr.Data.Store.create(default_allocator);
+        JSAst.Stmt.Data.Store.create();
+        JSAst.Expr.Data.Store.create();
         buffer_writer = JSPrinter.BufferWriter.init(default_allocator) catch unreachable;
         buffer_writer.buffer.growBy(1024) catch unreachable;
         writer = JSPrinter.BufferPrinter.init(buffer_writer);
-        define = Define.Define.init(default_allocator, null, null) catch unreachable;
+        define = Define.Define.init(default_allocator, null, null, false) catch unreachable;
         output_source = global.Output.Source.init(output_stream, error_stream);
         global.Output.Source.set(&output_source);
     } else {
@@ -449,11 +449,11 @@ const TestAnalyzer = struct {
 };
 export fn getTests(opts_array: u64) u64 {
     var arena = Arena.init() catch unreachable;
-    var allocator = arena.allocator();
+    const allocator = arena.allocator();
     defer arena.deinit();
     var log_ = Logger.Log.init(allocator);
     var reader = ApiReader.init(Uint8Array.fromJS(opts_array), allocator);
-    var opts = Api.GetTestsRequest.decode(&reader) catch bun.outOfMemory();
+    const opts = Api.GetTestsRequest.decode(&reader) catch bun.outOfMemory();
     var code = Logger.Source.initPathString(if (opts.path.len > 0) opts.path else "my-test-file.test.tsx", opts.contents);
     code.contents_is_recycled = true;
     defer {
@@ -488,7 +488,7 @@ export fn getTests(opts_array: u64) u64 {
     };
 
     var output = std.ArrayList(u8).init(default_allocator);
-    var output_writer = output.writer();
+    const output_writer = output.writer();
     const Encoder = ApiWriter(@TypeOf(output_writer));
     var encoder = Encoder.init(output_writer);
     var response = Api.GetTestsResponse{
@@ -503,12 +503,12 @@ export fn getTests(opts_array: u64) u64 {
 export fn transform(opts_array: u64) u64 {
     // var arena = bun.ArenaAllocator.init(default_allocator);
     var arena = Arena.init() catch unreachable;
-    var allocator = arena.allocator();
+    const allocator = arena.allocator();
     defer arena.deinit();
     log = Logger.Log.init(allocator);
 
     var reader = ApiReader.init(Uint8Array.fromJS(opts_array), allocator);
-    var opts = Api.Transform.decode(&reader) catch unreachable;
+    const opts = Api.Transform.decode(&reader) catch unreachable;
     const loader_ = opts.loader orelse Api.Loader.tsx;
 
     defer {
@@ -535,7 +535,7 @@ export fn transform(opts_array: u64) u64 {
     parser.options.features.top_level_await = true;
     const result = parser.parse() catch unreachable;
     if (result == .ast and log.errors == 0) {
-        var symbols = JSAst.Symbol.NestedList.init(&[_]JSAst.Symbol.List{result.ast.symbols});
+        const symbols = JSAst.Symbol.NestedList.init(&[_]JSAst.Symbol.List{result.ast.symbols});
 
         _ = JSPrinter.printAst(
             @TypeOf(&writer),
@@ -563,7 +563,7 @@ export fn transform(opts_array: u64) u64 {
     };
 
     var output = std.ArrayList(u8).init(default_allocator);
-    var output_writer = output.writer();
+    const output_writer = output.writer();
     const Encoder = ApiWriter(@TypeOf(output_writer));
     var encoder = Encoder.init(output_writer);
     transform_response.encode(&encoder) catch {};
@@ -578,7 +578,7 @@ export fn scan(opts_array: u64) u64 {
     log = Logger.Log.init(allocator);
 
     var reader = ApiReader.init(Uint8Array.fromJS(opts_array), allocator);
-    var opts = Api.Scan.decode(&reader) catch unreachable;
+    const opts = Api.Scan.decode(&reader) catch unreachable;
     const loader_ = opts.loader orelse Api.Loader.tsx;
 
     defer {
@@ -606,7 +606,7 @@ export fn scan(opts_array: u64) u64 {
     if (log.errors == 0) {
         var scan_result = std.mem.zeroes(Api.ScanResult);
         var output = std.ArrayList(u8).init(default_allocator);
-        var output_writer = output.writer();
+        const output_writer = output.writer();
         const Encoder = ApiWriter(@TypeOf(output_writer));
 
         if (result == .ast) {
@@ -630,7 +630,7 @@ export fn scan(opts_array: u64) u64 {
         return @as(u64, @bitCast([2]u32{ @intFromPtr(output.items.ptr), output.items.len }));
     } else {
         var output = std.ArrayList(u8).init(default_allocator);
-        var output_writer = output.writer();
+        const output_writer = output.writer();
         const Encoder = ApiWriter(@TypeOf(output_writer));
         var scan_result = Api.ScanResult{
             .exports = &.{},

src/output.zig

@@ -263,7 +263,7 @@ pub const Source = struct {
         pub fn restore() void {
             if (Environment.isWindows) {
                 WindowsStdio.restore();
-            } else {
+            } else if (comptime bun.Environment.isNative) {
                 bun.C.bun_restore_stdio();
             }
         }

src/resolver/resolve_path.zig

@@ -2044,6 +2044,10 @@ export fn ResolvePath__joinAbsStringBufCurrentPlatformBunString(
     globalObject: *bun.JSC.JSGlobalObject,
     in: bun.String,
 ) bun.String {
+    if (comptime bun.Environment.isWasm) {
+        unreachable;
+    }
+
     const str = in.toUTF8WithoutRef(bun.default_allocator);
     defer str.deinit();
 

src/string_immutable.zig

@@ -359,6 +359,9 @@ fn startsWithRedactedItem(text: string, comptime item: string) ?struct { usize,
 
 /// Returns offset and length of first secret found.
 pub fn startsWithSecret(str: string) ?struct { usize, usize } {
+    if (comptime bun.Environment.isWasm) {
+        unreachable;
+    }
     if (startsWithRedactedItem(str, "_auth")) |auth| {
         const offset, const len = auth;
         return .{ offset, len };
@@ -1108,6 +1111,10 @@ pub fn eqlCaseInsensitiveASCII(a: string, b: string, comptime check_len: bool) b
     bun.unsafeAssert(b.len > 0);
     bun.unsafeAssert(a.len > 0);
 
+    if (comptime bun.Environment.isWasm) {
+        return std.ascii.eqlIgnoreCase(a, b);
+    }
+
     return bun.C.strncasecmp(a.ptr, b.ptr, a.len) == 0;
 }