diff --git a/benchmark/util/inspect-object.js b/benchmark/util/inspect-object.js
new file mode 100644
index 000000000000..8a6e4dda8b35
--- /dev/null
+++ b/benchmark/util/inspect-object.js
@@ -0,0 +1,31 @@
+'use strict';
+
+const common = require('../common');
+const util = require('util');
+
+const bench = common.createBenchmark(main, {
+  n: [1e3],
+  len: [1e2, 1e4],
+  maxObjectProperties: [0, 10, 100, Infinity],
+  showHidden: [0, 1],
+});
+
+function main({ n, len, maxObjectProperties, showHidden }) {
+  const prototype = {};
+  const object = { __proto__: prototype };
+  for (let i = 0; i < len; i++) {
+    object[`property${i}`] = { value: i };
+    prototype[`prototypeProperty${i}`] = { value: i };
+  }
+
+  const options = {
+    maxObjectProperties,
+    showHidden: showHidden === 1,
+  };
+
+  bench.start();
+  for (let i = 0; i < n; i++) {
+    util.inspect(object, options);
+  }
+  bench.end(n);
+}
diff --git a/doc/api/util.md b/doc/api/util.md
index db574ab57461..2ea7adccddd3 100644
--- a/doc/api/util.md
+++ b/doc/api/util.md
@@ -911,6 +911,9 @@ stream.write('With ES6');
 <!-- YAML
 added: v0.3.0
 changes:
+  - version: REPLACEME
+    pr-url: https://github.com/nodejs/node/pull/65242
+    description: The `maxObjectProperties` option is supported now.
   - version:
     - v25.0.0
     pr-url: https://github.com/nodejs/node/pull/59710
@@ -1023,6 +1026,14 @@ changes:
     {TypedArray}, {Map}, {WeakMap}, and {WeakSet} elements to include when formatting.
     Set to `null` or `Infinity` to show all elements. Set to `0` or
     negative to show no elements. **Default:** `100`.
+  * `maxObjectProperties` {integer} Specifies the maximum number of named
+    properties per inspected value. Own string and symbol properties are
+    included before user-defined prototype properties. Content governed by
+    `maxArrayLength` and built-in metadata entries such as `[byteLength]`,
+    `[buffer]`, and `[BYTES_PER_ELEMENT]` do not count. The limit is applied
+    before `sorted`.
+    Set to `null` or `Infinity` to show all properties. Set to `0` or negative
+    to show no properties. **Default:** `Infinity`.
   * `maxStringLength` {integer} Specifies the maximum number of characters to
     include when formatting. Set to `null` or `Infinity` to show all elements.
     Set to `0` or negative to show no characters. **Default:** `10000`.
diff --git a/lib/internal/assert/assertion_error.js b/lib/internal/assert/assertion_error.js
index 5dbf1e7a3413..3cc8fb0f6ea8 100644
--- a/lib/internal/assert/assertion_error.js
+++ b/lib/internal/assert/assertion_error.js
@@ -77,6 +77,7 @@ function inspectValue(val) {
     customInspect: false,
     depth: 1000,
     maxArrayLength: Infinity,
+    maxObjectProperties: Infinity,
     // Assert compares only enumerable properties (with a few exceptions).
     showHidden: false,
     // Assert does not detect proxies currently.
diff --git a/lib/internal/util/inspect.js b/lib/internal/util/inspect.js
index 193ae8524632..6cc23b857c7b 100644
--- a/lib/internal/util/inspect.js
+++ b/lib/internal/util/inspect.js
@@ -14,7 +14,6 @@ const {
   ArrayPrototypeIndexOf,
   ArrayPrototypeJoin,
   ArrayPrototypeMap,
-  ArrayPrototypePop,
   ArrayPrototypePush,
   ArrayPrototypePushApply,
   ArrayPrototypeSlice,
@@ -227,6 +226,7 @@ const inspectDefaultOptions = ObjectSeal({
   customInspect: true,
   showProxy: false,
   maxArrayLength: 100,
+  maxObjectProperties: Infinity,
   maxStringLength: 10000,
   breakLength: 80,
   compact: 3,
@@ -305,6 +305,7 @@ function getUserOptions(ctx, isCrossContext) {
     customInspect: ctx.customInspect,
     showProxy: ctx.showProxy,
     maxArrayLength: ctx.maxArrayLength,
+    maxObjectProperties: ctx.maxObjectProperties,
     maxStringLength: ctx.maxStringLength,
     breakLength: ctx.breakLength,
     compact: ctx.compact,
@@ -365,6 +366,7 @@ function inspect(value, opts) {
     customInspect: inspectDefaultOptions.customInspect,
     showProxy: inspectDefaultOptions.showProxy,
     maxArrayLength: inspectDefaultOptions.maxArrayLength,
+    maxObjectProperties: inspectDefaultOptions.maxObjectProperties,
     maxStringLength: inspectDefaultOptions.maxStringLength,
     breakLength: inspectDefaultOptions.breakLength,
     compact: inspectDefaultOptions.compact,
@@ -405,6 +407,7 @@ function inspect(value, opts) {
   }
   if (ctx.colors) ctx.stylize = stylizeWithColor;
   if (ctx.maxArrayLength === null) ctx.maxArrayLength = Infinity;
+  if (ctx.maxObjectProperties === null) ctx.maxObjectProperties = Infinity;
   if (ctx.maxStringLength === null) ctx.maxStringLength = Infinity;
   return formatValue(ctx, value, 0);
 }
@@ -914,8 +917,7 @@ function getConstructorName(obj, ctx, recurseTimes, protoProps) {
       const { name, constructor } = wellKnownPrototypeNameAndConstructor;
       if (FunctionPrototypeSymbolHasInstance(constructor, tmp)) {
         if (protoProps !== undefined && firstProto !== obj) {
-          addPrototypeProperties(
-            ctx, tmp, firstProto || tmp, recurseTimes, protoProps);
+          addPrototypeProperties(tmp, firstProto || tmp, protoProps);
         }
         return name;
       }
@@ -928,8 +930,7 @@ function getConstructorName(obj, ctx, recurseTimes, protoProps) {
       if (protoProps !== undefined &&
          (firstProto !== obj ||
          !builtInObjects.has(descriptor.value.name))) {
-        addPrototypeProperties(
-          ctx, tmp, firstProto || tmp, recurseTimes, protoProps);
+        addPrototypeProperties(tmp, firstProto || tmp, protoProps);
       }
       return String(descriptor.value.name);
     }
@@ -964,10 +965,9 @@ function getConstructorName(obj, ctx, recurseTimes, protoProps) {
   return `${res} <${protoConstr}>`;
 }
 
-// This function has the side effect of adding prototype properties to the
-// `output` argument (which is an array). This is intended to highlight user
-// defined prototype properties.
-function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
+// Collect user defined prototype properties. They are formatted later so a
+// property limit can discard them without inspecting their values.
+function addPrototypeProperties(main, obj, output) {
   let depth = 0;
   let keys;
   let keySet;
@@ -994,7 +994,6 @@ function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
     }
     // Get all own property names and symbols.
     keys = ReflectOwnKeys(obj);
-    ArrayPrototypePush(ctx.seen, main);
     for (const key of keys) {
       // Ignore the `constructor` property and keys that exist on layers above.
       if (key === 'constructor' ||
@@ -1006,22 +1005,41 @@ function addPrototypeProperties(ctx, main, obj, recurseTimes, output) {
       if (typeof desc.value === 'function') {
         continue;
       }
-      const value = formatProperty(
-        ctx, obj, recurseTimes, key, kObjectType, desc, main);
-      if (ctx.colors) {
-        // Faint!
-        ArrayPrototypePush(output, `\u001b[2m${value}\u001b[22m`);
-      } else {
-        ArrayPrototypePush(output, value);
-      }
+      ArrayPrototypePush(output, [obj, key, desc]);
     }
-    ArrayPrototypePop(ctx.seen);
   // Limit the inspection to up to three prototype layers. Using `recurseTimes`
   // is not a good choice here, because it's as if the properties are declared
   // on the current object from the users perspective.
   } while (++depth !== 3);
 }
 
+function truncateProperties(properties, limit) {
+  // A NaN limit leaves `properties` untouched.
+  if (!(properties.length > limit)) {
+    return 0;
+  }
+  const omitted = properties.length - limit;
+  properties.length = limit;
+  return omitted;
+}
+
+// Discards properties beyond `ctx.maxObjectProperties`, retaining own
+// properties before prototype properties. Property candidates have already
+// been collected, so this limits formatting rather than enumeration. Returns
+// the number omitted.
+function limitProperties(ctx, keys, protoProps) {
+  if (ctx.maxObjectProperties === Infinity) {
+    return 0;
+  }
+  // Assigning to `array.length` requires an integral value.
+  const budget = MathTrunc(MathMax(0, ctx.maxObjectProperties));
+  let omitted = truncateProperties(keys, budget);
+  if (protoProps !== undefined) {
+    omitted += truncateProperties(protoProps, budget - keys.length);
+  }
+  return omitted;
+}
+
 /** @type {(constructor: string, tag: string, fallback: string, size?: string) => string} */
 function getPrefix(constructor, tag, fallback, size = '') {
   if (constructor === null) {
@@ -1422,9 +1440,26 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       constructorName = `[${constructorName}]`;
     return ctx.stylize(constructorName, 'special');
   }
+
+  // This must run after type-specific key normalization and empty-value fast
+  // paths. It must not move into getKeys().
+  const remainingProperties = limitProperties(ctx, keys, protoProps);
+
+  const protoRecurseTimes = recurseTimes;
   recurseTimes += 1;
 
   ctx.seen.push(value);
+  let formattedProtoProps;
+  if (protoProps !== undefined) {
+    formattedProtoProps = new Array(protoProps.length);
+    for (i = 0; i < protoProps.length; i++) {
+      const { 0: obj, 1: key, 2: desc } = protoProps[i];
+      const formatted = formatProperty(
+        ctx, obj, protoRecurseTimes, key, kObjectType, desc, value);
+      formattedProtoProps[i] =
+        ctx.colors ? `\u001b[2m${formatted}\u001b[22m` : formatted;
+    }
+  }
   ctx.currentDepth = recurseTimes;
   let output;
   const indentationLvl = ctx.indentationLvl;
@@ -1448,8 +1483,8 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
         formatProperty(ctx, value, recurseTimes, keys[i], extrasType),
       );
     }
-    if (protoProps !== undefined) {
-      ArrayPrototypePushApply(output, protoProps);
+    if (formattedProtoProps !== undefined) {
+      ArrayPrototypePushApply(output, formattedProtoProps);
     }
   } catch (err) {
     if (!isStackOverflowError(err)) throw err;
@@ -1480,9 +1515,16 @@ function formatRaw(ctx, value, recurseTimes, typedArray) {
       ReflectApply(ArrayPrototypeSplice, null, sorted);
     }
   }
+  if (remainingProperties > 0) {
+    ArrayPrototypePush(
+      output,
+      remainingText(remainingProperties, 'property', 'properties'),
+    );
+  }
 
   const res = reduceToSingleString(
-    ctx, output, base, braces, extrasType, recurseTimes, value);
+    ctx, output, base, braces, extrasType, recurseTimes, value,
+    remainingProperties > 0 ? 1 : 0);
   const budget = ctx.budget[ctx.indentationLvl] || 0;
   const newLength = budget + res.length;
   ctx.budget[ctx.indentationLvl] = newLength;
@@ -2048,12 +2090,15 @@ function formatError(err, constructor, tag, ctx, keys) {
   return stack;
 }
 
-function groupArrayElements(ctx, output, value) {
+// `trailingEntries` counts entries at the end of `output` that describe omitted
+// content rather than real entries. They must not take part in grouping.
+function groupArrayElements(ctx, output, value, trailingEntries) {
   let totalLength = 0;
   let maxLength = 0;
   let i = 0;
-  let outputLength = output.length;
-  if (ctx.maxArrayLength < output.length) {
+  const outputLengthWithoutTrailing = output.length - trailingEntries;
+  let outputLength = outputLengthWithoutTrailing;
+  if (ctx.maxArrayLength < outputLengthWithoutTrailing) {
     // This makes sure the "... n more items" part is not taken into account.
     outputLength--;
   }
@@ -2080,7 +2125,8 @@ function groupArrayElements(ctx, output, value) {
       (totalLength / actualMax > 5 || maxLength <= 6)) {
 
     const approxCharHeights = 2.5;
-    const averageBias = MathSqrt(actualMax - totalLength / output.length);
+    const averageBias =
+      MathSqrt(actualMax - totalLength / outputLengthWithoutTrailing);
     const biasedMax = MathMax(actualMax - 3 - averageBias, 1);
     // Dynamically check how many columns seem possible.
     const columns = MathMin(
@@ -2110,7 +2156,7 @@ function groupArrayElements(ctx, output, value) {
     const maxLineLength = [];
     for (let i = 0; i < columns; i++) {
       let lineMaxLength = 0;
-      for (let j = i; j < output.length; j += columns) {
+      for (let j = i; j < outputLengthWithoutTrailing; j += columns) {
         if (dataLen[j] > lineMaxLength)
           lineMaxLength = dataLen[j];
       }
@@ -2119,7 +2165,7 @@ function groupArrayElements(ctx, output, value) {
     }
     let order = StringPrototypePadStart;
     if (value !== undefined) {
-      for (let i = 0; i < output.length; i++) {
+      for (let i = 0; i < outputLengthWithoutTrailing; i++) {
         if (typeof value[i] !== 'number' && typeof value[i] !== 'bigint') {
           order = StringPrototypePadEnd;
           break;
@@ -2150,9 +2196,12 @@ function groupArrayElements(ctx, output, value) {
       }
       ArrayPrototypePush(tmp, str);
     }
-    if (ctx.maxArrayLength < output.length) {
+    if (ctx.maxArrayLength < outputLengthWithoutTrailing) {
       ArrayPrototypePush(tmp, output[outputLength]);
     }
+    for (let i = outputLengthWithoutTrailing; i < output.length; i++) {
+      ArrayPrototypePush(tmp, output[i]);
+    }
     output = tmp;
   }
   return output;
@@ -2192,7 +2241,8 @@ function addNumericSeparatorEnd(integerString) {
     `${result}${StringPrototypeSlice(integerString, i)}`;
 }
 
-const remainingText = (remaining) => `... ${remaining} more item${remaining > 1 ? 's' : ''}`;
+const remainingText = (remaining, singular = 'item', plural = 'items') =>
+  `... ${remaining} more ${remaining > 1 ? plural : singular}`;
 
 function formatNumber(fn, number, numericSeparator) {
   // Format -0 as '-0'. Checking `number === -0` won't distinguish 0 from -0.
@@ -2642,7 +2692,8 @@ function isBelowBreakLength(ctx, output, start, base) {
 }
 
 function reduceToSingleString(
-  ctx, output, base, braces, extrasType, recurseTimes, value) {
+  ctx, output, base, braces, extrasType, recurseTimes, value,
+  trailingEntries = 0) {
   if (ctx.compact !== true) {
     if (typeof ctx.compact === 'number' && ctx.compact >= 1) {
       // Memorize the original output length. In case the output is grouped,
@@ -2651,7 +2702,7 @@ function reduceToSingleString(
       // Group array elements together if the array contains at least six
       // separate entries.
       if (extrasType === kArrayExtrasType && entries > 6) {
-        output = groupArrayElements(ctx, output, value);
+        output = groupArrayElements(ctx, output, value, trailingEntries);
       }
       // `ctx.currentDepth` is set to the most inner depth of the currently
       // inspected object part while `recurseTimes` is the actual current depth
diff --git a/test/parallel/test-assert-deep.js b/test/parallel/test-assert-deep.js
index f7aded0d9aca..ca0af653d03c 100644
--- a/test/parallel/test-assert-deep.js
+++ b/test/parallel/test-assert-deep.js
@@ -1170,6 +1170,26 @@ test('Check proxies', () => {
   );
 });
 
+test('Assertion errors ignore the maxObjectProperties default', () => {
+  const original = util.inspect.defaultOptions.maxObjectProperties;
+  util.inspect.defaultOptions.maxObjectProperties = 1;
+  try {
+    assert.throws(
+      () => assert.deepStrictEqual({ a: 1, b: 2 }, { a: 1, b: 3 }),
+      {
+        message: `${defaultMsgStartFull}\n\n` +
+          '  {\n' +
+          '    a: 1,\n' +
+          '+   b: 2\n' +
+          '-   b: 3\n' +
+          '  }\n'
+      }
+    );
+  } finally {
+    util.inspect.defaultOptions.maxObjectProperties = original;
+  }
+});
+
 test('Strict equal with identical objects that are not identical ' +
      'by reference and longer than 50 elements', () => {
   // E.g., assert.deepStrictEqual({ a: Symbol() }, { a: Symbol() })
diff --git a/test/parallel/test-repl-inspect-defaults.js b/test/parallel/test-repl-inspect-defaults.js
index 599c973a53db..04767c893da9 100644
--- a/test/parallel/test-repl-inspect-defaults.js
+++ b/test/parallel/test-repl-inspect-defaults.js
@@ -17,6 +17,9 @@ child.on('exit', common.mustCall(() => {
     results,
     [
       '[ 42, 23 ]',
+      '{ first: 1, second: 2 }',
+      '1',
+      '{ first: 1, ... 1 more property }',
       '1',
       '[ 42, ... 1 more item ]',
       '',
@@ -25,6 +28,9 @@ child.on('exit', common.mustCall(() => {
 }));
 
 child.stdin.write('[ 42, 23 ]\n');
+child.stdin.write('({ first: 1, second: 2 })\n');
+child.stdin.write('util.inspect.replDefaults.maxObjectProperties = 1\n');
+child.stdin.write('({ first: 1, second: 2 })\n');
 child.stdin.write('util.inspect.replDefaults.maxArrayLength = 1\n');
 child.stdin.write('[ 42, 23 ]\n');
 child.stdin.end();
diff --git a/test/parallel/test-util-inspect-namespace.js b/test/parallel/test-util-inspect-namespace.js
index 244166f38198..9f64209d4b06 100644
--- a/test/parallel/test-util-inspect-namespace.js
+++ b/test/parallel/test-util-inspect-namespace.js
@@ -12,9 +12,17 @@ const { inspect } = require('util');
   assert.strictEqual(
     inspect(m.namespace),
     '[Module: null prototype] { a: <uninitialized>, b: undefined }');
+  assert.strictEqual(
+    inspect(m.namespace, { maxObjectProperties: 1 }),
+    '[Module: null prototype] { a: <uninitialized>, ... 1 more property }'
+  );
   await m.evaluate();
   assert.strictEqual(
     inspect(m.namespace),
     '[Module: null prototype] { a: 1, b: 2 }'
   );
+  assert.strictEqual(
+    inspect(m.namespace, { maxObjectProperties: 0 }),
+    '[Module: null prototype] { ... 2 more properties }'
+  );
 })().then(common.mustCall());
diff --git a/test/parallel/test-util-inspect.js b/test/parallel/test-util-inspect.js
index 1e305f0a45fb..363d86534956 100644
--- a/test/parallel/test-util-inspect.js
+++ b/test/parallel/test-util-inspect.js
@@ -1063,6 +1063,7 @@ util.inspect({ hasOwnProperty: null });
     assert.strictEqual(opts.budget, undefined);
     assert.strictEqual(opts.indentationLvl, undefined);
     assert.strictEqual(opts.showHidden, false);
+    assert.strictEqual(opts.maxObjectProperties, Infinity);
     assert.strictEqual(inspect, util.inspect);
     assert.deepStrictEqual(
       new Set(Object.keys(inspect.defaultOptions).concat(['stylize'])),
@@ -1599,6 +1600,318 @@ if (typeof Symbol !== 'undefined') {
   assert(util.inspect(x, { maxArrayLength: Infinity }).endsWith(' 0, 0\n]'));
 }
 
+// maxObjectProperties limits named properties independently for each object.
+{
+  const value = { first: 1, second: 2, third: 3 };
+  const unlimited = '{ first: 1, second: 2, third: 3 }';
+
+  assert.strictEqual(util.inspect(value), unlimited);
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: 2 }),
+    '{ first: 1, second: 2, ... 1 more property }'
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: 1 }),
+    '{ first: 1, ... 2 more properties }'
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: 0 }),
+    '{ ... 3 more properties }'
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: 0.5 }),
+    '{ ... 3 more properties }'
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: -1 }),
+    '{ ... 3 more properties }'
+  );
+  assert.strictEqual(
+    util.inspect({ only: 1 }, { maxObjectProperties: 0 }),
+    '{ ... 1 more property }'
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: null }),
+    unlimited
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: Infinity }),
+    unlimited
+  );
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: NaN }),
+    unlimited
+  );
+
+  assert.strictEqual(
+    util.inspect(
+      { outer: { first: 1, second: 2 }, sibling: 3 },
+      { maxObjectProperties: 1 }
+    ),
+    '{ outer: { first: 1, ... 1 more property }, ... 1 more property }'
+  );
+}
+
+// Array-like entries and collection entries use maxArrayLength, while named
+// properties use maxObjectProperties.
+{
+  const array = [1, 2];
+  array.first = 3;
+  array.second = 4;
+  assert.strictEqual(
+    util.inspect(array, { maxArrayLength: 1, maxObjectProperties: 1 }),
+    '[ 1, ... 1 more item, first: 3, ... 1 more property ]'
+  );
+
+  // The default grouping behavior must not change when the property limit is
+  // inactive.
+  const arrayWithProperty = Array.from({ length: 20 }, (_, i) => i);
+  arrayWithProperty.p0 = 0;
+  assert.strictEqual(
+    util.inspect(arrayWithProperty, { maxArrayLength: 20 }),
+    '[\n' +
+      '  0,  1,  2,  3,  4,  5,  6,\n' +
+      '  7,  8,  9,  10, 11, 12, 13,\n' +
+      '  14, 15, 16, 17, 18, 19,\n' +
+      '  p0: 0\n' +
+      ']'
+  );
+
+  const truncatedArrayWithProperties = Array.from(
+    { length: 20 },
+    (_, i) => i,
+  );
+  truncatedArrayWithProperties.foo = 1;
+  truncatedArrayWithProperties.bar = 2;
+  assert.strictEqual(
+    util.inspect(truncatedArrayWithProperties, { maxArrayLength: 10 }),
+    '[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ... 10 more items, ' +
+      'foo: 1, bar: 2 ]'
+  );
+
+  const groupedArray = Array.from({ length: 10 }, (_, i) => i);
+  groupedArray.extra = true;
+  assert.match(
+    util.inspect(groupedArray, {
+      maxObjectProperties: 0,
+      showHidden: true,
+    }),
+    /\n {2}\.\.\. 2 more properties\n\]$/
+  );
+
+  const truncatedGroupedArray = Array.from({ length: 20 }, (_, i) => i);
+  truncatedGroupedArray.extra = true;
+  assert.strictEqual(
+    util.inspect(truncatedGroupedArray, {
+      maxArrayLength: 10,
+      maxObjectProperties: 0,
+    }),
+    '[\n' +
+      '  0, 1, 2, 3, 4,\n' +
+      '  5, 6, 7, 8, 9,\n' +
+      '  ... 10 more items,\n' +
+      '  ... 1 more property\n' +
+      ']'
+  );
+
+  const truncatedArrayWithProperty = Array.from(
+    { length: 20 },
+    (_, i) => i,
+  );
+  truncatedArrayWithProperty.p0 = 0;
+  truncatedArrayWithProperty.p1 = 1;
+  truncatedArrayWithProperty.p2 = 2;
+  assert.strictEqual(
+    util.inspect(truncatedArrayWithProperty, {
+      maxArrayLength: 10,
+      maxObjectProperties: 1,
+    }),
+    '[\n' +
+      '  0,\n' +
+      '  1,\n' +
+      '  2,\n' +
+      '  3,\n' +
+      '  4,\n' +
+      '  5,\n' +
+      '  6,\n' +
+      '  7,\n' +
+      '  8,\n' +
+      '  9,\n' +
+      '  ... 10 more items,\n' +
+      '  p0: 0,\n' +
+      '  ... 2 more properties\n' +
+      ']'
+  );
+
+  const typedArray = new Uint8Array([1, 2]);
+  typedArray.first = 3;
+  typedArray.second = 4;
+  assert.strictEqual(
+    util.inspect(typedArray, {
+      maxArrayLength: 1,
+      maxObjectProperties: 1,
+    }),
+    'Uint8Array(2) [ 1, ... 1 more item, first: 3, ... 1 more property ]'
+  );
+
+  const map = new Map([['first', 1], ['second', 2]]);
+  map.first = 3;
+  map.second = 4;
+  assert.strictEqual(
+    util.inspect(map, { maxArrayLength: 1, maxObjectProperties: 1 }),
+    "Map(2) { 'first' => 1, ... 1 more item, first: 3, " +
+      '... 1 more property }'
+  );
+
+  const set = new Set([1, 2]);
+  set.first = 3;
+  set.second = 4;
+  assert.strictEqual(
+    util.inspect(set, { maxArrayLength: 1, maxObjectProperties: 1 }),
+    'Set(2) { 1, ... 1 more item, first: 3, ... 1 more property }'
+  );
+
+  const promise = Promise.resolve(1);
+  promise.property = 2;
+  assert.strictEqual(
+    util.inspect(promise, { maxObjectProperties: 0 }),
+    'Promise { 1, ... 1 more property }'
+  );
+}
+
+// Hidden, symbol, and user-defined prototype properties share the property
+// budget, with own properties taking precedence.
+{
+  class Foo {}
+  Object.defineProperty(Foo.prototype, 'inherited', {
+    configurable: true,
+    enumerable: true,
+    value: 4,
+  });
+  Object.defineProperty(Foo.prototype, 'hiddenInherited', {
+    configurable: true,
+    value: 5,
+  });
+
+  const symbol = Symbol('own');
+  const value = new Foo();
+  value.own = 1;
+  Object.defineProperty(value, 'hidden', { value: 2 });
+  value[symbol] = 3;
+
+  assert.strictEqual(
+    util.inspect(value, { showHidden: true, maxObjectProperties: 3 }),
+    'Foo { own: 1, [hidden]: 2, Symbol(own): 3, ... 2 more properties }'
+  );
+  assert.strictEqual(
+    util.inspect(value, { showHidden: true, maxObjectProperties: 4 }),
+    'Foo {\n' +
+      '  own: 1,\n' +
+      '  [hidden]: 2,\n' +
+      '  Symbol(own): 3,\n' +
+      '  inherited: 4,\n' +
+      '  ... 1 more property\n' +
+      '}'
+  );
+
+  const farPrototype = { far: 1 };
+  const nearPrototype = { __proto__: farPrototype, near: 2 };
+  assert.strictEqual(
+    util.inspect({ __proto__: nearPrototype }, {
+      maxObjectProperties: 1,
+      showHidden: true,
+    }),
+    '{ near: 2, ... 1 more property }'
+  );
+}
+
+// Omitted values and getters are not evaluated.
+{
+  const value = {
+    retained: 1,
+    omitted: { [util.inspect.custom]: common.mustNotCall() },
+  };
+  Object.defineProperty(value, 'getter', {
+    enumerable: true,
+    get: common.mustNotCall(),
+  });
+  assert.strictEqual(
+    util.inspect(value, { getters: true, maxObjectProperties: 1 }),
+    '{ retained: 1, ... 2 more properties }'
+  );
+
+  class WithGetter {
+    get omittedPrototypeGetter() {
+      return common.mustNotCall()();
+    }
+  }
+  const withGetter = new WithGetter();
+  withGetter.retained = 1;
+  assert.strictEqual(
+    util.inspect(withGetter, {
+      getters: true,
+      maxObjectProperties: 1,
+      showHidden: true,
+    }),
+    'WithGetter { retained: 1, ... 1 more property }'
+  );
+}
+
+// Sorting applies after discovery and limiting.
+{
+  const value = {};
+  value.z = 1;
+  value.a = 2;
+  value.m = 3;
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: 2, sorted: true }),
+    '{ a: 2, z: 1, ... 1 more property }'
+  );
+}
+
+// Property limiting happens after type-specific key normalization.
+{
+  const boxed = new String('abc');
+  boxed.extra = true;
+  assert.strictEqual(
+    util.inspect(boxed, { maxObjectProperties: 1 }),
+    "[String: 'abc'] { extra: true }"
+  );
+
+  const error = new Error('boom', { cause: 'root' });
+  const output = util.inspect(error, { maxObjectProperties: 0 });
+  assert.doesNotMatch(output, /cause:/);
+  assert.match(output, /\.\.\. 1 more property/);
+}
+
+// Built-in typed array metadata does not consume the property budget.
+{
+  const value = new Uint8Array([1, 2]);
+  value.extra = true;
+  const output = util.inspect(value, {
+    breakLength: Infinity,
+    maxObjectProperties: 0,
+    showHidden: true,
+  });
+  assert.match(output, /\[BYTES_PER_ELEMENT\]: 1/);
+  assert.match(output, /\[buffer\]: ArrayBuffer/);
+  assert.match(output, /\.\.\. 1 more property/);
+}
+
+// The option is passed to custom inspection functions.
+{
+  const value = {
+    [util.inspect.custom]: common.mustCall((depth, options) => {
+      assert.strictEqual(options.maxObjectProperties, 1);
+      return 'custom';
+    }),
+  };
+  assert.strictEqual(
+    util.inspect(value, { maxObjectProperties: 1 }),
+    'custom'
+  );
+}
+
 {
   const obj = { foo: 'abc', bar: 'xyz' };
   const oneLine = util.inspect(obj, { breakLength: Infinity });
@@ -1619,6 +1932,7 @@ if (typeof Symbol !== 'undefined') {
 {
   const arr = new Array(101).fill();
   const obj = { a: { a: { a: { a: 1 } } } };
+  const properties = { first: 1, second: 2 };
 
   const oldOptions = { ...util.inspect.defaultOptions };
 
@@ -1627,6 +1941,11 @@ if (typeof Symbol !== 'undefined') {
   assert.doesNotMatch(util.inspect(arr), /1 more item/);
   util.inspect.defaultOptions.maxArrayLength = oldOptions.maxArrayLength;
   assert.match(util.inspect(arr), /1 more item/);
+  util.inspect.defaultOptions.maxObjectProperties = 1;
+  assert.match(util.inspect(properties), /1 more property/);
+  util.inspect.defaultOptions.maxObjectProperties =
+    oldOptions.maxObjectProperties;
+  assert.doesNotMatch(util.inspect(properties), /more propert/);
   util.inspect.defaultOptions.depth = null;
   assert.doesNotMatch(util.inspect(obj), /Object/);
   util.inspect.defaultOptions.depth = oldOptions.depth;
@@ -1637,11 +1956,17 @@ if (typeof Symbol !== 'undefined') {
   );
 
   // Set multiple options through object assignment.
-  util.inspect.defaultOptions = { maxArrayLength: null, depth: 2 };
+  util.inspect.defaultOptions = {
+    depth: 2,
+    maxArrayLength: null,
+    maxObjectProperties: 1,
+  };
   assert.doesNotMatch(util.inspect(arr), /1 more item/);
+  assert.match(util.inspect(properties), /1 more property/);
   assert.match(util.inspect(obj), /Object/);
   util.inspect.defaultOptions = oldOptions;
   assert.match(util.inspect(arr), /1 more item/);
+  assert.doesNotMatch(util.inspect(properties), /more propert/);
   assert.match(util.inspect(obj), /Object/);
   assert.strictEqual(
     JSON.stringify(util.inspect.defaultOptions),
@@ -3524,6 +3849,66 @@ assert.strictEqual(
       '\x1B[2mdef: \x1B[33m5\x1B[39m\x1B[22m }'
   );
 
+  class Nested {}
+  Nested.prototype.nested = { a: { b: { c: { d: 1 } } } };
+  assert.strictEqual(
+    inspect(new Nested(), { showHidden: true }),
+    'Nested { nested: { a: { b: { c: [Object] } } } }'
+  );
+
+  class Deep {}
+  Deep.prototype.p = {
+    l1: { l2: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' },
+  };
+  assert.strictEqual(
+    inspect({ x: new Deep(), y: 1 }, { showHidden: true }),
+    '{\n' +
+      "  x: Deep { p: { l1: { l2: 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa' } } },\n" +
+      '  y: 1\n' +
+      '}'
+  );
+
+  const getterCalls = [];
+  const getterParent = {
+    get proto() {
+      getterCalls.push('proto');
+      return 2;
+    },
+  };
+  const getterPrototype = {
+    __proto__: getterParent,
+    get own() {
+      getterCalls.push('own');
+      return 1;
+    },
+  };
+  const getterValue = { __proto__: getterPrototype };
+  Object.defineProperty(getterValue, 'instance', {
+    enumerable: true,
+    get() {
+      getterCalls.push('instance');
+      return 3;
+    },
+  });
+  inspect(getterValue, { getters: true, showHidden: true });
+  assert.deepStrictEqual(getterCalls, ['own', 'proto', 'instance']);
+
+  const ownCircular = {};
+  ownCircular.self = ownCircular;
+  const protoCircular = {};
+  protoCircular.self = protoCircular;
+  const circularValue = {
+    __proto__: { proto: protoCircular },
+    own: ownCircular,
+  };
+  assert.strictEqual(
+    inspect(circularValue, { showHidden: true }),
+    '{\n' +
+      '  own: <ref *2> { self: [Circular *2] },\n' +
+      '  proto: <ref *1> { self: [Circular *1] }\n' +
+      '}'
+  );
+
   assert.match(
     inspect(Object.getPrototypeOf(bar), { showHidden: true, getters: true }),
     new RegExp('^' + RegExp.escape(