import math

def _sigmoid_stable(z: float) -> float:
    """Numerically-stable logistic sigmoid."""
    if z >= 0:
        ez = math.exp(-z)
        return 1.0 / (1.0 + ez)
    else:
        ez = math.exp(z)
        return ez / (1.0 + ez)

def white_hole_steering(x, y, N, a1, alpha, beta, T, *, exp_clip=60.0, inner_clip=60.0):
    """
    RomanAILabs — White Hole Steering scalar s.

    Computes:
      s = tanh( sign(S) * log(1+|S|) )
    where
      S = (Σ_{i=1..N} a1 * f(i) * sigmoid( f(i)*K(i)*T(x,i)*T(y,0)*exp(-i*T(x,i)*T(y,0)) )) / (Σ_{i=1..N} f(i))
      f(i) = (i+1)^(-alpha)
      K(i) = (i+1)^(-beta)

    Notes:
    - Uses i=1..N (not i=0..N-1) so the exponential actually depends on i.
    - Caches T(y,0) outside the loop.
    - Clips exponent/input to avoid overflow and “all-0 / all-1” saturation.
    """
    Ty0 = T(y, 0)  # constant across the sum

    numerator = 0.0
    denominator = 0.0

    # i in [1..N]
    for i in range(1, N + 1):
        fi = (i + 1) ** (-alpha)
        Ki = (i + 1) ** (-beta)

        Txi = T(x, i)

        # exp(-i*Txi*Ty0) with clip for safety
        expo_arg = -i * Txi * Ty0
        if expo_arg > exp_clip:
            expo_arg = exp_clip
        elif expo_arg < -exp_clip:
            expo_arg = -exp_clip
        exp_term = math.exp(expo_arg)

        inner = fi * Ki * Txi * Ty0 * exp_term

        # clip inner before sigmoid to avoid extreme saturation
        if inner > inner_clip:
            inner = inner_clip
        elif inner < -inner_clip:
            inner = -inner_clip

        G_val = _sigmoid_stable(inner)

        numerator += a1 * fi * G_val
        denominator += fi

    S = (numerator / denominator) if denominator != 0.0 else 0.0

    # phi(S) = sign(S) * log(1 + |S|)
    phi_val = math.copysign(math.log1p(abs(S)), S)

    # H(phi) = tanh(phi)
    return math.tanh(phi_val)