-module(spectator@internal@api).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/spectator/internal/api.gleam").
-export([invert_sort_direction/1, sort_table_list/3, sort_port_list/3, get_process_list/1, get_process_info/2, get_details/2, is_otp_compatible/2, get_status/3, get_state/3, request_otp_data/3, list_ets_tables/1, get_ets_table_info/2, get_raw_ets_data/2, opaque_tuple_to_list/1, get_ets_data/2, get_port_list/1, get_port_info/2, get_port_details/2, get_memory_statistics/1, sort_process_list/3, format_pid/1, format_port/1, kill_process/2, suspend/2, resume/2, new_ets_table/2, serialize_pid/1, serialize_port/1, decode_pid/1, decode_port/1, compare_dynamic_data/2, sort_table_data/3, get_word_size/1, get_system_info/1, start_tag_manager/0, add_tag/2, get_tag/1, hidden_connect_node/1, connect_node/1, node_from_params/1]).
-export_type([erlang_error/0, opaque_tuple/0, sys_state/0, system_primitive/0, table/0, table_data/0, process_otp_status/0, otp_details/0, process_item/0, process_info/0, process_details/0, port_item/0, port_info/0, port_details/0, process_sort_criteria/0, table_sort_criteria/0, port_sort_criteria/0, sort_direction/0, memory_statistics/0, system_info/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(false).

-type erlang_error() :: {erpc_error, gleam@erlang@atom:atom_()} |
    not_supported_error |
    bad_argument_error |
    returned_undefined_error |
    not_found_error |
    no_info_error |
    {dynamic_error, gleam@dynamic:dynamic_()}.

-type opaque_tuple() :: any().

-type sys_state() :: process_running | process_suspended.

-type system_primitive() :: {process_primitive,
        gleam@erlang@process:pid_(),
        gleam@option:option(gleam@erlang@atom:atom_()),
        gleam@option:option(binary())} |
    {port_primitive,
        gleam@erlang@port:port_(),
        gleam@option:option(gleam@erlang@atom:atom_())} |
    {remote_process_primitive,
        gleam@erlang@atom:atom_(),
        gleam@erlang@atom:atom_()} |
    {nif_resource_primitive, gleam@dynamic:dynamic_()}.

-type table() :: {table,
        gleam@erlang@reference:reference_(),
        gleam@erlang@atom:atom_(),
        gleam@erlang@atom:atom_(),
        integer(),
        integer(),
        system_primitive(),
        gleam@erlang@atom:atom_(),
        boolean(),
        boolean()}.

-type table_data() :: {table_data,
        list(list(gleam@dynamic:dynamic_())),
        integer()}.

-type process_otp_status() :: {process_otp_status,
        gleam@erlang@process:pid_(),
        gleam@erlang@atom:atom_(),
        gleam@erlang@process:pid_(),
        sys_state(),
        list(gleam@dynamic:dynamic_())}.

-type otp_details() :: {otp_details,
        gleam@erlang@process:pid_(),
        process_otp_status(),
        gleam@dynamic:dynamic_()}.

-type process_item() :: {process_item,
        gleam@erlang@process:pid_(),
        process_info()}.

-type process_info() :: {process_info,
        {gleam@erlang@atom:atom_(), gleam@erlang@atom:atom_(), integer()},
        {gleam@erlang@atom:atom_(), gleam@erlang@atom:atom_(), integer()},
        gleam@option:option(gleam@erlang@atom:atom_()),
        integer(),
        integer(),
        integer(),
        gleam@option:option(binary()),
        gleam@erlang@atom:atom_()}.

-type process_details() :: {process_details,
        list(gleam@dynamic:dynamic_()),
        list(system_primitive()),
        list(system_primitive()),
        list(system_primitive()),
        boolean(),
        gleam@option:option(system_primitive())}.

-type port_item() :: {port_item, gleam@erlang@port:port_(), port_info()}.

-type port_info() :: {port_info,
        binary(),
        gleam@option:option(gleam@erlang@atom:atom_()),
        system_primitive(),
        gleam@option:option(integer()),
        integer(),
        integer(),
        integer(),
        integer()}.

-type port_details() :: {port_details,
        list(system_primitive()),
        list(system_primitive()),
        list(system_primitive())}.

-type process_sort_criteria() :: sort_by_process_name |
    sort_by_tag |
    sort_by_current_function |
    sort_by_process_memory |
    sort_by_reductions |
    sort_by_message_queue |
    sort_by_process_status.

-type table_sort_criteria() :: sort_by_table_id |
    sort_by_table_name |
    sort_by_table_type |
    sort_by_table_size |
    sort_by_table_memory |
    sort_by_table_owner |
    sort_by_table_protection |
    sort_by_table_read_concurrency |
    sort_by_table_write_concurrency.

-type port_sort_criteria() :: sort_by_port_name |
    sort_by_port_command |
    sort_by_port_connected_process |
    sort_by_port_os_pid |
    sort_by_port_input |
    sort_by_port_output |
    sort_by_port_memory |
    sort_by_port_queue_size.

-type sort_direction() :: ascending | descending.

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

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

-file("src/spectator/internal/api.gleam", 255).
?DOC(false).
-spec invert_sort_direction(sort_direction()) -> sort_direction().
invert_sort_direction(Direction) ->
    case Direction of
        ascending ->
            descending;

        descending ->
            ascending
    end.

-file("src/spectator/internal/api.gleam", 262).
?DOC(false).
-spec apply_direction(gleam@order:order(), sort_direction()) -> gleam@order:order().
apply_direction(Order, Direction) ->
    case Direction of
        ascending ->
            Order;

        descending ->
            gleam@order:negate(Order)
    end.

-file("src/spectator/internal/api.gleam", 284).
?DOC(false).
-spec compare_name(process_item(), process_item()) -> gleam@order:order().
compare_name(A, B) ->
    case {erlang:element(4, erlang:element(3, A)),
        erlang:element(4, erlang:element(3, B))} of
        {{some, A_name}, {some, B_name}} ->
            gleam@string:compare(
                erlang:atom_to_binary(A_name),
                erlang:atom_to_binary(B_name)
            );

        {none, {some, _}} ->
            lt;

        {{some, _}, none} ->
            gt;

        {none, none} ->
            eq
    end.

-file("src/spectator/internal/api.gleam", 350).
?DOC(false).
-spec disgustingly_index_into_list_at(list(ABXZ), integer()) -> {ok, ABXZ} |
    {error, nil}.
disgustingly_index_into_list_at(List, Index) ->
    case Index >= 0 of
        true ->
            _pipe = List,
            _pipe@1 = gleam@list:drop(_pipe, Index),
            gleam@list:first(_pipe@1);

        false ->
            {error, nil}
    end.

-file("src/spectator/internal/api.gleam", 390).
?DOC(false).
-spec sort_table_list(list(table()), table_sort_criteria(), sort_direction()) -> list(table()).
sort_table_list(Input, Criteria, Direction) ->
    case Criteria of
        sort_by_table_id ->
            gleam@list:sort(
                Input,
                fun(A, B) ->
                    _pipe = gleam@string:compare(
                        gleam@string:inspect(erlang:element(2, A)),
                        gleam@string:inspect(erlang:element(2, B))
                    ),
                    apply_direction(_pipe, Direction)
                end
            );

        sort_by_table_name ->
            gleam@list:sort(
                Input,
                fun(A@1, B@1) ->
                    _pipe@1 = gleam@string:compare(
                        erlang:atom_to_binary(erlang:element(3, A@1)),
                        erlang:atom_to_binary(erlang:element(3, B@1))
                    ),
                    apply_direction(_pipe@1, Direction)
                end
            );

        sort_by_table_type ->
            gleam@list:sort(
                Input,
                fun(A@2, B@2) ->
                    _pipe@2 = gleam@string:compare(
                        erlang:atom_to_binary(erlang:element(4, A@2)),
                        erlang:atom_to_binary(erlang:element(4, B@2))
                    ),
                    apply_direction(_pipe@2, Direction)
                end
            );

        sort_by_table_size ->
            gleam@list:sort(
                Input,
                fun(A@3, B@3) ->
                    _pipe@3 = gleam@int:compare(
                        erlang:element(5, A@3),
                        erlang:element(5, B@3)
                    ),
                    apply_direction(_pipe@3, Direction)
                end
            );

        sort_by_table_memory ->
            gleam@list:sort(
                Input,
                fun(A@4, B@4) ->
                    _pipe@4 = gleam@int:compare(
                        erlang:element(6, A@4),
                        erlang:element(6, B@4)
                    ),
                    apply_direction(_pipe@4, Direction)
                end
            );

        sort_by_table_owner ->
            gleam@list:sort(
                Input,
                fun(A@5, B@5) ->
                    _pipe@5 = gleam@string:compare(
                        gleam@string:inspect(erlang:element(7, A@5)),
                        gleam@string:inspect(erlang:element(7, B@5))
                    ),
                    apply_direction(_pipe@5, Direction)
                end
            );

        sort_by_table_protection ->
            gleam@list:sort(
                Input,
                fun(A@6, B@6) ->
                    _pipe@6 = gleam@string:compare(
                        erlang:atom_to_binary(erlang:element(8, A@6)),
                        erlang:atom_to_binary(erlang:element(8, B@6))
                    ),
                    apply_direction(_pipe@6, Direction)
                end
            );

        sort_by_table_read_concurrency ->
            gleam@list:sort(
                Input,
                fun(A@7, B@7) ->
                    _pipe@7 = spectator@internal@common:bool_compare(
                        erlang:element(9, A@7),
                        erlang:element(9, B@7)
                    ),
                    apply_direction(_pipe@7, Direction)
                end
            );

        sort_by_table_write_concurrency ->
            gleam@list:sort(
                Input,
                fun(A@8, B@8) ->
                    _pipe@8 = spectator@internal@common:bool_compare(
                        erlang:element(10, A@8),
                        erlang:element(10, B@8)
                    ),
                    apply_direction(_pipe@8, Direction)
                end
            )
    end.

-file("src/spectator/internal/api.gleam", 457).
?DOC(false).
-spec sort_port_list(list(port_item()), port_sort_criteria(), sort_direction()) -> list(port_item()).
sort_port_list(Input, Criteria, Direction) ->
    case Criteria of
        sort_by_port_name ->
            gleam@list:sort(
                Input,
                fun(A, B) ->
                    case {erlang:element(3, erlang:element(3, A)),
                        erlang:element(3, erlang:element(3, B))} of
                        {{some, A@1}, {some, B@1}} ->
                            gleam@string:compare(
                                erlang:atom_to_binary(A@1),
                                erlang:atom_to_binary(B@1)
                            );

                        {{some, _}, none} ->
                            gt;

                        {none, {some, _}} ->
                            lt;

                        {none, none} ->
                            eq
                    end
                end
            );

        sort_by_port_command ->
            gleam@list:sort(
                Input,
                fun(A@2, B@2) ->
                    _pipe = gleam@string:compare(
                        erlang:element(2, erlang:element(3, A@2)),
                        erlang:element(2, erlang:element(3, B@2))
                    ),
                    apply_direction(_pipe, Direction)
                end
            );

        sort_by_port_connected_process ->
            gleam@list:sort(
                Input,
                fun(A@3, B@3) ->
                    _pipe@1 = gleam@string:compare(
                        gleam@string:inspect(
                            erlang:element(4, erlang:element(3, A@3))
                        ),
                        gleam@string:inspect(
                            erlang:element(4, erlang:element(3, B@3))
                        )
                    ),
                    apply_direction(_pipe@1, Direction)
                end
            );

        sort_by_port_os_pid ->
            gleam@list:sort(
                Input,
                fun(A@4, B@4) ->
                    _pipe@2 = case {erlang:element(5, erlang:element(3, A@4)),
                        erlang:element(5, erlang:element(3, B@4))} of
                        {{some, A@5}, {some, B@5}} ->
                            gleam@int:compare(A@5, B@5);

                        {{some, _}, none} ->
                            gt;

                        {none, {some, _}} ->
                            lt;

                        {none, none} ->
                            eq
                    end,
                    apply_direction(_pipe@2, Direction)
                end
            );

        sort_by_port_input ->
            gleam@list:sort(
                Input,
                fun(A@6, B@6) ->
                    _pipe@3 = gleam@int:compare(
                        erlang:element(6, erlang:element(3, A@6)),
                        erlang:element(6, erlang:element(3, B@6))
                    ),
                    apply_direction(_pipe@3, Direction)
                end
            );

        sort_by_port_output ->
            gleam@list:sort(
                Input,
                fun(A@7, B@7) ->
                    _pipe@4 = gleam@int:compare(
                        erlang:element(7, erlang:element(3, A@7)),
                        erlang:element(7, erlang:element(3, B@7))
                    ),
                    apply_direction(_pipe@4, Direction)
                end
            );

        sort_by_port_memory ->
            gleam@list:sort(
                Input,
                fun(A@8, B@8) ->
                    _pipe@5 = gleam@int:compare(
                        erlang:element(8, erlang:element(3, A@8)),
                        erlang:element(8, erlang:element(3, B@8))
                    ),
                    apply_direction(_pipe@5, Direction)
                end
            );

        sort_by_port_queue_size ->
            gleam@list:sort(
                Input,
                fun(A@9, B@9) ->
                    _pipe@6 = gleam@int:compare(
                        erlang:element(9, erlang:element(3, A@9)),
                        erlang:element(9, erlang:element(3, B@9))
                    ),
                    apply_direction(_pipe@6, Direction)
                end
            )
    end.

-file("src/spectator/internal/api.gleam", 528).
?DOC(false).
-spec get_process_list(gleam@option:option(gleam@erlang@atom:atom_())) -> list(process_item()).
get_process_list(N) ->
    case spectator_ffi:list_processes(N) of
        {ok, Items} ->
            Items;

        {error, E} ->
            logging:log(
                alert,
                <<"Failed to list processes, error: "/utf8,
                    (gleam@string:inspect(E))/binary>>
            ),
            []
    end.

-file("src/spectator/internal/api.gleam", 545).
?DOC(false).
-spec get_process_info(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_()
) -> {ok, process_info()} | {error, erlang_error()}.
get_process_info(Node, Pid) ->
    spectator_ffi:get_process_info(Node, Pid).

-file("src/spectator/internal/api.gleam", 553).
?DOC(false).
-spec get_details(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_()
) -> {ok, process_details()} | {error, erlang_error()}.
get_details(Node, Pid) ->
    spectator_ffi:get_details(Node, Pid).

-file("src/spectator/internal/api.gleam", 561).
?DOC(false).
-spec is_otp_compatible(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_()
) -> boolean().
is_otp_compatible(Node, Pid) ->
    spectator_ffi:is_otp_compatible(Node, Pid).

-file("src/spectator/internal/api.gleam", 590).
?DOC(false).
-spec get_status(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_(),
    integer()
) -> {ok, process_otp_status()} | {error, erlang_error()}.
get_status(Node, Pid, Timeout) ->
    spectator_ffi:get_status(Node, Pid, Timeout).

-file("src/spectator/internal/api.gleam", 597).
?DOC(false).
-spec get_state(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_(),
    integer()
) -> {ok, gleam@dynamic:dynamic_()} | {error, erlang_error()}.
get_state(Node, Pid, Timeout) ->
    spectator_ffi:get_state(Node, Pid, Timeout).

-file("src/spectator/internal/api.gleam", 563).
?DOC(false).
-spec request_otp_data(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_(),
    fun((otp_details()) -> nil)
) -> gleam@erlang@process:pid_().
request_otp_data(Node, Proc, Callback) ->
    proc_lib:spawn(fun() -> case spectator_ffi:is_otp_compatible(Node, Proc) of
                false ->
                    nil;

                true ->
                    case spectator_ffi:get_status(Node, Proc, 100) of
                        {error, _} ->
                            nil;

                        {ok, Status} ->
                            State = begin
                                _pipe = spectator_ffi:get_state(Node, Proc, 100),
                                gleam@result:unwrap(
                                    _pipe,
                                    gleam@function:identity(none)
                                )
                            end,
                            Callback({otp_details, Proc, Status, State})
                    end
            end end).

-file("src/spectator/internal/api.gleam", 634).
?DOC(false).
-spec list_ets_tables(gleam@option:option(gleam@erlang@atom:atom_())) -> {ok,
        list(table())} |
    {error, erlang_error()}.
list_ets_tables(Node) ->
    spectator_ffi:list_ets_tables(Node).

-file("src/spectator/internal/api.gleam", 637).
?DOC(false).
-spec get_ets_table_info(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@atom:atom_()
) -> {ok, table()} | {error, erlang_error()}.
get_ets_table_info(Node, Name) ->
    spectator_ffi:get_ets_table_info(Node, Name).

-file("src/spectator/internal/api.gleam", 643).
?DOC(false).
-spec get_raw_ets_data(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@reference:reference_()
) -> {ok, list(list(opaque_tuple()))} | {error, erlang_error()}.
get_raw_ets_data(Node, Table) ->
    spectator_ffi:get_ets_data(Node, Table).

-file("src/spectator/internal/api.gleam", 649).
?DOC(false).
-spec opaque_tuple_to_list(opaque_tuple()) -> list(gleam@dynamic:dynamic_()).
opaque_tuple_to_list(Tuple) ->
    spectator_ffi:opaque_tuple_to_list(Tuple).

-file("src/spectator/internal/api.gleam", 610).
?DOC(false).
-spec process_raw_ets_data(
    list(list(opaque_tuple())),
    list(list(gleam@dynamic:dynamic_())),
    integer()
) -> {ok, table_data()} | {error, erlang_error()}.
process_raw_ets_data(Remainder, Accumulator, Max_length) ->
    case Remainder of
        [] ->
            {ok, {table_data, Accumulator, Max_length}};

        [[Tup] | Rest] ->
            Converted = spectator_ffi:opaque_tuple_to_list(Tup),
            process_raw_ets_data(
                Rest,
                [Converted | Accumulator],
                gleam@int:max(Max_length, erlang:length(Converted))
            );

        _ ->
            {error, bad_argument_error}
    end.

-file("src/spectator/internal/api.gleam", 605).
?DOC(false).
-spec get_ets_data(gleam@option:option(gleam@erlang@atom:atom_()), table()) -> {ok,
        table_data()} |
    {error, erlang_error()}.
get_ets_data(Node, Table) ->
    gleam@result:'try'(
        spectator_ffi:get_ets_data(Node, erlang:element(2, Table)),
        fun(Raw_data) -> process_raw_ets_data(Raw_data, [], 0) end
    ).

-file("src/spectator/internal/api.gleam", 653).
?DOC(false).
-spec get_port_list(gleam@option:option(gleam@erlang@atom:atom_())) -> list(port_item()).
get_port_list(Node) ->
    case spectator_ffi:list_ports(Node) of
        {ok, Items} ->
            Items;

        {error, E} ->
            logging:log(
                alert,
                <<"Failed to list ports, error: "/utf8,
                    (gleam@string:inspect(E))/binary>>
            ),
            []
    end.

-file("src/spectator/internal/api.gleam", 667).
?DOC(false).
-spec get_port_info(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@port:port_()
) -> {ok, port_info()} | {error, erlang_error()}.
get_port_info(Node, Port) ->
    spectator_ffi:get_port_info(Node, Port).

-file("src/spectator/internal/api.gleam", 673).
?DOC(false).
-spec get_port_details(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@port:port_()
) -> {ok, port_details()} | {error, erlang_error()}.
get_port_details(Node, Port) ->
    spectator_ffi:get_port_details(Node, Port).

-file("src/spectator/internal/api.gleam", 681).
?DOC(false).
-spec get_memory_statistics(gleam@option:option(gleam@erlang@atom:atom_())) -> {ok,
        memory_statistics()} |
    {error, erlang_error()}.
get_memory_statistics(Node) ->
    spectator_ffi:get_memory_statistics(Node).

-file("src/spectator/internal/api.gleam", 687).
?DOC(false).
-spec function_to_string(
    {gleam@erlang@atom:atom_(), gleam@erlang@atom:atom_(), integer()}
) -> binary().
function_to_string(F) ->
    <<<<(erlang:atom_to_binary(erlang:element(1, F)))/binary,
            (erlang:atom_to_binary(erlang:element(2, F)))/binary>>/binary,
        (erlang:integer_to_binary(erlang:element(3, F)))/binary>>.

-file("src/spectator/internal/api.gleam", 269).
?DOC(false).
-spec compare_tag(process_item(), process_item()) -> gleam@order:order().
compare_tag(A, B) ->
    case {erlang:element(8, erlang:element(3, A)),
        erlang:element(8, erlang:element(3, B))} of
        {{some, A_tag}, {some, B_tag}} ->
            gleam@string:compare(A_tag, B_tag);

        {none, {some, _}} ->
            lt;

        {{some, _}, none} ->
            gt;

        {none, none} ->
            gleam@string:compare(
                function_to_string(erlang:element(3, erlang:element(3, A))),
                function_to_string(erlang:element(3, erlang:element(3, B)))
            )
    end.

-file("src/spectator/internal/api.gleam", 296).
?DOC(false).
-spec sort_process_list(
    list(process_item()),
    process_sort_criteria(),
    sort_direction()
) -> list(process_item()).
sort_process_list(Input, Criteria, Direction) ->
    case Criteria of
        sort_by_process_memory ->
            gleam@list:sort(
                Input,
                fun(A, B) ->
                    _pipe = gleam@int:compare(
                        erlang:element(5, erlang:element(3, A)),
                        erlang:element(5, erlang:element(3, B))
                    ),
                    apply_direction(_pipe, Direction)
                end
            );

        sort_by_reductions ->
            gleam@list:sort(
                Input,
                fun(A@1, B@1) ->
                    _pipe@1 = gleam@int:compare(
                        erlang:element(7, erlang:element(3, A@1)),
                        erlang:element(7, erlang:element(3, B@1))
                    ),
                    apply_direction(_pipe@1, Direction)
                end
            );

        sort_by_message_queue ->
            gleam@list:sort(
                Input,
                fun(A@2, B@2) ->
                    _pipe@2 = gleam@int:compare(
                        erlang:element(6, erlang:element(3, A@2)),
                        erlang:element(6, erlang:element(3, B@2))
                    ),
                    apply_direction(_pipe@2, Direction)
                end
            );

        sort_by_current_function ->
            gleam@list:sort(
                Input,
                fun(A@3, B@3) ->
                    _pipe@3 = gleam@string:compare(
                        function_to_string(
                            erlang:element(2, erlang:element(3, A@3))
                        ),
                        function_to_string(
                            erlang:element(2, erlang:element(3, B@3))
                        )
                    ),
                    apply_direction(_pipe@3, Direction)
                end
            );

        sort_by_process_name ->
            gleam@list:sort(
                Input,
                fun(A@4, B@4) -> _pipe@4 = compare_name(A@4, B@4),
                    apply_direction(_pipe@4, Direction) end
            );

        sort_by_tag ->
            gleam@list:sort(
                Input,
                fun(A@5, B@5) -> _pipe@5 = compare_tag(A@5, B@5),
                    apply_direction(_pipe@5, Direction) end
            );

        sort_by_process_status ->
            gleam@list:sort(
                Input,
                fun(A@6, B@6) ->
                    _pipe@6 = gleam@string:compare(
                        erlang:atom_to_binary(
                            erlang:element(9, erlang:element(3, A@6))
                        ),
                        erlang:atom_to_binary(
                            erlang:element(9, erlang:element(3, B@6))
                        )
                    ),
                    apply_direction(_pipe@6, Direction)
                end
            )
    end.

-file("src/spectator/internal/api.gleam", 692).
?DOC(false).
-spec format_pid(gleam@erlang@process:pid_()) -> binary().
format_pid(Pid) ->
    spectator_ffi:format_pid(Pid).

-file("src/spectator/internal/api.gleam", 695).
?DOC(false).
-spec format_port(gleam@erlang@port:port_()) -> binary().
format_port(Port) ->
    spectator_ffi:format_port(Port).

-file("src/spectator/internal/api.gleam", 700).
?DOC(false).
-spec kill_process(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_()
) -> {ok, boolean()} | {error, erlang_error()}.
kill_process(Node, Pid) ->
    spectator_ffi:kill_process(Node, Pid).

-file("src/spectator/internal/api.gleam", 706).
?DOC(false).
-spec suspend(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_()
) -> {ok, gleam@dynamic:dynamic_()} | {error, erlang_error()}.
suspend(Node, Pid) ->
    spectator_ffi:sys_suspend(Node, Pid).

-file("src/spectator/internal/api.gleam", 712).
?DOC(false).
-spec resume(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@process:pid_()
) -> {ok, gleam@dynamic:dynamic_()} | {error, erlang_error()}.
resume(Node, Pid) ->
    spectator_ffi:sys_resume(Node, Pid).

-file("src/spectator/internal/api.gleam", 718).
?DOC(false).
-spec new_ets_table(
    gleam@option:option(gleam@erlang@atom:atom_()),
    gleam@erlang@atom:atom_()
) -> {ok, gleam@erlang@atom:atom_()} | {error, erlang_error()}.
new_ets_table(Node, Name) ->
    spectator_ffi:new_ets_table(Node, Name).

-file("src/spectator/internal/api.gleam", 726).
?DOC(false).
-spec serialize_pid(gleam@erlang@process:pid_()) -> binary().
serialize_pid(Pid) ->
    _pipe = spectator_ffi:pid_to_string(Pid),
    gleam_stdlib:percent_encode(_pipe).

-file("src/spectator/internal/api.gleam", 734).
?DOC(false).
-spec serialize_port(gleam@erlang@port:port_()) -> binary().
serialize_port(Port) ->
    _pipe = spectator_ffi:port_to_string(Port),
    gleam_stdlib:percent_encode(_pipe).

-file("src/spectator/internal/api.gleam", 742).
?DOC(false).
-spec decode_pid(binary()) -> {ok, gleam@erlang@process:pid_()} | {error, nil}.
decode_pid(String) ->
    gleam@result:'try'(
        gleam_stdlib:percent_decode(String),
        fun(Decoded) -> spectator_ffi:pid_from_string(Decoded) end
    ).

-file("src/spectator/internal/api.gleam", 750).
?DOC(false).
-spec decode_port(binary()) -> {ok, gleam@erlang@port:port_()} | {error, nil}.
decode_port(String) ->
    gleam@result:'try'(
        gleam_stdlib:percent_decode(String),
        fun(Decoded) -> spectator_ffi:port_from_string(Decoded) end
    ).

-file("src/spectator/internal/api.gleam", 758).
?DOC(false).
-spec compare_dynamic_data(gleam@dynamic:dynamic_(), gleam@dynamic:dynamic_()) -> gleam@order:order().
compare_dynamic_data(A, B) ->
    spectator_ffi:compare_data(A, B).

-file("src/spectator/internal/api.gleam", 363).
?DOC(false).
-spec sort_table_data(table_data(), integer(), sort_direction()) -> table_data().
sort_table_data(Input, Sort_column, Sort_direction) ->
    Sorted = gleam@list:sort(
        erlang:element(2, Input),
        fun(A, B) ->
            A_cell = disgustingly_index_into_list_at(A, Sort_column),
            B_cell = disgustingly_index_into_list_at(B, Sort_column),
            case {A_cell, B_cell} of
                {{ok, A@1}, {ok, B@1}} ->
                    _pipe = spectator_ffi:compare_data(A@1, B@1),
                    apply_direction(_pipe, Sort_direction);

                {{ok, _}, {error, _}} ->
                    _pipe@1 = gt,
                    apply_direction(_pipe@1, Sort_direction);

                {{error, _}, {ok, _}} ->
                    lt;

                {{error, _}, {error, _}} ->
                    _pipe@2 = eq,
                    apply_direction(_pipe@2, Sort_direction)
            end
        end
    ),
    {table_data, Sorted, erlang:element(3, Input)}.

-file("src/spectator/internal/api.gleam", 764).
?DOC(false).
-spec get_word_size(gleam@option:option(gleam@erlang@atom:atom_())) -> {ok,
        integer()} |
    {error, erlang_error()}.
get_word_size(Node) ->
    spectator_ffi:get_word_size(Node).

-file("src/spectator/internal/api.gleam", 767).
?DOC(false).
-spec get_system_info(gleam@option:option(gleam@erlang@atom:atom_())) -> {ok,
        system_info()} |
    {error, erlang_error()}.
get_system_info(Node) ->
    spectator_ffi:get_system_info(Node).

-file("src/spectator/internal/api.gleam", 772).
?DOC(false).
-spec start_tag_manager() -> {ok, gleam@erlang@process:pid_()} |
    {error, gleam@dynamic:dynamic_()}.
start_tag_manager() ->
    spectator_tag_manager:start_link().

-file("src/spectator/internal/api.gleam", 775).
?DOC(false).
-spec add_tag(gleam@erlang@process:pid_(), binary()) -> nil.
add_tag(Pid, Tag) ->
    spectator_tag_manager:add_tag(Pid, Tag).

-file("src/spectator/internal/api.gleam", 778).
?DOC(false).
-spec get_tag(gleam@erlang@process:pid_()) -> gleam@option:option(binary()).
get_tag(Pid) ->
    spectator_tag_manager:get_tag(Pid).

-file("src/spectator/internal/api.gleam", 783).
?DOC(false).
-spec hidden_connect_node(gleam@erlang@atom:atom_()) -> {ok, boolean()} |
    {error, erlang_error()}.
hidden_connect_node(Node) ->
    spectator_ffi:hidden_connect_node(Node).

-file("src/spectator/internal/api.gleam", 786).
?DOC(false).
-spec connect_node(gleam@erlang@atom:atom_()) -> boolean().
connect_node(Node) ->
    net_kernel:connect_node(Node).

-file("src/spectator/internal/api.gleam", 788).
?DOC(false).
-spec node_from_params(list({binary(), binary()})) -> gleam@option:option(gleam@erlang@atom:atom_()).
node_from_params(Params) ->
    case spectator@internal@common:get_param(Params, <<"node"/utf8>>) of
        {ok, Node_raw} ->
            {some, erlang:binary_to_atom(Node_raw)};

        {error, _} ->
            none
    end.