Problem

A fintech risk engine processes millions of events per day and stores intermediate results in a JSON-like in-memory object graph (Python dict/list). For performance, the graph may contain shared sub-objects (aliasing) and, due to caching bugs, can even contain cycles (a container referencing itself). Before running a new model version, the engine must clone this graph so mutations in the new pipeline cannot corrupt the original.

Implement deep_clone(value) that returns a deep copy of a JSON-like value while preserving:

1. Value equality: primitives and container contents match the original.
2. Aliasing: if two paths in the original point to the same container object, the clone must point to the same cloned container.
3. Cycles: if the original contains a cycle, the clone must contain the corresponding cycle without infinite recursion.

Supported Types

• Primitives: None, bool, int, float, str
• Containers: list, dict (keys are strings)

Function Signature

• Input: value (any supported type)
• Output: a deep-cloned value of the same “shape”

Examples

Example 1 (cycle):

• Input:

  a = {}
  a["self"] = a
  

• Output: a dict b such that b is not a and b["self"] is b.
• Explanation: when the clone sees the back-edge to a, it reuses the already-created clone instead of recursing forever.

Example 2 (aliasing):

• Input:

  x = {"id": 7}
  obj = {"left": x, "right": x}
  

• Output: clone where clone["left"] is clone["right"] and clone["left"] is not x.
• Explanation: both references to x must map to the same cloned dict.

Notes

• You may not use copy.deepcopy.
• If an unsupported type is encountered, raise TypeError.

Constraints

• Reachable container nodes (list + dict) ≤ 2 * 10^5
• Total primitive elements across all containers ≤ 10^6
• Maximum nesting depth ≤ 10^4 (so recursion may overflow)