From c01faf82daf1e2824a234a8e5079b1b3b7821820 Mon Sep 17 00:00:00 2001
From: Thomas Watson <thomas.watson@datadoghq.com>
Date: Tue, 11 Aug 2026 15:24:39 +0200
Subject: [PATCH] util: add maxObjectProperties option to inspect

Add a maxObjectProperties option to util.inspect that caps the number of
named properties included in formatted output. The limit applies
independently from maxArrayLength and defaults to Infinity, preserving
existing behavior.

Own string and symbol properties are included before user-defined
prototype properties. Array, Map, Set, and WeakSet entries governed by
maxArrayLength, as well as built-in metadata entries such as
[byteLength], [buffer], and [BYTES_PER_ELEMENT], do not consume the
property budget. The limit is applied before sorted, and omitted
properties are not evaluated (including getters and
[util.inspect.custom]).

Prototype property collection is deferred so truncated properties are
discarded before their values are formatted. Assertion errors pass
maxObjectProperties: Infinity explicitly so changes to
inspect.defaultOptions do not affect diff output.

Signed-off-by: Thomas Watson <w@tson.dk>
---
 benchmark/util/inspect-object.js             |  31 ++
 doc/api/util.md                              |  11 +
 lib/internal/assert/assertion_error.js       |   1 +
 lib/internal/util/inspect.js                 | 115 ++++--
 test/parallel/test-assert-deep.js            |  20 +
 test/parallel/test-repl-inspect-defaults.js  |   6 +
 test/parallel/test-util-inspect-namespace.js |   8 +
 test/parallel/test-util-inspect.js           | 387 ++++++++++++++++++-
 8 files changed, 546 insertions(+), 33 deletions(-)
 create mode 100644 benchmark/util/inspect-object.js

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(