diff --git a/doc/api/cli.md b/doc/api/cli.md
index 11f1e4cb3cde36..412cf187d340fb 100644
--- a/doc/api/cli.md
+++ b/doc/api/cli.md
@@ -25,16 +25,14 @@ For more info about `node inspect`, see the [debugger][] documentation.
 
 The program entry point is a specifier-like string. If the string is not an
 absolute path, it's resolved as a relative path from the current working
-directory. That path is then resolved by [CommonJS][] module loader, or by the
-[ES module loader][Modules loaders] if [`--experimental-default-type=module`][]
-is passed. If no corresponding file is found, an error is thrown.
+directory. That path is then resolved by [CommonJS][] module loader. If no
+corresponding file is found, an error is thrown.
 
 If a file is found, its path will be passed to the
 [ES module loader][Modules loaders] under any of the following conditions:
 
 * The program was started with a command-line flag that forces the entry
-  point to be loaded with ECMAScript module loader, such as `--import` or
-  [`--experimental-default-type=module`][].
+  point to be loaded with ECMAScript module loader, such as `--import`.
 * The file has an `.mjs` extension.
 * The file does not have a `.cjs` extension, and the nearest parent
   `package.json` file contains a top-level [`"type"`][] field with a value of
@@ -47,9 +45,8 @@ Otherwise, the file is loaded using the CommonJS module loader. See
 
 When loading, the [ES module loader][Modules loaders] loads the program
 entry point, the `node` command will accept as input only files with `.js`,
-`.mjs`, or `.cjs` extensions; with `.wasm` extensions when
-[`--experimental-wasm-modules`][] is enabled; and with no extension when
-[`--experimental-default-type=module`][] is passed.
+`.mjs`, or `.cjs` extensions; and with `.wasm` extensions when
+[`--experimental-wasm-modules`][] is enabled.
 
 ## Options
 
@@ -910,38 +907,6 @@ flows within the application. As such, it is presently recommended to be sure
 your application behaviour is unaffected by this change before using it in
 production.
 
-### `--experimental-default-type=type`
-
-<!-- YAML
-added:
-  - v21.0.0
-  - v20.10.0
-  - v18.19.0
--->
-
-> Stability: 1.0 - Early development
-
-Define which module system, `module` or `commonjs`, to use for the following:
-
-* String input provided via `--eval` or STDIN, if `--input-type` is unspecified.
-
-* Files ending in `.js` or with no extension, if there is no `package.json` file
-  present in the same folder or any parent folder.
-
-* Files ending in `.js` or with no extension, if the nearest parent
-  `package.json` field lacks a `"type"` field; unless the `package.json` folder
-  or any parent folder is inside a `node_modules` folder.
-
-In other words, `--experimental-default-type=module` flips all the places where
-Node.js currently defaults to CommonJS to instead default to ECMAScript modules,
-with the exception of folders and subfolders below `node_modules`, for backward
-compatibility.
-
-Under `--experimental-default-type=module` and `--experimental-wasm-modules`,
-files with no extension will be treated as WebAssembly if they begin with the
-WebAssembly magic number (`\0asm`); otherwise they will be treated as ES module
-JavaScript.
-
 ### `--experimental-transform-types`
 
 <!-- YAML
@@ -1418,7 +1383,7 @@ added: v12.0.0
 
 This configures Node.js to interpret `--eval` or `STDIN` input as CommonJS or
 as an ES module. Valid values are `"commonjs"` or `"module"`. The default is
-`"commonjs"` unless [`--experimental-default-type=module`][] is used.
+`"commonjs"`.
 
 The REPL does not support this option. Usage of `--input-type=module` with
 [`--print`][] will throw an error, as `--print` does not support ES module
@@ -3059,7 +3024,6 @@ one is included in the list below.
 * `--entry-url`
 * `--experimental-abortcontroller`
 * `--experimental-async-context-frame`
-* `--experimental-default-type`
 * `--experimental-detect-module`
 * `--experimental-eventsource`
 * `--experimental-import-meta-resolve`
@@ -3621,7 +3585,6 @@ node --stack-trace-limit=12 -p -e "Error.stackTraceLimit" # prints 12
 [`--diagnostic-dir`]: #--diagnostic-dirdirectory
 [`--env-file-if-exists`]: #--env-file-if-existsconfig
 [`--env-file`]: #--env-fileconfig
-[`--experimental-default-type=module`]: #--experimental-default-typetype
 [`--experimental-sea-config`]: single-executable-applications.md#generating-single-executable-preparation-blobs
 [`--experimental-strip-types`]: #--experimental-strip-types
 [`--experimental-wasm-modules`]: #--experimental-wasm-modules
diff --git a/doc/api/esm.md b/doc/api/esm.md
index 8a80e0b1fe7202..ecb27680129737 100644
--- a/doc/api/esm.md
+++ b/doc/api/esm.md
@@ -122,14 +122,13 @@ Node.js has two module systems: [CommonJS][] modules and ECMAScript modules.
 
 Authors can tell Node.js to interpret JavaScript as an ES module via the `.mjs`
 file extension, the `package.json` [`"type"`][] field with a value `"module"`,
-the [`--input-type`][] flag with a value of `"module"`, or the
-[`--experimental-default-type`][] flag with a value of `"module"`. These are
-explicit markers of code being intended to run as an ES module.
+or the [`--input-type`][] flag with a value of `"module"`. These are explicit
+markers of code being intended to run as an ES module.
 
-Inversely, authors can tell Node.js to interpret JavaScript as CommonJS via the
-`.cjs` file extension, the `package.json` [`"type"`][] field with a value
-`"commonjs"`, the [`--input-type`][] flag with a value of `"commonjs"`, or the
-[`--experimental-default-type`][] flag with a value of `"commonjs"`.
+Inversely, authors can explicitly tell Node.js to interpret JavaScript as
+CommonJS via the `.cjs` file extension, the `package.json` [`"type"`][] field
+with a value `"commonjs"`, or the [`--input-type`][] flag with a value of
+`"commonjs"`.
 
 When code lacks explicit markers for either module system, Node.js will inspect
 the source code of a module to look for ES module syntax. If such syntax is
@@ -1120,7 +1119,6 @@ resolution for ESM specifiers is [commonjs-extension-resolution-loader][].
 [URL]: https://url.spec.whatwg.org/
 [`"exports"`]: packages.md#exports
 [`"type"`]: packages.md#type
-[`--experimental-default-type`]: cli.md#--experimental-default-typetype
 [`--input-type`]: cli.md#--input-typetype
 [`data:` URLs]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Basics_of_HTTP/Data_URIs
 [`export`]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/export
diff --git a/doc/api/module.md b/doc/api/module.md
index d5d3187439c0c0..19346182bf42d7 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -980,8 +980,7 @@ Omitting vs providing a `source` for `'commonjs'` has very different effects:
   registered hooks. This behavior for nullish `source` is temporary — in the
   future, nullish `source` will not be supported.
 
-When `node` is run with `--experimental-default-type=commonjs`, the Node.js
-internal `load` implementation, which is the value of `next` for the
+The Node.js internal `load` implementation, which is the value of `next` for the
 last hook in the `load` chain, returns `null` for `source` when `format` is
 `'commonjs'` for backward compatibility. Here is an example hook that would
 opt-in to using the non-default behavior:
diff --git a/doc/api/packages.md b/doc/api/packages.md
index 72494bf90d4b40..ab18fe4e1fd34b 100644
--- a/doc/api/packages.md
+++ b/doc/api/packages.md
@@ -73,10 +73,9 @@ expressions:
   `import` or `export` statements or `import.meta`, with no explicit marker of
   how it should be interpreted. Explicit markers are `.mjs` or `.cjs`
   extensions, `package.json` `"type"` fields with either `"module"` or
-  `"commonjs"` values, or `--input-type` or `--experimental-default-type` flags.
-  Dynamic `import()` expressions are supported in either CommonJS or ES modules
-  and would not force a file to be treated as an ES module. See
-  [Syntax detection][].
+  `"commonjs"` values, or the `--input-type` flag. Dynamic `import()`
+  expressions are supported in either CommonJS or ES modules and would not force
+  a file to be treated as an ES module. See [Syntax detection][].
 
 Node.js will treat the following as [CommonJS][] when passed to `node` as the
 initial input, or when referenced by `import` statements or `import()`
@@ -90,30 +89,21 @@ expressions:
 * Strings passed in as an argument to `--eval` or `--print`, or piped to `node`
   via `STDIN`, with the flag `--input-type=commonjs`.
 
-Aside from these explicit cases, there are other cases where Node.js defaults to
-one module system or the other based on the value of the
-[`--experimental-default-type`][] flag:
-
-* Files ending in `.js` or with no extension, if there is no `package.json` file
-  present in the same folder or any parent folder.
-
-* Files ending in `.js` or with no extension, if the nearest parent
-  `package.json` field lacks a `"type"` field; unless the folder is inside a
-  `node_modules` folder. (Package scopes under `node_modules` are always treated
-  as CommonJS when the `package.json` file lacks a `"type"` field, regardless
-  of `--experimental-default-type`, for backward compatibility.)
-
-* Strings passed in as an argument to `--eval` or piped to `node` via `STDIN`,
-  when `--input-type` is unspecified.
-
-This flag currently defaults to `"commonjs"`, but it may change in the future to
-default to `"module"`. For this reason it is best to be explicit wherever
-possible; in particular, package authors should always include the [`"type"`][]
-field in their `package.json` files, even in packages where all sources are
-CommonJS. Being explicit about the `type` of the package will future-proof the
-package in case the default type of Node.js ever changes, and it will also make
-things easier for build tools and loaders to determine how the files in the
-package should be interpreted.
+* Files with a `.js` extension with no parent `package.json` file or where the
+  nearest parent `package.json` file lacks a `type` field, and where the code
+  can evaluate successfully as CommonJS. In other words, Node.js tries to run
+  such "ambiguous" files as CommonJS first, and will retry evaluating them as ES
+  modules if the evaluation as CommonJS fails because the parser found ES module
+  syntax.
+
+Writing ES module syntax in "ambiguous" files incurs a performance cost, and
+therefore it is encouraged that authors be explicit wherever possible. In
+particular, package authors should always include the [`"type"`][] field in
+their `package.json` files, even in packages where all sources are CommonJS.
+Being explicit about the `type` of the package will future-proof the package in
+case the default type of Node.js ever changes, and it will also make things
+easier for build tools and loaders to determine how the files in the package
+should be interpreted.
 
 ### Syntax detection
 
@@ -137,10 +127,8 @@ as an ES module.
 Ambiguous input is defined as:
 
 * Files with a `.js` extension or no extension; and either no controlling
-  `package.json` file or one that lacks a `type` field; and
-  `--experimental-default-type` is not specified.
-* String input (`--eval` or STDIN) when neither `--input-type` nor
-  `--experimental-default-type` are specified.
+  `package.json` file or one that lacks a `type` field.
+* String input (`--eval` or `STDIN`) when `--input-type`is not specified.
 
 ES module syntax is defined as syntax that would throw when evaluated as
 CommonJS. This includes the following:
@@ -1162,7 +1150,6 @@ This field defines [subpath imports][] for the current package.
 [`"packageManager"`]: #packagemanager
 [`"type"`]: #type
 [`--conditions` / `-C` flag]: #resolving-user-conditions
-[`--experimental-default-type`]: cli.md#--experimental-default-typetype
 [`--no-addons` flag]: cli.md#--no-addons
 [`ERR_PACKAGE_PATH_NOT_EXPORTED`]: errors.md#err_package_path_not_exported
 [`package.json`]: #nodejs-packagejson-field-definitions
diff --git a/doc/node.1 b/doc/node.1
index ac55410f500b41..e38ce7f0431e62 100644
--- a/doc/node.1
+++ b/doc/node.1
@@ -163,11 +163,6 @@ Enable Source Map V3 support for stack traces.
 .It Fl -entry-url
 Interpret the entry point as a URL.
 .
-.It Fl -experimental-default-type Ns = Ns Ar type
-Interpret as either ES modules or CommonJS modules input via --eval or STDIN, when --input-type is unspecified;
-.js or extensionless files with no sibling or parent package.json;
-.js or extensionless files whose nearest parent package.json lacks a "type" field, unless under node_modules.
-.
 .It Fl -experimental-import-meta-resolve
 Enable experimental ES modules support for import.meta.resolve().
 .
diff --git a/lib/internal/main/check_syntax.js b/lib/internal/main/check_syntax.js
index aa521dea92e314..16e367c4e089f6 100644
--- a/lib/internal/main/check_syntax.js
+++ b/lib/internal/main/check_syntax.js
@@ -59,9 +59,7 @@ function loadESMIfNeeded(cb) {
 async function checkSyntax(source, filename) {
   let format;
   if (filename === '[stdin]' || filename === '[eval]') {
-    format = (getOptionValue('--input-type') === 'module' ||
-      (getOptionValue('--experimental-default-type') === 'module' && getOptionValue('--input-type') !== 'commonjs')) ?
-      'module' : 'commonjs';
+    format = (getOptionValue('--input-type') === 'module') ? 'module' : 'commonjs';
   } else {
     const { defaultResolve } = require('internal/modules/esm/resolve');
     const { defaultGetFormat } = require('internal/modules/esm/get_format');
diff --git a/lib/internal/main/eval_stdin.js b/lib/internal/main/eval_stdin.js
index 3ee4bcdb1d853b..2fd685dd6afcfa 100644
--- a/lib/internal/main/eval_stdin.js
+++ b/lib/internal/main/eval_stdin.js
@@ -25,8 +25,7 @@ readStdin((code) => {
 
   const print = getOptionValue('--print');
   const shouldLoadESM = getOptionValue('--import').length > 0;
-  if (getOptionValue('--input-type') === 'module' ||
-    (getOptionValue('--experimental-default-type') === 'module' && getOptionValue('--input-type') !== 'commonjs')) {
+  if (getOptionValue('--input-type') === 'module') {
     evalModuleEntryPoint(code, print);
   } else {
     evalScript('[stdin]',
diff --git a/lib/internal/main/eval_string.js b/lib/internal/main/eval_string.js
index 8027bc7e09b269..6518c93430a28e 100644
--- a/lib/internal/main/eval_string.js
+++ b/lib/internal/main/eval_string.js
@@ -29,8 +29,7 @@ const source = getOptionValue('--experimental-strip-types') ?
 
 const print = getOptionValue('--print');
 const shouldLoadESM = getOptionValue('--import').length > 0 || getOptionValue('--experimental-loader').length > 0;
-if (getOptionValue('--input-type') === 'module' ||
-  (getOptionValue('--experimental-default-type') === 'module' && getOptionValue('--input-type') !== 'commonjs')) {
+if (getOptionValue('--input-type') === 'module') {
   evalModuleEntryPoint(source, print);
 } else {
   // For backward compatibility, we want the identifier crypto to be the
diff --git a/lib/internal/main/run_main_module.js b/lib/internal/main/run_main_module.js
index 9b79410bdad88d..0089a62c61592d 100644
--- a/lib/internal/main/run_main_module.js
+++ b/lib/internal/main/run_main_module.js
@@ -23,15 +23,11 @@ if (isEntryURL) {
   emitExperimentalWarning('--entry-url');
 }
 
-if (getOptionValue('--experimental-default-type') === 'module') {
-  require('internal/modules/run_main').executeUserEntryPoint(mainEntry);
-} else {
-  /**
-   * To support legacy monkey-patching of `Module.runMain`, we call `runMain` here to have the CommonJS loader begin
-   * the execution of the main entry point, even if the ESM loader immediately takes over because the main entry is an
-   * ES module or one of the other opt-in conditions (such as the use of `--import`) are met. Users can monkey-patch
-   * before the main entry point is loaded by doing so via scripts loaded through `--require`. This monkey-patchability
-   * is undesirable and is removed in `--experimental-default-type=module` mode.
-   */
-  require('internal/modules/cjs/loader').Module.runMain(mainEntry);
-}
+/**
+ * To support legacy monkey-patching of `Module.runMain`, we call `runMain` here to have the CommonJS loader begin the
+ * execution of the main entry point, even if the ESM loader immediately takes over because the main entry is an ES
+ * module or one of the other opt-in conditions (such as the use of `--import`) are met. Users can monkey-patch before
+ * the main entry point is loaded by doing so via scripts loaded through `--require`. This monkey-patchability is
+ * undesirable and should be removed once the module customization hooks provide equivalent functionality.
+ */
+require('internal/modules/cjs/loader').Module.runMain(mainEntry);
diff --git a/lib/internal/modules/esm/formats.js b/lib/internal/modules/esm/formats.js
index 608b69caf3fe49..1ae4491b6fd2f6 100644
--- a/lib/internal/modules/esm/formats.js
+++ b/lib/internal/modules/esm/formats.js
@@ -46,8 +46,8 @@ function mimeToFormat(mime) {
 }
 
 /**
- * For extensionless files in a `module` package scope, or a default `module` scope enabled by the
- * `--experimental-default-type` flag, we check the file contents to disambiguate between ES module JavaScript and Wasm.
+ * For extensionless files in a `module` package scope, we check the file contents to disambiguate between ES module
+ * JavaScript and Wasm.
  * We do this by taking advantage of the fact that all Wasm files start with the header `0x00 0x61 0x73 0x6d` (`_asm`).
  * @param {URL} url
  */
diff --git a/lib/internal/modules/esm/get_format.js b/lib/internal/modules/esm/get_format.js
index 9519f947b8dfdc..9fc5e67969abcf 100644
--- a/lib/internal/modules/esm/get_format.js
+++ b/lib/internal/modules/esm/get_format.js
@@ -119,29 +119,16 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
     }
 
     // The controlling `package.json` file has no `type` field.
-    switch (getOptionValue('--experimental-default-type')) {
-      case 'module': { // The user explicitly passed `--experimental-default-type=module`.
-        // An exception to the type flag making ESM the default everywhere is that package scopes under `node_modules`
-        // should retain the assumption that a lack of a `type` field means CommonJS.
-        return underNodeModules(url) ? 'commonjs' : 'module';
-      }
-      case 'commonjs': { // The user explicitly passed `--experimental-default-type=commonjs`.
-        return 'commonjs';
-      }
-      default: { // The user did not pass `--experimental-default-type`.
-        // `source` is undefined when this is called from `defaultResolve`;
-        // but this gets called again from `defaultLoad`/`defaultLoadSync`.
-        // For ambiguous files (no type field, .js extension) we return
-        // undefined from `resolve` and re-run the check in `load`.
-        const format = detectModuleFormat(source, url);
-        if (format === 'module' && foundPackageJson) {
-          // This module has a .js extension, a package.json with no `type` field, and ESM syntax.
-          // Warn about the missing `type` field so that the user can avoid the performance penalty of detection.
-          warnTypelessPackageJsonFile(pjsonPath, url);
-        }
-        return format;
-      }
+    // `source` is undefined when this is called from `defaultResolve`;
+    // but this gets called again from `defaultLoad`/`defaultLoadSync`.
+    // For ambiguous files (.js, no type field) we return undefined from `resolve` and re-run the check in `load`.
+    const format = detectModuleFormat(source, url);
+    if (format === 'module' && foundPackageJson) {
+      // This module has a .js extension, a package.json with no `type` field, and ESM syntax.
+      // Warn about the missing `type` field so that the user can avoid the performance penalty of detection.
+      warnTypelessPackageJsonFile(pjsonPath, url);
     }
+    return format;
   }
   if (ext === '.ts' && getOptionValue('--experimental-strip-types')) {
     const { type: packageType, pjsonPath, exists: foundPackageJson } = getPackageScopeConfig(url);
@@ -149,35 +136,22 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
       return `${packageType}-typescript`;
     }
     // The controlling `package.json` file has no `type` field.
-    switch (getOptionValue('--experimental-default-type')) {
-      case 'module': { // The user explicitly passed `--experimental-default-type=module`.
-        // An exception to the type flag making ESM the default everywhere is that package scopes under `node_modules`
-        // should retain the assumption that a lack of a `type` field means CommonJS.
-        return underNodeModules(url) ? 'commonjs-typescript' : 'module-typescript';
-      }
-      case 'commonjs': { // The user explicitly passed `--experimental-default-type=commonjs`.
-        return 'commonjs-typescript';
-      }
-      default: { // The user did not pass `--experimental-default-type`.
-        // `source` is undefined when this is called from `defaultResolve`;
-        // but this gets called again from `defaultLoad`/`defaultLoadSync`.
-        // Since experimental-strip-types depends on detect-module, we always return null
-        // if source is undefined.
-        if (!source) { return null; }
-        const { stringify } = require('internal/modules/helpers');
-        const { stripTypeScriptModuleTypes } = require('internal/modules/typescript');
-        const stringifiedSource = stringify(source);
-        const parsedSource = stripTypeScriptModuleTypes(stringifiedSource, fileURLToPath(url));
-        const detectedFormat = detectModuleFormat(parsedSource, url);
-        const format = `${detectedFormat}-typescript`;
-        if (format === 'module-typescript' && foundPackageJson) {
-          // This module has a .js extension, a package.json with no `type` field, and ESM syntax.
-          // Warn about the missing `type` field so that the user can avoid the performance penalty of detection.
-          warnTypelessPackageJsonFile(pjsonPath, url);
-        }
-        return format;
-      }
+    // `source` is undefined when this is called from `defaultResolve`;
+    // but this gets called again from `defaultLoad`/`defaultLoadSync`.
+    // Since experimental-strip-types depends on detect-module, we always return null if source is undefined.
+    if (!source) { return null; }
+    const { stringify } = require('internal/modules/helpers');
+    const { stripTypeScriptModuleTypes } = require('internal/modules/typescript');
+    const stringifiedSource = stringify(source);
+    const parsedSource = stripTypeScriptModuleTypes(stringifiedSource, fileURLToPath(url));
+    const detectedFormat = detectModuleFormat(parsedSource, url);
+    const format = `${detectedFormat}-typescript`;
+    if (format === 'module-typescript' && foundPackageJson) {
+      // This module has a .js extension, a package.json with no `type` field, and ESM syntax.
+      // Warn about the missing `type` field so that the user can avoid the performance penalty of detection.
+      warnTypelessPackageJsonFile(pjsonPath, url);
     }
+    return format;
   }
 
   if (ext === '') {
@@ -190,24 +164,14 @@ function getFileProtocolModuleFormat(url, context = { __proto__: null }, ignoreE
     }
 
     // The controlling `package.json` file has no `type` field.
-    switch (getOptionValue('--experimental-default-type')) {
-      case 'module': { // The user explicitly passed `--experimental-default-type=module`.
-        return underNodeModules(url) ? 'commonjs' : getFormatOfExtensionlessFile(url);
-      }
-      case 'commonjs': { // The user explicitly passed `--experimental-default-type=commonjs`.
-        return 'commonjs';
-      }
-      default: { // The user did not pass `--experimental-default-type`.
-        if (!source) {
-          return null;
-        }
-        const format = getFormatOfExtensionlessFile(url);
-        if (format === 'wasm') {
-          return format;
-        }
-        return detectModuleFormat(source, url);
-      }
+    if (!source) {
+      return null;
     }
+    const format = getFormatOfExtensionlessFile(url);
+    if (format === 'wasm') {
+      return format;
+    }
+    return detectModuleFormat(source, url);
   }
 
   const format = extensionFormatMap[ext];
diff --git a/lib/internal/modules/esm/load.js b/lib/internal/modules/esm/load.js
index 5ba13096b98047..9e0a2c6ab6ee13 100644
--- a/lib/internal/modules/esm/load.js
+++ b/lib/internal/modules/esm/load.js
@@ -9,12 +9,8 @@ const {
 
 const { defaultGetFormat } = require('internal/modules/esm/get_format');
 const { validateAttributes, emitImportAssertionWarning } = require('internal/modules/esm/assert');
-const { getOptionValue } = require('internal/options');
 const { readFileSync } = require('fs');
 
-const defaultType =
-  getOptionValue('--experimental-default-type');
-
 const { Buffer: { from: BufferFrom } } = require('buffer');
 
 const { URL } = require('internal/url');
@@ -109,7 +105,7 @@ async function defaultLoad(url, context = kEmptyObject) {
   if (urlInstance.protocol === 'node:') {
     source = null;
     format ??= 'builtin';
-  } else if (format !== 'commonjs' || defaultType === 'module') {
+  } else if (format !== 'commonjs') {
     if (source == null) {
       ({ responseURL, source } = await getSource(urlInstance, context));
       context = { __proto__: context, source };
diff --git a/lib/internal/modules/run_main.js b/lib/internal/modules/run_main.js
index ab4783a7982b9f..9c90f0f6d3e33b 100644
--- a/lib/internal/modules/run_main.js
+++ b/lib/internal/modules/run_main.js
@@ -26,32 +26,18 @@ const {
  * @param {string} main - Entry point path
  */
 function resolveMainPath(main) {
-  const defaultType = getOptionValue('--experimental-default-type');
   /** @type {string} */
   let mainPath;
-  if (defaultType === 'module') {
-    if (getOptionValue('--preserve-symlinks-main')) { return; }
-    mainPath = path.resolve(main);
-  } else {
-    // Extension searching for the main entry point is supported only in legacy mode.
-    // Module._findPath is monkey-patchable here.
-    const { Module } = require('internal/modules/cjs/loader');
-    mainPath = Module._findPath(path.resolve(main), null, true);
-  }
+  // Extension searching for the main entry point is supported for backward compatibility.
+  // Module._findPath is monkey-patchable here.
+  const { Module } = require('internal/modules/cjs/loader');
+  mainPath = Module._findPath(path.resolve(main), null, true);
   if (!mainPath) { return; }
 
   const preserveSymlinksMain = getOptionValue('--preserve-symlinks-main');
   if (!preserveSymlinksMain) {
     const { toRealPath } = require('internal/modules/helpers');
-    try {
-      mainPath = toRealPath(mainPath);
-    } catch (err) {
-      if (defaultType === 'module' && err?.code === 'ENOENT') {
-        const { decorateErrorWithCommonJSHints } = require('internal/modules/esm/resolve');
-        decorateErrorWithCommonJSHints(err, mainPath, getCWDURL());
-      }
-      throw err;
-    }
+    mainPath = toRealPath(mainPath);
   }
 
   return mainPath;
@@ -62,8 +48,6 @@ function resolveMainPath(main) {
  * @param {string} mainPath - Absolute path to the main entry point
  */
 function shouldUseESMLoader(mainPath) {
-  if (getOptionValue('--experimental-default-type') === 'module') { return true; }
-
   /**
    * @type {string[]} userLoaders A list of custom loaders registered by the user
    * (or an empty list when none have been registered).
@@ -81,8 +65,6 @@ function shouldUseESMLoader(mainPath) {
   if (!mainPath || StringPrototypeEndsWith(mainPath, '.cjs')) { return false; }
 
   if (getOptionValue('--experimental-strip-types')) {
-    // This ensures that --experimental-default-type=commonjs and .mts files are treated as commonjs
-    if (getOptionValue('--experimental-default-type') === 'commonjs') { return false; }
     if (!mainPath || StringPrototypeEndsWith(mainPath, '.cts')) { return false; }
     // This will likely change in the future to start with commonjs loader by default
     if (mainPath && StringPrototypeEndsWith(mainPath, '.mts')) { return true; }
@@ -147,7 +129,6 @@ function runEntryPointWithESMLoader(callback) {
  * Parse the CLI main entry point string and run it.
  * For backwards compatibility, we have to run a bunch of monkey-patchable code that belongs to the CJS loader (exposed
  * by `require('module')`) even when the entry point is ESM.
- * This monkey-patchable code is bypassed under `--experimental-default-type=module`.
  * Because of backwards compatibility, this function is exposed publicly via `import { runMain } from 'node:module'`.
  * Because of module detection, this function will attempt to run ambiguous (no explicit extension, no
  * `package.json` type field) entry points as CommonJS first; under certain conditions, it will retry running as ESM.
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index 68b267b61c39b1..a5afd44ca9ca06 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -82,7 +82,7 @@ function evalScript(name, body, breakFirstLine, print, shouldLoadESM = false) {
   const baseUrl = pathToFileURL(module.filename).href;
 
   if (getOptionValue('--experimental-detect-module') &&
-    getOptionValue('--input-type') === '' && getOptionValue('--experimental-default-type') === '' &&
+    getOptionValue('--input-type') === '' &&
     containsModuleSyntax(body, name, null, 'no CJS variables')) {
     return evalModuleEntryPoint(body, print);
   }
diff --git a/src/node_options.cc b/src/node_options.cc
index b2be0e2c7a380f..8d39925ff524c8 100644
--- a/src/node_options.cc
+++ b/src/node_options.cc
@@ -113,13 +113,6 @@ void EnvironmentOptions::CheckOptions(std::vector<std::string>* errors,
     }
   }
 
-  if (!type.empty()) {
-    if (type != "commonjs" && type != "module") {
-      errors->push_back("--experimental-default-type must be "
-                        "\"module\" or \"commonjs\"");
-    }
-  }
-
   if (syntax_check_only && has_eval_string) {
     errors->push_back("either --check or --eval can be used, not both");
   }
@@ -777,10 +770,6 @@ EnvironmentOptionsParser::EnvironmentOptionsParser() {
       &EnvironmentOptions::trace_env_native_stack,
       kAllowedInEnvvar);
 
-  AddOption("--experimental-default-type",
-            "set module system to use by default",
-            &EnvironmentOptions::type,
-            kAllowedInEnvvar);
   AddOption("--extra-info-on-fatal-exception",
             "hide extra information on fatal exception that causes exit",
             &EnvironmentOptions::extra_info_on_fatal_exception,
diff --git a/src/node_options.h b/src/node_options.h
index 8cce0ec019254d..1b0adf32595fd3 100644
--- a/src/node_options.h
+++ b/src/node_options.h
@@ -131,7 +131,6 @@ class EnvironmentOptions : public Options {
   bool experimental_wasm_modules = false;
   bool experimental_import_meta_resolve = false;
   std::string input_type;  // Value of --input-type
-  std::string type;        // Value of --experimental-default-type
   bool entry_is_url = false;
   bool experimental_permission = false;
   std::vector<std::string> allow_fs_read;
diff --git a/test/es-module/test-esm-detect-ambiguous.mjs b/test/es-module/test-esm-detect-ambiguous.mjs
index 8da2fea8022a63..8b630b8cff6314 100644
--- a/test/es-module/test-esm-detect-ambiguous.mjs
+++ b/test/es-module/test-esm-detect-ambiguous.mjs
@@ -52,19 +52,6 @@ describe('Module syntax detection', { concurrency: !process.env.TEST_PARALLEL },
       strictEqual(signal, null);
     });
 
-    it('should be overridden by --experimental-default-type', async () => {
-      const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-        '--experimental-default-type=commonjs',
-        '--eval',
-        'import.meta.url',
-      ]);
-
-      match(stderr, /SyntaxError: Cannot use 'import\.meta' outside a module/);
-      strictEqual(stdout, '');
-      strictEqual(code, 1);
-      strictEqual(signal, null);
-    });
-
     it('does not trigger detection via source code `eval()`', async () => {
       const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
         '--eval',
diff --git a/test/es-module/test-esm-extensionless-esm-and-wasm.mjs b/test/es-module/test-esm-extensionless-esm-and-wasm.mjs
index 17786b61291ab6..41fda57cfa4e30 100644
--- a/test/es-module/test-esm-extensionless-esm-and-wasm.mjs
+++ b/test/es-module/test-esm-extensionless-esm-and-wasm.mjs
@@ -77,7 +77,6 @@ describe('extensionless ES modules within no package scope', { concurrency: !pro
 });
 
 describe('extensionless Wasm within no package scope', { concurrency: !process.env.TEST_PARALLEL }, () => {
-  // This succeeds with `--experimental-default-type=module`
   it('should error as the entry point', async () => {
     const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
       '--experimental-wasm-modules',
diff --git a/test/es-module/test-esm-type-flag-cli-entry.mjs b/test/es-module/test-esm-type-flag-cli-entry.mjs
deleted file mode 100644
index 673a5f2da15ae0..00000000000000
--- a/test/es-module/test-esm-type-flag-cli-entry.mjs
+++ /dev/null
@@ -1,96 +0,0 @@
-import { spawnPromisified } from '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
-import { describe, it } from 'node:test';
-import { match, strictEqual } from 'node:assert';
-
-describe('--experimental-default-type=module should not support extension searching', {
-  concurrency: !process.env.TEST_PARALLEL,
-}, () => {
-  it('should support extension searching under --experimental-default-type=commonjs', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=commonjs',
-      'index',
-    ], {
-      cwd: fixtures.path('es-modules/package-without-type'),
-    });
-
-    strictEqual(stdout, 'package-without-type\n');
-    strictEqual(stderr, '');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it('should error with implicit extension under --experimental-default-type=module', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      'index',
-    ], {
-      cwd: fixtures.path('es-modules/package-without-type'),
-    });
-
-    match(stderr, /ENOENT.*Did you mean to import .*index\.js"\?/s);
-    strictEqual(stdout, '');
-    strictEqual(code, 1);
-    strictEqual(signal, null);
-  });
-});
-
-describe('--experimental-default-type=module should not parse paths as URLs', {
-  concurrency: !process.env.TEST_PARALLEL,
-}, () => {
-  it('should not parse a `?` in a filename as starting a query string', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      'file#1.js',
-    ], {
-      cwd: fixtures.path('es-modules/package-without-type'),
-    });
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, 'file#1\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it('should resolve `..`', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '../package-without-type/file#1.js',
-    ], {
-      cwd: fixtures.path('es-modules/package-without-type'),
-    });
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, 'file#1\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it('should allow a leading `./`', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      './file#1.js',
-    ], {
-      cwd: fixtures.path('es-modules/package-without-type'),
-    });
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, 'file#1\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it('should not require a leading `./`', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      'file#1.js',
-    ], {
-      cwd: fixtures.path('es-modules/package-without-type'),
-    });
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, 'file#1\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-});
diff --git a/test/es-module/test-esm-type-flag-errors.mjs b/test/es-module/test-esm-type-flag-errors.mjs
deleted file mode 100644
index 2f7a1db35d2423..00000000000000
--- a/test/es-module/test-esm-type-flag-errors.mjs
+++ /dev/null
@@ -1,103 +0,0 @@
-import { spawnPromisified } from '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
-import { describe, it } from 'node:test';
-import { deepStrictEqual, match, strictEqual } from 'node:assert';
-
-describe('--experimental-default-type=module', { concurrency: !process.env.TEST_PARALLEL }, () => {
-  describe('should not affect the interpretation of files with unknown extensions', {
-    concurrency: !process.env.TEST_PARALLEL,
-  }, () => {
-    it('should error on an entry point with an unknown extension', async () => {
-      const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-        '--experimental-default-type=module',
-        fixtures.path('es-modules/package-type-module/extension.unknown'),
-      ]);
-
-      match(stderr, /ERR_UNKNOWN_FILE_EXTENSION/);
-      strictEqual(stdout, '');
-      strictEqual(code, 1);
-      strictEqual(signal, null);
-    });
-
-    it('should error on an import with an unknown extension', async () => {
-      const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-        '--experimental-default-type=module',
-        fixtures.path('es-modules/package-type-module/imports-unknownext.mjs'),
-      ]);
-
-      match(stderr, /ERR_UNKNOWN_FILE_EXTENSION/);
-      strictEqual(stdout, '');
-      strictEqual(code, 1);
-      strictEqual(signal, null);
-    });
-  });
-
-  it('should affect CJS .js files (imported, required, entry points)', async () => {
-    const result = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      fixtures.path('es-modules/package-type-commonjs/echo-require-cache.js'),
-    ]);
-
-    deepStrictEqual(result, {
-      code: 0,
-      stderr: '',
-      stdout: 'undefined\n',
-      signal: null,
-    });
-  });
-
-  it('should affect .cjs files that are imported', async () => {
-    const result = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '-e',
-      `import ${JSON.stringify(fixtures.fileURL('es-module-require-cache/echo.cjs'))}`,
-    ]);
-
-    deepStrictEqual(result, {
-      code: 0,
-      stderr: '',
-      stdout: 'undefined\n',
-      signal: null,
-    });
-  });
-
-  it('should affect entry point .cjs files (with no hooks)', async () => {
-    const { stderr, stdout, code } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      fixtures.path('es-module-require-cache/echo.cjs'),
-    ]);
-
-    strictEqual(stderr, '');
-    match(stdout, /^undefined\n$/);
-    strictEqual(code, 0);
-  });
-
-  it('should affect entry point .cjs files (when any hooks is registered)', async () => {
-    const result = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '--import',
-      'data:text/javascript,import{register}from"node:module";register("data:text/javascript,");',
-      fixtures.path('es-module-require-cache/echo.cjs'),
-    ]);
-
-    deepStrictEqual(result, {
-      code: 0,
-      stderr: '',
-      stdout: 'undefined\n',
-      signal: null,
-    });
-  });
-
-  it('should not affect CJS from input-type', async () => {
-    const { stderr, stdout, code } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '--input-type=commonjs',
-      '-p',
-      'require.cache',
-    ]);
-
-    strictEqual(stderr, '');
-    match(stdout, /^\[Object: null prototype\] \{\}\n$/);
-    strictEqual(code, 0);
-  });
-});
diff --git a/test/es-module/test-esm-type-flag-loose-files.mjs b/test/es-module/test-esm-type-flag-loose-files.mjs
deleted file mode 100644
index afa306099d5e6a..00000000000000
--- a/test/es-module/test-esm-type-flag-loose-files.mjs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Flags: --experimental-default-type=module --experimental-wasm-modules
-import { spawnPromisified } from '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
-import { describe, it } from 'node:test';
-import { strictEqual } from 'node:assert';
-
-describe('the type flag should change the interpretation of certain files outside of any package scope',
-         { concurrency: !process.env.TEST_PARALLEL }, () => {
-           it('should run as ESM a .js file that is outside of any package scope', async () => {
-             const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-               '--experimental-default-type=module',
-               fixtures.path('es-modules/loose.js'),
-             ]);
-
-             strictEqual(stderr, '');
-             strictEqual(stdout, 'executed\n');
-             strictEqual(code, 0);
-             strictEqual(signal, null);
-           });
-
-           it('should run as ESM an extensionless JavaScript file that is outside of any package scope', async () => {
-             const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-               '--experimental-default-type=module',
-               fixtures.path('es-modules/noext-esm'),
-             ]);
-
-             strictEqual(stderr, '');
-             strictEqual(stdout, 'executed\n');
-             strictEqual(code, 0);
-             strictEqual(signal, null);
-           });
-
-           it('should run as Wasm an extensionless Wasm file that is outside of any package scope', async () => {
-             const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-               '--experimental-default-type=module',
-               '--experimental-wasm-modules',
-               '--no-warnings',
-               fixtures.path('es-modules/noext-wasm'),
-             ]);
-
-             strictEqual(stderr, '');
-             strictEqual(stdout, '');
-             strictEqual(code, 0);
-             strictEqual(signal, null);
-           });
-
-           it('should import as ESM a .js file that is outside of any package scope', async () => {
-             const { default: defaultExport } = await import(fixtures.fileURL('es-modules/loose.js'));
-             strictEqual(defaultExport, 'module');
-           });
-
-           it('should import as ESM an extensionless JavaScript file that is outside of any package scope',
-              async () => {
-                const { default: defaultExport } = await import(fixtures.fileURL('es-modules/noext-esm'));
-                strictEqual(defaultExport, 'module');
-              });
-
-           it('should import as Wasm an extensionless Wasm file that is outside of any package scope', async () => {
-             const { add } = await import(fixtures.fileURL('es-modules/noext-wasm'));
-             strictEqual(add(1, 2), 3);
-           });
-
-           it('should check as ESM input passed via --check', async () => {
-             const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-               '--experimental-default-type=module',
-               '--check',
-               fixtures.path('es-modules/loose.js'),
-             ]);
-
-             strictEqual(stderr, '');
-             strictEqual(stdout, '');
-             strictEqual(code, 0);
-             strictEqual(signal, null);
-           });
-         });
diff --git a/test/es-module/test-esm-type-flag-package-scopes.mjs b/test/es-module/test-esm-type-flag-package-scopes.mjs
deleted file mode 100644
index 18d7d04f53a25b..00000000000000
--- a/test/es-module/test-esm-type-flag-package-scopes.mjs
+++ /dev/null
@@ -1,167 +0,0 @@
-// Flags: --experimental-default-type=module --experimental-wasm-modules
-import { spawnPromisified } from '../common/index.mjs';
-import * as fixtures from '../common/fixtures.mjs';
-import { describe, it } from 'node:test';
-import { strictEqual } from 'node:assert';
-
-describe('the type flag should change the interpretation of certain files within a "type": "module" package scope',
-         { concurrency: !process.env.TEST_PARALLEL }, () => {
-           it('should run as ESM an extensionless JavaScript file within a "type": "module" scope', async () => {
-             const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-               '--experimental-default-type=module',
-               fixtures.path('es-modules/package-type-module/noext-esm'),
-             ]);
-
-             strictEqual(stderr, '');
-             strictEqual(stdout, 'executed\n');
-             strictEqual(code, 0);
-             strictEqual(signal, null);
-           });
-
-           it('should import an extensionless JavaScript file within a "type": "module" scope', async () => {
-             const { default: defaultExport } =
-              await import(fixtures.fileURL('es-modules/package-type-module/noext-esm'));
-             strictEqual(defaultExport, 'module');
-           });
-
-           it('should import an extensionless JavaScript file within a "type": "module" scope under node_modules',
-              async () => {
-                const { default: defaultExport } =
-                await import(fixtures.fileURL(
-                  'es-modules/package-type-module/node_modules/dep-with-package-json-type-module/noext-esm'));
-                strictEqual(defaultExport, 'module');
-              });
-
-           it('should run as Wasm an extensionless Wasm file within a "type": "module" scope', async () => {
-             const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-               '--experimental-default-type=module',
-               '--experimental-wasm-modules',
-               '--no-warnings',
-               fixtures.path('es-modules/package-type-module/noext-wasm'),
-             ]);
-
-             strictEqual(stderr, '');
-             strictEqual(stdout, 'executed\n');
-             strictEqual(code, 0);
-             strictEqual(signal, null);
-           });
-
-           it('should import as Wasm an extensionless Wasm file within a "type": "module" scope', async () => {
-             const { add } = await import(fixtures.fileURL('es-modules/package-type-module/noext-wasm'));
-             strictEqual(add(1, 2), 3);
-           });
-
-           it('should import an extensionless Wasm file within a "type": "module" scope under node_modules',
-              async () => {
-                const { add } = await import(fixtures.fileURL(
-                  'es-modules/package-type-module/node_modules/dep-with-package-json-type-module/noext-wasm'));
-                strictEqual(add(1, 2), 3);
-              });
-         });
-
-describe(`the type flag should change the interpretation of certain files within a package scope that lacks a
-"type" field and is not under node_modules`, { concurrency: !process.env.TEST_PARALLEL }, () => {
-  it('should run as ESM a .js file within package scope that has no defined "type" and is not under node_modules',
-     async () => {
-       const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-         '--experimental-default-type=module',
-         fixtures.path('es-modules/package-without-type/module.js'),
-       ]);
-
-       strictEqual(stderr, '');
-       strictEqual(stdout, 'executed\n');
-       strictEqual(code, 0);
-       strictEqual(signal, null);
-     });
-
-  it(`should run as ESM an extensionless JavaScript file within a package scope that has no defined "type" and is not
-under node_modules`, async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      fixtures.path('es-modules/package-without-type/noext-esm'),
-    ]);
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, 'executed\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it(`should run as Wasm an extensionless Wasm file within a package scope that has no defined "type" and is not under
-  node_modules`, async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '--experimental-wasm-modules',
-      '--no-warnings',
-      fixtures.path('es-modules/noext-wasm'),
-    ]);
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, '');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it('should import as ESM a .js file within package scope that has no defined "type" and is not under node_modules',
-     async () => {
-       const { default: defaultExport } = await import(fixtures.fileURL('es-modules/package-without-type/module.js'));
-       strictEqual(defaultExport, 'module');
-     });
-
-  it(`should import as ESM an extensionless JavaScript file within a package scope that has no defined "type" and is
-  not under node_modules`, async () => {
-    const { default: defaultExport } = await import(fixtures.fileURL('es-modules/package-without-type/noext-esm'));
-    strictEqual(defaultExport, 'module');
-  });
-
-  it(`should import as Wasm an extensionless Wasm file within a package scope that has no defined "type" and is not
-  under node_modules`, async () => {
-    const { add } = await import(fixtures.fileURL('es-modules/noext-wasm'));
-    strictEqual(add(1, 2), 3);
-  });
-});
-
-describe(`the type flag should NOT change the interpretation of certain files within a package scope that lacks a
-"type" field and is under node_modules`, { concurrency: !process.env.TEST_PARALLEL }, () => {
-  it('should run as CommonJS a .js file within package scope that has no defined "type" and is under node_modules',
-     async () => {
-       const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-         '--experimental-default-type=module',
-         fixtures.path('es-modules/package-type-module/node_modules/dep-with-package-json-without-type/run.js'),
-       ]);
-
-       strictEqual(stderr, '');
-       strictEqual(stdout, 'executed\n');
-       strictEqual(code, 0);
-       strictEqual(signal, null);
-     });
-
-  it(`should import as CommonJS a .js file within a package scope that has no defined "type" and is under
-  node_modules`, async () => {
-    const { default: defaultExport } =
-      await import(fixtures.fileURL(
-        'es-modules/package-type-module/node_modules/dep-with-package-json-without-type/run.js'));
-    strictEqual(defaultExport, 42);
-  });
-
-  it(`should run as CommonJS an extensionless JavaScript file within a package scope that has no defined "type" and is
-  under node_modules`, async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      fixtures.path('es-modules/package-type-module/node_modules/dep-with-package-json-without-type/noext-cjs'),
-    ]);
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, 'executed\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  it(`should import as CommonJS an extensionless JavaScript file within a package scope that has no defined "type" and
-  is under node_modules`, async () => {
-    const { default: defaultExport } =
-      await import(fixtures.fileURL(
-        'es-modules/package-type-module/node_modules/dep-with-package-json-without-type/noext-cjs'));
-    strictEqual(defaultExport, 42);
-  });
-});
diff --git a/test/es-module/test-esm-type-flag-string-input.mjs b/test/es-module/test-esm-type-flag-string-input.mjs
deleted file mode 100644
index 5581aaa426b56f..00000000000000
--- a/test/es-module/test-esm-type-flag-string-input.mjs
+++ /dev/null
@@ -1,46 +0,0 @@
-import { spawnPromisified } from '../common/index.mjs';
-import { spawn } from 'node:child_process';
-import { describe, it } from 'node:test';
-import { strictEqual, match } from 'node:assert';
-
-describe('the type flag should change the interpretation of string input', {
-  concurrency: !process.env.TEST_PARALLEL,
-}, () => {
-  it('should run as ESM input passed via --eval', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '--eval',
-      'import "data:text/javascript,console.log(42)"',
-    ]);
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, '42\n');
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-
-  // ESM is unsupported for --print via --input-type=module
-
-  it('should run as ESM input passed via STDIN', async () => {
-    const child = spawn(process.execPath, [
-      '--experimental-default-type=module',
-    ]);
-    child.stdin.end('console.log(typeof import.meta.resolve)');
-
-    match((await child.stdout.toArray()).toString(), /^function\r?\n$/);
-  });
-
-  it('should be overridden by --input-type', async () => {
-    const { code, signal, stdout, stderr } = await spawnPromisified(process.execPath, [
-      '--experimental-default-type=module',
-      '--input-type=commonjs',
-      '--eval',
-      'console.log(require("process").version)',
-    ]);
-
-    strictEqual(stderr, '');
-    strictEqual(stdout, `${process.version}\n`);
-    strictEqual(code, 0);
-    strictEqual(signal, null);
-  });
-});
diff --git a/test/es-module/test-typescript-commonjs.mjs b/test/es-module/test-typescript-commonjs.mjs
index c24576c4a0c392..bbaaa7a414bc1d 100644
--- a/test/es-module/test-typescript-commonjs.mjs
+++ b/test/es-module/test-typescript-commonjs.mjs
@@ -121,19 +121,6 @@ test('execute a .cts file importing a .mts file export', async () => {
   strictEqual(result.code, 0);
 });
 
-test('execute a .cts file with default type module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module', // Keeps working with commonjs
-    '--no-warnings',
-    fixtures.path('typescript/cts/test-require-commonjs.cts'),
-  ]);
-
-  strictEqual(result.stderr, '');
-  match(result.stdout, /Hello, TypeScript!/);
-  strictEqual(result.code, 0);
-});
-
 test('expect failure of a .cts file in node_modules', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
diff --git a/test/es-module/test-typescript-module.mjs b/test/es-module/test-typescript-module.mjs
index 6b6b0e68f251f6..8a99c2e9576add 100644
--- a/test/es-module/test-typescript-module.mjs
+++ b/test/es-module/test-typescript-module.mjs
@@ -39,19 +39,6 @@ test('execute an .mts file importing a .ts file', async () => {
   strictEqual(result.code, 0);
 });
 
-test('execute an .mts file importing a .ts file with default-type module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module',
-    '--no-warnings',
-    fixtures.path('typescript/mts/test-import-ts-file.mts'),
-  ]);
-
-  strictEqual(result.stderr, '');
-  match(result.stdout, /Hello, TypeScript!/);
-  strictEqual(result.code, 0);
-});
-
 test('execute an .mts file importing a .cts file', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -64,31 +51,6 @@ test('execute an .mts file importing a .cts file', async () => {
   strictEqual(result.code, 0);
 });
 
-test('execute an .mts file with wrong default module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--no-experimental-require-module',
-    '--experimental-default-type=commonjs',
-    fixtures.path('typescript/mts/test-import-module.mts'),
-  ]);
-
-  strictEqual(result.stdout, '');
-  match(result.stderr, /Error \[ERR_REQUIRE_ESM\]: require\(\) of ES Module/);
-  strictEqual(result.code, 1);
-});
-
-test('execute an .mts file with wrong default module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-require-module',
-    '--experimental-default-type=commonjs',
-    fixtures.path('typescript/mts/test-import-module.mts'),
-  ]);
-
-  match(result.stdout, /Hello, TypeScript!/);
-  strictEqual(result.code, 0);
-});
-
 test('execute an .mts file from node_modules', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
diff --git a/test/es-module/test-typescript.mjs b/test/es-module/test-typescript.mjs
index a7ca6d70dd5e10..00cc80e0ce93ff 100644
--- a/test/es-module/test-typescript.mjs
+++ b/test/es-module/test-typescript.mjs
@@ -65,19 +65,6 @@ test('execute a TypeScript file with imports', async () => {
   strictEqual(result.code, 0);
 });
 
-test('execute a TypeScript file with imports with default-type module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module',
-    '--no-warnings',
-    fixtures.path('typescript/ts/test-import-foo.ts'),
-  ]);
-
-  strictEqual(result.stderr, '');
-  match(result.stdout, /Hello, TypeScript!/);
-  strictEqual(result.code, 0);
-});
-
 test('execute a TypeScript file with node_modules', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -90,19 +77,6 @@ test('execute a TypeScript file with node_modules', async () => {
   strictEqual(result.code, 0);
 });
 
-test('execute a TypeScript file with node_modules with default-type module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module',
-    '--no-warnings',
-    fixtures.path('typescript/ts/test-typescript-node-modules.ts'),
-  ]);
-
-  strictEqual(result.stderr, '');
-  match(result.stdout, /Hello, TypeScript!/);
-  strictEqual(result.code, 0);
-});
-
 test('expect error when executing a TypeScript file with imports with no extensions', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -114,19 +88,6 @@ test('expect error when executing a TypeScript file with imports with no extensi
   strictEqual(result.code, 1);
 });
 
-test('expect error when executing a TypeScript file with imports with no extensions with default-type module',
-     async () => {
-       const result = await spawnPromisified(process.execPath, [
-         '--experimental-strip-types',
-         '--experimental-default-type=module',
-         fixtures.path('typescript/ts/test-import-no-extension.ts'),
-       ]);
-
-       match(result.stderr, /Error \[ERR_MODULE_NOT_FOUND\]:/);
-       strictEqual(result.stdout, '');
-       strictEqual(result.code, 1);
-     });
-
 test('expect error when executing a TypeScript file with enum', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -184,18 +145,6 @@ test('execute a TypeScript file with type definition but no type keyword', async
   strictEqual(result.code, 1);
 });
 
-test('execute a TypeScript file with type definition but no type keyword with default-type modue', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module',
-    fixtures.path('typescript/ts/test-import-no-type-keyword.ts'),
-  ]);
-
-  match(result.stderr, /does not provide an export named 'MyType'/);
-  strictEqual(result.stdout, '');
-  strictEqual(result.code, 1);
-});
-
 test('execute a TypeScript file with CommonJS syntax', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -219,19 +168,6 @@ test('execute a TypeScript file with ES module syntax', async () => {
   strictEqual(result.code, 0);
 });
 
-test('execute a TypeScript file with ES module syntax with default-type module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module',
-    '--no-warnings',
-    fixtures.path('typescript/ts/test-module-typescript.ts'),
-  ]);
-
-  strictEqual(result.stderr, '');
-  match(result.stdout, /Hello, TypeScript!/);
-  strictEqual(result.code, 0);
-});
-
 test('expect failure of a TypeScript file requiring ES module syntax', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -266,30 +202,6 @@ test('execute CommonJS TypeScript file from node_modules with require-module', a
   strictEqual(result.code, 1);
 });
 
-test('execute CommonJS TypeScript file from node_modules with require-module and default-type module',
-     async () => {
-       const result = await spawnPromisified(process.execPath, [
-         '--experimental-strip-types',
-         '--experimental-default-type=module',
-         fixtures.path('typescript/ts/test-import-ts-node-modules.ts'),
-       ]);
-
-       match(result.stderr, /ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING/);
-       strictEqual(result.stdout, '');
-       strictEqual(result.code, 1);
-     });
-
-test('execute a TypeScript file with CommonJS syntax but default type module', async () => {
-  const result = await spawnPromisified(process.execPath, [
-    '--experimental-strip-types',
-    '--experimental-default-type=module',
-    fixtures.path('typescript/ts/test-commonjs-parsing.ts'),
-  ]);
-  strictEqual(result.stdout, '');
-  match(result.stderr, /require is not defined in ES module scope, you can use import instead/);
-  strictEqual(result.code, 1);
-});
-
 test('execute a TypeScript file with CommonJS syntax requiring .cts', async () => {
   const result = await spawnPromisified(process.execPath, [
     '--experimental-strip-types',
@@ -336,11 +248,10 @@ test('execute a TypeScript file with CommonJS syntax requiring .cts using common
   strictEqual(result.code, 0);
 });
 
-test('execute a TypeScript file with CommonJS syntax requiring .mts with require-module with default-type commonjs',
+test('execute a TypeScript file with CommonJS syntax requiring .mts with require-module',
      async () => {
        const result = await spawnPromisified(process.execPath, [
          '--experimental-strip-types',
-         '--experimental-default-type=commonjs',
          '--no-warnings',
          fixtures.path('typescript/ts/test-require-cts.ts'),
        ]);
diff --git a/test/fixtures/es-modules/loose.js b/test/fixtures/es-modules/loose.js
index c0d85f7eab9a2b..251d6e538a1fcf 100644
--- a/test/fixtures/es-modules/loose.js
+++ b/test/fixtures/es-modules/loose.js
@@ -1,5 +1,2 @@
-// This file can be run or imported only if `--experimental-default-type=module` is set
-// or `--experimental-detect-module` is not disabled. If it's loaded by
-// require(), then `--experimental-require-module` must not be disabled.
 export default 'module';
 console.log('executed');
diff --git a/test/fixtures/es-modules/package-without-type/noext-esm b/test/fixtures/es-modules/package-without-type/noext-esm
index 69147a3b8ca027..251d6e538a1fcf 100644
--- a/test/fixtures/es-modules/package-without-type/noext-esm
+++ b/test/fixtures/es-modules/package-without-type/noext-esm
@@ -1,3 +1,2 @@
-// This file can be run or imported only if `--experimental-default-type=module` is set.
 export default 'module';
 console.log('executed');
diff --git a/test/parallel/test-runner-module-mocking.js b/test/parallel/test-runner-module-mocking.js
index dd200eb839ed3d..803a566a3b4d28 100644
--- a/test/parallel/test-runner-module-mocking.js
+++ b/test/parallel/test-runner-module-mocking.js
@@ -637,12 +637,11 @@ test('defaultExports work with ESM mocks in both module systems', async (t) => {
   assert.strictEqual(require(fixturePath), defaultExport);
 });
 
-test('wrong import syntax should throw error after module mocking.', async () => {
+test('wrong import syntax should throw error after module mocking', async () => {
   const { stdout, stderr, code } = await common.spawnPromisified(
     process.execPath,
     [
       '--experimental-test-module-mocks',
-      '--experimental-default-type=module',
       fixtures.path('module-mocking/wrong-import-after-module-mocking.js'),
     ]
   );