skill-universe 1.1.0

package/build/dev/javascript/yay/yay.mjs

@@ -0,0 +1,1403 @@
+import * as $dict from "../gleam_stdlib/gleam/dict.mjs";
+import * as $int from "../gleam_stdlib/gleam/int.mjs";
+import * as $list from "../gleam_stdlib/gleam/list.mjs";
+import * as $option from "../gleam_stdlib/gleam/option.mjs";
+import * as $result from "../gleam_stdlib/gleam/result.mjs";
+import * as $set from "../gleam_stdlib/gleam/set.mjs";
+import * as $string from "../gleam_stdlib/gleam/string.mjs";
+import {
+  Ok,
+  Error,
+  toList,
+  Empty as $Empty,
+  prepend as listPrepend,
+  CustomType as $CustomType,
+} from "./gleam.mjs";
+import { parse_file, parse_string } from "./yaml_ffi.mjs";
+
+export { parse_file, parse_string };
+
+export class UnexpectedParsingError extends $CustomType {}
+export const YamlError$UnexpectedParsingError = () =>
+  new UnexpectedParsingError();
+export const YamlError$isUnexpectedParsingError = (value) =>
+  value instanceof UnexpectedParsingError;
+
+export class ParsingError extends $CustomType {
+  constructor(msg, loc) {
+    super();
+    this.msg = msg;
+    this.loc = loc;
+  }
+}
+export const YamlError$ParsingError = (msg, loc) => new ParsingError(msg, loc);
+export const YamlError$isParsingError = (value) =>
+  value instanceof ParsingError;
+export const YamlError$ParsingError$msg = (value) => value.msg;
+export const YamlError$ParsingError$0 = (value) => value.msg;
+export const YamlError$ParsingError$loc = (value) => value.loc;
+export const YamlError$ParsingError$1 = (value) => value.loc;
+
+export class YamlErrorLoc extends $CustomType {
+  constructor(line, column) {
+    super();
+    this.line = line;
+    this.column = column;
+  }
+}
+export const YamlErrorLoc$YamlErrorLoc = (line, column) =>
+  new YamlErrorLoc(line, column);
+export const YamlErrorLoc$isYamlErrorLoc = (value) =>
+  value instanceof YamlErrorLoc;
+export const YamlErrorLoc$YamlErrorLoc$line = (value) => value.line;
+export const YamlErrorLoc$YamlErrorLoc$0 = (value) => value.line;
+export const YamlErrorLoc$YamlErrorLoc$column = (value) => value.column;
+export const YamlErrorLoc$YamlErrorLoc$1 = (value) => value.column;
+
+export class Document extends $CustomType {
+  constructor(root) {
+    super();
+    this.root = root;
+  }
+}
+export const Document$Document = (root) => new Document(root);
+export const Document$isDocument = (value) => value instanceof Document;
+export const Document$Document$root = (value) => value.root;
+export const Document$Document$0 = (value) => value.root;
+
+export class NodeNil extends $CustomType {}
+export const Node$NodeNil = () => new NodeNil();
+export const Node$isNodeNil = (value) => value instanceof NodeNil;
+
+export class NodeStr extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Node$NodeStr = ($0) => new NodeStr($0);
+export const Node$isNodeStr = (value) => value instanceof NodeStr;
+export const Node$NodeStr$0 = (value) => value[0];
+
+export class NodeBool extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Node$NodeBool = ($0) => new NodeBool($0);
+export const Node$isNodeBool = (value) => value instanceof NodeBool;
+export const Node$NodeBool$0 = (value) => value[0];
+
+export class NodeInt extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Node$NodeInt = ($0) => new NodeInt($0);
+export const Node$isNodeInt = (value) => value instanceof NodeInt;
+export const Node$NodeInt$0 = (value) => value[0];
+
+export class NodeFloat extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Node$NodeFloat = ($0) => new NodeFloat($0);
+export const Node$isNodeFloat = (value) => value instanceof NodeFloat;
+export const Node$NodeFloat$0 = (value) => value[0];
+
+export class NodeSeq extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Node$NodeSeq = ($0) => new NodeSeq($0);
+export const Node$isNodeSeq = (value) => value instanceof NodeSeq;
+export const Node$NodeSeq$0 = (value) => value[0];
+
+export class NodeMap extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Node$NodeMap = ($0) => new NodeMap($0);
+export const Node$isNodeMap = (value) => value instanceof NodeMap;
+export const Node$NodeMap$0 = (value) => value[0];
+
+export class Selector extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Selector$Selector = ($0) => new Selector($0);
+export const Selector$isSelector = (value) => value instanceof Selector;
+export const Selector$Selector$0 = (value) => value[0];
+
+export class SelectMap extends $CustomType {
+  constructor(key) {
+    super();
+    this.key = key;
+  }
+}
+export const Selection$SelectMap = (key) => new SelectMap(key);
+export const Selection$isSelectMap = (value) => value instanceof SelectMap;
+export const Selection$SelectMap$key = (value) => value.key;
+export const Selection$SelectMap$0 = (value) => value.key;
+
+export class SelectSeq extends $CustomType {
+  constructor(index) {
+    super();
+    this.index = index;
+  }
+}
+export const Selection$SelectSeq = (index) => new SelectSeq(index);
+export const Selection$isSelectSeq = (value) => value instanceof SelectSeq;
+export const Selection$SelectSeq$index = (value) => value.index;
+export const Selection$SelectSeq$0 = (value) => value.index;
+
+export class NodeNotFound extends $CustomType {
+  constructor(at) {
+    super();
+    this.at = at;
+  }
+}
+export const SelectorError$NodeNotFound = (at) => new NodeNotFound(at);
+export const SelectorError$isNodeNotFound = (value) =>
+  value instanceof NodeNotFound;
+export const SelectorError$NodeNotFound$at = (value) => value.at;
+export const SelectorError$NodeNotFound$0 = (value) => value.at;
+
+export class SelectorParseError extends $CustomType {}
+export const SelectorError$SelectorParseError = () => new SelectorParseError();
+export const SelectorError$isSelectorParseError = (value) =>
+  value instanceof SelectorParseError;
+
+export class KeyMissing extends $CustomType {
+  constructor(key, failed_at_segment) {
+    super();
+    this.key = key;
+    this.failed_at_segment = failed_at_segment;
+  }
+}
+export const ExtractionError$KeyMissing = (key, failed_at_segment) =>
+  new KeyMissing(key, failed_at_segment);
+export const ExtractionError$isKeyMissing = (value) =>
+  value instanceof KeyMissing;
+export const ExtractionError$KeyMissing$key = (value) => value.key;
+export const ExtractionError$KeyMissing$0 = (value) => value.key;
+export const ExtractionError$KeyMissing$failed_at_segment = (value) =>
+  value.failed_at_segment;
+export const ExtractionError$KeyMissing$1 = (value) => value.failed_at_segment;
+
+export class KeyValueEmpty extends $CustomType {
+  constructor(key) {
+    super();
+    this.key = key;
+  }
+}
+export const ExtractionError$KeyValueEmpty = (key) => new KeyValueEmpty(key);
+export const ExtractionError$isKeyValueEmpty = (value) =>
+  value instanceof KeyValueEmpty;
+export const ExtractionError$KeyValueEmpty$key = (value) => value.key;
+export const ExtractionError$KeyValueEmpty$0 = (value) => value.key;
+
+export class KeyTypeMismatch extends $CustomType {
+  constructor(key, expected, found) {
+    super();
+    this.key = key;
+    this.expected = expected;
+    this.found = found;
+  }
+}
+export const ExtractionError$KeyTypeMismatch = (key, expected, found) =>
+  new KeyTypeMismatch(key, expected, found);
+export const ExtractionError$isKeyTypeMismatch = (value) =>
+  value instanceof KeyTypeMismatch;
+export const ExtractionError$KeyTypeMismatch$key = (value) => value.key;
+export const ExtractionError$KeyTypeMismatch$0 = (value) => value.key;
+export const ExtractionError$KeyTypeMismatch$expected = (value) =>
+  value.expected;
+export const ExtractionError$KeyTypeMismatch$1 = (value) => value.expected;
+export const ExtractionError$KeyTypeMismatch$found = (value) => value.found;
+export const ExtractionError$KeyTypeMismatch$2 = (value) => value.found;
+
+export class DuplicateKeysDetected extends $CustomType {
+  constructor(key, keys) {
+    super();
+    this.key = key;
+    this.keys = keys;
+  }
+}
+export const ExtractionError$DuplicateKeysDetected = (key, keys) =>
+  new DuplicateKeysDetected(key, keys);
+export const ExtractionError$isDuplicateKeysDetected = (value) =>
+  value instanceof DuplicateKeysDetected;
+export const ExtractionError$DuplicateKeysDetected$key = (value) => value.key;
+export const ExtractionError$DuplicateKeysDetected$0 = (value) => value.key;
+export const ExtractionError$DuplicateKeysDetected$keys = (value) => value.keys;
+export const ExtractionError$DuplicateKeysDetected$1 = (value) => value.keys;
+
+export const ExtractionError$key = (value) => value.key;
+
+/**
+ * Gets the root `Node` of a YAML document.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let document = Document(root: NodeNil)
+ * let assert NodeNil = document_root(document)
+ * ```
+ */
+export function document_root(document) {
+  return document.root;
+}
+
+function list_at(loop$l, loop$index) {
+  while (true) {
+    let l = loop$l;
+    let index = loop$index;
+    if (l instanceof $Empty) {
+      return new $option.None();
+    } else {
+      let head = l.head;
+      let tail = l.tail;
+      if (index === 0) {
+        return new $option.Some(head);
+      } else {
+        loop$l = tail;
+        loop$index = index - 1;
+      }
+    }
+  }
+}
+
+function do_select(loop$node, loop$selector, loop$select_idx) {
+  while (true) {
+    let node = loop$node;
+    let selector = loop$selector;
+    let select_idx = loop$select_idx;
+    let $ = selector[0];
+    if ($ instanceof $Empty) {
+      return new Ok(node);
+    } else {
+      let select$1 = $.head;
+      let selector_tail = $.tail;
+      if (select$1 instanceof SelectMap) {
+        let key = select$1.key;
+        if (node instanceof NodeMap) {
+          let pairs = node[0];
+          let $1 = $list.key_find(pairs, key);
+          if ($1 instanceof Ok) {
+            let node$1 = $1[0];
+            loop$node = node$1;
+            loop$selector = new Selector(selector_tail);
+            loop$select_idx = select_idx + 1;
+          } else {
+            return new Error(new NodeNotFound(select_idx));
+          }
+        } else {
+          return new Error(new NodeNotFound(select_idx));
+        }
+      } else {
+        let index = select$1.index;
+        if (node instanceof NodeSeq) {
+          let seq = node[0];
+          let $1 = list_at(seq, index);
+          if ($1 instanceof $option.Some) {
+            let node$1 = $1[0];
+            loop$node = node$1;
+            loop$selector = new Selector(selector_tail);
+            loop$select_idx = select_idx + 1;
+          } else {
+            return new Error(new NodeNotFound(select_idx));
+          }
+        } else {
+          return new Error(new NodeNotFound(select_idx));
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Queries the given `node` with a `Selector`.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let map = NodeMap([
+ *   #(NodeStr("lib name"), NodeStr("yay")),
+ *   #(NodeStr("stars"), NodeInt(7)),
+ * ])
+ *
+ * let assert Ok(NodeInt(7)) = select(from: map, selector: Selector([SelectMap(NodeStr("stars"))]))
+ * ```
+ */
+export function select(node, selector) {
+  return do_select(node, selector, 0);
+}
+
+function do_parse_selector(loop$selector_parts, loop$acc) {
+  while (true) {
+    let selector_parts = loop$selector_parts;
+    let acc = loop$acc;
+    if (selector_parts instanceof $Empty) {
+      return new Ok(acc);
+    } else {
+      let $ = selector_parts.head;
+      if ($ === "") {
+        let tail = selector_parts.tail;
+        loop$selector_parts = tail;
+        loop$acc = acc;
+      } else {
+        let part = $;
+        let tail = selector_parts.tail;
+        let $1 = $string.starts_with(part, "#");
+        if ($1) {
+          let $2 = $int.parse($string.drop_start(part, 1));
+          if ($2 instanceof Ok) {
+            let index = $2[0];
+            loop$selector_parts = tail;
+            loop$acc = listPrepend(new SelectSeq(index), acc);
+          } else {
+            return new Error(new SelectorParseError());
+          }
+        } else {
+          loop$selector_parts = tail;
+          loop$acc = listPrepend(new SelectMap(new NodeStr(part)), acc);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Parses a selector string into a `Selector`.
+ */
+export function parse_selector(selector) {
+  return $result.try$(
+    do_parse_selector($string.split(selector, "."), toList([])),
+    (selections) => { return new Ok(new Selector($list.reverse(selections))); },
+  );
+}
+
+/**
+ * Parses the `selector` and queries the given `node` with it.
+ *
+ * ## Examples
+ *
+ * ```gleam
+ * let map = NodeMap([
+ *   #(NodeStr("list"), NodeMap([
+ *     #(NodeStr("elements"), NodeSeq([NodeInt(101)]))
+ *   ])),
+ *   #(NodeStr("linked"), NodeBool(False)),
+ * ])
+ *
+ * let assert Ok(NodeInt(101)) = select_sugar(from: map, selector: "list.elements.#0")
+ * ```
+ */
+export function select_sugar(node, selector) {
+  return $result.try$(
+    parse_selector(selector),
+    (selector) => { return select(node, selector); },
+  );
+}
+
+/**
+ * Converts an ExtractionError to a human-readable string.
+ */
+export function extraction_error_to_string(error) {
+  if (error instanceof KeyMissing) {
+    let key = error.key;
+    let failed_at_segment = error.failed_at_segment;
+    return ((("Missing " + key) + " (failed at segment ") + $int.to_string(
+      failed_at_segment,
+    )) + ")";
+  } else if (error instanceof KeyValueEmpty) {
+    let key = error.key;
+    return ("Expected " + key) + " to be non-empty";
+  } else if (error instanceof KeyTypeMismatch) {
+    let key = error.key;
+    let expected = error.expected;
+    let found = error.found;
+    return (((("Expected " + key) + " to be a ") + expected) + ", but found ") + found;
+  } else {
+    let key = error.key;
+    let keys = error.keys;
+    return (("Duplicate keys detected for " + key) + ": ") + $string.join(
+      keys,
+      ", ",
+    );
+  }
+}
+
+/**
+ * Converts a Node to a human-readable type name.
+ * 
+ * @ignore
+ */
+function node_type_name(node) {
+  if (node instanceof NodeNil) {
+    return "nil";
+  } else if (node instanceof NodeStr) {
+    return "string";
+  } else if (node instanceof NodeBool) {
+    return "bool";
+  } else if (node instanceof NodeInt) {
+    return "int";
+  } else if (node instanceof NodeFloat) {
+    return "float";
+  } else if (node instanceof NodeSeq) {
+    return "list";
+  } else {
+    return "map";
+  }
+}
+
+/**
+ * Internal helper to select a node or return KeyMissing with position info.
+ * 
+ * @ignore
+ */
+function select_or_missing(node, key) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    return $;
+  } else {
+    let $1 = $[0];
+    if ($1 instanceof NodeNotFound) {
+      let at = $1.at;
+      return new Error(new KeyMissing(key, at));
+    } else {
+      return new Error(new KeyMissing(key, 0));
+    }
+  }
+}
+
+/**
+ * Extracts a string from a YAML node.
+ */
+export function extract_string(node, key) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (selected) => {
+      if (selected instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (selected instanceof NodeStr) {
+        let value = selected[0];
+        return new Ok(value);
+      } else {
+        let other = selected;
+        return new Error(
+          new KeyTypeMismatch(key, "string", node_type_name(other)),
+        );
+      }
+    },
+  );
+}
+
+/**
+ * Extracts an integer from a YAML node.
+ */
+export function extract_int(node, key) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (selected) => {
+      if (selected instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (selected instanceof NodeInt) {
+        let value = selected[0];
+        return new Ok(value);
+      } else {
+        let other = selected;
+        return new Error(new KeyTypeMismatch(key, "int", node_type_name(other)));
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a float from a YAML node.
+ * Also accepts integers and converts them to floats.
+ */
+export function extract_float(node, key) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (selected) => {
+      if (selected instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (selected instanceof NodeInt) {
+        let value = selected[0];
+        return new Ok($int.to_float(value));
+      } else if (selected instanceof NodeFloat) {
+        let value = selected[0];
+        return new Ok(value);
+      } else {
+        let other = selected;
+        return new Error(
+          new KeyTypeMismatch(key, "float", node_type_name(other)),
+        );
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a boolean from a YAML node.
+ */
+export function extract_bool(node, key) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (selected) => {
+      if (selected instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (selected instanceof NodeBool) {
+        let value = selected[0];
+        return new Ok(value);
+      } else {
+        let other = selected;
+        return new Error(
+          new KeyTypeMismatch(key, "bool", node_type_name(other)),
+        );
+      }
+    },
+  );
+}
+
+/**
+ * Extracts an optional string from a YAML node.
+ * Returns Ok(None) if the key is missing, Ok(Some(value)) if present.
+ * Returns Error for type mismatches.
+ */
+export function extract_optional_string(node, key) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(new $option.None());
+    } else if (selected instanceof NodeStr) {
+      let value = selected[0];
+      return new Ok(new $option.Some(value));
+    } else {
+      let other = selected;
+      return new Error(
+        new KeyTypeMismatch(key, "string", node_type_name(other)),
+      );
+    }
+  } else {
+    return new Ok(new $option.None());
+  }
+}
+
+/**
+ * Extracts an optional integer from a YAML node.
+ * Returns Ok(None) if the key is missing, Ok(Some(value)) if present.
+ * Returns Error for type mismatches.
+ */
+export function extract_optional_int(node, key) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(new $option.None());
+    } else if (selected instanceof NodeInt) {
+      let value = selected[0];
+      return new Ok(new $option.Some(value));
+    } else {
+      let other = selected;
+      return new Error(new KeyTypeMismatch(key, "int", node_type_name(other)));
+    }
+  } else {
+    return new Ok(new $option.None());
+  }
+}
+
+/**
+ * Extracts an optional float from a YAML node.
+ * Returns Ok(None) if the key is missing, Ok(Some(value)) if present.
+ * Also accepts integers and converts them to floats.
+ * Returns Error for type mismatches.
+ */
+export function extract_optional_float(node, key) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(new $option.None());
+    } else if (selected instanceof NodeInt) {
+      let value = selected[0];
+      return new Ok(new $option.Some($int.to_float(value)));
+    } else if (selected instanceof NodeFloat) {
+      let value = selected[0];
+      return new Ok(new $option.Some(value));
+    } else {
+      let other = selected;
+      return new Error(new KeyTypeMismatch(key, "float", node_type_name(other)));
+    }
+  } else {
+    return new Ok(new $option.None());
+  }
+}
+
+/**
+ * Extracts an optional boolean from a YAML node.
+ * Returns Ok(None) if the key is missing, Ok(Some(value)) if present.
+ * Returns Error for type mismatches.
+ */
+export function extract_optional_bool(node, key) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(new $option.None());
+    } else if (selected instanceof NodeBool) {
+      let value = selected[0];
+      return new Ok(new $option.Some(value));
+    } else {
+      let other = selected;
+      return new Error(new KeyTypeMismatch(key, "bool", node_type_name(other)));
+    }
+  } else {
+    return new Ok(new $option.None());
+  }
+}
+
+/**
+ * Extracts a string from a YAML node, returning a default if the key is missing or nil.
+ * Returns Error only for type mismatches.
+ */
+export function extract_string_or(node, key, default$) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(default$);
+    } else if (selected instanceof NodeStr) {
+      let value = selected[0];
+      return new Ok(value);
+    } else {
+      let other = selected;
+      return new Error(
+        new KeyTypeMismatch(key, "string", node_type_name(other)),
+      );
+    }
+  } else {
+    return new Ok(default$);
+  }
+}
+
+/**
+ * Extracts an integer from a YAML node, returning a default if the key is missing or nil.
+ * Returns Error only for type mismatches.
+ */
+export function extract_int_or(node, key, default$) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(default$);
+    } else if (selected instanceof NodeInt) {
+      let value = selected[0];
+      return new Ok(value);
+    } else {
+      let other = selected;
+      return new Error(new KeyTypeMismatch(key, "int", node_type_name(other)));
+    }
+  } else {
+    return new Ok(default$);
+  }
+}
+
+/**
+ * Extracts a float from a YAML node, returning a default if the key is missing or nil.
+ * Also accepts integers and converts them to floats.
+ * Returns Error only for type mismatches.
+ */
+export function extract_float_or(node, key, default$) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(default$);
+    } else if (selected instanceof NodeInt) {
+      let value = selected[0];
+      return new Ok($int.to_float(value));
+    } else if (selected instanceof NodeFloat) {
+      let value = selected[0];
+      return new Ok(value);
+    } else {
+      let other = selected;
+      return new Error(new KeyTypeMismatch(key, "float", node_type_name(other)));
+    }
+  } else {
+    return new Ok(default$);
+  }
+}
+
+/**
+ * Extracts a boolean from a YAML node, returning a default if the key is missing or nil.
+ * Returns Error only for type mismatches.
+ */
+export function extract_bool_or(node, key, default$) {
+  let $ = select_sugar(node, key);
+  if ($ instanceof Ok) {
+    let selected = $[0];
+    if (selected instanceof NodeNil) {
+      return new Ok(default$);
+    } else if (selected instanceof NodeBool) {
+      let value = selected[0];
+      return new Ok(value);
+    } else {
+      let other = selected;
+      return new Error(new KeyTypeMismatch(key, "bool", node_type_name(other)));
+    }
+  } else {
+    return new Ok(default$);
+  }
+}
+
+/**
+ * Helper to extract list items with index tracking for better error messages.
+ * 
+ * @ignore
+ */
+function extract_list_items(
+  loop$items,
+  loop$key,
+  loop$item_type,
+  loop$extract_item,
+  loop$index,
+  loop$acc
+) {
+  while (true) {
+    let items = loop$items;
+    let key = loop$key;
+    let item_type = loop$item_type;
+    let extract_item = loop$extract_item;
+    let index = loop$index;
+    let acc = loop$acc;
+    if (items instanceof $Empty) {
+      return new Ok($list.reverse(acc));
+    } else {
+      let item = items.head;
+      let rest = items.tail;
+      let $ = extract_item(item);
+      if ($ instanceof Ok) {
+        let value = $[0];
+        loop$items = rest;
+        loop$key = key;
+        loop$item_type = item_type;
+        loop$extract_item = extract_item;
+        loop$index = index + 1;
+        loop$acc = listPrepend(value, acc);
+      } else {
+        return new Error(
+          new KeyTypeMismatch(
+            key,
+            ("list of " + item_type) + "s",
+            (("list containing " + node_type_name(item)) + " at index ") + $int.to_string(
+              index,
+            ),
+          ),
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Internal helper for extracting typed lists with index information in errors.
+ * 
+ * @ignore
+ */
+function extract_list(node, key, item_type, extract_item) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (list_node) => {
+      if (list_node instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (list_node instanceof NodeSeq) {
+        let items = list_node[0];
+        return extract_list_items(
+          items,
+          key,
+          item_type,
+          extract_item,
+          0,
+          toList([]),
+        );
+      } else {
+        let other = list_node;
+        return new Error(
+          new KeyTypeMismatch(key, "list", node_type_name(other)),
+        );
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a list of strings from a YAML node.
+ */
+export function extract_string_list(node, key) {
+  return extract_list(
+    node,
+    key,
+    "string",
+    (n) => {
+      if (n instanceof NodeStr) {
+        let s = n[0];
+        return new Ok(s);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a list of integers from a YAML node.
+ */
+export function extract_int_list(node, key) {
+  return extract_list(
+    node,
+    key,
+    "int",
+    (n) => {
+      if (n instanceof NodeInt) {
+        let i = n[0];
+        return new Ok(i);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a list of floats from a YAML node.
+ * Also accepts integers and converts them to floats.
+ */
+export function extract_float_list(node, key) {
+  return extract_list(
+    node,
+    key,
+    "float",
+    (n) => {
+      if (n instanceof NodeInt) {
+        let i = n[0];
+        return new Ok($int.to_float(i));
+      } else if (n instanceof NodeFloat) {
+        let f = n[0];
+        return new Ok(f);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a list of booleans from a YAML node.
+ */
+export function extract_bool_list(node, key) {
+  return extract_list(
+    node,
+    key,
+    "bool",
+    (n) => {
+      if (n instanceof NodeBool) {
+        let b = n[0];
+        return new Ok(b);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Helper to extract map entries with detailed error messages.
+ * 
+ * @ignore
+ */
+function extract_map_entries(
+  loop$entries,
+  loop$key,
+  loop$value_type,
+  loop$extract_value,
+  loop$acc
+) {
+  while (true) {
+    let entries = loop$entries;
+    let key = loop$key;
+    let value_type = loop$value_type;
+    let extract_value = loop$extract_value;
+    let acc = loop$acc;
+    if (entries instanceof $Empty) {
+      return new Ok($list.reverse(acc));
+    } else {
+      let $ = entries.head[0];
+      if ($ instanceof NodeStr) {
+        let rest = entries.tail;
+        let value_node = entries.head[1];
+        let k = $[0];
+        let $1 = extract_value(value_node);
+        if ($1 instanceof Ok) {
+          let v = $1[0];
+          loop$entries = rest;
+          loop$key = key;
+          loop$value_type = value_type;
+          loop$extract_value = extract_value;
+          loop$acc = listPrepend([k, v], acc);
+        } else {
+          return new Error(
+            new KeyTypeMismatch(
+              key,
+              ("map of " + value_type) + "s",
+              ((("map with " + node_type_name(value_node)) + " value at key '") + k) + "'",
+            ),
+          );
+        }
+      } else {
+        let key_node = $;
+        return new Error(
+          new KeyTypeMismatch(
+            key,
+            ("map of " + value_type) + "s",
+            ("map with " + node_type_name(key_node)) + " key",
+          ),
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Internal helper for extracting typed maps with detailed error messages.
+ * 
+ * @ignore
+ */
+function extract_map(node, key, value_type, extract_value) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (map_node) => {
+      if (map_node instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (map_node instanceof NodeMap) {
+        let entries = map_node[0];
+        let _pipe = extract_map_entries(
+          entries,
+          key,
+          value_type,
+          extract_value,
+          toList([]),
+        );
+        return $result.map(_pipe, $dict.from_list);
+      } else {
+        let other = map_node;
+        return new Error(new KeyTypeMismatch(key, "map", node_type_name(other)));
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a map of string values from a YAML node.
+ */
+export function extract_string_map(node, key) {
+  return extract_map(
+    node,
+    key,
+    "string",
+    (n) => {
+      if (n instanceof NodeStr) {
+        let s = n[0];
+        return new Ok(s);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a map of integer values from a YAML node.
+ */
+export function extract_int_map(node, key) {
+  return extract_map(
+    node,
+    key,
+    "int",
+    (n) => {
+      if (n instanceof NodeInt) {
+        let i = n[0];
+        return new Ok(i);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a map of float values from a YAML node.
+ * Also accepts integers and converts them to floats.
+ */
+export function extract_float_map(node, key) {
+  return extract_map(
+    node,
+    key,
+    "float",
+    (n) => {
+      if (n instanceof NodeInt) {
+        let i = n[0];
+        return new Ok($int.to_float(i));
+      } else if (n instanceof NodeFloat) {
+        let f = n[0];
+        return new Ok(f);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a map of boolean values from a YAML node.
+ */
+export function extract_bool_map(node, key) {
+  return extract_map(
+    node,
+    key,
+    "bool",
+    (n) => {
+      if (n instanceof NodeBool) {
+        let b = n[0];
+        return new Ok(b);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+/**
+ * Helper to extract the expected string from an ExtractionError.
+ * 
+ * @ignore
+ */
+function extraction_error_expected(err) {
+  if (err instanceof KeyMissing) {
+    return "value";
+  } else if (err instanceof KeyValueEmpty) {
+    return "non-empty value";
+  } else if (err instanceof KeyTypeMismatch) {
+    let expected = err.expected;
+    return expected;
+  } else {
+    return "unique keys";
+  }
+}
+
+/**
+ * Helper to extract the found string from an ExtractionError.
+ * 
+ * @ignore
+ */
+function extraction_error_found(err) {
+  if (err instanceof KeyMissing) {
+    let k = err.key;
+    return "missing key: " + k;
+  } else if (err instanceof KeyValueEmpty) {
+    return "nil";
+  } else if (err instanceof KeyTypeMismatch) {
+    let found = err.found;
+    return found;
+  } else {
+    let keys = err.keys;
+    return "duplicate keys: " + $string.join(keys, ", ");
+  }
+}
+
+/**
+ * Helper to extract list items with a custom extractor and index tracking.
+ * 
+ * @ignore
+ */
+function extract_list_items_with(
+  loop$items,
+  loop$key,
+  loop$item_extractor,
+  loop$index,
+  loop$acc
+) {
+  while (true) {
+    let items = loop$items;
+    let key = loop$key;
+    let item_extractor = loop$item_extractor;
+    let index = loop$index;
+    let acc = loop$acc;
+    if (items instanceof $Empty) {
+      return new Ok($list.reverse(acc));
+    } else {
+      let item = items.head;
+      let rest = items.tail;
+      let $ = item_extractor(item);
+      if ($ instanceof Ok) {
+        let value = $[0];
+        loop$items = rest;
+        loop$key = key;
+        loop$item_extractor = item_extractor;
+        loop$index = index + 1;
+        loop$acc = listPrepend(value, acc);
+      } else {
+        let err = $[0];
+        return new Error(
+          new KeyTypeMismatch(
+            (key + ".#") + $int.to_string(index),
+            extraction_error_expected(err),
+            extraction_error_found(err),
+          ),
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Extracts a list using a custom item extractor function.
+ * Useful for extracting nested containers like List(Dict(String, String)).
+ *
+ * ## Example
+ * ```gleam
+ * // Extract a list of string maps
+ * extract_list_with(node, "servers", fn(item) {
+ *   extract_string_map(item, "")
+ * })
+ * ```
+ */
+export function extract_list_with(node, key, item_extractor) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (list_node) => {
+      if (list_node instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (list_node instanceof NodeSeq) {
+        let items = list_node[0];
+        return extract_list_items_with(
+          items,
+          key,
+          item_extractor,
+          0,
+          toList([]),
+        );
+      } else {
+        let other = list_node;
+        return new Error(
+          new KeyTypeMismatch(key, "list", node_type_name(other)),
+        );
+      }
+    },
+  );
+}
+
+/**
+ * Helper to extract map entries with a custom value extractor.
+ * 
+ * @ignore
+ */
+function extract_map_entries_with(
+  loop$entries,
+  loop$key,
+  loop$value_extractor,
+  loop$acc
+) {
+  while (true) {
+    let entries = loop$entries;
+    let key = loop$key;
+    let value_extractor = loop$value_extractor;
+    let acc = loop$acc;
+    if (entries instanceof $Empty) {
+      return new Ok($list.reverse(acc));
+    } else {
+      let $ = entries.head[0];
+      if ($ instanceof NodeStr) {
+        let rest = entries.tail;
+        let value_node = entries.head[1];
+        let k = $[0];
+        let $1 = value_extractor(value_node);
+        if ($1 instanceof Ok) {
+          let v = $1[0];
+          loop$entries = rest;
+          loop$key = key;
+          loop$value_extractor = value_extractor;
+          loop$acc = listPrepend([k, v], acc);
+        } else {
+          let err = $1[0];
+          return new Error(
+            new KeyTypeMismatch(
+              (key + ".") + k,
+              extraction_error_expected(err),
+              extraction_error_found(err),
+            ),
+          );
+        }
+      } else {
+        let key_node = $;
+        return new Error(
+          new KeyTypeMismatch(
+            key,
+            "map with string keys",
+            ("map with " + node_type_name(key_node)) + " key",
+          ),
+        );
+      }
+    }
+  }
+}
+
+/**
+ * Extracts a map using a custom value extractor function.
+ * Useful for extracting nested containers like Dict(String, List(Int)).
+ *
+ * ## Example
+ * ```gleam
+ * // Extract a map of integer lists
+ * extract_map_with(node, "groups", fn(item) {
+ *   extract_int_list(item, "")
+ * })
+ * ```
+ */
+export function extract_map_with(node, key, value_extractor) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (map_node) => {
+      if (map_node instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (map_node instanceof NodeMap) {
+        let entries = map_node[0];
+        let _pipe = extract_map_entries_with(
+          entries,
+          key,
+          value_extractor,
+          toList([]),
+        );
+        return $result.map(_pipe, $dict.from_list);
+      } else {
+        let other = map_node;
+        return new Error(new KeyTypeMismatch(key, "map", node_type_name(other)));
+      }
+    },
+  );
+}
+
+function validate_no_duplicate_keys(items_result, key, fail_on_key_duplication) {
+  return $result.try$(
+    items_result,
+    (items) => {
+      if (fail_on_key_duplication) {
+        let $ = $list.fold(
+          items,
+          [$set.new$(), $set.new$()],
+          (acc, item) => {
+            let seen;
+            let duplicates;
+            seen = acc[0];
+            duplicates = acc[1];
+            let $1 = $set.contains(seen, item[0]);
+            if ($1) {
+              return [seen, $set.insert(duplicates, item[0])];
+            } else {
+              return [$set.insert(seen, item[0]), duplicates];
+            }
+          },
+        );
+        let duplicates;
+        duplicates = $[1];
+        let _block;
+        let _pipe = $set.to_list(duplicates);
+        _block = $list.sort(_pipe, $string.compare);
+        let dupes_list = _block;
+        if (dupes_list instanceof $Empty) {
+          return new Ok(items);
+        } else {
+          return new Error(new DuplicateKeysDetected(key, dupes_list));
+        }
+      } else {
+        return new Ok(items);
+      }
+    },
+  );
+}
+
+/**
+ * Extracts a string map with duplicate key detection.
+ */
+export function extract_string_map_with_duplicate_detection(
+  node,
+  key,
+  fail_on_key_duplication
+) {
+  return $result.try$(
+    select_or_missing(node, key),
+    (dict_node) => {
+      if (dict_node instanceof NodeNil) {
+        return new Error(new KeyValueEmpty(key));
+      } else if (dict_node instanceof NodeMap) {
+        let entries = dict_node[0];
+        let _pipe = entries;
+        let _pipe$1 = $list.try_map(
+          _pipe,
+          (entry) => {
+            let $ = entry[0];
+            if ($ instanceof NodeStr) {
+              let $1 = entry[1];
+              if ($1 instanceof NodeStr) {
+                let dict_key = $[0];
+                let value = $1[0];
+                return new Ok([dict_key, value]);
+              } else {
+                let value_node = $1;
+                let dict_key = $[0];
+                return new Error(
+                  new KeyTypeMismatch(
+                    key,
+                    "map of strings",
+                    ((("map with " + node_type_name(value_node)) + " value at key '") + dict_key) + "'",
+                  ),
+                );
+              }
+            } else {
+              let key_node = $;
+              return new Error(
+                new KeyTypeMismatch(
+                  key,
+                  "map of strings",
+                  ("map with " + node_type_name(key_node)) + " key",
+                ),
+              );
+            }
+          },
+        );
+        let _pipe$2 = validate_no_duplicate_keys(
+          _pipe$1,
+          key,
+          fail_on_key_duplication,
+        );
+        return $result.map(_pipe$2, $dict.from_list);
+      } else {
+        let other = dict_node;
+        return new Error(new KeyTypeMismatch(key, "map", node_type_name(other)));
+      }
+    },
+  );
+}