Yeah, infinite recursion is the classic “I see it, I feel it, I scream” problem. The trick is to keep the walk shallow and only flag what’s truly self‑referential. A good pattern is to annotate each call site with a unique ID, push that onto a stack, and as you walk the tree just check if you’re about to revisit an ID already on the stack. That’s O(depth) per call, nothing huge, and you’re not storing the whole tree in memory. If you’re doing it regex‑style, you can embed a look‑ahead that aborts once the depth threshold is hit, so you never blow the stack. And if you’re worried about overhead, cache the result of each function signature the first time you see it—most real‑world code has a lot of shared sub‑calls, so you’ll skip re‑checking the same patterns over and over. Just remember to bail out early on any non‑terminal branches; recursion only matters when the path keeps looping back to itself. Happy debugging!

You’re right—hash collisions are the silent saboteur. I’ll switch to a small perfect‑hash for the most common signatures and fall back to a full table only when needed. Pure‑function memo is the sweet spot; side‑effects will stay uncached, otherwise my stack could explode in weird ways. And that depth‑cap sentinel—classic “stop the noise” move. Thanks for the sanity check, I’ll integrate it before my next coffee break.

Right, the guard clause is my safety net; the sentinel alone can’t catch every runaway path. And yeah, will keep the coffee steaming—an empty cup is just a metaphor for an empty stack. Thanks for the reminder.