diff --git a/src/bun.js/bindings/bindings.zig b/src/bun.js/bindings/bindings.zig
index 4c2325ff11..d4c50d15c8 100644
--- a/src/bun.js/bindings/bindings.zig
+++ b/src/bun.js/bindings/bindings.zig
@@ -5922,13 +5922,17 @@ pub const JSHostFunctionType = fn (*JSGlobalObject, *CallFrame) callconv(.C) JSV
 pub const JSHostFunctionPtr = *const JSHostFunctionType;
 const DeinitFunction = *const fn (ctx: *anyopaque, buffer: [*]u8, len: usize) callconv(.C) void;
 
-pub const JSArray = struct {
+pub const JSArray = opaque {
     // TODO(@paperdave): this can throw
     extern fn JSArray__constructArray(*JSGlobalObject, [*]const JSValue, usize) JSValue;
 
     pub fn create(global: *JSGlobalObject, items: []const JSValue) JSValue {
         return JSArray__constructArray(global, items.ptr, items.len);
     }
+
+    pub fn iterator(array: *JSArray, global: *JSGlobalObject) JSArrayIterator {
+        return JSValue.fromCell(array).arrayIterator(global);
+    }
 };
 
 const private = struct {
diff --git a/src/bun.js/bindings/exports.zig b/src/bun.js/bindings/exports.zig
index 4b40aff2f4..76476df03d 100644
--- a/src/bun.js/bindings/exports.zig
+++ b/src/bun.js/bindings/exports.zig
@@ -114,6 +114,10 @@ pub const ErrorCode = enum(ErrorCodeInt) {
         return @as(ErrorCode, @enumFromInt(@intFromError(code)));
     }
 
+    pub inline fn toError(self: ErrorCode) anyerror {
+        return @errorFromInt(@intFromEnum(self));
+    }
+
     pub const ParserError = @intFromEnum(ErrorCode.from(error.ParserError));
     pub const JSErrorObject = @intFromEnum(ErrorCode.from(error.JSErrorObject));
 
@@ -154,6 +158,14 @@ pub fn Errorable(comptime Type: type) type {
             err: ZigErrorType,
         };
 
+        pub fn unwrap(errorable: @This()) !Type {
+            if (errorable.success) {
+                return errorable.result.value;
+            } else {
+                return errorable.result.err.code.toError();
+            }
+        }
+
         pub fn value(val: Type) @This() {
             return @This(){ .result = .{ .value = val }, .success = true };
         }
@@ -959,3 +971,60 @@ pub export fn Bun__LoadLibraryBunString(str: *bun.String) ?*anyopaque {
     const LOAD_WITH_ALTERED_SEARCH_PATH = 0x00000008;
     return bun.windows.LoadLibraryExW(buf[0..data.len :0].ptr, null, LOAD_WITH_ALTERED_SEARCH_PATH);
 }
+
+// https://github.com/nodejs/node/blob/40ef9d541ed79470977f90eb445c291b95ab75a0/lib/internal/modules/cjs/loader.js#L666
+pub export fn NodeModuleModule__findPath(
+    global: *JSGlobalObject,
+    request_bun_str: bun.String,
+    paths_maybe: ?*JSC.JSArray,
+) JSValue {
+    var stack_buf = std.heap.stackFallback(8192, default_allocator);
+    const alloc = stack_buf.get();
+
+    const request_slice = request_bun_str.toUTF8(alloc);
+    defer request_slice.deinit();
+    const request = request_slice.slice();
+
+    const absolute_request = std.fs.path.isAbsolute(request);
+    if (!absolute_request and paths_maybe == null) {
+        return .false;
+    }
+
+    // for each path
+    const found = if (paths_maybe) |paths| found: {
+        var iter = paths.iterator(global);
+        while (iter.next()) |path| {
+            const cur_path = bun.String.tryFromJS(path, global) orelse continue;
+            defer cur_path.deref();
+
+            if (findPathInner(request_bun_str, cur_path, global)) |found| {
+                break :found found;
+            }
+        }
+
+        break :found null;
+    } else findPathInner(request_bun_str, bun.String.static(""), global);
+
+    if (found) |str| {
+        return str.toJS(global);
+    }
+
+    return .false;
+}
+
+fn findPathInner(
+    request: bun.String,
+    cur_path: bun.String,
+    global: *JSGlobalObject,
+) ?bun.String {
+    var errorable: ErrorableString = undefined;
+    JSC.VirtualMachine.resolve(
+        &errorable,
+        global,
+        request,
+        cur_path,
+        null,
+        false,
+    );
+    return errorable.unwrap() catch null;
+}
diff --git a/src/bun.js/javascript.zig b/src/bun.js/javascript.zig
index 042c6b2d3b..5ff730f06c 100644
--- a/src/bun.js/javascript.zig
+++ b/src/bun.js/javascript.zig
@@ -1853,7 +1853,7 @@ pub const VirtualMachine = struct {
         global: *JSGlobalObject,
         specifier: bun.String,
         source: bun.String,
-        query_string: *ZigString,
+        query_string: ?*ZigString,
         is_esm: bool,
     ) void {
         resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, false);
@@ -1864,7 +1864,7 @@ pub const VirtualMachine = struct {
         global: *JSGlobalObject,
         specifier: bun.String,
         source: bun.String,
-        query_string: *ZigString,
+        query_string: ?*ZigString,
         is_esm: bool,
     ) void {
         resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, true);
@@ -1875,7 +1875,7 @@ pub const VirtualMachine = struct {
         global: *JSGlobalObject,
         specifier: bun.String,
         source: bun.String,
-        query_string: *ZigString,
+        query_string: ?*ZigString,
         is_esm: bool,
     ) void {
         resolveMaybeNeedsTrailingSlash(res, global, specifier, source, query_string, is_esm, true);
diff --git a/src/bun.js/module_loader.zig b/src/bun.js/module_loader.zig
index 9ef6dbdc43..1b5847509f 100644
--- a/src/bun.js/module_loader.zig
+++ b/src/bun.js/module_loader.zig
@@ -2970,3 +2970,8 @@ export fn Bun__resolveEmbeddedNodeFile(vm: *JSC.VirtualMachine, in_out_str: *bun
     in_out_str.* = bun.String.createUTF8(result);
     return true;
 }
+
+export fn ModuleLoader__isBuiltin(data: [*]const u8, len: usize) bool {
+    const str = data[0..len];
+    return HardcodedModule.Map.get(str) != null;
+}
diff --git a/src/bun.js/modules/NodeModuleModule.h b/src/bun.js/modules/NodeModuleModule.h
index 1891723ec6..f7639da82e 100644
--- a/src/bun.js/modules/NodeModuleModule.h
+++ b/src/bun.js/modules/NodeModuleModule.h
@@ -1,3 +1,4 @@
+// clang-format off
 #pragma once
 
 #include "CommonJSModuleRecord.h"
@@ -6,6 +7,7 @@
 #include "isBuiltinModule.h"
 #include <JavaScriptCore/JSBoundFunction.h>
 #include <JavaScriptCore/ObjectConstructor.h>
+#include "PathInlines.h"
 
 using namespace Zig;
 using namespace JSC;
@@ -92,9 +94,11 @@ static constexpr ASCIILiteral builtinModuleNames[] = {
     "zlib"_s,
 };
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callFrame)) {
+JSC_DEFINE_HOST_FUNCTION(jsFunctionDebugNoop, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
+  return JSValue::encode(jsUndefined());
+}
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
   // In node, this is supposed to be the actual CommonJSModule constructor.
   // We are cutting a huge corner by not doing all that work.
   // This code is only to support babel.
@@ -126,20 +130,21 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleModuleConstructor,
   auto *out = Bun::JSCommonJSModule::create(vm, structure, idString, jsNull(),
                                             dirname, SourceCode());
 
-  if (!parentValue.isUndefined())
-    out->putDirect(vm, JSC::Identifier::fromString(vm, "parent"_s), parentValue,
-                   0);
+  if (!parentValue.isUndefined()) {
+    out->putDirect(vm, JSC::Identifier::fromString(vm, "parent"_s), parentValue, 0);
+  }
+
+  out->putDirect(
+    vm,
+    JSC::Identifier::fromString(vm, "exports"_s),
+    JSC::constructEmptyObject(globalObject, globalObject->objectPrototype(), 0),
+    0
+  );
 
-  out->putDirect(vm, JSC::Identifier::fromString(vm, "exports"_s),
-                 JSC::constructEmptyObject(globalObject,
-                                           globalObject->objectPrototype(), 0),
-                 0);
   return JSValue::encode(out);
 }
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBuiltinModule,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callFrame)) {
+JSC_DEFINE_HOST_FUNCTION(jsFunctionIsBuiltinModule, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
   JSC::VM &vm = globalObject->vm();
   auto scope = DECLARE_THROW_SCOPE(vm);
   JSValue moduleName = callFrame->argument(0);
@@ -163,10 +168,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionWrap, (JSC::JSGlobalObject * globalObject,
     return JSC::JSValue::encode(JSC::jsUndefined());
   }
 
-  JSString *prefix = jsString(
-      vm,
-      String(
-          "(function (exports, require, module, __filename, __dirname) { "_s));
+  JSString *prefix = jsString(vm, String( "(function (exports, require, module, __filename, __dirname) { "_s));
   JSString *suffix = jsString(vm, String("\n});"_s));
 
   return JSValue::encode(jsString(globalObject, prefix, code, suffix));
@@ -191,7 +193,6 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleCreateRequire,
       throwTypeError(globalObject, scope,
                      makeString("createRequire() was given an invalid URL '"_s,
                                 url.string(), "'"_s));
-      ;
       RELEASE_AND_RETURN(scope, JSValue::encode({}));
     }
     if (!url.protocolIsFile()) {
@@ -207,16 +208,12 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionNodeModuleCreateRequire,
       scope, JSValue::encode(Bun::JSCommonJSModule::createBoundRequireFunction(
                  vm, globalObject, val)));
 }
-extern "C" JSC::EncodedJSValue Resolver__nodeModulePathsForJS(JSGlobalObject *,
-                                                              CallFrame *);
+extern "C" JSC::EncodedJSValue Resolver__nodeModulePathsForJS(JSGlobalObject *, CallFrame *);
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionFindSourceMap,
-                         (JSGlobalObject * globalObject,
-                          CallFrame *callFrame)) {
+JSC_DEFINE_HOST_FUNCTION(jsFunctionFindSourceMap, (JSGlobalObject * globalObject, CallFrame *callFrame)) {
   auto &vm = globalObject->vm();
   auto scope = DECLARE_THROW_SCOPE(vm);
-  throwException(globalObject, scope,
-                 createError(globalObject, "Not implemented"_s));
+  throwException(globalObject, scope, createError(globalObject, "module.SourceMap is not yet implemented in Bun"_s));
   return JSValue::encode(jsUndefined());
 }
 
@@ -226,8 +223,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionSyncBuiltinExports,
   return JSValue::encode(jsUndefined());
 }
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionSourceMap, (JSGlobalObject * globalObject,
-                                               CallFrame *callFrame)) {
+JSC_DEFINE_HOST_FUNCTION(jsFunctionSourceMap, (JSGlobalObject * globalObject, CallFrame *callFrame)) {
   auto &vm = globalObject->vm();
   auto scope = DECLARE_THROW_SCOPE(vm);
   throwException(globalObject, scope,
@@ -235,9 +231,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionSourceMap, (JSGlobalObject * globalObject,
   return JSValue::encode(jsUndefined());
 }
 
-JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName,
-                         (JSC::JSGlobalObject * globalObject,
-                          JSC::CallFrame *callFrame)) {
+JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
   JSC::VM &vm = globalObject->vm();
 
   switch (callFrame->argumentCount()) {
@@ -246,7 +240,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName,
     // not "requires" because "require" could be confusing
     JSC::throwTypeError(
         globalObject, scope,
-        "Module._resolveFileName needs 2+ arguments (a string)"_s);
+        "Module._resolveFilename needs 2+ arguments (a string)"_s);
     scope.release();
     return JSC::JSValue::encode(JSC::JSValue{});
   }
@@ -257,7 +251,7 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName,
     if (moduleName.isUndefinedOrNull()) {
       auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
       JSC::throwTypeError(globalObject, scope,
-                          "Module._resolveFileName expects a string"_s);
+                          "Module._resolveFilename expects a string"_s);
       scope.release();
       return JSC::JSValue::encode(JSC::JSValue{});
     }
@@ -271,17 +265,14 @@ JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveFileName,
         // weird thing.
         (fromValue.isObject()) {
 
-      if (auto idValue = fromValue.getObject()->getIfPropertyExists(
-              globalObject, Identifier::fromString(vm, "filename"_s))) {
+      if (auto idValue = fromValue.getObject()->getIfPropertyExists(globalObject, Identifier::fromString(vm, "filename"_s))) {
         if (idValue.isString()) {
           fromValue = idValue;
         }
       }
     }
 
-    auto result =
-        Bun__resolveSync(globalObject, JSC::JSValue::encode(moduleName),
-                         JSValue::encode(fromValue), false);
+    auto result = Bun__resolveSync(globalObject, JSC::JSValue::encode(moduleName), JSValue::encode(fromValue), false);
     auto scope = DECLARE_THROW_SCOPE(globalObject->vm());
 
     if (!JSC::JSValue::decode(result).isString()) {
@@ -332,6 +323,118 @@ JSC_DEFINE_CUSTOM_SETTER(set_resolveFilename,
   return false;
 }
 
+extern "C" bool ModuleLoader__isBuiltin(const char* data, size_t len);
+
+struct Parent {
+  JSArray* paths;
+  JSString* filename;
+};
+
+Parent getParent(VM&vm, JSGlobalObject* global, JSValue maybe_parent) {
+  Parent value { nullptr, nullptr };
+  if (!maybe_parent.isCell()) {
+    return value;
+  }
+  if (!maybe_parent.isObject()) {
+    return value;
+  }
+  auto parent = maybe_parent.getObject();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+  JSValue paths = parent->get(global, Identifier::fromString(vm, "paths"_s));
+  RETURN_IF_EXCEPTION(scope, value);
+  if (paths.isCell()) {
+    value.paths = jsDynamicCast<JSArray*>(paths);
+  }
+
+  JSValue filename = parent->get(global, Identifier::fromString(vm, "filename"_s));
+  RETURN_IF_EXCEPTION(scope, value);
+  if (filename.isString()) {
+    value.filename = filename.toString(global);
+  }
+  RELEASE_AND_RETURN(scope, value);
+}
+
+// https://github.com/nodejs/node/blob/40ef9d541ed79470977f90eb445c291b95ab75a0/lib/internal/modules/cjs/loader.js#L895
+JSC_DEFINE_HOST_FUNCTION(jsFunctionResolveLookupPaths, (JSC::JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
+  auto &vm = globalObject->vm();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+  
+  String request = callFrame->argument(0).toWTFString(globalObject);
+  RETURN_IF_EXCEPTION(scope, {});
+
+  auto utf8 = request.utf8();
+  if(ModuleLoader__isBuiltin(utf8.data(), utf8.length())) {
+    return JSC::JSValue::encode(JSC::jsNull());
+  }
+
+  auto parent = getParent(vm, globalObject, callFrame->argument(1));
+  RETURN_IF_EXCEPTION(scope, {});
+
+  // Check for node modules paths.
+  if (
+    request.characterAt(0) != '.' ||
+    (request.length() > 1 &&
+      request.characterAt(1) != '.' &&
+      request.characterAt(1) != '/' &&
+#if OS(WINDOWS)
+      request.characterAt(1) != '\\'
+#else
+      true
+#endif
+    )
+  ) {
+    auto array = JSC::constructArray(globalObject, (ArrayAllocationProfile*)nullptr, nullptr, 0);
+    if (parent.paths) {
+      auto len = parent.paths->length();
+      for (size_t i = 0; i < len; i++) {
+        auto path = parent.paths->getIndex(globalObject, i);
+        array->push(globalObject, path);
+      }
+    }
+    return JSValue::encode(array);
+  }
+
+  JSString* dirname = nullptr;
+  if (parent.filename) {
+    String str = parent.filename->value(globalObject);
+    if (str.endsWith(PLATFORM_SEP_s)) {
+      str = str.substring(0, str.length() - 1);
+    } else if (str.contains(PLATFORM_SEP)) {
+      str = str.substring(0, str.reverseFind(PLATFORM_SEP));
+    }
+    dirname = jsString(vm, str);
+  } else {
+    dirname = jsString(vm, String("."_s));
+  }
+
+  JSValue values[] = { dirname };
+  auto array = JSC::constructArray(
+    globalObject,
+    (ArrayAllocationProfile*)nullptr,
+    values,
+    1
+  );
+  RELEASE_AND_RETURN(scope, JSValue::encode(array));
+}
+
+extern "C" JSC::EncodedJSValue NodeModuleModule__findPath(JSGlobalObject*, BunString, JSArray*);
+
+JSC_DEFINE_HOST_FUNCTION(jsFunctionFindPath, (JSGlobalObject * globalObject, JSC::CallFrame *callFrame)) {
+  JSC::VM &vm = globalObject->vm();
+  auto scope = DECLARE_THROW_SCOPE(vm);
+
+  JSValue request_value = callFrame->argument(0);
+  JSValue paths_value = callFrame->argument(1);
+  
+  String request = request_value.toWTFString(globalObject);
+  RETURN_IF_EXCEPTION(scope, {});
+  BunString request_bun_str = Bun::toString(request);
+
+  JSArray* paths = paths_value.isCell() ? jsDynamicCast<JSArray*>(paths_value) : nullptr;
+
+  return NodeModuleModule__findPath(globalObject, request_bun_str, paths);
+}
+
 // These two setters are only used if you directly hit
 // `Module.prototype.require` or `module.require`. When accessing the cjs
 // require argument, this is a bound version of `require`, which calls into the
@@ -370,9 +473,7 @@ namespace Zig {
 DEFINE_NATIVE_MODULE(NodeModule) {
   // the default object here is a function, so we cant use the
   // INIT_NATIVE_MODULE helper
-
-  Zig::GlobalObject *globalObject =
-      reinterpret_cast<Zig::GlobalObject *>(lexicalGlobalObject);
+  Zig::GlobalObject *globalObject = reinterpret_cast<Zig::GlobalObject *>(lexicalGlobalObject);
   JSC::VM &vm = globalObject->vm();
   JSC::JSObject *defaultObject = JSC::JSFunction::create(
       vm, globalObject, 0, "Module"_s, jsFunctionNodeModuleModuleConstructor,
@@ -399,58 +500,54 @@ DEFINE_NATIVE_MODULE(NodeModule) {
   put(Identifier::fromString(vm, "Module"_s), defaultObject);
 
   // Module._extensions === require.extensions
-  put(Identifier::fromString(vm, "_extensions"_s),
-      globalObject->requireFunctionUnbound()->get(
-          globalObject, Identifier::fromString(vm, "extensions"_s)));
+  put(
+    Identifier::fromString(vm, "_extensions"_s),
+    globalObject->requireFunctionUnbound()->get( globalObject, Identifier::fromString(vm, "extensions"_s))
+  );
 
   defaultObject->putDirectCustomAccessor(
-      vm, JSC::Identifier::fromString(vm, "_resolveFilename"_s),
-      JSC::CustomGetterSetter::create(vm, get_resolveFilename,
-                                      set_resolveFilename),
-      JSC::PropertyAttribute::CustomAccessor | 0);
-  putNativeFn(Identifier::fromString(vm, "__resolveFilename"_s),
-              jsFunctionResolveFileName);
+    vm,
+    JSC::Identifier::fromString(vm, "_resolveFilename"_s),
+    JSC::CustomGetterSetter::create(vm, get_resolveFilename, set_resolveFilename),
+    JSC::PropertyAttribute::CustomAccessor | 0
+  );
 
-  putNativeFn(Identifier::fromString(vm, "createRequire"_s),
-              jsFunctionNodeModuleCreateRequire);
-  putNativeFn(Identifier::fromString(vm, "paths"_s),
-              Resolver__nodeModulePathsForJS);
-  putNativeFn(Identifier::fromString(vm, "findSourceMap"_s),
-              jsFunctionFindSourceMap);
-  putNativeFn(Identifier::fromString(vm, "syncBuiltinExports"_s),
-              jsFunctionSyncBuiltinExports);
+  putNativeFn(Identifier::fromString(vm, "__resolveFilename"_s), jsFunctionResolveFileName);
+  putNativeFn(Identifier::fromString(vm, "_resolveLookupPaths"_s), jsFunctionResolveLookupPaths);
+
+  putNativeFn(Identifier::fromString(vm, "createRequire"_s), jsFunctionNodeModuleCreateRequire);
+  putNativeFn(Identifier::fromString(vm, "paths"_s), Resolver__nodeModulePathsForJS);
+  putNativeFn(Identifier::fromString(vm, "findSourceMap"_s), jsFunctionFindSourceMap);
+  putNativeFn(Identifier::fromString(vm, "syncBuiltinExports"_s), jsFunctionSyncBuiltinExports);
   putNativeFn(Identifier::fromString(vm, "SourceMap"_s), jsFunctionSourceMap);
-  putNativeFn(Identifier::fromString(vm, "isBuiltin"_s),
-              jsFunctionIsBuiltinModule);
-  putNativeFn(Identifier::fromString(vm, "_nodeModulePaths"_s),
-              Resolver__nodeModulePathsForJS);
+  putNativeFn(Identifier::fromString(vm, "isBuiltin"_s), jsFunctionIsBuiltinModule);
+  putNativeFn(Identifier::fromString(vm, "_nodeModulePaths"_s), Resolver__nodeModulePathsForJS);
   putNativeFn(Identifier::fromString(vm, "wrap"_s), jsFunctionWrap);
 
-  put(Identifier::fromString(vm, "_cache"_s),
-      jsCast<Zig::GlobalObject *>(globalObject)->lazyRequireCacheObject());
+  put(Identifier::fromString(vm, "_cache"_s), jsCast<Zig::GlobalObject *>(globalObject)->lazyRequireCacheObject());
+  put(Identifier::fromString(vm, "globalPaths"_s), constructEmptyArray(globalObject, nullptr, 0));
 
-  put(Identifier::fromString(vm, "globalPaths"_s),
-      constructEmptyArray(globalObject, nullptr, 0));
-
-  auto prototype =
-      constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
+  auto prototype = constructEmptyObject(globalObject, globalObject->objectPrototype(), 1);
   prototype->putDirectCustomAccessor(
-      vm, JSC::Identifier::fromString(vm, "require"_s),
-      JSC::CustomGetterSetter::create(vm, getterRequireFunction,
-                                      setterRequireFunction),
-      0);
+    vm, JSC::Identifier::fromString(vm, "require"_s),
+    JSC::CustomGetterSetter::create(
+      vm,
+      getterRequireFunction,
+      setterRequireFunction
+    ),
+    0
+  );
 
   defaultObject->putDirect(vm, vm.propertyNames->prototype, prototype);
 
   JSC::JSArray *builtinModules = JSC::JSArray::create(
-      vm,
-      globalObject->arrayStructureForIndexingTypeDuringAllocation(
-          ArrayWithContiguous),
-      countof(builtinModuleNames));
+    vm,
+    globalObject->arrayStructureForIndexingTypeDuringAllocation(ArrayWithContiguous),
+    countof(builtinModuleNames)
+  );
 
   for (unsigned i = 0; i < countof(builtinModuleNames); ++i) {
-    builtinModules->putDirectIndex(
-        globalObject, i, JSC::jsString(vm, String(builtinModuleNames[i])));
+    builtinModules->putDirectIndex(globalObject, i, JSC::jsString(vm, String(builtinModuleNames[i])));
   }
 
   put(JSC::Identifier::fromString(vm, "builtinModules"_s), builtinModules);
diff --git a/src/bun.js/node/types.zig b/src/bun.js/node/types.zig
index 101c12e1a3..2c388d4b00 100644
--- a/src/bun.js/node/types.zig
+++ b/src/bun.js/node/types.zig
@@ -3492,6 +3492,13 @@ pub const Path = struct {
         return buf[0..bufSize];
     }
 
+    pub fn normalizeT(comptime T: type, path: []const T, buf: []T) []const T {
+        return switch (Environment.os) {
+            .windows => normalizeWindowsT(T, path, buf),
+            else => normalizePosixT(T, path, buf),
+        };
+    }
+
     pub inline fn normalizePosixJS_T(comptime T: type, globalObject: *JSC.JSGlobalObject, path: []const T, buf: []T) JSC.JSValue {
         return toJSString(globalObject, normalizePosixT(T, path, buf));
     }
diff --git a/src/js/node/async_hooks.ts b/src/js/node/async_hooks.ts
index 110571eb0c..e8814aa590 100644
--- a/src/js/node/async_hooks.ts
+++ b/src/js/node/async_hooks.ts
@@ -308,9 +308,13 @@ function createWarning(message) {
   var wrapped = function () {
     if (warned) return;
 
-    // zx does not need createHook to function
-    const isFromZX = new Error().stack!.includes("zx/build/core.js");
-    if (isFromZX) return;
+    const known_supported_modules = [
+      // the following do not actually need async_hooks to work properly
+      "zx/build/core.js",
+      "datadog-core/src/storage/async_resource.js",
+    ];
+    const e = new Error().stack!;
+    if (known_supported_modules.some(m => e.includes(m))) return;
 
     warned = true;
     console.warn("[bun] Warning:", message);
diff --git a/src/js/node/net.ts b/src/js/node/net.ts
index 4406231304..366335c89f 100644
--- a/src/js/node/net.ts
+++ b/src/js/node/net.ts
@@ -980,6 +980,17 @@ function createServer(options, connectionListener) {
   return new Server(options, connectionListener);
 }
 
+// TODO:
+class BlockList {
+  constructor() {}
+
+  addSubnet(net, prefix, type) {}
+
+  check(address, type) {
+    return false;
+  }
+}
+
 export default {
   createServer,
   Server,
@@ -995,4 +1006,6 @@ export default {
   setDefaultAutoSelectFamily: $zig("node_net_binding.zig", "setDefaultAutoSelectFamily"),
   getDefaultAutoSelectFamilyAttemptTimeout: $zig("node_net_binding.zig", "getDefaultAutoSelectFamilyAttemptTimeout"),
   setDefaultAutoSelectFamilyAttemptTimeout: $zig("node_net_binding.zig", "setDefaultAutoSelectFamilyAttemptTimeout"),
+
+  BlockList,
 };
diff --git a/test/js/node/module/node-module-module.test.js b/test/js/node/module/node-module-module.test.js
index 07aa5b94d1..6fa6dd670f 100644
--- a/test/js/node/module/node-module-module.test.js
+++ b/test/js/node/module/node-module-module.test.js
@@ -110,3 +110,11 @@ test("Module._extensions", () => {
   expect(".node" in Module._extensions).toBeTrue();
   expect(require.extensions).toBe(Module._extensions);
 });
+
+test("Module._resolveLookupPaths", () => {
+  expect(Module._resolveLookupPaths("foo")).toEqual([]);
+  expect(Module._resolveLookupPaths("./bar", { id: "1", filename: "/baz/abc" })).toEqual(["/baz"]);
+  expect(Module._resolveLookupPaths("./bar", {})).toEqual(["."]);
+  expect(Module._resolveLookupPaths("./bar", { paths: ["a"] })).toEqual(["."]);
+  expect(Module._resolveLookupPaths("bar", { paths: ["a"] })).toEqual(["a"]);
+});