-module(sprocket@runtime).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([stop/1, get_reconciled/1, process_event/4, process_event_immediate/4, process_client_hook/6, render_update/1, reconcile_immediate/1, start/3]).
-export_type([rendered_update/0, state/0, message/0]).

-type rendered_update() :: {full_update,
        sprocket@internal@reconcile:reconciled_element()} |
    {patch_update, sprocket@internal@patch:patch()}.

-opaque state() :: {state,
        sprocket@context:context(),
        sprocket@context:updater(rendered_update()),
        gleam@option:option(sprocket@internal@reconcile:reconciled_element()),
        gleam@erlang@process:subject(ids@cuid:message()),
        gleam@option:option(fun((binary(), binary(), binary(), gleam@option:option(binary())) -> {ok,
                nil} |
            {error, nil}))}.

-opaque message() :: shutdown |
    {get_reconciled,
        gleam@erlang@process:subject(gleam@option:option(sprocket@internal@reconcile:reconciled_element()))} |
    {process_event,
        sprocket@internal@utils@unique:unique(sprocket@context:element_id()),
        binary(),
        gleam@dynamic:dynamic_()} |
    {process_event_immediate,
        gleam@erlang@process:subject({ok, nil} | {error, nil}),
        sprocket@internal@utils@unique:unique(sprocket@context:element_id()),
        binary(),
        gleam@dynamic:dynamic_()} |
    {process_client_hook,
        sprocket@internal@utils@unique:unique(sprocket@context:element_id()),
        binary(),
        binary(),
        gleam@option:option(gleam@dynamic:dynamic_()),
        fun((binary(), gleam@option:option(binary())) -> nil)} |
    {update_hook_state,
        sprocket@internal@utils@unique:unique(sprocket@context:hook_id()),
        fun((sprocket@context:hook()) -> sprocket@context:hook())} |
    {emit_client_hook_event,
        sprocket@internal@utils@unique:unique(sprocket@context:hook_id()),
        binary(),
        gleam@option:option(binary())} |
    {reconcile_immediate,
        gleam@erlang@process:subject(sprocket@internal@reconcile:reconciled_element())} |
    render_update.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 352).
-spec stop(gleam@erlang@process:subject(message())) -> nil.
stop(Actor) ->
    sprocket@internal@logger:debug(<<"actor.send Shutdown"/utf8>>),
    gleam@otp@actor:send(Actor, shutdown).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 359).
-spec get_reconciled(gleam@erlang@process:subject(message())) -> gleam@option:option(sprocket@internal@reconcile:reconciled_element()).
get_reconciled(Actor) ->
    sprocket@internal@logger:debug(<<"process.try_call GetReconciled"/utf8>>),
    case gleam@erlang@process:try_call(
        Actor,
        fun(_capture) -> {get_reconciled, _capture} end,
        1000
    ) of
        {ok, Rendered} ->
            Rendered;

        {error, Err} ->
            sprocket@internal@logger:error_meta(
                <<"Error getting rendered view from runtime actor"/utf8>>,
                Err
            ),
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    module => <<"sprocket/runtime"/utf8>>,
                    function => <<"get_reconciled"/utf8>>,
                    line => 367})
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 373).
-spec process_event(
    gleam@erlang@process:subject(message()),
    binary(),
    binary(),
    gleam@dynamic:dynamic_()
) -> nil.
process_event(Actor, Element_id, Kind, Payload) ->
    sprocket@internal@logger:debug(<<"process.try_call ProcessEvent"/utf8>>),
    gleam@otp@actor:send(
        Actor,
        {process_event,
            sprocket@internal@utils@unique:from_string(Element_id),
            Kind,
            Payload}
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 379).
-spec process_event_immediate(
    gleam@erlang@process:subject(message()),
    binary(),
    binary(),
    gleam@dynamic:dynamic_()
) -> {ok, nil} | {error, nil}.
process_event_immediate(Actor, Element_id, Kind, Payload) ->
    sprocket@internal@logger:debug(
        <<"process.try_call ProcessEventImmediate"/utf8>>
    ),
    case gleam@erlang@process:try_call(
        Actor,
        fun(_capture) ->
            {process_event_immediate,
                _capture,
                sprocket@internal@utils@unique:from_string(Element_id),
                Kind,
                Payload}
        end,
        1000
    ) of
        {ok, Result} ->
            Result;

        {error, Err} ->
            sprocket@internal@logger:error_meta(
                <<"Error processing event from runtime actor"/utf8>>,
                Err
            ),
            {error, nil}
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 404).
-spec process_client_hook(
    gleam@erlang@process:subject(message()),
    binary(),
    binary(),
    binary(),
    gleam@option:option(gleam@dynamic:dynamic_()),
    fun((binary(), gleam@option:option(binary())) -> nil)
) -> nil.
process_client_hook(Actor, Element_id, Hook_name, Event, Payload, Reply_emitter) ->
    sprocket@internal@logger:debug(<<"actor.send ProcessClientHook"/utf8>>),
    gleam@otp@actor:send(
        Actor,
        {process_client_hook,
            sprocket@internal@utils@unique:from_string(Element_id),
            Hook_name,
            Event,
            Payload,
            Reply_emitter}
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 426).
-spec render_update(gleam@erlang@process:subject(message())) -> nil.
render_update(Actor) ->
    sprocket@internal@logger:debug(<<"actor.send RenderUpdate"/utf8>>),
    gleam@otp@actor:send(Actor, render_update).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 433).
-spec reconcile_immediate(gleam@erlang@process:subject(message())) -> sprocket@internal@reconcile:reconciled_element().
reconcile_immediate(Actor) ->
    sprocket@internal@logger:debug(<<"process.try_call Reconcile"/utf8>>),
    case gleam@erlang@process:try_call(
        Actor,
        fun(_capture) -> {reconcile_immediate, _capture} end,
        1000
    ) of
        {ok, Reconciled} ->
            Reconciled;

        {error, Err} ->
            sprocket@internal@logger:error_meta(
                <<"Error reconciling view from runtime actor"/utf8>>,
                Err
            ),
            erlang:error(#{gleam_error => panic,
                    message => <<"`panic` expression evaluated."/utf8>>,
                    module => <<"sprocket/runtime"/utf8>>,
                    function => <<"reconcile_immediate"/utf8>>,
                    line => 441})
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 520).
-spec build_hooks_map(
    sprocket@internal@reconcile:reconciled_element(),
    gleam@dict:dict(sprocket@internal@utils@unique:unique(sprocket@context:hook_id()), sprocket@context:hook())
) -> gleam@dict:dict(sprocket@internal@utils@unique:unique(sprocket@context:hook_id()), sprocket@context:hook()).
build_hooks_map(Node, Acc) ->
    case Node of
        {reconciled_component, _, _, _, Hooks, El} ->
            Acc@2 = sprocket@internal@utils@ordered_map:fold(
                Hooks,
                Acc,
                fun(Acc@1, Hook) ->
                    {keyed_item, _, Hook@1} = Hook,
                    case Hook@1 of
                        {callback, Id, _, _} ->
                            gleam@dict:insert(Acc@1, Id, Hook@1);

                        {memo, Id@1, _, _} ->
                            gleam@dict:insert(Acc@1, Id@1, Hook@1);

                        {effect, Id@2, _, _, _} ->
                            gleam@dict:insert(Acc@1, Id@2, Hook@1);

                        {state, Id@3, _} ->
                            gleam@dict:insert(Acc@1, Id@3, Hook@1);

                        {reducer, Id@4, _, _} ->
                            gleam@dict:insert(Acc@1, Id@4, Hook@1);

                        {client, Id@5, _, _} ->
                            gleam@dict:insert(Acc@1, Id@5, Hook@1)
                    end
                end
            ),
            build_hooks_map(El, Acc@2);

        {reconciled_element, _, _, _, _, Children} ->
            gleam@list:fold(
                Children,
                Acc,
                fun(Acc@3, Child) ->
                    maps:merge(Acc@3, build_hooks_map(Child, Acc@3))
                end
            );

        {reconciled_fragment, _, Children@1} ->
            gleam@list:fold(
                Children@1,
                Acc,
                fun(Acc@4, Child@1) ->
                    maps:merge(Acc@4, build_hooks_map(Child@1, Acc@4))
                end
            );

        _ ->
            Acc
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 470).
-spec cleanup_hooks(sprocket@internal@reconcile:reconciled_element()) -> nil.
cleanup_hooks(Rendered) ->
    _pipe = build_hooks_map(Rendered, maps:new()),
    _pipe@1 = maps:values(_pipe),
    gleam@list:each(_pipe@1, fun(Hook) -> case Hook of
                {effect, _, _, _, Prev} ->
                    case Prev of
                        {some, {effect_result, {some, Cleanup}, _}} ->
                            Cleanup();

                        _ ->
                            nil
                    end;

                {reducer, _, _, Cleanup@1} ->
                    Cleanup@1();

                _ ->
                    nil
            end end).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 490).
-spec run_cleanup_for_disposed_hooks(
    sprocket@internal@reconcile:reconciled_element(),
    sprocket@internal@reconcile:reconciled_element()
) -> nil.
run_cleanup_for_disposed_hooks(Prev_rendered, Rendered) ->
    Prev_hooks = build_hooks_map(Prev_rendered, maps:new()),
    New_hooks = build_hooks_map(Rendered, maps:new()),
    Removed_hooks = begin
        _pipe = Prev_hooks,
        _pipe@1 = maps:keys(_pipe),
        gleam@list:filter(
            _pipe@1,
            fun(Id) -> not gleam@dict:has_key(New_hooks, Id) end
        )
    end,
    _pipe@2 = Removed_hooks,
    gleam@list:each(
        _pipe@2,
        fun(Id@1) -> case gleam_stdlib:map_get(Prev_hooks, Id@1) of
                {ok, {effect, _, _, _, Prev}} ->
                    case Prev of
                        {some, {effect_result, {some, Cleanup}, _}} ->
                            Cleanup();

                        _ ->
                            nil
                    end;

                {ok, {reducer, _, _, Cleanup@1}} ->
                    Cleanup@1();

                _ ->
                    nil
            end end
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 617).
-spec maybe_cleanup_and_rerun_effect(
    gleam@option:option(fun(() -> nil)),
    fun(() -> gleam@option:option(fun(() -> nil))),
    gleam@option:option(list(gleam@dynamic:dynamic_()))
) -> sprocket@context:effect_result().
maybe_cleanup_and_rerun_effect(Cleanup, Effect_fn, Deps) ->
    case Cleanup of
        {some, Cleanup_fn} ->
            Cleanup_fn(),
            {effect_result, Effect_fn(), Deps};

        _ ->
            {effect_result, Effect_fn(), Deps}
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 593).
-spec run_effect(
    fun(() -> gleam@option:option(fun(() -> nil))),
    list(gleam@dynamic:dynamic_()),
    gleam@option:option(sprocket@context:effect_result())
) -> sprocket@context:effect_result().
run_effect(Effect_fn, Deps, Prev) ->
    case Prev of
        {some, {effect_result, Cleanup, {some, Prev_deps}}} ->
            case sprocket@context:compare_deps(Prev_deps, Deps) of
                {changed, _} ->
                    maybe_cleanup_and_rerun_effect(
                        Cleanup,
                        Effect_fn,
                        {some, Deps}
                    );

                unchanged ->
                    {effect_result, Cleanup, {some, Deps}}
            end;

        none ->
            maybe_cleanup_and_rerun_effect(none, Effect_fn, {some, Deps});

        _ ->
            sprocket@internal@exceptions:throw_on_unexpected_hook_result(
                {<<"handle_effect"/utf8>>, Prev}
            )
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 655).
-spec find_reconciled_hook(
    sprocket@internal@reconcile:reconciled_element(),
    fun((sprocket@context:hook()) -> boolean())
) -> gleam@option:option(sprocket@context:hook()).
find_reconciled_hook(Node, Find_by) ->
    case Node of
        {reconciled_component, _, _, _, Hooks, El} ->
            case sprocket@internal@utils@ordered_map:find(
                Hooks,
                fun(Keyed_item) -> Find_by(erlang:element(3, Keyed_item)) end
            ) of
                {ok, {keyed_item, _, Hook}} ->
                    {some, Hook};

                _ ->
                    find_reconciled_hook(El, Find_by)
            end;

        {reconciled_element, _, _, _, _, Children} ->
            gleam@list:fold(Children, none, fun(Acc, Child) -> case Acc of
                        {some, _} ->
                            Acc;

                        _ ->
                            find_reconciled_hook(Child, Find_by)
                    end end);

        {reconciled_fragment, _, Children@1} ->
            gleam@list:fold(
                Children@1,
                none,
                fun(Acc@1, Child@1) -> case Acc@1 of
                        {some, _} ->
                            Acc@1;

                        _ ->
                            find_reconciled_hook(Child@1, Find_by)
                    end end
            );

        _ ->
            none
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 735).
-spec process_next_hook(
    sprocket@internal@utils@ordered_map:ordered_map_iter(integer(), sprocket@context:hook()),
    {list(sprocket@internal@utils@ordered_map:keyed_item(integer(), sprocket@context:hook())),
        gleam@dict:dict(integer(), sprocket@context:hook()),
        integer()},
    fun((sprocket@context:hook()) -> sprocket@context:hook())
) -> {list(sprocket@internal@utils@ordered_map:keyed_item(integer(), sprocket@context:hook())),
    gleam@dict:dict(integer(), sprocket@context:hook()),
    integer()}.
process_next_hook(Iter, Acc, Process_hook) ->
    case sprocket@internal@utils@ordered_map:next(Iter) of
        {ok, {Iter@1, {keyed_item, Index, Hook}}} ->
            {Ordered, By_index, Size} = Acc,
            Updated = Process_hook(Hook),
            process_next_hook(
                Iter@1,
                {[{keyed_item, Index, Updated} | Ordered],
                    gleam@dict:insert(By_index, Index, Updated),
                    Size + 1},
                Process_hook
            );

        {error, _} ->
            Acc
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 723).
-spec process_hooks(
    sprocket@internal@utils@ordered_map:ordered_map(integer(), sprocket@context:hook()),
    fun((sprocket@context:hook()) -> sprocket@context:hook())
) -> sprocket@internal@utils@ordered_map:ordered_map(integer(), sprocket@context:hook()).
process_hooks(Hooks, Process_hook) ->
    {R_ordered, By_index, Size} = begin
        _pipe = Hooks,
        _pipe@1 = sprocket@internal@utils@ordered_map:iter(_pipe),
        process_next_hook(_pipe@1, {[], maps:new(), 0}, Process_hook)
    end,
    sprocket@internal@utils@ordered_map:from(
        lists:reverse(R_ordered),
        By_index,
        Size
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 690).
-spec traverse_rendered_hooks(
    sprocket@internal@reconcile:reconciled_element(),
    fun((sprocket@context:hook()) -> sprocket@context:hook())
) -> sprocket@internal@reconcile:reconciled_element().
traverse_rendered_hooks(Node, Process_hook) ->
    case Node of
        {reconciled_component, Fc, Key, Props, Hooks, El} ->
            Processed_hooks = process_hooks(Hooks, Process_hook),
            {reconciled_component,
                Fc,
                Key,
                Props,
                Processed_hooks,
                traverse_rendered_hooks(El, Process_hook)};

        {reconciled_element, Id, Tag, Key@1, Hooks@1, Children} ->
            R_children = gleam@list:fold(
                Children,
                [],
                fun(Acc, Child) ->
                    [traverse_rendered_hooks(Child, Process_hook) | Acc]
                end
            ),
            {reconciled_element,
                Id,
                Tag,
                Key@1,
                Hooks@1,
                lists:reverse(R_children)};

        {reconciled_fragment, Key@2, Children@1} ->
            R_children@1 = gleam@list:fold(
                Children@1,
                [],
                fun(Acc@1, Child@1) ->
                    [traverse_rendered_hooks(Child@1, Process_hook) | Acc@1]
                end
            ),
            {reconciled_fragment, Key@2, lists:reverse(R_children@1)};

        _ ->
            Node
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 631).
-spec find_and_update_hook(
    sprocket@internal@reconcile:reconciled_element(),
    sprocket@internal@utils@unique:unique(sprocket@context:hook_id()),
    fun((sprocket@context:hook()) -> sprocket@context:hook())
) -> sprocket@internal@reconcile:reconciled_element().
find_and_update_hook(Reconciled, Hook_id, Update_fn) ->
    traverse_rendered_hooks(
        Reconciled,
        fun(Hook) -> case sprocket@context:has_id(Hook, Hook_id) of
                true ->
                    Update_fn(Hook);

                false ->
                    Hook
            end end
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 648).
-spec process_state_hooks(
    sprocket@internal@reconcile:reconciled_element(),
    fun((sprocket@context:hook()) -> sprocket@context:hook())
) -> sprocket@internal@reconcile:reconciled_element().
process_state_hooks(Rendered, Process_hook) ->
    traverse_rendered_hooks(Rendered, Process_hook).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 571).
-spec run_effects(sprocket@internal@reconcile:reconciled_element()) -> sprocket@internal@reconcile:reconciled_element().
run_effects(Rendered) ->
    process_state_hooks(Rendered, fun(Hook) -> case Hook of
                {effect, Id, Effect_fn, Deps, Prev} ->
                    Result = run_effect(Effect_fn, Deps, Prev),
                    {effect, Id, Effect_fn, Deps, {some, Result}};

                {reducer, Id@1, Reducer_actor, Cleanup} ->
                    _pipe = Reducer_actor,
                    _pipe@1 = sprocket@internal@utils@unsafe_coerce:unsafe_coerce(
                        _pipe
                    ),
                    sprocket@internal@reducer:process_commands(_pipe@1),
                    {reducer, Id@1, Reducer_actor, Cleanup};

                Other ->
                    Other
            end end).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 446).
-spec do_reconciliation(
    sprocket@context:context(),
    sprocket@context:element(),
    gleam@option:option(sprocket@internal@reconcile:reconciled_element())
) -> {sprocket@context:context(),
    sprocket@internal@reconcile:reconciled_element()}.
do_reconciliation(Ctx, View, Prev) ->
    sprocket@internal@utils@timer:timed_operation(
        <<"runtime.reconcile"/utf8>>,
        fun() ->
            {reconciled_result, Ctx@1, Reconciled} = begin
                _pipe = Ctx,
                _pipe@1 = sprocket@context:prepare_for_reconciliation(_pipe),
                sprocket@internal@reconcilers@recursive:reconcile(
                    _pipe@1,
                    View,
                    none,
                    Prev
                )
            end,
            gleam@option:map(
                Prev,
                fun(Prev@1) ->
                    run_cleanup_for_disposed_hooks(Prev@1, Reconciled)
                end
            ),
            Reconciled@1 = run_effects(Reconciled),
            {Ctx@1, Reconciled@1}
        end
    ).

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 81).
-spec handle_message(message(), state()) -> gleam@otp@actor:next(message(), state()).
handle_message(Message, State) ->
    case Message of
        shutdown ->
            case erlang:element(4, State) of
                {some, Reconciled} ->
                    cleanup_hooks(Reconciled),
                    nil;

                _ ->
                    nil
            end,
            {stop, normal};

        {get_reconciled, Reply_with} ->
            gleam@otp@actor:send(Reply_with, erlang:element(4, State)),
            gleam@otp@actor:continue(State);

        {process_event, Element_id, Kind, Payload} ->
            _ = begin
                _pipe = gleam@list:find(
                    erlang:element(4, erlang:element(2, State)),
                    fun(H) ->
                        {event_handler, Handler_id, Handler_kind, _} = H,
                        (Handler_id =:= Element_id) andalso (Handler_kind =:= Kind)
                    end
                ),
                _pipe@1 = gleam@result:map(
                    _pipe,
                    fun(H@1) ->
                        {event_handler, _, _, Handler_fn} = H@1,
                        Handler_fn(Payload)
                    end
                ),
                gleam@result:map_error(
                    _pipe@1,
                    fun(_) ->
                        sprocket@internal@logger:error(
                            <<<<<<"No handler found for element "/utf8,
                                        (sprocket@internal@utils@unique:to_string(
                                            Element_id
                                        ))/binary>>/binary,
                                    " and kind "/utf8>>/binary,
                                Kind/binary>>
                        )
                    end
                )
            end,
            gleam@otp@actor:continue(State);

        {process_event_immediate, Reply_with@1, Element_id@1, Kind@1, Payload@1} ->
            Handler = gleam@list:find(
                erlang:element(4, erlang:element(2, State)),
                fun(H@2) ->
                    {event_handler, Handler_id@1, Handler_kind@1, _} = H@2,
                    (Handler_id@1 =:= Element_id@1) andalso (Handler_kind@1 =:= Kind@1)
                end
            ),
            case Handler of
                {ok, {event_handler, _, _, Handler_fn@1}} ->
                    Handler_fn@1(Payload@1),
                    gleam@otp@actor:send(Reply_with@1, {ok, nil}),
                    gleam@otp@actor:continue(State);

                _ ->
                    sprocket@internal@logger:error(
                        <<<<<<"No handler found for element "/utf8,
                                    (sprocket@internal@utils@unique:to_string(
                                        Element_id@1
                                    ))/binary>>/binary,
                                " and kind "/utf8>>/binary,
                            Kind@1/binary>>
                    ),
                    gleam@otp@actor:send(Reply_with@1, {error, nil}),
                    gleam@otp@actor:continue(State)
            end;

        {process_client_hook,
            Element_id@2,
            Hook_name,
            Kind@2,
            Payload@2,
            Reply_emitter} ->
            case erlang:element(4, State) of
                {some, Reconciled@1} ->
                    _ = begin
                        _pipe@2 = gleam@list:find(
                            erlang:element(5, erlang:element(2, State)),
                            fun(H@3) ->
                                (erlang:element(2, H@3) =:= Element_id@2)
                                andalso (erlang:element(3, H@3) =:= Hook_name)
                            end
                        ),
                        gleam@result:map(
                            _pipe@2,
                            fun(H@4) ->
                                _pipe@3 = find_reconciled_hook(
                                    Reconciled@1,
                                    fun(Hook) -> case Hook of
                                            {client, Hook_id, _, _} ->
                                                Hook_id =:= erlang:element(
                                                    4,
                                                    H@4
                                                );

                                            _ ->
                                                false
                                        end end
                                ),
                                gleam@option:map(
                                    _pipe@3,
                                    fun(Hook@1) ->
                                        {client, _, _, Handle_event} = case Hook@1 of
                                            {client, _, _, _} -> Hook@1;
                                            _assert_fail ->
                                                erlang:error(
                                                        #{gleam_error => let_assert,
                                                            message => <<"Pattern match failed, no pattern matched the value."/utf8>>,
                                                            value => _assert_fail,
                                                            module => <<"sprocket/runtime"/utf8>>,
                                                            function => <<"handle_message"/utf8>>,
                                                            line => 169}
                                                    )
                                        end,
                                        gleam@option:map(
                                            Handle_event,
                                            fun(Handle_event@1) ->
                                                Handle_event@1(
                                                    Kind@2,
                                                    Payload@2,
                                                    Reply_emitter
                                                )
                                            end
                                        )
                                    end
                                )
                            end
                        )
                    end,
                    nil;

                none ->
                    sprocket@internal@logger:error(
                        <<"Runtime must be reconciled before processing client hooks"/utf8>>
                    ),
                    nil
            end,
            gleam@otp@actor:continue(State);

        {update_hook_state, Hook_id@1, Update_fn} ->
            Updated = begin
                _pipe@4 = erlang:element(4, State),
                gleam@option:map(
                    _pipe@4,
                    fun(Reconciled@2) ->
                        find_and_update_hook(
                            Reconciled@2,
                            Hook_id@1,
                            fun(Hook@2) -> case Hook@2 of
                                    {state, Id, _} ->
                                        case Id =:= Hook_id@1 of
                                            true ->
                                                Update_fn(Hook@2);

                                            false ->
                                                Hook@2
                                        end;

                                    _ ->
                                        Hook@2
                                end end
                        )
                    end
                )
            end,
            gleam@otp@actor:continue(erlang:setelement(4, State, Updated));

        {emit_client_hook_event, Hook_id@2, Kind@3, Payload@3} ->
            case erlang:element(4, State) of
                {some, Reconciled@3} ->
                    _ = begin
                        _pipe@5 = gleam@list:find(
                            erlang:element(5, erlang:element(2, State)),
                            fun(H@5) ->
                                {client_hook_id, _, _, Client_hook_id} = H@5,
                                Client_hook_id =:= Hook_id@2
                            end
                        ),
                        gleam@result:map(
                            _pipe@5,
                            fun(H@6) ->
                                {client_hook_id, Element_id@3, Hook_name@1, _} = H@6,
                                _pipe@6 = erlang:element(6, State),
                                gleam@option:map(
                                    _pipe@6,
                                    fun(Emitter) ->
                                        Emitter(
                                            sprocket@internal@utils@unique:to_string(
                                                Element_id@3
                                            ),
                                            Hook_name@1,
                                            Kind@3,
                                            Payload@3
                                        )
                                    end
                                )
                            end
                        )
                    end,
                    nil;

                none ->
                    sprocket@internal@logger:error(
                        <<"Runtime must be reconciled before emitting client hook events"/utf8>>
                    ),
                    nil
            end,
            gleam@otp@actor:continue(State);

        {reconcile_immediate, Reply_with@2} ->
            Prev_reconciled = erlang:element(4, State),
            View = erlang:element(2, erlang:element(2, State)),
            {Ctx, Reconciled@4} = do_reconciliation(
                erlang:element(2, State),
                View,
                Prev_reconciled
            ),
            gleam@otp@actor:send(Reply_with@2, Reconciled@4),
            gleam@otp@actor:continue(
                erlang:setelement(
                    4,
                    erlang:setelement(2, State, Ctx),
                    {some, Reconciled@4}
                )
            );

        render_update ->
            Prev_reconciled@1 = erlang:element(4, State),
            Updater = erlang:element(3, State),
            View@1 = erlang:element(2, erlang:element(2, State)),
            {Ctx@1, Reconciled@5} = do_reconciliation(
                erlang:element(2, State),
                View@1,
                Prev_reconciled@1
            ),
            case Prev_reconciled@1 of
                {some, Prev_reconciled@2} ->
                    Update = sprocket@internal@patch:create(
                        Prev_reconciled@2,
                        Reconciled@5
                    ),
                    case (erlang:element(2, Updater))({patch_update, Update}) of
                        {ok, _} ->
                            nil;

                        {error, _} ->
                            sprocket@internal@logger:error(
                                <<"Failed to send update patch!"/utf8>>
                            ),
                            nil
                    end;

                none ->
                    case (erlang:element(2, Updater))(
                        {full_update, Reconciled@5}
                    ) of
                        {ok, _} ->
                            nil;

                        {error, _} ->
                            sprocket@internal@logger:error(
                                <<"Failed to send full reconciled view!"/utf8>>
                            ),
                            nil
                    end
            end,
            gleam@otp@actor:continue(
                erlang:setelement(
                    4,
                    erlang:setelement(2, State, Ctx@1),
                    {some, Reconciled@5}
                )
            )
    end.

-file("/home/runner/work/sprocket/sprocket/src/sprocket/runtime.gleam", 297).
-spec start(
    sprocket@context:element(),
    sprocket@context:updater(rendered_update()),
    gleam@option:option(fun((binary(), binary(), binary(), gleam@option:option(binary())) -> {ok,
            nil} |
        {error, nil}))
) -> {ok, gleam@erlang@process:subject(message())} |
    {error, gleam@otp@actor:start_error()}.
start(View, Updater, Emitter) ->
    Init = fun() ->
        Self = gleam@erlang@process:new_subject(),
        Render_update = fun() ->
            sprocket@internal@logger:debug(<<"actor.send RenderUpdate"/utf8>>),
            gleam@otp@actor:send(Self, render_update)
        end,
        Update_hook = fun(Id, Updater@1) ->
            sprocket@internal@logger:debug(
                <<"actor.send UpdateHookState"/utf8>>
            ),
            gleam@otp@actor:send(Self, {update_hook_state, Id, Updater@1})
        end,
        _assert_subject = begin
            _pipe = ids@cuid:start(),
            gleam@result:map_error(
                _pipe,
                fun(Error) ->
                    sprocket@internal@logger:error(
                        <<"runtime.start: error starting cuid process"/utf8>>
                    ),
                    Error
                end
            )
        end,
        {ok, Cuid_channel} = 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 => <<"sprocket/runtime"/utf8>>,
                            function => <<"start"/utf8>>,
                            line => 315})
        end,
        Emit = fun(Id@1, Name, Payload) ->
            sprocket@internal@logger:debug(
                <<"actor.send EmitClientHookEvent"/utf8>>
            ),
            gleam@otp@actor:send(
                Self,
                {emit_client_hook_event, Id@1, Name, Payload}
            )
        end,
        State = {state,
            sprocket@context:new(
                View,
                Cuid_channel,
                {some, Emit},
                Render_update,
                Update_hook
            ),
            Updater,
            none,
            Cuid_channel,
            Emitter},
        Selector = gleam@erlang@process:selecting(
            gleam_erlang_ffi:new_selector(),
            Self,
            fun gleam@function:identity/1
        ),
        {ready, State, Selector}
    end,
    gleam@otp@actor:start_spec({spec, Init, 1000, fun handle_message/2}).