[thaibaole89]

Deeply nested patterns below the existing character limit can overflow the recursive AST walkers. This change rejects excessive nesting with a controlled SyntaxError before the engine exhausts its stack.

• Cap parser brace/parenthesis nesting and recursive compile/expand/stringify traversal at 100.
• Apply the traversal bound to direct AST nodes trees, which bypass parsing.
• Document the bound in README and its .verb source. Parser container nesting and walker call depth have distinct counts at the boundary.
• Preserve ordinary alternatives, ranges, escapes and parsed AST behavior. No version/dependency change.

Addresses #70 / GHSA-vfj7-8cjw-p6xm. Related to #77, which proposes an opt-in maxDepth option; this proposal provides a mandatory default bound for existing callers that pass no option. Maintainer input on the threshold/API is welcome.

Validation:

• New regressions against unchanged upstream: 12 fail / 2 pass.
• Builder: npm test on Node 24.14.1, 908 pass, including 14 new cases.
• Independent reviewer: full upstream suite on actual Node 8.3.0, 908 pass; new tests 14/14 pass. Removing the shared guard causes 12 failures; individual compile/expand/stringify guards cause 2 failures each, and parser guards 1 failure.
• A 512KB-stack child process checks 4000-level strings; direct AST and 100/101 boundaries are exercised. Ordinary syntax and 99 nested containers retain expected results.

This bounds parser and AST nodes recursion depth; it does not cap expansion cardinality or claim safety for every malformed AST field/getter/parent structure or resource-exhaustion input. For example, a malformed array-valued text node can still reach unguarded flattening; the parser does not emit that shape. No general CPU/memory or regex-safety claim is made.

AI assistance: OpenAI Codex was used to prepare the patch, tests and independent review.

[ulises-jeremias]

I independently tested the current head 97308a0 with the upstream test suite on Node 22.22.0: npm test passes all 908 tests. This includes the new nesting/depth cases. GitHub currently reports no CI checks for this PR, and no npm release is available yet, so consumers cannot adopt it as a supported dependency update until it is merged and published.

[ActiveInAI]

We tested an additional local guard against the published 3.0.3 package while working on the existing stack exhaustion advisory. This feedback is intended to complement the current PR rather than duplicate it.

A parser-only nesting cap does not cover the public AST entry points:

const braces = require('braces');
let ast = { type: 'text', value: 'x' };
for (let i = 0; i < 20000; i++) ast = { type: 'root', nodes: [ast] };
braces.compile(ast); // RangeError with the unpatched package on Node 24.19.0

Our local patch checks nodes iteratively before compile, expand and stringify, as well as limiting parser brace/parenthesis nesting. An ancestry set catches child cycles while allowing shared subtrees: a root whose two children are the same text node must still compile to xx. A global visited set alone would reject that valid case.

The guard runs before the existing recursive walkers and throws a controlled SyntaxError. We used an explicit fixed depth budget of 128. Range/cardinality limits remain separate; this is not a claim to validate all malformed AST fields or prevent every expansion resource-exhaustion case.

Validation: 37 tests passed, 0 failed on Node 24.19.0, covering the existing compile/expand/parse fixtures and three new regression tests for deep strings, deep/cyclic/shared ASTs, and ordinary escape/range behaviour. The fixture harness uses Node's test runner with the existing Mocha-style globals; this is not a claim that the complete Mocha suite or the Node 8 compatibility matrix was run.

On this Node 24 runtime, the balanced 4000-level string case did not reproduce a stack overflow at the default stack size. The direct AST case above did, so we kept that distinction in the evidence.