KALTECH V7 Feature Catalog

v5/lib/features_v5.py:960–965  ::  extract_features        _signal_for_env, _med_filter, _med_info = med(signal)
        signal_env = _signal_for_env
        _med_aborted = _med_info["aborted"]
        _med_converged = float(_med_info["converged"])
        _med_kurt_before = float(_med_info["kurtosis_before"])
        _med_kurt_after = float(_med_info["kurtosis_after"])

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:960–965  ::  extract_features        _signal_for_env, _med_filter, _med_info = med(signal)
        signal_env = _signal_for_env
        _med_aborted = _med_info["aborted"]
        _med_converged = float(_med_info["converged"])
        _med_kurt_before = float(_med_info["kurtosis_before"])
        _med_kurt_after = float(_med_info["kurtosis_after"])

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:967–973  ::  extract_features    else:
        signal_env = signal
        # F7 Wave-2: explicit "disabled" sentinel so the (aborted, converged)
        # pair is unambiguous. Pre-fix: aborted="" + converged=0.0 in the
        # disabled branch collided with the THEORETICAL "MED ran cleanly but
        # converged=0" combination — downstream consumers checking
        # `if features["med_aborted"]:` to detect "MED skipped" would

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:967–973  ::  extract_features    else:
        signal_env = signal
        # F7 Wave-2: explicit "disabled" sentinel so the (aborted, converged)
        # pair is unambiguous. Pre-fix: aborted="" + converged=0.0 in the
        # disabled branch collided with the THEORETICAL "MED ran cleanly but
        # converged=0" combination — downstream consumers checking
        # `if features["med_aborted"]:` to detect "MED skipped" would

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:967–973  ::  extract_features    else:
        signal_env = signal
        # F7 Wave-2: explicit "disabled" sentinel so the (aborted, converged)
        # pair is unambiguous. Pre-fix: aborted="" + converged=0.0 in the
        # disabled branch collided with the THEORETICAL "MED ran cleanly but
        # converged=0" combination — downstream consumers checking
        # `if features["med_aborted"]:` to detect "MED skipped" would

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:967–973  ::  extract_features    else:
        signal_env = signal
        # F7 Wave-2: explicit "disabled" sentinel so the (aborted, converged)
        # pair is unambiguous. Pre-fix: aborted="" + converged=0.0 in the
        # disabled branch collided with the THEORETICAL "MED ran cleanly but
        # converged=0" combination — downstream consumers checking
        # `if features["med_aborted"]:` to detect "MED skipped" would

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:967–973  ::  extract_features    else:
        signal_env = signal
        # F7 Wave-2: explicit "disabled" sentinel so the (aborted, converged)
        # pair is unambiguous. Pre-fix: aborted="" + converged=0.0 in the
        # disabled branch collided with the THEORETICAL "MED ran cleanly but
        # converged=0" combination — downstream consumers checking
        # `if features["med_aborted"]:` to detect "MED skipped" would

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:960–965  ::  extract_features        _signal_for_env, _med_filter, _med_info = med(signal)
        signal_env = _signal_for_env
        _med_aborted = _med_info["aborted"]
        _med_converged = float(_med_info["converged"])
        _med_kurt_before = float(_med_info["kurtosis_before"])
        _med_kurt_after = float(_med_info["kurtosis_after"])

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:975–978  ::  extract_features        # produced a usable result.
        _med_aborted = "disabled"
        _med_converged = 0.0
        _med_kurt_before = 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:975–978  ::  extract_features        # produced a usable result.
        _med_aborted = "disabled"
        _med_converged = 0.0
        _med_kurt_before = 0.0

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:978–983  ::  extract_features        _med_kurt_before = 0.0
        _med_kurt_after = 0.0
        _med_n_iter = 0.0

    # -----------------------------------------------------------------------
    # TIME-DOMAIN STATISTICAL (11 features)

firmware/common/dsp/kaltech_dsp.c:70–122  ::  kaltech_time_featuresvoid kaltech_time_features(const float *x, size_t n, kaltech_time_feats_t *o) {
    *o = (kaltech_time_feats_t){0};
    if (n == 0) return;

    float sum = 0.0f, peak = 0.0f, sum_abs = 0.0f, sum_sqrt_abs = 0.0f;
    int   nonfinite = 0;
    for (size_t i = 0; i < n; i++) {
        float v = x[i];
        if (!isfinite(v)) { nonfinite = 1; continue; }
        sum += v;
        float a = fabsf(v);
        sum_abs += a;
        sum_sqrt_abs += sqrtf(a);
        if (a > peak) peak = a;
    }
    if (nonfinite) return;
    float mean          = sum / (float)n;
    float mean_abs      = sum_abs / (float)n;
    float mean_sqrt_abs = sum_sqrt_abs / (float)n;

    float m2 = 0.0f, m3 = 0.0f, m4 = 0.0f;
    float sum_sq = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float d  = x[i] - mean;
        float d2 = d * d;
        m2 += d2;
        m3 += d2 * d;
        m4 += d2 * d2;
        sum_sq += x[i] * x[i];
    }
    m2 /= (float)n;
    m3 /= (float)n;
    m4 /= (float)n;

    float rms     = sqrtf(sum_sq / (float)n);
    float std_dev = sqrtf(m2);
    float var     = m2;

    o->rms             = rms;
    o->peak            = peak;
    o->mean            = mean;
    o->std_dev         = std_dev;
    o->variance        = var;
    o->kurtosis        = var      > 0.0f ? m4 / (var * var)      : 0.0f;
    o->skewness        = std_dev  > 0.0f ? m3 / (std_dev*std_dev*std_dev) : 0.0f;
    o->crest_factor    = rms      > 0.0f ? peak / rms            : 0.0f;
    o->impulse_factor  = mean_abs > 0.0f ? peak / mean_abs       : 0.0f;
    o->shape_factor    = mean_abs > 0.0f ? rms  / mean_abs       : 0.0f;
    o->clearance_factor = (mean_sqrt_abs > 0.0f)
                          ? peak / (mean_sqrt_abs * mean_sqrt_abs) : 0.0f;

    o->valid = (rms >= KAL_DEGENERATE_RMS_FLOOR) ? 1 : 0;
}

v5/lib/features_v5.py:990–994  ::  extract_features    std_dev = float(np.std(signal))
    var = std_dev ** 2
    # Non-excess kurtosis: mu_4/sigma^4 (Gaussian = 3.0, NOT 0.0)
    # All downstream thresholds (4.0, 8.0) are calibrated to this definition.
    kurtosis = float(np.mean((signal - mean) ** 4) / (var ** 2)) if var > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:998–1001  ::  extract_features    mean_abs = float(np.mean(abs_signal))
    shape_factor = rms / mean_abs if mean_abs > 0 else 0.0
    impulse_factor = peak / mean_abs if mean_abs > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:998–1001  ::  extract_features    mean_abs = float(np.mean(abs_signal))
    shape_factor = rms / mean_abs if mean_abs > 0 else 0.0
    impulse_factor = peak / mean_abs if mean_abs > 0 else 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:1003–1006  ::  extract_features    clearance_factor = peak / (mean_sqrt_abs ** 2) if mean_sqrt_abs > 0 else 0.0

    # -----------------------------------------------------------------------
    # FREQUENCY-DOMAIN (7 features)

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:1008–1018  ::  extract_features    freqs, magnitudes = compute_fft(signal, fs)

    # Exclude DC bin (index 0) for spectral statistics
    freqs_ndc = freqs[1:]
    mags_ndc = magnitudes[1:]

    dominant_freq_hz = float(freqs_ndc[np.argmax(mags_ndc)]) if len(mags_ndc) > 0 else 0.0

    # Spectral power (for weighted statistics)
    power = mags_ndc ** 2
    total_power = float(np.sum(power))

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:1190–1199  ::  extract_features    # g·s → m/s for second integration
    vel_raw *= 9.81
    displacement_m = cumulative_trapezoid(vel_raw, dx=dt, initial=0.0)
    displacement_m -= np.linspace(displacement_m[0], displacement_m[-1], len(displacement_m))
    if nyquist > 100:
        b_d, a_d = butter(2, [max(2.0 / nyquist, 0.001), min(100.0 / nyquist, 0.99)], btype="band")
        disp_filtered = filtfilt(b_d, a_d, displacement_m)
        # ISO 20816-3: peak-to-peak displacement in µm
        pp_displacement_um = float(np.max(disp_filtered) - np.min(disp_filtered)) * 1e6
    else:

firmware/common/dsp/kaltech_dsp.c:160–182  ::  kaltech_spectral_entropy_f32    mag_out[half] = fabsf(kal_fft_work_pack[1]) * dc_scale;
    for (size_t k = 1; k < half; k++) {
        float re = kal_fft_work_pack[2*k];
        float im = kal_fft_work_pack[2*k + 1];
        mag_out[k] = sqrtf(re*re + im*im) * scale;
    }
}

/* Spectral entropy (normalized to [0,1]), excluding DC.
 * entropy = -Σ(p * log2 p) / log2(nz_count), where p = power / total_power. */
float kaltech_spectral_entropy_f32(const float *mag, size_t n) {
    size_t half = n / 2;
    double total = 0.0;
    for (size_t k = 1; k <= half; k++) {
        double m = mag[k];
        total += m * m;
    }
    if (total <= 0.0) return 0.0f;

    double ent = 0.0;
    int nz = 0;
    for (size_t k = 1; k <= half; k++) {
        double m = mag[k];

v5/lib/features_v5.py:1020–1037  ::  extract_features    if total_power > 0:
        weights = power / total_power
        spectral_centroid = float(np.sum(freqs_ndc * weights))
        spectral_bandwidth = float(np.sqrt(np.sum(((freqs_ndc - spectral_centroid) ** 2) * weights)))

        # Rolloff: frequency below which 85% of spectral energy resides
        cumulative_energy = np.cumsum(power) / total_power
        rolloff_idx = np.searchsorted(cumulative_energy, 0.85)
        spectral_rolloff = float(freqs_ndc[min(rolloff_idx, len(freqs_ndc) - 1)])

        # Flatness: geometric mean / arithmetic mean of power spectrum
        # High flatness → noise-like; low flatness → tonal/harmonic
        log_power = np.log(power + 1e-20)
        geo_mean = float(np.exp(np.mean(log_power)))
        arith_mean = float(np.mean(power))
        spectral_flatness = geo_mean / arith_mean if arith_mean > 0 else 0.0
    else:
        spectral_centroid = 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:1020–1037  ::  extract_features    if total_power > 0:
        weights = power / total_power
        spectral_centroid = float(np.sum(freqs_ndc * weights))
        spectral_bandwidth = float(np.sqrt(np.sum(((freqs_ndc - spectral_centroid) ** 2) * weights)))

        # Rolloff: frequency below which 85% of spectral energy resides
        cumulative_energy = np.cumsum(power) / total_power
        rolloff_idx = np.searchsorted(cumulative_energy, 0.85)
        spectral_rolloff = float(freqs_ndc[min(rolloff_idx, len(freqs_ndc) - 1)])

        # Flatness: geometric mean / arithmetic mean of power spectrum
        # High flatness → noise-like; low flatness → tonal/harmonic
        log_power = np.log(power + 1e-20)
        geo_mean = float(np.exp(np.mean(log_power)))
        arith_mean = float(np.mean(power))
        spectral_flatness = geo_mean / arith_mean if arith_mean > 0 else 0.0
    else:
        spectral_centroid = 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:1020–1037  ::  extract_features    if total_power > 0:
        weights = power / total_power
        spectral_centroid = float(np.sum(freqs_ndc * weights))
        spectral_bandwidth = float(np.sqrt(np.sum(((freqs_ndc - spectral_centroid) ** 2) * weights)))

        # Rolloff: frequency below which 85% of spectral energy resides
        cumulative_energy = np.cumsum(power) / total_power
        rolloff_idx = np.searchsorted(cumulative_energy, 0.85)
        spectral_rolloff = float(freqs_ndc[min(rolloff_idx, len(freqs_ndc) - 1)])

        # Flatness: geometric mean / arithmetic mean of power spectrum
        # High flatness → noise-like; low flatness → tonal/harmonic
        log_power = np.log(power + 1e-20)
        geo_mean = float(np.exp(np.mean(log_power)))
        arith_mean = float(np.mean(power))
        spectral_flatness = geo_mean / arith_mean if arith_mean > 0 else 0.0
    else:
        spectral_centroid = 0.0

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:1180–1188  ::  extract_features    #
    # Effective band by fs is intentional — the firmware/common parity
    # contract requires this exact clamp to match the C implementation
    # (see firmware/common/dsp/kaltech_filter_coeffs.h
    # KAL_FILT_DISP_PP_COEFFS). Changing here would break design specification
    # bit-exact parity.
    #
    # Use unfiltered velocity for integration to avoid double-filtering.
    vel_raw = cumulative_trapezoid(signal, dx=dt, initial=0.0)

firmware/common/dsp/kaltech_dsp.c:187–257  ::  kaltech_spec_features        }
    }
    if (nz <= 1) return 0.0f;
    double norm = log((double)nz) / log(2.0);
    return (float)(ent / (norm > 0.0 ? norm : 1.0));
}

/* Compute the full set of 10 spectral features from a magnitude spectrum.
 * All formulas mirror backend/features.py exactly — centroid / bandwidth /
 * rolloff / flatness use power-weighted statistics on non-DC bins. */
void kaltech_spec_features(const float *mag, size_t n, float fs,
                           kaltech_spec_feats_t *out) {
    memset(out, 0, sizeof(*out));
    size_t half = n / 2;
    if (half < 1) return;

    out->dominant_freq_hz = kaltech_dominant_freq_f32(mag, n, fs);
    out->spectral_entropy = kaltech_spectral_entropy_f32(mag, n);

    /* Power spectrum excluding DC. */
    double total_power = 0.0;
    for (size_t k = 1; k <= half; k++) total_power += (double)mag[k] * (double)mag[k];
    if (total_power <= 0.0) return;

    double centroid = 0.0, bw_acc = 0.0;
    double cum = 0.0;
    double rolloff_threshold = 0.85 * total_power;
    int rolloff_bin = (int)half;
    double log_sum = 0.0, power_sum = 0.0;
    float  fs_per_n = fs / (float)n;
    for (size_t k = 1; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        centroid += freq * p;
        cum += p;
        if (rolloff_bin == (int)half && cum >= rolloff_threshold)
            rolloff_bin = (int)k;
        log_sum   += log(p + 1e-20);
        power_sum += p;
    }
    centroid /= total_power;

    for (size_t k = 1; k <= half; k++) {
        double p    = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        double d    = freq - centroid;
        bw_acc += d * d * p;
    }
    double bandwidth = sqrt(bw_acc / total_power);
    double geo_mean   = exp(log_sum / (double)half);
    double arith_mean = power_sum / (double)half;
    double flatness   = arith_mean > 0.0 ? geo_mean / arith_mean : 0.0;

    out->spectral_centroid  = (float)centroid;
    out->spectral_bandwidth = (float)bandwidth;
    out->spectral_rolloff   = (float)((double)rolloff_bin * fs_per_n);
    out->spectral_flatness  = (float)flatness;

    /* Band-energy ratios — low/mid/high thirds of Nyquist + ultrasonic (>=10 kHz).
     * Python sums over ALL bins (including DC and Nyquist) using power = mag².
     * total_band is the denominator: sum of all power + tiny epsilon. */
    float nyq = fs * 0.5f;
    double band_edges[4] = { 0.0, nyq / 3.0, 2.0 * nyq / 3.0, nyq };
    double band[3] = {0, 0, 0};
    double total_band = 0.0;
    double band_ultra = 0.0;
    for (size_t k = 0; k <= half; k++) {
        double p = (double)mag[k] * (double)mag[k];
        double freq = (double)k * fs_per_n;
        total_band += p;
        for (int b = 0; b < 3; b++) {

v5/lib/features_v5.py:793–821  ::  compute_rms_velocity        hop_length: Hop size between STFT frames.

    Returns:
        float32 array of shape (n_mels, time_frames) normalised to [0, 1].
    """
    _f, _t, Zxx = stft(segment, fs=fs, nperseg=n_fft, noverlap=n_fft - hop_length)
    power = np.abs(Zxx) ** 2

    mel_basis = _mel_filterbank(fs, n_fft, n_mels)
    mel_spec = mel_basis @ power[: n_fft // 2 + 1, :]

    log_mel = np.log(mel_spec + 1e-9)
    log_mel = (log_mel - log_mel.min()) / (log_mel.max() - log_mel.min() + 1e-9)

    return log_mel.astype(np.float32)


# ---------------------------------------------------------------------------
# RMS Velocity (ISO 10816)
# ---------------------------------------------------------------------------

def compute_rms_velocity(signal: np.ndarray, fs: int = CWRU_FS) -> float:
    """
    Integrate acceleration signal to velocity and compute RMS in mm/s.

    ISO 10816-1 specifies velocity RMS in the 10-1000 Hz band.
    Integration via cumulative trapezoidal rule, followed by 10-1000 Hz
    bandpass filter, then RMS computation.

firmware/common/dsp/kaltech_dsp.c:1146–1172  ::  kaltech_iso_velocity_rms_f32    for (size_t i = start; i < start + count; i++) {
        const kaltech_filter_band_t *b = &KAL_FILTER_BANK[i];
        float dc = logf(b->center_hz)    - log_req_c;
        float db = logf(b->bandwidth_hz) - log_req_bw;
        float d = dc * dc + W_BW * db * db;
        if (d < best_d) { best_d = d; best_idx = i; }
    }
    return &KAL_FILTER_BANK[best_idx];
}

void kaltech_optimal_envelope_features(
    const float *x, size_t n, float fs,
    float kurt_center_hz, float kurt_bw_hz,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float out_12[12]) {
    /* zero-init for early-return paths */
    for (int i = 0; i < 12; i++) out_12[i] = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;
    if (kurt_bw_hz < 50.0f) return;                  /* matches Python guard */

    const kaltech_filter_band_t *band =
        kaltech_select_filter_band(fs, kurt_center_hz, kurt_bw_hz);
    if (!band) return;

    /* Reuse the shared envelope-spectrum scratch — must reside in
     * env_mag_static (sized KAL_FFT_MAX_N/2 + 1). */

v5/lib/features_v5.py:793–821  ::  compute_rms_velocity        hop_length: Hop size between STFT frames.

    Returns:
        float32 array of shape (n_mels, time_frames) normalised to [0, 1].
    """
    _f, _t, Zxx = stft(segment, fs=fs, nperseg=n_fft, noverlap=n_fft - hop_length)
    power = np.abs(Zxx) ** 2

    mel_basis = _mel_filterbank(fs, n_fft, n_mels)
    mel_spec = mel_basis @ power[: n_fft // 2 + 1, :]

    log_mel = np.log(mel_spec + 1e-9)
    log_mel = (log_mel - log_mel.min()) / (log_mel.max() - log_mel.min() + 1e-9)

    return log_mel.astype(np.float32)


# ---------------------------------------------------------------------------
# RMS Velocity (ISO 10816)
# ---------------------------------------------------------------------------

def compute_rms_velocity(signal: np.ndarray, fs: int = CWRU_FS) -> float:
    """
    Integrate acceleration signal to velocity and compute RMS in mm/s.

    ISO 10816-1 specifies velocity RMS in the 10-1000 Hz band.
    Integration via cumulative trapezoidal rule, followed by 10-1000 Hz
    bandpass filter, then RMS computation.

firmware/common/dsp/kaltech_dsp.c:1175–1194  ::  kaltech_iso_velocity_peak_f32                                   env_mag_opt);

    float nyq = fs * 0.5f;
    /* 1x — bandwidth_hz=3.0 (matches Python features.py optimal_env_* path) */
    if (bpfo_hz > 0)               out_12[0] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfo_hz, 3.0f);
    if (bpfi_hz > 0)               out_12[1] = kaltech_energy_near_f32(env_mag_opt, n, fs, bpfi_hz, 3.0f);
    if (bsf_hz > 0)                out_12[2] = kaltech_energy_near_f32(env_mag_opt, n, fs, bsf_hz,  3.0f);
    if (ftf_hz > 0)                out_12[3] = kaltech_energy_near_f32(env_mag_opt, n, fs, ftf_hz,  3.0f);
    /* 2x */
    if (bpfo_hz > 0 && 2*bpfo_hz < nyq) out_12[4] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfo_hz, 3.0f);
    /* 3x */
    if (bpfo_hz > 0 && 3*bpfo_hz < nyq) out_12[5] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfo_hz, 3.0f);
    if (bpfi_hz > 0 && 2*bpfi_hz < nyq) out_12[6] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bpfi_hz, 3.0f);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq) out_12[7] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bpfi_hz, 3.0f);
    if (bsf_hz  > 0 && 2*bsf_hz  < nyq) out_12[8] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*bsf_hz,  3.0f);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq) out_12[9] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*bsf_hz,  3.0f);
    if (ftf_hz  > 0 && 2*ftf_hz  < nyq) out_12[10] = kaltech_energy_near_f32(env_mag_opt, n, fs, 2*ftf_hz, 3.0f);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq) out_12[11] = kaltech_energy_near_f32(env_mag_opt, n, fs, 3*ftf_hz, 3.0f);
}

v5/lib/features_v5.py:1499–1623  ::  extract_randall_features    # Dominant order (excluding DC)
    non_dc = orders_trim > 0.5
    if np.any(non_dc):
        dominant_idx = np.argmax(mags_trim[non_dc])
        order_energies["dominant_order"] = float(orders_trim[non_dc][dominant_idx])
    else:
        order_energies["dominant_order"] = 0.0

    # 1x/2x ratio (imbalance indicator — high 1x relative to 2x)
    e1x = order_energies.get("order_1x_energy", 0.0)
    e2x = order_energies.get("order_2x_energy", 0.0)
    order_energies["order_1x_2x_ratio"] = min(e1x / (e2x + 1e-8), 1000.0)

    # Sub-synchronous energy (orders < 1.0) — looseness indicator
    mask_sub = (orders_trim > 0.1) & (orders_trim < 0.95)
    order_energies["order_subsync_energy"] = float(np.sum(mags_trim[mask_sub] ** 2))

    # Include the defect order values for reference
    order_energies.update(defect_orders)

    return order_energies


def extract_randall_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, Any]:
    """
    Extract advanced diagnostic features using Randall's techniques.

    Complements extract_features() with:
    - Cepstrum-based periodicity detection
    - Spectral kurtosis band selection
    - Optimal-band envelope analysis
    """
    features: dict[str, Any] = {}

    # --- Cepstrum analysis ---
    quefrency, cepstrum = compute_cepstrum(signal, fs)

    # Peak cepstrum value (excluding near-zero quefrency)
    min_quef = 0.002  # 2ms minimum (500 Hz max)
    max_quef = 0.1    # 100ms maximum (10 Hz min)
    mask = (quefrency >= min_quef) & (quefrency <= max_quef)
    if np.any(mask):
        peak_idx = np.argmax(cepstrum[mask])
        features["cepstrum_peak_quefrency"] = float(quefrency[mask][peak_idx])
        features["cepstrum_peak_magnitude"] = float(cepstrum[mask][peak_idx])
        features["cepstrum_peak_freq"] = (
            1.0 / features["cepstrum_peak_quefrency"]
            if features["cepstrum_peak_quefrency"] > 0
            else 0.0
        )
    else:
        features["cepstrum_peak_quefrency"] = 0.0
        features["cepstrum_peak_magnitude"] = 0.0
        features["cepstrum_peak_freq"] = 0.0

    # Check if cepstrum peak matches any defect frequency.
    # A bearing impact train has cepstrum peaks at the IMPACT PERIOD (1/BPFO)
    # AND its integer multiples (2/BPFO, 3/BPFO, ...). Original implementation
    # only matched the fundamental cep_freq vs defect freq within ±5%, which
    # missed signals where the algorithm picked a higher cepstral harmonic.
    # Fix: check if peak_quefrency × defect_freq is within ±10% of any integer
    # K ∈ [1, 5]. K=1 reduces to the original test (slightly relaxed), K≥2
    # captures higher-order cepstral harmonics. Mirrors firmware fix in
    # kaltech_cepstrum_extended_f32.
    # cepstrum_defect_match: categorical {none, bpfo, bpfi, bsf, ftf}.
    # Pre-seed to "none" so the key always exists in the returned dict —
    # downstream callers (services/features_api/main.py contract check,
    # NPZ training pipeline) require stable schema regardless of whether
    # rpm is provided. Wave-2 fix C-1.
    features["cepstrum_defect_match"] = "none"
    if rpm is not None and rpm > 0:
        defect_freqs = bearing_defect_freqs(rpm, bearing_type)
        peak_q = features["cepstrum_peak_quefrency"]
        if peak_q > 0:
            best_err = 1e30
# … 45 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1464–1469  ::  kaltech_per_axis_features::rms_acceleration_g        }
        if (bsf > 0) {
            out->envelope_energy_bsf = kaltech_energy_near_f32(env_mag, n, fs, bsf, 5.0f);
            if (2*bsf < nyq) out->envelope_energy_2x_bsf = kaltech_energy_near_f32(env_mag, n, fs, 2*bsf, 5.0f);
            if (3*bsf < nyq) out->envelope_energy_3x_bsf = kaltech_energy_near_f32(env_mag, n, fs, 3*bsf, 5.0f);
        }

v5/lib/features_v5.py:1499–1623  ::  extract_randall_features    # Dominant order (excluding DC)
    non_dc = orders_trim > 0.5
    if np.any(non_dc):
        dominant_idx = np.argmax(mags_trim[non_dc])
        order_energies["dominant_order"] = float(orders_trim[non_dc][dominant_idx])
    else:
        order_energies["dominant_order"] = 0.0

    # 1x/2x ratio (imbalance indicator — high 1x relative to 2x)
    e1x = order_energies.get("order_1x_energy", 0.0)
    e2x = order_energies.get("order_2x_energy", 0.0)
    order_energies["order_1x_2x_ratio"] = min(e1x / (e2x + 1e-8), 1000.0)

    # Sub-synchronous energy (orders < 1.0) — looseness indicator
    mask_sub = (orders_trim > 0.1) & (orders_trim < 0.95)
    order_energies["order_subsync_energy"] = float(np.sum(mags_trim[mask_sub] ** 2))

    # Include the defect order values for reference
    order_energies.update(defect_orders)

    return order_energies


def extract_randall_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, Any]:
    """
    Extract advanced diagnostic features using Randall's techniques.

    Complements extract_features() with:
    - Cepstrum-based periodicity detection
    - Spectral kurtosis band selection
    - Optimal-band envelope analysis
    """
    features: dict[str, Any] = {}

    # --- Cepstrum analysis ---
    quefrency, cepstrum = compute_cepstrum(signal, fs)

    # Peak cepstrum value (excluding near-zero quefrency)
    min_quef = 0.002  # 2ms minimum (500 Hz max)
    max_quef = 0.1    # 100ms maximum (10 Hz min)
    mask = (quefrency >= min_quef) & (quefrency <= max_quef)
    if np.any(mask):
        peak_idx = np.argmax(cepstrum[mask])
        features["cepstrum_peak_quefrency"] = float(quefrency[mask][peak_idx])
        features["cepstrum_peak_magnitude"] = float(cepstrum[mask][peak_idx])
        features["cepstrum_peak_freq"] = (
            1.0 / features["cepstrum_peak_quefrency"]
            if features["cepstrum_peak_quefrency"] > 0
            else 0.0
        )
    else:
        features["cepstrum_peak_quefrency"] = 0.0
        features["cepstrum_peak_magnitude"] = 0.0
        features["cepstrum_peak_freq"] = 0.0

    # Check if cepstrum peak matches any defect frequency.
    # A bearing impact train has cepstrum peaks at the IMPACT PERIOD (1/BPFO)
    # AND its integer multiples (2/BPFO, 3/BPFO, ...). Original implementation
    # only matched the fundamental cep_freq vs defect freq within ±5%, which
    # missed signals where the algorithm picked a higher cepstral harmonic.
    # Fix: check if peak_quefrency × defect_freq is within ±10% of any integer
    # K ∈ [1, 5]. K=1 reduces to the original test (slightly relaxed), K≥2
    # captures higher-order cepstral harmonics. Mirrors firmware fix in
    # kaltech_cepstrum_extended_f32.
    # cepstrum_defect_match: categorical {none, bpfo, bpfi, bsf, ftf}.
    # Pre-seed to "none" so the key always exists in the returned dict —
    # downstream callers (services/features_api/main.py contract check,
    # NPZ training pipeline) require stable schema regardless of whether
    # rpm is provided. Wave-2 fix C-1.
    features["cepstrum_defect_match"] = "none"
    if rpm is not None and rpm > 0:
        defect_freqs = bearing_defect_freqs(rpm, bearing_type)
        peak_q = features["cepstrum_peak_quefrency"]
        if peak_q > 0:
            best_err = 1e30
# … 45 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1196–1227  ::  kaltech_pp_displacement_um_f32    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    /* cumulative trapezoid: v[0] = 0; v[i] = v[i-1] + 0.5*(x[i-1]+x[i])*dt */
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;

    /* Remove linear drift: v -= linspace(v[0], v[-1], n). v[0]=0, so just
     * subtract i/(n-1) * v[-1]. */
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;

    /* g·s → mm/s */
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;

    /* Bandpass 10–1000 Hz, filtfilt */
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);

    /* RMS */
    double ss = 0.0;
    for (size_t i = 0; i < n; i++) ss += (double)kal_env_tmp2[i] * (double)kal_env_tmp2[i];
    return (float)sqrt(ss / (double)n);
}

/* ─── Peak velocity + PP displacement helpers ───────────────────── */
float kaltech_iso_velocity_peak_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:964–975  ::  kaltech_energy_near_f32    if (bpfo_hz > 0 && 3*bpfo_hz < nyq)
        out_24[8]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfo_hz, BW_HARM);
    if (bpfi_hz > 0 && 3*bpfi_hz < nyq)
        out_24[9]  = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bpfi_hz, BW_HARM);
    if (bsf_hz  > 0 && 3*bsf_hz  < nyq)
        out_24[10] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*bsf_hz,  BW_HARM);
    if (ftf_hz  > 0 && 3*ftf_hz  < nyq)
        out_24[11] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, 3*ftf_hz,  BW_HARM);

    /* 3. Kurtogram-selected band squared envelope — slots 12-23.
     *    Skip if band is invalid (<50 Hz) per Python guard. */
    if (kurt_bw_hz < 50.0f) return;

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:336–382  ::  envelope_spectrum

def envelope_spectrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    band_low: float = 2000.0,
    band_high: float = 5000.0,
    squared: bool = False,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Hilbert-transform envelope analysis.

    Steps:
      1. Bandpass filter around housing resonance frequency.
      2. Hilbert transform → analytic signal → take magnitude (envelope).
      3. Optionally square the envelope (Randall §5.5, Fig 5.39).
      4. Remove DC component.
      5. FFT of envelope → reveals fault modulation frequencies.

    Args:
        signal:    1-D acceleration time series.
        fs:        Sampling frequency in Hz.
        band_low:  Lower edge of bandpass filter (Hz).
        band_high: Upper edge of bandpass filter (Hz).
        squared:   If True, FFT operates on envelope² instead of envelope.
                   Squared envelope prevents aliasing of the magnitude operation
                   (Randall p.201) and concentrates energy at modulation lines.
                   V5 uses squared=True for the new slr_sq_* features.

    Returns:
        (freqs, fft_env) — frequency axis and envelope spectrum magnitudes.
    """
    nyq = fs / 2.0
    b, a = butter(4, [band_low / nyq, band_high / nyq], btype="band")
    filtered = filtfilt(b, a, signal)

    analytic = hilbert(filtered)
    envelope = np.abs(analytic)
    if squared:
        # Square then DC-remove → preserves Randall's recommended pipeline:
        # |FFT(envelope² - mean(envelope²))| / N
        envelope = envelope * envelope
    envelope -= np.mean(envelope)

    N = len(envelope)
    freqs = np.fft.rfftfreq(N, d=1.0 / fs)
    fft_env = np.abs(np.fft.rfft(envelope)) / N

firmware/common/dsp/kaltech_dsp.c:631–669  ::  kaltech_envelope_spectrum_f32    }

    /* second forward — steady-state init for reversed[0] */
    sos_zi_for_step(sos, n_sec, kal_filt_pad_b[0], state);
    sos_run_with_state(sos, n_sec, state, kal_filt_pad_b, n_ext, kal_filt_pad_a);

    /* reverse back into y, trimming padding */
    for (size_t i = 0; i < n; i++) y[i] = kal_filt_pad_a[n_ext - 1 - padlen - i];
}

/* Ext-buffer variant of kaltech_sos_filtfilt_f32 for LONG records (deep
 * capture, n up to 32768): identical algorithm, but the two padded work
 * buffers are CALLER-PROVIDED (PSRAM on the chip) instead of the static
 * SRAM pads capped at KAL_FFT_MAX_N. ext_a/ext_b must each hold
 * n + 2*padlen floats, padlen = 3*(2*n_sec+1) (<= n/4 for short inputs);
 * returns without touching y when ext_cap is insufficient — callers MUST
 * size against KAL_SOS_FILTFILT_EXT_PAD. (2026-07-17, edge-parity #24.) */
void kaltech_sos_filtfilt_ext_f32(const float *sos, int n_sec,
                                  const float *x, size_t n, float *y,
                                  float *ext_a, float *ext_b, size_t ext_cap) {
    if (n == 0 || n_sec <= 0 || n_sec > 8 || !ext_a || !ext_b) return;
    int padlen = 3 * (2 * n_sec + 1);
    if ((size_t)padlen * 2 >= n) { padlen = (int)(n / 4); }
    size_t n_ext = n + 2 * (size_t)padlen;
    if (n_ext > ext_cap) return;

    for (int i = 0; i < padlen; i++)
        ext_a[i] = 2.0f * x[0] - x[padlen - 1 - i];
    for (size_t i = 0; i < n; i++)
        ext_a[padlen + i] = x[i];
    for (int i = 0; i < padlen; i++)
        ext_a[padlen + n + i] = 2.0f * x[n - 1] - x[n - 2 - i];

    float state[8 * 4];
    sos_zi_for_step(sos, n_sec, ext_a[0], state);
    sos_run_with_state(sos, n_sec, state, ext_a, n_ext, ext_b);

    for (size_t i = 0; i < n_ext / 2; i++) {
        float t = ext_b[i];

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:1107–1144  ::  kaltech_optimal_envelope_features     * peak is more likely line noise / a single tone. */
    if (ratio2 < 0.05f && ratio3 < 0.05f) return 0.0f;

    return peak_hz * 60.0f;
}

/* ===================== Antoni filter bank — selector + optimal envelope =====================
 * Catalog data lives in kaltech_filter_bank.h (auto-generated). We pick the
 * entry whose (log-center, log-bandwidth) Euclidean distance is smallest from
 * the kurtogram's request. Bandwidth dominates the metric — picking the right
 * resolution matters more than the exact center frequency.
 */
#include "kaltech_filter_bank.h"

const kaltech_filter_band_t *kaltech_select_filter_band(
    float fs, float requested_center_hz, float requested_bw_hz) {
    /* Locate the per-fs slice in the catalog. We tolerate ±1% sample-rate
     * mismatch (e.g. 12000 vs 12005). */
    int fs_slice = -1;
    for (int i = 0; i < KAL_FILTER_BANK_NUM_FS; i++) {
        float ratio = fs / KAL_FILTER_BANK_FS[i];
        if (ratio > 0.99f && ratio < 1.01f) { fs_slice = i; break; }
    }
    if (fs_slice < 0) return NULL;
    if (requested_bw_hz < 1.0f) return NULL;        /* invalid kurtogram band */

    size_t start = KAL_FILTER_BANK_START[fs_slice];
    size_t count = KAL_FILTER_BANK_COUNT[fs_slice];
    if (count == 0) return NULL;

    float log_req_c  = logf(requested_center_hz > 1.0f ? requested_center_hz : 1.0f);
    float log_req_bw = logf(requested_bw_hz);

    /* Bandwidth weight = 2.0 — matching the right resolution dominates the
     * metric. Center accuracy matters less because the bandpass already lets
     * energy through across the full passband. */
    const float W_BW = 2.0f;
    float best_d = 1e30f;

v5/lib/features_v5.py:489–499  ::  drs_squared_envelope_features

def drs_squared_envelope_features(*args, **kwargs):
    """DEPRECATED alias for ``slr_squared_envelope_features``.

    The original name "DRS" misleadingly implied Sawalhi-Randall Discrete/Random
    Separation (2008). What this function actually applies is spectral line
    removal (median-of-neighbour-bins comb filter). The keys were renamed in
    ``drs_sq_*`` to ``slr_sq_*`` for honesty. Use the new name in new
    code. This alias kept temporarily to avoid breaking external callers; will
    be removed in V6.

firmware/common/dsp/kaltech_dsp.c:869–962  ::  kaltech_drs_squared_envelope_features    float *out_env_bpfo, float *out_env_bpfi,
    float *out_env_bsf,  float *out_env_ftf,
    float *out_opt_bpfo, float *out_opt_bpfi,
    float *out_opt_bsf,  float *out_opt_ftf)
{
    /* Initialize all out pointers to 0 (caller may pass any subset NULL). */
    if (out_env_bpfo) *out_env_bpfo = 0.0f;
    if (out_env_bpfi) *out_env_bpfi = 0.0f;
    if (out_env_bsf)  *out_env_bsf  = 0.0f;
    if (out_env_ftf)  *out_env_ftf  = 0.0f;
    if (out_opt_bpfo) *out_opt_bpfo = 0.0f;
    if (out_opt_bpfi) *out_opt_bpfi = 0.0f;
    if (out_opt_bsf)  *out_opt_bsf  = 0.0f;
    if (out_opt_ftf)  *out_opt_ftf  = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband (CWRU envelope band) → defect energies.
     * Same coeffs / bandwidth-Hz as kaltech_per_axis_features lines 1173-1194. */
    static float drs_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(drs_resid, n,
        KAL_FILT_ENV_CWRU_COEFFS, KAL_FILT_ENV_CWRU_N_SEC, drs_env_mag);
    if (out_env_bpfo && bpfo > 0)
        *out_env_bpfo = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfo, 5.0f);
    if (out_env_bpfi && bpfi > 0)
        *out_env_bpfi = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfi, 5.0f);
    if (out_env_bsf && bsf > 0)
        *out_env_bsf  = kaltech_energy_near_f32(drs_env_mag, n, fs, bsf,  5.0f);
    if (out_env_ftf && ftf > 0)
        *out_env_ftf  = kaltech_energy_near_f32(drs_env_mag, n, fs, ftf,  5.0f);

    /* 3. Kurtogram-selected band → optimal_env_* equivalent.
     * Reuses the band the raw-signal kurtogram already chose (passed in by
     * the caller). If the band is invalid (<50 Hz), skip. */
    if (kurt_bw_hz < 50.0f) return;

    float opt_band[12] = {0};
    kaltech_optimal_envelope_features(drs_resid, n, fs,
        kurt_center_hz, kurt_bw_hz, bpfo, bpfi, bsf, ftf, opt_band);
    if (out_opt_bpfo) *out_opt_bpfo = opt_band[0];
    if (out_opt_bpfi) *out_opt_bpfi = opt_band[1];
    if (out_opt_bsf)  *out_opt_bsf  = opt_band[2];
    if (out_opt_ftf)  *out_opt_ftf  = opt_band[3];
}

void kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
# … 14 more lines truncated …

v5/lib/features_v5.py:489–499  ::  drs_squared_envelope_features

def drs_squared_envelope_features(*args, **kwargs):
    """DEPRECATED alias for ``slr_squared_envelope_features``.

    The original name "DRS" misleadingly implied Sawalhi-Randall Discrete/Random
    Separation (2008). What this function actually applies is spectral line
    removal (median-of-neighbour-bins comb filter). The keys were renamed in
    ``drs_sq_*`` to ``slr_sq_*`` for honesty. Use the new name in new
    code. This alias kept temporarily to avoid breaking external callers; will
    be removed in V6.

firmware/common/dsp/kaltech_dsp.c:869–962  ::  kaltech_drs_squared_envelope_features    float *out_env_bpfo, float *out_env_bpfi,
    float *out_env_bsf,  float *out_env_ftf,
    float *out_opt_bpfo, float *out_opt_bpfi,
    float *out_opt_bsf,  float *out_opt_ftf)
{
    /* Initialize all out pointers to 0 (caller may pass any subset NULL). */
    if (out_env_bpfo) *out_env_bpfo = 0.0f;
    if (out_env_bpfi) *out_env_bpfi = 0.0f;
    if (out_env_bsf)  *out_env_bsf  = 0.0f;
    if (out_env_ftf)  *out_env_ftf  = 0.0f;
    if (out_opt_bpfo) *out_opt_bpfo = 0.0f;
    if (out_opt_bpfi) *out_opt_bpfi = 0.0f;
    if (out_opt_bsf)  *out_opt_bsf  = 0.0f;
    if (out_opt_ftf)  *out_opt_ftf  = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband (CWRU envelope band) → defect energies.
     * Same coeffs / bandwidth-Hz as kaltech_per_axis_features lines 1173-1194. */
    static float drs_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(drs_resid, n,
        KAL_FILT_ENV_CWRU_COEFFS, KAL_FILT_ENV_CWRU_N_SEC, drs_env_mag);
    if (out_env_bpfo && bpfo > 0)
        *out_env_bpfo = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfo, 5.0f);
    if (out_env_bpfi && bpfi > 0)
        *out_env_bpfi = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfi, 5.0f);
    if (out_env_bsf && bsf > 0)
        *out_env_bsf  = kaltech_energy_near_f32(drs_env_mag, n, fs, bsf,  5.0f);
    if (out_env_ftf && ftf > 0)
        *out_env_ftf  = kaltech_energy_near_f32(drs_env_mag, n, fs, ftf,  5.0f);

    /* 3. Kurtogram-selected band → optimal_env_* equivalent.
     * Reuses the band the raw-signal kurtogram already chose (passed in by
     * the caller). If the band is invalid (<50 Hz), skip. */
    if (kurt_bw_hz < 50.0f) return;

    float opt_band[12] = {0};
    kaltech_optimal_envelope_features(drs_resid, n, fs,
        kurt_center_hz, kurt_bw_hz, bpfo, bpfi, bsf, ftf, opt_band);
    if (out_opt_bpfo) *out_opt_bpfo = opt_band[0];
    if (out_opt_bpfi) *out_opt_bpfi = opt_band[1];
    if (out_opt_bsf)  *out_opt_bsf  = opt_band[2];
    if (out_opt_ftf)  *out_opt_ftf  = opt_band[3];
}

void kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
# … 14 more lines truncated …

v5/lib/features_v5.py:489–499  ::  drs_squared_envelope_features

def drs_squared_envelope_features(*args, **kwargs):
    """DEPRECATED alias for ``slr_squared_envelope_features``.

    The original name "DRS" misleadingly implied Sawalhi-Randall Discrete/Random
    Separation (2008). What this function actually applies is spectral line
    removal (median-of-neighbour-bins comb filter). The keys were renamed in
    ``drs_sq_*`` to ``slr_sq_*`` for honesty. Use the new name in new
    code. This alias kept temporarily to avoid breaking external callers; will
    be removed in V6.

firmware/common/dsp/kaltech_dsp.c:869–962  ::  kaltech_drs_squared_envelope_features    float *out_env_bpfo, float *out_env_bpfi,
    float *out_env_bsf,  float *out_env_ftf,
    float *out_opt_bpfo, float *out_opt_bpfi,
    float *out_opt_bsf,  float *out_opt_ftf)
{
    /* Initialize all out pointers to 0 (caller may pass any subset NULL). */
    if (out_env_bpfo) *out_env_bpfo = 0.0f;
    if (out_env_bpfi) *out_env_bpfi = 0.0f;
    if (out_env_bsf)  *out_env_bsf  = 0.0f;
    if (out_env_ftf)  *out_env_ftf  = 0.0f;
    if (out_opt_bpfo) *out_opt_bpfo = 0.0f;
    if (out_opt_bpfi) *out_opt_bpfi = 0.0f;
    if (out_opt_bsf)  *out_opt_bsf  = 0.0f;
    if (out_opt_ftf)  *out_opt_ftf  = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband (CWRU envelope band) → defect energies.
     * Same coeffs / bandwidth-Hz as kaltech_per_axis_features lines 1173-1194. */
    static float drs_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(drs_resid, n,
        KAL_FILT_ENV_CWRU_COEFFS, KAL_FILT_ENV_CWRU_N_SEC, drs_env_mag);
    if (out_env_bpfo && bpfo > 0)
        *out_env_bpfo = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfo, 5.0f);
    if (out_env_bpfi && bpfi > 0)
        *out_env_bpfi = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfi, 5.0f);
    if (out_env_bsf && bsf > 0)
        *out_env_bsf  = kaltech_energy_near_f32(drs_env_mag, n, fs, bsf,  5.0f);
    if (out_env_ftf && ftf > 0)
        *out_env_ftf  = kaltech_energy_near_f32(drs_env_mag, n, fs, ftf,  5.0f);

    /* 3. Kurtogram-selected band → optimal_env_* equivalent.
     * Reuses the band the raw-signal kurtogram already chose (passed in by
     * the caller). If the band is invalid (<50 Hz), skip. */
    if (kurt_bw_hz < 50.0f) return;

    float opt_band[12] = {0};
    kaltech_optimal_envelope_features(drs_resid, n, fs,
        kurt_center_hz, kurt_bw_hz, bpfo, bpfi, bsf, ftf, opt_band);
    if (out_opt_bpfo) *out_opt_bpfo = opt_band[0];
    if (out_opt_bpfi) *out_opt_bpfi = opt_band[1];
    if (out_opt_bsf)  *out_opt_bsf  = opt_band[2];
    if (out_opt_ftf)  *out_opt_ftf  = opt_band[3];
}

void kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
# … 14 more lines truncated …

v5/lib/features_v5.py:489–499  ::  drs_squared_envelope_features

def drs_squared_envelope_features(*args, **kwargs):
    """DEPRECATED alias for ``slr_squared_envelope_features``.

    The original name "DRS" misleadingly implied Sawalhi-Randall Discrete/Random
    Separation (2008). What this function actually applies is spectral line
    removal (median-of-neighbour-bins comb filter). The keys were renamed in
    ``drs_sq_*`` to ``slr_sq_*`` for honesty. Use the new name in new
    code. This alias kept temporarily to avoid breaking external callers; will
    be removed in V6.

firmware/common/dsp/kaltech_dsp.c:869–962  ::  kaltech_drs_squared_envelope_features    float *out_env_bpfo, float *out_env_bpfi,
    float *out_env_bsf,  float *out_env_ftf,
    float *out_opt_bpfo, float *out_opt_bpfi,
    float *out_opt_bsf,  float *out_opt_ftf)
{
    /* Initialize all out pointers to 0 (caller may pass any subset NULL). */
    if (out_env_bpfo) *out_env_bpfo = 0.0f;
    if (out_env_bpfi) *out_env_bpfi = 0.0f;
    if (out_env_bsf)  *out_env_bsf  = 0.0f;
    if (out_env_ftf)  *out_env_ftf  = 0.0f;
    if (out_opt_bpfo) *out_opt_bpfo = 0.0f;
    if (out_opt_bpfi) *out_opt_bpfi = 0.0f;
    if (out_opt_bsf)  *out_opt_bsf  = 0.0f;
    if (out_opt_ftf)  *out_opt_ftf  = 0.0f;

    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband (CWRU envelope band) → defect energies.
     * Same coeffs / bandwidth-Hz as kaltech_per_axis_features lines 1173-1194. */
    static float drs_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_envelope_spectrum_f32(drs_resid, n,
        KAL_FILT_ENV_CWRU_COEFFS, KAL_FILT_ENV_CWRU_N_SEC, drs_env_mag);
    if (out_env_bpfo && bpfo > 0)
        *out_env_bpfo = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfo, 5.0f);
    if (out_env_bpfi && bpfi > 0)
        *out_env_bpfi = kaltech_energy_near_f32(drs_env_mag, n, fs, bpfi, 5.0f);
    if (out_env_bsf && bsf > 0)
        *out_env_bsf  = kaltech_energy_near_f32(drs_env_mag, n, fs, bsf,  5.0f);
    if (out_env_ftf && ftf > 0)
        *out_env_ftf  = kaltech_energy_near_f32(drs_env_mag, n, fs, ftf,  5.0f);

    /* 3. Kurtogram-selected band → optimal_env_* equivalent.
     * Reuses the band the raw-signal kurtogram already chose (passed in by
     * the caller). If the band is invalid (<50 Hz), skip. */
    if (kurt_bw_hz < 50.0f) return;

    float opt_band[12] = {0};
    kaltech_optimal_envelope_features(drs_resid, n, fs,
        kurt_center_hz, kurt_bw_hz, bpfo, bpfi, bsf, ftf, opt_band);
    if (out_opt_bpfo) *out_opt_bpfo = opt_band[0];
    if (out_opt_bpfi) *out_opt_bpfi = opt_band[1];
    if (out_opt_bsf)  *out_opt_bsf  = opt_band[2];
    if (out_opt_ftf)  *out_opt_ftf  = opt_band[3];
}

void kaltech_drs_squared_envelope_features(
    const float *x, size_t n, float fs,
    float bpfo_hz, float bpfi_hz, float bsf_hz, float ftf_hz,
    float kurt_center_hz, float kurt_bw_hz,
    float out_24[24])
{
    for (int i = 0; i < 24; i++) out_24[i] = 0.0f;
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* 1. DRS residual — remove deterministic spectral lines. */
    static float drs_resid[KAL_FFT_MAX_N];
    kaltech_drs_f32(x, n, drs_resid);

    /* 2. Broadband squared envelope. Uses KAL_FILT_ENV_V5_BB_COEFFS (the
     *    [2000, 5000] Hz Butterworth-4 that Python actually uses), NOT the
     *    V4 KAL_FILT_ENV_CWRU_COEFFS which represents a different band by
     *    historical accident and only passes V4 parity via loose tolerance. */
    static float drs_sq_env_mag[KAL_FFT_MAX_N / 2 + 1];
    kaltech_squared_envelope_spectrum_f32(
        drs_resid, n,
        KAL_FILT_ENV_V5_BB_COEFFS, KAL_FILT_ENV_V5_BB_N_SEC,
        drs_sq_env_mag);

    float nyq = fs * 0.5f;
    /* Bandwidths per features_v5.py:drs_squared_envelope_features:
     *   bw = 5.0 if k == 1.0 else 3.0 */
    const float BW_1X = 5.0f, BW_HARM = 3.0f;
    /* Broadband 1x — slots 0-3 */
    if (bpfo_hz > 0 && bpfo_hz < nyq)
        out_24[0] = kaltech_energy_near_f32(drs_sq_env_mag, n, fs, bpfo_hz, BW_1X);
    if (bpfi_hz > 0 && bpfi_hz < nyq)
# … 14 more lines truncated …

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:1394–1400  ::  kaltech_per_axis_features::harmonic_1x                               float shaft_hz,
                               kaltech_per_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));

    kaltech_time_feats_t t;
    kaltech_time_features(x, n, &t);
    out->rms = t.rms; out->mean = t.mean; out->std_dev = t.std_dev;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:1394–1400  ::  kaltech_per_axis_features::harmonic_1x                               float shaft_hz,
                               kaltech_per_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));

    kaltech_time_feats_t t;
    kaltech_time_features(x, n, &t);
    out->rms = t.rms; out->mean = t.mean; out->std_dev = t.std_dev;

v5/lib/features_v5.py:828–836  ::  _energy_near    """
    dt = 1.0 / fs
    velocity = cumulative_trapezoid(signal, dx=dt, initial=0.0)
    # Remove linear drift from integration
    velocity -= np.linspace(velocity[0], velocity[-1], len(velocity))
    # Input is in g, integration gives g·s. Convert: g·s × 9.81 m/s²/g × 1000 mm/m
    velocity_mm_s = velocity * 9.81 * 1000.0  # g·s → mm/s (ISO 10816)
    # ISO 10816-1: bandpass 10-1000 Hz
    nyquist = fs / 2.0

firmware/common/dsp/kaltech_dsp.c:1394–1400  ::  kaltech_per_axis_features::harmonic_1x                               float shaft_hz,
                               kaltech_per_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));

    kaltech_time_feats_t t;
    kaltech_time_features(x, n, &t);
    out->rms = t.rms; out->mean = t.mean; out->std_dev = t.std_dev;

v5/lib/features_v5.py:552–578  ::  compute_cepstrum        if len(signal) < DEFAULT_SUB_WINDOW + DEFAULT_HOP:
            kwargs = {"sub_window": SHORT_SUB_WINDOW, "hop": DEFAULT_HOP}
        result = tachless_cot(signal, float(fs),
                              approximate_rpm=float(approximate_rpm), **kwargs)
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out


def compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

firmware/common/dsp/kaltech_dsp.c:1229–1340  ::  kaltech_cepstrum_extended_f32        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);
    float peak = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float a = fabsf(kal_env_tmp2[i]);
        if (a > peak) peak = a;
    }
    return peak;
}

float kaltech_pp_displacement_um_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1]
                        + 0.5f * (x[i - 1] + x[i]) * 9.81f * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    kal_env_tmp3[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp3[i] = kal_env_tmp3[i - 1]
                        + 0.5f * (kal_env_tmp1[i - 1] + kal_env_tmp1[i]) * dt;
    float d_end = kal_env_tmp3[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp3[i] -= (float)i / (float)(n - 1) * d_end;
    /* ISO 20816-3 displacement bandpass — Python features.py:691 specifies
     * butter(2, [max(2/nyq, 0.001), min(100/nyq, 0.99)], btype='band'). At
     * fs=12000 the lower-cutoff floor activates and the EFFECTIVE band is
     * [6, 100] Hz (not the [2, 100] the comment used to claim). The SOS
     * catalog entry KAL_FILT_DISP_PP is designed against the effective
     * band so parity holds bit-exact. See firmware/common/dsp/kaltech_filter_coeffs.h. */
    kaltech_sos_filtfilt_f32(KAL_FILT_DISP_PP_COEFFS, KAL_FILT_DISP_PP_N_SEC,
                             kal_env_tmp3, n, kal_env_tmp2);
    float mn = kal_env_tmp2[0], mx = kal_env_tmp2[0];
    for (size_t i = 1; i < n; i++) {
        if (kal_env_tmp2[i] < mn) mn = kal_env_tmp2[i];
        if (kal_env_tmp2[i] > mx) mx = kal_env_tmp2[i];
    }
    return (mx - mn) * 1e6f;
}

void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
# … 32 more lines truncated …

v5/lib/features_v5.py:552–578  ::  compute_cepstrum        if len(signal) < DEFAULT_SUB_WINDOW + DEFAULT_HOP:
            kwargs = {"sub_window": SHORT_SUB_WINDOW, "hop": DEFAULT_HOP}
        result = tachless_cot(signal, float(fs),
                              approximate_rpm=float(approximate_rpm), **kwargs)
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out


def compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

firmware/common/dsp/kaltech_dsp.c:1229–1340  ::  kaltech_cepstrum_extended_f32        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);
    float peak = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float a = fabsf(kal_env_tmp2[i]);
        if (a > peak) peak = a;
    }
    return peak;
}

float kaltech_pp_displacement_um_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1]
                        + 0.5f * (x[i - 1] + x[i]) * 9.81f * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    kal_env_tmp3[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp3[i] = kal_env_tmp3[i - 1]
                        + 0.5f * (kal_env_tmp1[i - 1] + kal_env_tmp1[i]) * dt;
    float d_end = kal_env_tmp3[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp3[i] -= (float)i / (float)(n - 1) * d_end;
    /* ISO 20816-3 displacement bandpass — Python features.py:691 specifies
     * butter(2, [max(2/nyq, 0.001), min(100/nyq, 0.99)], btype='band'). At
     * fs=12000 the lower-cutoff floor activates and the EFFECTIVE band is
     * [6, 100] Hz (not the [2, 100] the comment used to claim). The SOS
     * catalog entry KAL_FILT_DISP_PP is designed against the effective
     * band so parity holds bit-exact. See firmware/common/dsp/kaltech_filter_coeffs.h. */
    kaltech_sos_filtfilt_f32(KAL_FILT_DISP_PP_COEFFS, KAL_FILT_DISP_PP_N_SEC,
                             kal_env_tmp3, n, kal_env_tmp2);
    float mn = kal_env_tmp2[0], mx = kal_env_tmp2[0];
    for (size_t i = 1; i < n; i++) {
        if (kal_env_tmp2[i] < mn) mn = kal_env_tmp2[i];
        if (kal_env_tmp2[i] > mx) mx = kal_env_tmp2[i];
    }
    return (mx - mn) * 1e6f;
}

void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
# … 32 more lines truncated …

v5/lib/features_v5.py:552–578  ::  compute_cepstrum        if len(signal) < DEFAULT_SUB_WINDOW + DEFAULT_HOP:
            kwargs = {"sub_window": SHORT_SUB_WINDOW, "hop": DEFAULT_HOP}
        result = tachless_cot(signal, float(fs),
                              approximate_rpm=float(approximate_rpm), **kwargs)
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out


def compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

firmware/common/dsp/kaltech_dsp.c:1229–1340  ::  kaltech_cepstrum_extended_f32        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);
    float peak = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float a = fabsf(kal_env_tmp2[i]);
        if (a > peak) peak = a;
    }
    return peak;
}

float kaltech_pp_displacement_um_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1]
                        + 0.5f * (x[i - 1] + x[i]) * 9.81f * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    kal_env_tmp3[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp3[i] = kal_env_tmp3[i - 1]
                        + 0.5f * (kal_env_tmp1[i - 1] + kal_env_tmp1[i]) * dt;
    float d_end = kal_env_tmp3[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp3[i] -= (float)i / (float)(n - 1) * d_end;
    /* ISO 20816-3 displacement bandpass — Python features.py:691 specifies
     * butter(2, [max(2/nyq, 0.001), min(100/nyq, 0.99)], btype='band'). At
     * fs=12000 the lower-cutoff floor activates and the EFFECTIVE band is
     * [6, 100] Hz (not the [2, 100] the comment used to claim). The SOS
     * catalog entry KAL_FILT_DISP_PP is designed against the effective
     * band so parity holds bit-exact. See firmware/common/dsp/kaltech_filter_coeffs.h. */
    kaltech_sos_filtfilt_f32(KAL_FILT_DISP_PP_COEFFS, KAL_FILT_DISP_PP_N_SEC,
                             kal_env_tmp3, n, kal_env_tmp2);
    float mn = kal_env_tmp2[0], mx = kal_env_tmp2[0];
    for (size_t i = 1; i < n; i++) {
        if (kal_env_tmp2[i] < mn) mn = kal_env_tmp2[i];
        if (kal_env_tmp2[i] > mx) mx = kal_env_tmp2[i];
    }
    return (mx - mn) * 1e6f;
}

void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
# … 32 more lines truncated …

v5/lib/features_v5.py:552–578  ::  compute_cepstrum        if len(signal) < DEFAULT_SUB_WINDOW + DEFAULT_HOP:
            kwargs = {"sub_window": SHORT_SUB_WINDOW, "hop": DEFAULT_HOP}
        result = tachless_cot(signal, float(fs),
                              approximate_rpm=float(approximate_rpm), **kwargs)
    except ValueError as e:
        # Log the failure so NPZ-build runs leave a trail. Returning zeros is
        # appropriate (downstream reads rpm_confidence=0 → unreliable), but we
        # want to know if a fixture problem is producing many failed windows.
        logger.warning(
            "tachless_cot raised ValueError on signal len=%d, fs=%s, "
            "approximate_rpm=%s: %s — returning zero RPM features",
            len(signal), fs, approximate_rpm, e,
        )
        return out
    out["rpm_estimate_hz"] = float(result.omega_bar_hz)
    out["rpm_drift_pct"] = float(result.sigma_pp * 100.0)
    out["rpm_is_steady"] = 1.0 if result.is_steady else 0.0
    out["rpm_confidence"] = float(result.confidence)
    return out


def compute_cepstrum(
    signal: np.ndarray,
    fs: int = CWRU_FS,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute the real cepstrum of a signal (Randall Ch. 8).

firmware/common/dsp/kaltech_dsp.c:1229–1340  ::  kaltech_cepstrum_extended_f32        kal_env_tmp1[i] = kal_env_tmp1[i - 1] + 0.5f * (x[i - 1] + x[i]) * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    const float gmm = 9.81f * 1000.0f;
    for (size_t i = 0; i < n; i++) kal_env_tmp1[i] *= gmm;
    kaltech_sos_filtfilt_f32(KAL_FILT_ISO_VEL_COEFFS, KAL_FILT_ISO_VEL_N_SEC,
                             kal_env_tmp1, n, kal_env_tmp2);
    float peak = 0.0f;
    for (size_t i = 0; i < n; i++) {
        float a = fabsf(kal_env_tmp2[i]);
        if (a > peak) peak = a;
    }
    return peak;
}

float kaltech_pp_displacement_um_f32(const float *x, size_t n) {
    KAL_DSP_REQUIRE_N(n);
    const float dt = 1.0f / KAL_FILTER_FS;
    kal_env_tmp1[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp1[i] = kal_env_tmp1[i - 1]
                        + 0.5f * (x[i - 1] + x[i]) * 9.81f * dt;
    float v_end = kal_env_tmp1[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp1[i] -= (float)i / (float)(n - 1) * v_end;
    kal_env_tmp3[0] = 0.0f;
    for (size_t i = 1; i < n; i++)
        kal_env_tmp3[i] = kal_env_tmp3[i - 1]
                        + 0.5f * (kal_env_tmp1[i - 1] + kal_env_tmp1[i]) * dt;
    float d_end = kal_env_tmp3[n - 1];
    for (size_t i = 0; i < n; i++)
        kal_env_tmp3[i] -= (float)i / (float)(n - 1) * d_end;
    /* ISO 20816-3 displacement bandpass — Python features.py:691 specifies
     * butter(2, [max(2/nyq, 0.001), min(100/nyq, 0.99)], btype='band'). At
     * fs=12000 the lower-cutoff floor activates and the EFFECTIVE band is
     * [6, 100] Hz (not the [2, 100] the comment used to claim). The SOS
     * catalog entry KAL_FILT_DISP_PP is designed against the effective
     * band so parity holds bit-exact. See firmware/common/dsp/kaltech_filter_coeffs.h. */
    kaltech_sos_filtfilt_f32(KAL_FILT_DISP_PP_COEFFS, KAL_FILT_DISP_PP_N_SEC,
                             kal_env_tmp3, n, kal_env_tmp2);
    float mn = kal_env_tmp2[0], mx = kal_env_tmp2[0];
    for (size_t i = 1; i < n; i++) {
        if (kal_env_tmp2[i] < mn) mn = kal_env_tmp2[i];
        if (kal_env_tmp2[i] > mx) mx = kal_env_tmp2[i];
    }
    return (mx - mn) * 1e6f;
}

void kaltech_cepstrum_extended_f32(const float *x, size_t n, float fs,
                                   float bpfo, float bpfi, float bsf, float ftf,
                                   kaltech_cepstrum_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Python cepstrum = |irfft(log(|rfft(x * hanning)|))|
     *   1. Hanning-window the signal
     *   2. rfft → complex half-spectrum
     *   3. log of MAGNITUDE (not power)
     *   4. irfft (inverse real FFT) — produces real time-domain cepstrum
     *   5. take |cepstrum|
     * CMSIS arm_rfft_fast_f32 with ifftFlag=1 performs irfft. */
    static float windowed[KAL_FFT_MAX_N];
    static float log_mag_packed[KAL_FFT_MAX_N];
    static float cepstrum[KAL_FFT_MAX_N];

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)n) != ARM_MATH_SUCCESS) return;

    const float tau_over_N = 6.28318530717958647692f / (float)(n - 1);
    for (size_t i = 0; i < n; i++) {
        float w = 0.5f * (1.0f - cosf(tau_over_N * (float)i));   /* symmetric Hanning (np.hanning) */
        windowed[i] = x[i] * w;
    }
    arm_rfft_fast_f32(&S, windowed, kal_fft_work_pack, 0);

    /* Build log-magnitude in CMSIS rfft packed layout: [R0, R_N/2, R1, I1, ...]
     * We want irfft of (log(|X|) + 0j). Pack: log|X_k| in real slot, 0 in imag. */
    size_t half = n / 2;
    float dc_mag  = fabsf(kal_fft_work_pack[0]);
# … 32 more lines truncated …

v5/lib/features_v5.py:581–623  ::  compute_spectral_kurtosis    Peaks in the cepstrum (called "rahmonics") indicate:
    - Bearing defects: peak at 1/defect_freq (e.g., 1/BPFO)
    - Gear mesh: peak at 1/mesh_freq
    - Echo/reflection: peak at delay time

    Returns:
        (quefrency, cepstrum) — quefrency axis in seconds, cepstrum magnitudes
    """
    N = len(signal)
    windowed = signal * np.hanning(N)

    fft_mag = np.abs(np.fft.rfft(windowed))
    fft_mag = np.maximum(fft_mag, 1e-20)  # avoid log(0)

    log_spectrum = np.log(fft_mag)
    cepstrum = np.fft.irfft(log_spectrum)

    quefrency = np.arange(len(cepstrum)) / fs
    return quefrency, np.abs(cepstrum)


def compute_spectral_kurtosis(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    window_size: int = 256,
    overlap: int = 192,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute Spectral Kurtosis via STFT (Randall Ch. 9, Antoni 2006).

    SK(f) = <|X(f)|^4> / <|X(f)|^2>^2 - 2

    High SK at a frequency → impulsive/transient content (bearing impacts).
    Low SK → stationary content (shaft rotation, noise).

    Use SK to identify the optimal frequency band for envelope demodulation.

    Convention / baseline note
    --------------------------
    Returns Antoni (2006) MSSP 20(2):282-307 eq. 6 baseline:
        SK = E[|X|^4] / E[|X|^2]^2 - 2.
    The -2 term is the complex-circular-Gaussian baseline. We feed the complex
    STFT output (scipy.signal.stft) and take |Zxx|² as power. For a white-

firmware/common/dsp/kaltech_dsp.c:1563–1627  ::  kaltech_spectral_kurtosis_fixed_f32        x, n, fs,
        bpfo, bpfi, bsf, ftf,
        out->optimal_band_center, out->optimal_band_bw,
        drs_sq);
    /* Slots 0-11: broadband 1x / 2x / 3x */
    out->drs_sq_env_bpfo    = drs_sq[0];
    out->drs_sq_env_bpfi    = drs_sq[1];
    out->drs_sq_env_bsf     = drs_sq[2];
    out->drs_sq_env_ftf     = drs_sq[3];
    out->drs_sq_env_2x_bpfo = drs_sq[4];
    out->drs_sq_env_2x_bpfi = drs_sq[5];
    out->drs_sq_env_2x_bsf  = drs_sq[6];
    out->drs_sq_env_2x_ftf  = drs_sq[7];
    out->drs_sq_env_3x_bpfo = drs_sq[8];
    out->drs_sq_env_3x_bpfi = drs_sq[9];
    out->drs_sq_env_3x_bsf  = drs_sq[10];
    out->drs_sq_env_3x_ftf  = drs_sq[11];
    /* Slots 12-23: optimal (kurtogram-band) 1x / 2x / 3x */
    out->drs_sq_optimal_env_bpfo    = drs_sq[12];
    out->drs_sq_optimal_env_bpfi    = drs_sq[13];
    out->drs_sq_optimal_env_bsf     = drs_sq[14];
    out->drs_sq_optimal_env_ftf     = drs_sq[15];
    out->drs_sq_optimal_env_2x_bpfo = drs_sq[16];
    out->drs_sq_optimal_env_2x_bpfi = drs_sq[17];
    out->drs_sq_optimal_env_2x_bsf  = drs_sq[18];
    out->drs_sq_optimal_env_2x_ftf  = drs_sq[19];
    out->drs_sq_optimal_env_3x_bpfo = drs_sq[20];
    out->drs_sq_optimal_env_3x_bpfi = drs_sq[21];
    out->drs_sq_optimal_env_3x_bsf  = drs_sq[22];
    out->drs_sq_optimal_env_3x_ftf  = drs_sq[23];

    /* ─── V5 Phase E.2: tachless on-edge COT (design specification) ──────────
     * 4 rpm_* features. Pass shaft_hz (already in Hz, the per-axis-features
     * caller has already divided RPM by 60). Sentinel contract: if signal
     * is too short or shaft_hz<=0, all 4 outputs are 0 INCLUDING confidence
     * so consumers can distinguish "I refused to compute" from "I computed
     * a zero". */
    {
        /* RPM context (see kaltech_dsp.h): prepend the caller-provided
         * previous window so short chip windows get full-resolution COT. */
        const float *rpm_sig = x;
        size_t rpm_n = n;
        if (kal_rpm_ctx != NULL && kal_rpm_ctx_n > 0 && n <= 2048 &&
            kal_rpm_ctx_n + n <= (sizeof kal_rpm_concat / sizeof kal_rpm_concat[0])) {
            memcpy(kal_rpm_concat, kal_rpm_ctx, kal_rpm_ctx_n * sizeof(float));
            memcpy(kal_rpm_concat + kal_rpm_ctx_n, x, n * sizeof(float));
            rpm_sig = kal_rpm_concat;
            rpm_n = kal_rpm_ctx_n + n;
        }
        kal_rpm_ctx = NULL;           /* consumed — one call only */
        kal_rpm_ctx_n = 0;
        kaltech_tachless_cot_features(
            rpm_sig, rpm_n, fs, shaft_hz,
            &out->rpm_estimate_hz,
            &out->rpm_drift_pct,
            &out->rpm_is_steady,
            &out->rpm_confidence);
    }
}

/* SK at a fixed STFT window size — matches Python compute_spectral_kurtosis
 * (win=256, overlap=192 default). Returns max and mean of SK across bins
 * with freq > 50 Hz. Uses scipy.signal.stft conventions (Hann periodic,
 * boundary='zeros', padtype='zeros'). */
void kaltech_spectral_kurtosis_fixed_f32(const float *x, size_t n, float fs,

v5/lib/features_v5.py:581–623  ::  compute_spectral_kurtosis    Peaks in the cepstrum (called "rahmonics") indicate:
    - Bearing defects: peak at 1/defect_freq (e.g., 1/BPFO)
    - Gear mesh: peak at 1/mesh_freq
    - Echo/reflection: peak at delay time

    Returns:
        (quefrency, cepstrum) — quefrency axis in seconds, cepstrum magnitudes
    """
    N = len(signal)
    windowed = signal * np.hanning(N)

    fft_mag = np.abs(np.fft.rfft(windowed))
    fft_mag = np.maximum(fft_mag, 1e-20)  # avoid log(0)

    log_spectrum = np.log(fft_mag)
    cepstrum = np.fft.irfft(log_spectrum)

    quefrency = np.arange(len(cepstrum)) / fs
    return quefrency, np.abs(cepstrum)


def compute_spectral_kurtosis(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    window_size: int = 256,
    overlap: int = 192,
) -> tuple[np.ndarray, np.ndarray]:
    """
    Compute Spectral Kurtosis via STFT (Randall Ch. 9, Antoni 2006).

    SK(f) = <|X(f)|^4> / <|X(f)|^2>^2 - 2

    High SK at a frequency → impulsive/transient content (bearing impacts).
    Low SK → stationary content (shaft rotation, noise).

    Use SK to identify the optimal frequency band for envelope demodulation.

    Convention / baseline note
    --------------------------
    Returns Antoni (2006) MSSP 20(2):282-307 eq. 6 baseline:
        SK = E[|X|^4] / E[|X|^2]^2 - 2.
    The -2 term is the complex-circular-Gaussian baseline. We feed the complex
    STFT output (scipy.signal.stft) and take |Zxx|² as power. For a white-

firmware/common/dsp/kaltech_dsp.c:1563–1627  ::  kaltech_spectral_kurtosis_fixed_f32        x, n, fs,
        bpfo, bpfi, bsf, ftf,
        out->optimal_band_center, out->optimal_band_bw,
        drs_sq);
    /* Slots 0-11: broadband 1x / 2x / 3x */
    out->drs_sq_env_bpfo    = drs_sq[0];
    out->drs_sq_env_bpfi    = drs_sq[1];
    out->drs_sq_env_bsf     = drs_sq[2];
    out->drs_sq_env_ftf     = drs_sq[3];
    out->drs_sq_env_2x_bpfo = drs_sq[4];
    out->drs_sq_env_2x_bpfi = drs_sq[5];
    out->drs_sq_env_2x_bsf  = drs_sq[6];
    out->drs_sq_env_2x_ftf  = drs_sq[7];
    out->drs_sq_env_3x_bpfo = drs_sq[8];
    out->drs_sq_env_3x_bpfi = drs_sq[9];
    out->drs_sq_env_3x_bsf  = drs_sq[10];
    out->drs_sq_env_3x_ftf  = drs_sq[11];
    /* Slots 12-23: optimal (kurtogram-band) 1x / 2x / 3x */
    out->drs_sq_optimal_env_bpfo    = drs_sq[12];
    out->drs_sq_optimal_env_bpfi    = drs_sq[13];
    out->drs_sq_optimal_env_bsf     = drs_sq[14];
    out->drs_sq_optimal_env_ftf     = drs_sq[15];
    out->drs_sq_optimal_env_2x_bpfo = drs_sq[16];
    out->drs_sq_optimal_env_2x_bpfi = drs_sq[17];
    out->drs_sq_optimal_env_2x_bsf  = drs_sq[18];
    out->drs_sq_optimal_env_2x_ftf  = drs_sq[19];
    out->drs_sq_optimal_env_3x_bpfo = drs_sq[20];
    out->drs_sq_optimal_env_3x_bpfi = drs_sq[21];
    out->drs_sq_optimal_env_3x_bsf  = drs_sq[22];
    out->drs_sq_optimal_env_3x_ftf  = drs_sq[23];

    /* ─── V5 Phase E.2: tachless on-edge COT (design specification) ──────────
     * 4 rpm_* features. Pass shaft_hz (already in Hz, the per-axis-features
     * caller has already divided RPM by 60). Sentinel contract: if signal
     * is too short or shaft_hz<=0, all 4 outputs are 0 INCLUDING confidence
     * so consumers can distinguish "I refused to compute" from "I computed
     * a zero". */
    {
        /* RPM context (see kaltech_dsp.h): prepend the caller-provided
         * previous window so short chip windows get full-resolution COT. */
        const float *rpm_sig = x;
        size_t rpm_n = n;
        if (kal_rpm_ctx != NULL && kal_rpm_ctx_n > 0 && n <= 2048 &&
            kal_rpm_ctx_n + n <= (sizeof kal_rpm_concat / sizeof kal_rpm_concat[0])) {
            memcpy(kal_rpm_concat, kal_rpm_ctx, kal_rpm_ctx_n * sizeof(float));
            memcpy(kal_rpm_concat + kal_rpm_ctx_n, x, n * sizeof(float));
            rpm_sig = kal_rpm_concat;
            rpm_n = kal_rpm_ctx_n + n;
        }
        kal_rpm_ctx = NULL;           /* consumed — one call only */
        kal_rpm_ctx_n = 0;
        kaltech_tachless_cot_features(
            rpm_sig, rpm_n, fs, shaft_hz,
            &out->rpm_estimate_hz,
            &out->rpm_drift_pct,
            &out->rpm_is_steady,
            &out->rpm_confidence);
    }
}

/* SK at a fixed STFT window size — matches Python compute_spectral_kurtosis
 * (win=256, overlap=192 default). Returns max and mean of SK across bins
 * with freq > 50 Hz. Uses scipy.signal.stft conventions (Hann periodic,
 * boundary='zeros', padtype='zeros'). */
void kaltech_spectral_kurtosis_fixed_f32(const float *x, size_t n, float fs,

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:423–455  ::  kaltech_kurtogram_f32        float acc = 0.0f;
        for (int m = loj; m < hij; m++) acc += kal_kurt_skband[m];
        float sm = acc / (float)(hij - loj);
        if (sm > best_sm) { best_sm = sm; best_j = j; }
    }
    *out_peak_sk = best_sm;
    *out_peak_freq = (float)(first_bin + best_j) * fs / (float)win;
    return 1;
}

void kaltech_kurtogram_f32(const float *x, size_t n, float fs,
                           kaltech_kurtogram_t *out) {
    out->center_freq = 0.0f;
    out->bandwidth   = 0.0f;
    out->max_sk      = 0.0f;  /* Python best_sk starts at 0.0 */
    out->band_low    = 50.0f;
    out->band_high   = fs * 0.5f - 50.0f;

    const int wins[] = {64, 128, 256, 512};
    const int n_levels = 4;

    for (int L = 0; L < n_levels; L++) {
        int win = wins[L];
        if (win > (int)n / 4) break;

        float peak_sk, peak_freq;
        if (!scan_one_level(x, (int)n, win, fs, 0, 0, &peak_sk, &peak_freq)) continue;

        if (peak_sk > out->max_sk) {
            out->max_sk      = peak_sk;
            out->center_freq = peak_freq;
            out->bandwidth   = (float)KAL_SK_EFFECTIVE_BW_BINS * fs / (float)win;
        }

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:423–455  ::  kaltech_kurtogram_f32        float acc = 0.0f;
        for (int m = loj; m < hij; m++) acc += kal_kurt_skband[m];
        float sm = acc / (float)(hij - loj);
        if (sm > best_sm) { best_sm = sm; best_j = j; }
    }
    *out_peak_sk = best_sm;
    *out_peak_freq = (float)(first_bin + best_j) * fs / (float)win;
    return 1;
}

void kaltech_kurtogram_f32(const float *x, size_t n, float fs,
                           kaltech_kurtogram_t *out) {
    out->center_freq = 0.0f;
    out->bandwidth   = 0.0f;
    out->max_sk      = 0.0f;  /* Python best_sk starts at 0.0 */
    out->band_low    = 50.0f;
    out->band_high   = fs * 0.5f - 50.0f;

    const int wins[] = {64, 128, 256, 512};
    const int n_levels = 4;

    for (int L = 0; L < n_levels; L++) {
        int win = wins[L];
        if (win > (int)n / 4) break;

        float peak_sk, peak_freq;
        if (!scan_one_level(x, (int)n, win, fs, 0, 0, &peak_sk, &peak_freq)) continue;

        if (peak_sk > out->max_sk) {
            out->max_sk      = peak_sk;
            out->center_freq = peak_freq;
            out->bandwidth   = (float)KAL_SK_EFFECTIVE_BW_BINS * fs / (float)win;
        }

v5/lib/features_v5.py:736–749  ::  find_optimal_demod_band        # band-integrated kurtogram band width at this STFT level.
        bin_spacing = float(fs) / float(win)
        eff_bw = _SK_EFFECTIVE_BW_BINS * bin_spacing

        if peak_sk > best_sk:
            best_sk = peak_sk
            best_center = peak_freq
            best_bw = eff_bw

    band_low = max(best_center - best_bw / 2, 50.0)
    band_high = min(best_center + best_bw / 2, fs / 2 - 50.0)

    return {
        "center_freq": best_center,

firmware/common/dsp/kaltech_dsp.c:423–455  ::  kaltech_kurtogram_f32        float acc = 0.0f;
        for (int m = loj; m < hij; m++) acc += kal_kurt_skband[m];
        float sm = acc / (float)(hij - loj);
        if (sm > best_sm) { best_sm = sm; best_j = j; }
    }
    *out_peak_sk = best_sm;
    *out_peak_freq = (float)(first_bin + best_j) * fs / (float)win;
    return 1;
}

void kaltech_kurtogram_f32(const float *x, size_t n, float fs,
                           kaltech_kurtogram_t *out) {
    out->center_freq = 0.0f;
    out->bandwidth   = 0.0f;
    out->max_sk      = 0.0f;  /* Python best_sk starts at 0.0 */
    out->band_low    = 50.0f;
    out->band_high   = fs * 0.5f - 50.0f;

    const int wins[] = {64, 128, 256, 512};
    const int n_levels = 4;

    for (int L = 0; L < n_levels; L++) {
        int win = wins[L];
        if (win > (int)n / 4) break;

        float peak_sk, peak_freq;
        if (!scan_one_level(x, (int)n, win, fs, 0, 0, &peak_sk, &peak_freq)) continue;

        if (peak_sk > out->max_sk) {
            out->max_sk      = peak_sk;
            out->center_freq = peak_freq;
            out->bandwidth   = (float)KAL_SK_EFFECTIVE_BW_BINS * fs / (float)win;
        }

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1630–1677  ::  kaltech_order_features_f32    *sk_max = 0.0f; *sk_mean = 0.0f;
    if (win > KAL_KURT_MAX_WIN || win <= 0) return;
    int hop = win - overlap;
    if (hop <= 0) return;
    int pad = win / 2;
    int half = win / 2;

    static float hann[KAL_KURT_MAX_WIN];
    float tau_over_n = 6.28318530717958647692f / (float)win;
    for (int i = 0; i < win; i++) hann[i] = 0.5f - 0.5f * cosf(tau_over_n * (float)i);

    static float m_p[KAL_KURT_MAX_WIN/2 + 1];
    static float m_p2[KAL_KURT_MAX_WIN/2 + 1];
    for (int k = 0; k <= half; k++) { m_p[k] = 0.0f; m_p2[k] = 0.0f; }

    arm_rfft_fast_instance_f32 S;
    if (arm_rfft_fast_init_f32(&S, (uint16_t)win) != ARM_MATH_SUCCESS) return;

    int padded_len = (int)n + 2 * pad;
    int min_frames = (padded_len - win) / hop + 1;
    int need_end_pad = ((padded_len - win) % hop) != 0;
    int n_frames = min_frames + (need_end_pad ? 1 : 0);

    static float buf[KAL_KURT_MAX_WIN];
    static float fftbuf[KAL_KURT_MAX_WIN];

    for (int f = 0; f < n_frames; f++) {
        int start_padded = f * hop;
        for (int i = 0; i < win; i++) {
            int idx = start_padded + i - pad;
            float v = (idx < 0 || idx >= (int)n) ? 0.0f : x[idx];
            buf[i] = v * hann[i];
        }
        arm_rfft_fast_f32(&S, buf, fftbuf, 0);
        float r0 = fftbuf[0], rn = fftbuf[1];
        float p0 = r0 * r0, pn = rn * rn;
        m_p[0] += p0;    m_p2[0] += p0 * p0;
        m_p[half] += pn; m_p2[half] += pn * pn;
        for (int k = 1; k < half; k++) {
            float re = fftbuf[2*k], im = fftbuf[2*k + 1];
            float p = re*re + im*im;
            m_p[k] += p;
            m_p2[k] += p * p;
        }
    }
    float inv = 1.0f / (float)n_frames;
    float peak = -1e30f;
    double sum = 0.0; int n_valid = 0;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1503–1506  ::  kaltech_per_axis_features::bpfo_order     * window_size=256, overlap=192, filter bins with f > 50 Hz. */
    kaltech_spectral_kurtosis_fixed_f32(x, n, fs, 256, 192, &out->sk_max, &out->sk_mean);

    kaltech_cepstrum_t cep;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1503–1506  ::  kaltech_per_axis_features::bpfo_order     * window_size=256, overlap=192, filter bins with f > 50 Hz. */
    kaltech_spectral_kurtosis_fixed_f32(x, n, fs, 256, 192, &out->sk_max, &out->sk_mean);

    kaltech_cepstrum_t cep;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1503–1506  ::  kaltech_per_axis_features::bpfo_order     * window_size=256, overlap=192, filter bins with f > 50 Hz. */
    kaltech_spectral_kurtosis_fixed_f32(x, n, fs, 256, 192, &out->sk_max, &out->sk_mean);

    kaltech_cepstrum_t cep;

v5/lib/features_v5.py:1394–1496  ::  extract_order_features        if humidity_pct is None:
            logger.warning("humidity_pct not provided; defaulting to 50.0%%")
        temp_feats = extract_temperature_features(
            surface_temp_c=surface_temp_c,
            ambient_temp_c=ambient_temp_c if ambient_temp_c is not None else 25.0,
            humidity_pct=humidity_pct if humidity_pct is not None else 50.0,
            temp_history=temp_history,
        )
        features.update(temp_feats)

    # MED observability fields (T2 follow-up). NOT in SCALAR_FEATURE_KEYS_V5
    # contract — observability only. Downstream consumers (verdict engine,
    # dashboards, training scripts) can inspect med_aborted/med_converged
    # to know whether MED contributed to the envelope features this window.
    features["med_aborted"] = _med_aborted
    features["med_converged"] = _med_converged
    features["med_kurt_before"] = _med_kurt_before
    features["med_kurt_after"] = _med_kurt_after
    features["med_n_iter"] = _med_n_iter

    return features


def extract_order_features(
    signal: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float = 1800.0,
    bearing_type: str = "6205",
    max_order: float = 20.0,
) -> dict[str, Any]:
    """
    Extract order-based features for VFD-driven motor analysis.

    Unlike Hz-based features, order features are RPM-invariant —
    the same fault produces the same order signature regardless of VFD speed setpoint.

    Features returned:
      order_1x_energy .. order_10x_energy — energy at integer shaft orders
      order_energy_bpfo_order, _bpfi_order, _bsf_order, _ftf_order — defect order energies
      order_sideband_bpfo, order_sideband_bpfi — modulation sideband energies
      dominant_order — highest-magnitude order (excluding DC)
      order_1x_2x_ratio — imbalance indicator
      order_subsync_energy — sub-synchronous energy (looseness indicator)
      bpfo_order, bpfi_order, bsf_order, ftf_order — defect order values for reference

    Args:
        signal:       1-D acceleration time series.
        fs:           Sampling frequency in Hz.
        rpm:          Shaft speed in revolutions per minute.
        bearing_type: Bearing identifier key in BEARING_DB (default "6205").
        max_order:    Maximum order to include in analysis (default 20.0).

    Returns:
        Dict with order-domain features complementing extract_features().
        Empty dict if rpm is non-positive.
    """
    shaft_freq = rpm / 60.0
    if shaft_freq <= 0:
        return {}

    orders, magnitudes = compute_order_spectrum(signal, fs, rpm)

    # Trim to max_order for focused analysis
    mask = orders <= max_order
    orders_trim = orders[mask]
    mags_trim = magnitudes[mask]

    if len(orders_trim) == 0:
        return {}

    # Energy at integer orders (1x through 10x)
    order_energies: dict[str, Any] = {}
    for n in range(1, 11):
        bw = 0.15  # ±0.15 orders bandwidth
        mask_n = np.abs(orders_trim - float(n)) <= bw
        order_energies[f"order_{n}x_energy"] = float(np.sum(mags_trim[mask_n] ** 2))

    # Bearing defect orders (defect_freq / shaft_freq)
    defect_freqs = bearing_defect_freqs(rpm, bearing_type)

# … 23 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1503–1506  ::  kaltech_per_axis_features::bpfo_order     * window_size=256, overlap=192, filter bins with f > 50 Hz. */
    kaltech_spectral_kurtosis_fixed_f32(x, n, fs, 256, 192, &out->sk_max, &out->sk_mean);

    kaltech_cepstrum_t cep;

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1653–1868  ::  compute_cross_axis_features# Canonical cross-axis feature keys (29 total)
CROSS_AXIS_KEYS: list[str] = [
    # Existing 12
    "cross_corr_xy", "cross_corr_xz", "cross_corr_yz",
    "kurtosis_ratio_xy", "kurtosis_ratio_xz", "kurtosis_ratio_yz",
    "rms_vector_magnitude", "rms_ratio_xy", "rms_ratio_xz",
    "crest_max_axis", "energy_anisotropy", "coherence_mean",
    # New 17 — Design specification(b), 10, 15
    "coherence_at_shaft_xy", "coherence_at_shaft_xz", "coherence_at_shaft_yz",
    "coherence_at_bpfo_xy", "coherence_at_bpfo_xz", "coherence_at_bpfo_yz",
    "coherence_at_bpfi_xy", "coherence_at_bpfi_xz", "coherence_at_bpfi_yz",
    "coherence_at_bsf_xy", "coherence_at_bsf_xz", "coherence_at_bsf_yz",
    "coherence_at_ftf_xy", "coherence_at_ftf_xz", "coherence_at_ftf_yz",
    "orbit_ellipticity",
    "direction_of_max_vibration",
    # sentinel — 1.0 when triaxial AND RPM known (so coherence-at-defect-freq
    # and orbit features were actually computed), 0.0 otherwise. Lets the model
    # treat single-axis-tiled or no-RPM windows differently from real isotropic
    # signals. Per internal coding rule.
    "cross_axis_full_valid",
]


def compute_cross_axis_features(
    seg_x: np.ndarray,
    seg_y: np.ndarray,
    seg_z: np.ndarray,
    fs: int = CWRU_FS,
    rpm: float | None = None,
    bearing_type: str = "6205",
) -> dict[str, float]:
    """Compute 29 cross-axis features from triaxial vibration segments.

    x = radial, y = axial, z = tangential.
    For single-axis datasets, pass zeros for y and z — features default to 0.

    Features:
      Existing 12: correlations, kurtosis ratios, RMS magnitude/ratios,
                   crest max, energy anisotropy, broadband coherence mean.
      New 17 (patent-required):
        - Coherence at shaft frequency (3 axis pairs) — Claim 15
        - Coherence at 4 defect frequencies × 3 pairs = 12 — Claim 15
        - Orbit ellipticity (minor/major from 2 radial axes at 1x) — Claim 4(b), 15
        - Direction of maximum vibration (angle in measurement plane) — Claim 4(b), 15
    """
    from scipy.stats import kurtosis as sp_kurtosis

    result = {k: 0.0 for k in CROSS_AXIS_KEYS}

    has_y = np.any(seg_y != 0)
    has_z = np.any(seg_z != 0)
    if not has_y and not has_z:
        return result

    eps = 1e-12

    # ── RMS per axis ──
    rms_x = float(np.sqrt(np.mean(seg_x**2))) + eps
    rms_y = float(np.sqrt(np.mean(seg_y**2))) + eps
    rms_z = float(np.sqrt(np.mean(seg_z**2))) + eps

    # ── Cross-correlations (Pearson) ──
    def _corr(a: np.ndarray, b: np.ndarray) -> float:
        if np.std(a) < 1e-10 or np.std(b) < 1e-10:
            return 0.0
        return float(np.corrcoef(a, b)[0, 1])

    result["cross_corr_xy"] = _corr(seg_x, seg_y)
    result["cross_corr_xz"] = _corr(seg_x, seg_z)
    result["cross_corr_yz"] = _corr(seg_y, seg_z)

    # ── Kurtosis ratios (Pearson convention, Gaussian=3.0 — matches extract_features) ──
    kurt_x = float(sp_kurtosis(seg_x, fisher=False)) if len(seg_x) > 4 else 3.0
    kurt_y = float(sp_kurtosis(seg_y, fisher=False)) if has_y and len(seg_y) > 4 else 3.0
    kurt_z = float(sp_kurtosis(seg_z, fisher=False)) if has_z and len(seg_z) > 4 else 3.0
    result["kurtosis_ratio_xy"] = kurt_x / (abs(kurt_y) + 1e-8)
    result["kurtosis_ratio_xz"] = kurt_x / (abs(kurt_z) + 1e-8)
    result["kurtosis_ratio_yz"] = kurt_y / (abs(kurt_z) + 1e-8)

    # ── RMS vector magnitude and ratios ──
# … 136 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1844–1954  ::  kaltech_cross_axis_features        arm_rfft_fast_f32(&S, buf_a, fft_a, 0);
        arm_rfft_fast_f32(&S, buf_b, fft_b, 0);
        /* Bin 0: [R0, 0]; bin half: [R_{N/2}, 0] per CMSIS packing */
        float axr = fft_a[0], bxr = fft_b[0];
        kal_welch_pxx[0] += axr*axr;
        kal_welch_pyy[0] += bxr*bxr;
        kal_welch_pxy_re[0] += axr*bxr;  /* imag=0 */
        float anr = fft_a[1], bnr = fft_b[1];
        kal_welch_pxx[KAL_WELCH_HALF-1] += anr*anr;
        kal_welch_pyy[KAL_WELCH_HALF-1] += bnr*bnr;
        kal_welch_pxy_re[KAL_WELCH_HALF-1] += anr*bnr;
        for (int k = 1; k < KAL_WELCH_HALF-1; k++) {
            float ar = fft_a[2*k], ai = fft_a[2*k+1];
            float br = fft_b[2*k], bi = fft_b[2*k+1];
            kal_welch_pxx[k] += ar*ar + ai*ai;
            kal_welch_pyy[k] += br*br + bi*bi;
            /* Cross: X * conj(Y) */
            kal_welch_pxy_re[k] += ar*br + ai*bi;
            kal_welch_pxy_im[k] += ai*br - ar*bi;
        }
    }
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float pxx = kal_welch_pxx[k] / n_seg;
        float pyy = kal_welch_pyy[k] / n_seg;
        float pxy2 = (kal_welch_pxy_re[k]*kal_welch_pxy_re[k]
                    + kal_welch_pxy_im[k]*kal_welch_pxy_im[k]) / (float)(n_seg*n_seg);
        float denom = pxx * pyy;
        msc_out[k] = denom > 1e-20f ? pxy2 / denom : 0.0f;
    }
}

static float msc_at_freq(const float *msc, float target_hz, float bw_hz, float fs) {
    /* Welch nperseg=256 → bin spacing fs/nperseg (e.g. 46.875 Hz at fs=12000).
     * Caller's bw_hz of 5 Hz is narrower than ONE bin, so the equality test
     * `|f - target| <= bw_hz` matches no bins for most targets and the
     * function returns 0.0 — silently masking real coherence. Fix per
     * internal coding rule: widen the effective bandwidth to at least
     * one bin, guaranteeing the closest bin participates. If the mask is
     * STILL empty (target outside [0, Nyquist]), snap to the nearest valid
     * bin so we report a useful value rather than zero. Mirrors fix in
     * backend/features.py _coherence_at_freq. */
    if (target_hz <= 0.0f) return 0.0f;
    float bin_hz = fs / (float)KAL_WELCH_NSEG;
    float bw_eff = bw_hz > bin_hz ? bw_hz : bin_hz;   /* at least one bin */
    float sum = 0.0f; int n = 0;
    for (int k = 0; k < KAL_WELCH_HALF; k++) {
        float f = (float)k * bin_hz;
        if (fabsf(f - target_hz) <= bw_eff) { sum += msc[k]; n++; }
    }
    if (n > 0) return sum / n;
    /* Snap to nearest bin (target inside Nyquist range but bw_eff missed
     * due to fp rounding — extremely rare with bw_eff = bin_hz). */
    int best_k = (int)lrintf(target_hz / bin_hz);
    if (best_k < 0) best_k = 0;
    if (best_k >= KAL_WELCH_HALF) best_k = KAL_WELCH_HALF - 1;
    return msc[best_k];
}

static float band_mean(const float *v, int n) {
    if (n <= 0) return 0.0f;
    double s = 0; for (int i = 0; i < n; i++) s += v[i];
    return (float)(s / n);
}

void kaltech_cross_axis_features(const float *x, const float *y, const float *z,
                                 size_t n, float fs, float shaft_hz,
                                 float bpfo, float bpfi, float bsf, float ftf,
                                 kaltech_cross_axis_feats_t *out) {
    memset(out, 0, sizeof(*out));
    /* Correlations */
    out->cross_corr_xy = pearson_corr(x, y, n);
    out->cross_corr_xz = pearson_corr(x, z, n);
    out->cross_corr_yz = pearson_corr(y, z, n);
    /* Kurtosis ratios */
    float kx = axis_kurtosis_pearson(x, n);
    float ky = axis_kurtosis_pearson(y, n);
    float kz = axis_kurtosis_pearson(z, n);
    out->kurtosis_ratio_xy = kx / (fabsf(ky) + 1e-8f);
    out->kurtosis_ratio_xz = kx / (fabsf(kz) + 1e-8f);
    out->kurtosis_ratio_yz = ky / (fabsf(kz) + 1e-8f);
# … 31 more lines truncated …

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:1907–2118  ::  extract_ultrasonic_features    if high_hz >= nyq or low_hz >= nyq or low_hz >= high_hz:
        _logging.getLogger("kaltech.features").warning(
            "_bandpass_rms: band [%.0f, %.0f] Hz not representable at fs=%d Hz "
            "(Nyquist=%.0f Hz). Returning 0.0.",
            low_hz, high_hz, fs, nyq,
        )
        return 0.0
    low_n = max(low_hz / nyq, 0.001)
    high_n = min(high_hz / nyq, 0.999)
    if high_n <= low_n:
        return 0.0
    b, a = butter(4, [low_n, high_n], btype="band")
    filtered = filtfilt(b, a, signal)
    return float(np.sqrt(np.mean(filtered ** 2)))


def _rms_to_dbuv(rms: float, ref: float = 1e-6) -> float:
    """Convert RMS amplitude to dBuV (decibels relative to 1 microvolt)."""
    if not np.isfinite(rms) or rms <= 0:
        return -999.0
    return float(20.0 * np.log10(rms / ref))


def extract_ultrasonic_features(
    us_signal: np.ndarray,
    fs_us: int = 192000,
    baseline_rms_dbuv: float | None = None,
) -> dict[str, Any]:
    """
    Extract 11 ultrasonic condition monitoring features from IMP23ABSU signal.

    Standards: ISO 29821:2018, NASA bearing research, SDT 4CI methodology.
    Sensor: IMP23ABSU (100 Hz – 80 kHz airborne MEMS mic, ~$1.50).

    Frequency bands:
      20–80 kHz  overall ultrasonic
      25–40 kHz  bearing friction / lubrication quality
      38–42 kHz  compressed air leak detection (ISO 50001)
      30–50 kHz  electrical discharge / arcing / corona

    Alarm thresholds (relative to per-machine baseline):
      +8 dB   lubrication needed (pre-failure)
      +12 dB  beginning of failure mode
      +16 dB  bearing damage confirmed
      +35 dB  catastrophic failure imminent

    Args:
        us_signal:          Raw signal from IMP23ABSU.
        fs_us:              Sampling rate (192 kHz for full 80 kHz BW).
        baseline_rms_dbuv:  Machine's baseline RMS in dBuV (25–40 kHz band).
                            None if no baseline established yet.

    Returns:
        Dict with 11 features (us_* prefix).
    """
    import logging as _logging
    _us_log = _logging.getLogger("kaltech.features.ultrasonic")

    nyq = fs_us / 2.0

    # --- Input validation ---
    _MIN_FILTER_SAMPLES = 27  # filtfilt min for 4th-order Butterworth
    if len(us_signal) == 0:
        raise ValueError("extract_ultrasonic_features: empty signal")
    if len(us_signal) < _MIN_FILTER_SAMPLES:
        raise ValueError(
            f"extract_ultrasonic_features: signal length {len(us_signal)} < "
            f"{_MIN_FILTER_SAMPLES} (minimum for bandpass filtering)"
        )
    if nyq <= 40000:
        raise ValueError(
            f"extract_ultrasonic_features: fs_us={fs_us} Hz (Nyquist={nyq:.0f} Hz) "
            f"is too low for ultrasonic band (need Nyquist > 40 kHz). "
            f"Wrong sample rate passed?"
        )
    if np.all(np.isnan(us_signal)):
        raise ValueError(
            "extract_ultrasonic_features: signal is all NaN — sensor failure"
        )
    if np.all(us_signal == 0.0):
# … 132 more lines truncated …

firmware/common/dsp/kaltech_dsp.c:1968–2009  ::  kaltech_ultrasonic_features    if (ftf > 0 && ftf < fs/2) {
        out->coherence_at_ftf_xy = msc_at_freq(msc_xy, ftf, 5.0f, fs);
        out->coherence_at_ftf_xz = msc_at_freq(msc_xz, ftf, 5.0f, fs);
        out->coherence_at_ftf_yz = msc_at_freq(msc_yz, ftf, 5.0f, fs);
    }

    /* Orbit ellipticity + direction of max vibration */
    if (shaft_hz > 0 && n > 0 && n <= KAL_FFT_MAX_N) {
        arm_rfft_fast_instance_f32 S;
        if (arm_rfft_fast_init_f32(&S, (uint16_t)n) == ARM_MATH_SUCCESS) {
            static float bx[KAL_FFT_MAX_N], fx[KAL_FFT_MAX_N];
            static float bz[KAL_FFT_MAX_N], fz[KAL_FFT_MAX_N];
            for (size_t i = 0; i < n; i++) { bx[i] = x[i]; bz[i] = z[i]; }
            arm_rfft_fast_f32(&S, bx, fx, 0);
            arm_rfft_fast_f32(&S, bz, fz, 0);
            size_t shaft_bin = (size_t)lrintf(shaft_hz * n / fs);
            if (shaft_bin > 0 && shaft_bin < n/2) {
                float xr = fx[2*shaft_bin], xi = fx[2*shaft_bin+1];
                float zr = fz[2*shaft_bin], zi = fz[2*shaft_bin+1];
                float amp_x = sqrtf(xr*xr + xi*xi);
                float amp_z = sqrtf(zr*zr + zi*zi);
                float phase_x = atan2f(xi, xr);
                float phase_z = atan2f(zi, zr);
                float phase_diff = fabsf(phase_x - phase_z);
                float major = fmaxf(amp_x, amp_z) + eps;
                float minor = fminf(amp_x, amp_z) * fabsf(sinf(phase_diff)) + eps;
                out->orbit_ellipticity = minor / major;

                /* direction_of_max_vibration: Bently-Hatch (2002) eq 6.18.
                 *   psi = 0.5 * atan2(2*Ax*Az*cos(phi_z - phi_x), Ax^2 - Az^2)
                 * Previous atan2f(rms_z, rms_x) collapsed orbit motion to
                 * RMS magnitudes (ignored phase + biased to higher-RMS axis).
                 * Mirrors features_v5.py:1841-1849.
                 *
                 * Degenerate guard: 1x amplitude must exceed _direction_amp_floor
                 * on at least one radial channel — else leave the memset default 0.0. */
                const float _direction_amp_floor = 1e-6f;
                if (fmaxf(amp_x, amp_z) >= _direction_amp_floor) {
                    float num = 2.0f * amp_x * amp_z * cosf(phase_z - phase_x);
                    float den = amp_x * amp_x - amp_z * amp_z;
                    out->direction_of_max_vibration = 0.5f * atan2f(num, den);
                }

v5/lib/features_v5.py:2125–2201  ::  extract_temperature_features        "us_rms_leak": us_rms_leak,
        "us_rms_electrical": us_rms_electrical,
        "us_peak": us_peak,
        "us_crest_factor": us_crest_factor,
        "us_baseline_delta_dB": us_baseline_delta_dB,
        "us_spectral_flatness": us_spectral_flatness,
        "us_dominant_freq": us_dominant_freq,
        "us_is_steady": us_is_steady,
        "us_max_rms": us_max_rms,
        # Additional features for 67-feature vector
        "us_rms_bearing_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 25000, 35000)),
        "us_rms_leak_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 36000, 42000)),
        "us_rms_electrical_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 43000, 60000)),
        "us_kurtosis": us_kurtosis,
        "us_steadiness": us_steadiness,
        "us_max_rms_100ms": _rms_to_dbuv(us_max_rms_raw),
    }


# ---------------------------------------------------------------------------
# Temperature Feature Extraction (STTS22H / SHT45 / NTC)
# ---------------------------------------------------------------------------

def extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

firmware/common/dsp/kaltech_dsp.c:2012–2049  ::  kaltech_temperature_features            }
        }
        /* NOTE: the wrong "atan2f(rz, rx)" assignment that used to live here
         * has been removed (parity bug, see commit). Direction now lives inside
         * the shaft_bin guard above. */
    }
}

/* ─── Ultrasonic features (17) — synthetic-tested, awaiting hardware ── */
static float band_rms(const float *mag, size_t n, float fs, float lo_hz, float hi_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    double s = 0.0; int cnt = 0;
    for (size_t k = 1; k <= half; k++) {
        float f = (float)k * fs_per_n;
        if (f >= lo_hz && f <= hi_hz) { s += (double)mag[k] * mag[k]; cnt++; }
    }
    return cnt > 0 ? (float)sqrt(s / cnt) : 0.0f;
}

void kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);

v5/lib/features_v5.py:2125–2201  ::  extract_temperature_features        "us_rms_leak": us_rms_leak,
        "us_rms_electrical": us_rms_electrical,
        "us_peak": us_peak,
        "us_crest_factor": us_crest_factor,
        "us_baseline_delta_dB": us_baseline_delta_dB,
        "us_spectral_flatness": us_spectral_flatness,
        "us_dominant_freq": us_dominant_freq,
        "us_is_steady": us_is_steady,
        "us_max_rms": us_max_rms,
        # Additional features for 67-feature vector
        "us_rms_bearing_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 25000, 35000)),
        "us_rms_leak_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 36000, 42000)),
        "us_rms_electrical_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 43000, 60000)),
        "us_kurtosis": us_kurtosis,
        "us_steadiness": us_steadiness,
        "us_max_rms_100ms": _rms_to_dbuv(us_max_rms_raw),
    }


# ---------------------------------------------------------------------------
# Temperature Feature Extraction (STTS22H / SHT45 / NTC)
# ---------------------------------------------------------------------------

def extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

firmware/common/dsp/kaltech_dsp.c:2012–2049  ::  kaltech_temperature_features            }
        }
        /* NOTE: the wrong "atan2f(rz, rx)" assignment that used to live here
         * has been removed (parity bug, see commit). Direction now lives inside
         * the shaft_bin guard above. */
    }
}

/* ─── Ultrasonic features (17) — synthetic-tested, awaiting hardware ── */
static float band_rms(const float *mag, size_t n, float fs, float lo_hz, float hi_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    double s = 0.0; int cnt = 0;
    for (size_t k = 1; k <= half; k++) {
        float f = (float)k * fs_per_n;
        if (f >= lo_hz && f <= hi_hz) { s += (double)mag[k] * mag[k]; cnt++; }
    }
    return cnt > 0 ? (float)sqrt(s / cnt) : 0.0f;
}

void kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);

v5/lib/features_v5.py:2125–2201  ::  extract_temperature_features        "us_rms_leak": us_rms_leak,
        "us_rms_electrical": us_rms_electrical,
        "us_peak": us_peak,
        "us_crest_factor": us_crest_factor,
        "us_baseline_delta_dB": us_baseline_delta_dB,
        "us_spectral_flatness": us_spectral_flatness,
        "us_dominant_freq": us_dominant_freq,
        "us_is_steady": us_is_steady,
        "us_max_rms": us_max_rms,
        # Additional features for 67-feature vector
        "us_rms_bearing_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 25000, 35000)),
        "us_rms_leak_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 36000, 42000)),
        "us_rms_electrical_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 43000, 60000)),
        "us_kurtosis": us_kurtosis,
        "us_steadiness": us_steadiness,
        "us_max_rms_100ms": _rms_to_dbuv(us_max_rms_raw),
    }


# ---------------------------------------------------------------------------
# Temperature Feature Extraction (STTS22H / SHT45 / NTC)
# ---------------------------------------------------------------------------

def extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

firmware/common/dsp/kaltech_dsp.c:2012–2049  ::  kaltech_temperature_features            }
        }
        /* NOTE: the wrong "atan2f(rz, rx)" assignment that used to live here
         * has been removed (parity bug, see commit). Direction now lives inside
         * the shaft_bin guard above. */
    }
}

/* ─── Ultrasonic features (17) — synthetic-tested, awaiting hardware ── */
static float band_rms(const float *mag, size_t n, float fs, float lo_hz, float hi_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    double s = 0.0; int cnt = 0;
    for (size_t k = 1; k <= half; k++) {
        float f = (float)k * fs_per_n;
        if (f >= lo_hz && f <= hi_hz) { s += (double)mag[k] * mag[k]; cnt++; }
    }
    return cnt > 0 ? (float)sqrt(s / cnt) : 0.0f;
}

void kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);

v5/lib/features_v5.py:2125–2201  ::  extract_temperature_features        "us_rms_leak": us_rms_leak,
        "us_rms_electrical": us_rms_electrical,
        "us_peak": us_peak,
        "us_crest_factor": us_crest_factor,
        "us_baseline_delta_dB": us_baseline_delta_dB,
        "us_spectral_flatness": us_spectral_flatness,
        "us_dominant_freq": us_dominant_freq,
        "us_is_steady": us_is_steady,
        "us_max_rms": us_max_rms,
        # Additional features for 67-feature vector
        "us_rms_bearing_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 25000, 35000)),
        "us_rms_leak_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 36000, 42000)),
        "us_rms_electrical_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 43000, 60000)),
        "us_kurtosis": us_kurtosis,
        "us_steadiness": us_steadiness,
        "us_max_rms_100ms": _rms_to_dbuv(us_max_rms_raw),
    }


# ---------------------------------------------------------------------------
# Temperature Feature Extraction (STTS22H / SHT45 / NTC)
# ---------------------------------------------------------------------------

def extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

firmware/common/dsp/kaltech_dsp.c:2012–2049  ::  kaltech_temperature_features            }
        }
        /* NOTE: the wrong "atan2f(rz, rx)" assignment that used to live here
         * has been removed (parity bug, see commit). Direction now lives inside
         * the shaft_bin guard above. */
    }
}

/* ─── Ultrasonic features (17) — synthetic-tested, awaiting hardware ── */
static float band_rms(const float *mag, size_t n, float fs, float lo_hz, float hi_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    double s = 0.0; int cnt = 0;
    for (size_t k = 1; k <= half; k++) {
        float f = (float)k * fs_per_n;
        if (f >= lo_hz && f <= hi_hz) { s += (double)mag[k] * mag[k]; cnt++; }
    }
    return cnt > 0 ? (float)sqrt(s / cnt) : 0.0f;
}

void kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);

v5/lib/features_v5.py:2125–2201  ::  extract_temperature_features        "us_rms_leak": us_rms_leak,
        "us_rms_electrical": us_rms_electrical,
        "us_peak": us_peak,
        "us_crest_factor": us_crest_factor,
        "us_baseline_delta_dB": us_baseline_delta_dB,
        "us_spectral_flatness": us_spectral_flatness,
        "us_dominant_freq": us_dominant_freq,
        "us_is_steady": us_is_steady,
        "us_max_rms": us_max_rms,
        # Additional features for 67-feature vector
        "us_rms_bearing_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 25000, 35000)),
        "us_rms_leak_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 36000, 42000)),
        "us_rms_electrical_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 43000, 60000)),
        "us_kurtosis": us_kurtosis,
        "us_steadiness": us_steadiness,
        "us_max_rms_100ms": _rms_to_dbuv(us_max_rms_raw),
    }


# ---------------------------------------------------------------------------
# Temperature Feature Extraction (STTS22H / SHT45 / NTC)
# ---------------------------------------------------------------------------

def extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

firmware/common/dsp/kaltech_dsp.c:2012–2049  ::  kaltech_temperature_features            }
        }
        /* NOTE: the wrong "atan2f(rz, rx)" assignment that used to live here
         * has been removed (parity bug, see commit). Direction now lives inside
         * the shaft_bin guard above. */
    }
}

/* ─── Ultrasonic features (17) — synthetic-tested, awaiting hardware ── */
static float band_rms(const float *mag, size_t n, float fs, float lo_hz, float hi_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    double s = 0.0; int cnt = 0;
    for (size_t k = 1; k <= half; k++) {
        float f = (float)k * fs_per_n;
        if (f >= lo_hz && f <= hi_hz) { s += (double)mag[k] * mag[k]; cnt++; }
    }
    return cnt > 0 ? (float)sqrt(s / cnt) : 0.0f;
}

void kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);

v5/lib/features_v5.py:2125–2201  ::  extract_temperature_features        "us_rms_leak": us_rms_leak,
        "us_rms_electrical": us_rms_electrical,
        "us_peak": us_peak,
        "us_crest_factor": us_crest_factor,
        "us_baseline_delta_dB": us_baseline_delta_dB,
        "us_spectral_flatness": us_spectral_flatness,
        "us_dominant_freq": us_dominant_freq,
        "us_is_steady": us_is_steady,
        "us_max_rms": us_max_rms,
        # Additional features for 67-feature vector
        "us_rms_bearing_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 25000, 35000)),
        "us_rms_leak_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 36000, 42000)),
        "us_rms_electrical_band": _rms_to_dbuv(_bandpass_rms(us_signal, fs_us, 43000, 60000)),
        "us_kurtosis": us_kurtosis,
        "us_steadiness": us_steadiness,
        "us_max_rms_100ms": _rms_to_dbuv(us_max_rms_raw),
    }


# ---------------------------------------------------------------------------
# Temperature Feature Extraction (STTS22H / SHT45 / NTC)
# ---------------------------------------------------------------------------

def extract_temperature_features(
    surface_temp_c: float,
    ambient_temp_c: float,
    humidity_pct: float,
    temp_history: list[float] | None = None,
    rms_history: list[float] | None = None,
) -> dict[str, Any]:
    """
    Extract 6 temperature condition monitoring features.

    Sensors: STTS22H (surface), SHT45 (ambient + humidity), NTC (hot axle).

    Features:
      surface_temp_c             — direct surface reading (degC)
      ambient_temp_c             — ambient reading (degC)
      delta_t                    — surface - ambient (>40C = hot axle alert)
      humidity_pct               — relative humidity (>80% = condensation risk)
      temp_rate_of_rise          — degC/min from recent temp_history (0.0 if no history)
      temp_vibration_correlation — Pearson correlation between temp and RMS histories
                                   (Claim 10: concurrent positive = friction-driven degradation)

    Args:
        surface_temp_c: Surface temperature from STTS22H/NTC (degC).
        ambient_temp_c: Ambient temperature from SHT45 (degC).
        humidity_pct:   Relative humidity from SHT45 (0-100%).
        temp_history:   List of recent surface temps at 1-minute intervals,
                        most recent last. If None or too short, rate_of_rise = 0.
        rms_history:    List of recent vibration RMS values (same interval as temp_history).
                        Used to compute temperature-vibration correlation (Claim 10).

    Returns:
        Dict with 6 temperature features.
    """
    if not math.isfinite(surface_temp_c):
        logger.warning("surface_temp_c=%s is not finite — possible sensor failure", surface_temp_c)
        surface_temp_c = 0.0
    if not math.isfinite(ambient_temp_c):
        logger.warning("ambient_temp_c=%s is not finite — possible sensor failure", ambient_temp_c)
        ambient_temp_c = 25.0

    delta_t = surface_temp_c - ambient_temp_c

    # Rate of rise: linear regression slope over temp_history (degC/min)
    temp_rate_of_rise = 0.0
    if temp_history and len(temp_history) >= 2:
        n = len(temp_history)
        x = np.arange(n, dtype=np.float64)
        y = np.array(temp_history, dtype=np.float64)
        x_mean = np.mean(x)
        y_mean = np.mean(y)
        cov_xy = np.sum((x - x_mean) * (y - y_mean))
        var_x = np.sum((x - x_mean) ** 2)
        if var_x > 0:
            temp_rate_of_rise = float(cov_xy / var_x)

firmware/common/dsp/kaltech_dsp.c:2012–2049  ::  kaltech_temperature_features            }
        }
        /* NOTE: the wrong "atan2f(rz, rx)" assignment that used to live here
         * has been removed (parity bug, see commit). Direction now lives inside
         * the shaft_bin guard above. */
    }
}

/* ─── Ultrasonic features (17) — synthetic-tested, awaiting hardware ── */
static float band_rms(const float *mag, size_t n, float fs, float lo_hz, float hi_hz) {
    size_t half = n / 2;
    float fs_per_n = fs / (float)n;
    double s = 0.0; int cnt = 0;
    for (size_t k = 1; k <= half; k++) {
        float f = (float)k * fs_per_n;
        if (f >= lo_hz && f <= hi_hz) { s += (double)mag[k] * mag[k]; cnt++; }
    }
    return cnt > 0 ? (float)sqrt(s / cnt) : 0.0f;
}

void kaltech_ultrasonic_features(const float *sig_dbuv, size_t n, float fs,
                                 float baseline_bearing_rms,
                                 kaltech_ultrasonic_feats_t *out) {
    memset(out, 0, sizeof(*out));
    if (n == 0 || n > KAL_FFT_MAX_N) return;

    /* Time-domain on dBuV signal */
    kaltech_time_feats_t t;
    kaltech_time_features(sig_dbuv, n, &t);
    out->us_rms_overall  = t.rms;
    out->us_peak         = t.peak;
    out->us_crest_factor = t.crest_factor;
    out->us_kurtosis     = t.kurtosis;

    /* Spectrum-derived band RMS */
    static float mag[KAL_FFT_MAX_N/2 + 1];
    kaltech_rfft_mag(sig_dbuv, n, mag);
    out->us_rms_bearing     = band_rms(mag, n, fs, 20000.0f, 60000.0f);