René's URL Explorer Experiment

{"@context":"https://schema.org","@type":"DiscussionForumPosting","headline":"[Bug] assert.strictEqual OOM on objects with deeply shared references","articleBody":"### Version\n\nv25.2.1\n\n### Platform\n\n```text\nDarwin Hafezs-MacBook-Pro.local 25.2.0 Darwin Kernel Version 25.2.0: Tue Nov 18 21:09:40 PST 2025; root:xnu-12377.61.12~1/RELEASE_ARM64_T6000 arm64\n```\n\n### Subsystem\n\nassert\n\n### What steps will reproduce the bug?\n\n```javascript\n// Run with: node --max-old-space-size=512 repro.js\n'use strict';\nconst assert = require('assert');\n\n// Create an object graph where many unique paths converge on shared objects.\n// This delays circular reference detection and creates exponential growth\n// in util.inspect output at high depths.\n\nfunction createBase() {\n  const base = { id: 'base', models: {}, schemas: {}, types: {} };\n  for (let i = 0; i \u003c 5; i++) {\n    base.types[`type_${i}`] = {\n      name: `type_${i}`,\n      base,\n      caster: { base, name: `type_${i}_caster` },\n      options: {\n        base,\n        validators: [\n          { base, name: 'v1' },\n          { base, name: 'v2' },\n          { base, name: 'v3' },\n        ],\n      },\n    };\n  }\n  return base;\n}\n\nfunction createSchema(base, name) {\n  const schema = { name, base, paths: {}, tree: {}, virtuals: {} };\n  for (let i = 0; i \u003c 10; i++) {\n    schema.paths[`field_${i}`] = {\n      path: `field_${i}`,\n      schema,\n      instance: base.types[`type_${i % 5}`],\n      options: {\n        type: base.types[`type_${i % 5}`],\n        validators: [\n          { validator: () =\u003e true, base, schema },\n          { validator: () =\u003e true, base, schema },\n        ],\n      },\n      caster: base.types[`type_${i % 5}`].caster,\n    };\n  }\n  schema.childSchemas = [];\n  for (let i = 0; i \u003c 3; i++) {\n    const child = { name: `${name}_child_${i}`, base, schema, paths: {} };\n    for (let j = 0; j \u003c 5; j++) {\n      child.paths[`child_field_${j}`] = {\n        path: `child_field_${j}`,\n        schema: child,\n        instance: base.types[`type_${j % 5}`],\n        options: { base, schema: child },\n      };\n    }\n    schema.childSchemas.push(child);\n  }\n  return schema;\n}\n\nconst base = createBase();\nconst schema1 = createSchema(base, 'Schema1');\nconst schema2 = createSchema(base, 'Schema2');\n\n// These are different objects, so comparison should fail with AssertionError\nassert.strictEqual(schema1, schema2);\n```\n\n### How often does it reproduce? Is there a required condition?\n\n100% reproducible. The condition is having objects with many unique paths that converge on shared objects (common in ORMs like Mongoose where schemas reference a shared \"base\" object).\n\n### What is the expected behavior? Why is that the expected behavior?\n\n`assert.strictEqual` should throw an `AssertionError` with a diff showing the objects are not reference-equal. The error message can be truncated if very large, but the process should not crash.\n\n### What do you see instead?\n\nThe process crashes with OOM:\n```\nFATAL ERROR: Reached heap limit Allocation failed - JavaScript heap out of memory\n```\n\nThe OOM happens because `util.inspect` expands each unique path through the object graph separately. For objects where many paths converge on shared objects (common in ORMs), the number of unique paths grows exponentially. With `depth: 1000`, the expansion runs long enough to produce 100+ MB strings before hitting circular reference markers.\n\n### Additional information\n\nThis was discovered while working with Mongoose documents. The issue is in `lib/internal/assert/assertion_error.js` where `inspectValue()` has no output size limit.\n\n**Potential fixes:**\n\n1. **Truncate inspect output** (e.g., at 2MB) before passing to the diff algorithm\n2. **Skip diff entirely for huge objects** - just show \"Objects are not equal (output too large to diff)\"\n3. **Smarter truncation** - find where objects differ first, truncate around that area. However, this is complex to implement and the performance impact is probably negative compared to current solution: for objects with exponential paths, even traversing them to find differences could be expensive, and the subtree around the difference may still contain references to shared objects that cause the same explosion.\n\n**Trade-off with truncation:**\n\nIf both objects produce very large inspect output and happen to match exactly in the first 2MB but differ later, the diff would appear identical even though the assertion failed. However:\n- The alternative is an OOM crash, which is worse\n- The assertion result is still correct (`===` failed)\n- A truncation marker (`... [truncated]`) indicates output was cut off\n- Users can examine `error.actual` and `error.expected` programmatically for further investigation\n\nI'm happy to submit a PR with a fix.","author":{"url":"https://github.com/AbdelrahmanHafez","@type":"Person","name":"AbdelrahmanHafez"},"datePublished":"2026-01-11T17:51:21.000Z","interactionStatistic":{"@type":"InteractionCounter","interactionType":"https://schema.org/CommentAction","userInteractionCount":0},"url":"https://github.com/61346/node/issues/61346"}