diff --git a/doc/api/module.md b/doc/api/module.md
index 62780536914f96..1add32bc3ba4c9 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -220,6 +220,12 @@ changes:
 Register a module that exports [hooks][] that customize Node.js module
 resolution and loading behavior. See [Customization hooks][].
 
+This API is runtime-deprecated. New code should use
+[`module.registerHooks()`][] instead, which runs hooks synchronously on the
+main thread and avoids the worker-thread caveats listed under
+[caveats of asynchronous customization hooks][]. Hook context fields are
+kept in sync across both APIs to ease migration.
+
 This feature requires `--allow-worker` if used with the [Permission Model][].
 
 ### `module.registerHooks(options)`
@@ -873,6 +879,11 @@ via `process.execArgv` inheritance. See [the documentation of `Worker`][] for de
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Add `context.requestType` so hooks can distinguish a `require()`
+                 call from an `import`. `context.conditions` now reflects the
+                 request type (CJS conditions when `requestType` is `'require'`).
   - version:
     - v23.5.0
     - v22.15.0
@@ -882,11 +893,19 @@ changes:
 
 * `specifier` {string}
 * `context` {Object}
-  * `conditions` {string\[]} Export conditions of the relevant `package.json`
+  * `conditions` {string\[]} Export conditions of the relevant `package.json`.
+    When `requestType` is `'require'`, the array contains CJS conditions
+    (including `'require'`); otherwise it contains ESM conditions
+    (including `'import'`).
   * `importAttributes` {Object} An object whose key-value pairs represent the
     attributes for the module to import
   * `parentURL` {string|undefined} The module importing this one, or undefined
     if this is the Node.js entry point
+  * `requestType` {string} `'import'` if this resolution is on behalf of an
+    `import` statement, `import()` expression, or `import.meta.resolve()`;
+    `'require'` if it is on behalf of a `require()` call (including
+    `require()` in a CommonJS module reached via the [`require(esm)`][]
+    bridge).
 * `nextResolve` {Function} The subsequent `resolve` hook in the chain, or the
   Node.js default `resolve` hook after the last user-supplied `resolve` hook
   * `specifier` {string}
@@ -961,6 +980,11 @@ registerHooks({ resolve });
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Add `context.requestType` so hooks can distinguish a `require()`
+                 call from an `import`. `context.conditions` now reflects the
+                 request type (CJS conditions when `requestType` is `'require'`).
   - version:
     - v23.5.0
     - v22.15.0
@@ -970,11 +994,18 @@ changes:
 
 * `url` {string} The URL returned by the `resolve` chain
 * `context` {Object}
-  * `conditions` {string\[]} Export conditions of the relevant `package.json`
+  * `conditions` {string\[]} Export conditions of the relevant `package.json`.
+    When `requestType` is `'require'`, the array contains CJS conditions
+    (including `'require'`); otherwise it contains ESM conditions
+    (including `'import'`).
   * `format` {string|null|undefined} The format optionally supplied by the
     `resolve` hook chain. This can be any string value as an input; input values do not need to
     conform to the list of acceptable return values described below.
   * `importAttributes` {Object}
+  * `requestType` {string} `'import'` if this load is on behalf of an `import`
+    statement or `import()` expression; `'require'` if it is on behalf of a
+    `require()` call (including `require()` in a CommonJS module reached via
+    the [`require(esm)`][] bridge).
 * `nextLoad` {Function} The subsequent `load` hook in the chain, or the
   Node.js default `load` hook after the last user-supplied `load` hook
   * `url` {string}
@@ -1382,6 +1413,11 @@ register('./path-to-my-hooks.js', {
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Add `context.requestType` so hooks can distinguish a `require()`
+                 call from an `import`. `context.conditions` now reflects the
+                 request type (CJS conditions when `requestType` is `'require'`).
   - version:
     - v21.0.0
     - v20.10.0
@@ -1406,11 +1442,19 @@ changes:
 
 * `specifier` {string}
 * `context` {Object}
-  * `conditions` {string\[]} Export conditions of the relevant `package.json`
+  * `conditions` {string\[]} Export conditions of the relevant `package.json`.
+    When `requestType` is `'require'`, the array contains CJS conditions
+    (including `'require'`); otherwise it contains ESM conditions
+    (including `'import'`).
   * `importAttributes` {Object} An object whose key-value pairs represent the
     attributes for the module to import
   * `parentURL` {string|undefined} The module importing this one, or undefined
     if this is the Node.js entry point
+  * `requestType` {string} `'import'` if this resolution is on behalf of an
+    `import` statement, `import()` expression, or `import.meta.resolve()`;
+    `'require'` if it is on behalf of a `require()` call (including
+    `require()` in a CommonJS module reached via the [`require(esm)`][]
+    bridge).
 * `nextResolve` {Function} The subsequent `resolve` hook in the chain, or the
   Node.js default `resolve` hook after the last user-supplied `resolve` hook
   * `specifier` {string}
@@ -1439,10 +1483,6 @@ The asynchronous version works similarly to the synchronous version, only that t
 > `require()`. Instead, it receives a URL already fully resolved using the default
 > CommonJS resolution.
 
-> **Warning** In the CommonJS modules that are customized by the asynchronous customization hooks,
-> `require.resolve()` and `require()` will use `"import"` export condition instead of
-> `"require"`, which may cause unexpected behaviors when loading dual packages.
-
 ```mjs
 export async function resolve(specifier, context, nextResolve) {
   // When calling `defaultResolve`, the arguments can be modified. For example,
@@ -1474,6 +1514,12 @@ export async function resolve(specifier, context, nextResolve) {
 
 <!-- YAML
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/REPLACEME
+    description: Add `context.requestType` so hooks can distinguish a `require()`
+                 call from an `import`. `context.conditions` is now populated on
+                 the load context as well (it was previously absent), and
+                 reflects the request type.
   - version: v22.6.0
     pr-url: https://github.com/nodejs/node/pull/56350
     description: Add support for `source` with format `commonjs-typescript` and `module-typescript`.
@@ -1491,11 +1537,18 @@ changes:
 
 * `url` {string} The URL returned by the `resolve` chain
 * `context` {Object}
-  * `conditions` {string\[]} Export conditions of the relevant `package.json`
+  * `conditions` {string\[]} Export conditions of the relevant `package.json`.
+    When `requestType` is `'require'`, the array contains CJS conditions
+    (including `'require'`); otherwise it contains ESM conditions
+    (including `'import'`).
   * `format` {string|null|undefined} The format optionally supplied by the
     `resolve` hook chain. This can be any string value as an input; input values do not need to
     conform to the list of acceptable return values described below.
   * `importAttributes` {Object}
+  * `requestType` {string} `'import'` if this load is on behalf of an `import`
+    statement or `import()` expression; `'require'` if it is on behalf of a
+    `require()` call (including `require()` in a CommonJS module reached via
+    the [`require(esm)`][] bridge).
 * `nextLoad` {Function} The subsequent `load` hook in the chain, or the
   Node.js default `load` hook after the last user-supplied `load` hook
   * `url` {string}
@@ -2072,6 +2125,7 @@ returned object contains the following keys:
 [`module`]: #the-module-object
 [`os.tmpdir()`]: os.md#ostmpdir
 [`register`]: #moduleregisterspecifier-parenturl-options
+[`require(esm)`]: modules.md#loading-ecmascript-modules-using-require
 [`util.TextDecoder`]: util.md#class-utiltextdecoder
 [accepted final formats]: #accepted-final-formats-returned-by-load
 [asynchronous `load` hook]: #asynchronous-loadurl-context-nextload
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 65a35299eb6552..610baa3f6fad1f 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -1165,7 +1165,7 @@ function resolveForCJSWithHooks(specifier, parent, isMain, internalOptions) {
   }
 
   const resolveResult = resolveWithHooks(specifier, parentURL, /* importAttributes */ undefined,
-                                         getCjsConditionsArray(), defaultResolve);
+                                         getCjsConditionsArray(), 'require', defaultResolve);
   const { url, format } = resolveResult;
   // Convert the URL from the hook chain back to a filename for internal use.
   const filename = convertURLToCJSFilename(url);
@@ -1239,7 +1239,8 @@ function loadBuiltinWithHooks(id, url, format) {
     debug('loadBuiltinWithHooks ', loadHooks.length, id, url, format);
     // TODO(joyeecheung): do we really want to invoke the load hook for the builtins?
     resultFromHook = loadWithHooks(url, format || 'builtin', /* importAttributes */ undefined,
-                                   getCjsConditionsArray(), getDefaultLoad(url, id), validateLoadStrict);
+                                   getCjsConditionsArray(), 'require',
+                                   getDefaultLoad(url, id), validateLoadStrict);
     if (resultFromHook.format && resultFromHook.format !== 'builtin') {
       debug('loadBuiltinWithHooks overriding module', id, url, resultFromHook);
       // Format has been overridden, return result for the caller to continue loading.
@@ -1906,7 +1907,7 @@ function loadSource(mod, filename, formatFromNode) {
 
   const defaultLoad = getDefaultLoad(mod[kURL], filename);
   const loadResult = loadWithHooks(mod[kURL], mod[kFormat], /* importAttributes */ undefined,
-                                   getCjsConditionsArray(), defaultLoad, validateLoadStrict);
+                                   getCjsConditionsArray(), 'require', defaultLoad, validateLoadStrict);
   // Reset the module properties with load hook results.
   if (loadResult.format !== undefined) {
     mod[kFormat] = loadResult.format;
diff --git a/lib/internal/modules/customization_hooks.js b/lib/internal/modules/customization_hooks.js
index c2579269ec6396..29418cbdaf962c 100644
--- a/lib/internal/modules/customization_hooks.js
+++ b/lib/internal/modules/customization_hooks.js
@@ -328,12 +328,15 @@ class ModuleResolveContext {
    * @param {string|undefined} parentURL Parent URL.
    * @param {ImportAttributes|undefined} importAttributes Import attributes.
    * @param {string[]} conditions Conditions.
+   * @param {'import'|'require'} requestType Whether the resolution is being done on behalf of
+   *   a `require()` call (`'require'`) or an `import` statement / `import()` expression /
+   *   `import.meta.resolve()` (`'import'`).
    */
-  constructor(parentURL, importAttributes, conditions) {
+  constructor(parentURL, importAttributes, conditions, requestType) {
     this.parentURL = parentURL;
     this.importAttributes = importAttributes;
     this.conditions = conditions;
-    // TODO(joyeecheung): a field to differentiate between require and import?
+    this.requestType = requestType;
   }
 };
 
@@ -343,11 +346,15 @@ class ModuleLoadContext {
    * @param {string|undefined} format URL.
    * @param {ImportAttributes|undefined} importAttributes Import attributes.
    * @param {string[]} conditions Conditions.
+   * @param {'import'|'require'} requestType Whether the load is being done on behalf of
+   *   a `require()` call (`'require'`) or an `import` statement / `import()` expression
+   *   (`'import'`).
    */
-  constructor(format, importAttributes, conditions) {
+  constructor(format, importAttributes, conditions, requestType) {
     this.format = format;
     this.importAttributes = importAttributes;
     this.conditions = conditions;
+    this.requestType = requestType;
   }
 };
 
@@ -358,13 +365,15 @@ let decoder;
  * @param {string|undefined} originalFormat
  * @param {ImportAttributes|undefined} importAttributes
  * @param {string[]} conditions
+ * @param {'import'|'require'} requestType See {@link ModuleLoadContext}.
  * @param {(url: string, context: ModuleLoadContext) => ModuleLoadResult} defaultLoad
  * @param {(url: string, context: ModuleLoadContext, result: ModuleLoadResult) => ModuleLoadResult} validateLoad
  * @returns {ModuleLoadResult}
  */
-function loadWithHooks(url, originalFormat, importAttributes, conditions, defaultLoad, validateLoad) {
+function loadWithHooks(url, originalFormat, importAttributes, conditions, requestType,
+                       defaultLoad, validateLoad) {
   debug('loadWithHooks', url, originalFormat);
-  const context = new ModuleLoadContext(originalFormat, importAttributes, conditions);
+  const context = new ModuleLoadContext(originalFormat, importAttributes, conditions, requestType);
   if (loadHooks.length === 0) {
     return defaultLoad(url, context);
   }
@@ -402,12 +411,13 @@ function loadWithHooks(url, originalFormat, importAttributes, conditions, defaul
  * @param {string|undefined} parentURL
  * @param {ImportAttributes|undefined} importAttributes
  * @param {string[]} conditions
+ * @param {'import'|'require'} requestType See {@link ModuleResolveContext}.
  * @param {(specifier: string, context: ModuleResolveContext) => ModuleResolveResult} defaultResolve
  * @returns {ModuleResolveResult}
  */
-function resolveWithHooks(specifier, parentURL, importAttributes, conditions, defaultResolve) {
+function resolveWithHooks(specifier, parentURL, importAttributes, conditions, requestType, defaultResolve) {
   debug('resolveWithHooks', specifier, parentURL, importAttributes);
-  const context = new ModuleResolveContext(parentURL, importAttributes, conditions);
+  const context = new ModuleResolveContext(parentURL, importAttributes, conditions, requestType);
   if (resolveHooks.length === 0) {
     return defaultResolve(specifier, context);
   }
diff --git a/lib/internal/modules/esm/hooks.js b/lib/internal/modules/esm/hooks.js
index 78ffb5f834a989..047e533bdf38ab 100644
--- a/lib/internal/modules/esm/hooks.js
+++ b/lib/internal/modules/esm/hooks.js
@@ -50,6 +50,9 @@ const {
 const {
   getDefaultConditions,
 } = require('internal/modules/esm/utils');
+const {
+  getConditionsForRequestType,
+} = require('internal/modules/helpers');
 const { deserializeError } = require('internal/error_serdes');
 const {
   SHARED_MEMORY_BYTE_LENGTH,
@@ -219,20 +222,24 @@ class AsyncLoaderHooksOnLoaderHookWorker {
    * @param {string} [parentURL] The URL path of the module's parent.
    * @param {ImportAttributes} [importAttributes] Attributes from the import
    *   statement or expression.
+   * @param {'import'|'require'} [requestType] Whether this resolution is on behalf of a
+   *   `require()` call or an `import`. Defaults to `'import'`.
    * @returns {Promise<{ format: string, url: URL['href'] }>}
    */
   async resolve(
     originalSpecifier,
     parentURL,
     importAttributes = { __proto__: null },
+    requestType = 'import',
   ) {
     throwIfInvalidParentURL(parentURL);
 
     const chain = this.#chains.resolve;
     const context = {
-      conditions: getDefaultConditions(),
+      conditions: getConditionsForRequestType(requestType, getDefaultConditions()),
       importAttributes,
       parentURL,
+      requestType,
     };
     const meta = {
       chainFinished: null,
@@ -355,6 +362,19 @@ class AsyncLoaderHooksOnLoaderHookWorker {
    * @returns {Promise<{ format: ModuleFormat, source: ModuleSource }>}
    */
   async load(url, context = {}) {
+    // The context arriving over IPC was constructed on the main thread (see ModuleLoader
+    // #getOrCreateModuleJobAfterResolve) and carries `requestType`. The requestType fallback
+    // here is for the rare case where a caller constructs a load context directly without
+    // going through that path (for example a user hook that calls `nextLoad(url, {})`). Build
+    // a fresh, plain context object for the hook chain so user hooks observe parity with the
+    // sync ModuleLoadContext shape.
+    const requestType = context.requestType ?? 'import';
+    context = {
+      format: context.format,
+      importAttributes: context.importAttributes,
+      conditions: context.conditions ?? getConditionsForRequestType(requestType, getDefaultConditions()),
+      requestType,
+    };
     const chain = this.#chains.load;
     const meta = {
       chainFinished: null,
@@ -834,15 +854,20 @@ class AsyncLoaderHooksProxiedToLoaderHookWorker {
    * @param {string} [parentURL] The URL path of the module's parent.
    * @param {ImportAttributes} importAttributes Attributes from the import
    *   statement or expression.
+   * @param {'import'|'require'} [requestType] Whether this resolution is on behalf of a `require()`
+   *   call or an `import`. Defaults to `'import'`.
    * @returns {{ format: string, url: URL['href'] }}
    */
-  resolve(originalSpecifier, parentURL, importAttributes) {
-    return asyncLoaderHookWorker.makeAsyncRequest('resolve', undefined, originalSpecifier, parentURL, importAttributes);
+  resolve(originalSpecifier, parentURL, importAttributes, requestType = 'import') {
+    return asyncLoaderHookWorker.makeAsyncRequest('resolve', undefined, originalSpecifier, parentURL,
+                                                  importAttributes, requestType);
   }
 
-  resolveSync(originalSpecifier, parentURL, importAttributes) {
-    // This happens only as a result of `import.meta.resolve` calls, which must be sync per spec.
-    return asyncLoaderHookWorker.makeSyncRequest('resolve', undefined, originalSpecifier, parentURL, importAttributes);
+  resolveSync(originalSpecifier, parentURL, importAttributes, requestType = 'import') {
+    // This happens as a result of `import.meta.resolve` calls (which must be sync per spec) and
+    // `require()` in imported CJS.
+    return asyncLoaderHookWorker.makeSyncRequest('resolve', undefined, originalSpecifier, parentURL,
+                                                 importAttributes, requestType);
   }
 
   /**
diff --git a/lib/internal/modules/esm/loader.js b/lib/internal/modules/esm/loader.js
index 34a9393ac18f01..3a93f6dc1c2d42 100644
--- a/lib/internal/modules/esm/loader.js
+++ b/lib/internal/modules/esm/loader.js
@@ -42,6 +42,7 @@ const {
   getDefaultConditions,
   shouldSpawnLoaderHookWorker,
   requestTypes: { kImportInRequiredESM, kRequireInImportedCJS, kImportInImportedESM },
+  toRequestTypeString,
 } = require('internal/modules/esm/utils');
 /**
  * @typedef {import('./utils.js').ModuleRequestType} ModuleRequestType
@@ -60,6 +61,7 @@ const {
   setImportMetaResolveInitializer,
 } = internalBinding('module_wrap');
 const {
+  getConditionsForRequestType,
   urlToFilename,
 } = require('internal/modules/helpers');
 const {
@@ -545,8 +547,7 @@ class ModuleLoader {
     const { url, format } = resolveResult;
 
     if (process.env.WATCH_REPORT_DEPENDENCIES && process.send) {
-      const type = requestType === kRequireInImportedCJS ? 'require' : 'import';
-      process.send({ [`watch:${type}`]: [url] });
+      process.send({ [`watch:${toRequestTypeString(requestType)}`]: [url] });
     }
     // Relay Events from worker to main thread
     if (process.env.WATCH_REPORT_DEPENDENCIES && !process.send) {
@@ -571,7 +572,14 @@ class ModuleLoader {
       return job;
     }
 
-    const context = { format, importAttributes, __proto__: null };
+    // Tell user hooks whether this load is on behalf of a require() call or an import.
+    // See {@link toRequestTypeString} for the mapping semantics.
+    const context = {
+      format,
+      importAttributes,
+      requestType: toRequestTypeString(requestType),
+      __proto__: null,
+    };
 
     let moduleOrModulePromise;
     if (requestType === kRequireInImportedCJS) {
@@ -617,13 +625,17 @@ class ModuleLoader {
    * @returns {Promise<ModuleJobBase>|ModuleJobBase}
    */
   getOrCreateModuleJob(parentURL, request, requestType) {
+    // Tell user hooks whether this resolve is on behalf of a require() call or an import.
+    // See {@link toRequestTypeString} for the mapping semantics.
+    const requestTypeString = toRequestTypeString(requestType);
+
     let maybePromise;
     if (requestType === kRequireInImportedCJS || requestType === kImportInRequiredESM) {
       // In these two cases, resolution must be synchronous.
-      maybePromise = this.resolveSync(parentURL, request);
+      maybePromise = this.resolveSync(parentURL, request, false, requestTypeString);
       assert(!isPromise(maybePromise));
     } else {
-      maybePromise = this.#resolve(parentURL, request);
+      maybePromise = this.#resolve(parentURL, request, requestTypeString);
     }
 
     const afterResolve = (resolveResult) => {
@@ -693,17 +705,19 @@ class ModuleLoader {
    * @param {string} [parentURL] The URL of the module where the module request is initiated.
    *   It's undefined if it's from the root module.
    * @param {ModuleRequest} request Module request.
+   * @param {'import'|'require'} [requestType] Whether this resolve is on behalf of a require() call
+   *   or an import. Defaults to 'import'.
    * @returns {Promise<ResolveResult>|ResolveResult}
    */
-  #resolve(parentURL, request) {
+  #resolve(parentURL, request, requestType = 'import') {
     if (this.isForAsyncLoaderHookWorker) {
       const specifier = `${request.specifier}`;
       const importAttributes = request.attributes ?? kEmptyObject;
       // TODO(joyeecheung): invoke the synchronous hooks in the default step on loader thread.
-      return this.#asyncLoaderHooks.resolve(specifier, parentURL, importAttributes);
+      return this.#asyncLoaderHooks.resolve(specifier, parentURL, importAttributes, requestType);
     }
 
-    return this.resolveSync(parentURL, request);
+    return this.resolveSync(parentURL, request, false, requestType);
   }
 
   /**
@@ -732,13 +746,14 @@ class ModuleLoader {
    * @param {{isResolvedByDefaultResolve: boolean}} out Output object to track whether the default resolve was used
    *   without polluting the user-visible resolve result.
    * @param {string|URL} specifier See {@link resolveSync}.
-   * @param {{ parentURL?: string, importAttributes: ImportAttributes, conditions?: string[]}} context
-   *   See {@link resolveSync}.
+   * @param {{ parentURL?: string, importAttributes: ImportAttributes, conditions?: string[],
+   *           requestType?: 'import'|'require' }} context See {@link resolveSync}.
    * @returns {{ format: string, url: string }}
    */
   #resolveAndMaybeBlockOnLoaderThread(out, specifier, context) {
     if (this.#asyncLoaderHooks?.resolveSync) {
-      return this.#asyncLoaderHooks.resolveSync(specifier, context.parentURL, context.importAttributes);
+      return this.#asyncLoaderHooks.resolveSync(specifier, context.parentURL, context.importAttributes,
+                                                context.requestType);
     }
     out.isResolvedByDefaultResolve = true;
     return this.#cachedDefaultResolve(specifier, context);
@@ -755,28 +770,33 @@ class ModuleLoader {
    * @param {boolean} [shouldSkipSyncHooks] Whether to skip the synchronous hooks registered by module.registerHooks().
    *   This is used to maintain compatibility for the re-invented require.resolve (in imported CJS customized
    *   by module.register()`) which invokes the CJS resolution separately from the hook chain.
+   * @param {'import'|'require'} [requestType] Whether this resolve is on behalf of a `require()` call
+   *   or an `import`. Defaults to `'import'`. When `'require'`, resolution uses CJS conditions instead
+   *   of ESM defaults, matching what the CJS loader would do.
    * @returns {ResolveResult}
    */
-  resolveSync(parentURL, request, shouldSkipSyncHooks = false) {
+  resolveSync(parentURL, request, shouldSkipSyncHooks = false, requestType = 'import') {
     const specifier = `${request.specifier}`;
     const importAttributes = request.attributes ?? kEmptyObject;
     // Use an output parameter to track the state and avoid polluting the user-visible resolve results.
     const out = { isResolvedByDefaultResolve: false, __proto__: null };
+    const conditions = getConditionsForRequestType(requestType, this.#defaultConditions);
 
     let result;
     let isResolvedBySyncHooks = false;
     if (!shouldSkipSyncHooks && syncResolveHooks.length) {
       // Has module.registerHooks() hooks, chain the asynchronous hooks in the default step.
-      result = resolveWithSyncHooks(specifier, parentURL, importAttributes, this.#defaultConditions,
+      result = resolveWithSyncHooks(specifier, parentURL, importAttributes, conditions, requestType,
                                     this.#resolveAndMaybeBlockOnLoaderThread.bind(this, out));
       // If the default step ran, sync hooks did not short-circuit the resolution.
       isResolvedBySyncHooks = !out.isResolvedByDefaultResolve;
     } else {
       const context = {
         ...request,
-        conditions: this.#defaultConditions,
+        conditions,
         parentURL,
         importAttributes,
+        requestType,
         __proto__: null,
       };
       result = this.#resolveAndMaybeBlockOnLoaderThread(out, specifier, context);
@@ -840,6 +860,9 @@ class ModuleLoader {
       isSourceLoadedSynchronously: true,
       __proto__: null,
     };
+    // Default requestType to 'import' for callers (entry-point loading, etc.) that don't set it.
+    const requestType = context.requestType ?? 'import';
+    const conditions = getConditionsForRequestType(requestType, this.#defaultConditions);
     let result;
     if (syncLoadHooks.length) {
       // Has module.registerHooks() hooks, chain the asynchronous hooks in the default step.
@@ -849,7 +872,8 @@ class ModuleLoader {
         url,
         context.format,
         context.importAttributes,
-        this.#defaultConditions,
+        conditions,
+        requestType,
         this.#loadAndMaybeBlockOnLoaderThread.bind(this, out),
         validateLoadSloppy,
       );
diff --git a/lib/internal/modules/esm/translators.js b/lib/internal/modules/esm/translators.js
index c453e2b54f5957..1584378ae24aa4 100644
--- a/lib/internal/modules/esm/translators.js
+++ b/lib/internal/modules/esm/translators.js
@@ -180,7 +180,9 @@ function loadCJSModuleWithSpecialRequire(module, source, url, filename, isMain,
 
     const request = { specifier, __proto__: null, attributes: kEmptyObject };
     // Skip sync hooks in resolveSync since resolveForCJSWithHooks already ran them above.
-    const { url: resolvedURL } = cascadedLoader.resolveSync(url, request, /* shouldSkipSyncHooks */ true);
+    // This is the re-invented require.resolve() in imported CJS, so the requestType is 'require'.
+    const { url: resolvedURL } = cascadedLoader.resolveSync(
+      url, request, /* shouldSkipSyncHooks */ true, 'require');
     return urlToFilename(resolvedURL);
   });
   setOwnProperty(requireFn, 'main', process.mainModule);
diff --git a/lib/internal/modules/esm/utils.js b/lib/internal/modules/esm/utils.js
index f977bfaf57498f..8e1e200dfc034e 100644
--- a/lib/internal/modules/esm/utils.js
+++ b/lib/internal/modules/esm/utils.js
@@ -387,6 +387,19 @@ const kRequireInImportedCJS = Symbol('kRequireInImportedCJS');
  */
 const requestTypes = { kImportInImportedESM, kImportInRequiredESM, kRequireInImportedCJS };
 
+/**
+ * Convert the internal ModuleRequestType symbol into the user-facing string used as
+ * `context.requestType` on resolve and load hooks. `kRequireInImportedCJS` is the only one
+ * with `require()` semantics; `kImportInRequiredESM` is an `import` statement inside a
+ * `require()`'d ESM, which is still semantically an `import`. This matches the existing
+ * `WATCH_REPORT_DEPENDENCIES` telemetry mapping in `esm/loader.js`.
+ * @param {ModuleRequestType} requestType
+ * @returns {'import'|'require'}
+ */
+function toRequestTypeString(requestType) {
+  return requestType === kRequireInImportedCJS ? 'require' : 'import';
+}
+
 module.exports = {
   embedder_module_hdo,
   registerModule,
@@ -397,4 +410,5 @@ module.exports = {
   compileSourceTextModule,
   SourceTextModuleTypes,
   requestTypes,
+  toRequestTypeString,
 };
diff --git a/lib/internal/modules/helpers.js b/lib/internal/modules/helpers.js
index 839ce9af4bb678..1a454946f4b0db 100644
--- a/lib/internal/modules/helpers.js
+++ b/lib/internal/modules/helpers.js
@@ -112,6 +112,20 @@ function getCjsConditionsArray() {
   return cjsConditionsArray;
 }
 
+/**
+ * Get the conditions array a user hook should observe given the request type. For
+ * `'require'` requests this is the CJS conditions array (`['require', 'node', ...]`),
+ * matching what the CJS loader would pass. For `'import'` requests it is the caller's
+ * default ESM conditions (typically `['node', 'import', ...]`). The ESM defaults are
+ * passed in because they are per-loader-instance (see `ModuleLoader.#defaultConditions`).
+ * @param {'import'|'require'} requestType
+ * @param {string[]} defaultEsmConditions
+ * @returns {string[]}
+ */
+function getConditionsForRequestType(requestType, defaultEsmConditions) {
+  return requestType === 'require' ? getCjsConditionsArray() : defaultEsmConditions;
+}
+
 /**
  * Provide one of Node.js' public modules to user code.
  * @param {string} id - The identifier/specifier of the builtin module to load
@@ -522,6 +536,7 @@ module.exports = {
   getBuiltinModule,
   getCjsConditions,
   getCjsConditionsArray,
+  getConditionsForRequestType,
   getCompileCacheDir,
   initializeCjsConditions,
   loadBuiltinModuleForEmbedder,
diff --git a/test/es-module/test-esm-loader-hooks-conditions-bridge.mjs b/test/es-module/test-esm-loader-hooks-conditions-bridge.mjs
new file mode 100644
index 00000000000000..c460c7903bdd62
--- /dev/null
+++ b/test/es-module/test-esm-loader-hooks-conditions-bridge.mjs
@@ -0,0 +1,80 @@
+// Flags: --no-warnings
+
+// Regression test for nodejs/node#51327.
+//
+// When an asynchronous loader's `load` hook returns `format: 'commonjs'`, the
+// `require()` and `require.resolve()` calls inside the resulting CJS source
+// must reach the resolve hook with CJS conditions (containing 'require',
+// NOT 'import'). The original bug, confirmed by @aduh95 in
+// https://github.com/nodejs/node/issues/51327#issuecomment-1873442078, was
+// that the resolve hook received ESM conditions for those calls because the
+// load context constructed on the main thread did not carry the requestType
+// signal across the IPC to the loader worker.
+//
+// This test adapts aduh95's minimal repro.
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { execPath } from 'node:process';
+import { spawnSyncAndAssert } from '../common/child_process.js';
+
+// Loader registered as a data: URL so the test is fully self-contained.
+const loaderSource = `
+import assert from 'node:assert';
+
+export async function resolve(specifier, context, nextResolve) {
+  if (specifier === 'node:target') {
+    assert.ok(
+      context.conditions.includes('require'),
+      \`Conditions should include 'require' for require.resolve('node:target') inside async-hook-supplied CJS, got \${JSON.stringify(context.conditions)}\`,
+    );
+    assert.ok(
+      !context.conditions.includes('import'),
+      \`Conditions should not include 'import' for require.resolve('node:target') inside async-hook-supplied CJS, got \${JSON.stringify(context.conditions)}\`,
+    );
+    assert.strictEqual(
+      context.requestType,
+      'require',
+      'requestType should be "require" for require.resolve in async-hook-supplied CJS',
+    );
+  }
+  return nextResolve(specifier, context);
+}
+
+export async function load(url, context, nextLoad) {
+  if (url === 'custom:cjs') {
+    return {
+      format: 'commonjs',
+      source: 'console.log(require.resolve("node:target"))',
+      shortCircuit: true,
+    };
+  }
+  return nextLoad(url, context);
+}
+`;
+
+const loaderDataURL = `data:text/javascript,${encodeURIComponent(loaderSource)}`;
+
+const childSource = `
+import { register } from 'node:module';
+register(${JSON.stringify(loaderDataURL)});
+await import('custom:cjs');
+`;
+
+spawnSyncAndAssert(
+  execPath,
+  [
+    '--no-warnings',
+    '--input-type=module',
+    '--eval',
+    childSource,
+  ],
+  {
+    stderr: '',
+    stdout(output) {
+      // The synthetic CJS source contains console.log(require.resolve('node:target')),
+      // which should print 'node:target' to stdout after the assertions pass.
+      assert.match(output, /^node:target\s*$/m);
+    },
+  },
+);
diff --git a/test/es-module/test-esm-loader-hooks-request-type.mjs b/test/es-module/test-esm-loader-hooks-request-type.mjs
new file mode 100644
index 00000000000000..bb319ad15a98b3
--- /dev/null
+++ b/test/es-module/test-esm-loader-hooks-request-type.mjs
@@ -0,0 +1,92 @@
+// Test that asynchronous module hooks registered via `module.register()`
+// receive `context.requestType` ('import' or 'require') and a populated
+// `context.conditions` array in both resolve and load hooks. Previously the
+// async load hook received a context with no `conditions` and no signal of
+// the request type, which made composed loaders unable to distinguish
+// `import` from `require` semantics.
+//
+// The require(esm) bridge invoked from an authentic CJS `require()` on the
+// main thread is handled by the CJS loader and ESMLoader.importSyncForRequire,
+// which compile the loaded source directly without re-entering the async load
+// chain. That path is covered by test-esm-loader-hooks-conditions-bridge.mjs,
+// which arranges for the bridge call to originate from an async-hook-supplied
+// CJS source.
+//
+// Refs: https://github.com/nodejs/node/issues/51327
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { execPath } from 'node:process';
+import { fileURLToPath } from 'node:url';
+import fixtures from '../common/fixtures.js';
+import { spawnSyncAndAssert } from '../common/child_process.js';
+
+const loaderURL = fixtures.fileURL('es-module-loaders/loader-request-type.mjs');
+const esmURL = fixtures.fileURL('module-hooks/empty.mjs');
+// main.cjs requires esm.mjs (require(esm) bridge) which then statically
+// imports inner.mjs. The kImportInRequiredESM case (import inside a require()'d
+// ESM) routes through the cascaded loader and reaches the async hook.
+const requireEsmMainPath = fileURLToPath(fixtures.fileURL('module-hooks/require-esm/main.cjs'));
+
+const childSource =
+  `import { register, createRequire } from 'node:module';\n` +
+  `register(${JSON.stringify(loaderURL.href)});\n` +
+  `const require = createRequire(import.meta.url);\n` +
+  `require(${JSON.stringify(requireEsmMainPath)});\n` +
+  `await import(${JSON.stringify(esmURL.href)});\n`;
+
+spawnSyncAndAssert(
+  execPath,
+  [
+    '--no-warnings',
+    '--require-module',
+    '--input-type=module',
+    '--eval',
+    childSource,
+  ],
+  {
+    stderr: '',
+    stdout(output) {
+      const records = output.split('\n')
+        .filter((line) => line.startsWith('{'))
+        .map((line) => JSON.parse(line));
+
+      function find(predicate, label) {
+        const record = records.find(predicate);
+        assert.ok(record, `expected to find a record for ${label}\nRecords:\n${output}`);
+        return record;
+      }
+
+      // 1. import() of an ESM file: requestType 'import', ESM conditions.
+      const esmImportLoad = find(
+        (r) => r.kind === 'load' && r.url.endsWith('module-hooks/empty.mjs'),
+        'load of empty.mjs via import()');
+      assert.strictEqual(esmImportLoad.requestType, 'import');
+      assert.strictEqual(esmImportLoad.hasImportCondition, true);
+      assert.strictEqual(esmImportLoad.hasRequireCondition, false);
+
+      const esmImportResolve = find(
+        (r) => r.kind === 'resolve' && r.specifier.endsWith('module-hooks/empty.mjs'),
+        'resolve of empty.mjs via import()');
+      assert.strictEqual(esmImportResolve.requestType, 'import');
+
+      // 2. kImportInRequiredESM: inside a require()'d ESM (esm.mjs reached via
+      //    require-bridge), the static `import { esmValue } from './inner.mjs'`
+      //    routes through the cascaded loader and reaches the async hook. The
+      //    requestType should be 'import' because it is still an import.
+      const importInRequiredEsmLoad = find(
+        (r) => r.kind === 'load' && r.url.endsWith('require-esm/inner.mjs'),
+        'load of inner.mjs (import inside required ESM)');
+      assert.strictEqual(importInRequiredEsmLoad.requestType, 'import');
+      assert.strictEqual(importInRequiredEsmLoad.hasImportCondition, true);
+      assert.strictEqual(importInRequiredEsmLoad.hasRequireCondition, false);
+
+      // 3. Same for an import-of-CJS from within the required ESM: still 'import'.
+      const importOfCjsFromRequiredEsm = find(
+        (r) => r.kind === 'load' && r.url.endsWith('require-esm/cjs.cjs'),
+        'load of cjs.cjs (import of CJS inside required ESM)');
+      assert.strictEqual(importOfCjsFromRequiredEsm.requestType, 'import');
+      assert.strictEqual(importOfCjsFromRequiredEsm.hasImportCondition, true);
+    },
+  },
+);
diff --git a/test/fixtures/es-module-loaders/hooks-input.mjs b/test/fixtures/es-module-loaders/hooks-input.mjs
index e4eb159b398797..10a201f4b0ada0 100644
--- a/test/fixtures/es-module-loaders/hooks-input.mjs
+++ b/test/fixtures/es-module-loaders/hooks-input.mjs
@@ -39,9 +39,11 @@ export async function resolve(specifier, context, next) {
     'conditions',
     'importAttributes',
     'parentURL',
+    'requestType',
     'importAssertions',
   ]);
   assert.ok(Array.isArray(context.conditions));
+  assert.strictEqual(context.requestType, 'import');
   assert.strictEqual(typeof next, 'function');
 
   const returnValue = {
@@ -73,13 +75,18 @@ export async function load(url, context, next) {
   }
 
   assert.ok(new URL(url));
-  // Ensure `context` has all and only the properties it's supposed to
+  // Ensure `context` has all and only the properties it's supposed to.
+  // requestType and conditions are set by the load step; importAssertions is the deprecated alias.
   assert.deepStrictEqual(Reflect.ownKeys(context), [
     'format',
     'importAttributes',
+    'conditions',
+    'requestType',
     'importAssertions',
   ]);
   assert.strictEqual(context.format, 'test');
+  assert.strictEqual(context.requestType, 'import');
+  assert.ok(Array.isArray(context.conditions));
   assert.strictEqual(typeof next, 'function');
 
   const returnValue = {
diff --git a/test/fixtures/es-module-loaders/loader-request-type.mjs b/test/fixtures/es-module-loaders/loader-request-type.mjs
new file mode 100644
index 00000000000000..31fc82b93a92c1
--- /dev/null
+++ b/test/fixtures/es-module-loaders/loader-request-type.mjs
@@ -0,0 +1,34 @@
+// Async loader fixture for tests verifying that `context.requestType` and
+// `context.conditions` are set correctly in resolve and load hooks.
+//
+// Each call appends a JSON line to stdout describing the hook kind, the
+// specifier or url, requestType, and the relevant subset of conditions.
+
+import { writeSync } from 'node:fs';
+
+function logHook(record) {
+  writeSync(1, JSON.stringify(record) + '\n');
+}
+
+export async function resolve(specifier, context, nextResolve) {
+  logHook({
+    kind: 'resolve',
+    specifier,
+    requestType: context.requestType,
+    hasRequireCondition: Array.isArray(context.conditions) && context.conditions.includes('require'),
+    hasImportCondition: Array.isArray(context.conditions) && context.conditions.includes('import'),
+  });
+  return nextResolve(specifier, context);
+}
+
+export async function load(url, context, nextLoad) {
+  logHook({
+    kind: 'load',
+    url,
+    requestType: context.requestType,
+    format: context.format,
+    hasRequireCondition: Array.isArray(context.conditions) && context.conditions.includes('require'),
+    hasImportCondition: Array.isArray(context.conditions) && context.conditions.includes('import'),
+  });
+  return nextLoad(url, context);
+}
diff --git a/test/module-hooks/test-module-hooks-request-type-chained.js b/test/module-hooks/test-module-hooks-request-type-chained.js
new file mode 100644
index 00000000000000..a35766e50835cf
--- /dev/null
+++ b/test/module-hooks/test-module-hooks-request-type-chained.js
@@ -0,0 +1,85 @@
+'use strict';
+
+// Test that context.requestType survives a chain of module.registerHooks() hooks,
+// even when an intermediate hook calls nextResolve / nextLoad without forwarding
+// the context object explicitly. The chain runner in customization_hooks merges
+// the live context object, so the requestType set by Node should still reach
+// hooks earlier in the chain.
+
+const common = require('../common');
+const assert = require('node:assert');
+const { registerHooks } = require('node:module');
+const fixtures = require('../common/fixtures');
+
+const upstreamResolveSeen = [];
+const upstreamLoadSeen = [];
+
+// "Upstream" hook (runs LAST in the chain when iterating top-down because
+// registerHooks pushes hooks LIFO; the most recently registered runs first).
+// We register this first so it ends up at the bottom of the chain.
+const upstreamHook = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    upstreamResolveSeen.push({
+      specifier,
+      requestType: context.requestType,
+      hasRequire: context.conditions.includes('require'),
+      hasImport: context.conditions.includes('import'),
+    });
+    return nextResolve(specifier, context);
+  },
+  load(url, context, nextLoad) {
+    upstreamLoadSeen.push({
+      url,
+      requestType: context.requestType,
+      hasRequire: context.conditions.includes('require'),
+      hasImport: context.conditions.includes('import'),
+    });
+    return nextLoad(url, context);
+  },
+});
+
+// "Downstream" hook (runs FIRST). It deliberately omits the context argument
+// when calling next(): it just passes the specifier/url. The chain runner
+// should preserve the original context (including requestType) for the
+// upstream hook to observe.
+const downstreamHook = registerHooks({
+  resolve(specifier, _context, nextResolve) {
+    return nextResolve(specifier);
+  },
+  load(url, _context, nextLoad) {
+    return nextLoad(url);
+  },
+});
+
+require(fixtures.path('module-hooks', 'require-esm', 'inner.cjs'));
+
+// The upstream load hook should observe requestType and CJS conditions even
+// though the downstream hook called nextLoad(url) without forwarding context.
+const cjsLoad = upstreamLoadSeen.find((r) =>
+  r.url.endsWith('require-esm/inner.cjs'));
+assert.ok(cjsLoad, 'upstream load hook should have seen inner.cjs');
+assert.strictEqual(cjsLoad.requestType, 'require');
+assert.strictEqual(cjsLoad.hasRequire, true);
+assert.strictEqual(cjsLoad.hasImport, false);
+
+// Same for the resolve chain.
+const cjsResolve = upstreamResolveSeen.find((r) =>
+  typeof r.specifier === 'string' && r.specifier.endsWith('inner.cjs'));
+assert.ok(cjsResolve, 'upstream resolve hook should have seen inner.cjs');
+assert.strictEqual(cjsResolve.requestType, 'require');
+assert.strictEqual(cjsResolve.hasRequire, true);
+assert.strictEqual(cjsResolve.hasImport, false);
+
+(async () => {
+  await import(fixtures.fileURL('module-hooks', 'empty.mjs').href);
+
+  const importLoad = upstreamLoadSeen.find((r) =>
+    r.url.endsWith('module-hooks/empty.mjs'));
+  assert.ok(importLoad, 'upstream load hook should have seen empty.mjs');
+  assert.strictEqual(importLoad.requestType, 'import');
+  assert.strictEqual(importLoad.hasRequire, false);
+  assert.strictEqual(importLoad.hasImport, true);
+
+  downstreamHook.deregister();
+  upstreamHook.deregister();
+})().then(common.mustCall());
diff --git a/test/module-hooks/test-module-hooks-request-type-import-meta-resolve.mjs b/test/module-hooks/test-module-hooks-request-type-import-meta-resolve.mjs
new file mode 100644
index 00000000000000..5b7ca42b1e8dd6
--- /dev/null
+++ b/test/module-hooks/test-module-hooks-request-type-import-meta-resolve.mjs
@@ -0,0 +1,36 @@
+// Flags: --experimental-import-meta-resolve
+
+// Test that import.meta.resolve() invokes the resolve hook with
+// context.requestType === 'import'. This goes through the same resolveSync
+// path as require() in imported CJS but with import semantics.
+
+import '../common/index.mjs';
+import assert from 'node:assert';
+import { registerHooks } from 'node:module';
+
+const records = [];
+const hook = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    records.push({
+      specifier,
+      requestType: context.requestType,
+      hasRequire: context.conditions.includes('require'),
+      hasImport: context.conditions.includes('import'),
+    });
+    return nextResolve(specifier, context);
+  },
+});
+
+import.meta.resolve('../common/index.mjs');
+
+const record = records.find((r) =>
+  typeof r.specifier === 'string' && r.specifier.endsWith('common/index.mjs'));
+assert.ok(record, 'expected to see common/index.mjs in resolve records');
+// import.meta.resolve has import semantics; the hook should see requestType
+// 'import' and ESM conditions even though it routes through resolveSync (the
+// same function require() in imported CJS uses).
+assert.strictEqual(record.requestType, 'import');
+assert.strictEqual(record.hasImport, true);
+assert.strictEqual(record.hasRequire, false);
+
+hook.deregister();
diff --git a/test/module-hooks/test-module-hooks-request-type.js b/test/module-hooks/test-module-hooks-request-type.js
new file mode 100644
index 00000000000000..bf111ed3a4410a
--- /dev/null
+++ b/test/module-hooks/test-module-hooks-request-type.js
@@ -0,0 +1,157 @@
+// Flags: --require-module
+'use strict';
+
+// Test that synchronous module hooks (module.registerHooks) receive
+// context.requestType ('import' or 'require') in resolve and load hooks,
+// and that context.conditions is the correct set for the request type
+// (CJS conditions when requestType is 'require', ESM defaults otherwise).
+//
+// Covers the request-type matrix produced by the require-esm fixture, which
+// interleaves require() and import in both directions:
+//   - main.cjs                 : required at top-level                      -> 'require'
+//   - main.cjs requires esm.mjs: require(esm) bridge                        -> 'require'
+//   - esm.mjs imports inner.mjs: import inside require()'d ESM
+//                                (kImportInRequiredESM)                     -> 'import'
+//   - esm.mjs imports cjs.cjs  : import inside require()'d ESM of a CJS     -> 'import'
+//   - cjs.cjs requires inner.cjs: require() inside CJS reached via import   -> 'require'
+//
+// Refs: https://github.com/nodejs/node/issues/51327
+
+const common = require('../common');
+const assert = require('node:assert');
+const { registerHooks } = require('node:module');
+const fixtures = require('../common/fixtures');
+
+const records = [];
+
+const hook = registerHooks({
+  resolve(specifier, context, nextResolve) {
+    records.push({
+      kind: 'resolve',
+      specifier,
+      requestType: context.requestType,
+      conditions: context.conditions,
+    });
+    return nextResolve(specifier, context);
+  },
+  load(url, context, nextLoad) {
+    records.push({
+      kind: 'load',
+      url,
+      format: context.format,
+      requestType: context.requestType,
+      conditions: context.conditions,
+    });
+    return nextLoad(url, context);
+  },
+});
+
+function findLoadRecord(suffix) {
+  return records.find((r) => r.kind === 'load' && r.url.endsWith(suffix));
+}
+
+function assertRequireContext(record, label) {
+  assert.ok(record, `expected a record for ${label}`);
+  assert.strictEqual(record.requestType, 'require',
+                     `${label}: requestType`);
+  assert.ok(Array.isArray(record.conditions),
+            `${label}: conditions should be an array`);
+  assert.ok(record.conditions.includes('require'),
+            `${label}: conditions should include 'require', got ${JSON.stringify(record.conditions)}`);
+  assert.ok(!record.conditions.includes('import'),
+            `${label}: conditions should not include 'import', got ${JSON.stringify(record.conditions)}`);
+}
+
+function assertImportContext(record, label) {
+  assert.ok(record, `expected a record for ${label}`);
+  assert.strictEqual(record.requestType, 'import',
+                     `${label}: requestType`);
+  assert.ok(Array.isArray(record.conditions),
+            `${label}: conditions should be an array`);
+  assert.ok(record.conditions.includes('import'),
+            `${label}: conditions should include 'import', got ${JSON.stringify(record.conditions)}`);
+  assert.ok(!record.conditions.includes('require'),
+            `${label}: conditions should not include 'require', got ${JSON.stringify(record.conditions)}`);
+}
+
+// Trigger the full interleaving in one require chain.
+require(fixtures.path('module-hooks', 'require-esm', 'main.cjs'));
+
+// 1. main.cjs is required at top level -> 'require'.
+assertRequireContext(findLoadRecord('require-esm/main.cjs'),
+                     'require(main.cjs) load');
+
+// 2. main.cjs does require('./esm.mjs') -> 'require' (require(esm) bridge).
+assertRequireContext(findLoadRecord('require-esm/esm.mjs'),
+                     'require(esm.mjs) load (bridge)');
+
+// 3. esm.mjs does `import { esmValue } from './inner.mjs'` -> 'import'.
+//    This is the kImportInRequiredESM case: an import statement inside an ESM
+//    module that was reached via require(). Semantically still an import.
+assertImportContext(findLoadRecord('require-esm/inner.mjs'),
+                    'import-in-required-esm of inner.mjs load');
+
+// 4. esm.mjs does `import { cjsValue } from './cjs.cjs'` -> 'import'.
+//    Still an import statement, even though the target happens to be CJS.
+assertImportContext(findLoadRecord('require-esm/cjs.cjs'),
+                    'import-in-required-esm of cjs.cjs load');
+
+// 5. cjs.cjs does require('./inner.cjs') -> 'require'.
+//    Even though cjs.cjs was reached via an import statement, its internal
+//    require() call still has require() semantics.
+assertRequireContext(findLoadRecord('require-esm/inner.cjs'),
+                     'require(inner.cjs) inside cjs.cjs load');
+
+// Sanity check the resolve hook also saw the same requestType for each load.
+function findResolveRecord(suffix) {
+  return records.find((r) =>
+    r.kind === 'resolve' &&
+    typeof r.specifier === 'string' &&
+    r.specifier.endsWith(suffix));
+}
+
+assertRequireContext(findResolveRecord('esm.mjs'), 'resolve esm.mjs');
+assertImportContext(findResolveRecord('inner.mjs'), 'resolve inner.mjs');
+assertImportContext(findResolveRecord('cjs.cjs'), 'resolve cjs.cjs');
+assertRequireContext(findResolveRecord('inner.cjs'), 'resolve inner.cjs');
+
+hook.deregister();
+
+// Also test dynamic import() in an async block. Use a separate fixture path
+// to avoid the module cache from the require chain above.
+(async () => {
+  const records2 = [];
+  const dynHook = registerHooks({
+    resolve(specifier, context, nextResolve) {
+      records2.push({
+        kind: 'resolve',
+        specifier,
+        requestType: context.requestType,
+        conditions: context.conditions,
+      });
+      return nextResolve(specifier, context);
+    },
+    load(url, context, nextLoad) {
+      records2.push({
+        kind: 'load',
+        url,
+        requestType: context.requestType,
+        conditions: context.conditions,
+      });
+      return nextLoad(url, context);
+    },
+  });
+
+  await import(fixtures.fileURL('module-hooks', 'empty.mjs').href);
+
+  const importLoad = records2.find((r) =>
+    r.kind === 'load' && r.url.endsWith('module-hooks/empty.mjs'));
+  assertImportContext(importLoad, 'dynamic import(empty.mjs) load');
+
+  const importResolve = records2.find((r) =>
+    r.kind === 'resolve' && typeof r.specifier === 'string' &&
+    r.specifier.endsWith('module-hooks/empty.mjs'));
+  assertImportContext(importResolve, 'dynamic import(empty.mjs) resolve');
+
+  dynHook.deregister();
+})().then(common.mustCall());