diff --git a/doc/api/module.md b/doc/api/module.md
index 45e027c76155c3..ef87a2c3ce6b60 100644
--- a/doc/api/module.md
+++ b/doc/api/module.md
@@ -217,6 +217,48 @@ added: v22.8.0
 * Returns: {string|undefined} Path to the [module compile cache][] directory if it is enabled,
   or `undefined` otherwise.
 
+### `module.getPackageJSON(startLocation[, everything])`
+
+<!-- YAML
+added: REPLACEME
+-->
+
+> Stability: 1.1 - Active Development
+
+* `startLocation` {string} A fully resolved FS path or file URL to start looking
+* `everything` {boolean} Whether to return the full contents of the found package.json
+* Returns: {Object | undefined}
+  * data: {Object}
+    * name: {string | undefined}
+    * type: {string | undefined}
+    * exports: string | string\[] | Record\<string, unknown> | undefined
+    * imports: string | string\[] | Record\<string, unknown> | undefined
+    * …
+  * path: {string}
+
+Retreives the contents and location of the package.json closest to the supplied `startLocation`;
+this behaves identically to node's own lookup and consumption of package.json for a given module.
+
+```mjs
+import { getPackageJSON } from 'node:module';
+
+const somePackage = getPackageJSON(import.meta.resolve('some-package'), true);
+
+somePackage?.path; // '/…/node_modules/some-package/package.json'
+somePackage?.data.name; // 'some-package-real-name'
+somePackage?.data.types; // './index.d.ts'
+
+const thisParentPackage = getPackageJSON(import.meta.resolve('..'));
+
+thisParentPackage?.path; // '../../package.json'
+thisParentPackage?.data.type; // 'module'
+
+const thisSubPackage = getPackageJSON(import.meta.url);
+
+thisSubPackage?.path; // './package.json'
+thisSubPackage?.data.type; // 'commonjs'
+```
+
 ### `module.isBuiltin(moduleName)`
 
 <!-- YAML
diff --git a/lib/internal/modules/cjs/loader.js b/lib/internal/modules/cjs/loader.js
index 638bdb83fe74b3..3b30c51a6f304e 100644
--- a/lib/internal/modules/cjs/loader.js
+++ b/lib/internal/modules/cjs/loader.js
@@ -604,11 +604,11 @@ function trySelf(parentPath, request) {
   try {
     const { packageExportsResolve } = require('internal/modules/esm/resolve');
     return finalizeEsmResolution(packageExportsResolve(
-      pathToFileURL(pkg.path + '/package.json'), expansion, pkg.data,
+      pathToFileURL(pkg.path), expansion, pkg.data,
       pathToFileURL(parentPath), getCjsConditions()), parentPath, pkg.path);
   } catch (e) {
     if (e.code === 'ERR_MODULE_NOT_FOUND') {
-      throw createEsmNotFoundErr(request, pkg.path + '/package.json');
+      throw createEsmNotFoundErr(request, pkg.path);
     }
     throw e;
   }
@@ -1214,14 +1214,15 @@ Module._resolveFilename = function(request, parent, isMain, options) {
 
   if (request[0] === '#' && (parent?.filename || parent?.id === '<repl>')) {
     const parentPath = parent?.filename ?? process.cwd() + path.sep;
-    const pkg = packageJsonReader.getNearestParentPackageJSON(parentPath) || { __proto__: null };
-    if (pkg.data?.imports != null) {
+    const pkg = packageJsonReader.getNearestParentPackageJSON(parentPath);
+    if (pkg?.data.imports != null) {
       try {
         const { packageImportsResolve } = require('internal/modules/esm/resolve');
         return finalizeEsmResolution(
-          packageImportsResolve(request, pathToFileURL(parentPath),
-                                getCjsConditions()), parentPath,
-          pkg.path);
+          packageImportsResolve(request, pathToFileURL(parentPath), getCjsConditions()),
+          parentPath,
+          pkg.path,
+        );
       } catch (e) {
         if (e.code === 'ERR_MODULE_NOT_FOUND') {
           throw createEsmNotFoundErr(request);
@@ -1281,8 +1282,7 @@ function finalizeEsmResolution(resolved, parentPath, pkgPath) {
   if (actual) {
     return actual;
   }
-  const err = createEsmNotFoundErr(filename,
-                                   path.resolve(pkgPath, 'package.json'));
+  const err = createEsmNotFoundErr(filename, pkgPath);
   throw err;
 }
 
@@ -1614,7 +1614,7 @@ function loadTS(module, filename) {
 
     const parent = module[kModuleParent];
     const parentPath = parent?.filename;
-    const packageJsonPath = path.resolve(pkg.path, 'package.json');
+    const packageJsonPath = pkg.path;
     const usesEsm = containsModuleSyntax(content, filename);
     const err = new ERR_REQUIRE_ESM(filename, usesEsm, parentPath,
                                     packageJsonPath);
@@ -1673,7 +1673,7 @@ Module._extensions['.js'] = function(module, filename) {
       // This is an error path because `require` of a `.js` file in a `"type": "module"` scope is not allowed.
       const parent = module[kModuleParent];
       const parentPath = parent?.filename;
-      const packageJsonPath = path.resolve(pkg.path, 'package.json');
+      const packageJsonPath = pkg.path;
       const usesEsm = containsModuleSyntax(content, filename);
       const err = new ERR_REQUIRE_ESM(filename, usesEsm, parentPath,
                                       packageJsonPath);
diff --git a/lib/internal/modules/esm/resolve.js b/lib/internal/modules/esm/resolve.js
index 35925ef0817273..2bbb16dc803387 100644
--- a/lib/internal/modules/esm/resolve.js
+++ b/lib/internal/modules/esm/resolve.js
@@ -191,7 +191,7 @@ const legacyMainResolveExtensionsIndexes = {
  * 4. TRY(pkg_url/index.js, pkg_url/index.json, pkg_url/index.node)
  * 5. NOT_FOUND
  * @param {URL} packageJSONUrl
- * @param {import('typings/internalBinding/modules').PackageConfig} packageConfig
+ * @param {import('typings/internalBinding/modules').RecognizedPackageConfig} packageConfig
  * @param {string | URL | undefined} base
  * @returns {URL}
  */
diff --git a/lib/internal/modules/package_json_reader.js b/lib/internal/modules/package_json_reader.js
index 9a9dcebb799c00..2680072b50ca54 100644
--- a/lib/internal/modules/package_json_reader.js
+++ b/lib/internal/modules/package_json_reader.js
@@ -2,31 +2,49 @@
 
 const {
   ArrayIsArray,
+  ArrayPrototypeJoin,
   JSONParse,
   ObjectDefineProperty,
-  StringPrototypeLastIndexOf,
-  StringPrototypeSlice,
+  StringPrototypeEndsWith,
 } = primordials;
+const {
+  codes: {
+    ERR_INVALID_ARG_VALUE,
+  },
+} = require('internal/errors');
 const modulesBinding = internalBinding('modules');
-const { resolve, sep } = require('path');
+const path = require('path');
 const { kEmptyObject } = require('internal/util');
+const { fileURLToPath, URL } = require('internal/url');
+const {
+  validateBoolean,
+  validateString,
+} = require('internal/validators');
+
+/**
+ * @typedef {import('typings/internalBinding/modules').DeserializedPackageConfig} DeserializedPackageConfig
+ * @typedef {import('typings/internalBinding/modules').FullPackageConfig} FullPackageConfig
+ * @typedef {import('typings/internalBinding/modules').RecognizedPackageConfig} RecognizedPackageConfig
+ * @typedef {import('typings/internalBinding/modules').SerializedPackageConfig} SerializedPackageConfig
+ */
 
 /**
  * @param {string} path
- * @param {import('typings/internalBinding/modules').SerializedPackageConfig} contents
- * @returns {import('typings/internalBinding/modules').PackageConfig}
+ * @param {SerializedPackageConfig} contents
+ * @returns {DeserializedPackageConfig}
  */
 function deserializePackageJSON(path, contents) {
   if (contents === undefined) {
     return {
-      __proto__: null,
+      data: {
+        __proto__: null,
+        type: 'none', // Ignore unknown types for forwards compatibility
+      },
       exists: false,
-      pjsonPath: path,
-      type: 'none', // Ignore unknown types for forwards compatibility
+      path,
     };
   }
 
-  let pjsonPath = path;
   const {
     0: name,
     1: main,
@@ -37,36 +55,40 @@ function deserializePackageJSON(path, contents) {
   } = contents;
 
   // This is required to be used in getPackageScopeConfig.
-  if (optionalFilePath) {
-    pjsonPath = optionalFilePath;
-  }
-
-  // The imports and exports fields can be either undefined or a string.
-  // - If it's a string, it's either plain string or a stringified JSON string.
-  // - If it's a stringified JSON string, it starts with either '[' or '{'.
-  const requiresJSONParse = (value) => (value !== undefined && (value[0] === '[' || value[0] === '{'));
+  const pjsonPath = optionalFilePath ?? path;
 
   return {
-    __proto__: null,
-    exists: true,
-    pjsonPath,
-    name,
-    main,
-    type,
-    // This getters are used to lazily parse the imports and exports fields.
-    get imports() {
-      const value = requiresJSONParse(plainImports) ? JSONParse(plainImports) : plainImports;
-      ObjectDefineProperty(this, 'imports', { __proto__: null, value });
-      return this.imports;
-    },
-    get exports() {
-      const value = requiresJSONParse(plainExports) ? JSONParse(plainExports) : plainExports;
-      ObjectDefineProperty(this, 'exports', { __proto__: null, value });
-      return this.exports;
+    data: {
+      __proto__: null,
+      ...(name != null && { __proto__: null, name }),
+      ...(main != null && { __proto__: null, main }),
+      ...(type != null && { __proto__: null, type }),
+      ...(plainImports != null && {
+        // This getters are used to lazily parse the imports and exports fields.
+        get imports() {
+          const value = requiresJSONParse(plainImports) ? JSONParse(plainImports) : plainImports;
+          ObjectDefineProperty(this, 'imports', { __proto__: null, value });
+          return this.imports;
+        },
+      }),
+      ...(plainExports != null && {
+        get exports() {
+          const value = requiresJSONParse(plainExports) ? JSONParse(plainExports) : plainExports;
+          ObjectDefineProperty(this, 'exports', { __proto__: null, value });
+          return this.exports;
+        },
+      }),
     },
+    exists: true,
+    path: pjsonPath,
   };
 }
 
+// The imports and exports fields can be either undefined or a string.
+// - If it's a string, it's either plain string or a stringified JSON string.
+// - If it's a stringified JSON string, it starts with either '[' or '{'.
+const requiresJSONParse = (value) => (value !== undefined && (value[0] === '[' || value[0] === '{'));
+
 /**
  * Reads a package.json file and returns the parsed contents.
  * @param {string} jsonPath
@@ -75,7 +97,7 @@ function deserializePackageJSON(path, contents) {
  *   specifier?: URL | string,
  *   isESM?: boolean,
  * }} options
- * @returns {import('typings/internalBinding/modules').PackageConfig}
+ * @returns {RecognizedPackageConfig}
  */
 function read(jsonPath, { base, specifier, isESM } = kEmptyObject) {
   // This function will be called by both CJS and ESM, so we need to make sure
@@ -87,52 +109,97 @@ function read(jsonPath, { base, specifier, isESM } = kEmptyObject) {
     specifier == null ? undefined : `${specifier}`,
   );
 
-  return deserializePackageJSON(jsonPath, parsed);
+  const result = deserializePackageJSON(jsonPath, parsed);
+
+  return {
+    __proto__: null,
+    ...result.data,
+    exists: result.exists,
+    pjsonPath: result.path,
+  };
 }
 
 /**
  * @deprecated Expected to be removed in favor of `read` in the future.
  * Behaves the same was as `read`, but appends package.json to the path.
  * @param {string} requestPath
- * @return {PackageConfig}
+ * @return {RecognizedPackageConfig}
  */
 function readPackage(requestPath) {
   // TODO(@anonrig): Remove this function.
-  return read(resolve(requestPath, 'package.json'));
+  return read(path.resolve(requestPath, 'package.json'));
 }
 
 /**
  * Get the nearest parent package.json file from a given path.
  * Return the package.json data and the path to the package.json file, or undefined.
- * @param {string} checkPath The path to start searching from.
- * @returns {undefined | {data: import('typings/internalBinding/modules').PackageConfig, path: string}}
+ * @param {URL['href'] | URL['pathname']} startLocation The path to start searching from.
+ * @param {boolean} everything Whether to include the full contents of the package.json.
+ * @returns {undefined | DeserializedPackageConfig<everything>}
  */
-function getNearestParentPackageJSON(checkPath) {
-  const result = modulesBinding.getNearestParentPackageJSON(checkPath);
+function getNearestParentPackageJSON(startLocation, everything = false) {
+  let startPath = URL.canParse(startLocation) ? fileURLToPath(startLocation) : startLocation;
+
+  validateString(startPath, 'startPath');
+  validateBoolean(everything, 'everything');
+
+  if (!path.isAbsolute(startPath)) {
+    throw new ERR_INVALID_ARG_VALUE(
+      'startLocation',
+      startLocation,
+      ArrayPrototypeJoin([
+        'must be a fully resolved location. To use a relative location, first wrap with',
+        '`import.meta.resolve(startLocation)` in ESM',
+        'or',
+        '`path.resolve(__dirname, startLocation) in CJS',
+      ], ' '),
+    );
+  }
 
-  if (result === undefined) {
-    return undefined;
+  if (!StringPrototypeEndsWith(startPath, path.sep)) { startPath += path.sep; }
+
+  if (everything) {
+    const result = modulesBinding.getNearestRawParentPackageJSON(startPath);
+
+    return {
+      data: {
+        __proto__: null,
+        ...JSONParse(result?.[0]),
+      },
+      exists: true,
+      path: result?.[1],
+    };
   }
 
-  const data = deserializePackageJSON(checkPath, result);
+  const result = modulesBinding.getNearestParentPackageJSON(startPath);
 
-  // Path should be the root folder of the matched package.json
-  // For example for ~/path/package.json, it should be ~/path
-  const path = StringPrototypeSlice(data.pjsonPath, 0, StringPrototypeLastIndexOf(data.pjsonPath, sep));
+  if (result === undefined) {
+    return undefined;
+  }
 
-  return { data, path };
+  return deserializePackageJSON(startPath, result);
 }
 
 /**
  * Returns the package configuration for the given resolved URL.
  * @param {URL | string} resolved - The resolved URL.
- * @returns {import('typings/internalBinding/modules').PackageConfig} - The package configuration.
+ * @returns {RecognizedPackageConfig & {
+ *  exists: boolean,
+ *  pjsonPath: DeserializedPackageConfig['path'],
+ * }} - The package configuration.
  */
 function getPackageScopeConfig(resolved) {
   const result = modulesBinding.getPackageScopeConfig(`${resolved}`);
 
   if (ArrayIsArray(result)) {
-    return deserializePackageJSON(`${resolved}`, result);
+    const { data, exists, path } = deserializePackageJSON(`${resolved}`, result);
+
+    return {
+      __proto__: null,
+      ...data,
+      exists,
+      pjsonPath: path,
+    };
   }
 
   // This means that the response is a string
diff --git a/lib/module.js b/lib/module.js
index 48ba9215b081eb..c9e0a5036eaf76 100644
--- a/lib/module.js
+++ b/lib/module.js
@@ -10,6 +10,9 @@ const {
   flushCompileCache,
   getCompileCacheDir,
 } = require('internal/modules/helpers');
+const {
+  getNearestParentPackageJSON,
+} = require('internal/modules/package_json_reader');
 
 Module.findSourceMap = findSourceMap;
 Module.register = register;
@@ -19,4 +22,5 @@ Module.enableCompileCache = enableCompileCache;
 Module.flushCompileCache = flushCompileCache;
 
 Module.getCompileCacheDir = getCompileCacheDir;
+Module.getPackageJSON = getNearestParentPackageJSON;
 module.exports = Module;
diff --git a/src/node_modules.cc b/src/node_modules.cc
index dfd115a9eccc6b..e4fb240a255578 100644
--- a/src/node_modules.cc
+++ b/src/node_modules.cc
@@ -313,6 +313,30 @@ const BindingData::PackageConfig* BindingData::TraverseParent(
   return nullptr;
 }
 
+void BindingData::GetNearestRawParentPackageJSON(
+    const v8::FunctionCallbackInfo<v8::Value>& args) {
+  CHECK_GE(args.Length(), 1);
+  CHECK(args[0]->IsString());
+
+  Realm* realm = Realm::GetCurrent(args);
+  BufferValue path_value(realm->isolate(), args[0]);
+
+  // Required for long paths in Windows
+  ToNamespacedPath(realm->env(), &path_value);
+
+  auto package_json =
+      TraverseParent(realm, std::filesystem::path(path_value.ToStringView()));
+
+  if (package_json != nullptr) {
+    Local<Value> result[2] = {
+        ToV8Value(realm->context(), package_json->raw_json).ToLocalChecked(),
+        ToV8Value(realm->context(), package_json->file_path).ToLocalChecked(),
+    };
+
+    args.GetReturnValue().Set(Array::New(realm->isolate(), result, 2));
+  }
+}
+
 void BindingData::GetNearestParentPackageJSON(
     const v8::FunctionCallbackInfo<v8::Value>& args) {
   CHECK_GE(args.Length(), 1);
@@ -494,6 +518,10 @@ void BindingData::CreatePerIsolateProperties(IsolateData* isolate_data,
             target,
             "getNearestParentPackageJSON",
             GetNearestParentPackageJSON);
+  SetMethod(isolate,
+            target,
+            "getNearestRawParentPackageJSON",
+            GetNearestRawParentPackageJSON);
   SetMethod(isolate, target, "getPackageScopeConfig", GetPackageScopeConfig);
   SetMethod(isolate, target, "enableCompileCache", EnableCompileCache);
   SetMethod(isolate, target, "getCompileCacheDir", GetCompileCacheDir);
@@ -527,6 +555,7 @@ void BindingData::RegisterExternalReferences(
   registry->Register(ReadPackageJSON);
   registry->Register(GetNearestParentPackageJSONType);
   registry->Register(GetNearestParentPackageJSON);
+  registry->Register(GetNearestRawParentPackageJSON);
   registry->Register(GetPackageScopeConfig);
   registry->Register(EnableCompileCache);
   registry->Register(GetCompileCacheDir);
diff --git a/src/node_modules.h b/src/node_modules.h
index 17909b2270454b..dff2085ec4a35d 100644
--- a/src/node_modules.h
+++ b/src/node_modules.h
@@ -59,6 +59,8 @@ class BindingData : public SnapshotableObject {
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetNearestParentPackageJSONType(
       const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNearestRawParentPackageJSON(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetPackageScopeConfig(
       const v8::FunctionCallbackInfo<v8::Value>& args);
   static void GetPackageJSONScripts(
diff --git a/test/fixtures/packages/cjs-main-no-index/main.js b/test/fixtures/packages/cjs-main-no-index/main.js
new file mode 100644
index 00000000000000..888cae37af95c5
--- /dev/null
+++ b/test/fixtures/packages/cjs-main-no-index/main.js
@@ -0,0 +1 @@
+module.exports = 42;
diff --git a/test/fixtures/packages/cjs-main-no-index/other.js b/test/fixtures/packages/cjs-main-no-index/other.js
new file mode 100644
index 00000000000000..8fa48276783484
--- /dev/null
+++ b/test/fixtures/packages/cjs-main-no-index/other.js
@@ -0,0 +1,3 @@
+const answer = require('./');
+
+module.exports = answer+1;
diff --git a/test/fixtures/packages/cjs-main-no-index/package.json b/test/fixtures/packages/cjs-main-no-index/package.json
new file mode 100644
index 00000000000000..897d3f99daf7a2
--- /dev/null
+++ b/test/fixtures/packages/cjs-main-no-index/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "main-no-index",
+  "main": "./main.js",
+  "type":"commonjs"
+}
diff --git a/test/fixtures/packages/nested-types-field/index.js b/test/fixtures/packages/nested-types-field/index.js
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/test/fixtures/packages/nested-types-field/package.json b/test/fixtures/packages/nested-types-field/package.json
new file mode 100644
index 00000000000000..70b41256741ace
--- /dev/null
+++ b/test/fixtures/packages/nested-types-field/package.json
@@ -0,0 +1,9 @@
+{
+  "name": "package-with-unrecognised-fields",
+  "type": "module",
+  "exports": {
+    "default": "./index.js",
+    "types": "./index.d.ts"
+  },
+  "unrecognised": true
+}
diff --git a/test/fixtures/packages/nested/package.json b/test/fixtures/packages/nested/package.json
new file mode 100644
index 00000000000000..0ce6c71db42e8c
--- /dev/null
+++ b/test/fixtures/packages/nested/package.json
@@ -0,0 +1 @@
+{"name": "package-with-sub-package"}
diff --git a/test/fixtures/packages/nested/sub-pkg-cjs/index.js b/test/fixtures/packages/nested/sub-pkg-cjs/index.js
new file mode 100644
index 00000000000000..9db89b8bf068c8
--- /dev/null
+++ b/test/fixtures/packages/nested/sub-pkg-cjs/index.js
@@ -0,0 +1,4 @@
+const { getPackageJSON } = require('node:module');
+const { resolve } = require('node:path');
+
+module.exports = getPackageJSON(resolve(__dirname, '..'));
diff --git a/test/fixtures/packages/nested/sub-pkg-cjs/package.json b/test/fixtures/packages/nested/sub-pkg-cjs/package.json
new file mode 100644
index 00000000000000..2dec7591cd6db8
--- /dev/null
+++ b/test/fixtures/packages/nested/sub-pkg-cjs/package.json
@@ -0,0 +1 @@
+{"name": "sub-package", "type": "commonjs"}
diff --git a/test/fixtures/packages/nested/sub-pkg-mjs/index.js b/test/fixtures/packages/nested/sub-pkg-mjs/index.js
new file mode 100644
index 00000000000000..6dd75e8525d8cf
--- /dev/null
+++ b/test/fixtures/packages/nested/sub-pkg-mjs/index.js
@@ -0,0 +1,3 @@
+import { getPackageJSON } from 'node:module';
+
+export default getPackageJSON(import.meta.resolve('..'));
diff --git a/test/fixtures/packages/nested/sub-pkg-mjs/package.json b/test/fixtures/packages/nested/sub-pkg-mjs/package.json
new file mode 100644
index 00000000000000..c294ec5158824a
--- /dev/null
+++ b/test/fixtures/packages/nested/sub-pkg-mjs/package.json
@@ -0,0 +1 @@
+{"name": "sub-package", "type": "module"}
diff --git a/test/fixtures/packages/root-types-field/index.js b/test/fixtures/packages/root-types-field/index.js
new file mode 100644
index 00000000000000..e69de29bb2d1d6
diff --git a/test/fixtures/packages/root-types-field/package.json b/test/fixtures/packages/root-types-field/package.json
new file mode 100644
index 00000000000000..4af68442446dd8
--- /dev/null
+++ b/test/fixtures/packages/root-types-field/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "package-with-unrecognised-fields",
+  "type": "module",
+  "types": "./index.d.ts"
+}
diff --git a/test/parallel/test-get-package-json.js b/test/parallel/test-get-package-json.js
new file mode 100644
index 00000000000000..9ed9629674b4dc
--- /dev/null
+++ b/test/parallel/test-get-package-json.js
@@ -0,0 +1,152 @@
+'use strict';
+
+require('../common');
+const fixtures = require('../common/fixtures');
+const assert = require('assert');
+const path = require('path');
+const { getPackageJSON } = require('module');
+const { pathToFileURL } = require('url');
+
+
+{ // Throws when no arguments are provided
+  assert.throws(
+    () => getPackageJSON(),
+    { code: 'ERR_INVALID_ARG_TYPE' }
+  );
+}
+
+{ // Throw when `everything` is not a boolean
+  for (const invalid of ['', {}, [], Symbol(), 1, 0]) assert.throws(
+    () => getPackageJSON('', invalid),
+    { code: 'ERR_INVALID_ARG_TYPE' }
+  );
+}
+
+const pkgName = 'package-with-unrecognised-fields';
+const pkgType = 'module'; // a non-default value
+
+{ // Accepts a file URL (string), like from `import.meta.resolve()`
+  const pathToDir = fixtures.path('packages/root-types-field/');
+  const pkg = getPackageJSON(`${pathToFileURL(pathToDir)}`);
+
+  assert.deepStrictEqual(pkg, {
+    path: path.join(pathToDir, 'package.json'),
+    exists: true,
+    data: {
+      __proto__: null,
+      name: pkgName,
+      type: pkgType,
+    }
+  });
+}
+
+{ // Exclude unrecognised fields when `everything` is not `true`
+  const pathToDir = fixtures.path('packages/root-types-field/');
+  const pkg = getPackageJSON(pathToDir);
+
+  assert.deepStrictEqual(pkg, {
+    path: path.join(pathToDir, 'package.json'),
+    exists: true,
+    data: {
+      __proto__: null,
+      name: pkgName,
+      type: pkgType,
+    }
+  });
+}
+
+{ // Include unrecognised fields when `everything` is `true`
+  const pathToDir = fixtures.path('packages/root-types-field/');
+  const pkg = getPackageJSON(pathToDir, true);
+
+  assert.deepStrictEqual(pkg, {
+    path: path.join(pathToDir, 'package.json'),
+    exists: true,
+    data: {
+      __proto__: null,
+      name: pkgName,
+      type: pkgType,
+      types: './index.d.ts',
+    }
+  });
+}
+
+{ // Exclude unrecognised fields when `everything` is not `true`
+  const pathToDir = fixtures.path('packages/nested-types-field/');
+  const pkg = getPackageJSON(pathToDir);
+
+  assert.deepStrictEqual(pkg, {
+    path: path.join(pathToDir, 'package.json'),
+    exists: true,
+    data: {
+      __proto__: null,
+      name: pkgName,
+      type: pkgType,
+      exports: {
+        default: './index.js',
+        types: './index.d.ts', // I think this is unexpected?
+      },
+    },
+  });
+}
+
+{ // Include unrecognised fields when `everything` is not `true`
+  const pathToDir = fixtures.path('packages/nested-types-field/');
+  const pkg = getPackageJSON(pathToDir, true);
+
+  assert.deepStrictEqual(pkg, {
+    path: path.join(pathToDir, 'package.json'),
+    exists: true,
+    data: {
+      __proto__: null,
+      name: pkgName,
+      type: pkgType,
+      exports: {
+        default: './index.js',
+        types: './index.d.ts', // I think this is unexpected?
+      },
+      unrecognised: true,
+    },
+  });
+}
+
+{ // Throws on unresolved location
+  let err;
+  try {
+    getPackageJSON('..');
+  } catch (e) {
+    err = e;
+  }
+
+  assert.strictEqual(err.code, 'ERR_INVALID_ARG_VALUE');
+  assert.match(err.message, /fully resolved/);
+  assert.match(err.message, /relative/);
+  assert.match(err.message, /import\.meta\.resolve/);
+  assert.match(err.message, /path\.resolve\(__dirname/);
+}
+
+{ // Can crawl up (CJS)
+  const pathToMod = fixtures.path('packages/nested/sub-pkg-cjs/index.js');
+  const parentPkg = require(pathToMod);
+
+  assert.strictEqual(parentPkg.data.name, 'package-with-sub-package');
+  const pathToParent = fixtures.path('packages/nested/package.json');
+  assert.strictEqual(parentPkg.path, pathToParent);
+}
+
+{ // Can crawl up (ESM)
+  const pathToMod = fixtures.path('packages/nested/sub-pkg-mjs/index.js');
+  const parentPkg = require(pathToMod).default;
+
+  assert.strictEqual(parentPkg.data.name, 'package-with-sub-package');
+  const pathToParent = fixtures.path('packages/nested/package.json');
+  assert.strictEqual(parentPkg.path, pathToParent);
+}
+
+{ // Can require via package.json
+  const pathToMod = fixtures.path('packages/cjs-main-no-index/other.js');
+  // require() falls back to package.json values like "main" to resolve when there is no index
+  const answer = require(pathToMod);
+
+  assert.strictEqual(answer, 43);
+}
diff --git a/typings/internalBinding/modules.d.ts b/typings/internalBinding/modules.d.ts
index b9aa518abde337..ba50cddb0e2e42 100644
--- a/typings/internalBinding/modules.d.ts
+++ b/typings/internalBinding/modules.d.ts
@@ -1,26 +1,33 @@
 export type PackageType = 'commonjs' | 'module' | 'none'
-export type PackageConfig = {
-  pjsonPath: string
-  exists: boolean
+export type RecognizedPackageConfig = {
   name?: string
   main?: any
   type: PackageType
   exports?: string | string[] | Record<string, unknown>
   imports?: string | string[] | Record<string, unknown>
 }
+export type FullPackageConfig = RecognizedPackageConfig & {
+  [key: string]: unknown,
+}
+export type DeserializedPackageConfig<everything = false> = {
+  data: everything extends true ? FullPackageConfig : RecognizedPackageConfig,
+  exists: boolean,
+  path: URL['pathname'],
+}
 export type SerializedPackageConfig = [
-  PackageConfig['name'],
-  PackageConfig['main'],
-  PackageConfig['type'],
+  RecognizedPackageConfig['name'],
+  RecognizedPackageConfig['main'],
+  RecognizedPackageConfig['type'],
   string | undefined, // exports
   string | undefined, // imports
-  string | undefined, // raw json available for experimental policy
+  DeserializedPackageConfig['path'], // pjson file path
 ]
 
 export interface ModulesBinding {
   readPackageJSON(path: string): SerializedPackageConfig | undefined;
-  getNearestParentPackageJSON(path: string): PackageConfig | undefined
-  getNearestParentPackageJSONType(path: string): PackageConfig['type']
+  getNearestParentPackageJSON(path: string): SerializedPackageConfig | undefined
+  getNearestRawParentPackageJSON(origin: URL['pathname']): [ReturnType<JSON['stringify']>, DeserializedPackageConfig['path']] | undefined
+  getNearestParentPackageJSONType(path: string): RecognizedPackageConfig['type']
   getPackageScopeConfig(path: string): SerializedPackageConfig | undefined
   getPackageJSONScripts(): string | undefined
 }