From 53fea22846df532162d3641c8b31925af2dfe9b0 Mon Sep 17 00:00:00 2001
From: Guy Bedford <guybedford@gmail.com>
Date: Thu, 24 Jan 2019 19:33:28 +0200
Subject: [PATCH] esm: irp type implementation

Refs: https://github.com/GeoffreyBooth/node-import-file-specifier-resolution-proposal
PR-URL: https://github.com/nodejs/ecmascript-modules/pull/28
---
 .eslintrc.js                                  |   2 +
 doc/api/cli.md                                |  12 +
 doc/api/errors.md                             |  32 +-
 doc/api/esm.md                                |  38 +-
 doc/node.1                                    |   3 +
 lib/internal/errors.js                        |  32 +-
 lib/internal/main/check_syntax.js             |  36 +-
 lib/internal/main/eval_stdin.js               |   6 +-
 lib/internal/main/eval_string.js              |   7 +-
 lib/internal/main/repl.js                     |   7 +
 lib/internal/modules/cjs/loader.js            |  26 +-
 lib/internal/modules/esm/default_resolve.js   | 142 +++++---
 lib/internal/modules/esm/loader.js            |  29 +-
 lib/internal/modules/esm/module_job.js        |   5 +-
 lib/internal/modules/esm/translators.js       |  13 +-
 lib/internal/process/esm_loader.js            |  18 +-
 lib/internal/process/execution.js             |  19 +
 src/env.h                                     |  26 +-
 src/module_wrap.cc                            | 335 ++++++++++++++++--
 src/module_wrap.h                             |   4 -
 src/node_errors.h                             |   2 +
 src/node_options.cc                           |  11 +-
 src/node_options.h                            |   1 +
 test/es-module/test-esm-dynamic-import.js     |   2 +-
 test/es-module/test-esm-loader-modulemap.js   |   2 +-
 test/es-module/test-esm-main-lookup.mjs       |   2 +-
 test/es-module/test-esm-package-scope.mjs     |  12 +
 test/es-module/test-esm-symlink-type.js       |  77 ++++
 test/es-module/test-esm-type-flag-alias.mjs   |   6 +
 test/es-module/test-esm-type-flag-errors.js   |  57 +++
 test/es-module/test-esm-type-flag.mjs         |  11 +
 test/fixtures/es-modules/cjs-file.cjs         |   1 +
 test/fixtures/es-modules/mjs-file.mjs         |   1 +
 .../es-modules/package-type-commonjs/index.js |   3 +
 .../package-type-commonjs/package.json        |   4 +
 .../es-modules/package-type-module/index.js   |   3 +
 .../package-type-module/package.json          |   4 +
 .../es-modules/package-without-type/index.js  |   3 +
 .../package-without-type/package.json         |   3 +
 .../esm-package-scope/legacy-loader/a.js      |   1 +
 .../esm-package-scope/legacy-loader/b.mjs     |   1 +
 .../esm-package-scope/legacy-loader/c.cjs     |   5 +
 .../esm-package-scope/legacy-loader/index.mjs |  21 ++
 .../legacy-loader/package.json                |  13 +
 .../esm-package-scope/new-loader/a.js         |   1 +
 .../esm-package-scope/new-loader/b.mjs        |   1 +
 .../esm-package-scope/new-loader/c.cjs        |   5 +
 .../esm-package-scope/new-loader/index.js     |  21 ++
 .../esm-package-scope/new-loader/package.json |  13 +
 test/message/esm_display_syntax_error.out     |   2 +-
 test/parallel/test-cli-syntax-piped-bad.js    |  33 +-
 test/parallel/test-cli-syntax-piped-good.js   |  24 +-
 52 files changed, 962 insertions(+), 176 deletions(-)
 create mode 100644 test/es-module/test-esm-package-scope.mjs
 create mode 100644 test/es-module/test-esm-symlink-type.js
 create mode 100644 test/es-module/test-esm-type-flag-alias.mjs
 create mode 100644 test/es-module/test-esm-type-flag-errors.js
 create mode 100644 test/es-module/test-esm-type-flag.mjs
 create mode 100644 test/fixtures/es-modules/cjs-file.cjs
 create mode 100644 test/fixtures/es-modules/mjs-file.mjs
 create mode 100644 test/fixtures/es-modules/package-type-commonjs/index.js
 create mode 100644 test/fixtures/es-modules/package-type-commonjs/package.json
 create mode 100644 test/fixtures/es-modules/package-type-module/index.js
 create mode 100644 test/fixtures/es-modules/package-type-module/package.json
 create mode 100644 test/fixtures/es-modules/package-without-type/index.js
 create mode 100644 test/fixtures/es-modules/package-without-type/package.json
 create mode 100644 test/fixtures/esm-package-scope/legacy-loader/a.js
 create mode 100644 test/fixtures/esm-package-scope/legacy-loader/b.mjs
 create mode 100644 test/fixtures/esm-package-scope/legacy-loader/c.cjs
 create mode 100644 test/fixtures/esm-package-scope/legacy-loader/index.mjs
 create mode 100644 test/fixtures/esm-package-scope/legacy-loader/package.json
 create mode 100644 test/fixtures/esm-package-scope/new-loader/a.js
 create mode 100644 test/fixtures/esm-package-scope/new-loader/b.mjs
 create mode 100644 test/fixtures/esm-package-scope/new-loader/c.cjs
 create mode 100644 test/fixtures/esm-package-scope/new-loader/index.js
 create mode 100644 test/fixtures/esm-package-scope/new-loader/package.json

diff --git a/.eslintrc.js b/.eslintrc.js
index 8b3b613e67..9de0f850df 100644
--- a/.eslintrc.js
+++ b/.eslintrc.js
@@ -38,6 +38,8 @@ module.exports = {
     {
       files: [
         'doc/api/esm.md',
+        'test/es-module/test-esm-type-flag.js',
+        'test/es-module/test-esm-type-flag-alias.js',
         '*.mjs',
       ],
       parserOptions: { sourceType: 'module' },
diff --git a/doc/api/cli.md b/doc/api/cli.md
index f8fa53a5cc..de822b6a06 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -504,6 +504,18 @@ added: v2.4.0
 
 Track heap object allocations for heap snapshots.
 
+### `-m`, `--type=type`
+
+When using `--experimental-modules`, this informs the module resolution type
+to interpret the top-level entry into Node.js.
+
+Works with stdin, `--eval`, `--print` as well as standard execution.
+
+Valid values are `"commonjs"` and `"module"`, where the default is to infer
+from the file extension and package type boundary.
+
+`-m` is an alias for `--type=module`.
+
 ### `--use-bundled-ca`, `--use-openssl-ca`
 <!-- YAML
 added: v6.11.0
diff --git a/doc/api/errors.md b/doc/api/errors.md
index 602455be7c..fe886cf59c 100644
--- a/doc/api/errors.md
+++ b/doc/api/errors.md
@@ -1267,6 +1267,11 @@ An invalid or unexpected value was passed in an options object.
 
 An invalid or unknown file encoding was passed.
 
+<a id="ERR_INVALID_PACKAGE_CONFIG"></a>
+### ERR_INVALID_PACKAGE_CONFIG
+
+An invalid `package.json` file was found which failed parsing.
+
 <a id="ERR_INVALID_PERFORMANCE_MARK"></a>
 ### ERR_INVALID_PERFORMANCE_MARK
 
@@ -2213,6 +2218,32 @@ A non-specific HTTP/2 error has occurred.
 Used in the `repl` in case the old history file is used and an error occurred
 while trying to read and parse it.
 
+<a id="ERR_INVALID_REPL_TYPE"></a>
+### ERR_INVALID_REPL_TYPE
+
+> Stability: 1 - Experimental
+
+The `--type=...` flag is not compatible with the Node.js REPL.
+
+<a id="ERR_TYPE_MISMATCH"></a>
+### ERR_TYPE_MISMATCH
+
+> Stability: 1 - Experimental
+
+The `--type=commonjs` flag was used to attempt to execute an `.mjs` file or
+a `.js` file where the nearest parent `package.json` contains
+`"type": "module"`; or
+the `--type=module` flag was used to attempt to execute a `.cjs` file or
+a `.js` file where the nearest parent `package.json` either lacks a `"type"`
+field or contains `"type": "commonjs"`.
+
+<a id="ERR_INVALID_TYPE_FLAG"></a>
+### ERR_INVALID_TYPE_FLAG
+
+> Stability: 1 - Experimental
+
+An invalid `--type=...` flag value was provided.
+
 <a id="ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK"></a>
 #### ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK
 
@@ -2243,7 +2274,6 @@ size.
 This `Error` is thrown when a read is attempted on a TTY `WriteStream`,
 such as `process.stdout.on('data')`.
 
-
 [`'uncaughtException'`]: process.html#process_event_uncaughtexception
 [`--force-fips`]: cli.html#cli_force_fips
 [`Class: assert.AssertionError`]: assert.html#assert_class_assert_assertionerror
diff --git a/doc/api/esm.md b/doc/api/esm.md
index 6987c7bf55..37f3d12df1 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -158,8 +158,8 @@ The algorithm to load an ES module specifier is given through the
 module specifier relative to a parentURL, in addition to the unique module
 format for that resolved URL given by the **ESM_FORMAT** routine.
 
-The _"esm"_ format is returned for an ECMAScript Module, while the
-_"legacy"_ format is used to indicate loading through the legacy
+The _"module"_ format is returned for an ECMAScript Module, while the
+_"commonjs"_ format is used to indicate loading through the legacy
 CommonJS loader. Additional formats such as _"wasm"_ or _"addon"_ can be
 extended in future updates.
 
@@ -168,6 +168,12 @@ of these top-level routines.
 
 _isMain_ is **true** when resolving the Node.js application entry point.
 
+If the top-level `--type` is _"commonjs"_, then the ESM resolver is skipped
+entirely for the CommonJS loader.
+
+If the top-level `--type` is _"module"_, then the ESM resolver is used
+as described here, with the conditional `--type` check in **ESM_FORMAT**.
+
 **ESM_RESOLVE(_specifier_, _parentURL_, _isMain_)**
 > 1. Let _resolvedURL_ be **undefined**.
 > 1. If _specifier_ is a valid URL, then
@@ -184,7 +190,8 @@ _isMain_ is **true** when resolving the Node.js application entry point.
 >       **PACKAGE_RESOLVE**(_specifier_, _parentURL_).
 > 1. If the file at _resolvedURL_ does not exist, then
 >    1. Throw a _Module Not Found_ error.
-> 1. Let _format_ be the result of **ESM_FORMAT**(_url_, _isMain_).
+> 1. Set _resolvedURL_ to the real path of _resolvedURL_.
+> 1. Let _format_ be the result of **ESM_FORMAT**(_resolvedURL_, _isMain_).
 > 1. Load _resolvedURL_ as module format, _format_.
 
 PACKAGE_RESOLVE(_packageSpecifier_, _parentURL_)
@@ -234,7 +241,7 @@ PACKAGE_MAIN_RESOLVE(_packageURL_, _pjson_)
 >       _pjson.main_.
 >    1. If the file at _resolvedMain_ exists, then
 >       1. Return _resolvedMain_.
-> 1. If _pjson.type_ is equal to _"esm"_, then
+> 1. If _pjson.type_ is equal to _"module"_, then
 >    1. Throw a _Module Not Found_ error.
 > 1. Let _legacyMainURL_ be the result applying the legacy
 >    **LOAD_AS_DIRECTORY** CommonJS resolver to _packageURL_, throwing a
@@ -245,18 +252,25 @@ PACKAGE_MAIN_RESOLVE(_packageURL_, _pjson_)
 
 **ESM_FORMAT(_url_, _isMain_)**
 > 1. Assert: _url_ corresponds to an existing file.
+> 1. If _isMain_ is **true** and the `--type` flag is _"module"_, then
+>    1. If _url_ ends with _".cjs"_, then
+>       1. Throw a _Type Mismatch_ error.
+>    1. Return _"module"_.
 > 1. Let _pjson_ be the result of **READ_PACKAGE_BOUNDARY**(_url_).
 > 1. If _pjson_ is **null** and _isMain_ is **true**, then
->    1. Return _"legacy"_.
-> 1. If _pjson.type_ exists and is _"esm"_, then
->    1. If _url_ does not end in _".js"_ or _".mjs"_, then
->       1. Throw an _Unsupported File Extension_ error.
->    1. Return _"esm"_.
+>    1. If _url_ ends in _".mjs"_, then
+>       1. Return _"module"_.
+>    1. Return _"commonjs"_.
+> 1. If _pjson.type_ exists and is _"module"_, then
+>    1. If _url_ ends in _".cjs"_, then
+>       1. Return _"commonjs"_.
+>    1. Return _"module"_.
 > 1. Otherwise,
 >    1. If _url_ ends in _".mjs"_, then
->       1. Return _"esm"_.
->    1. Otherwise,
->       1. Return _"legacy"_.
+>       1. Return _"module"_.
+>    1. If _url_ does not end in _".js"_, then
+>       1. Throw an _Unsupported File Extension_ error.
+>    1. Return _"commonjs"_.
 
 READ_PACKAGE_BOUNDARY(_url_)
 > 1. Let _boundaryURL_ be _url_.
diff --git a/doc/node.1 b/doc/node.1
index 6945654689..525c8b4806 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -270,6 +270,9 @@ Print stack traces for process warnings (including deprecations).
 .It Fl -track-heap-objects
 Track heap object allocations for heap snapshots.
 .
+.It Fl -type Ns = Ns Ar type
+Set the top-level module resolution type.
+.
 .It Fl -use-bundled-ca , Fl -use-openssl-ca
 Use bundled Mozilla CA store as supplied by current Node.js version or use OpenSSL's default CA store.
 The default store is selectable at build-time.
diff --git a/lib/internal/errors.js b/lib/internal/errors.js
index 5e7f504be8..d2bc107c6f 100644
--- a/lib/internal/errors.js
+++ b/lib/internal/errors.js
@@ -774,6 +774,8 @@ E('ERR_INVALID_OPT_VALUE', (name, value) =>
   RangeError);
 E('ERR_INVALID_OPT_VALUE_ENCODING',
   'The value "%s" is invalid for option "encoding"', TypeError);
+E('ERR_INVALID_PACKAGE_CONFIG',
+  'Invalid package config in \'%s\' imported from %s', Error);
 E('ERR_INVALID_PERFORMANCE_MARK',
   'The "%s" performance mark has not been set', Error);
 E('ERR_INVALID_PROTOCOL',
@@ -781,6 +783,8 @@ E('ERR_INVALID_PROTOCOL',
   TypeError);
 E('ERR_INVALID_REPL_EVAL_CONFIG',
   'Cannot specify both "breakEvalOnSigint" and "eval" for REPL', TypeError);
+E('ERR_INVALID_REPL_TYPE',
+  'Cannot specify --type for REPL', TypeError);
 E('ERR_INVALID_RETURN_PROPERTY', (input, name, prop, value) => {
   return `Expected a valid ${input} to be returned for the "${prop}" from the` +
          ` "${name}" function but got ${value}.`;
@@ -811,6 +815,9 @@ E('ERR_INVALID_SYNC_FORK_INPUT',
   TypeError);
 E('ERR_INVALID_THIS', 'Value of "this" must be of type %s', TypeError);
 E('ERR_INVALID_TUPLE', '%s must be an iterable %s tuple', TypeError);
+E('ERR_INVALID_TYPE_FLAG',
+  'Type flag must be one of "module", "commonjs". Received --type=%s',
+  TypeError);
 E('ERR_INVALID_URI', 'URI malformed', URIError);
 E('ERR_INVALID_URL', 'Invalid URL: %s', TypeError);
 E('ERR_INVALID_URL_SCHEME',
@@ -865,13 +872,6 @@ E('ERR_MISSING_ARGS',
 E('ERR_MISSING_DYNAMIC_INSTANTIATE_HOOK',
   'The ES Module loader may not return a format of \'dynamic\' when no ' +
   'dynamicInstantiate function was provided', Error);
-E('ERR_MODULE_NOT_FOUND', (module, base, legacyResolution) => {
-  let msg = `Cannot find module '${module}' imported from ${base}.`;
-  if (legacyResolution)
-    msg += ' Legacy behavior in require() would have found it at ' +
-           legacyResolution;
-  return msg;
-}, Error);
 E('ERR_MULTIPLE_CALLBACK', 'Callback called multiple times', Error);
 E('ERR_NAPI_CONS_FUNCTION', 'Constructor must be a function', TypeError);
 E('ERR_NAPI_INVALID_DATAVIEW_ARGS',
@@ -956,6 +956,20 @@ E('ERR_TRANSFORM_ALREADY_TRANSFORMING',
 E('ERR_TRANSFORM_WITH_LENGTH_0',
   'Calling transform done when writableState.length != 0', Error);
 E('ERR_TTY_INIT_FAILED', 'TTY initialization failed', SystemError);
+E('ERR_TYPE_MISMATCH', (filename, ext, typeFlag, conflict) => {
+  const typeString =
+    typeFlag === 'module' ? '--type=module or -m' : '--type=commonjs';
+  // --type mismatches file extension
+  if (conflict === 'extension')
+    return `Extension ${ext} is not supported for ` +
+      `${typeString} loading ${filename}`;
+  // --type mismatches package.json "type"
+  else if (conflict === 'scope')
+    return `Cannot use ${typeString} because nearest parent package.json ` +
+      ((typeFlag === 'module') ?
+        'includes "type": "commonjs"' : 'includes "type": "module",') +
+      ` which controls the type to use for ${filename}`;
+}, TypeError);
 E('ERR_UNCAUGHT_EXCEPTION_CAPTURE_ALREADY_SET',
   '`process.setupUncaughtExceptionCapture()` was called while a capture ' +
     'callback was already active',
@@ -972,10 +986,8 @@ E('ERR_UNHANDLED_ERROR',
 // This should probably be a `TypeError`.
 E('ERR_UNKNOWN_CREDENTIAL', '%s identifier does not exist: %s', Error);
 E('ERR_UNKNOWN_ENCODING', 'Unknown encoding: %s', TypeError);
-
+E('ERR_UNKNOWN_FILE_EXTENSION', 'Unknown file extension: %s', TypeError);
 // This should probably be a `TypeError`.
-E('ERR_UNKNOWN_FILE_EXTENSION', 'Unknown file extension: \'%s\' imported ' +
-  'from %s', Error);
 E('ERR_UNKNOWN_MODULE_FORMAT', 'Unknown module format: %s', RangeError);
 E('ERR_UNKNOWN_SIGNAL', 'Unknown signal: %s', TypeError);
 
diff --git a/lib/internal/main/check_syntax.js b/lib/internal/main/check_syntax.js
index 7df70b2720..2795f5766e 100644
--- a/lib/internal/main/check_syntax.js
+++ b/lib/internal/main/check_syntax.js
@@ -11,12 +11,18 @@ const {
   readStdin
 } = require('internal/process/execution');
 
-const CJSModule = require('internal/modules/cjs/loader');
+const { pathToFileURL } = require('url');
+
 const vm = require('vm');
 const {
   stripShebang, stripBOM
 } = require('internal/modules/cjs/helpers');
 
+let CJSModule;
+function CJSModuleInit() {
+  if (!CJSModule)
+    CJSModule = require('internal/modules/cjs/loader');
+}
 
 if (process.argv[1] && process.argv[1] !== '-') {
   // Expand process.argv[1] into a full path.
@@ -25,7 +31,7 @@ if (process.argv[1] && process.argv[1] !== '-') {
 
   // TODO(joyeecheung): not every one of these are necessary
   prepareMainThreadExecution();
-
+  CJSModuleInit();
   // Read the source.
   const filename = CJSModule._resolveFilename(process.argv[1]);
 
@@ -34,20 +40,40 @@ if (process.argv[1] && process.argv[1] !== '-') {
 
   markBootstrapComplete();
 
-  checkScriptSyntax(source, filename);
+  checkSyntax(source, filename);
 } else {
   // TODO(joyeecheung): not every one of these are necessary
   prepareMainThreadExecution();
+  CJSModuleInit();
   markBootstrapComplete();
 
   readStdin((code) => {
-    checkScriptSyntax(code, '[stdin]');
+    checkSyntax(code, '[stdin]');
   });
 }
 
-function checkScriptSyntax(source, filename) {
+function checkSyntax(source, filename) {
   // Remove Shebang.
   source = stripShebang(source);
+
+  const experimentalModules =
+      require('internal/options').getOptionValue('--experimental-modules');
+  if (experimentalModules) {
+    let isModule = false;
+    if (filename === '[stdin]' || filename === '[eval]') {
+      isModule = require('internal/process/esm_loader').typeFlag === 'module';
+    } else {
+      const resolve = require('internal/modules/esm/default_resolve');
+      const { format } = resolve(pathToFileURL(filename).toString());
+      isModule = format === 'module';
+    }
+    if (isModule) {
+      const { ModuleWrap } = internalBinding('module_wrap');
+      new ModuleWrap(source, filename);
+      return;
+    }
+  }
+
   // Remove BOM.
   source = stripBOM(source);
   // Wrap it.
diff --git a/lib/internal/main/eval_stdin.js b/lib/internal/main/eval_stdin.js
index 2a2ef6d38a..869a3675b6 100644
--- a/lib/internal/main/eval_stdin.js
+++ b/lib/internal/main/eval_stdin.js
@@ -7,6 +7,7 @@ const {
 } = require('internal/bootstrap/pre_execution');
 
 const {
+  evalModule,
   evalScript,
   readStdin
 } = require('internal/process/execution');
@@ -16,5 +17,8 @@ markBootstrapComplete();
 
 readStdin((code) => {
   process._eval = code;
-  evalScript('[stdin]', process._eval, process._breakFirstLine);
+  if (require('internal/process/esm_loader').typeFlag === 'module')
+    evalModule(process._eval);
+  else
+    evalScript('[stdin]', process._eval, process._breakFirstLine);
 });
diff --git a/lib/internal/main/eval_string.js b/lib/internal/main/eval_string.js
index 953fab386d..9328a114aa 100644
--- a/lib/internal/main/eval_string.js
+++ b/lib/internal/main/eval_string.js
@@ -6,11 +6,14 @@
 const {
   prepareMainThreadExecution
 } = require('internal/bootstrap/pre_execution');
-const { evalScript } = require('internal/process/execution');
+const { evalModule, evalScript } = require('internal/process/execution');
 const { addBuiltinLibsToObject } = require('internal/modules/cjs/helpers');
 
 const source = require('internal/options').getOptionValue('--eval');
 prepareMainThreadExecution();
 addBuiltinLibsToObject(global);
 markBootstrapComplete();
-evalScript('[eval]', source, process._breakFirstLine);
+if (require('internal/process/esm_loader').typeFlag === 'module')
+  evalModule(source);
+else
+  evalScript('[eval]', source, process._breakFirstLine);
diff --git a/lib/internal/main/repl.js b/lib/internal/main/repl.js
index e6b9885351..7656af46a3 100644
--- a/lib/internal/main/repl.js
+++ b/lib/internal/main/repl.js
@@ -11,8 +11,15 @@ const {
   evalScript
 } = require('internal/process/execution');
 
+const { ERR_INVALID_REPL_TYPE } = require('internal/errors').codes;
+
 prepareMainThreadExecution();
 
+// --type flag not supported in REPL
+if (require('internal/process/esm_loader').typeFlag) {
+  throw ERR_INVALID_REPL_TYPE();
+}
+
 const cliRepl = require('internal/repl');
 cliRepl.createInternalRepl(process.env, (err, repl) => {
   if (err) {
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index f28dadc654..533e65385a 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -864,21 +864,21 @@ if (experimentalModules) {
 // bootstrap main module.
 Module.runMain = function() {
   // Load the main module--the command line argument.
-  const base = path.basename(process.argv[1]);
-  const ext = path.extname(base);
-  const isESM = ext === '.mjs';
-
-  if (experimentalModules && isESM) {
+  if (experimentalModules) {
     if (asyncESM === undefined) lazyLoadESM();
-    asyncESM.loaderPromise.then((loader) => {
-      return loader.import(pathToFileURL(process.argv[1]).pathname);
-    })
-    .catch((e) => {
-      internalBinding('task_queue').triggerFatalException(e);
-    });
-  } else {
-    Module._load(process.argv[1], null, true);
+    if (asyncESM.typeFlag !== 'commonjs') {
+      asyncESM.loaderPromise.then((loader) => {
+        return loader.import(pathToFileURL(process.argv[1]).pathname);
+      })
+      .catch((e) => {
+        internalBinding('task_queue').triggerFatalException(e);
+      });
+      // Handle any nextTicks added in the first tick of the program
+      process._tickCallback();
+      return;
+    }
   }
+  Module._load(process.argv[1], null, true);
   // Handle any nextTicks added in the first tick of the program
   process._tickCallback();
 };
diff --git a/lib/internal/modules/esm/default_resolve.js b/lib/internal/modules/esm/default_resolve.js
index d1d400c6b5..5471ee629a 100644
--- a/lib/internal/modules/esm/default_resolve.js
+++ b/lib/internal/modules/esm/default_resolve.js
@@ -1,48 +1,107 @@
 'use strict';
 
-const { URL } = require('url');
-const CJSmodule = require('internal/modules/cjs/loader');
 const internalFS = require('internal/fs/utils');
 const { NativeModule } = require('internal/bootstrap/loaders');
 const { extname } = require('path');
-const { realpathSync } = require('fs');
+const { realpathSync, readFileSync } = require('fs');
 const { getOptionValue } = require('internal/options');
 const preserveSymlinks = getOptionValue('--preserve-symlinks');
 const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
-const {
-  ERR_MODULE_NOT_FOUND,
-  ERR_UNKNOWN_FILE_EXTENSION
-} = require('internal/errors').codes;
+const { ERR_INVALID_PACKAGE_CONFIG,
+        ERR_TYPE_MISMATCH,
+        ERR_UNKNOWN_FILE_EXTENSION } = require('internal/errors').codes;
 const { resolve: moduleWrapResolve } = internalBinding('module_wrap');
-const StringStartsWith = Function.call.bind(String.prototype.startsWith);
-const { pathToFileURL, fileURLToPath } = require('internal/url');
+const { pathToFileURL, fileURLToPath, URL } = require('internal/url');
+const asyncESM = require('internal/process/esm_loader');
 
 const realpathCache = new Map();
+// TOOD(@guybedford): Shared cache with C++
+const pjsonCache = new Map();
 
-function search(target, base) {
+const extensionFormatMap = {
+  '__proto__': null,
+  '.cjs': 'commonjs',
+  '.js': 'module',
+  '.mjs': 'module'
+};
+
+const legacyExtensionFormatMap = {
+  '__proto__': null,
+  '.cjs': 'commonjs',
+  '.js': 'commonjs',
+  '.json': 'commonjs',
+  '.mjs': 'module',
+  '.node': 'commonjs'
+};
+
+function readPackageConfig(path, parentURL) {
+  const existing = pjsonCache.get(path);
+  if (existing !== undefined)
+    return existing;
   try {
-    return moduleWrapResolve(target, base);
+    return JSON.parse(readFileSync(path).toString());
   } catch (e) {
-    e.stack; // cause V8 to generate stack before rethrow
-    let error = e;
-    try {
-      const questionedBase = new URL(base);
-      const tmpMod = new CJSmodule(questionedBase.pathname, null);
-      tmpMod.paths = CJSmodule._nodeModulePaths(
-        new URL('./', questionedBase).pathname);
-      const found = CJSmodule._resolveFilename(target, tmpMod);
-      error = new ERR_MODULE_NOT_FOUND(target, fileURLToPath(base), found);
-    } catch {
-      // ignore
+    if (e.code === 'ENOENT') {
+      pjsonCache.set(path, null);
+      return null;
+    } else if (e instanceof SyntaxError) {
+      throw new ERR_INVALID_PACKAGE_CONFIG(path, fileURLToPath(parentURL));
     }
-    throw error;
+    throw e;
   }
 }
 
-const extensionFormatMap = {
-  '__proto__': null,
-  '.mjs': 'esm'
-};
+function getPackageBoundaryConfig(url, parentURL) {
+  let pjsonURL = new URL('package.json', url);
+  while (true) {
+    const pcfg = readPackageConfig(fileURLToPath(pjsonURL), parentURL);
+    if (pcfg)
+      return pcfg;
+
+    const lastPjsonURL = pjsonURL;
+    pjsonURL = new URL('../package.json', pjsonURL);
+
+    // Terminates at root where ../package.json equals ../../package.json
+    // (can't just check "/package.json" for Windows support).
+    if (pjsonURL.pathname === lastPjsonURL.pathname)
+      return;
+  }
+}
+
+function getModuleFormat(url, isMain, parentURL) {
+  const pcfg = getPackageBoundaryConfig(url, parentURL);
+
+  const legacy = !pcfg || pcfg.type !== 'module';
+
+  const ext = extname(url.pathname);
+
+  let format = (legacy ? legacyExtensionFormatMap : extensionFormatMap)[ext];
+
+  if (!format) {
+    if (isMain)
+      format = legacy ? 'commonjs' : 'module';
+    else
+      throw new ERR_UNKNOWN_FILE_EXTENSION(fileURLToPath(url),
+                                           fileURLToPath(parentURL));
+  }
+
+  // Check for mismatch between --type and file extension,
+  // and between --type and the "type" field in package.json.
+  if (isMain && format !== 'module' && asyncESM.typeFlag === 'module') {
+    // Conflict between package scope type and --type
+    if (ext === '.js') {
+      if (pcfg && pcfg.type)
+        throw new ERR_TYPE_MISMATCH(
+          fileURLToPath(url), ext, asyncESM.typeFlag, 'scope');
+    // Conflict between explicit extension (.mjs, .cjs) and --type
+    } else {
+      throw new ERR_TYPE_MISMATCH(
+        fileURLToPath(url), ext, asyncESM.typeFlag, 'extension');
+    }
+  }
+
+  return format;
+}
 
 function resolve(specifier, parentURL) {
   if (NativeModule.canBeRequiredByUsers(specifier)) {
@@ -52,21 +111,11 @@ function resolve(specifier, parentURL) {
     };
   }
 
-  let url;
-  try {
-    url = search(specifier,
-                 parentURL || pathToFileURL(`${process.cwd()}/`).href);
-  } catch (e) {
-    if (typeof e.message === 'string' &&
-        StringStartsWith(e.message, 'Cannot find module')) {
-      e.code = 'MODULE_NOT_FOUND';
-      // TODO: also add e.requireStack to match behavior with CJS
-      // MODULE_NOT_FOUND.
-    }
-    throw e;
-  }
-
   const isMain = parentURL === undefined;
+  if (isMain)
+    parentURL = pathToFileURL(`${process.cwd()}/`).href;
+
+  let url = moduleWrapResolve(specifier, parentURL);
 
   if (isMain ? !preserveSymlinksMain : !preserveSymlinks) {
     const real = realpathSync(fileURLToPath(url), {
@@ -78,16 +127,7 @@ function resolve(specifier, parentURL) {
     url.hash = old.hash;
   }
 
-  const ext = extname(url.pathname);
-
-  let format = extensionFormatMap[ext];
-  if (!format) {
-    if (isMain)
-      format = 'cjs';
-    else
-      throw new ERR_UNKNOWN_FILE_EXTENSION(url.pathname,
-                                           fileURLToPath(parentURL));
-  }
+  const format = getModuleFormat(url, isMain, parentURL);
 
   return { url: `${url}`, format };
 }
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index a1a1621909..dced45f7a0 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -11,10 +11,12 @@ const { URL } = require('url');
 const { validateString } = require('internal/validators');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
+
 const defaultResolve = require('internal/modules/esm/default_resolve');
 const createDynamicModule = require(
   'internal/modules/esm/create_dynamic_module');
-const translators = require('internal/modules/esm/translators');
+const { translators } = require('internal/modules/esm/translators');
+const { ModuleWrap } = internalBinding('module_wrap');
 
 const FunctionBind = Function.call.bind(Function.prototype.bind);
 
@@ -32,6 +34,9 @@ class Loader {
     // Registry of loaded modules, akin to `require.cache`
     this.moduleMap = new ModuleMap();
 
+    // Map of already-loaded CJS modules to use
+    this.cjsCache = new Map();
+
     // The resolver has the signature
     //   (specifier : string, parentURL : string, defaultResolve)
     //       -> Promise<{ url : string, format: string }>
@@ -48,6 +53,8 @@ class Loader {
     // an object with the same keys as `exports`, whose values are get/set
     // functions for the actual exported values.
     this._dynamicInstantiate = undefined;
+    // The index for assigning unique URLs to anonymous module evaluation
+    this.evalIndex = 0;
   }
 
   async resolve(specifier, parentURL) {
@@ -95,9 +102,25 @@ class Loader {
     return { url, format };
   }
 
+  async eval(source, url = `eval:${++this.evalIndex}`) {
+    const evalInstance = async (url) => {
+      return {
+        module: new ModuleWrap(source, url),
+        reflect: undefined
+      };
+    };
+    const job = new ModuleJob(this, url, evalInstance, false);
+    this.moduleMap.set(url, job);
+    const { module, result } = await job.run();
+    return {
+      namespace: module.namespace(),
+      result
+    };
+  }
+
   async import(specifier, parent) {
     const job = await this.getModuleJob(specifier, parent);
-    const module = await job.run();
+    const { module } = await job.run();
     return module.namespace();
   }
 
@@ -143,4 +166,4 @@ class Loader {
 
 Object.setPrototypeOf(Loader.prototype, null);
 
-module.exports = Loader;
+exports.Loader = Loader;
diff --git a/lib/internal/modules/esm/module_job.js b/lib/internal/modules/esm/module_job.js
index 016495096c..8e0c7b7be9 100644
--- a/lib/internal/modules/esm/module_job.js
+++ b/lib/internal/modules/esm/module_job.js
@@ -23,7 +23,7 @@ class ModuleJob {
 
     // This is a Promise<{ module, reflect }>, whose fields will be copied
     // onto `this` by `link()` below once it has been resolved.
-    this.modulePromise = moduleProvider(url, isMain);
+    this.modulePromise = moduleProvider.call(loader, url, isMain);
     this.module = undefined;
     this.reflect = undefined;
 
@@ -101,8 +101,7 @@ class ModuleJob {
 
   async run() {
     const module = await this.instantiate();
-    module.evaluate(-1, false);
-    return module;
+    return { module, result: module.evaluate(-1, false) };
   }
 }
 Object.setPrototypeOf(ModuleJob.prototype, null);
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index 46e3bdd998..456f541ee6 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -23,7 +23,7 @@ const StringReplace = Function.call.bind(String.prototype.replace);
 const debug = debuglog('esm');
 
 const translators = new SafeMap();
-module.exports = translators;
+exports.translators = translators;
 
 function initializeImportMeta(meta, { url }) {
   meta.url = url;
@@ -35,7 +35,7 @@ async function importModuleDynamically(specifier, { url }) {
 }
 
 // Strategy for loading a standard JavaScript module
-translators.set('esm', async (url) => {
+translators.set('module', async function(url) {
   const source = `${await readFileAsync(new URL(url))}`;
   debug(`Translating StandardModule ${url}`);
   const module = new ModuleWrap(stripShebang(source), url);
@@ -52,9 +52,14 @@ translators.set('esm', async (url) => {
 // Strategy for loading a node-style CommonJS module
 const isWindows = process.platform === 'win32';
 const winSepRegEx = /\//g;
-translators.set('cjs', async (url, isMain) => {
+translators.set('commonjs', async function(url, isMain) {
   debug(`Translating CJSModule ${url}`);
   const pathname = internalURLModule.fileURLToPath(new URL(url));
+  const cached = this.cjsCache.get(url);
+  if (cached) {
+    this.cjsCache.delete(url);
+    return cached;
+  }
   const module = CJSModule._cache[
     isWindows ? StringReplace(pathname, winSepRegEx, '\\') : pathname];
   if (module && module.loaded) {
@@ -74,7 +79,7 @@ translators.set('cjs', async (url, isMain) => {
 
 // Strategy for loading a node builtin CommonJS module that isn't
 // through normal resolution
-translators.set('builtin', async (url) => {
+translators.set('builtin', async function(url) {
   debug(`Translating BuiltinModule ${url}`);
   // slice 'node:' scheme
   const id = url.slice(5);
diff --git a/lib/internal/process/esm_loader.js b/lib/internal/process/esm_loader.js
index 6ed43970cb..e405dc8b30 100644
--- a/lib/internal/process/esm_loader.js
+++ b/lib/internal/process/esm_loader.js
@@ -3,14 +3,20 @@
 const {
   callbackMap,
 } = internalBinding('module_wrap');
+const {
+  ERR_INVALID_TYPE_FLAG,
+  ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING,
+} = require('internal/errors').codes;
+
+const type = require('internal/options').getOptionValue('--type');
+if (type && type !== 'commonjs' && type !== 'module')
+  throw new ERR_INVALID_TYPE_FLAG(type);
+exports.typeFlag = type;
 
-const Loader = require('internal/modules/esm/loader');
+const { Loader } = require('internal/modules/esm/loader');
 const {
   wrapToModuleMap,
 } = require('internal/vm/source_text_module');
-const {
-  ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING,
-} = require('internal/errors').codes;
 
 exports.initializeImportMetaObject = function(wrap, meta) {
   if (callbackMap.has(wrap)) {
@@ -33,9 +39,7 @@ exports.importModuleDynamicallyCallback = async function(wrap, specifier) {
 };
 
 let loaderResolve;
-exports.loaderPromise = new Promise((resolve, reject) => {
-  loaderResolve = resolve;
-});
+exports.loaderPromise = new Promise((resolve) => loaderResolve = resolve);
 
 exports.ESMLoader = undefined;
 
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index 7118dbf3ad..070410ef6f 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -33,6 +33,24 @@ function tryGetCwd() {
   }
 }
 
+function evalModule(source) {
+  const { decorateErrorStack } = require('internal/util');
+  const asyncESM = require('internal/process/esm_loader');
+  asyncESM.loaderPromise.then(async (loader) => {
+    const { result } = await loader.eval(source);
+    if (require('internal/options').getOptionValue('--print')) {
+      console.log(result);
+    }
+  })
+  .catch((e) => {
+    decorateErrorStack(e);
+    console.error(e);
+    process.exit(1);
+  });
+  // Handle any nextTicks added in the first tick of the program.
+  process._tickCallback();
+}
+
 function evalScript(name, body, breakFirstLine) {
   const CJSModule = require('internal/modules/cjs/loader');
   const { kVmBreakFirstLineSymbol } = require('internal/util');
@@ -176,6 +194,7 @@ function readStdin(callback) {
 module.exports = {
   readStdin,
   tryGetCwd,
+  evalModule,
   evalScript,
   fatalException: createFatalException(),
   setUncaughtExceptionCaptureCallback,
diff --git a/src/env.h b/src/env.h
index e07e77aaa6..e351afd9a4 100644
--- a/src/env.h
+++ b/src/env.h
@@ -73,14 +73,23 @@ namespace loader {
 class ModuleWrap;
 
 struct PackageConfig {
-  enum class Exists { Yes, No };
-  enum class IsValid { Yes, No };
-  enum class HasMain { Yes, No };
-
-  Exists exists;
-  IsValid is_valid;
-  HasMain has_main;
-  std::string main;
+  struct Exists {
+    enum Bool { No, Yes };
+  };
+  struct IsValid {
+    enum Bool { No, Yes };
+  };
+  struct HasMain {
+    enum Bool { No, Yes };
+  };
+  struct IsESM {
+    enum Bool { No, Yes };
+  };
+  const Exists::Bool exists;
+  const IsValid::Bool is_valid;
+  const HasMain::Bool has_main;
+  const std::string main;
+  const IsESM::Bool esm;
 };
 }  // namespace loader
 
@@ -209,6 +218,7 @@ constexpr size_t kFsStatsBufferLength = kFsStatsFieldsNumber * 2;
   V(kill_signal_string, "killSignal")                                          \
   V(kind_string, "kind")                                                       \
   V(library_string, "library")                                                 \
+  V(legacy_string, "legacy")                                                   \
   V(mac_string, "mac")                                                         \
   V(main_string, "main")                                                       \
   V(max_buffer_string, "maxBuffer")                                            \
diff --git a/src/module_wrap.cc b/src/module_wrap.cc
index 04bee9dadb..96bcda2fd7 100644
--- a/src/module_wrap.cc
+++ b/src/module_wrap.cc
@@ -45,8 +45,6 @@ using v8::String;
 using v8::Undefined;
 using v8::Value;
 
-static const char* const EXTENSIONS[] = {".mjs"};
-
 ModuleWrap::ModuleWrap(Environment* env,
                        Local<Object> object,
                        Local<Module> module,
@@ -471,14 +469,30 @@ std::string ReadFile(uv_file file) {
 }
 
 enum DescriptorType {
-  NONE,
   FILE,
-  DIRECTORY
+  DIRECTORY,
+  NONE
 };
 
-DescriptorType CheckDescriptor(const std::string& path) {
+// When DescriptorType cache is added, this can also return
+// Nothing for the "null" cache entries.
+inline Maybe<uv_file> OpenDescriptor(const std::string& path) {
+  uv_fs_t fs_req;
+  uv_file fd = uv_fs_open(nullptr, &fs_req, path.c_str(), O_RDONLY, 0, nullptr);
+  uv_fs_req_cleanup(&fs_req);
+  if (fd < 0) return Nothing<uv_file>();
+  return Just(fd);
+}
+
+inline void CloseDescriptor(uv_file fd) {
+  uv_fs_t fs_req;
+  uv_fs_close(nullptr, &fs_req, fd, nullptr);
+  uv_fs_req_cleanup(&fs_req);
+}
+
+inline DescriptorType CheckDescriptorAtFile(uv_file fd) {
   uv_fs_t fs_req;
-  int rc = uv_fs_stat(nullptr, &fs_req, path.c_str(), nullptr);
+  int rc = uv_fs_fstat(nullptr, &fs_req, fd, nullptr);
   if (rc == 0) {
     uint64_t is_directory = fs_req.statbuf.st_mode & S_IFDIR;
     uv_fs_req_cleanup(&fs_req);
@@ -488,27 +502,282 @@ DescriptorType CheckDescriptor(const std::string& path) {
   return NONE;
 }
 
+// TODO(@guybedford): Add a DescriptorType cache layer here.
+// Should be directory based -> if path/to/dir doesn't exist
+// then the cache should early-fail any path/to/dir/file check.
+DescriptorType CheckDescriptorAtPath(const std::string& path) {
+  Maybe<uv_file> fd = OpenDescriptor(path);
+  if (fd.IsNothing()) return NONE;
+  DescriptorType type = CheckDescriptorAtFile(fd.FromJust());
+  CloseDescriptor(fd.FromJust());
+  return type;
+}
+
+Maybe<std::string> ReadIfFile(const std::string& path) {
+  Maybe<uv_file> fd = OpenDescriptor(path);
+  if (fd.IsNothing()) return Nothing<std::string>();
+  DescriptorType type = CheckDescriptorAtFile(fd.FromJust());
+  if (type != FILE) return Nothing<std::string>();
+  std::string source = ReadFile(fd.FromJust());
+  CloseDescriptor(fd.FromJust());
+  return Just(source);
+}
+
+using Exists = PackageConfig::Exists;
+using IsValid = PackageConfig::IsValid;
+using HasMain = PackageConfig::HasMain;
+using IsESM = PackageConfig::IsESM;
+
+Maybe<const PackageConfig*> GetPackageConfig(Environment* env,
+                                             const std::string& path,
+                                             const URL& base) {
+  auto existing = env->package_json_cache.find(path);
+  if (existing != env->package_json_cache.end()) {
+    return Just(&existing->second);
+  }
+
+  Maybe<std::string> source = ReadIfFile(path);
+
+  if (source.IsNothing()) {
+    auto entry = env->package_json_cache.emplace(path,
+        PackageConfig { Exists::No, IsValid::Yes, HasMain::No, "",
+                        IsESM::No });
+    return Just(&entry.first->second);
+  }
+
+  std::string pkg_src = source.FromJust();
+
+  Isolate* isolate = env->isolate();
+  v8::HandleScope handle_scope(isolate);
+
+  bool parsed = false;
+  Local<Object> pkg_json;
+  {
+    Local<String> src;
+    Local<Value> pkg_json_v;
+    if (String::NewFromUtf8(isolate,
+                            pkg_src.c_str(),
+                            v8::NewStringType::kNormal,
+                            pkg_src.length()).ToLocal(&src) &&
+        v8::JSON::Parse(env->context(), src).ToLocal(&pkg_json_v) &&
+        pkg_json_v->ToObject(env->context()).ToLocal(&pkg_json)) {
+      parsed = true;
+    }
+  }
+
+  if (!parsed) {
+    (void)env->package_json_cache.emplace(path,
+        PackageConfig { Exists::Yes, IsValid::No, HasMain::No, "",
+                        IsESM::No });
+    std::string msg = "Invalid JSON in '" + path +
+        "' imported from " + base.ToFilePath();
+    node::THROW_ERR_INVALID_PACKAGE_CONFIG(env, msg.c_str());
+    return Nothing<const PackageConfig*>();
+  }
+
+  Local<Value> pkg_main;
+  HasMain::Bool has_main = HasMain::No;
+  std::string main_std;
+  if (pkg_json->Get(env->context(), env->main_string()).ToLocal(&pkg_main)) {
+    if (pkg_main->IsString()) {
+      has_main = HasMain::Yes;
+    }
+    Utf8Value main_utf8(isolate, pkg_main);
+    main_std.assign(std::string(*main_utf8, main_utf8.length()));
+  }
+
+  IsESM::Bool esm = IsESM::No;
+  Local<Value> type_v;
+  if (pkg_json->Get(env->context(), env->type_string()).ToLocal(&type_v)) {
+    if (type_v->StrictEquals(env->module_string())) {
+      esm = IsESM::Yes;
+    }
+  }
+
+  Local<Value> exports_v;
+  if (pkg_json->Get(env->context(),
+      env->exports_string()).ToLocal(&exports_v) &&
+      (exports_v->IsObject() || exports_v->IsString() ||
+      exports_v->IsBoolean())) {
+    Persistent<Value> exports;
+    // esm = IsESM::Yes;
+    exports.Reset(env->isolate(), exports_v);
+
+    auto entry = env->package_json_cache.emplace(path,
+        PackageConfig { Exists::Yes, IsValid::Yes, has_main, main_std,
+                        esm });
+    return Just(&entry.first->second);
+  }
+
+  auto entry = env->package_json_cache.emplace(path,
+      PackageConfig { Exists::Yes, IsValid::Yes, has_main, main_std,
+                      esm });
+  return Just(&entry.first->second);
+}
+
+/*
+ * Legacy CommonJS main resolution:
+ * 1. let M = pkg_url + (json main field)
+ * 2. TRY(M, M.js, M.json, M.node)
+ * 3. TRY(M/index.js, M/index.json, M/index.node)
+ * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
+ * 5. NOT_FOUND
+ */
+inline bool FileExists(const URL& url) {
+  return CheckDescriptorAtPath(url.ToFilePath()) == FILE;
+}
+Maybe<URL> LegacyMainResolve(const URL& pjson_url,
+                             const PackageConfig& pcfg) {
+  URL guess;
+  if (pcfg.has_main == HasMain::Yes) {
+    // Note: fs check redundances will be handled by Descriptor cache here.
+    if (FileExists(guess = URL("./" + pcfg.main, pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + ".js", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + ".json", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + ".node", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + "/index.js", pjson_url))) {
+      return Just(guess);
+    }
+    // Such stat.
+    if (FileExists(guess = URL("./" + pcfg.main + "/index.json", pjson_url))) {
+      return Just(guess);
+    }
+    if (FileExists(guess = URL("./" + pcfg.main + "/index.node", pjson_url))) {
+      return Just(guess);
+    }
+    // Fallthrough.
+  }
+  if (FileExists(guess = URL("./index.js", pjson_url))) {
+    return Just(guess);
+  }
+  // So fs.
+  if (FileExists(guess = URL("./index.json", pjson_url))) {
+    return Just(guess);
+  }
+  if (FileExists(guess = URL("./index.node", pjson_url))) {
+    return Just(guess);
+  }
+  // Not found.
+  return Nothing<URL>();
+}
+
+Maybe<URL> FinalizeResolution(Environment* env,
+                                           const URL& resolved,
+                                           const URL& base,
+                                           bool check_exists) {
+  const std::string& path = resolved.ToFilePath();
+
+  if (check_exists && CheckDescriptorAtPath(path) != FILE) {
+    std::string msg = "Cannot find module '" + path +
+        "' imported from " + base.ToFilePath();
+    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+    return Nothing<URL>();
+  }
+
+  return Just(resolved);
+}
+
+Maybe<URL> PackageMainResolve(Environment* env,
+                                           const URL& pjson_url,
+                                           const PackageConfig& pcfg,
+                                           const URL& base) {
+  if (pcfg.exists == Exists::No || (
+      pcfg.esm == IsESM::Yes && pcfg.has_main == HasMain::No)) {
+    std::string msg = "Cannot find main entry point for '" +
+        URL(".", pjson_url).ToFilePath() + "' imported from " +
+        base.ToFilePath();
+    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+    return Nothing<URL>();
+  }
+  if (pcfg.has_main == HasMain::Yes &&
+      pcfg.main.substr(pcfg.main.length() - 4, 4) == ".mjs") {
+    return FinalizeResolution(env, URL(pcfg.main, pjson_url), base, true);
+  }
+  if (pcfg.esm == IsESM::Yes &&
+      pcfg.main.substr(pcfg.main.length() - 3, 3) == ".js") {
+    return FinalizeResolution(env, URL(pcfg.main, pjson_url), base, true);
+  }
+
+  Maybe<URL> resolved = LegacyMainResolve(pjson_url, pcfg);
+  // Legacy main resolution error
+  if (resolved.IsNothing()) {
+    return Nothing<URL>();
+  }
+  return resolved;
+}
+
 Maybe<URL> PackageResolve(Environment* env,
                           const std::string& specifier,
                           const URL& base) {
-  URL parent(".", base);
+  size_t sep_index = specifier.find('/');
+  if (specifier[0] == '@' && (sep_index == std::string::npos ||
+      specifier.length() == 0)) {
+    std::string msg = "Invalid package name '" + specifier +
+      "' imported from " + base.ToFilePath();
+    node::THROW_ERR_INVALID_MODULE_SPECIFIER(env, msg.c_str());
+    return Nothing<URL>();
+  }
+  bool scope = false;
+  if (specifier[0] == '@') {
+    scope = true;
+    sep_index = specifier.find('/', sep_index + 1);
+  }
+  std::string pkg_name = specifier.substr(0,
+      sep_index == std::string::npos ? std::string::npos : sep_index);
+  std::string pkg_subpath;
+  if ((sep_index == std::string::npos ||
+      sep_index == specifier.length() - 1)) {
+    pkg_subpath = "";
+  } else {
+    pkg_subpath = "." + specifier.substr(sep_index);
+  }
+  URL pjson_url("./node_modules/" + pkg_name + "/package.json", &base);
+  std::string pjson_path = pjson_url.ToFilePath();
   std::string last_path;
   do {
-    URL pkg_url("./node_modules/" + specifier, &parent);
-    DescriptorType check = CheckDescriptor(pkg_url.ToFilePath());
-    if (check == FILE) return Just(pkg_url);
-    last_path = parent.path();
-    parent = URL("..", &parent);
-    // cross-platform root check
-  } while (parent.path() != last_path);
+    DescriptorType check =
+        CheckDescriptorAtPath(pjson_path.substr(0, pjson_path.length() - 13));
+    if (check != DIRECTORY) {
+      last_path = pjson_path;
+      pjson_url = URL((scope ?
+          "../../../../node_modules/" : "../../../node_modules/") +
+          pkg_name + "/package.json", &pjson_url);
+      pjson_path = pjson_url.ToFilePath();
+      continue;
+    }
+
+    // Package match.
+    Maybe<const PackageConfig*> pcfg = GetPackageConfig(env, pjson_path, base);
+    // Invalid package configuration error.
+    if (pcfg.IsNothing()) return Nothing<URL>();
+    if (!pkg_subpath.length()) {
+      return PackageMainResolve(env, pjson_url, *pcfg.FromJust(), base);
+    } else {
+      return FinalizeResolution(env, URL(pkg_subpath, pjson_url), base, true);
+    }
+    CHECK(false);
+    // Cross-platform root check.
+  } while (pjson_path.length() != last_path.length());
+
+  std::string msg = "Cannot find package '" + pkg_name +
+      "' imported from " + base.ToFilePath();
+  node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
   return Nothing<URL>();
 }
 
 }  // anonymous namespace
 
 Maybe<URL> Resolve(Environment* env,
-                   const std::string& specifier,
-                   const URL& base) {
+                                const std::string& specifier,
+                                const URL& base) {
   // Order swapped from spec for minor perf gain.
   // Ok since relative URLs cannot parse as URLs.
   URL resolved;
@@ -522,14 +791,7 @@ Maybe<URL> Resolve(Environment* env,
       return PackageResolve(env, specifier, base);
     }
   }
-  DescriptorType check = CheckDescriptor(resolved.ToFilePath());
-  if (check != FILE) {
-    std::string msg = "Cannot find module '" + resolved.ToFilePath() +
-          "' imported from " + base.ToFilePath();
-    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
-    return Nothing<URL>();
-  }
-  return Just(resolved);
+  return FinalizeResolution(env, resolved, base, true);
 }
 
 void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
@@ -552,22 +814,23 @@ void ModuleWrap::Resolve(const FunctionCallbackInfo<Value>& args) {
   }
 
   TryCatchScope try_catch(env);
-  Maybe<URL> result = node::loader::Resolve(env, specifier_std, url);
-  if (try_catch.HasCaught()) {
-    try_catch.ReThrow();
-    return;
-  } else if (result.IsNothing() ||
-             (result.FromJust().flags() & URL_FLAGS_FAILED)) {
-    std::string msg = "Cannot find module '" + specifier_std +
-        "' imported from " + url.ToFilePath();
-    node::THROW_ERR_MODULE_NOT_FOUND(env, msg.c_str());
+  Maybe<URL> result =
+      node::loader::Resolve(env,
+                            specifier_std,
+                            url);
+  if (result.IsNothing()) {
+    CHECK(try_catch.HasCaught());
     try_catch.ReThrow();
     return;
   }
+  CHECK(!try_catch.HasCaught());
+
+  URL resolution = result.FromJust();
+  CHECK(!(resolution.flags() & URL_FLAGS_FAILED));
+
+  Local<Value> resolved = resolution.ToObject(env).ToLocalChecked();
 
-  MaybeLocal<Value> obj = result.FromJust().ToObject(env);
-  if (!obj.IsEmpty())
-    args.GetReturnValue().Set(obj.ToLocalChecked());
+  args.GetReturnValue().Set(resolved);
 }
 
 static MaybeLocal<Promise> ImportModuleDynamically(
diff --git a/src/module_wrap.h b/src/module_wrap.h
index d3089202ba..9ddb99d174 100644
--- a/src/module_wrap.h
+++ b/src/module_wrap.h
@@ -24,10 +24,6 @@ enum HostDefinedOptions : int {
   kLength = 10,
 };
 
-v8::Maybe<url::URL> Resolve(Environment* env,
-                            const std::string& specifier,
-                            const url::URL& base);
-
 class ModuleWrap : public BaseObject {
  public:
   static const std::string EXTENSIONS[];
diff --git a/src/node_errors.h b/src/node_errors.h
index 42d34458ed..9d3f2ead71 100644
--- a/src/node_errors.h
+++ b/src/node_errors.h
@@ -45,6 +45,8 @@ void FatalException(v8::Isolate* isolate,
   V(ERR_CONSTRUCT_CALL_REQUIRED, Error)                                      \
   V(ERR_INVALID_ARG_VALUE, TypeError)                                        \
   V(ERR_INVALID_ARG_TYPE, TypeError)                                         \
+  V(ERR_INVALID_MODULE_SPECIFIER, TypeError)                                 \
+  V(ERR_INVALID_PACKAGE_CONFIG, SyntaxError)                                 \
   V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                  \
   V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                     \
   V(ERR_MISSING_ARGS, TypeError)                                             \
diff --git a/src/node_options.cc b/src/node_options.cc
index 96fe7b3585..74ead2c248 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -262,10 +262,12 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             kAllowedInEnvironment);
   AddOption("--preserve-symlinks",
             "preserve symbolic links when resolving",
-            &EnvironmentOptions::preserve_symlinks);
+            &EnvironmentOptions::preserve_symlinks,
+            kAllowedInEnvironment);
   AddOption("--preserve-symlinks-main",
             "preserve symbolic links when resolving the main module",
-            &EnvironmentOptions::preserve_symlinks_main);
+            &EnvironmentOptions::preserve_symlinks_main,
+            kAllowedInEnvironment);
   AddOption("--prof-process",
             "process V8 profiler output generated using --prof",
             &EnvironmentOptions::prof_process);
@@ -292,6 +294,11 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
             "show stack traces on process warnings",
             &EnvironmentOptions::trace_warnings,
             kAllowedInEnvironment);
+  AddOption("--type",
+            "top-level module type name",
+            &EnvironmentOptions::module_type,
+            kAllowedInEnvironment);
+  AddAlias("-m", { "--type", "module" });
 
   AddOption("--check",
             "syntax check script without executing",
diff --git a/src/node_options.h b/src/node_options.h
index 7346e955db..ee4cc98c9b 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -86,6 +86,7 @@ class EnvironmentOptions : public Options {
  public:
   bool abort_on_uncaught_exception = false;
   bool experimental_modules = false;
+  std::string module_type;
   std::string experimental_policy;
   bool experimental_repl_await = false;
   bool experimental_vm_modules = false;
diff --git a/test/es-module/test-esm-dynamic-import.js b/test/es-module/test-esm-dynamic-import.js
index 07294d4d24..ca9c99007b 100644
--- a/test/es-module/test-esm-dynamic-import.js
+++ b/test/es-module/test-esm-dynamic-import.js
@@ -18,7 +18,7 @@ function expectErrorProperty(result, propertyKey, value) {
 }
 
 function expectMissingModuleError(result) {
-  expectErrorProperty(result, 'code', 'MODULE_NOT_FOUND');
+  expectErrorProperty(result, 'code', 'ERR_MODULE_NOT_FOUND');
 }
 
 function expectOkNamespace(result) {
diff --git a/test/es-module/test-esm-loader-modulemap.js b/test/es-module/test-esm-loader-modulemap.js
index 946d54ffaa..5493c6c47c 100644
--- a/test/es-module/test-esm-loader-modulemap.js
+++ b/test/es-module/test-esm-loader-modulemap.js
@@ -7,7 +7,7 @@
 const common = require('../common');
 
 const { URL } = require('url');
-const Loader = require('internal/modules/esm/loader');
+const { Loader } = require('internal/modules/esm/loader');
 const ModuleMap = require('internal/modules/esm/module_map');
 const ModuleJob = require('internal/modules/esm/module_job');
 const createDynamicModule = require(
diff --git a/test/es-module/test-esm-main-lookup.mjs b/test/es-module/test-esm-main-lookup.mjs
index 76c6263853..19c025beab 100644
--- a/test/es-module/test-esm-main-lookup.mjs
+++ b/test/es-module/test-esm-main-lookup.mjs
@@ -8,7 +8,7 @@ async function main() {
   try {
     mod = await import('../fixtures/es-modules/pjson-main');
   } catch (e) {
-    assert.strictEqual(e.code, 'MODULE_NOT_FOUND');
+    assert.strictEqual(e.code, 'ERR_MODULE_NOT_FOUND');
   }
 
   assert.strictEqual(mod, undefined);
diff --git a/test/es-module/test-esm-package-scope.mjs b/test/es-module/test-esm-package-scope.mjs
new file mode 100644
index 0000000000..6e07a307e0
--- /dev/null
+++ b/test/es-module/test-esm-package-scope.mjs
@@ -0,0 +1,12 @@
+// Flags: --experimental-modules
+/* eslint-disable node-core/required-modules */
+
+import '../common/index.mjs';
+import assert from 'assert';
+
+import legacyLoader from
+  '../fixtures/esm-package-scope/legacy-loader/index.mjs';
+import newLoader from '../fixtures/esm-package-scope/new-loader/index.js';
+
+assert.strictEqual(legacyLoader, 'legacy-loader');
+assert.strictEqual(newLoader, 'new-loader');
diff --git a/test/es-module/test-esm-symlink-type.js b/test/es-module/test-esm-symlink-type.js
new file mode 100644
index 0000000000..6159ebecd1
--- /dev/null
+++ b/test/es-module/test-esm-symlink-type.js
@@ -0,0 +1,77 @@
+'use strict';
+const common = require('../common');
+const fixtures = require('../common/fixtures');
+const path = require('path');
+const assert = require('assert');
+const exec = require('child_process').execFile;
+const fs = require('fs');
+
+const tmpdir = require('../common/tmpdir');
+tmpdir.refresh();
+const tmpDir = tmpdir.path;
+
+// Check that running the symlink executes the target as the correct type
+const symlinks = [
+  {
+    source: 'extensionless-symlink-to-mjs-file',
+    target: fixtures.path('es-modules/mjs-file.mjs'),
+    prints: '.mjs file',
+    errorsWithPreserveSymlinksMain: false
+  }, {
+    source: 'extensionless-symlink-to-cjs-file',
+    target: fixtures.path('es-modules/cjs-file.cjs'),
+    prints: '.cjs file',
+    errorsWithPreserveSymlinksMain: false
+  }, {
+    source: 'extensionless-symlink-to-file-in-module-scope',
+    target: fixtures.path('es-modules/package-type-module/index.js'),
+    prints: 'package-type-module',
+    // The package scope of the symlinks' sources is commonjs, and this
+    // symlink's target is a .js file in a module scope, so when the scope
+    // is evaluated based on the source (commonjs) this esm file should error
+    errorsWithPreserveSymlinksMain: true
+  }, {
+    source: 'extensionless-symlink-to-file-in-explicit-commonjs-scope',
+    target: fixtures.path('es-modules/package-type-commonjs/index.js'),
+    prints: 'package-type-commonjs',
+    errorsWithPreserveSymlinksMain: false
+  }, {
+    source: 'extensionless-symlink-to-file-in-implicit-commonjs-scope',
+    target: fixtures.path('es-modules/package-without-type/index.js'),
+    prints: 'package-without-type',
+    errorsWithPreserveSymlinksMain: false
+  }
+];
+
+symlinks.forEach((symlink) => {
+  const mainPath = path.join(tmpDir, symlink.source);
+  fs.symlinkSync(symlink.target, mainPath);
+
+  const flags = [
+    '--experimental-modules',
+    '--experimental-modules --preserve-symlinks-main'
+  ];
+  flags.forEach((nodeOptions) => {
+    const opts = {
+      env: Object.assign({}, process.env, { NODE_OPTIONS: nodeOptions })
+    };
+    exec(process.execPath, [mainPath], opts, common.mustCall(
+      (err, stdout) => {
+        if (nodeOptions.includes('--preserve-symlinks-main')) {
+          if (symlink.errorsWithPreserveSymlinksMain &&
+              err.toString().includes('Error')) return;
+          else if (!symlink.errorsWithPreserveSymlinksMain &&
+                    stdout.includes(symlink.prints)) return;
+          assert.fail(`For ${JSON.stringify(symlink)}, ${
+            (symlink.errorsWithPreserveSymlinksMain) ?
+              'failed to error' : 'errored unexpectedly'
+          } with --preserve-symlinks-main`);
+        } else {
+          if (stdout.includes(symlink.prints)) return;
+          assert.fail(`For ${JSON.stringify(symlink)}, failed to find ` +
+            `${symlink.prints} in: <\n${stdout}\n>`);
+        }
+      }
+    ));
+  });
+});
diff --git a/test/es-module/test-esm-type-flag-alias.mjs b/test/es-module/test-esm-type-flag-alias.mjs
new file mode 100644
index 0000000000..022847bcfb
--- /dev/null
+++ b/test/es-module/test-esm-type-flag-alias.mjs
@@ -0,0 +1,6 @@
+// Flags: --experimental-modules -m
+/* eslint-disable node-core/required-modules */
+import { message } from '../fixtures/es-modules/message.mjs';
+import assert from 'assert';
+
+assert.strictEqual(message, 'A message');
diff --git a/test/es-module/test-esm-type-flag-errors.js b/test/es-module/test-esm-type-flag-errors.js
new file mode 100644
index 0000000000..84d67a8681
--- /dev/null
+++ b/test/es-module/test-esm-type-flag-errors.js
@@ -0,0 +1,57 @@
+'use strict';
+const common = require('../common');
+const assert = require('assert');
+const exec = require('child_process').execFile;
+
+const mjsFile = require.resolve('../fixtures/es-modules/mjs-file.mjs');
+const cjsFile = require.resolve('../fixtures/es-modules/cjs-file.cjs');
+const packageWithoutTypeMain =
+  require.resolve('../fixtures/es-modules/package-without-type/index.js');
+const packageTypeCommonJsMain =
+  require.resolve('../fixtures/es-modules/package-type-commonjs/index.js');
+const packageTypeModuleMain =
+  require.resolve('../fixtures/es-modules/package-type-module/index.js');
+
+// Check that running `node` without options works
+expect('', mjsFile, '.mjs file');
+expect('', cjsFile, '.cjs file');
+expect('', packageTypeModuleMain, 'package-type-module');
+expect('', packageTypeCommonJsMain, 'package-type-commonjs');
+expect('', packageWithoutTypeMain, 'package-without-type');
+
+// Check that running with --type and no package.json "type" works
+expect('--type=commonjs', packageWithoutTypeMain, 'package-without-type');
+expect('--type=module', packageWithoutTypeMain, 'package-without-type');
+expect('-m', packageWithoutTypeMain, 'package-without-type');
+
+// Check that running with conflicting --type flags throws errors
+expect('--type=commonjs', mjsFile, 'ERR_REQUIRE_ESM', true);
+expect('--type=module', cjsFile, 'ERR_TYPE_MISMATCH', true);
+expect('-m', cjsFile, 'ERR_TYPE_MISMATCH', true);
+expect('--type=commonjs', packageTypeModuleMain,
+       'SyntaxError', true);
+expect('--type=module', packageTypeCommonJsMain,
+       'ERR_TYPE_MISMATCH', true);
+expect('-m', packageTypeCommonJsMain,
+       'ERR_TYPE_MISMATCH', true);
+
+function expect(opt = '', inputFile, want, wantsError = false) {
+  // TODO: Remove when --experimental-modules is unflagged
+  opt = `--experimental-modules ${opt}`;
+  const argv = [inputFile];
+  const opts = {
+    env: Object.assign({}, process.env, { NODE_OPTIONS: opt }),
+    maxBuffer: 1e6,
+  };
+  exec(process.execPath, argv, opts, common.mustCall((err, stdout, stderr) => {
+    if (wantsError) {
+      stdout = stderr;
+    } else {
+      assert.ifError(err);
+    }
+    if (stdout.includes(want)) return;
+
+    const o = JSON.stringify(opt);
+    assert.fail(`For ${o}, failed to find ${want} in: <\n${stdout}\n>`);
+  }));
+}
diff --git a/test/es-module/test-esm-type-flag.mjs b/test/es-module/test-esm-type-flag.mjs
new file mode 100644
index 0000000000..cf91580490
--- /dev/null
+++ b/test/es-module/test-esm-type-flag.mjs
@@ -0,0 +1,11 @@
+// Flags: --experimental-modules --type=module
+/* eslint-disable node-core/required-modules */
+import cjs from '../fixtures/baz.js';
+import '../common/index.mjs';
+import { message } from '../fixtures/es-modules/message.mjs';
+import assert from 'assert';
+
+// Assert we loaded esm dependency as ".js" in this mode
+assert.strictEqual(message, 'A message');
+// Assert we loaded CommonJS dependency
+assert.strictEqual(cjs, 'perhaps I work');
diff --git a/test/fixtures/es-modules/cjs-file.cjs b/test/fixtures/es-modules/cjs-file.cjs
new file mode 100644
index 0000000000..3d0637686e
--- /dev/null
+++ b/test/fixtures/es-modules/cjs-file.cjs
@@ -0,0 +1 @@
+console.log('.cjs file');
diff --git a/test/fixtures/es-modules/mjs-file.mjs b/test/fixtures/es-modules/mjs-file.mjs
new file mode 100644
index 0000000000..489d4ab570
--- /dev/null
+++ b/test/fixtures/es-modules/mjs-file.mjs
@@ -0,0 +1 @@
+console.log('.mjs file');
diff --git a/test/fixtures/es-modules/package-type-commonjs/index.js b/test/fixtures/es-modules/package-type-commonjs/index.js
new file mode 100644
index 0000000000..009431d851
--- /dev/null
+++ b/test/fixtures/es-modules/package-type-commonjs/index.js
@@ -0,0 +1,3 @@
+const identifier = 'package-type-commonjs';
+console.log(identifier);
+module.exports = identifier;
diff --git a/test/fixtures/es-modules/package-type-commonjs/package.json b/test/fixtures/es-modules/package-type-commonjs/package.json
new file mode 100644
index 0000000000..4aaa4a2388
--- /dev/null
+++ b/test/fixtures/es-modules/package-type-commonjs/package.json
@@ -0,0 +1,4 @@
+{
+  "type": "commonjs",
+  "main": "index.js"
+}
diff --git a/test/fixtures/es-modules/package-type-module/index.js b/test/fixtures/es-modules/package-type-module/index.js
new file mode 100644
index 0000000000..12aba970ef
--- /dev/null
+++ b/test/fixtures/es-modules/package-type-module/index.js
@@ -0,0 +1,3 @@
+const identifier = 'package-type-module';
+console.log(identifier);
+export default identifier;
diff --git a/test/fixtures/es-modules/package-type-module/package.json b/test/fixtures/es-modules/package-type-module/package.json
new file mode 100644
index 0000000000..07aec65d5a
--- /dev/null
+++ b/test/fixtures/es-modules/package-type-module/package.json
@@ -0,0 +1,4 @@
+{
+  "type": "module",
+  "main": "index.js"
+}
diff --git a/test/fixtures/es-modules/package-without-type/index.js b/test/fixtures/es-modules/package-without-type/index.js
new file mode 100644
index 0000000000..a547216cb0
--- /dev/null
+++ b/test/fixtures/es-modules/package-without-type/index.js
@@ -0,0 +1,3 @@
+const identifier = 'package-without-type';
+console.log(identifier);
+module.exports = identifier;
diff --git a/test/fixtures/es-modules/package-without-type/package.json b/test/fixtures/es-modules/package-without-type/package.json
new file mode 100644
index 0000000000..14ab704d8f
--- /dev/null
+++ b/test/fixtures/es-modules/package-without-type/package.json
@@ -0,0 +1,3 @@
+{
+  "main": "index.js"
+}
diff --git a/test/fixtures/esm-package-scope/legacy-loader/a.js b/test/fixtures/esm-package-scope/legacy-loader/a.js
new file mode 100644
index 0000000000..2e7700bc63
--- /dev/null
+++ b/test/fixtures/esm-package-scope/legacy-loader/a.js
@@ -0,0 +1 @@
+module.exports = 'a';
diff --git a/test/fixtures/esm-package-scope/legacy-loader/b.mjs b/test/fixtures/esm-package-scope/legacy-loader/b.mjs
new file mode 100644
index 0000000000..137b8ce642
--- /dev/null
+++ b/test/fixtures/esm-package-scope/legacy-loader/b.mjs
@@ -0,0 +1 @@
+export const b = 'b';
diff --git a/test/fixtures/esm-package-scope/legacy-loader/c.cjs b/test/fixtures/esm-package-scope/legacy-loader/c.cjs
new file mode 100644
index 0000000000..2d5312952f
--- /dev/null
+++ b/test/fixtures/esm-package-scope/legacy-loader/c.cjs
@@ -0,0 +1,5 @@
+module.exports = {
+  one: 1,
+  two: 2,
+  three: 3
+};
diff --git a/test/fixtures/esm-package-scope/legacy-loader/index.mjs b/test/fixtures/esm-package-scope/legacy-loader/index.mjs
new file mode 100644
index 0000000000..1c78c389a2
--- /dev/null
+++ b/test/fixtures/esm-package-scope/legacy-loader/index.mjs
@@ -0,0 +1,21 @@
+// js file that is common.js
+import a from './a.js';
+// ESM with named export
+import {b} from './b.mjs';
+// import 'c.cjs';
+import cjs from './c.cjs';
+// proves cross boundary fun bits
+import jsAsEsm from '../new-loader/a.js';
+
+// named export from core
+import {strictEqual, deepStrictEqual} from 'assert';
+
+strictEqual(a, jsAsEsm);
+strictEqual(b, 'b');
+deepStrictEqual(cjs, {
+  one: 1,
+  two: 2,
+  three: 3
+});
+
+export default 'legacy-loader';
diff --git a/test/fixtures/esm-package-scope/legacy-loader/package.json b/test/fixtures/esm-package-scope/legacy-loader/package.json
new file mode 100644
index 0000000000..215a962248
--- /dev/null
+++ b/test/fixtures/esm-package-scope/legacy-loader/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "legacy-loader",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Myles Borins <mylesborins@google.com>",
+  "license": "Apache-2.0",
+  "type": "commonjs"
+}
diff --git a/test/fixtures/esm-package-scope/new-loader/a.js b/test/fixtures/esm-package-scope/new-loader/a.js
new file mode 100644
index 0000000000..90bd54cd7f
--- /dev/null
+++ b/test/fixtures/esm-package-scope/new-loader/a.js
@@ -0,0 +1 @@
+export default 'a'
diff --git a/test/fixtures/esm-package-scope/new-loader/b.mjs b/test/fixtures/esm-package-scope/new-loader/b.mjs
new file mode 100644
index 0000000000..137b8ce642
--- /dev/null
+++ b/test/fixtures/esm-package-scope/new-loader/b.mjs
@@ -0,0 +1 @@
+export const b = 'b';
diff --git a/test/fixtures/esm-package-scope/new-loader/c.cjs b/test/fixtures/esm-package-scope/new-loader/c.cjs
new file mode 100644
index 0000000000..2d5312952f
--- /dev/null
+++ b/test/fixtures/esm-package-scope/new-loader/c.cjs
@@ -0,0 +1,5 @@
+module.exports = {
+  one: 1,
+  two: 2,
+  three: 3
+};
diff --git a/test/fixtures/esm-package-scope/new-loader/index.js b/test/fixtures/esm-package-scope/new-loader/index.js
new file mode 100644
index 0000000000..98c536cc34
--- /dev/null
+++ b/test/fixtures/esm-package-scope/new-loader/index.js
@@ -0,0 +1,21 @@
+// ESM with only default
+import a from './a.js';
+// ESM with named export
+import {b} from './b.mjs';
+// import 'c.cjs';
+import cjs from './c.cjs';
+// import across boundaries
+import jsAsCjs from '../legacy-loader/a.js'
+
+// named export from core
+import {strictEqual, deepStrictEqual} from 'assert';
+
+strictEqual(a, jsAsCjs);
+strictEqual(b, 'b');
+deepStrictEqual(cjs, {
+  one: 1,
+  two: 2,
+  three: 3
+});
+
+export default 'new-loader';
diff --git a/test/fixtures/esm-package-scope/new-loader/package.json b/test/fixtures/esm-package-scope/new-loader/package.json
new file mode 100644
index 0000000000..1f2c704322
--- /dev/null
+++ b/test/fixtures/esm-package-scope/new-loader/package.json
@@ -0,0 +1,13 @@
+{
+  "name": "new-loader",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Myles Borins <mylesborins@google.com>",
+  "license": "Apache-2.0",
+  "type": "module"
+}
diff --git a/test/message/esm_display_syntax_error.out b/test/message/esm_display_syntax_error.out
index ed2e928eb1..2700fd894c 100644
--- a/test/message/esm_display_syntax_error.out
+++ b/test/message/esm_display_syntax_error.out
@@ -3,4 +3,4 @@ file:///*/test/message/esm_display_syntax_error.mjs:3
 await async () => 0;
 ^^^^^
 SyntaxError: Unexpected reserved word
-    at translators.set (internal/modules/esm/translators.js:*:*)
+    at Loader.<anonymous> (internal/modules/esm/translators.js:*:*)
diff --git a/test/parallel/test-cli-syntax-piped-bad.js b/test/parallel/test-cli-syntax-piped-bad.js
index 4fb24b24f3..ba93e13038 100644
--- a/test/parallel/test-cli-syntax-piped-bad.js
+++ b/test/parallel/test-cli-syntax-piped-bad.js
@@ -8,24 +8,45 @@ const node = process.execPath;
 
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
-  ['-c'],
-  ['--check']
+  '-c',
+  '--check'
 ];
 
 // Match on the name of the `Error` but not the message as it is different
 // depending on the JavaScript engine.
-const syntaxErrorRE = /^SyntaxError: \b/m;
+const syntaxErrorRE = /^SyntaxError: Unexpected identifier\b/m;
 
 // Should throw if code piped from stdin with --check has bad syntax
 // loop each possible option, `-c` or `--check`
-syntaxArgs.forEach(function(args) {
+syntaxArgs.forEach(function(arg) {
   const stdin = 'var foo bar;';
-  const c = spawnSync(node, args, { encoding: 'utf8', input: stdin });
+  const c = spawnSync(node, [arg], { encoding: 'utf8', input: stdin });
 
   // stderr should include '[stdin]' as the filename
   assert(c.stderr.startsWith('[stdin]'), `${c.stderr} starts with ${stdin}`);
 
-  // No stdout or stderr should be produced
+  // no stdout should be produced
+  assert.strictEqual(c.stdout, '');
+
+  // stderr should have a syntax error message
+  assert(syntaxErrorRE.test(c.stderr), `${syntaxErrorRE} === ${c.stderr}`);
+
+  assert.strictEqual(c.status, 1);
+});
+
+// Check --type=module
+syntaxArgs.forEach(function(arg) {
+  const stdin = 'export var p = 5; var foo bar;';
+  const c = spawnSync(
+    node,
+    ['--experimental-modules', '--type=module', '--no-warnings', arg],
+    { encoding: 'utf8', input: stdin }
+  );
+
+  // stderr should include '[stdin]' as the filename
+  assert(c.stderr.startsWith('[stdin]'), `${c.stderr} starts with ${stdin}`);
+
+  // no stdout should be produced
   assert.strictEqual(c.stdout, '');
 
   // stderr should have a syntax error message
diff --git a/test/parallel/test-cli-syntax-piped-good.js b/test/parallel/test-cli-syntax-piped-good.js
index cdadf449d8..8ee11226d9 100644
--- a/test/parallel/test-cli-syntax-piped-good.js
+++ b/test/parallel/test-cli-syntax-piped-good.js
@@ -8,15 +8,31 @@ const node = process.execPath;
 
 // Test both sets of arguments that check syntax
 const syntaxArgs = [
-  ['-c'],
-  ['--check']
+  '-c',
+  '--check'
 ];
 
 // Should not execute code piped from stdin with --check.
 // Loop each possible option, `-c` or `--check`.
-syntaxArgs.forEach(function(args) {
+syntaxArgs.forEach(function(arg) {
   const stdin = 'throw new Error("should not get run");';
-  const c = spawnSync(node, args, { encoding: 'utf8', input: stdin });
+  const c = spawnSync(node, [arg], { encoding: 'utf8', input: stdin });
+
+  // No stdout or stderr should be produced
+  assert.strictEqual(c.stdout, '');
+  assert.strictEqual(c.stderr, '');
+
+  assert.strictEqual(c.status, 0);
+});
+
+// Check --type=module
+syntaxArgs.forEach(function(arg) {
+  const stdin = 'export var p = 5; throw new Error("should not get run");';
+  const c = spawnSync(
+    node,
+    ['--experimental-modules', '--no-warnings', '--type=module', arg],
+    { encoding: 'utf8', input: stdin }
+  );
 
   // No stdout or stderr should be produced
   assert.strictEqual(c.stdout, '');