Advance Range Detector

A multi-factor Pine Script v6 engine for detecting, validating, tracking, and classifying price ranges/consolidations — with volatility normalization, structural quality filters, breakout confirmation, overshoot absorption, and fakeout/deviation handling.

1. Overview

Advance Range Detector is designed to answer a more difficult question than:

“Is price moving sideways?”

Instead, it attempts to determine:

“Is this a statistically tight, repeatedly tested, sufficiently balanced consolidation that deserves to be classified as a meaningful trading range?”

The script evaluates a candidate range through several independent dimensions:

Candidate Window
      │
      ├── Boundary Calculation
      │
      ├── Volatility / Tightness
      │
      ├── Midline Rotation
      │
      ├── Boundary Touches
      │
      ├── Price Containment
      │
      ├── Directional Drift
      │
      └── Qualification
             │
             ▼
       Range Detected
             │
       ┌─────┴─────┐
       │           │
   Confirmation   Breakout
       │           │
       ▼           ▼
   Valid Range   Breakout
                     │
              ┌──────┴──────┐
              │             │
           Fakeout       Valid Break
              │             │
          Deviation      Breakout

The key design philosophy is:

A range should not be identified from width alone.

A narrow price box can simply be a pause in a trend, a V-shaped reversal, a volatile spike, or an accidental clustering of candles.

This script therefore combines multiple measurements.

2. Core Philosophy

A high-quality range generally has several characteristics:

2.1 Tight enough

The price should be relatively compressed compared with its recent volatility.

2.2 Repeated interaction

Price should interact with both the upper and lower boundaries.

2.3 Rotation

Price should repeatedly move between the upper and lower portions of the range.

2.4 Containment

Most closes should remain inside the proposed range.

2.5 Limited directional drift

The range should not simply be an upward or downward channel.

2.6 Persistence

The consolidation should survive long enough to become meaningful.

2.7 Confirmed breakout

A boundary violation should be meaningful rather than merely a marginal wick.

These principles make the detector closer to a range-quality classifier rather than a simple highest-high/lowest-low indicator.

3. Detection Pipeline

The script operates in several stages.

                PRICE DATA
                    │
                    ▼
          ┌───────────────────┐
          │ Candidate Windows │
          └─────────┬─────────┘
                    │
          ┌─────────▼─────────┐
          │ Boundary Engine   │
          └─────────┬─────────┘
                    │
          ┌─────────▼─────────┐
          │ Tightness Filter  │
          └─────────┬─────────┘
                    │
       ┌────────────┼────────────┐
       ▼            ▼            ▼
   Rotation      Touches     Containment
       │            │            │
       └────────────┼────────────┘
                    ▼
              Drift Filter
                    │
                    ▼
             QUALIFICATION
                    │
                    ▼
              RANGE ACTIVE
                    │
          ┌─────────┴─────────┐
          ▼                   ▼
     Confirmation          Break Test
                              │
                    ┌─────────┴─────────┐
                    ▼                   ▼
                 Fakeout             Breakout

This is one of the strongest conceptual aspects of the script.

4. Window Selection

The detector can test up to three different consolidation lengths.

Base

Base Window

Default:

20 bars

Double

20 × 2 = 40 bars

Triple

20 × 3 = 60 bars

When all three are enabled, the script checks:

60 → 40 → 20

and selects the longest qualifying window.

This is important because it prevents a large consolidation from being unnecessarily represented as a smaller consolidation.

For example:

60-bar range qualifies
40-bar range qualifies
20-bar range qualifies

The detector chooses:

60 bars

rather than chopping the structure down to 20 bars.

5. Boundary Engine

The script supports three boundary methodologies.

5.1 Percentile

Default:

Top = 90th percentile of highs
Bottom = 10th percentile of lows

This is particularly interesting because it attempts to reduce the influence of isolated extreme candles.

Example:

Highs:

100
101
102
103
104
105
106
107
108
140 ← abnormal spike

A traditional highest-high method would use:

Top = 140

The percentile approach can effectively ignore the extreme observation.

Why this matters

A single liquidity sweep should not necessarily redefine the entire consolidation.

6. Absolute Extremes

The second method uses:

Top    = highest high
Bottom = lowest low

This represents the literal price extremes of the window.

Advantages:

• 
  simple
  
• 
  intuitive
  
• 
  captures actual range extremes
  

Disadvantages:

• 
  extremely sensitive to outliers
  
• 
  one wick can dramatically increase range height
  

7. Body Extremes

The third method ignores candle wicks when defining boundaries.

Upper boundary:

highest(max(Open, Close))

Lower boundary:

lowest(min(Open, Close))

This is effectively a body-based range.

It can be useful when you want to distinguish:

wick manipulation

from:

actual body acceptance

8. Volatility-Normalized Tightness

One of the most important components is the ATR normalization.

The script calculates:

Range Height / ATR

instead of simply asking:

“Is the range 2 points wide?”

This is important because 2 points mean very different things for different instruments.

For example:

Stock A
Range = 2
ATR   = 1

Range/ATR = 2

versus:

Stock B
Range = 2
ATR   = 10

Range/ATR = 0.2

The second consolidation is much tighter relative to its volatility.

9. Tightness Ranking

The script maintains:

heightHistory[]

This stores previously tested candidate range heights in ATR units.

Then the current candidate is ranked against historical candidates.

Conceptually:

Current Range
     │
     ▼
Range Height / ATR
     │
     ▼
Compare against historical candidates
     │
     ▼
Percentile Rank
     │
     ▼
Is this unusually tight?

Default requirement:

Must be tighter than approximately the lower 30% threshold

This gives the detector a relative volatility perspective.

10. Midline Rotation

This is another strong idea in the script.

The midpoint is:

Mid = (Top + Bottom) / 2

The script tracks whether closing prices move above and below this midpoint.

Example:

Above
   ↓
Below
   ↓
Above
   ↓
Below
   ↓
Above

This produces multiple rotations.

The default requirement is:

Minimum rotations = 4

Why?

Consider two structures.

Structure A

          /
         /
        /
       /
      /

Price continuously trends upward.

Structure B

     ┌─────────┐
     │ ↕ ↕ ↕ ↕ │
     │ ↕ ↕ ↕ ↕ │
     └─────────┘

Price repeatedly rotates.

Both might have similar width.

But only the second behaves like a conventional range.

Therefore:

Rotation is being used as a proxy for two-sided order flow.

11. Boundary Touches

The detector requires interaction with both sides.

Default:

Minimum upper touches = 2
Minimum lower touches = 2

A touch is not required to exactly equal the boundary.

Instead:

Touch tolerance = 0.15 × ATR

So the detector creates an ATR-scaled interaction zone.

Conceptually:

        Upper Boundary
━━━━━━━━━━━━━━━━━━━━━━━━
        Touch Zone
------------------------

          RANGE

------------------------
        Touch Zone
━━━━━━━━━━━━━━━━━━━━━━━━
        Lower Boundary

This is preferable to requiring exact price equality.

12. Containment

The detector counts how many closes remain inside:

Bottom ≤ Close ≤ Top

Default:

Minimum containment = 80%

Therefore, if 20 bars are tested:

At least 16 closes

should remain inside.

This prevents a proposed range from being constructed around a price structure that is actually experiencing frequent external closes.

13. Drift Detection

This is another important quality filter.

The script divides the window approximately into:

First Half
Second Half

Then calculates:

Average Price First Half
Average Price Second Half

The difference is compared with the range height.

Formula conceptually:

Drift %
=
abs(SecondHalfAverage - FirstHalfAverage)
/
RangeHeight
× 100

Default:

Maximum drift = 30%

Why?

Consider:

Range A

────────────
 ↕ ↕ ↕ ↕ ↕
────────────

versus:

Range B

       ───────
     /
   /
 /
────────

Range B may technically fit inside a bounding box, but it is behaving more like a channel/trend.

The drift filter attempts to reject that.

14. Range Qualification

The candidate becomes a valid range only when all major conditions are satisfied:

Tightness
    AND
Rotation
    AND
Upper Touches
    AND
Lower Touches
    AND
Drift
    AND
Containment

In logical form:

QUALIFIED =
    Tightness
    &&
    Rotation
    &&
    Upper Touches
    &&
    Lower Touches
    &&
    Drift
    &&
    Containment

This is much better than:

Highest High + Lowest Low = Range

15. Backward Extension

Once a range is detected, the script attempts to extend the left side backward.

It checks earlier closes:

Current candidate
        │
        ▼
Can previous close fit inside?
        │
       YES
        │
        ▼
Go one more bar backward
        │
       YES
        │
        ▼
Continue...

until:

Maximum backward extension

is reached or price leaves the boundaries.

Default:

100 bars

This can reveal that the consolidation actually started much earlier than the initial detection window suggests.

16. Range State Machine

The script uses a state machine.

There are three primary states:

NONE
ACTIVE
WAITING

NONE

No active range exists.

The detector scans for a new candidate.

NONE
 │
 │ candidate qualifies
 ▼
ACTIVE

ACTIVE

The range is currently being monitored.

Possible outcomes:

ACTIVE
 │
 ├── remains inside
 │
 ├── absorbs overshoot
 │
 ├── becomes confirmed
 │
 └── breaks

WAITING

A confirmed breakout has occurred.

The detector temporarily waits to determine whether the breakout is genuine or a deviation/fakeout.

ACTIVE
   │
   │ breakout
   ▼
WAITING
   │
   ├── returns inside
   │       ↓
   │   DEVIATION
   │
   └── remains outside
           ↓
      BREAKOUT STANDS

This state-machine architecture is a major strength of the design.

17. Provisional vs Confirmed Range

The detector does not immediately treat a newly detected range as fully confirmed.

Default:

5 bars

Before confirmation:

Dashed border

After confirmation:

Solid border

This provides a useful distinction:

Provisional

“This looks like a range, but it hasn't demonstrated enough persistence yet.”

Confirmed

“The range has survived the required confirmation period.”

This is a better conceptual model than treating every detected box equally.

18. Overshoot Absorption

This feature attempts to distinguish:

small liquidity sweep

from:

true breakout

Suppose:

Range Top
━━━━━━━━━━━━━━━━

        │
        │ wick
        │
        ▼
        ↑
       close back inside

If the wick exceeds the boundary only slightly and the candle closes back inside, the script can expand the boundary.

Default allowance:

0.15 × ATR

So instead of immediately terminating the range:

Old Top
──────────────

       wick

New Top
──────────────

the range absorbs the excursion.

19. Breakout Buffer

The detector does not necessarily accept a tiny breach.

Default:

0.10 × ATR

For a bullish close breakout:

Close > Top + 0.10 ATR

For bearish:

Close < Bottom - 0.10 ATR

This reduces sensitivity to tiny boundary violations.

20. Close vs Wick Breakout

Two breakout modes are available.

Close

Requires:

Close > Top + Buffer

or:

Close < Bottom - Buffer

This emphasizes acceptance beyond the range.

Wick

Requires:

High > Top + Buffer

or:

Low < Bottom - Buffer

This is much more sensitive.

Therefore:

Close Mode
= confirmation-oriented

while:

Wick Mode
= event-oriented

21. Breakout Classification

When a confirmed range breaks, the script determines direction:

Bullish Breakout

or:

Bearish Breakout

The box changes color accordingly.

It also creates a:

Breakout

label.

The script stores:

breakDir
breakExtreme
breakBar

so the breakout can subsequently be evaluated for deviation.

22. Merge Deviation / Fakeout Handling

This is one of the more advanced features.

After breakout:

WAITING

The detector gives the market a defined number of bars to prove the breakout.

Default:

5 bars

If price closes back inside the original range:

BREAKOUT
    ↓
close returns inside
    ↓
DEVIATION

The original breakout marker is removed.

The range resumes:

ACTIVE

This effectively treats the breakout as a failed expansion/deviation rather than a permanent structural transition.

23. Why This Is Different From a Basic Range Indicator

A basic range detector might do:

Highest High
Lowest Low

Your script does:

Boundary
+
Volatility
+
Relative Tightness
+
Rotation
+
Touches
+
Containment
+
Drift
+
Persistence
+
Overshoot Handling
+
Breakout Buffer
+
Fakeout Handling

That is a substantially richer framework.

24. Visual Architecture

The chart can contain:

Range box

Represents the active consolidation.

Midline

Represents the 50% equilibrium level.

25% line

Represents lower internal quartile.

75% line

Represents upper internal quartile.

Thus the box becomes:

        RANGE HIGH
━━━━━━━━━━━━━━━━━━━━
        75%
- - - - - - - - - - -

        50%
- - - - - - - - - - -

        25%
- - - - - - - - - - -
━━━━━━━━━━━━━━━━━━━━
        RANGE LOW

This gives the user internal range positioning rather than only the outer boundaries.

25. Range Lifecycle

A complete range lifecycle is approximately:

                SCAN
                  │
                  ▼
          Candidate Window
                  │
                  ▼
        Quality Qualification
                  │
             qualifies?
            /          \
          NO            YES
          │              │
          ▼              ▼
       Continue        RANGE
                         │
                         ▼
                    Provisional
                         │
                         ▼
                    Confirmation
                         │
                ┌────────┴────────┐
                │                 │
             No Break           Break
                │                 │
                │                 ▼
                │             Breakout
                │                 │
                │                 ▼
                │              WAITING
                │              /      \
                │        Return       Stay out
                │         inside          │
                │           │              ▼
                │           ▼         Breakout Stands
                │       Deviation
                │           │
                └───────────┘

26. What the Script Is Really Trying to Detect

The underlying concept is not simply:

“Sideways candles.”

It is closer to:

A statistically compressed area where price repeatedly rotates between two boundaries with sufficient two-sided interaction and limited directional displacement.

That distinction is important.

27. Current Quality Scoring: The Major Missing Piece

This is where I would improve your script substantially.

Right now the detector is mostly:

PASS / FAIL

For example:

rotation >= 4
touches >= 2
drift <= 30
containment >= 80
tightness = true

But consider two ranges:

Range A

Rotation = 12
Top Touches = 8
Bottom Touches = 7
Containment = 97%
Drift = 3%
Tightness = excellent

Range B

Rotation = 4
Top Touches = 2
Bottom Touches = 2
Containment = 80%
Drift = 29%
Tightness = barely qualifies

Both are currently:

QUALIFIED = TRUE

But they clearly have different structural quality.

That is the biggest analytical opportunity.

28. Add a Range Quality Score

Instead of only:

QUALIFIED = TRUE/FALSE

create:

RANGE QUALITY SCORE = 0–100

For example:

                    Weight
Tightness             20%
Rotation              20%
Boundary Interaction  20%
Containment            15%
Drift                  15%
Persistence            10%
                       ───
                       100%

Then:

90–100 = Exceptional structural quality
75–89  = High structural quality
60–74  = Moderate structural quality
<60    = Weak

However, I would not necessarily display these as trading recommendations. They should represent detector confidence/structural quality, not “buy/sell quality.”

29. Improve Tightness Measurement

The current system compares candidate height/ATR against its own history.

A stronger approach would consider:

Range Height
──────────────
ATR

plus:

Range Height
──────────────
Average True Range

plus potentially:

Range Height
──────────────
Recent Median Range Height

This would make the tightness estimate less dependent on the specific candidate history.

30. Add Volume Compression

One major missing dimension is volume.

A genuine consolidation often exhibits changes in participation.

Possible metrics:

Volume / Volume SMA

and:

Relative Volume

Then examine whether volume contracts during the range.

For example:

Volume
│
│ █
│ █
│ █
│  █
│   █
│    █
│     █
└────────────────
       RANGE

This can add another dimension to range quality.

But importantly:

Low volume should not automatically mean a better range.

It should be treated as context, not a standalone qualification rule.

31. Add Range Efficiency

Another useful metric:

Directional Movement
────────────────────
Total Movement

A strongly trending market has high directional efficiency.

A rotating market has lower directional efficiency.

Conceptually:

Trending:

A → B → C → D → E

Range:

A → B → A → C → B → A

A range detector could therefore calculate:

Efficiency Ratio
=
abs(Net Change)
/
Sum(abs(Bar-to-Bar Changes))

Lower values indicate more back-and-forth movement.

This complements your existing rotation metric extremely well.

32. Add Boundary Symmetry

Currently you measure:

Top touches
Bottom touches

But you could also measure their balance.

Example:

Top touches = 8
Bottom touches = 2

This isn't the same quality as:

Top touches = 5
Bottom touches = 5

Create:

Touch Balance

For example:

Touch Balance =
1 - abs(topTouches - bottomTouches)
    / (topTouches + bottomTouches)

This gives a more balanced representation.

33. Add Range Occupancy

Another useful measurement is where price actually spends time.

For example:

Upper Zone
━━━━━━━━━━
████████

Middle
━━━━━━━━━━
████

Lower
━━━━━━━━━━
██

This tells you whether the market is:

balanced

or:

accepting higher/lower prices

This can be particularly useful when distinguishing:

true equilibrium range

from:

re-accumulation / redistribution-like structures

without forcing a directional interpretation.

34. Add Wick Rejection Statistics

Since your detector already distinguishes wicks and bodies, you can calculate:

Upper Rejection Count
Lower Rejection Count

For example:

Upper sweep
    │
    ▼
    wick
━━━━━━━ boundary
    │
    ▼
close inside

Repeated occurrences could indicate that the boundary is being actively rejected.

This would be more informative than merely counting touches.

35. Add Boundary Respect

A useful metric would measure how closely price respects the range.

Example:

Average Distance From Top
Average Distance From Bottom

Normalized by ATR.

You could then distinguish:

Clean boundary

from:

messy boundary

even when both technically satisfy the touch condition.

36. Improve Breakout Quality

Currently:

Breakout = boundary + ATR buffer

A stronger breakout classifier could evaluate:

1. Break distance

Break distance / ATR

2. Closing position

Where did the candle close relative to its full range?

3. Follow-through

Did subsequent candles continue away from the range?

4. Retest

Did price return to the boundary?

5. Acceptance

Did multiple closes remain outside?

This produces a much more sophisticated breakout model:

Boundary breach
      ↓
Initial breakout
      ↓
Acceptance test
      ↓
Retest
      ↓
Continuation

37. Improve Fakeout Detection

Your current fakeout rule is:

close returns inside within N bars

That's useful, but it can be improved.

For example:

Breakout
   ↓
Returns inside
   ↓
How deeply?

A close barely inside is different from:

price completely traverses the range

You could classify:

Minor Deviation
Deep Deviation
Full Failure

based on penetration depth.

38. Add Range Age Quality

Currently you have:

Minimum confirmation

and optional:

Maximum age

But age could become part of the quality model.

For example:

5 bars
10 bars
20 bars
30 bars
50 bars

A range that remains structurally valid for longer may provide a different type of information than one that immediately breaks.

Instead of simply:

age >= confirmation

you could calculate:

Persistence Score

39. Add Structural Stability

This would be a particularly useful advanced feature.

Every new bar could recalculate:

Top stability
Bottom stability
Midline stability
Width stability

Suppose:

Top = stable
Bottom = stable
Width = stable

Then the range is structurally stable.

But if:

Top keeps expanding
Bottom keeps expanding

the detector may actually be witnessing volatility expansion rather than a stable range.

40. Add Range Expansion Detection

A very useful companion metric:

Current Range Height
/
Previous Range Height

Then identify:

Compression
Expansion

This gives the lifecycle:

Expansion
    ↓
Compression
    ↓
Range
    ↓
Expansion

This is much more informative than simply drawing boxes.

41. Add Nested Ranges

This is probably one of the most valuable improvements.

Imagine:

        60-Bar Range
┌───────────────────────────┐
│                           │
│      40-Bar Range         │
│    ┌───────────────┐      │
│    │               │      │
│    │ 20-Bar Range  │      │
│    │               │      │
│    └───────────────┘      │
│                           │
└───────────────────────────┘

Your current system chooses the longest qualifying range.

But instead, an advanced engine could recognize:

Parent Range
Child Range
Nested Compression

This would provide much richer structural information.

42. Add Multi-Timeframe Context

The current detector works on the chart timeframe.

A more advanced architecture could use:

HTF
 │
 ▼
Macro Range
 │
 ▼
Current TF Range
 │
 ▼
LTF Range

For example:

4H → structural range
1H → active range
15m → local range
5m → execution structure

The important principle would be:

Higher timeframe defines context; lower timeframe defines local structure.

The detector should not simply mix data from different timeframes into one box.

43. Add Range Classification

Once quality metrics are available, the engine could classify ranges.

For example:

BALANCED RANGE

when:

High rotation
Low drift
Balanced touches
High containment

Another:

COMPRESSED RANGE

when:

Extremely low height / ATR

Another:

EXPANDING RANGE

when:

Range width progressively increases

Another:

DRIFTING RANGE

when:

Directional displacement increases

This is more informative than simply:

RANGE

44. Suggested Architecture 2.0

I would evolve your script toward this architecture:

                    ADVANCE RANGE ENGINE
                            │
          ┌─────────────────┼─────────────────┐
          │                 │                 │
          ▼                 ▼                 ▼
      Boundary          Volatility        Structure
       Engine             Engine            Engine
          │                 │                 │
          │                 │          ┌──────┼──────┐
          │                 │          │      │      │
          │                 │       Rotation Touch Drift
          │                 │
          └─────────────────┼─────────────────┘
                            │
                            ▼
                    QUALITY ENGINE
                            │
          ┌─────────────────┼─────────────────┐
          │                 │                 │
          ▼                 ▼                 ▼
      Containment       Symmetry         Stability
          │                 │                 │
          └─────────────────┼─────────────────┘
                            ▼
                     QUALITY SCORE
                         0–100
                            │
                            ▼
                    RANGE CLASSIFIER
                            │
             ┌──────────────┼──────────────┐
             ▼              ▼              ▼
         Balanced       Compressed      Drifting
                            │
                            ▼
                     BREAKOUT ENGINE
                            │
          ┌─────────────────┼─────────────────┐
          ▼                 ▼                 ▼
       Breakout          Retest            Fakeout
                            │
                            ▼
                     FINAL EVENT

45. Recommended Future Metrics

If you want this to become a genuinely advanced range-analysis engine, I would add these:

MetricPurposeATR-normalized widthVolatility-adjusted range sizeRotation countTwo-sided movementTouch countBoundary interactionTouch symmetryBalance between boundariesContainmentInternal acceptanceDriftTrend/channel rejectionEfficiency ratioMeasures directional efficiencyVolume compressionParticipation contextWick rejectionBoundary rejectionWidth stabilityRange consistencyMidline stabilityEquilibrium stabilityPersistenceDurationExpansion ratioCompression → expansionBreakout distanceBreak strengthBreakout acceptancePost-break behaviorRetest qualityBoundary validationDeviation depthFakeout severityNested-range relationshipMulti-scale structure

46. One Important Conceptual Change

The biggest upgrade I'd recommend is changing the mental model from:

IF conditions pass
    → RANGE

to:

                 CANDIDATE
                     │
                     ▼
              ┌─────────────┐
              │ Measurements│
              └──────┬──────┘
                     │
                     ▼
              QUALITY SCORE
                 0 → 100
                     │
          ┌──────────┼──────────┐
          ▼          ▼          ▼
       Weak       Moderate     Strong
          │          │          │
       Reject      Monitor     Track

This gives you much more information.

A detector should ideally tell you:

Why is this a range?

not merely:

Is this a range?

47. Example of a High-Quality Range Report

A future version could internally produce something like:

ADVANCE RANGE
────────────────────────

Range Quality: 87/100

Window:          40 bars
Width / ATR:     1.42
Rotation:        9
Upper Touches:   6
Lower Touches:   5
Touch Balance:   0.91
Containment:     94%
Drift:           8%
Efficiency:      0.18
Width Stability: High
Volume State:    Contracting

Classification:
BALANCED CONSOLIDATION

Status:
CONFIRMED

Breakout:
NOT YET CONFIRMED

That would be significantly more analytical than the current:

RANGE 40 BARS 1.42%

48. What Your Current Script Already Does Well

The strongest parts of your existing design are:

✅ Multi-window detection

20 / 40 / 60-bar analysis.

✅ ATR normalization

Makes the logic adaptive to volatility.

✅ Percentile boundaries

Reduces sensitivity to isolated extreme wicks.

✅ Rotation filter

Helps reject V-shaped reversals and trends.

✅ Two-sided touch requirement

Prevents one-sided structures from being called ranges.

✅ Drift filter

Helps distinguish consolidation from directional channels.

✅ Containment

Requires actual internal price acceptance.

✅ Backward extension

Allows the range to represent more historical structure.

✅ Confirmation state

Separates provisional and established ranges.

✅ Overshoot absorption

Handles small boundary sweeps.

✅ Breakout buffer

Reduces insignificant boundary breaches.

✅ Deviation handling

Attempts to distinguish fakeouts from genuine breakouts.

✅ State-machine architecture

Makes the indicator much easier to extend.

49. Current Weaknesses

The biggest limitations are not that the script lacks features; it's that some features are still binary.

For example:

Rotation >= 4

doesn't distinguish:

4 rotations

from:

12 rotations

Similarly:

Containment >= 80%

doesn't distinguish:

80%

from:

98%

And:

Drift <= 30%

doesn't distinguish:

29%

from:

3%

That information is being thrown away.

50. The Next Version Should Preserve Raw Measurements

Instead of:

rotationOK = rotations >= minRotations

think:

rotationScore

Instead of:

containmentOK

think:

containmentScore

Instead of:

driftOK

think:

driftScore

Then combine them.

Conceptually:

Quality =
    Tightness Score
  + Rotation Score
  + Touch Score
  + Containment Score
  + Drift Score
  + Stability Score

This allows the detector to become continuous rather than binary.

51. Final Concept

Your current indicator is best described as:

A rule-based multi-factor consolidation detector with volatility-normalized boundaries and event-state management.

The more advanced version would become:

A multi-dimensional market range analysis engine that measures compression, equilibrium, boundary interaction, structural stability, participation, and breakout behavior across multiple scales.

That is the direction I'd take.

In short:

CURRENT VERSION

Detect Range
     ↓
Validate Range
     ↓
Track Range
     ↓
Detect Breakout
     ↓
Detect Deviation

ADVANCED VERSION

Detect Candidate
       ↓
Measure Structure
       ↓
Measure Volatility
       ↓
Measure Participation
       ↓
Measure Boundary Quality
       ↓
Measure Balance
       ↓
Measure Stability
       ↓
Calculate 0–100 Quality
       ↓
Classify Range
       ↓
Track Lifecycle
       ↓
Detect Breakout
       ↓
Measure Breakout Quality
       ↓
Detect Retest / Acceptance
       ↓
Classify Deviation / Failure