-module(gladvent@internal@cmd@run).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/gladvent/internal/cmd/run.gleam").
-export([timeout_flag/0, allow_crash_flag/0, timed_flag/0, run_command/0, run_all_command/0]).
-export_type([run_err/0, solve_err/0, solution/0, direction/0, crash/0, gleam_err/0, expectation/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 run_err() :: {failed_to_read_input, binary()} |
    {failed_to_parse_input, binary()} |
    {failed_to_get_runner, snag:snag()} |
    {unregistered, integer()} |
    {other, binary()}.

-type solve_err() :: undef | {run_failed, binary()}.

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

-type direction() :: both.

-type crash() :: {exited, gleam@dynamic:dynamic_()} |
    {thrown, gleam@dynamic:dynamic_()} |
    {errored, gleam@dynamic:dynamic_()}.

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

-type expectation() :: {expect_int, integer()} | {expect_string, binary()}.

-file("src/gladvent/internal/cmd/run.gleam", 51).
?DOC(false).
-spec run_err_to_snag(run_err()) -> snag:snag().
run_err_to_snag(Err) ->
    case Err of
        {unregistered, Day} ->
            snag:new(
                <<<<<<<<"day"/utf8, " "/utf8>>/binary,
                            (erlang:integer_to_binary(Day))/binary>>/binary,
                        " "/utf8>>/binary,
                    "unregistered"/utf8>>
            );

        {failed_to_read_input, Input_path} ->
            snag:new(<<"failed to read input file: "/utf8, Input_path/binary>>);

        {failed_to_parse_input, Err@1} ->
            snag:new(<<"failed to parse input: "/utf8, Err@1/binary>>);

        {failed_to_get_runner, S} ->
            snag:layer(S, <<"failed to get runner"/utf8>>);

        {other, S@1} ->
            snag:new(S@1)
    end.

-file("src/gladvent/internal/cmd/run.gleam", 69).
?DOC(false).
-spec string_trim(binary(), direction(), binary()) -> binary().
string_trim(S, Dir, Sub) ->
    string:trim(S, Dir, unicode:characters_to_list(Sub)).

-file("src/gladvent/internal/cmd/run.gleam", 137).
?DOC(false).
-spec solve(fun((OCW) -> gleam@dynamic:dynamic_()), OCW) -> solution().
solve(Solver, Input) ->
    {Execution_time, Value} = timer:tc(fun() -> Solver(Input) end),
    {solution, Value, Execution_time}.

-file("src/gladvent/internal/cmd/run.gleam", 142).
?DOC(false).
-spec crash_to_dyn(crash()) -> gleam@dynamic:dynamic_().
crash_to_dyn(Err) ->
    case Err of
        {errored, Dyn} ->
            Dyn;

        {exited, Dyn} ->
            Dyn;

        {thrown, Dyn} ->
            Dyn
    end.

-file("src/gladvent/internal/cmd/run.gleam", 158).
?DOC(false).
-spec decode_gleam_err(gleam@dynamic:dynamic_()) -> {ok, gleam_err()} |
    {error, list(gleam@dynamic@decode:decode_error())}.
decode_gleam_err(Dyn) ->
    gleam@dynamic@decode:run(
        Dyn,
        begin
            gleam@dynamic@decode:field(
                erlang:binary_to_atom(<<"gleam_error"/utf8>>),
                gleam@erlang@atom:decoder(),
                fun(Gleam_error) ->
                    gleam@dynamic@decode:field(
                        erlang:binary_to_atom(<<"module"/utf8>>),
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        fun(Module) ->
                            gleam@dynamic@decode:field(
                                erlang:binary_to_atom(<<"function"/utf8>>),
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1},
                                fun(Function) ->
                                    gleam@dynamic@decode:field(
                                        erlang:binary_to_atom(<<"line"/utf8>>),
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_int/1},
                                        fun(Line) ->
                                            gleam@dynamic@decode:field(
                                                erlang:binary_to_atom(
                                                    <<"message"/utf8>>
                                                ),
                                                {decoder,
                                                    fun gleam@dynamic@decode:decode_string/1},
                                                fun(Message) ->
                                                    gleam@dynamic@decode:success(
                                                        {gleam_err,
                                                            Gleam_error,
                                                            Module,
                                                            Function,
                                                            Line,
                                                            Message}
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/gladvent/internal/cmd/run.gleam", 170).
?DOC(false).
-spec gleam_err_to_string(gleam_err()) -> binary().
gleam_err_to_string(G) ->
    gleam@string:join(
        [<<"error:"/utf8>>,
            erlang:atom_to_binary(erlang:element(2, G)),
            <<"-"/utf8>>,
            erlang:element(6, G),
            <<"in module"/utf8>>,
            erlang:element(3, G),
            <<"in function"/utf8>>,
            erlang:element(4, G),
            <<"at line"/utf8>>,
            erlang:integer_to_binary(erlang:element(5, G))],
        <<" "/utf8>>
    ).

-file("src/gladvent/internal/cmd/run.gleam", 188).
?DOC(false).
-spec crash_to_string(crash()) -> binary().
crash_to_string(Err) ->
    _pipe = crash_to_dyn(Err),
    _pipe@1 = decode_gleam_err(_pipe),
    _pipe@2 = gleam@result:map(_pipe@1, fun gleam_err_to_string/1),
    gleam@result:lazy_unwrap(
        _pipe@2,
        fun() ->
            <<"run failed for some reason: "/utf8,
                (gleam@string:inspect(Err))/binary>>
        end
    ).

-file("src/gladvent/internal/cmd/run.gleam", 197).
?DOC(false).
-spec crash_to_solve_err(crash()) -> solve_err().
crash_to_solve_err(Err) ->
    _pipe = Err,
    _pipe@1 = crash_to_string(_pipe),
    {run_failed, _pipe@1}.

-file("src/gladvent/internal/cmd/run.gleam", 90).
?DOC(false).
-spec do(
    integer(),
    integer(),
    gleam@package_interface:package(),
    boolean(),
    gladvent@internal@input:kind()
) -> {ok,
        {{ok, solution()} | {error, solve_err()},
            {ok, solution()} | {error, solve_err()}}} |
    {error, run_err()}.
do(Year, Day, Package, Allow_crash, Input_kind) ->
    gleam@result:'try'(
        begin
            _pipe = gladvent@internal@runners:get_day(Package, Year, Day),
            gleam@result:map_error(
                _pipe,
                fun(Field@0) -> {failed_to_get_runner, Field@0} end
            )
        end,
        fun(_use0) ->
            {Pt_1, Pt_2, Parse} = _use0,
            Input_path = gladvent@internal@input:get_file_path(
                Year,
                Day,
                Input_kind
            ),
            gleam@result:'try'(
                begin
                    _pipe@1 = Input_path,
                    _pipe@2 = simplifile:read(_pipe@1),
                    _pipe@3 = gleam@result:map(
                        _pipe@2,
                        fun(_capture) ->
                            string_trim(_capture, both, <<"\n"/utf8>>)
                        end
                    ),
                    gleam@result:replace_error(
                        _pipe@3,
                        {failed_to_read_input, Input_path}
                    )
                end,
                fun(Input) ->
                    Parse@1 = gleam@option:unwrap(
                        Parse,
                        fun runners_ffi:identity/1
                    ),
                    case Allow_crash of
                        true ->
                            Input@1 = Parse@1(Input),
                            {ok,
                                {{ok, solve(Pt_1, Input@1)},
                                    {ok, solve(Pt_2, Input@1)}}};

                        false ->
                            gleam@result:'try'(
                                begin
                                    _pipe@4 = fun() -> Parse@1(Input) end,
                                    _pipe@5 = runners_ffi:rescue(_pipe@4),
                                    _pipe@6 = gleam@result:map_error(
                                        _pipe@5,
                                        fun crash_to_string/1
                                    ),
                                    gleam@result:map_error(
                                        _pipe@6,
                                        fun(Field@0) -> {failed_to_parse_input, Field@0} end
                                    )
                                end,
                                fun(Input@2) ->
                                    Pt_1@1 = begin
                                        _pipe@7 = fun() ->
                                            solve(Pt_1, Input@2)
                                        end,
                                        _pipe@8 = runners_ffi:rescue(_pipe@7),
                                        gleam@result:map_error(
                                            _pipe@8,
                                            fun crash_to_solve_err/1
                                        )
                                    end,
                                    Pt_2@1 = begin
                                        _pipe@9 = fun() ->
                                            solve(Pt_2, Input@2)
                                        end,
                                        _pipe@10 = runners_ffi:rescue(_pipe@9),
                                        gleam@result:map_error(
                                            _pipe@10,
                                            fun crash_to_solve_err/1
                                        )
                                    end,
                                    {ok, {Pt_1@1, Pt_2@1}}
                                end
                            )
                    end
                end
            )
        end
    ).

-file("src/gladvent/internal/cmd/run.gleam", 203).
?DOC(false).
-spec solve_err_to_string(solve_err()) -> binary().
solve_err_to_string(Solve_err) ->
    case Solve_err of
        undef ->
            <<"function undefined"/utf8>>;

        {run_failed, S} ->
            S
    end.

-file("src/gladvent/internal/cmd/run.gleam", 270).
?DOC(false).
-spec format_execution_time(integer()) -> binary().
format_execution_time(Execution_time) ->
    {Divisor, Precision, Unit} = case Execution_time of
        T when T > 1000000 ->
            {1000000.0, 3, <<" s"/utf8>>};

        T@1 when T@1 > 1000 ->
            {1000.0, 3, <<" ms"/utf8>>};

        _ ->
            {1.0, 0, <<" µs"/utf8>>}
    end,
    <<(gladvent@internal@util:format_float(case Divisor of
                +0.0 -> +0.0;
                -0.0 -> -0.0;
                Gleam@denominator -> erlang:float(Execution_time) / Gleam@denominator
            end, Precision))/binary, Unit/binary>>.

-file("src/gladvent/internal/cmd/run.gleam", 263).
?DOC(false).
-spec exec_time_suffix(solution(), boolean()) -> binary().
exec_time_suffix(Solution, Timed) ->
    case Timed of
        true ->
            <<<<" (in "/utf8,
                    (format_execution_time(erlang:element(3, Solution)))/binary>>/binary,
                ")"/utf8>>;

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

-file("src/gladvent/internal/cmd/run.gleam", 210).
?DOC(false).
-spec solve_res_to_string(
    {ok, solution()} | {error, solve_err()},
    gleam@option:option(expectation()),
    boolean()
) -> binary().
solve_res_to_string(Res, Expectation, Timed) ->
    gleam@result:unwrap_both(
        begin
            gleam@result:map(
                begin
                    _pipe = Res,
                    gleam@result:map_error(_pipe, fun solve_err_to_string/1)
                end,
                fun(Solution) ->
                    gleam@option:lazy_unwrap(
                        begin
                            gleam@option:map(
                                Expectation,
                                fun(Expect) -> case Expect of
                                        {expect_int, Expect@1} ->
                                            case gleam@dynamic@decode:run(
                                                erlang:element(2, Solution),
                                                {decoder,
                                                    fun gleam@dynamic@decode:decode_int/1}
                                            ) of
                                                {ok, I} when Expect@1 =:= I ->
                                                    <<<<"✅ met expected value: "/utf8,
                                                            (erlang:integer_to_binary(
                                                                I
                                                            ))/binary>>/binary,
                                                        (exec_time_suffix(
                                                            Solution,
                                                            Timed
                                                        ))/binary>>;

                                                {ok, I@1} ->
                                                    <<<<<<"❌ unmet expectation: expected "/utf8,
                                                                (erlang:integer_to_binary(
                                                                    Expect@1
                                                                ))/binary>>/binary,
                                                            ", got "/utf8>>/binary,
                                                        (erlang:integer_to_binary(
                                                            I@1
                                                        ))/binary>>;

                                                {error, _} ->
                                                    <<<<<<"❌ expected "/utf8,
                                                                (erlang:integer_to_binary(
                                                                    Expect@1
                                                                ))/binary>>/binary,
                                                            ", got non-integer value of "/utf8>>/binary,
                                                        (gleam@string:inspect(
                                                            Res
                                                        ))/binary>>
                                            end;

                                        {expect_string, Expect@2} ->
                                            case gleam@dynamic@decode:run(
                                                erlang:element(2, Solution),
                                                {decoder,
                                                    fun gleam@dynamic@decode:decode_string/1}
                                            ) of
                                                {ok, S} when Expect@2 =:= S ->
                                                    <<<<"✅ met expected value: "/utf8,
                                                            S/binary>>/binary,
                                                        (exec_time_suffix(
                                                            Solution,
                                                            Timed
                                                        ))/binary>>;

                                                {ok, S@1} ->
                                                    <<<<<<"❌ unmet expectation: expected "/utf8,
                                                                Expect@2/binary>>/binary,
                                                            ", got "/utf8>>/binary,
                                                        S@1/binary>>;

                                                {error, _} ->
                                                    <<<<<<"❌ expected "/utf8,
                                                                Expect@2/binary>>/binary,
                                                            ", got non-string value of "/utf8>>/binary,
                                                        (gleam@string:inspect(
                                                            Res
                                                        ))/binary>>
                                            end
                                    end end
                            )
                        end,
                        fun() ->
                            <<(gleam@string:inspect(erlang:element(2, Solution)))/binary,
                                (exec_time_suffix(Solution, Timed))/binary>>
                        end
                    )
                end
            )
        end
    ).

-file("src/gladvent/internal/cmd/run.gleam", 299).
?DOC(false).
-spec collect(
    integer(),
    {integer(),
        {ok,
                {{ok, solution()} | {error, solve_err()},
                    {ok, solution()} | {error, solve_err()}}} |
            {error, run_err()}},
    gleam@option:option(expectation()),
    gleam@option:option(expectation()),
    boolean()
) -> binary().
collect(Year, X, Expect_pt_1, Expect_pt_2, Timed) ->
    Day = erlang:integer_to_binary(erlang:element(1, X)),
    case erlang:element(2, X) of
        {ok, {Res_1, Res_2}} ->
            <<<<<<<<<<<<<<<<<<"Ran "/utf8,
                                                (erlang:integer_to_binary(Year))/binary>>/binary,
                                            " day "/utf8>>/binary,
                                        Day/binary>>/binary,
                                    ":\n"/utf8>>/binary,
                                "  Part 1: "/utf8>>/binary,
                            (solve_res_to_string(Res_1, Expect_pt_1, Timed))/binary>>/binary,
                        "\n"/utf8>>/binary,
                    "  Part 2: "/utf8>>/binary,
                (solve_res_to_string(Res_2, Expect_pt_2, Timed))/binary>>;

        {error, Err} ->
            _pipe = Err,
            _pipe@1 = run_err_to_snag(_pipe),
            _pipe@2 = snag:layer(
                _pipe@1,
                <<<<<<"Failed to run "/utf8,
                            (erlang:integer_to_binary(Year))/binary>>/binary,
                        " day "/utf8>>/binary,
                    Day/binary>>
            ),
            snag:pretty_print(_pipe@2)
    end.

-file("src/gladvent/internal/cmd/run.gleam", 330).
?DOC(false).
-spec timeout_flag() -> glint:flag(integer()).
timeout_flag() ->
    glint:flag_constraint(
        begin
            _pipe = glint:int_flag(<<"timeout"/utf8>>),
            glint:flag_help(_pipe, <<"Run with specified timeout"/utf8>>)
        end,
        fun(I) -> case I > 0 of
                true ->
                    {ok, I};

                false ->
                    snag:error(<<"timeout value must greater than zero"/utf8>>)
            end end
    ).

-file("src/gladvent/internal/cmd/run.gleam", 342).
?DOC(false).
-spec allow_crash_flag() -> glint:flag(boolean()).
allow_crash_flag() ->
    _pipe = glint:bool_flag(<<"allow-crash"/utf8>>),
    _pipe@1 = glint:flag_default(_pipe, false),
    glint:flag_help(
        _pipe@1,
        <<"Don't catch exceptions thrown by runners."/utf8>>
    ).

-file("src/gladvent/internal/cmd/run.gleam", 348).
?DOC(false).
-spec timed_flag() -> glint:flag(boolean()).
timed_flag() ->
    _pipe = glint:bool_flag(<<"timed"/utf8>>),
    _pipe@1 = glint:flag_default(_pipe, false),
    glint:flag_help(
        _pipe@1,
        <<"Display solution execution time.

The time displayed does not include any work done in a 'parse' function."/utf8>>
    ).

-file("src/gladvent/internal/cmd/run.gleam", 470).
?DOC(false).
-spec read_gleam_toml() -> {ok, gleam@dict:dict(binary(), tom:toml())} |
    {error, snag:snag()}.
read_gleam_toml() ->
    _pipe = filepath:join(gladvent@internal@cmd:root(), <<"gleam.toml"/utf8>>),
    _pipe@1 = simplifile:read(_pipe),
    _pipe@4 = gleam@result:map_error(
        _pipe@1,
        fun(E) -> _pipe@2 = gleam@string:inspect(E),
            _pipe@3 = snag:new(_pipe@2),
            snag:layer(_pipe@3, <<"failed to read gleam.toml"/utf8>>) end
    ),
    gleam@result:'try'(_pipe@4, fun(Data) -> _pipe@5 = Data,
            _pipe@6 = tom:parse(_pipe@5),
            gleam@result:map_error(
                _pipe@6,
                fun(E@1) -> _pipe@7 = gleam@string:inspect(E@1),
                    _pipe@8 = snag:new(_pipe@7),
                    snag:layer(_pipe@8, <<"failed to parse gleam.toml"/utf8>>) end
            ) end).

-file("src/gladvent/internal/cmd/run.gleam", 494).
?DOC(false).
-spec toml_decode_expectation(
    gleam@dict:dict(binary(), tom:toml()),
    list(binary())
) -> {ok, expectation()} | {error, tom:get_error()}.
toml_decode_expectation(Toml, Path) ->
    gleam@result:'try'(tom:get(Toml, Path), fun(Data) -> case Data of
                {string, S} ->
                    {ok, {expect_string, S}};

                {int, I} ->
                    {ok, {expect_int, I}};

                _ ->
                    {error,
                        {wrong_type,
                            Path,
                            <<"Int or String"/utf8>>,
                            <<"something else"/utf8>>}}
            end end).

-file("src/gladvent/internal/cmd/run.gleam", 281).
?DOC(false).
-spec collect_async(
    integer(),
    {integer(),
        {ok,
                {ok,
                        {{ok, solution()} | {error, solve_err()},
                            {ok, solution()} | {error, solve_err()}}} |
                    {error, run_err()}} |
            {error, binary()}},
    gleam@option:option(gleam@dict:dict(binary(), tom:toml())),
    boolean()
) -> binary().
collect_async(Year, X, Expectations, Timed) ->
    Expect = fun(Key) ->
        gleam@option:then(
            Expectations,
            fun(Ex) ->
                _pipe = toml_decode_expectation(
                    Ex,
                    [erlang:integer_to_binary(erlang:element(1, X)), Key]
                ),
                gleam@option:from_result(_pipe)
            end
        )
    end,
    _pipe@1 = X,
    _pipe@2 = gleam@pair:map_second(
        _pipe@1,
        fun(_capture) ->
            gleam@result:map_error(
                _capture,
                fun(Field@0) -> {other, Field@0} end
            )
        end
    ),
    _pipe@3 = gleam@pair:map_second(_pipe@2, fun gleam@result:flatten/1),
    collect(
        Year,
        _pipe@3,
        Expect(<<"pt_1"/utf8>>),
        Expect(<<"pt_2"/utf8>>),
        Timed
    ).

-file("src/gladvent/internal/cmd/run.gleam", 358).
?DOC(false).
-spec run_command() -> glint:command({ok, list(binary())} | {error, snag:snag()}).
run_command() ->
    glint:command_help(
        <<"Run the specified days"/utf8>>,
        fun() ->
            glint:unnamed_args(
                {min_args, 1},
                fun() ->
                    glint:flag(
                        begin
                            _pipe = glint:bool_flag(<<"example"/utf8>>),
                            _pipe@1 = glint:flag_default(_pipe, false),
                            glint:flag_help(
                                _pipe@1,
                                <<"Run solutions against example inputs (found at input/<year>/<day>.example.txt)"/utf8>>
                            )
                        end,
                        fun(Example_flag) ->
                            glint:command(
                                fun(_, Args, Flags) ->
                                    gleam@result:'try'(
                                        gladvent@internal@parse:days(Args),
                                        fun(Days) ->
                                            Days@1 = gladvent@internal@util:deduplicate_sort(
                                                Days
                                            ),
                                            Year@1 = case glint:get_flag(
                                                Flags,
                                                gladvent@internal@cmd:year_flag(
                                                    
                                                )
                                            ) of
                                                {ok, Year} -> Year;
                                                _assert_fail ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 371,
                                                                value => _assert_fail,
                                                                start => 9295,
                                                                'end' => 9355,
                                                                pattern_start => 9306,
                                                                pattern_end => 9314}
                                                        )
                                            end,
                                            Allow_crash@1 = case glint:get_flag(
                                                Flags,
                                                allow_crash_flag()
                                            ) of
                                                {ok, Allow_crash} -> Allow_crash;
                                                _assert_fail@1 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 372,
                                                                value => _assert_fail@1,
                                                                start => 9358,
                                                                'end' => 9428,
                                                                pattern_start => 9369,
                                                                pattern_end => 9384}
                                                        )
                                            end,
                                            Timed@1 = case glint:get_flag(
                                                Flags,
                                                timed_flag()
                                            ) of
                                                {ok, Timed} -> Timed;
                                                _assert_fail@2 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 373,
                                                                value => _assert_fail@2,
                                                                start => 9431,
                                                                'end' => 9489,
                                                                pattern_start => 9442,
                                                                pattern_end => 9451}
                                                        )
                                            end,
                                            Input_kind@1 = case case Example_flag(
                                                Flags
                                            ) of
                                                {error, A} ->
                                                    {error, A};

                                                {ok, true} ->
                                                    {ok, example};

                                                _ ->
                                                    {ok, puzzle}
                                            end of
                                                {ok, Input_kind} -> Input_kind;
                                                _assert_fail@3 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                file => <<?FILEPATH/utf8>>,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 374,
                                                                value => _assert_fail@3,
                                                                start => 9492,
                                                                'end' => 9635,
                                                                pattern_start => 9503,
                                                                pattern_end => 9517}
                                                        )
                                            end,
                                            Spinner = begin
                                                _pipe@2 = spinner:new(
                                                    <<<<<<"running days "/utf8,
                                                                (gleam@string:join(
                                                                    Args,
                                                                    <<", "/utf8>>
                                                                ))/binary>>/binary,
                                                            " in "/utf8>>/binary,
                                                        (erlang:integer_to_binary(
                                                            Year@1
                                                        ))/binary>>
                                                ),
                                                spinner:start(_pipe@2)
                                            end,
                                            gladvent@internal@util:defer(
                                                fun() ->
                                                    spinner:stop(Spinner)
                                                end,
                                                fun() ->
                                                    Timing = begin
                                                        _pipe@3 = glint:get_flag(
                                                            Flags,
                                                            timeout_flag()
                                                        ),
                                                        _pipe@4 = gleam@result:map(
                                                            _pipe@3,
                                                            fun(Field@0) -> {ending, Field@0} end
                                                        ),
                                                        gleam@result:unwrap(
                                                            _pipe@4,
                                                            endless
                                                        )
                                                    end,
                                                    gleam@result:'try'(
                                                        read_gleam_toml(),
                                                        fun(Gleam_toml) ->
                                                            Expectations = case Input_kind@1 of
                                                                puzzle ->
                                                                    gleam@option:from_result(
                                                                        tom:get_table(
                                                                            Gleam_toml,
                                                                            [<<"gladvent"/utf8>>,
                                                                                erlang:integer_to_binary(
                                                                                    Year@1
                                                                                )]
                                                                        )
                                                                    );

                                                                example ->
                                                                    none
                                                            end,
                                                            gleam@result:map(
                                                                begin
                                                                    _pipe@5 = gladvent@internal@runners:pkg_interface(
                                                                        
                                                                    ),
                                                                    snag:context(
                                                                        _pipe@5,
                                                                        <<"failed to generate package interface"/utf8>>
                                                                    )
                                                                end,
                                                                fun(Package) ->
                                                                    _pipe@6 = Days@1,
                                                                    gladvent@internal@cmd:exec(
                                                                        _pipe@6,
                                                                        Timing,
                                                                        fun(
                                                                            _capture
                                                                        ) ->
                                                                            do(
                                                                                Year@1,
                                                                                _capture,
                                                                                Package,
                                                                                Allow_crash@1,
                                                                                Input_kind@1
                                                                            )
                                                                        end,
                                                                        fun(
                                                                            _capture@1
                                                                        ) ->
                                                                            collect_async(
                                                                                Year@1,
                                                                                _capture@1,
                                                                                Expectations,
                                                                                Timed@1
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/gladvent/internal/cmd/run.gleam", 419).
?DOC(false).
-spec run_all_command() -> glint:command({ok, list(binary())} |
    {error, snag:snag()}).
run_all_command() ->
    glint:command_help(
        <<"Run all registered days"/utf8>>,
        fun() ->
            glint:unnamed_args(
                {eq_args, 0},
                fun() ->
                    glint:command(
                        fun(_, _, Flags) ->
                            Year@1 = case glint:get_flag(
                                Flags,
                                gladvent@internal@cmd:year_flag()
                            ) of
                                {ok, Year} -> Year;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 424,
                                                value => _assert_fail,
                                                start => 10694,
                                                'end' => 10754,
                                                pattern_start => 10705,
                                                pattern_end => 10713})
                            end,
                            Allow_crash@1 = case glint:get_flag(
                                Flags,
                                allow_crash_flag()
                            ) of
                                {ok, Allow_crash} -> Allow_crash;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 425,
                                                value => _assert_fail@1,
                                                start => 10757,
                                                'end' => 10827,
                                                pattern_start => 10768,
                                                pattern_end => 10783})
                            end,
                            Timed@1 = case glint:get_flag(Flags, timed_flag()) of
                                {ok, Timed} -> Timed;
                                _assert_fail@2 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                file => <<?FILEPATH/utf8>>,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 426,
                                                value => _assert_fail@2,
                                                start => 10830,
                                                'end' => 10888,
                                                pattern_start => 10841,
                                                pattern_end => 10850})
                            end,
                            Spinner = begin
                                _pipe = spinner:new(
                                    <<"running all days in "/utf8,
                                        (erlang:integer_to_binary(Year@1))/binary>>
                                ),
                                spinner:start(_pipe)
                            end,
                            gladvent@internal@util:defer(
                                fun() -> spinner:stop(Spinner) end,
                                fun() ->
                                    Timing = begin
                                        _pipe@1 = glint:get_flag(
                                            Flags,
                                            timeout_flag()
                                        ),
                                        _pipe@2 = gleam@result:map(
                                            _pipe@1,
                                            fun(Field@0) -> {ending, Field@0} end
                                        ),
                                        gleam@result:unwrap(_pipe@2, endless)
                                    end,
                                    gleam@result:'try'(
                                        read_gleam_toml(),
                                        fun(Gleam_toml) ->
                                            Expectations = gleam@option:from_result(
                                                tom:get_table(
                                                    Gleam_toml,
                                                    [<<"gladvent"/utf8>>,
                                                        erlang:integer_to_binary(
                                                            Year@1
                                                        )]
                                                )
                                            ),
                                            gleam@result:map(
                                                begin
                                                    _pipe@3 = gladvent@internal@runners:pkg_interface(
                                                        
                                                    ),
                                                    snag:context(
                                                        _pipe@3,
                                                        <<"failed to generate package interface"/utf8>>
                                                    )
                                                end,
                                                fun(Package) ->
                                                    _pipe@4 = erlang:element(
                                                        5,
                                                        Package
                                                    ),
                                                    _pipe@5 = maps:keys(_pipe@4),
                                                    _pipe@8 = gleam@list:filter_map(
                                                        _pipe@5,
                                                        fun(K) ->
                                                            gleam@result:'try'(
                                                                gleam@string:split_once(
                                                                    K,
                                                                    <<<<"aoc_"/utf8,
                                                                            (erlang:integer_to_binary(
                                                                                Year@1
                                                                            ))/binary>>/binary,
                                                                        "/day_"/utf8>>
                                                                ),
                                                                fun(Day) ->
                                                                    _pipe@6 = erlang:element(
                                                                        2,
                                                                        Day
                                                                    ),
                                                                    _pipe@7 = gladvent@internal@parse:day(
                                                                        _pipe@6
                                                                    ),
                                                                    gleam@result:replace_error(
                                                                        _pipe@7,
                                                                        nil
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    ),
                                                    _pipe@9 = gleam@list:sort(
                                                        _pipe@8,
                                                        fun gleam@int:compare/2
                                                    ),
                                                    gladvent@internal@cmd:exec(
                                                        _pipe@9,
                                                        Timing,
                                                        fun(_capture) ->
                                                            do(
                                                                Year@1,
                                                                _capture,
                                                                Package,
                                                                Allow_crash@1,
                                                                puzzle
                                                            )
                                                        end,
                                                        fun(_capture@1) ->
                                                            collect_async(
                                                                Year@1,
                                                                _capture@1,
                                                                Expectations,
                                                                Timed@1
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).