-module(lightspeed@ops@overload_control).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lightspeed/ops/overload_control.gleam").
-export([signal/4, thresholds/6, default_thresholds/0, operator_hook/6, default_hook/0, restrictive_hook/0, new/2, classify/2, recommended_mitigations/3, active_mitigations/1, status_label/1, decision_label/1, mitigation_label/1, audit_metric/1, evaluate/4, run_rollback_drill/4, default_stress_budgets/0, policy_compliant/1, mitigation_reversible/1, active_mitigations_reversible/1, valid/1, audit_entries/1, run_stress_simulation/0, evaluate_stress_budgets/2, budget_failures/1, runtime_thresholds/1, runtime_hook/1, telemetry_metrics/1, signal_label/1, thresholds_label/1, hook_label/1, audit_label/1, signature/1, stress_scenario_label/1, stress_observation_signature/1, budget_result_signature/1, audit_decision/1, audit_mitigation/1, stress_scenario/1]).
-export_type([overload_signal/0, thresholds/0, status/0, mitigation/0, operator_hook/0, decision/0, audit_entry/0, stress_scenario/0, stress_observation/0, stress_budget/0, budget_result/0, runtime/0]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(" Adaptive overload-control and graceful-degradation contracts for M50.\n").

-type overload_signal() :: {overload_signal,
        integer(),
        integer(),
        binary(),
        integer()}.

-type thresholds() :: {thresholds,
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer()}.

-type status() :: healthy | warning | critical.

-type mitigation() :: {shed_events, integer()} |
    {throttle_cadence, integer()} |
    {enforce_tenant_budget, binary()} |
    enter_read_only_mode.

-type operator_hook() :: {operator_hook,
        binary(),
        boolean(),
        boolean(),
        boolean(),
        boolean(),
        integer()}.

-type decision() :: applied |
    rolled_back |
    {blocked_by_hook, binary()} |
    {noop, binary()}.

-type audit_entry() :: {audit_entry,
        binary(),
        mitigation(),
        decision(),
        binary(),
        integer(),
        status(),
        binary()}.

-type stress_scenario() :: queue_depth_spike |
    cadence_storm |
    tenant_budget_hotspot |
    combined_pressure.

-type stress_observation() :: {stress_observation,
        stress_scenario(),
        integer(),
        integer(),
        integer(),
        integer(),
        integer(),
        boolean()}.

-type stress_budget() :: {stress_budget,
        stress_scenario(),
        integer(),
        integer(),
        integer(),
        integer(),
        boolean()}.

-type budget_result() :: {budget_result, stress_scenario(), boolean(), binary()}.

-opaque runtime() :: {runtime,
        thresholds(),
        operator_hook(),
        list(mitigation()),
        list(audit_entry()),
        list(lightspeed@ops@telemetry:metric())}.

-file("src/lightspeed/ops/overload_control.gleam", 127).
?DOC(" Build one overload signal.\n").
-spec signal(integer(), integer(), binary(), integer()) -> overload_signal().
signal(
    Queue_depth,
    Event_cadence_per_sec,
    Tenant_id,
    Tenant_budget_used_percent
) ->
    {overload_signal,
        Queue_depth,
        Event_cadence_per_sec,
        Tenant_id,
        Tenant_budget_used_percent}.

-file("src/lightspeed/ops/overload_control.gleam", 142).
?DOC(" Build one threshold profile.\n").
-spec thresholds(
    integer(),
    integer(),
    integer(),
    integer(),
    integer(),
    integer()
) -> thresholds().
thresholds(
    Warn_queue_depth,
    Critical_queue_depth,
    Warn_event_cadence_per_sec,
    Critical_event_cadence_per_sec,
    Warn_tenant_budget_percent,
    Critical_tenant_budget_percent
) ->
    {thresholds,
        Warn_queue_depth,
        Critical_queue_depth,
        Warn_event_cadence_per_sec,
        Critical_event_cadence_per_sec,
        Warn_tenant_budget_percent,
        Critical_tenant_budget_percent}.

-file("src/lightspeed/ops/overload_control.gleam", 161).
?DOC(" Default M50 threshold profile.\n").
-spec default_thresholds() -> thresholds().
default_thresholds() ->
    {thresholds, 120, 220, 220, 340, 80, 95}.

-file("src/lightspeed/ops/overload_control.gleam", 173).
?DOC(" Build one operator-policy hook profile.\n").
-spec operator_hook(
    binary(),
    boolean(),
    boolean(),
    boolean(),
    boolean(),
    integer()
) -> operator_hook().
operator_hook(
    Name,
    Allow_shed_events,
    Allow_cadence_throttle,
    Allow_tenant_budget_enforcement,
    Allow_read_only_mode,
    Rollback_window_ms
) ->
    {operator_hook,
        Name,
        Allow_shed_events,
        Allow_cadence_throttle,
        Allow_tenant_budget_enforcement,
        Allow_read_only_mode,
        Rollback_window_ms}.

-file("src/lightspeed/ops/overload_control.gleam", 192).
?DOC(" Default permissive operator-policy hook.\n").
-spec default_hook() -> operator_hook().
default_hook() ->
    {operator_hook, <<"default_autopilot"/utf8>>, true, true, true, true, 300}.

-file("src/lightspeed/ops/overload_control.gleam", 204).
?DOC(" Restrictive hook used for policy-boundary validation.\n").
-spec restrictive_hook() -> operator_hook().
restrictive_hook() ->
    {operator_hook, <<"restrictive_hook"/utf8>>, true, true, true, false, 300}.

-file("src/lightspeed/ops/overload_control.gleam", 216).
?DOC(" Build one overload runtime.\n").
-spec new(thresholds(), operator_hook()) -> runtime().
new(Thresholds, Hook) ->
    {runtime, Thresholds, Hook, [], [], []}.

-file("src/lightspeed/ops/overload_control.gleam", 227).
?DOC(" Classify one overload signal.\n").
-spec classify(overload_signal(), thresholds()) -> status().
classify(Signal, Thresholds) ->
    case ((erlang:element(2, Signal) >= erlang:element(3, Thresholds)) orelse (erlang:element(
        3,
        Signal
    )
    >= erlang:element(5, Thresholds)))
    orelse (erlang:element(5, Signal) >= erlang:element(7, Thresholds)) of
        true ->
            critical;

        false ->
            case ((erlang:element(2, Signal) >= erlang:element(2, Thresholds))
            orelse (erlang:element(3, Signal) >= erlang:element(4, Thresholds)))
            orelse (erlang:element(5, Signal) >= erlang:element(6, Thresholds)) of
                true ->
                    warning;

                false ->
                    healthy
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 627).
-spec tenant_mitigation(binary()) -> list(mitigation()).
tenant_mitigation(Tenant_id) ->
    case Tenant_id =:= <<""/utf8>> of
        true ->
            [];

        false ->
            [{enforce_tenant_budget, Tenant_id}]
    end.

-file("src/lightspeed/ops/overload_control.gleam", 1116).
-spec append(list(mitigation()), list(mitigation())) -> list(mitigation()).
append(Left, Right) ->
    case Left of
        [] ->
            Right;

        [Item | Rest] ->
            [Item | append(Rest, Right)]
    end.

-file("src/lightspeed/ops/overload_control.gleam", 249).
?DOC(" Recommended mitigation set for one signal/status pair.\n").
-spec recommended_mitigations(overload_signal(), status(), thresholds()) -> list(mitigation()).
recommended_mitigations(Signal, Status, Thresholds) ->
    case Status of
        healthy ->
            [];

        warning ->
            _pipe = [{shed_events, 15},
                {throttle_cadence, erlang:element(4, Thresholds)}],
            append(_pipe, tenant_mitigation(erlang:element(4, Signal)));

        critical ->
            _pipe@1 = [{shed_events, 45},
                {throttle_cadence, erlang:element(4, Thresholds)},
                enter_read_only_mode],
            append(_pipe@1, tenant_mitigation(erlang:element(4, Signal)))
    end.

-file("src/lightspeed/ops/overload_control.gleam", 406).
?DOC(" Active mitigations in stable order.\n").
-spec active_mitigations(runtime()) -> list(mitigation()).
active_mitigations(Runtime) ->
    lists:reverse(erlang:element(4, Runtime)).

-file("src/lightspeed/ops/overload_control.gleam", 449).
?DOC(" Stable status label.\n").
-spec status_label(status()) -> binary().
status_label(Status) ->
    case Status of
        healthy ->
            <<"healthy"/utf8>>;

        warning ->
            <<"warning"/utf8>>;

        critical ->
            <<"critical"/utf8>>
    end.

-file("src/lightspeed/ops/overload_control.gleam", 469).
?DOC(" Stable decision label.\n").
-spec decision_label(decision()) -> binary().
decision_label(Decision) ->
    case Decision of
        applied ->
            <<"applied"/utf8>>;

        rolled_back ->
            <<"rolled_back"/utf8>>;

        {blocked_by_hook, Hook_name} ->
            <<"blocked_by_hook:"/utf8, Hook_name/binary>>;

        {noop, Reason} ->
            <<"noop:"/utf8, Reason/binary>>
    end.

-file("src/lightspeed/ops/overload_control.gleam", 458).
?DOC(" Stable mitigation label.\n").
-spec mitigation_label(mitigation()) -> binary().
mitigation_label(Mitigation) ->
    case Mitigation of
        {shed_events, Percent} ->
            <<"shed_events:"/utf8, (erlang:integer_to_binary(Percent))/binary>>;

        {throttle_cadence, Max_events_per_sec} ->
            <<"throttle_cadence:"/utf8,
                (erlang:integer_to_binary(Max_events_per_sec))/binary>>;

        {enforce_tenant_budget, Tenant_id} ->
            <<"enforce_tenant_budget:"/utf8, Tenant_id/binary>>;

        enter_read_only_mode ->
            <<"enter_read_only_mode"/utf8>>
    end.

-file("src/lightspeed/ops/overload_control.gleam", 588).
?DOC(" Convert one audit entry into a deterministic overload metric.\n").
-spec audit_metric(audit_entry()) -> lightspeed@ops@telemetry:metric().
audit_metric(Entry) ->
    {counter,
        <<"lightspeed.overload.mitigation_total"/utf8>>,
        1,
        [{tag, <<"actor_id"/utf8>>, erlang:element(2, Entry)},
            {tag, <<"hook"/utf8>>, erlang:element(8, Entry)},
            {tag,
                <<"mitigation"/utf8>>,
                mitigation_label(erlang:element(3, Entry))},
            {tag, <<"decision"/utf8>>, decision_label(erlang:element(4, Entry))},
            {tag, <<"status"/utf8>>, status_label(erlang:element(7, Entry))}]}.

-file("src/lightspeed/ops/overload_control.gleam", 859).
-spec record_audit(runtime(), audit_entry()) -> runtime().
record_audit(Runtime, Entry) ->
    {runtime,
        erlang:element(2, Runtime),
        erlang:element(3, Runtime),
        erlang:element(4, Runtime),
        [Entry | erlang:element(5, Runtime)],
        [audit_metric(Entry) | erlang:element(6, Runtime)]}.

-file("src/lightspeed/ops/overload_control.gleam", 883).
-spec remove_mitigation(list(mitigation()), mitigation()) -> list(mitigation()).
remove_mitigation(Mitigations, Expected) ->
    case Mitigations of
        [] ->
            [];

        [Mitigation | Rest] ->
            case Mitigation =:= Expected of
                true ->
                    remove_mitigation(Rest, Expected);

                false ->
                    [Mitigation | remove_mitigation(Rest, Expected)]
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 875).
-spec has_mitigation(list(mitigation()), mitigation()) -> boolean().
has_mitigation(Mitigations, Expected) ->
    case Mitigations of
        [] ->
            false;

        [Mitigation | Rest] ->
            (Mitigation =:= Expected) orelse has_mitigation(Rest, Expected)
    end.

-file("src/lightspeed/ops/overload_control.gleam", 797).
-spec rollback(runtime(), mitigation(), binary(), binary(), integer(), status()) -> runtime().
rollback(Runtime, Mitigation, Actor_id, Reason, At_ms, Status) ->
    case has_mitigation(erlang:element(4, Runtime), Mitigation) of
        true ->
            _pipe = {runtime,
                erlang:element(2, Runtime),
                erlang:element(3, Runtime),
                remove_mitigation(erlang:element(4, Runtime), Mitigation),
                erlang:element(5, Runtime),
                erlang:element(6, Runtime)},
            record_audit(
                _pipe,
                {audit_entry,
                    Actor_id,
                    Mitigation,
                    rolled_back,
                    Reason,
                    At_ms,
                    Status,
                    erlang:element(2, erlang:element(3, Runtime))}
            );

        false ->
            record_audit(
                Runtime,
                {audit_entry,
                    Actor_id,
                    Mitigation,
                    {noop, <<"not_active"/utf8>>},
                    Reason,
                    At_ms,
                    Status,
                    erlang:element(2, erlang:element(3, Runtime))}
            )
    end.

-file("src/lightspeed/ops/overload_control.gleam", 701).
-spec rollback_not_desired_loop(
    runtime(),
    list(mitigation()),
    list(mitigation()),
    binary(),
    integer(),
    status()
) -> runtime().
rollback_not_desired_loop(Runtime, Active, Desired, Actor_id, Now_ms, Status) ->
    case Active of
        [] ->
            Runtime;

        [Mitigation | Rest] ->
            case has_mitigation(Desired, Mitigation) of
                true ->
                    rollback_not_desired_loop(
                        Runtime,
                        Rest,
                        Desired,
                        Actor_id,
                        Now_ms + 1,
                        Status
                    );

                false ->
                    rollback_not_desired_loop(
                        rollback(
                            Runtime,
                            Mitigation,
                            Actor_id,
                            <<"adaptive_reconcile"/utf8>>,
                            Now_ms,
                            Status
                        ),
                        Rest,
                        Desired,
                        Actor_id,
                        Now_ms + 1,
                        Status
                    )
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 684).
-spec rollback_not_desired(
    runtime(),
    list(mitigation()),
    binary(),
    integer(),
    status()
) -> runtime().
rollback_not_desired(Runtime, Desired, Actor_id, Now_ms, Status) ->
    rollback_not_desired_loop(
        Runtime,
        active_mitigations(Runtime),
        Desired,
        Actor_id,
        Now_ms,
        Status
    ).

-file("src/lightspeed/ops/overload_control.gleam", 866).
-spec allowed_mitigation(operator_hook(), mitigation()) -> boolean().
allowed_mitigation(Hook, Mitigation) ->
    case Mitigation of
        {shed_events, _} ->
            erlang:element(3, Hook);

        {throttle_cadence, _} ->
            erlang:element(4, Hook);

        {enforce_tenant_budget, _} ->
            erlang:element(5, Hook);

        enter_read_only_mode ->
            erlang:element(6, Hook)
    end.

-file("src/lightspeed/ops/overload_control.gleam", 742).
-spec apply(runtime(), mitigation(), binary(), binary(), integer(), status()) -> runtime().
apply(Runtime, Mitigation, Actor_id, Reason, At_ms, Status) ->
    case has_mitigation(erlang:element(4, Runtime), Mitigation) of
        true ->
            record_audit(
                Runtime,
                {audit_entry,
                    Actor_id,
                    Mitigation,
                    {noop, <<"already_active"/utf8>>},
                    Reason,
                    At_ms,
                    Status,
                    erlang:element(2, erlang:element(3, Runtime))}
            );

        false ->
            case allowed_mitigation(erlang:element(3, Runtime), Mitigation) of
                false ->
                    record_audit(
                        Runtime,
                        {audit_entry,
                            Actor_id,
                            Mitigation,
                            {blocked_by_hook,
                                erlang:element(2, erlang:element(3, Runtime))},
                            Reason,
                            At_ms,
                            Status,
                            erlang:element(2, erlang:element(3, Runtime))}
                    );

                true ->
                    _pipe = {runtime,
                        erlang:element(2, Runtime),
                        erlang:element(3, Runtime),
                        [Mitigation | erlang:element(4, Runtime)],
                        erlang:element(5, Runtime),
                        erlang:element(6, Runtime)},
                    record_audit(
                        _pipe,
                        {audit_entry,
                            Actor_id,
                            Mitigation,
                            applied,
                            Reason,
                            At_ms,
                            Status,
                            erlang:element(2, erlang:element(3, Runtime))}
                    )
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 657).
-spec apply_desired(
    runtime(),
    list(mitigation()),
    binary(),
    integer(),
    status()
) -> runtime().
apply_desired(Runtime, Desired, Actor_id, Now_ms, Status) ->
    case Desired of
        [] ->
            Runtime;

        [Mitigation | Rest] ->
            apply_desired(
                apply(
                    Runtime,
                    Mitigation,
                    Actor_id,
                    <<"adaptive_reconcile"/utf8>>,
                    Now_ms,
                    Status
                ),
                Rest,
                Actor_id,
                Now_ms + 1,
                Status
            )
    end.

-file("src/lightspeed/ops/overload_control.gleam", 646).
-spec reconcile_mitigations(
    runtime(),
    list(mitigation()),
    binary(),
    integer(),
    status()
) -> runtime().
reconcile_mitigations(Runtime, Desired, Actor_id, Now_ms, Status) ->
    Applied = apply_desired(Runtime, Desired, Actor_id, Now_ms, Status),
    rollback_not_desired(Applied, Desired, Actor_id, Now_ms + 1, Status).

-file("src/lightspeed/ops/overload_control.gleam", 277).
?DOC(" Evaluate one overload signal and reconcile adaptive mitigations.\n").
-spec evaluate(runtime(), overload_signal(), binary(), integer()) -> {runtime(),
    status()}.
evaluate(Runtime, Signal, Actor_id, Now_ms) ->
    Status = classify(Signal, erlang:element(2, Runtime)),
    Desired = recommended_mitigations(
        Signal,
        Status,
        erlang:element(2, Runtime)
    ),
    {reconcile_mitigations(Runtime, Desired, Actor_id, Now_ms, Status), Status}.

-file("src/lightspeed/ops/overload_control.gleam", 839).
-spec rollback_all(runtime(), list(mitigation()), binary(), integer(), status()) -> runtime().
rollback_all(Runtime, Mitigations, Actor_id, At_ms, Status) ->
    case Mitigations of
        [] ->
            Runtime;

        [Mitigation | Rest] ->
            rollback_all(
                rollback(
                    Runtime,
                    Mitigation,
                    Actor_id,
                    <<"rollback_drill"/utf8>>,
                    At_ms,
                    Status
                ),
                Rest,
                Actor_id,
                At_ms + 1,
                Status
            )
    end.

-file("src/lightspeed/ops/overload_control.gleam", 290).
?DOC(" Execute one rollback drill by rolling back all active mitigations.\n").
-spec run_rollback_drill(runtime(), binary(), integer(), status()) -> runtime().
run_rollback_drill(Runtime, Actor_id, Now_ms, Status) ->
    rollback_all(Runtime, active_mitigations(Runtime), Actor_id, Now_ms, Status).

-file("src/lightspeed/ops/overload_control.gleam", 300).
?DOC(" Stress budgets for M50 certification.\n").
-spec default_stress_budgets() -> list(stress_budget()).
default_stress_budgets() ->
    [{stress_budget, queue_depth_spike, 215, 210, 74, 2, true},
        {stress_budget, cadence_storm, 180, 360, 70, 3, true},
        {stress_budget, tenant_budget_hotspot, 160, 230, 98, 3, true},
        {stress_budget, combined_pressure, 260, 380, 99, 4, true}].

-file("src/lightspeed/ops/overload_control.gleam", 919).
-spec all_mitigations_allowed(operator_hook(), list(mitigation())) -> boolean().
all_mitigations_allowed(Hook, Mitigations) ->
    case Mitigations of
        [] ->
            true;

        [Mitigation | Rest] ->
            allowed_mitigation(Hook, Mitigation) andalso all_mitigations_allowed(
                Hook,
                Rest
            )
    end.

-file("src/lightspeed/ops/overload_control.gleam", 436).
?DOC(" `True` when active mitigations are compliant with the operator hook.\n").
-spec policy_compliant(runtime()) -> boolean().
policy_compliant(Runtime) ->
    all_mitigations_allowed(
        erlang:element(3, Runtime),
        active_mitigations(Runtime)
    ).

-file("src/lightspeed/ops/overload_control.gleam", 421).
?DOC(" Mitigation reversibility indicator.\n").
-spec mitigation_reversible(mitigation()) -> boolean().
mitigation_reversible(Mitigation) ->
    case Mitigation of
        {shed_events, _} ->
            true;

        {throttle_cadence, _} ->
            true;

        {enforce_tenant_budget, _} ->
            true;

        enter_read_only_mode ->
            true
    end.

-file("src/lightspeed/ops/overload_control.gleam", 911).
-spec all_mitigations_reversible(list(mitigation())) -> boolean().
all_mitigations_reversible(Mitigations) ->
    case Mitigations of
        [] ->
            true;

        [Mitigation | Rest] ->
            mitigation_reversible(Mitigation) andalso all_mitigations_reversible(
                Rest
            )
    end.

-file("src/lightspeed/ops/overload_control.gleam", 431).
?DOC(" `True` when all active mitigations are reversible.\n").
-spec active_mitigations_reversible(runtime()) -> boolean().
active_mitigations_reversible(Runtime) ->
    all_mitigations_reversible(active_mitigations(Runtime)).

-file("src/lightspeed/ops/overload_control.gleam", 897).
-spec unique_mitigations(list(mitigation()), list(mitigation())) -> boolean().
unique_mitigations(Mitigations, Seen) ->
    case Mitigations of
        [] ->
            true;

        [Mitigation | Rest] ->
            case has_mitigation(Seen, Mitigation) of
                true ->
                    false;

                false ->
                    unique_mitigations(Rest, [Mitigation | Seen])
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 634).
-spec thresholds_valid(thresholds()) -> boolean().
thresholds_valid(Thresholds) ->
    ((((((erlang:element(2, Thresholds) > 0) andalso (erlang:element(
        3,
        Thresholds
    )
    >= erlang:element(2, Thresholds)))
    andalso (erlang:element(4, Thresholds) > 0))
    andalso (erlang:element(5, Thresholds) >= erlang:element(4, Thresholds)))
    andalso (erlang:element(6, Thresholds) >= 0))
    andalso (erlang:element(7, Thresholds) >= erlang:element(6, Thresholds)))
    andalso (erlang:element(7, Thresholds) =< 100).

-file("src/lightspeed/ops/overload_control.gleam", 441).
?DOC(" Runtime invariants.\n").
-spec valid(runtime()) -> boolean().
valid(Runtime) ->
    ((thresholds_valid(erlang:element(2, Runtime)) andalso (erlang:element(
        7,
        erlang:element(3, Runtime)
    )
    > 0))
    andalso unique_mitigations(active_mitigations(Runtime), []))
    andalso active_mitigations_reversible(Runtime).

-file("src/lightspeed/ops/overload_control.gleam", 1015).
-spec peak_tenant_budget(list(overload_signal()), integer()) -> integer().
peak_tenant_budget(Signals, Peak) ->
    case Signals of
        [] ->
            Peak;

        [Signal | Rest] ->
            Next_peak = case erlang:element(5, Signal) > Peak of
                true ->
                    erlang:element(5, Signal);

                false ->
                    Peak
            end,
            peak_tenant_budget(Rest, Next_peak)
    end.

-file("src/lightspeed/ops/overload_control.gleam", 1002).
-spec peak_event_cadence(list(overload_signal()), integer()) -> integer().
peak_event_cadence(Signals, Peak) ->
    case Signals of
        [] ->
            Peak;

        [Signal | Rest] ->
            Next_peak = case erlang:element(3, Signal) > Peak of
                true ->
                    erlang:element(3, Signal);

                false ->
                    Peak
            end,
            peak_event_cadence(Rest, Next_peak)
    end.

-file("src/lightspeed/ops/overload_control.gleam", 989).
-spec peak_queue_depth(list(overload_signal()), integer()) -> integer().
peak_queue_depth(Signals, Peak) ->
    case Signals of
        [] ->
            Peak;

        [Signal | Rest] ->
            Next_peak = case erlang:element(2, Signal) > Peak of
                true ->
                    erlang:element(2, Signal);

                false ->
                    Peak
            end,
            peak_queue_depth(Rest, Next_peak)
    end.

-file("src/lightspeed/ops/overload_control.gleam", 978).
-spec count_decision(list(audit_entry()), binary()) -> integer().
count_decision(Audits, Expected_label) ->
    case Audits of
        [] ->
            0;

        [Entry | Rest] ->
            case decision_label(erlang:element(4, Entry)) =:= Expected_label of
                true ->
                    1 + count_decision(Rest, Expected_label);

                false ->
                    count_decision(Rest, Expected_label)
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 411).
?DOC(" Audit entries in stable order.\n").
-spec audit_entries(runtime()) -> list(audit_entry()).
audit_entries(Runtime) ->
    lists:reverse(erlang:element(5, Runtime)).

-file("src/lightspeed/ops/overload_control.gleam", 963).
-spec evaluate_signals(runtime(), list(overload_signal()), binary(), integer()) -> runtime().
evaluate_signals(Runtime, Signals, Actor_id, At_ms) ->
    case Signals of
        [] ->
            Runtime;

        [Signal | Rest] ->
            {Next_runtime, _} = evaluate(Runtime, Signal, Actor_id, At_ms),
            evaluate_signals(Next_runtime, Rest, Actor_id, At_ms + 5)
    end.

-file("src/lightspeed/ops/overload_control.gleam", 931).
-spec simulate_stress(stress_scenario(), list(overload_signal()), integer()) -> stress_observation().
simulate_stress(Scenario, Signals, Base_time_ms) ->
    Runtime = new(default_thresholds(), default_hook()),
    After_signals = evaluate_signals(
        Runtime,
        Signals,
        <<"autopilot"/utf8>>,
        Base_time_ms
    ),
    Rolled_back = run_rollback_drill(
        After_signals,
        <<"autopilot"/utf8>>,
        Base_time_ms + 50,
        critical
    ),
    Audits = audit_entries(Rolled_back),
    Mitigations_applied = count_decision(Audits, <<"applied"/utf8>>),
    Rollbacks_executed = count_decision(Audits, <<"rolled_back"/utf8>>),
    Peak_queue_depth = peak_queue_depth(Signals, 0),
    Peak_event_cadence = peak_event_cadence(Signals, 0),
    Peak_tenant_budget = peak_tenant_budget(Signals, 0),
    Bounded = (valid(Rolled_back) andalso policy_compliant(Rolled_back)) andalso (Rollbacks_executed
    >= Mitigations_applied),
    {stress_observation,
        Scenario,
        Peak_queue_depth,
        Peak_event_cadence,
        Peak_tenant_budget,
        Mitigations_applied,
        Rollbacks_executed,
        Bounded}.

-file("src/lightspeed/ops/overload_control.gleam", 338).
?DOC(" Run deterministic stress simulations for M50.\n").
-spec run_stress_simulation() -> list(stress_observation()).
run_stress_simulation() ->
    [simulate_stress(
            queue_depth_spike,
            [signal(130, 170, <<""/utf8>>, 70),
                signal(210, 205, <<""/utf8>>, 74)],
            1
        ),
        simulate_stress(
            cadence_storm,
            [signal(125, 260, <<""/utf8>>, 68),
                signal(170, 350, <<""/utf8>>, 70)],
            1000
        ),
        simulate_stress(
            tenant_budget_hotspot,
            [signal(140, 220, <<"tenant-alpha"/utf8>>, 84),
                signal(158, 228, <<"tenant-alpha"/utf8>>, 97)],
            2000
        ),
        simulate_stress(
            combined_pressure,
            [signal(155, 240, <<"tenant-bravo"/utf8>>, 88),
                signal(255, 370, <<"tenant-bravo"/utf8>>, 99)],
            3000
        )].

-file("src/lightspeed/ops/overload_control.gleam", 1123).
-spec bool_label(boolean()) -> binary().
bool_label(Value) ->
    case Value of
        true ->
            <<"true"/utf8>>;

        false ->
            <<"false"/utf8>>
    end.

-file("src/lightspeed/ops/overload_control.gleam", 1102).
-spec budget_for_scenario(stress_scenario(), list(stress_budget())) -> {ok,
        stress_budget()} |
    {error, binary()}.
budget_for_scenario(Scenario, Budgets) ->
    case Budgets of
        [] ->
            {error, <<"missing_stress_budget"/utf8>>};

        [Budget | Rest] ->
            case erlang:element(2, Budget) =:= Scenario of
                true ->
                    {ok, Budget};

                false ->
                    budget_for_scenario(Scenario, Rest)
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 1042).
-spec evaluate_one_budget(stress_observation(), list(stress_budget())) -> budget_result().
evaluate_one_budget(Observation, Budgets) ->
    case budget_for_scenario(erlang:element(2, Observation), Budgets) of
        {error, Reason} ->
            {budget_result, erlang:element(2, Observation), false, Reason};

        {ok, Budget} ->
            Queue_ok = erlang:element(3, Observation) =< erlang:element(
                3,
                Budget
            ),
            Cadence_ok = erlang:element(4, Observation) =< erlang:element(
                4,
                Budget
            ),
            Tenant_ok = erlang:element(5, Observation) =< erlang:element(
                5,
                Budget
            ),
            Mitigation_ok = erlang:element(6, Observation) >= erlang:element(
                6,
                Budget
            ),
            Rollback_ok = case erlang:element(7, Budget) of
                true ->
                    erlang:element(7, Observation) > 0;

                false ->
                    true
            end,
            Bounded_ok = erlang:element(8, Observation),
            Passed = ((((Queue_ok andalso Cadence_ok) andalso Tenant_ok) andalso Mitigation_ok)
            andalso Rollback_ok)
            andalso Bounded_ok,
            Reason@1 = case Passed of
                true ->
                    <<"within_budget"/utf8>>;

                false ->
                    <<<<<<<<<<<<<<<<<<<<<<<<"budget_exceeded:"/utf8,
                                                                    "queue="/utf8>>/binary,
                                                                (bool_label(
                                                                    Queue_ok
                                                                ))/binary>>/binary,
                                                            ":cadence="/utf8>>/binary,
                                                        (bool_label(Cadence_ok))/binary>>/binary,
                                                    ":tenant="/utf8>>/binary,
                                                (bool_label(Tenant_ok))/binary>>/binary,
                                            ":mitigations="/utf8>>/binary,
                                        (bool_label(Mitigation_ok))/binary>>/binary,
                                    ":rollback="/utf8>>/binary,
                                (bool_label(Rollback_ok))/binary>>/binary,
                            ":bounded="/utf8>>/binary,
                        (bool_label(Bounded_ok))/binary>>
            end,
            {budget_result, erlang:element(2, Observation), Passed, Reason@1}
    end.

-file("src/lightspeed/ops/overload_control.gleam", 1028).
-spec evaluate_budgets_loop(
    list(stress_observation()),
    list(stress_budget()),
    list(budget_result())
) -> list(budget_result()).
evaluate_budgets_loop(Observations, Budgets, Results_rev) ->
    case Observations of
        [] ->
            lists:reverse(Results_rev);

        [Observation | Rest] ->
            Result = evaluate_one_budget(Observation, Budgets),
            evaluate_budgets_loop(Rest, Budgets, [Result | Results_rev])
    end.

-file("src/lightspeed/ops/overload_control.gleam", 376).
?DOC(" Evaluate stress observations against one budget profile.\n").
-spec evaluate_stress_budgets(list(stress_observation()), list(stress_budget())) -> list(budget_result()).
evaluate_stress_budgets(Observations, Budgets) ->
    evaluate_budgets_loop(Observations, Budgets, []).

-file("src/lightspeed/ops/overload_control.gleam", 384).
?DOC(" Count failing stress budgets.\n").
-spec budget_failures(list(budget_result())) -> integer().
budget_failures(Results) ->
    case Results of
        [] ->
            0;

        [Result | Rest] ->
            case erlang:element(3, Result) of
                true ->
                    budget_failures(Rest);

                false ->
                    1 + budget_failures(Rest)
            end
    end.

-file("src/lightspeed/ops/overload_control.gleam", 396).
?DOC(" Runtime threshold accessor.\n").
-spec runtime_thresholds(runtime()) -> thresholds().
runtime_thresholds(Runtime) ->
    erlang:element(2, Runtime).

-file("src/lightspeed/ops/overload_control.gleam", 401).
?DOC(" Runtime operator hook accessor.\n").
-spec runtime_hook(runtime()) -> operator_hook().
runtime_hook(Runtime) ->
    erlang:element(3, Runtime).

-file("src/lightspeed/ops/overload_control.gleam", 416).
?DOC(" Telemetry metrics in stable order.\n").
-spec telemetry_metrics(runtime()) -> list(lightspeed@ops@telemetry:metric()).
telemetry_metrics(Runtime) ->
    lists:reverse(erlang:element(6, Runtime)).

-file("src/lightspeed/ops/overload_control.gleam", 620).
-spec tenant_label(binary()) -> binary().
tenant_label(Tenant_id) ->
    case Tenant_id =:= <<""/utf8>> of
        true ->
            <<"none"/utf8>>;

        false ->
            Tenant_id
    end.

-file("src/lightspeed/ops/overload_control.gleam", 479).
?DOC(" Stable signal label.\n").
-spec signal_label(overload_signal()) -> binary().
signal_label(Signal) ->
    <<<<<<<<<<<<<<"queue="/utf8,
                                (erlang:integer_to_binary(
                                    erlang:element(2, Signal)
                                ))/binary>>/binary,
                            "|cadence="/utf8>>/binary,
                        (erlang:integer_to_binary(erlang:element(3, Signal)))/binary>>/binary,
                    "|tenant="/utf8>>/binary,
                (tenant_label(erlang:element(4, Signal)))/binary>>/binary,
            "|tenant_budget="/utf8>>/binary,
        (erlang:integer_to_binary(erlang:element(5, Signal)))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 491).
?DOC(" Stable threshold label.\n").
-spec thresholds_label(thresholds()) -> binary().
thresholds_label(Thresholds) ->
    <<<<<<<<<<<<<<<<<<<<<<"warn_queue="/utf8,
                                                (erlang:integer_to_binary(
                                                    erlang:element(
                                                        2,
                                                        Thresholds
                                                    )
                                                ))/binary>>/binary,
                                            ",critical_queue="/utf8>>/binary,
                                        (erlang:integer_to_binary(
                                            erlang:element(3, Thresholds)
                                        ))/binary>>/binary,
                                    ",warn_cadence="/utf8>>/binary,
                                (erlang:integer_to_binary(
                                    erlang:element(4, Thresholds)
                                ))/binary>>/binary,
                            ",critical_cadence="/utf8>>/binary,
                        (erlang:integer_to_binary(erlang:element(5, Thresholds)))/binary>>/binary,
                    ",warn_tenant="/utf8>>/binary,
                (erlang:integer_to_binary(erlang:element(6, Thresholds)))/binary>>/binary,
            ",critical_tenant="/utf8>>/binary,
        (erlang:integer_to_binary(erlang:element(7, Thresholds)))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 507).
?DOC(" Stable operator-hook label.\n").
-spec hook_label(operator_hook()) -> binary().
hook_label(Hook) ->
    <<<<<<<<<<<<<<<<<<<<(erlang:element(2, Hook))/binary, "|shed="/utf8>>/binary,
                                        (bool_label(erlang:element(3, Hook)))/binary>>/binary,
                                    "|throttle="/utf8>>/binary,
                                (bool_label(erlang:element(4, Hook)))/binary>>/binary,
                            "|tenant="/utf8>>/binary,
                        (bool_label(erlang:element(5, Hook)))/binary>>/binary,
                    "|read_only="/utf8>>/binary,
                (bool_label(erlang:element(6, Hook)))/binary>>/binary,
            "|rollback_window_ms="/utf8>>/binary,
        (erlang:integer_to_binary(erlang:element(7, Hook)))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 522).
?DOC(" Stable audit-entry label.\n").
-spec audit_label(audit_entry()) -> binary().
audit_label(Entry) ->
    <<<<<<<<<<<<<<<<<<<<<<<<<<"actor="/utf8, (erlang:element(2, Entry))/binary>>/binary,
                                                    "|mitigation="/utf8>>/binary,
                                                (mitigation_label(
                                                    erlang:element(3, Entry)
                                                ))/binary>>/binary,
                                            "|decision="/utf8>>/binary,
                                        (decision_label(
                                            erlang:element(4, Entry)
                                        ))/binary>>/binary,
                                    "|status="/utf8>>/binary,
                                (status_label(erlang:element(7, Entry)))/binary>>/binary,
                            "|hook="/utf8>>/binary,
                        (erlang:element(8, Entry))/binary>>/binary,
                    "|at_ms="/utf8>>/binary,
                (erlang:integer_to_binary(erlang:element(6, Entry)))/binary>>/binary,
            "|reason="/utf8>>/binary,
        (erlang:element(5, Entry))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 1130).
-spec join_with(binary(), list(binary())) -> binary().
join_with(Separator, Values) ->
    case Values of
        [] ->
            <<""/utf8>>;

        [Value] ->
            Value;

        [Value@1 | Rest] ->
            <<<<Value@1/binary, Separator/binary>>/binary,
                (join_with(Separator, Rest))/binary>>
    end.

-file("src/lightspeed/ops/overload_control.gleam", 540).
?DOC(" Stable runtime signature.\n").
-spec signature(runtime()) -> binary().
signature(Runtime) ->
    <<<<<<<<<<<<<<"thresholds="/utf8,
                                (thresholds_label(erlang:element(2, Runtime)))/binary>>/binary,
                            "|hook="/utf8>>/binary,
                        (hook_label(erlang:element(3, Runtime)))/binary>>/binary,
                    "|active="/utf8>>/binary,
                (join_with(
                    <<","/utf8>>,
                    gleam@list:map(
                        active_mitigations(Runtime),
                        fun mitigation_label/1
                    )
                ))/binary>>/binary,
            "|audits="/utf8>>/binary,
        (join_with(
            <<";"/utf8>>,
            gleam@list:map(audit_entries(Runtime), fun audit_label/1)
        ))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 552).
?DOC(" Stable stress-scenario label.\n").
-spec stress_scenario_label(stress_scenario()) -> binary().
stress_scenario_label(Scenario) ->
    case Scenario of
        queue_depth_spike ->
            <<"queue_depth_spike"/utf8>>;

        cadence_storm ->
            <<"cadence_storm"/utf8>>;

        tenant_budget_hotspot ->
            <<"tenant_budget_hotspot"/utf8>>;

        combined_pressure ->
            <<"combined_pressure"/utf8>>
    end.

-file("src/lightspeed/ops/overload_control.gleam", 562).
?DOC(" Stable stress-observation signature.\n").
-spec stress_observation_signature(stress_observation()) -> binary().
stress_observation_signature(Observation) ->
    <<<<<<<<<<<<<<<<<<<<<<<<(stress_scenario_label(
                                                        erlang:element(
                                                            2,
                                                            Observation
                                                        )
                                                    ))/binary,
                                                    ":peak_queue="/utf8>>/binary,
                                                (erlang:integer_to_binary(
                                                    erlang:element(
                                                        3,
                                                        Observation
                                                    )
                                                ))/binary>>/binary,
                                            ":peak_cadence="/utf8>>/binary,
                                        (erlang:integer_to_binary(
                                            erlang:element(4, Observation)
                                        ))/binary>>/binary,
                                    ":peak_tenant_budget="/utf8>>/binary,
                                (erlang:integer_to_binary(
                                    erlang:element(5, Observation)
                                ))/binary>>/binary,
                            ":mitigations="/utf8>>/binary,
                        (erlang:integer_to_binary(
                            erlang:element(6, Observation)
                        ))/binary>>/binary,
                    ":rollbacks="/utf8>>/binary,
                (erlang:integer_to_binary(erlang:element(7, Observation)))/binary>>/binary,
            ":bounded="/utf8>>/binary,
        (bool_label(erlang:element(8, Observation)))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 579).
?DOC(" Stable stress-budget result signature.\n").
-spec budget_result_signature(budget_result()) -> binary().
budget_result_signature(Result) ->
    <<<<<<<<(stress_scenario_label(erlang:element(2, Result)))/binary,
                    ":passed="/utf8>>/binary,
                (bool_label(erlang:element(3, Result)))/binary>>/binary,
            ":reason="/utf8>>/binary,
        (erlang:element(4, Result))/binary>>.

-file("src/lightspeed/ops/overload_control.gleam", 606).
?DOC(" Audit entry decision accessor.\n").
-spec audit_decision(audit_entry()) -> decision().
audit_decision(Entry) ->
    erlang:element(4, Entry).

-file("src/lightspeed/ops/overload_control.gleam", 611).
?DOC(" Audit entry mitigation accessor.\n").
-spec audit_mitigation(audit_entry()) -> mitigation().
audit_mitigation(Entry) ->
    erlang:element(3, Entry).

-file("src/lightspeed/ops/overload_control.gleam", 616).
?DOC(" Stress observation scenario accessor.\n").
-spec stress_scenario(stress_observation()) -> stress_scenario().
stress_scenario(Observation) ->
    erlang:element(2, Observation).