@@ -6,6 +6,14 @@
 
 namespace tns {
 
+// Heuristic: does this bare specifier look like an npm-style package name
+// (as opposed to an explicit, extension-qualified file reference)? Shared by
+// both the CommonJS require() path (ModuleInternal.mm) and the ESM
+// import()/resolver path (ModuleInternalCallbacks.mm) so the two can't drift
+// out of sync with each other. See the definition in ModuleInternal.mm for
+// the full rationale.
+bool IsLikelyOptionalModule(const std::string& moduleName);
+
 class ModuleInternal {
  public:
   ModuleInternal(v8::Local<v8::Context> context);
 
@@ -19,11 +19,41 @@
 
 namespace tns {
 
-// Helper function to check if a module name looks like an optional external module
+// Shared by both the require() path (this file) and the import()/ESM resolver path
+// (ModuleInternalCallbacks.mm) — see the declaration in ModuleInternal.h. Keeping a single
+// definition means a boundary fix like the extension carve-out below automatically applies
+// to both call sites instead of only the one that happened to get touched.
 bool IsLikelyOptionalModule(const std::string& moduleName) {
-  // Check if it's a bare module name (no path separators) that could be an npm package
+  // Node built-ins are handled by their own dedicated resolution path; never treat them as
+  // an optional external module.
+  if (moduleName.rfind("node:", 0) == 0) {
+    return false;
+  }
+
+  // Check if it's a bare module name (no path separators) that could be an npm package.
+  //
+  // Bare specifiers that end in a recognizable script/data extension (e.g. "foo.js",
+  // "config.json") are explicit file references, not npm-style package names — real npm
+  // package names don't carry a file extension. Treating them as "likely optional" would
+  // swallow a genuine "module not found" failure behind a lazily-throwing placeholder
+  // instead of letting require()/import() fail immediately, which is what callers (and the
+  // existing "should throw error if cant find node module" test) expect for those names.
+  //
+  // This carve-out is deliberately narrow: a dotted bare name that doesn't end in one of
+  // these exact extensions (e.g. "lodash.debounce") is still treated as optional, same as
+  // before. See ModuleInternal.mm/ModuleInternalCallbacks.mm optional-module tests for the
+  // cases this boundary is expected to hold for.
+  static const char* kExplicitFileExtensions[] = {".js", ".mjs", ".cjs", ".json", ".node", ".ts"};
+
   if (moduleName.find('/') == std::string::npos && moduleName.find('\\') == std::string::npos &&
       moduleName[0] != '.' && moduleName[0] != '~' && moduleName[0] != '/') {
+    for (const char* ext : kExplicitFileExtensions) {
+      size_t extLen = strlen(ext);
+      if (moduleName.size() > extLen &&
+          moduleName.compare(moduleName.size() - extLen, extLen, ext) == 0) {
+        return false;
+      }
+    }
     return true;
   }
   return false;
 
@@ -28,20 +28,8 @@
 
 namespace tns {
 
-// Helper function to check if a module name looks like an optional external module
-static bool IsLikelyOptionalModule(const std::string& moduleName) {
-  // Skip Node.js built-in modules (they should be handled separately)
-  if (moduleName.rfind("node:", 0) == 0) {
-    return false;
-  }
-
-  // Check if it's a bare module name (no path separators) that could be an npm package
-  if (moduleName.find('/') == std::string::npos && moduleName.find('\\') == std::string::npos &&
-      moduleName[0] != '.' && moduleName[0] != '~' && moduleName[0] != '/') {
-    return true;
-  }
-  return false;
-}
+// IsLikelyOptionalModule is declared in ModuleInternal.h and defined once in
+// ModuleInternal.mm, shared with the require() path so the two can't drift apart.
 
 // Helper function to check if a module name is a Node.js built-in module
 static bool IsNodeBuiltinModule(const std::string& moduleName) {
 
@@ -37,6 +37,50 @@ describe("Node built-in and optional module resolution", function () {
     expect(threw).toBe(true);
   });
 
+  // IsLikelyOptionalModule is shared between require() (CommonJS) and this ESM resolver
+  // (see ModuleInternal.h) so the boundary can't drift apart between the two paths. The
+  // require()-side cases live in shared/Require/index.js; these mirror them for import()
+  // to confirm the two stay in parity.
+  it("still creates a placeholder for a dotted-but-not-extension bare specifier", async function () {
+    // A dot that isn't a recognized file extension (e.g. an npm name like "lodash.debounce")
+    // must still be treated as optional, not as an explicit missing file.
+    const mod = await import("__ns_optional_test_module.dotted__");
+
+    expect(mod).toBeDefined();
+    expect(typeof mod.default).toBe("object");
+
+    let threw = false;
+    try {
+      // eslint-disable-next-line no-unused-expressions
+      mod.default.someProperty;
+    } catch (e) {
+      threw = true;
+    }
+    expect(threw).toBe(true);
+  });
+
+  it("rejects immediately for a missing bare specifier that carries an explicit file extension", async function () {
+    // Mirrors the require()-side "video.js" case: a bare specifier with a recognized file
+    // extension is an explicit (here, missing) file reference, not an optional dependency,
+    // so import() must reject instead of resolving to a lazily-throwing placeholder.
+    const names = [
+      "__ns_missing_import_test__.js",
+      "__ns_missing_import_test__.json",
+      "__ns_missing_import_test__.mjs",
+      "video.js",
+    ];
+
+    for (const name of names) {
+      let threw = false;
+      try {
+        await import(name);
+      } catch (e) {
+        threw = true;
+      }
+      expect(threw).toBe(true);
+    }
+  });
+
   it("resolves import-map vendor modules through the explicit vendor registry", async function () {
     const configureRuntime = globalThis.__NS_DEV__ && globalThis.__NS_DEV__.configureRuntime;
     expect(typeof configureRuntime).toBe("function");