assert: prevent OOM when generating diff for large objects

Objects with many converging paths to shared objects can cause
exponential growth in util.inspect output. When assert.strictEqual
fails on such objects, the error message generation would OOM while
trying to create a diff of the 100+ MB inspect strings.

Add a 2MB limit to inspectValue() output. When truncation occurs,
a marker is added and the error message indicates lines were skipped.
The comparison itself is unaffected; only the error output is truncated.

Author: AbdelrahmanHafez

lib/internal/assert/assertion_error.js

@@ -12,6 +12,7 @@ const {
   ObjectPrototypeHasOwnProperty,
   SafeSet,
   String,
+  StringPrototypeEndsWith,
   StringPrototypeRepeat,
   StringPrototypeSlice,
   StringPrototypeSplit,
@@ -42,6 +43,10 @@ const kReadableOperator = {
 
 const kMaxShortStringLength = 12;
 const kMaxLongStringLength = 512;
+// Maximum size for inspect output before truncation to prevent OOM.
+// Objects with many converging paths can produce exponential growth in
+// util.inspect output at high depths, leading to OOM during diff generation.
+const kMaxInspectOutputLength = 2 * 1024 * 1024; // 2MB
 
 const kMethodsWithCustomMessageDiff = new SafeSet()
   .add('deepStrictEqual')
@@ -69,10 +74,10 @@ function copyError(source) {
   return target;
 }
 
-function inspectValue(val) {
+function inspectValue(val, maxLength = kMaxInspectOutputLength) {
   // The util.inspect default values could be changed. This makes sure the
   // error messages contain the necessary information nevertheless.
-  return inspect(val, {
+  const result = inspect(val, {
     compact: false,
     customInspect: false,
     depth: 1000,
@@ -85,6 +90,15 @@ function inspectValue(val) {
     // Inspect getters as we also check them when comparing entries.
     getters: true,
   });
+
+  // Truncate if the output is too large to prevent OOM during diff generation.
+  // Objects with deeply nested structures can produce exponentially large
+  // inspect output that causes memory exhaustion when passed to the diff
+  // algorithm.
+  if (result.length > maxLength) {
+    return StringPrototypeSlice(result, 0, maxLength) + '\n... [truncated]';
+  }
+  return result;
 }
 
 function getErrorMessage(operator, message) {
@@ -189,6 +203,13 @@ function createErrDiff(actual, expected, operator, customMessage, diffType = 'si
   let message = '';
   const inspectedActual = inspectValue(actual);
   const inspectedExpected = inspectValue(expected);
+
+  // Check if either value was truncated due to size limits
+  const truncationMarker = '\n... [truncated]';
+  if (StringPrototypeEndsWith(inspectedActual, truncationMarker) ||
+      StringPrototypeEndsWith(inspectedExpected, truncationMarker)) {
+    skipped = true;
+  }
   const inspectedSplitActual = StringPrototypeSplit(inspectedActual, '\n');
   const inspectedSplitExpected = StringPrototypeSplit(inspectedExpected, '\n');
   const showSimpleDiff = isSimpleDiff(actual, inspectedSplitActual, expected, inspectedSplitExpected);