-module(gladvent@internal@cmd@run).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([timeout_flag/0, allow_crash_flag/0, run_command/0, run_all_command/0]).
-export_type([run_err/0, solve_err/0, direction/0, gleam_err/0, expectation/0]).

-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 direction() :: both.

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

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

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 48).
-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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 66).
-spec string_trim(binary(), direction(), binary()) -> binary().
string_trim(S, Dir, Sub) ->
    string:trim(S, Dir, unicode:characters_to_list(Sub)).

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 120).
-spec crash_to_dyn(gleam@erlang:crash()) -> gleam@dynamic:dynamic_().
crash_to_dyn(Err) ->
    case Err of
        {errored, Dyn} ->
            Dyn;

        {exited, Dyn} ->
            Dyn;

        {thrown, Dyn} ->
            Dyn
    end.

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 137).
-spec decode_gleam_err(gleam@dynamic:dynamic_()) -> {ok, gleam_err()} |
    {error, list(gleam@dynamic:decode_error())}.
decode_gleam_err(Dyn) ->
    _pipe = decode:into(
        (decode:parameter(
            fun(Gleam_error) ->
                decode:parameter(
                    fun(Module) ->
                        decode:parameter(
                            fun(Function) ->
                                decode:parameter(
                                    fun(Line) ->
                                        decode:parameter(
                                            fun(Message) ->
                                                decode:parameter(
                                                    fun(Value) ->
                                                        {gleam_err,
                                                            Gleam_error,
                                                            Module,
                                                            Function,
                                                            Line,
                                                            Message,
                                                            Value}
                                                    end
                                                )
                                            end
                                        )
                                    end
                                )
                            end
                        )
                    end
                )
            end
        ))
    ),
    _pipe@1 = decode:field(
        _pipe,
        erlang:binary_to_atom(<<"gleam_error"/utf8>>),
        (decode:then(
            {decoder, fun(Field@0) -> {ok, Field@0} end},
            fun(Dyn@1) -> case gleam_erlang_ffi:atom_from_dynamic(Dyn@1) of
                    {ok, A} ->
                        decode:into(A);

                    {error, E} ->
                        decode:fail(
                            <<"failed to decode gleam error: "/utf8,
                                (gleam@string:inspect(E))/binary>>
                        )
                end end
        ))
    ),
    _pipe@2 = decode:field(
        _pipe@1,
        erlang:binary_to_atom(<<"module"/utf8>>),
        {decoder, fun gleam@dynamic:string/1}
    ),
    _pipe@3 = decode:field(
        _pipe@2,
        erlang:binary_to_atom(<<"function"/utf8>>),
        {decoder, fun gleam@dynamic:string/1}
    ),
    _pipe@4 = decode:field(
        _pipe@3,
        erlang:binary_to_atom(<<"line"/utf8>>),
        {decoder, fun gleam@dynamic:int/1}
    ),
    _pipe@5 = decode:field(
        _pipe@4,
        erlang:binary_to_atom(<<"message"/utf8>>),
        {decoder, fun gleam@dynamic:string/1}
    ),
    _pipe@6 = decode:field(
        _pipe@5,
        erlang:binary_to_atom(<<"value"/utf8>>),
        decode:optional({decoder, fun(Field@0) -> {ok, Field@0} end})
    ),
    decode:from(_pipe@6, Dyn).

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 166).
-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)),
            begin
                _pipe = erlang:element(7, G),
                _pipe@1 = gleam@option:map(
                    _pipe,
                    fun(Val) ->
                        <<"with value "/utf8,
                            (gleam@string:inspect(Val))/binary>>
                    end
                ),
                gleam@option:unwrap(_pipe@1, <<""/utf8>>)
            end],
        <<" "/utf8>>
    ).

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 187).
-spec crash_to_string(gleam@erlang: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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 196).
-spec crash_to_solve_err(gleam@erlang:crash()) -> solve_err().
crash_to_solve_err(Err) ->
    _pipe = Err,
    _pipe@1 = crash_to_string(_pipe),
    {run_failed, _pipe@1}.

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 73).
-spec do(
    integer(),
    integer(),
    gleam@package_interface:package(),
    boolean(),
    gladvent@internal@input:kind()
) -> {ok,
        {{ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
            {ok, gleam@dynamic:dynamic_()} | {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 gleam_stdlib:identity/1
                    ),
                    case Allow_crash of
                        true ->
                            Input@1 = Parse@1(Input),
                            {ok, {{ok, Pt_1(Input@1)}, {ok, Pt_2(Input@1)}}};

                        false ->
                            gleam@result:'try'(
                                begin
                                    _pipe@4 = fun() -> Parse@1(Input) end,
                                    _pipe@5 = gleam_erlang_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() -> Pt_1(Input@2) end,
                                        _pipe@8 = gleam_erlang_ffi:rescue(
                                            _pipe@7
                                        ),
                                        gleam@result:map_error(
                                            _pipe@8,
                                            fun crash_to_solve_err/1
                                        )
                                    end,
                                    Pt_2@1 = begin
                                        _pipe@9 = fun() -> Pt_2(Input@2) end,
                                        _pipe@10 = gleam_erlang_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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 202).
-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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 209).
-spec solve_res_to_string(
    {ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
    gleam@option:option(expectation())
) -> binary().
solve_res_to_string(Res, Expectation) ->
    gleam@result:unwrap_both(
        (gleam@result:map(
            begin
                _pipe = Res,
                gleam@result:map_error(_pipe, fun solve_err_to_string/1)
            end,
            fun(Res@1) ->
                gleam@option:lazy_unwrap(
                    (gleam@option:map(Expectation, fun(Expect) -> case Expect of
                                {expect_int, Expect@1} ->
                                    case gleam@dynamic:int(Res@1) of
                                        {ok, I} when Expect@1 =:= I ->
                                            <<"✅ met expected value: "/utf8,
                                                (erlang:integer_to_binary(I))/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@1))/binary>>
                                    end;

                                {expect_string, Expect@2} ->
                                    case gleam@dynamic:string(Res@1) of
                                        {ok, S} when Expect@2 =:= S ->
                                            <<"✅ met expected value: "/utf8,
                                                S/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@1))/binary>>
                                    end
                            end end)),
                    fun() -> gleam@string:inspect(Res@1) end
                )
            end
        ))
    ).

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 273).
-spec collect(
    integer(),
    {integer(),
        {ok,
                {{ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
                    {ok, gleam@dynamic:dynamic_()} | {error, solve_err()}}} |
            {error, run_err()}},
    gleam@option:option(expectation()),
    gleam@option:option(expectation())
) -> binary().
collect(Year, X, Expect_pt_1, Expect_pt_2) ->
    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))/binary>>/binary,
                        "\n"/utf8>>/binary,
                    "  Part 2: "/utf8>>/binary,
                (solve_res_to_string(Res_2, Expect_pt_2))/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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 303).
-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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 315).
-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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 431).
-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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 455).
-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("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 256).
-spec collect_async(
    integer(),
    {integer(),
        {ok,
                {ok,
                        {{ok, gleam@dynamic:dynamic_()} | {error, solve_err()},
                            {ok, gleam@dynamic:dynamic_()} |
                                {error, solve_err()}}} |
                    {error, run_err()}} |
            {error, binary()}},
    gleam@option:option(gleam@dict:dict(binary(), tom:toml()))
) -> binary().
collect_async(Year, X, Expectations) ->
    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>>)).

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 321).
-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:then(
                                        gladvent@internal@parse:days(Args),
                                        fun(Days) ->
                                            Days@1 = gladvent@internal@util:deduplicate_sort(
                                                Days
                                            ),
                                            _assert_subject = glint:get_flag(
                                                Flags,
                                                gladvent@internal@cmd:year_flag(
                                                    
                                                )
                                            ),
                                            {ok, Year} = case _assert_subject of
                                                {ok, _} -> _assert_subject;
                                                _assert_fail ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                value => _assert_fail,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 334}
                                                        )
                                            end,
                                            _assert_subject@1 = glint:get_flag(
                                                Flags,
                                                allow_crash_flag()
                                            ),
                                            {ok, Allow_crash} = case _assert_subject@1 of
                                                {ok, _} -> _assert_subject@1;
                                                _assert_fail@1 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                value => _assert_fail@1,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 335}
                                                        )
                                            end,
                                            _assert_subject@2 = case Example_flag(
                                                Flags
                                            ) of
                                                {error, A} ->
                                                    {error, A};

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

                                                _ ->
                                                    {ok, puzzle}
                                            end,
                                            {ok, Input_kind} = case _assert_subject@2 of
                                                {ok, _} -> _assert_subject@2;
                                                _assert_fail@2 ->
                                                    erlang:error(
                                                            #{gleam_error => let_assert,
                                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                                value => _assert_fail@2,
                                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                                function => <<"run_command"/utf8>>,
                                                                line => 336}
                                                        )
                                            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
                                                        ))/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 of
                                                                puzzle ->
                                                                    gleam@option:from_result(
                                                                        tom:get_table(
                                                                            Gleam_toml,
                                                                            [<<"gladvent"/utf8>>,
                                                                                erlang:integer_to_binary(
                                                                                    Year
                                                                                )]
                                                                        )
                                                                    );

                                                                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,
                                                                                _capture,
                                                                                Package,
                                                                                Allow_crash,
                                                                                Input_kind
                                                                            )
                                                                        end,
                                                                        fun(
                                                                            _capture@1
                                                                        ) ->
                                                                            collect_async(
                                                                                Year,
                                                                                _capture@1,
                                                                                Expectations
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("/home/runner/work/gladvent/gladvent/src/gladvent/internal/cmd/run.gleam", 381).
-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) ->
                            _assert_subject = glint:get_flag(
                                Flags,
                                gladvent@internal@cmd:year_flag()
                            ),
                            {ok, Year} = case _assert_subject of
                                {ok, _} -> _assert_subject;
                                _assert_fail ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 386})
                            end,
                            _assert_subject@1 = glint:get_flag(
                                Flags,
                                allow_crash_flag()
                            ),
                            {ok, Allow_crash} = case _assert_subject@1 of
                                {ok, _} -> _assert_subject@1;
                                _assert_fail@1 ->
                                    erlang:error(#{gleam_error => let_assert,
                                                message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                value => _assert_fail@1,
                                                module => <<"gladvent/internal/cmd/run"/utf8>>,
                                                function => <<"run_all_command"/utf8>>,
                                                line => 387})
                            end,
                            Spinner = begin
                                _pipe = spinner:new(
                                    <<"running all days in "/utf8,
                                        (erlang:integer_to_binary(Year))/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
                                                        )]
                                                )
                                            ),
                                            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
                                                                            ))/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,
                                                                _capture,
                                                                Package,
                                                                Allow_crash,
                                                                puzzle
                                                            )
                                                        end,
                                                        fun(_capture@1) ->
                                                            collect_async(
                                                                Year,
                                                                _capture@1,
                                                                Expectations
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).