-module(lightspeed@component@template_compiler).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/lightspeed/component/template_compiler.gleam").
-export([required_string/1, required_int/1, required_bool/1, optional_string/2, optional_int/2, optional_bool/2, required_slot/1, optional_slot/1, schema/6, compile/3, diagnostic_label/1, diagnostics_signature/1, signature/1, rendered/1, html/1, fingerprint/1, require_string/2, require_int/2, require_bool/2, slot_rendered/2, require_slot/2]).
-export_type([attr_kind/0, attr_value/0, attr_requirement/0, attr_schema/0, slot_requirement/0, slot_schema/0, schema/2, compiled_template/2, diagnostic/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(" Compile-time-style template schema validation with deterministic diagnostics.\n").

-type attr_kind() :: attr_string | attr_int | attr_bool.

-type attr_value() :: {string_attr, binary()} |
    {int_attr, integer()} |
    {bool_attr, boolean()}.

-type attr_requirement() :: required_attr |
    {optional_attr, gleam@option:option(attr_value())}.

-type attr_schema() :: {attr_schema, binary(), attr_kind(), attr_requirement()}.

-type slot_requirement() :: required_slot | optional_slot.

-type slot_schema() :: {slot_schema, binary(), slot_requirement()}.

-type schema(IKD, IKE) :: {schema,
        binary(),
        list(attr_schema()),
        list(slot_schema()),
        fun((list({binary(), attr_value()})) -> {ok, IKD} | {error, binary()}),
        fun((list({binary(), lightspeed@component:rendered()})) -> {ok, IKE} |
            {error, binary()}),
        fun((IKD, IKE) -> lightspeed@component:rendered())}.

-type compiled_template(IKF, IKG) :: {compiled_template,
        binary(),
        list({binary(), attr_value()}),
        list({binary(), lightspeed@component:rendered()}),
        IKF,
        IKG,
        lightspeed@component:rendered(),
        binary()}.

-type diagnostic() :: {missing_attribute, binary(), binary()} |
    {duplicate_attribute, binary(), binary()} |
    {unknown_attribute, binary(), binary()} |
    {invalid_attribute_type, binary(), binary(), attr_kind(), attr_kind()} |
    {missing_slot, binary(), binary()} |
    {duplicate_slot, binary(), binary()} |
    {unknown_slot, binary(), binary()} |
    {assign_build_failed, binary(), binary()} |
    {slot_build_failed, binary(), binary()}.

-file("src/lightspeed/component/template_compiler.gleam", 90).
?DOC(" Build one required string attribute rule.\n").
-spec required_string(binary()) -> attr_schema().
required_string(Name) ->
    {attr_schema, Name, attr_string, required_attr}.

-file("src/lightspeed/component/template_compiler.gleam", 95).
?DOC(" Build one required int attribute rule.\n").
-spec required_int(binary()) -> attr_schema().
required_int(Name) ->
    {attr_schema, Name, attr_int, required_attr}.

-file("src/lightspeed/component/template_compiler.gleam", 100).
?DOC(" Build one required bool attribute rule.\n").
-spec required_bool(binary()) -> attr_schema().
required_bool(Name) ->
    {attr_schema, Name, attr_bool, required_attr}.

-file("src/lightspeed/component/template_compiler.gleam", 744).
-spec option_map_string(gleam@option:option(binary())) -> gleam@option:option(attr_value()).
option_map_string(Value) ->
    case Value of
        none ->
            none;

        {some, Default} ->
            {some, {string_attr, Default}}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 105).
?DOC(" Build one optional string attribute with optional default.\n").
-spec optional_string(binary(), gleam@option:option(binary())) -> attr_schema().
optional_string(Name, Default) ->
    {attr_schema,
        Name,
        attr_string,
        {optional_attr, option_map_string(Default)}}.

-file("src/lightspeed/component/template_compiler.gleam", 751).
-spec option_map_int(gleam@option:option(integer())) -> gleam@option:option(attr_value()).
option_map_int(Value) ->
    case Value of
        none ->
            none;

        {some, Default} ->
            {some, {int_attr, Default}}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 114).
?DOC(" Build one optional int attribute with optional default.\n").
-spec optional_int(binary(), gleam@option:option(integer())) -> attr_schema().
optional_int(Name, Default) ->
    {attr_schema, Name, attr_int, {optional_attr, option_map_int(Default)}}.

-file("src/lightspeed/component/template_compiler.gleam", 758).
-spec option_map_bool(gleam@option:option(boolean())) -> gleam@option:option(attr_value()).
option_map_bool(Value) ->
    case Value of
        none ->
            none;

        {some, Default} ->
            {some, {bool_attr, Default}}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 123).
?DOC(" Build one optional bool attribute with optional default.\n").
-spec optional_bool(binary(), gleam@option:option(boolean())) -> attr_schema().
optional_bool(Name, Default) ->
    {attr_schema, Name, attr_bool, {optional_attr, option_map_bool(Default)}}.

-file("src/lightspeed/component/template_compiler.gleam", 132).
?DOC(" Build one required slot rule.\n").
-spec required_slot(binary()) -> slot_schema().
required_slot(Name) ->
    {slot_schema, Name, required_slot}.

-file("src/lightspeed/component/template_compiler.gleam", 137).
?DOC(" Build one optional slot rule.\n").
-spec optional_slot(binary()) -> slot_schema().
optional_slot(Name) ->
    {slot_schema, Name, optional_slot}.

-file("src/lightspeed/component/template_compiler.gleam", 142).
?DOC(" Build one template compilation schema.\n").
-spec schema(
    binary(),
    list(attr_schema()),
    list(slot_schema()),
    fun((list({binary(), attr_value()})) -> {ok, IKN} | {error, binary()}),
    fun((list({binary(), lightspeed@component:rendered()})) -> {ok, IKR} |
        {error, binary()}),
    fun((IKN, IKR) -> lightspeed@component:rendered())
) -> schema(IKN, IKR).
schema(Name, Attrs, Slots, Build_assigns, Build_slots, Render) ->
    {schema, Name, Attrs, Slots, Build_assigns, Build_slots, Render}.

-file("src/lightspeed/component/template_compiler.gleam", 773).
-spec concat_lists(list(IOU), list(IOU)) -> list(IOU).
concat_lists(First, Second) ->
    case First of
        [] ->
            Second;

        [Value | Rest] ->
            [Value | concat_lists(Rest, Second)]
    end.

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

        [Value] ->
            Value;

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

-file("src/lightspeed/component/template_compiler.gleam", 724).
-spec attr_value_label(attr_value()) -> binary().
attr_value_label(Value) ->
    case Value of
        {string_attr, String_value} ->
            <<"string:"/utf8, String_value/binary>>;

        {int_attr, Int_value} ->
            <<"int:"/utf8, (erlang:integer_to_binary(Int_value))/binary>>;

        {bool_attr, Bool_value} ->
            case Bool_value of
                true ->
                    <<"bool:true"/utf8>>;

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

-file("src/lightspeed/component/template_compiler.gleam", 689).
-spec compile_signature(
    binary(),
    list({binary(), attr_value()}),
    list({binary(), lightspeed@component:rendered()}),
    lightspeed@component:rendered()
) -> binary().
compile_signature(Name, Attrs, Slots, Rendered) ->
    Attr_labels = gleam@list:map(
        Attrs,
        fun(Attribute) ->
            {Attr_name, Attr_value} = Attribute,
            <<<<Attr_name/binary, "="/utf8>>/binary,
                (attr_value_label(Attr_value))/binary>>
        end
    ),
    Attr_signature = join_with(<<","/utf8>>, Attr_labels),
    Slot_labels = gleam@list:map(
        Slots,
        fun(Slot) ->
            {Slot_name, Slot_rendered} = Slot,
            <<<<<<<<Slot_name/binary, ":fingerprint="/utf8>>/binary,
                        (lightspeed@component:fingerprint(Slot_rendered))/binary>>/binary,
                    ":html="/utf8>>/binary,
                (lightspeed@component:to_html(Slot_rendered))/binary>>
        end
    ),
    Slot_signature = join_with(<<","/utf8>>, Slot_labels),
    <<<<<<<<<<<<<<<<<<"template="/utf8, Name/binary>>/binary, "|attrs="/utf8>>/binary,
                                Attr_signature/binary>>/binary,
                            "|slots="/utf8>>/binary,
                        Slot_signature/binary>>/binary,
                    "|rendered_fingerprint="/utf8>>/binary,
                (lightspeed@component:fingerprint(Rendered))/binary>>/binary,
            "|rendered_html="/utf8>>/binary,
        (lightspeed@component:to_html(Rendered))/binary>>.

-file("src/lightspeed/component/template_compiler.gleam", 642).
-spec find_slot(list({binary(), lightspeed@component:rendered()}), binary()) -> gleam@option:option(lightspeed@component:rendered()).
find_slot(Slots, Name) ->
    case Slots of
        [] ->
            none;

        [{Entry_name, Entry_value} | Rest] ->
            case Entry_name =:= Name of
                true ->
                    {some, Entry_value};

                false ->
                    find_slot(Rest, Name)
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 583).
-spec validate_schema_slots(
    binary(),
    list(slot_schema()),
    list({binary(), lightspeed@component:rendered()}),
    list({binary(), lightspeed@component:rendered()})
) -> {ok, list({binary(), lightspeed@component:rendered()})} |
    {error, list(diagnostic())}.
validate_schema_slots(
    Template_name,
    Schema_slots,
    Provided_slots,
    Normalized_rev
) ->
    case Schema_slots of
        [] ->
            {ok, lists:reverse(Normalized_rev)};

        [Schema | Rest] ->
            case {erlang:element(3, Schema),
                find_slot(Provided_slots, erlang:element(2, Schema))} of
                {required_slot, none} ->
                    {error,
                        [{missing_slot,
                                Template_name,
                                erlang:element(2, Schema)}]};

                {required_slot, {some, Rendered}} ->
                    validate_schema_slots(
                        Template_name,
                        Rest,
                        Provided_slots,
                        [{erlang:element(2, Schema), Rendered} | Normalized_rev]
                    );

                {optional_slot, none} ->
                    validate_schema_slots(
                        Template_name,
                        Rest,
                        Provided_slots,
                        Normalized_rev
                    );

                {optional_slot, {some, Rendered@1}} ->
                    validate_schema_slots(
                        Template_name,
                        Rest,
                        Provided_slots,
                        [{erlang:element(2, Schema), Rendered@1} |
                            Normalized_rev]
                    )
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 667).
-spec slot_in_schema(list(slot_schema()), binary()) -> boolean().
slot_in_schema(Slots, Name) ->
    case Slots of
        [] ->
            false;

        [Schema | Rest] ->
            case erlang:element(2, Schema) =:= Name of
                true ->
                    true;

                false ->
                    slot_in_schema(Rest, Name)
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 678).
-spec contains_name(list(binary()), binary()) -> boolean().
contains_name(Names, Expected) ->
    case Names of
        [] ->
            false;

        [Name | Rest] ->
            case Name =:= Expected of
                true ->
                    true;

                false ->
                    contains_name(Rest, Expected)
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 535).
-spec find_slot_input_diagnostics_loop(
    binary(),
    list(slot_schema()),
    list({binary(), lightspeed@component:rendered()}),
    list(binary()),
    list(diagnostic())
) -> list(diagnostic()).
find_slot_input_diagnostics_loop(
    Template_name,
    Schema_slots,
    Provided_slots,
    Seen,
    Diagnostics_rev
) ->
    case Provided_slots of
        [] ->
            lists:reverse(Diagnostics_rev);

        [{Name, _} | Rest] ->
            case {contains_name(Seen, Name), slot_in_schema(Schema_slots, Name)} of
                {true, _} ->
                    find_slot_input_diagnostics_loop(
                        Template_name,
                        Schema_slots,
                        Rest,
                        Seen,
                        [{duplicate_slot, Template_name, Name} |
                            Diagnostics_rev]
                    );

                {false, false} ->
                    find_slot_input_diagnostics_loop(
                        Template_name,
                        Schema_slots,
                        Rest,
                        [Name | Seen],
                        [{unknown_slot, Template_name, Name} | Diagnostics_rev]
                    );

                {false, true} ->
                    find_slot_input_diagnostics_loop(
                        Template_name,
                        Schema_slots,
                        Rest,
                        [Name | Seen],
                        Diagnostics_rev
                    )
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 521).
-spec find_slot_input_diagnostics(
    binary(),
    list(slot_schema()),
    list({binary(), lightspeed@component:rendered()})
) -> list(diagnostic()).
find_slot_input_diagnostics(Template_name, Schema_slots, Provided_slots) ->
    find_slot_input_diagnostics_loop(
        Template_name,
        Schema_slots,
        Provided_slots,
        [],
        []
    ).

-file("src/lightspeed/component/template_compiler.gleam", 366).
-spec validate_slots(
    binary(),
    list(slot_schema()),
    list({binary(), lightspeed@component:rendered()})
) -> {ok, list({binary(), lightspeed@component:rendered()})} |
    {error, list(diagnostic())}.
validate_slots(Template_name, Schema_slots, Provided_slots) ->
    Unknown_or_duplicate = find_slot_input_diagnostics(
        Template_name,
        Schema_slots,
        Provided_slots
    ),
    Schema_validation = validate_schema_slots(
        Template_name,
        Schema_slots,
        Provided_slots,
        []
    ),
    case {Unknown_or_duplicate, Schema_validation} of
        {[], {ok, Normalized}} ->
            {ok, Normalized};

        {[], {error, Diagnostics}} ->
            {error, Diagnostics};

        {Diagnostics@1, {ok, _}} ->
            {error, Diagnostics@1};

        {Diagnostics@2, {error, Other}} ->
            {error, concat_lists(Diagnostics@2, Other)}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 620).
-spec kind_of_value(attr_value()) -> attr_kind().
kind_of_value(Value) ->
    case Value of
        {string_attr, _} ->
            attr_string;

        {int_attr, _} ->
            attr_int;

        {bool_attr, _} ->
            attr_bool
    end.

-file("src/lightspeed/component/template_compiler.gleam", 628).
-spec find_attr(list({binary(), attr_value()}), binary()) -> gleam@option:option(attr_value()).
find_attr(Attrs, Name) ->
    case Attrs of
        [] ->
            none;

        [{Entry_name, Entry_value} | Rest] ->
            case Entry_name =:= Name of
                true ->
                    {some, Entry_value};

                false ->
                    find_attr(Rest, Name)
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 446).
-spec validate_schema_attrs(
    binary(),
    list(attr_schema()),
    list({binary(), attr_value()}),
    list({binary(), attr_value()})
) -> {ok, list({binary(), attr_value()})} | {error, list(diagnostic())}.
validate_schema_attrs(
    Template_name,
    Schema_attrs,
    Provided_attrs,
    Normalized_rev
) ->
    case Schema_attrs of
        [] ->
            {ok, lists:reverse(Normalized_rev)};

        [Schema | Rest] ->
            Value = find_attr(Provided_attrs, erlang:element(2, Schema)),
            case {erlang:element(4, Schema), Value} of
                {required_attr, none} ->
                    {error,
                        [{missing_attribute,
                                Template_name,
                                erlang:element(2, Schema)}]};

                {required_attr, {some, Actual}} ->
                    case kind_of_value(Actual) =:= erlang:element(3, Schema) of
                        true ->
                            validate_schema_attrs(
                                Template_name,
                                Rest,
                                Provided_attrs,
                                [{erlang:element(2, Schema), Actual} |
                                    Normalized_rev]
                            );

                        false ->
                            {error,
                                [{invalid_attribute_type,
                                        Template_name,
                                        erlang:element(2, Schema),
                                        erlang:element(3, Schema),
                                        kind_of_value(Actual)}]}
                    end;

                {{optional_attr, Default}, none} ->
                    case Default of
                        {some, Value@1} ->
                            validate_schema_attrs(
                                Template_name,
                                Rest,
                                Provided_attrs,
                                [{erlang:element(2, Schema), Value@1} |
                                    Normalized_rev]
                            );

                        none ->
                            validate_schema_attrs(
                                Template_name,
                                Rest,
                                Provided_attrs,
                                Normalized_rev
                            )
                    end;

                {{optional_attr, _}, {some, Actual@1}} ->
                    case kind_of_value(Actual@1) =:= erlang:element(3, Schema) of
                        true ->
                            validate_schema_attrs(
                                Template_name,
                                Rest,
                                Provided_attrs,
                                [{erlang:element(2, Schema), Actual@1} |
                                    Normalized_rev]
                            );

                        false ->
                            {error,
                                [{invalid_attribute_type,
                                        Template_name,
                                        erlang:element(2, Schema),
                                        erlang:element(3, Schema),
                                        kind_of_value(Actual@1)}]}
                    end
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 656).
-spec attr_in_schema(list(attr_schema()), binary()) -> boolean().
attr_in_schema(Attrs, Name) ->
    case Attrs of
        [] ->
            false;

        [Schema | Rest] ->
            case erlang:element(2, Schema) =:= Name of
                true ->
                    true;

                false ->
                    attr_in_schema(Rest, Name)
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 398).
-spec find_attr_input_diagnostics_loop(
    binary(),
    list(attr_schema()),
    list({binary(), attr_value()}),
    list(binary()),
    list(diagnostic())
) -> list(diagnostic()).
find_attr_input_diagnostics_loop(
    Template_name,
    Schema_attrs,
    Provided_attrs,
    Seen,
    Diagnostics_rev
) ->
    case Provided_attrs of
        [] ->
            lists:reverse(Diagnostics_rev);

        [{Name, _} | Rest] ->
            case {contains_name(Seen, Name), attr_in_schema(Schema_attrs, Name)} of
                {true, _} ->
                    find_attr_input_diagnostics_loop(
                        Template_name,
                        Schema_attrs,
                        Rest,
                        Seen,
                        [{duplicate_attribute, Template_name, Name} |
                            Diagnostics_rev]
                    );

                {false, false} ->
                    find_attr_input_diagnostics_loop(
                        Template_name,
                        Schema_attrs,
                        Rest,
                        [Name | Seen],
                        [{unknown_attribute, Template_name, Name} |
                            Diagnostics_rev]
                    );

                {false, true} ->
                    find_attr_input_diagnostics_loop(
                        Template_name,
                        Schema_attrs,
                        Rest,
                        [Name | Seen],
                        Diagnostics_rev
                    )
            end
    end.

-file("src/lightspeed/component/template_compiler.gleam", 384).
-spec find_attr_input_diagnostics(
    binary(),
    list(attr_schema()),
    list({binary(), attr_value()})
) -> list(diagnostic()).
find_attr_input_diagnostics(Template_name, Schema_attrs, Provided_attrs) ->
    find_attr_input_diagnostics_loop(
        Template_name,
        Schema_attrs,
        Provided_attrs,
        [],
        []
    ).

-file("src/lightspeed/component/template_compiler.gleam", 348).
-spec validate_attrs(
    binary(),
    list(attr_schema()),
    list({binary(), attr_value()})
) -> {ok, list({binary(), attr_value()})} | {error, list(diagnostic())}.
validate_attrs(Template_name, Schema_attrs, Provided_attrs) ->
    Unknown_or_duplicate = find_attr_input_diagnostics(
        Template_name,
        Schema_attrs,
        Provided_attrs
    ),
    Schema_validation = validate_schema_attrs(
        Template_name,
        Schema_attrs,
        Provided_attrs,
        []
    ),
    case {Unknown_or_duplicate, Schema_validation} of
        {[], {ok, Normalized}} ->
            {ok, Normalized};

        {[], {error, Diagnostics}} ->
            {error, Diagnostics};

        {Diagnostics@1, {ok, _}} ->
            {error, Diagnostics@1};

        {Diagnostics@2, {error, Other}} ->
            {error, concat_lists(Diagnostics@2, Other)}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 161).
?DOC(" Validate and compile one template invocation.\n").
-spec compile(
    schema(IKY, IKZ),
    list({binary(), attr_value()}),
    list({binary(), lightspeed@component:rendered()})
) -> {ok, compiled_template(IKY, IKZ)} | {error, list(diagnostic())}.
compile(Schema, Attrs, Slots) ->
    Attr_validation = validate_attrs(
        erlang:element(2, Schema),
        erlang:element(3, Schema),
        Attrs
    ),
    Slot_validation = validate_slots(
        erlang:element(2, Schema),
        erlang:element(4, Schema),
        Slots
    ),
    case {Attr_validation, Slot_validation} of
        {{ok, Normalized_attrs}, {ok, Normalized_slots}} ->
            case {(erlang:element(5, Schema))(Normalized_attrs),
                (erlang:element(6, Schema))(Normalized_slots)} of
                {{ok, Assigns}, {ok, Slot_assigns}} ->
                    Rendered = lightspeed@component@template:render(
                        erlang:element(7, Schema),
                        Assigns,
                        Slot_assigns
                    ),
                    Signature = compile_signature(
                        erlang:element(2, Schema),
                        Normalized_attrs,
                        Normalized_slots,
                        Rendered
                    ),
                    {ok,
                        {compiled_template,
                            erlang:element(2, Schema),
                            Normalized_attrs,
                            Normalized_slots,
                            Assigns,
                            Slot_assigns,
                            Rendered,
                            Signature}};

                {{error, Reason}, _} ->
                    {error,
                        [{assign_build_failed,
                                erlang:element(2, Schema),
                                Reason}]};

                {_, {error, Reason@1}} ->
                    {error,
                        [{slot_build_failed,
                                erlang:element(2, Schema),
                                Reason@1}]}
            end;

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

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

        {{error, Attr_diagnostics@1}, {error, Slot_diagnostics@1}} ->
            {error, concat_lists(Attr_diagnostics@1, Slot_diagnostics@1)}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 736).
-spec kind_label(attr_kind()) -> binary().
kind_label(Kind) ->
    case Kind of
        attr_string ->
            <<"string"/utf8>>;

        attr_int ->
            <<"int"/utf8>>;

        attr_bool ->
            <<"bool"/utf8>>
    end.

-file("src/lightspeed/component/template_compiler.gleam", 213).
?DOC(" Stable diagnostic label.\n").
-spec diagnostic_label(diagnostic()) -> binary().
diagnostic_label(Diagnostic) ->
    case Diagnostic of
        {missing_attribute, Template, Attribute} ->
            <<<<<<"missing_attribute:"/utf8, Template/binary>>/binary,
                    ":"/utf8>>/binary,
                Attribute/binary>>;

        {duplicate_attribute, Template@1, Attribute@1} ->
            <<<<<<"duplicate_attribute:"/utf8, Template@1/binary>>/binary,
                    ":"/utf8>>/binary,
                Attribute@1/binary>>;

        {unknown_attribute, Template@2, Attribute@2} ->
            <<<<<<"unknown_attribute:"/utf8, Template@2/binary>>/binary,
                    ":"/utf8>>/binary,
                Attribute@2/binary>>;

        {invalid_attribute_type, Template@3, Attribute@3, Expected, Actual} ->
            <<<<<<<<<<<<<<"invalid_attribute_type:"/utf8, Template@3/binary>>/binary,
                                    ":"/utf8>>/binary,
                                Attribute@3/binary>>/binary,
                            ":expected="/utf8>>/binary,
                        (kind_label(Expected))/binary>>/binary,
                    ":actual="/utf8>>/binary,
                (kind_label(Actual))/binary>>;

        {missing_slot, Template@4, Slot} ->
            <<<<<<"missing_slot:"/utf8, Template@4/binary>>/binary, ":"/utf8>>/binary,
                Slot/binary>>;

        {duplicate_slot, Template@5, Slot@1} ->
            <<<<<<"duplicate_slot:"/utf8, Template@5/binary>>/binary, ":"/utf8>>/binary,
                Slot@1/binary>>;

        {unknown_slot, Template@6, Slot@2} ->
            <<<<<<"unknown_slot:"/utf8, Template@6/binary>>/binary, ":"/utf8>>/binary,
                Slot@2/binary>>;

        {assign_build_failed, Template@7, Reason} ->
            <<<<<<"assign_build_failed:"/utf8, Template@7/binary>>/binary,
                    ":"/utf8>>/binary,
                Reason/binary>>;

        {slot_build_failed, Template@8, Reason@1} ->
            <<<<<<"slot_build_failed:"/utf8, Template@8/binary>>/binary,
                    ":"/utf8>>/binary,
                Reason@1/binary>>
    end.

-file("src/lightspeed/component/template_compiler.gleam", 246).
?DOC(" Stable diagnostics signature.\n").
-spec diagnostics_signature(list(diagnostic())) -> binary().
diagnostics_signature(Diagnostics) ->
    Labels = gleam@list:map(Diagnostics, fun diagnostic_label/1),
    join_with(<<";"/utf8>>, Labels).

-file("src/lightspeed/component/template_compiler.gleam", 252).
?DOC(" Compiled template stable signature.\n").
-spec signature(compiled_template(any(), any())) -> binary().
signature(Compiled) ->
    erlang:element(8, Compiled).

-file("src/lightspeed/component/template_compiler.gleam", 257).
?DOC(" Compiled template rendered output.\n").
-spec rendered(compiled_template(any(), any())) -> lightspeed@component:rendered().
rendered(Compiled) ->
    erlang:element(7, Compiled).

-file("src/lightspeed/component/template_compiler.gleam", 264).
?DOC(" Compiled template HTML.\n").
-spec html(compiled_template(any(), any())) -> binary().
html(Compiled) ->
    _pipe = erlang:element(7, Compiled),
    lightspeed@component:to_html(_pipe).

-file("src/lightspeed/component/template_compiler.gleam", 270).
?DOC(" Compiled template fingerprint.\n").
-spec fingerprint(compiled_template(any(), any())) -> binary().
fingerprint(Compiled) ->
    _pipe = erlang:element(7, Compiled),
    lightspeed@component:fingerprint(_pipe).

-file("src/lightspeed/component/template_compiler.gleam", 276).
?DOC(" Find one required string attribute from normalized attrs.\n").
-spec require_string(list({binary(), attr_value()}), binary()) -> {ok, binary()} |
    {error, binary()}.
require_string(Attrs, Name) ->
    case find_attr(Attrs, Name) of
        none ->
            {error, <<"missing_attr:"/utf8, Name/binary>>};

        {some, {string_attr, Value}} ->
            {ok, Value};

        {some, Other} ->
            {error,
                <<<<<<"invalid_attr_type:"/utf8, Name/binary>>/binary,
                        ":expected=string:actual="/utf8>>/binary,
                    (kind_label(kind_of_value(Other)))/binary>>}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 294).
?DOC(" Find one required int attribute from normalized attrs.\n").
-spec require_int(list({binary(), attr_value()}), binary()) -> {ok, integer()} |
    {error, binary()}.
require_int(Attrs, Name) ->
    case find_attr(Attrs, Name) of
        none ->
            {error, <<"missing_attr:"/utf8, Name/binary>>};

        {some, {int_attr, Value}} ->
            {ok, Value};

        {some, Other} ->
            {error,
                <<<<<<"invalid_attr_type:"/utf8, Name/binary>>/binary,
                        ":expected=int:actual="/utf8>>/binary,
                    (kind_label(kind_of_value(Other)))/binary>>}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 312).
?DOC(" Find one required bool attribute from normalized attrs.\n").
-spec require_bool(list({binary(), attr_value()}), binary()) -> {ok, boolean()} |
    {error, binary()}.
require_bool(Attrs, Name) ->
    case find_attr(Attrs, Name) of
        none ->
            {error, <<"missing_attr:"/utf8, Name/binary>>};

        {some, {bool_attr, Value}} ->
            {ok, Value};

        {some, Other} ->
            {error,
                <<<<<<"invalid_attr_type:"/utf8, Name/binary>>/binary,
                        ":expected=bool:actual="/utf8>>/binary,
                    (kind_label(kind_of_value(Other)))/binary>>}
    end.

-file("src/lightspeed/component/template_compiler.gleam", 330).
?DOC(" Find optional slot by name.\n").
-spec slot_rendered(list({binary(), lightspeed@component:rendered()}), binary()) -> gleam@option:option(lightspeed@component:rendered()).
slot_rendered(Slots, Name) ->
    find_slot(Slots, Name).

-file("src/lightspeed/component/template_compiler.gleam", 338).
?DOC(" Find required slot by name with deterministic errors.\n").
-spec require_slot(list({binary(), lightspeed@component:rendered()}), binary()) -> {ok,
        lightspeed@component:rendered()} |
    {error, binary()}.
require_slot(Slots, Name) ->
    case find_slot(Slots, Name) of
        {some, Rendered} ->
            {ok, Rendered};

        none ->
            {error, <<"missing_slot:"/utf8, Name/binary>>}
    end.