Cache repeated npm module loader filesystem work

crates/wasm-rquickjs/skeleton/src/builtin/fs.rs

@@ -228,10 +228,20 @@ fn with_fs_mut<R>(
 }
 
 fn invalidate_module_resolution_probes(ctx: &rquickjs::Ctx<'_>) {
-    ctx.userdata::<crate::internal::runtime_services::RuntimeServices>()
-        .expect("runtime services not initialized")
-        .cjs_module_probe_session
-        .invalidate();
+    let services = ctx
+        .userdata::<crate::internal::runtime_services::RuntimeServices>()
+        .expect("runtime services not initialized");
+    let _missing_package_json = services.cjs_module_probe_session.invalidate();
+    #[cfg(feature = "typescript-compiler-profiling")]
+    if _missing_package_json > 0
+        && let Some(profile) = services.execution_profile()
+    {
+        profile.increment("modules.packageJson.negativeCacheInvalidations");
+        profile.add(
+            "modules.packageJson.negativeCacheInvalidatedEntries",
+            _missing_package_json as u64,
+        );
+    }
 }
 
 fn normalize_mode_override(mode: u32) -> u32 {
@@ -309,11 +319,87 @@ fn rename_fd_path(ctx: &rquickjs::Ctx<'_>, old_path: &str, new_path: &str) {
     });
 }
 
+#[derive(Clone, Copy)]
+pub(crate) enum ModuleLoaderRealpathDomain {
+    CommonJs,
+    Esm,
+}
+
 pub(super) fn realpath_for_module_resolution(
-    _ctx: &rquickjs::Ctx<'_>,
+    ctx: &rquickjs::Ctx<'_>,
     path: &str,
-) -> Option<String> {
-    canonicalize_guest_path(path).ok()
+    domain: ModuleLoaderRealpathDomain,
+) -> std::io::Result<String> {
+    // Wizer has no guest preopens. Touching wasi-libc's lazy preopen cache here
+    // would snapshot the empty build-time filesystem into every runtime.
+    if crate::internal::is_wizer_active() {
+        return Err(wizer_enoent_io());
+    }
+
+    let services = ctx
+        .userdata::<crate::internal::runtime_services::RuntimeServices>()
+        .expect("runtime services not initialized");
+    #[cfg(feature = "typescript-compiler-profiling")]
+    let profile = services.execution_profile();
+    #[cfg(feature = "typescript-compiler-profiling")]
+    if let Some(profile) = &profile {
+        profile.increment("modules.realpath.calls");
+    }
+
+    let cached = match domain {
+        ModuleLoaderRealpathDomain::CommonJs => services
+            .cjs_loader_realpath_cache
+            .borrow()
+            .get(path)
+            .cloned(),
+        ModuleLoaderRealpathDomain::Esm => services
+            .esm_loader_realpath_cache
+            .borrow()
+            .get(path)
+            .cloned(),
+    };
+    if let Some(resolved) = cached {
+        #[cfg(feature = "test-observability")]
+        services.record_loader_realpath_cache_hit();
+        #[cfg(feature = "typescript-compiler-profiling")]
+        if let Some(profile) = &profile {
+            profile.increment("modules.realpath.cacheHits");
+        }
+        return Ok(resolved);
+    }
+
+    let resolved = canonicalize_guest_path(path);
+    #[cfg(feature = "test-observability")]
+    services.record_loader_realpath_system_call();
+    #[cfg(feature = "typescript-compiler-profiling")]
+    if let Some(profile) = &profile {
+        profile.increment("modules.realpath.systemCalls");
+        profile.increment("filesystem.realpath.calls");
+        profile.increment(match &resolved {
+            Ok(_) => "filesystem.realpath.success",
+            Err(error) if error.kind() == std::io::ErrorKind::NotFound => {
+                "filesystem.realpath.notFound"
+            }
+            Err(_) => "filesystem.realpath.errors",
+        });
+    }
+    if let Ok(resolved) = &resolved {
+        match domain {
+            ModuleLoaderRealpathDomain::CommonJs => {
+                services
+                    .cjs_loader_realpath_cache
+                    .borrow_mut()
+                    .insert(path.to_string(), resolved.clone());
+            }
+            ModuleLoaderRealpathDomain::Esm => {
+                services
+                    .esm_loader_realpath_cache
+                    .borrow_mut()
+                    .insert(path.to_string(), resolved.clone());
+            }
+        }
+    }
+    resolved
 }
 
 fn canonicalize_guest_path(path: &str) -> std::io::Result<String> {
@@ -1472,6 +1558,25 @@ pub mod native_module {
         }
     }
 
+    #[rquickjs::function]
+    pub fn fs_loader_realpath(ctx: Ctx<'_>, path: String) -> Object<'_> {
+        let result = Object::new(ctx.clone()).unwrap();
+        match super::realpath_for_module_resolution(
+            &ctx,
+            &path,
+            super::ModuleLoaderRealpathDomain::CommonJs,
+        ) {
+            Ok(resolved) => result.set("result", resolved).unwrap(),
+            Err(error) => result
+                .set(
+                    "error",
+                    super::make_fs_error(&ctx, &error, "realpath", Some(&path)),
+                )
+                .unwrap(),
+        }
+        result
+    }
+
     #[rquickjs::function]
     pub fn fs_realpath(ctx: Ctx<'_>, path: String) -> Object<'_> {
         let result = Object::new(ctx.clone()).unwrap();

crates/wasm-rquickjs/skeleton/src/builtin/mod.rs

@@ -111,11 +111,18 @@ mod sqlite {
     pub use super::sqlite_disabled::*;
 }
 
-pub(crate) fn realpath_for_module_resolution(
+pub(crate) fn realpath_for_cjs_module_resolution(
     ctx: &rquickjs::Ctx<'_>,
     path: &str,
-) -> Option<String> {
-    fs::realpath_for_module_resolution(ctx, path)
+) -> std::io::Result<String> {
+    fs::realpath_for_module_resolution(ctx, path, fs::ModuleLoaderRealpathDomain::CommonJs)
+}
+
+pub(crate) fn realpath_for_esm_module_resolution(
+    ctx: &rquickjs::Ctx<'_>,
+    path: &str,
+) -> std::io::Result<String> {
+    fs::realpath_for_module_resolution(ctx, path, fs::ModuleLoaderRealpathDomain::Esm)
 }
 
 pub fn add_module_resolvers(

crates/wasm-rquickjs/skeleton/src/builtin/module.js

@@ -2,6 +2,7 @@ import * as pathModule from 'node:path';
 import * as pathPosix from 'node:path/posix';
 import * as pathWin32 from 'node:path/win32';
 import * as fsModule from 'node:fs';
+import * as fsNative from '__wasm_rquickjs_builtin/fs_native';
 import * as util from 'node:util';
 import * as buffer from 'node:buffer';
 import * as os from 'node:os';
@@ -53,6 +54,7 @@ import * as sqlite from 'node:sqlite';
 import * as internalHttp from '__wasm_rquickjs_builtin/internal/http';
 import { ERR_INVALID_ARG_TYPE, ERR_INVALID_ARG_VALUE, ERR_MISSING_ARGS } from '__wasm_rquickjs_builtin/internal/errors';
 import * as internalErrors from '__wasm_rquickjs_builtin/internal/errors';
+import { createSystemError as createFsSystemError } from '__wasm_rquickjs_builtin/internal/fs/shared';
 import * as internalFsUtils from '__wasm_rquickjs_builtin/internal/fs/utils';
 import * as internalUrl from '__wasm_rquickjs_builtin/internal/url';
 import * as internalUtil from '__wasm_rquickjs_builtin/internal/util';
@@ -736,7 +738,20 @@ function shouldPreserveSymlinks(isMainModuleLoad) {
 
 function toCjsCanonicalFilename(filename, isMainModuleLoad) {
     if (shouldPreserveSymlinks(isMainModuleLoad)) return filename;
-    return fsModule.realpathSync.native(filename);
+    // Node resolves against process.cwd() before consulting its loader realpath
+    // cache. Keep the native bridge limited to absolute, normalized guest paths.
+    const normalized = pathModule.resolve(filename);
+    const outcome = fsNative.fs_loader_realpath(normalized);
+    if (outcome.error) throw createFsSystemError(outcome.error);
+    return outcome.result;
+}
+
+if (testObservabilityEnabledNative()) {
+    Object.defineProperty(globalThis, '__wasm_rquickjs_test_cjs_canonical_filename', {
+        value: filename => toCjsCanonicalFilename(filename, false),
+        writable: false,
+        configurable: false,
+    });
 }
 
 function tryReadFile(filename) {

crates/wasm-rquickjs/skeleton/src/builtin_p3.rs

@@ -179,11 +179,18 @@ mod zlib {
 #[path = "builtin/websocket.rs"]
 mod websocket;
 
-pub(crate) fn realpath_for_module_resolution(
+pub(crate) fn realpath_for_cjs_module_resolution(
     ctx: &rquickjs::Ctx<'_>,
     path: &str,
-) -> Option<String> {
-    fs::realpath_for_module_resolution(ctx, path)
+) -> std::io::Result<String> {
+    fs::realpath_for_module_resolution(ctx, path, fs::ModuleLoaderRealpathDomain::CommonJs)
+}
+
+pub(crate) fn realpath_for_esm_module_resolution(
+    ctx: &rquickjs::Ctx<'_>,
+    path: &str,
+) -> std::io::Result<String> {
+    fs::realpath_for_module_resolution(ctx, path, fs::ModuleLoaderRealpathDomain::Esm)
 }
 
 /// Registers builtin native and JavaScript module names with the resolver.