skill-universe 1.1.0

package/build/dev/javascript/yay/yay.erl

@@ -0,0 +1,1218 @@
+-module(yay).
+-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
+-define(FILEPATH, "src/yay.gleam").
+-export([parse_file/1, parse_string/1, document_root/1, select/2, parse_selector/1, select_sugar/2, extraction_error_to_string/1, extract_string/2, extract_int/2, extract_float/2, extract_bool/2, extract_optional_string/2, extract_optional_int/2, extract_optional_float/2, extract_optional_bool/2, extract_string_or/3, extract_int_or/3, extract_float_or/3, extract_bool_or/3, extract_string_list/2, extract_int_list/2, extract_float_list/2, extract_bool_list/2, extract_string_map/2, extract_int_map/2, extract_float_map/2, extract_bool_map/2, extract_list_with/3, extract_map_with/3, extract_string_map_with_duplicate_detection/3]).
+-export_type([yaml_error/0, yaml_error_loc/0, document/0, node_/0, selector/0, selection/0, selector_error/0, extraction_error/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.
+
+-type yaml_error() :: unexpected_parsing_error |
+    {parsing_error, binary(), yaml_error_loc()}.
+
+-type yaml_error_loc() :: {yaml_error_loc, integer(), integer()}.
+
+-type document() :: {document, node_()}.
+
+-type node_() :: node_nil |
+    {node_str, binary()} |
+    {node_bool, boolean()} |
+    {node_int, integer()} |
+    {node_float, float()} |
+    {node_seq, list(node_())} |
+    {node_map, list({node_(), node_()})}.
+
+-type selector() :: {selector, list(selection())}.
+
+-type selection() :: {select_map, node_()} | {select_seq, integer()}.
+
+-type selector_error() :: {node_not_found, integer()} | selector_parse_error.
+
+-type extraction_error() :: {key_missing, binary(), integer()} |
+    {key_value_empty, binary()} |
+    {key_type_mismatch, binary(), binary(), binary()} |
+    {duplicate_keys_detected, binary(), list(binary())}.
+
+-file("src/yay.gleam", 50).
+?DOC(" Parse a YAML file located in `path` into a list of YAML documents.\n").
+-spec parse_file(binary()) -> {ok, list(document())} | {error, yaml_error()}.
+parse_file(Path) ->
+    yaml_ffi:parse_file(Path).
+
+-file("src/yay.gleam", 56).
+?DOC(" Parse a string into a list of YAML documents.\n").
+-spec parse_string(binary()) -> {ok, list(document())} | {error, yaml_error()}.
+parse_string(String) ->
+    yaml_ffi:parse_string(String).
+
+-file("src/yay.gleam", 67).
+?DOC(
+    " Gets the root `Node` of a YAML document.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " let document = Document(root: NodeNil)\n"
+    " let assert NodeNil = document_root(document)\n"
+    " ```\n"
+).
+-spec document_root(document()) -> node_().
+document_root(Document) ->
+    erlang:element(2, Document).
+
+-file("src/yay.gleam", 167).
+-spec list_at(list(EUL), integer()) -> gleam@option:option(EUL).
+list_at(L, Index) ->
+    case L of
+        [Head | Tail] ->
+            case Index of
+                0 ->
+                    {some, Head};
+
+                _ ->
+                    list_at(Tail, Index - 1)
+            end;
+
+        [] ->
+            none
+    end.
+
+-file("src/yay.gleam", 134).
+-spec do_select(node_(), selector(), integer()) -> {ok, node_()} |
+    {error, selector_error()}.
+do_select(Node, Selector, Select_idx) ->
+    case Selector of
+        {selector, [Select | Selector_tail]} ->
+            case Select of
+                {select_seq, Index} ->
+                    case Node of
+                        {node_seq, Seq} ->
+                            case list_at(Seq, Index) of
+                                {some, Node@1} ->
+                                    do_select(
+                                        Node@1,
+                                        {selector, Selector_tail},
+                                        Select_idx + 1
+                                    );
+
+                                none ->
+                                    {error, {node_not_found, Select_idx}}
+                            end;
+
+                        _ ->
+                            {error, {node_not_found, Select_idx}}
+                    end;
+
+                {select_map, Key} ->
+                    case Node of
+                        {node_map, Pairs} ->
+                            case gleam@list:key_find(Pairs, Key) of
+                                {ok, Node@2} ->
+                                    do_select(
+                                        Node@2,
+                                        {selector, Selector_tail},
+                                        Select_idx + 1
+                                    );
+
+                                {error, _} ->
+                                    {error, {node_not_found, Select_idx}}
+                            end;
+
+                        _ ->
+                            {error, {node_not_found, Select_idx}}
+                    end
+            end;
+
+        {selector, []} ->
+            {ok, Node}
+    end.
+
+-file("src/yay.gleam", 127).
+?DOC(
+    " Queries the given `node` with a `Selector`.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " let map = NodeMap([\n"
+    "   #(NodeStr(\"lib name\"), NodeStr(\"yay\")),\n"
+    "   #(NodeStr(\"stars\"), NodeInt(7)),\n"
+    " ])\n"
+    "\n"
+    " let assert Ok(NodeInt(7)) = select(from: map, selector: Selector([SelectMap(NodeStr(\"stars\"))]))\n"
+    " ```\n"
+).
+-spec select(node_(), selector()) -> {ok, node_()} | {error, selector_error()}.
+select(Node, Selector) ->
+    do_select(Node, Selector, 0).
+
+-file("src/yay.gleam", 187).
+-spec do_parse_selector(list(binary()), list(selection())) -> {ok,
+        list(selection())} |
+    {error, selector_error()}.
+do_parse_selector(Selector_parts, Acc) ->
+    case Selector_parts of
+        [<<""/utf8>> | Tail] ->
+            do_parse_selector(Tail, Acc);
+
+        [Part | Tail@1] ->
+            case gleam_stdlib:string_starts_with(Part, <<"#"/utf8>>) of
+                true ->
+                    case gleam_stdlib:parse_int(
+                        gleam@string:drop_start(Part, 1)
+                    ) of
+                        {ok, Index} ->
+                            do_parse_selector(
+                                Tail@1,
+                                [{select_seq, Index} | Acc]
+                            );
+
+                        {error, nil} ->
+                            {error, selector_parse_error}
+                    end;
+
+                false ->
+                    do_parse_selector(
+                        Tail@1,
+                        [{select_map, {node_str, Part}} | Acc]
+                    )
+            end;
+
+        [] ->
+            {ok, Acc}
+    end.
+
+-file("src/yay.gleam", 180).
+?DOC(" Parses a selector string into a `Selector`.\n").
+-spec parse_selector(binary()) -> {ok, selector()} | {error, selector_error()}.
+parse_selector(Selector) ->
+    gleam@result:'try'(
+        do_parse_selector(gleam@string:split(Selector, <<"."/utf8>>), []),
+        fun(Selections) -> {ok, {selector, lists:reverse(Selections)}} end
+    ).
+
+-file("src/yay.gleam", 106).
+?DOC(
+    " Parses the `selector` and queries the given `node` with it.\n"
+    "\n"
+    " ## Examples\n"
+    "\n"
+    " ```gleam\n"
+    " let map = NodeMap([\n"
+    "   #(NodeStr(\"list\"), NodeMap([\n"
+    "     #(NodeStr(\"elements\"), NodeSeq([NodeInt(101)]))\n"
+    "   ])),\n"
+    "   #(NodeStr(\"linked\"), NodeBool(False)),\n"
+    " ])\n"
+    "\n"
+    " let assert Ok(NodeInt(101)) = select_sugar(from: map, selector: \"list.elements.#0\")\n"
+    " ```\n"
+).
+-spec select_sugar(node_(), binary()) -> {ok, node_()} |
+    {error, selector_error()}.
+select_sugar(Node, Selector) ->
+    gleam@result:'try'(
+        parse_selector(Selector),
+        fun(Selector@1) -> select(Node, Selector@1) end
+    ).
+
+-file("src/yay.gleam", 220).
+?DOC(" Converts an ExtractionError to a human-readable string.\n").
+-spec extraction_error_to_string(extraction_error()) -> binary().
+extraction_error_to_string(Error) ->
+    case Error of
+        {key_missing, Key, Failed_at_segment} ->
+            <<<<<<<<"Missing "/utf8, Key/binary>>/binary,
+                        " (failed at segment "/utf8>>/binary,
+                    (erlang:integer_to_binary(Failed_at_segment))/binary>>/binary,
+                ")"/utf8>>;
+
+        {key_value_empty, Key@1} ->
+            <<<<"Expected "/utf8, Key@1/binary>>/binary,
+                " to be non-empty"/utf8>>;
+
+        {key_type_mismatch, Key@2, Expected, Found} ->
+            <<<<<<<<<<"Expected "/utf8, Key@2/binary>>/binary,
+                            " to be a "/utf8>>/binary,
+                        Expected/binary>>/binary,
+                    ", but found "/utf8>>/binary,
+                Found/binary>>;
+
+        {duplicate_keys_detected, Key@3, Keys} ->
+            <<<<<<"Duplicate keys detected for "/utf8, Key@3/binary>>/binary,
+                    ": "/utf8>>/binary,
+                (gleam@string:join(Keys, <<", "/utf8>>))/binary>>
+    end.
+
+-file("src/yay.gleam", 237).
+?DOC(" Converts a Node to a human-readable type name.\n").
+-spec node_type_name(node_()) -> binary().
+node_type_name(Node) ->
+    case Node of
+        node_nil ->
+            <<"nil"/utf8>>;
+
+        {node_str, _} ->
+            <<"string"/utf8>>;
+
+        {node_bool, _} ->
+            <<"bool"/utf8>>;
+
+        {node_int, _} ->
+            <<"int"/utf8>>;
+
+        {node_float, _} ->
+            <<"float"/utf8>>;
+
+        {node_seq, _} ->
+            <<"list"/utf8>>;
+
+        {node_map, _} ->
+            <<"map"/utf8>>
+    end.
+
+-file("src/yay.gleam", 250).
+?DOC(" Internal helper to select a node or return KeyMissing with position info.\n").
+-spec select_or_missing(node_(), binary()) -> {ok, node_()} |
+    {error, extraction_error()}.
+select_or_missing(Node, Key) ->
+    case select_sugar(Node, Key) of
+        {ok, N} ->
+            {ok, N};
+
+        {error, {node_not_found, At}} ->
+            {error, {key_missing, Key, At}};
+
+        {error, selector_parse_error} ->
+            {error, {key_missing, Key, 0}}
+    end.
+
+-file("src/yay.gleam", 265).
+?DOC(" Extracts a string from a YAML node.\n").
+-spec extract_string(node_(), binary()) -> {ok, binary()} |
+    {error, extraction_error()}.
+extract_string(Node, Key) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Selected) -> case Selected of
+                {node_str, Value} ->
+                    {ok, Value};
+
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"string"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 283).
+?DOC(" Extracts an integer from a YAML node.\n").
+-spec extract_int(node_(), binary()) -> {ok, integer()} |
+    {error, extraction_error()}.
+extract_int(Node, Key) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Selected) -> case Selected of
+                {node_int, Value} ->
+                    {ok, Value};
+
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"int"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 299).
+?DOC(
+    " Extracts a float from a YAML node.\n"
+    " Also accepts integers and converts them to floats.\n"
+).
+-spec extract_float(node_(), binary()) -> {ok, float()} |
+    {error, extraction_error()}.
+extract_float(Node, Key) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Selected) -> case Selected of
+                {node_float, Value} ->
+                    {ok, Value};
+
+                {node_int, Value@1} ->
+                    {ok, erlang:float(Value@1)};
+
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"float"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 315).
+?DOC(" Extracts a boolean from a YAML node.\n").
+-spec extract_bool(node_(), binary()) -> {ok, boolean()} |
+    {error, extraction_error()}.
+extract_bool(Node, Key) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Selected) -> case Selected of
+                {node_bool, Value} ->
+                    {ok, Value};
+
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"bool"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 336).
+?DOC(
+    " Extracts an optional string from a YAML node.\n"
+    " Returns Ok(None) if the key is missing, Ok(Some(value)) if present.\n"
+    " Returns Error for type mismatches.\n"
+).
+-spec extract_optional_string(node_(), binary()) -> {ok,
+        gleam@option:option(binary())} |
+    {error, extraction_error()}.
+extract_optional_string(Node, Key) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, none};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_str, Value} ->
+                    {ok, {some, Value}};
+
+                node_nil ->
+                    {ok, none};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"string"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 359).
+?DOC(
+    " Extracts an optional integer from a YAML node.\n"
+    " Returns Ok(None) if the key is missing, Ok(Some(value)) if present.\n"
+    " Returns Error for type mismatches.\n"
+).
+-spec extract_optional_int(node_(), binary()) -> {ok,
+        gleam@option:option(integer())} |
+    {error, extraction_error()}.
+extract_optional_int(Node, Key) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, none};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_int, Value} ->
+                    {ok, {some, Value}};
+
+                node_nil ->
+                    {ok, none};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"int"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 383).
+?DOC(
+    " Extracts an optional float from a YAML node.\n"
+    " Returns Ok(None) if the key is missing, Ok(Some(value)) if present.\n"
+    " Also accepts integers and converts them to floats.\n"
+    " Returns Error for type mismatches.\n"
+).
+-spec extract_optional_float(node_(), binary()) -> {ok,
+        gleam@option:option(float())} |
+    {error, extraction_error()}.
+extract_optional_float(Node, Key) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, none};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_float, Value} ->
+                    {ok, {some, Value}};
+
+                {node_int, Value@1} ->
+                    {ok, {some, erlang:float(Value@1)}};
+
+                node_nil ->
+                    {ok, none};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"float"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 407).
+?DOC(
+    " Extracts an optional boolean from a YAML node.\n"
+    " Returns Ok(None) if the key is missing, Ok(Some(value)) if present.\n"
+    " Returns Error for type mismatches.\n"
+).
+-spec extract_optional_bool(node_(), binary()) -> {ok,
+        gleam@option:option(boolean())} |
+    {error, extraction_error()}.
+extract_optional_bool(Node, Key) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, none};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_bool, Value} ->
+                    {ok, {some, Value}};
+
+                node_nil ->
+                    {ok, none};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"bool"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 433).
+?DOC(
+    " Extracts a string from a YAML node, returning a default if the key is missing or nil.\n"
+    " Returns Error only for type mismatches.\n"
+).
+-spec extract_string_or(node_(), binary(), binary()) -> {ok, binary()} |
+    {error, extraction_error()}.
+extract_string_or(Node, Key, Default) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, Default};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_str, Value} ->
+                    {ok, Value};
+
+                node_nil ->
+                    {ok, Default};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"string"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 456).
+?DOC(
+    " Extracts an integer from a YAML node, returning a default if the key is missing or nil.\n"
+    " Returns Error only for type mismatches.\n"
+).
+-spec extract_int_or(node_(), binary(), integer()) -> {ok, integer()} |
+    {error, extraction_error()}.
+extract_int_or(Node, Key, Default) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, Default};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_int, Value} ->
+                    {ok, Value};
+
+                node_nil ->
+                    {ok, Default};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"int"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 480).
+?DOC(
+    " Extracts a float from a YAML node, returning a default if the key is missing or nil.\n"
+    " Also accepts integers and converts them to floats.\n"
+    " Returns Error only for type mismatches.\n"
+).
+-spec extract_float_or(node_(), binary(), float()) -> {ok, float()} |
+    {error, extraction_error()}.
+extract_float_or(Node, Key, Default) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, Default};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_float, Value} ->
+                    {ok, Value};
+
+                {node_int, Value@1} ->
+                    {ok, erlang:float(Value@1)};
+
+                node_nil ->
+                    {ok, Default};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"float"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 504).
+?DOC(
+    " Extracts a boolean from a YAML node, returning a default if the key is missing or nil.\n"
+    " Returns Error only for type mismatches.\n"
+).
+-spec extract_bool_or(node_(), binary(), boolean()) -> {ok, boolean()} |
+    {error, extraction_error()}.
+extract_bool_or(Node, Key, Default) ->
+    case select_sugar(Node, Key) of
+        {error, _} ->
+            {ok, Default};
+
+        {ok, Selected} ->
+            case Selected of
+                {node_bool, Value} ->
+                    {ok, Value};
+
+                node_nil ->
+                    {ok, Default};
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"bool"/utf8>>,
+                            node_type_name(Other)}}
+            end
+    end.
+
+-file("src/yay.gleam", 605).
+?DOC(" Helper to extract list items with index tracking for better error messages.\n").
+-spec extract_list_items(
+    list(node_()),
+    binary(),
+    binary(),
+    fun((node_()) -> {ok, EWS} | {error, nil}),
+    integer(),
+    list(EWS)
+) -> {ok, list(EWS)} | {error, extraction_error()}.
+extract_list_items(Items, Key, Item_type, Extract_item, Index, Acc) ->
+    case Items of
+        [] ->
+            {ok, lists:reverse(Acc)};
+
+        [Item | Rest] ->
+            case Extract_item(Item) of
+                {ok, Value} ->
+                    extract_list_items(
+                        Rest,
+                        Key,
+                        Item_type,
+                        Extract_item,
+                        Index + 1,
+                        [Value | Acc]
+                    );
+
+                {error, _} ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<<<"list of "/utf8, Item_type/binary>>/binary,
+                                "s"/utf8>>,
+                            <<<<<<"list containing "/utf8,
+                                        (node_type_name(Item))/binary>>/binary,
+                                    " at index "/utf8>>/binary,
+                                (erlang:integer_to_binary(Index))/binary>>}}
+            end
+    end.
+
+-file("src/yay.gleam", 584).
+?DOC(" Internal helper for extracting typed lists with index information in errors.\n").
+-spec extract_list(
+    node_(),
+    binary(),
+    binary(),
+    fun((node_()) -> {ok, EWL} | {error, nil})
+) -> {ok, list(EWL)} | {error, extraction_error()}.
+extract_list(Node, Key, Item_type, Extract_item) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(List_node) -> case List_node of
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                {node_seq, Items} ->
+                    extract_list_items(
+                        Items,
+                        Key,
+                        Item_type,
+                        Extract_item,
+                        0,
+                        []
+                    );
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"list"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 530).
+?DOC(" Extracts a list of strings from a YAML node.\n").
+-spec extract_string_list(node_(), binary()) -> {ok, list(binary())} |
+    {error, extraction_error()}.
+extract_string_list(Node, Key) ->
+    extract_list(Node, Key, <<"string"/utf8>>, fun(N) -> case N of
+                {node_str, S} ->
+                    {ok, S};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 543).
+?DOC(" Extracts a list of integers from a YAML node.\n").
+-spec extract_int_list(node_(), binary()) -> {ok, list(integer())} |
+    {error, extraction_error()}.
+extract_int_list(Node, Key) ->
+    extract_list(Node, Key, <<"int"/utf8>>, fun(N) -> case N of
+                {node_int, I} ->
+                    {ok, I};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 557).
+?DOC(
+    " Extracts a list of floats from a YAML node.\n"
+    " Also accepts integers and converts them to floats.\n"
+).
+-spec extract_float_list(node_(), binary()) -> {ok, list(float())} |
+    {error, extraction_error()}.
+extract_float_list(Node, Key) ->
+    extract_list(Node, Key, <<"float"/utf8>>, fun(N) -> case N of
+                {node_float, F} ->
+                    {ok, F};
+
+                {node_int, I} ->
+                    {ok, erlang:float(I)};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 571).
+?DOC(" Extracts a list of booleans from a YAML node.\n").
+-spec extract_bool_list(node_(), binary()) -> {ok, list(boolean())} |
+    {error, extraction_error()}.
+extract_bool_list(Node, Key) ->
+    extract_list(Node, Key, <<"bool"/utf8>>, fun(N) -> case N of
+                {node_bool, B} ->
+                    {ok, B};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 716).
+?DOC(" Helper to extract map entries with detailed error messages.\n").
+-spec extract_map_entries(
+    list({node_(), node_()}),
+    binary(),
+    binary(),
+    fun((node_()) -> {ok, EXX} | {error, nil}),
+    list({binary(), EXX})
+) -> {ok, list({binary(), EXX})} | {error, extraction_error()}.
+extract_map_entries(Entries, Key, Value_type, Extract_value, Acc) ->
+    case Entries of
+        [] ->
+            {ok, lists:reverse(Acc)};
+
+        [{{node_str, K}, Value_node} | Rest] ->
+            case Extract_value(Value_node) of
+                {ok, V} ->
+                    extract_map_entries(
+                        Rest,
+                        Key,
+                        Value_type,
+                        Extract_value,
+                        [{K, V} | Acc]
+                    );
+
+                {error, _} ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<<<"map of "/utf8, Value_type/binary>>/binary,
+                                "s"/utf8>>,
+                            <<<<<<<<"map with "/utf8,
+                                            (node_type_name(Value_node))/binary>>/binary,
+                                        " value at key '"/utf8>>/binary,
+                                    K/binary>>/binary,
+                                "'"/utf8>>}}
+            end;
+
+        [{Key_node, _} | _] ->
+            {error,
+                {key_type_mismatch,
+                    Key,
+                    <<<<"map of "/utf8, Value_type/binary>>/binary, "s"/utf8>>,
+                    <<<<"map with "/utf8, (node_type_name(Key_node))/binary>>/binary,
+                        " key"/utf8>>}}
+    end.
+
+-file("src/yay.gleam", 694).
+?DOC(" Internal helper for extracting typed maps with detailed error messages.\n").
+-spec extract_map(
+    node_(),
+    binary(),
+    binary(),
+    fun((node_()) -> {ok, EXP} | {error, nil})
+) -> {ok, gleam@dict:dict(binary(), EXP)} | {error, extraction_error()}.
+extract_map(Node, Key, Value_type, Extract_value) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Map_node) -> case Map_node of
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                {node_map, Entries} ->
+                    _pipe = extract_map_entries(
+                        Entries,
+                        Key,
+                        Value_type,
+                        Extract_value,
+                        []
+                    ),
+                    gleam@result:map(_pipe, fun maps:from_list/1);
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"map"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 640).
+?DOC(" Extracts a map of string values from a YAML node.\n").
+-spec extract_string_map(node_(), binary()) -> {ok,
+        gleam@dict:dict(binary(), binary())} |
+    {error, extraction_error()}.
+extract_string_map(Node, Key) ->
+    extract_map(Node, Key, <<"string"/utf8>>, fun(N) -> case N of
+                {node_str, S} ->
+                    {ok, S};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 653).
+?DOC(" Extracts a map of integer values from a YAML node.\n").
+-spec extract_int_map(node_(), binary()) -> {ok,
+        gleam@dict:dict(binary(), integer())} |
+    {error, extraction_error()}.
+extract_int_map(Node, Key) ->
+    extract_map(Node, Key, <<"int"/utf8>>, fun(N) -> case N of
+                {node_int, I} ->
+                    {ok, I};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 667).
+?DOC(
+    " Extracts a map of float values from a YAML node.\n"
+    " Also accepts integers and converts them to floats.\n"
+).
+-spec extract_float_map(node_(), binary()) -> {ok,
+        gleam@dict:dict(binary(), float())} |
+    {error, extraction_error()}.
+extract_float_map(Node, Key) ->
+    extract_map(Node, Key, <<"float"/utf8>>, fun(N) -> case N of
+                {node_float, F} ->
+                    {ok, F};
+
+                {node_int, I} ->
+                    {ok, erlang:float(I)};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 681).
+?DOC(" Extracts a map of boolean values from a YAML node.\n").
+-spec extract_bool_map(node_(), binary()) -> {ok,
+        gleam@dict:dict(binary(), boolean())} |
+    {error, extraction_error()}.
+extract_bool_map(Node, Key) ->
+    extract_map(Node, Key, <<"bool"/utf8>>, fun(N) -> case N of
+                {node_bool, B} ->
+                    {ok, B};
+
+                _ ->
+                    {error, nil}
+            end end).
+
+-file("src/yay.gleam", 873).
+?DOC(" Helper to extract the expected string from an ExtractionError.\n").
+-spec extraction_error_expected(extraction_error()) -> binary().
+extraction_error_expected(Err) ->
+    case Err of
+        {key_missing, _, _} ->
+            <<"value"/utf8>>;
+
+        {key_value_empty, _} ->
+            <<"non-empty value"/utf8>>;
+
+        {key_type_mismatch, _, Expected, _} ->
+            Expected;
+
+        {duplicate_keys_detected, _, _} ->
+            <<"unique keys"/utf8>>
+    end.
+
+-file("src/yay.gleam", 883).
+?DOC(" Helper to extract the found string from an ExtractionError.\n").
+-spec extraction_error_found(extraction_error()) -> binary().
+extraction_error_found(Err) ->
+    case Err of
+        {key_missing, K, _} ->
+            <<"missing key: "/utf8, K/binary>>;
+
+        {key_value_empty, _} ->
+            <<"nil"/utf8>>;
+
+        {key_type_mismatch, _, _, Found} ->
+            Found;
+
+        {duplicate_keys_detected, _, Keys} ->
+            <<"duplicate keys: "/utf8,
+                (gleam@string:join(Keys, <<", "/utf8>>))/binary>>
+    end.
+
+-file("src/yay.gleam", 785).
+?DOC(" Helper to extract list items with a custom extractor and index tracking.\n").
+-spec extract_list_items_with(
+    list(node_()),
+    binary(),
+    fun((node_()) -> {ok, EYL} | {error, extraction_error()}),
+    integer(),
+    list(EYL)
+) -> {ok, list(EYL)} | {error, extraction_error()}.
+extract_list_items_with(Items, Key, Item_extractor, Index, Acc) ->
+    case Items of
+        [] ->
+            {ok, lists:reverse(Acc)};
+
+        [Item | Rest] ->
+            case Item_extractor(Item) of
+                {ok, Value} ->
+                    extract_list_items_with(
+                        Rest,
+                        Key,
+                        Item_extractor,
+                        Index + 1,
+                        [Value | Acc]
+                    );
+
+                {error, Err} ->
+                    {error,
+                        {key_type_mismatch,
+                            <<<<Key/binary, ".#"/utf8>>/binary,
+                                (erlang:integer_to_binary(Index))/binary>>,
+                            extraction_error_expected(Err),
+                            extraction_error_found(Err)}}
+            end
+    end.
+
+-file("src/yay.gleam", 766).
+?DOC(
+    " Extracts a list using a custom item extractor function.\n"
+    " Useful for extracting nested containers like List(Dict(String, String)).\n"
+    "\n"
+    " ## Example\n"
+    " ```gleam\n"
+    " // Extract a list of string maps\n"
+    " extract_list_with(node, \"servers\", fn(item) {\n"
+    "   extract_string_map(item, \"\")\n"
+    " })\n"
+    " ```\n"
+).
+-spec extract_list_with(
+    node_(),
+    binary(),
+    fun((node_()) -> {ok, EYE} | {error, extraction_error()})
+) -> {ok, list(EYE)} | {error, extraction_error()}.
+extract_list_with(Node, Key, Item_extractor) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(List_node) -> case List_node of
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                {node_seq, Items} ->
+                    extract_list_items_with(Items, Key, Item_extractor, 0, []);
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"list"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 843).
+?DOC(" Helper to extract map entries with a custom value extractor.\n").
+-spec extract_map_entries_with(
+    list({node_(), node_()}),
+    binary(),
+    fun((node_()) -> {ok, EZA} | {error, extraction_error()}),
+    list({binary(), EZA})
+) -> {ok, list({binary(), EZA})} | {error, extraction_error()}.
+extract_map_entries_with(Entries, Key, Value_extractor, Acc) ->
+    case Entries of
+        [] ->
+            {ok, lists:reverse(Acc)};
+
+        [{{node_str, K}, Value_node} | Rest] ->
+            case Value_extractor(Value_node) of
+                {ok, V} ->
+                    extract_map_entries_with(
+                        Rest,
+                        Key,
+                        Value_extractor,
+                        [{K, V} | Acc]
+                    );
+
+                {error, Err} ->
+                    {error,
+                        {key_type_mismatch,
+                            <<<<Key/binary, "."/utf8>>/binary, K/binary>>,
+                            extraction_error_expected(Err),
+                            extraction_error_found(Err)}}
+            end;
+
+        [{Key_node, _} | _] ->
+            {error,
+                {key_type_mismatch,
+                    Key,
+                    <<"map with string keys"/utf8>>,
+                    <<<<"map with "/utf8, (node_type_name(Key_node))/binary>>/binary,
+                        " key"/utf8>>}}
+    end.
+
+-file("src/yay.gleam", 822).
+?DOC(
+    " Extracts a map using a custom value extractor function.\n"
+    " Useful for extracting nested containers like Dict(String, List(Int)).\n"
+    "\n"
+    " ## Example\n"
+    " ```gleam\n"
+    " // Extract a map of integer lists\n"
+    " extract_map_with(node, \"groups\", fn(item) {\n"
+    "   extract_int_list(item, \"\")\n"
+    " })\n"
+    " ```\n"
+).
+-spec extract_map_with(
+    node_(),
+    binary(),
+    fun((node_()) -> {ok, EYS} | {error, extraction_error()})
+) -> {ok, gleam@dict:dict(binary(), EYS)} | {error, extraction_error()}.
+extract_map_with(Node, Key, Value_extractor) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Map_node) -> case Map_node of
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                {node_map, Entries} ->
+                    _pipe = extract_map_entries_with(
+                        Entries,
+                        Key,
+                        Value_extractor,
+                        []
+                    ),
+                    gleam@result:map(_pipe, fun maps:from_list/1);
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"map"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).
+
+-file("src/yay.gleam", 897).
+-spec validate_no_duplicate_keys(
+    {ok, list({binary(), binary()})} | {error, extraction_error()},
+    binary(),
+    boolean()
+) -> {ok, list({binary(), binary()})} | {error, extraction_error()}.
+validate_no_duplicate_keys(Items_result, Key, Fail_on_key_duplication) ->
+    gleam@result:'try'(
+        Items_result,
+        fun(Items) -> case Fail_on_key_duplication of
+                false ->
+                    {ok, Items};
+
+                true ->
+                    {_, Duplicates@1} = gleam@list:fold(
+                        Items,
+                        {gleam@set:new(), gleam@set:new()},
+                        fun(Acc, Item) ->
+                            {Seen, Duplicates} = Acc,
+                            case gleam@set:contains(
+                                Seen,
+                                erlang:element(1, Item)
+                            ) of
+                                true ->
+                                    {Seen,
+                                        gleam@set:insert(
+                                            Duplicates,
+                                            erlang:element(1, Item)
+                                        )};
+
+                                false ->
+                                    {gleam@set:insert(
+                                            Seen,
+                                            erlang:element(1, Item)
+                                        ),
+                                        Duplicates}
+                            end
+                        end
+                    ),
+                    Dupes_list = begin
+                        _pipe = gleam@set:to_list(Duplicates@1),
+                        gleam@list:sort(_pipe, fun gleam@string:compare/2)
+                    end,
+                    case Dupes_list of
+                        [] ->
+                            {ok, Items};
+
+                        _ ->
+                            {error, {duplicate_keys_detected, Key, Dupes_list}}
+                    end
+            end end
+    ).
+
+-file("src/yay.gleam", 927).
+?DOC(" Extracts a string map with duplicate key detection.\n").
+-spec extract_string_map_with_duplicate_detection(node_(), binary(), boolean()) -> {ok,
+        gleam@dict:dict(binary(), binary())} |
+    {error, extraction_error()}.
+extract_string_map_with_duplicate_detection(Node, Key, Fail_on_key_duplication) ->
+    gleam@result:'try'(
+        select_or_missing(Node, Key),
+        fun(Dict_node) -> case Dict_node of
+                node_nil ->
+                    {error, {key_value_empty, Key}};
+
+                {node_map, Entries} ->
+                    _pipe = Entries,
+                    _pipe@1 = gleam@list:try_map(
+                        _pipe,
+                        fun(Entry) -> case Entry of
+                                {{node_str, Dict_key}, {node_str, Value}} ->
+                                    {ok, {Dict_key, Value}};
+
+                                {{node_str, Dict_key@1}, Value_node} ->
+                                    {error,
+                                        {key_type_mismatch,
+                                            Key,
+                                            <<"map of strings"/utf8>>,
+                                            <<<<<<<<"map with "/utf8,
+                                                            (node_type_name(
+                                                                Value_node
+                                                            ))/binary>>/binary,
+                                                        " value at key '"/utf8>>/binary,
+                                                    Dict_key@1/binary>>/binary,
+                                                "'"/utf8>>}};
+
+                                {Key_node, _} ->
+                                    {error,
+                                        {key_type_mismatch,
+                                            Key,
+                                            <<"map of strings"/utf8>>,
+                                            <<<<"map with "/utf8,
+                                                    (node_type_name(Key_node))/binary>>/binary,
+                                                " key"/utf8>>}}
+                            end end
+                    ),
+                    _pipe@2 = validate_no_duplicate_keys(
+                        _pipe@1,
+                        Key,
+                        Fail_on_key_duplication
+                    ),
+                    gleam@result:map(_pipe@2, fun maps:from_list/1);
+
+                Other ->
+                    {error,
+                        {key_type_mismatch,
+                            Key,
+                            <<"map"/utf8>>,
+                            node_type_name(Other)}}
+            end end
+    ).