skill-universe 1.1.0

package/build/dev/javascript/skillc/skillc/template.mjs

@@ -0,0 +1,1177 @@
+import * as $float from "../../gleam_stdlib/gleam/float.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 { None, Some } from "../../gleam_stdlib/gleam/option.mjs";
+import * as $result from "../../gleam_stdlib/gleam/result.mjs";
+import * as $string from "../../gleam_stdlib/gleam/string.mjs";
+import * as $yay from "../../yay/yay.mjs";
+import {
+  Ok,
+  Error,
+  toList,
+  Empty as $Empty,
+  prepend as listPrepend,
+  CustomType as $CustomType,
+} from "../gleam.mjs";
+import * as $error from "../skillc/error.mjs";
+import { TemplateError } from "../skillc/error.mjs";
+import * as $semver from "../skillc/semver.mjs";
+import * as $types from "../skillc/types.mjs";
+import { Optional, OptionalWithDefault, Required } from "../skillc/types.mjs";
+import * as $version_constraint from "../skillc/version_constraint.mjs";
+
+class ConditionalBlock extends $CustomType {
+  constructor(if_content, else_content, remaining) {
+    super();
+    this.if_content = if_content;
+    this.else_content = else_content;
+    this.remaining = remaining;
+  }
+}
+
+export class VStr extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Value$VStr = ($0) => new VStr($0);
+export const Value$isVStr = (value) => value instanceof VStr;
+export const Value$VStr$0 = (value) => value[0];
+
+export class VBool extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Value$VBool = ($0) => new VBool($0);
+export const Value$isVBool = (value) => value instanceof VBool;
+export const Value$VBool$0 = (value) => value[0];
+
+export class VInt extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Value$VInt = ($0) => new VInt($0);
+export const Value$isVInt = (value) => value instanceof VInt;
+export const Value$VInt$0 = (value) => value[0];
+
+export class VFloat extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Value$VFloat = ($0) => new VFloat($0);
+export const Value$isVFloat = (value) => value instanceof VFloat;
+export const Value$VFloat$0 = (value) => value[0];
+
+export class VList extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Value$VList = ($0) => new VList($0);
+export const Value$isVList = (value) => value instanceof VList;
+export const Value$VList$0 = (value) => value[0];
+
+export class VDict extends $CustomType {
+  constructor($0) {
+    super();
+    this[0] = $0;
+  }
+}
+export const Value$VDict = ($0) => new VDict($0);
+export const Value$isVDict = (value) => value instanceof VDict;
+export const Value$VDict$0 = (value) => value[0];
+
+export class VNil extends $CustomType {}
+export const Value$VNil = () => new VNil();
+export const Value$isVNil = (value) => value instanceof VNil;
+
+const escaped_brace_placeholder = "___ESCAPED_OPEN_BRACE___";
+
+const key_index = "@index";
+
+const key_first = "@first";
+
+const key_last = "@last";
+
+const key_this = "this";
+
+function strip_surrounding_newlines(s) {
+  let _block;
+  let $ = $string.starts_with(s, "\n");
+  if ($) {
+    _block = $string.drop_start(s, 1);
+  } else {
+    _block = s;
+  }
+  let s$1 = _block;
+  let $1 = $string.ends_with(s$1, "\n");
+  if ($1) {
+    return $string.drop_end(s$1, 1);
+  } else {
+    return s$1;
+  }
+}
+
+function strip_trailing_newlines(loop$s) {
+  while (true) {
+    let s = loop$s;
+    let $ = $string.ends_with(s, "\n");
+    if ($) {
+      loop$s = $string.drop_end(s, 1);
+    } else {
+      return s;
+    }
+  }
+}
+
+function parse_provider_names(content) {
+  let _pipe = $string.split(content, " ");
+  return $list.filter_map(
+    _pipe,
+    (part) => {
+      let trimmed = $string.trim(part);
+      let $ = $string.starts_with(trimmed, "\"");
+      let $1 = $string.ends_with(trimmed, "\"");
+      if ($ && $1) {
+        let _block;
+        let _pipe$1 = trimmed;
+        let _pipe$2 = $string.drop_start(_pipe$1, 1);
+        _block = $string.drop_end(_pipe$2, 1);
+        let name = _block;
+        if (name === "") {
+          return new Error(undefined);
+        } else {
+          return new Ok(name);
+        }
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+}
+
+function parse_provider_tag(content) {
+  let $ = $string.split_once(content, "}}");
+  if ($ instanceof Ok) {
+    let tag_content = $[0][0];
+    let rest = $[0][1];
+    let providers = parse_provider_names($string.trim(tag_content));
+    if (providers instanceof $Empty) {
+      return new Error(undefined);
+    } else {
+      return new Ok([providers, rest]);
+    }
+  } else {
+    return new Error(undefined);
+  }
+}
+
+function count_opens(loop$content, loop$acc) {
+  while (true) {
+    let content = loop$content;
+    let acc = loop$acc;
+    let $ = $string.split_once(content, "{{#provider ");
+    if ($ instanceof Ok) {
+      let rest = $[0][1];
+      loop$content = rest;
+      loop$acc = acc + 1;
+    } else {
+      return acc;
+    }
+  }
+}
+
+function find_closing_provider(content, depth) {
+  if (depth === 0) {
+    return new Ok(["", content]);
+  } else {
+    let $ = $string.split_once(content, "{{/provider}}");
+    if ($ instanceof Ok) {
+      let before = $[0][0];
+      let after = $[0][1];
+      let nested_opens = count_opens(before, 0);
+      let new_depth = (depth + nested_opens) - 1;
+      if (new_depth === 0) {
+        return new Ok([before, after]);
+      } else {
+        return $result.try$(
+          find_closing_provider(after, new_depth),
+          (_use0) => {
+            let rest_content;
+            let rest_after;
+            rest_content = _use0[0];
+            rest_after = _use0[1];
+            return new Ok(
+              [(before + "{{/provider}}") + rest_content, rest_after],
+            );
+          },
+        );
+      }
+    } else {
+      return new Error(undefined);
+    }
+  }
+}
+
+function is_before_open(else_pos, open_pos) {
+  if (open_pos instanceof Some) {
+    let op = open_pos[0];
+    return else_pos < op;
+  } else {
+    return true;
+  }
+}
+
+function find_position(haystack, needle) {
+  let $ = $string.split_once(haystack, needle);
+  if ($ instanceof Ok) {
+    let before = $[0][0];
+    return new Some($string.length(before));
+  } else {
+    return new None();
+  }
+}
+
+function do_find_block_end(
+  loop$remaining,
+  loop$open_tag,
+  loop$close_tag,
+  loop$depth,
+  loop$acc,
+  loop$open_line
+) {
+  while (true) {
+    let remaining = loop$remaining;
+    let open_tag = loop$open_tag;
+    let close_tag = loop$close_tag;
+    let depth = loop$depth;
+    let acc = loop$acc;
+    let open_line = loop$open_line;
+    if (depth === 0) {
+      return new Ok([acc, remaining]);
+    } else {
+      let open_pos = find_position(remaining, open_tag);
+      let close_pos = find_position(remaining, close_tag);
+      if (close_pos instanceof Some) {
+        let close_pos$1 = close_pos[0];
+        if (open_pos instanceof Some) {
+          let open_pos$1 = open_pos[0];
+          if (open_pos$1 < close_pos$1) {
+            let before_len = open_pos$1 + $string.length(open_tag);
+            let before = $string.slice(remaining, 0, before_len);
+            let rest = $string.drop_start(remaining, before_len);
+            loop$remaining = rest;
+            loop$open_tag = open_tag;
+            loop$close_tag = close_tag;
+            loop$depth = depth + 1;
+            loop$acc = acc + before;
+            loop$open_line = open_line;
+          } else {
+            if (depth === 1) {
+              let block_content = $string.slice(remaining, 0, close_pos$1);
+              let rest = $string.drop_start(
+                remaining,
+                close_pos$1 + $string.length(close_tag),
+              );
+              return new Ok([acc + block_content, rest]);
+            } else {
+              let before_len = close_pos$1 + $string.length(close_tag);
+              let before = $string.slice(remaining, 0, before_len);
+              let rest = $string.drop_start(remaining, before_len);
+              loop$remaining = rest;
+              loop$open_tag = open_tag;
+              loop$close_tag = close_tag;
+              loop$depth = depth - 1;
+              loop$acc = acc + before;
+              loop$open_line = open_line;
+            }
+          }
+        } else {
+          if (depth === 1) {
+            let block_content = $string.slice(remaining, 0, close_pos$1);
+            let rest = $string.drop_start(
+              remaining,
+              close_pos$1 + $string.length(close_tag),
+            );
+            return new Ok([acc + block_content, rest]);
+          } else {
+            let before_len = close_pos$1 + $string.length(close_tag);
+            let before = $string.slice(remaining, 0, before_len);
+            let rest = $string.drop_start(remaining, before_len);
+            loop$remaining = rest;
+            loop$open_tag = open_tag;
+            loop$close_tag = close_tag;
+            loop$depth = depth - 1;
+            loop$acc = acc + before;
+            loop$open_line = open_line;
+          }
+        }
+      } else {
+        let _block;
+        let _pipe = open_tag;
+        let _pipe$1 = $string.replace(_pipe, "{{#", "");
+        _block = $string.trim(_pipe$1);
+        let block_name = _block;
+        return new Error(
+          new TemplateError(
+            open_line,
+            ("Unclosed {{#" + block_name) + "}} block",
+          ),
+        );
+      }
+    }
+  }
+}
+
+function find_block_end(content, block_type, open_line) {
+  let open_tag = ("{{#" + block_type) + " ";
+  let close_tag = ("{{/" + block_type) + "}}";
+  return do_find_block_end(content, open_tag, close_tag, 1, "", open_line);
+}
+
+function do_find_block_end_with_else(
+  loop$remaining,
+  loop$open_tag,
+  loop$close_tag,
+  loop$else_tag,
+  loop$depth,
+  loop$acc,
+  loop$else_split,
+  loop$open_line
+) {
+  while (true) {
+    let remaining = loop$remaining;
+    let open_tag = loop$open_tag;
+    let close_tag = loop$close_tag;
+    let else_tag = loop$else_tag;
+    let depth = loop$depth;
+    let acc = loop$acc;
+    let else_split = loop$else_split;
+    let open_line = loop$open_line;
+    if (depth === 0) {
+      if (else_split instanceof Some) {
+        let if_content = else_split[0];
+        return new Ok(
+          new ConditionalBlock(if_content, new Some(acc), remaining),
+        );
+      } else {
+        return new Ok(new ConditionalBlock(acc, new None(), remaining));
+      }
+    } else {
+      let open_pos = find_position(remaining, open_tag);
+      let close_pos = find_position(remaining, close_tag);
+      let _block;
+      if (depth === 1) {
+        _block = find_position(remaining, else_tag);
+      } else {
+        _block = new None();
+      }
+      let else_pos = _block;
+      if (close_pos instanceof Some) {
+        let cp = close_pos[0];
+        let _block$1;
+        if (else_pos instanceof Some && else_split instanceof None) {
+          let ep = else_pos[0];
+          if (ep < cp) {
+            _block$1 = is_before_open(ep, open_pos);
+          } else {
+            _block$1 = false;
+          }
+        } else {
+          _block$1 = false;
+        }
+        let use_else = _block$1;
+        if (use_else && else_pos instanceof Some) {
+          let ep = else_pos[0];
+          let before_else = $string.slice(remaining, 0, ep);
+          let after_else = $string.drop_start(
+            remaining,
+            ep + $string.length(else_tag),
+          );
+          loop$remaining = after_else;
+          loop$open_tag = open_tag;
+          loop$close_tag = close_tag;
+          loop$else_tag = else_tag;
+          loop$depth = depth;
+          loop$acc = "";
+          loop$else_split = new Some(acc + before_else);
+          loop$open_line = open_line;
+        } else {
+          if (open_pos instanceof Some) {
+            let op = open_pos[0];
+            if (op < cp) {
+              let before_len = op + $string.length(open_tag);
+              let before = $string.slice(remaining, 0, before_len);
+              let rest = $string.drop_start(remaining, before_len);
+              loop$remaining = rest;
+              loop$open_tag = open_tag;
+              loop$close_tag = close_tag;
+              loop$else_tag = else_tag;
+              loop$depth = depth + 1;
+              loop$acc = acc + before;
+              loop$else_split = else_split;
+              loop$open_line = open_line;
+            } else {
+              if (depth === 1) {
+                let block_content = $string.slice(remaining, 0, cp);
+                let rest = $string.drop_start(
+                  remaining,
+                  cp + $string.length(close_tag),
+                );
+                if (else_split instanceof Some) {
+                  let if_content = else_split[0];
+                  return new Ok(
+                    new ConditionalBlock(
+                      if_content,
+                      new Some(acc + block_content),
+                      rest,
+                    ),
+                  );
+                } else {
+                  return new Ok(
+                    new ConditionalBlock(acc + block_content, new None(), rest),
+                  );
+                }
+              } else {
+                let before_len = cp + $string.length(close_tag);
+                let before = $string.slice(remaining, 0, before_len);
+                let rest = $string.drop_start(remaining, before_len);
+                loop$remaining = rest;
+                loop$open_tag = open_tag;
+                loop$close_tag = close_tag;
+                loop$else_tag = else_tag;
+                loop$depth = depth - 1;
+                loop$acc = acc + before;
+                loop$else_split = else_split;
+                loop$open_line = open_line;
+              }
+            }
+          } else {
+            if (depth === 1) {
+              let block_content = $string.slice(remaining, 0, cp);
+              let rest = $string.drop_start(
+                remaining,
+                cp + $string.length(close_tag),
+              );
+              if (else_split instanceof Some) {
+                let if_content = else_split[0];
+                return new Ok(
+                  new ConditionalBlock(
+                    if_content,
+                    new Some(acc + block_content),
+                    rest,
+                  ),
+                );
+              } else {
+                return new Ok(
+                  new ConditionalBlock(acc + block_content, new None(), rest),
+                );
+              }
+            } else {
+              let before_len = cp + $string.length(close_tag);
+              let before = $string.slice(remaining, 0, before_len);
+              let rest = $string.drop_start(remaining, before_len);
+              loop$remaining = rest;
+              loop$open_tag = open_tag;
+              loop$close_tag = close_tag;
+              loop$else_tag = else_tag;
+              loop$depth = depth - 1;
+              loop$acc = acc + before;
+              loop$else_split = else_split;
+              loop$open_line = open_line;
+            }
+          }
+        }
+      } else {
+        let _block$1;
+        let _pipe = open_tag;
+        let _pipe$1 = $string.replace(_pipe, "{{#", "");
+        _block$1 = $string.trim(_pipe$1);
+        let block_name = _block$1;
+        return new Error(
+          new TemplateError(
+            open_line,
+            ("Unclosed {{#" + block_name) + "}} block",
+          ),
+        );
+      }
+    }
+  }
+}
+
+function find_block_end_with_else(content, block_type, open_line) {
+  let open_tag = ("{{#" + block_type) + " ";
+  let close_tag = ("{{/" + block_type) + "}}";
+  let else_tag = "{{else}}";
+  return do_find_block_end_with_else(
+    content,
+    open_tag,
+    close_tag,
+    else_tag,
+    1,
+    "",
+    new None(),
+    open_line,
+  );
+}
+
+function lookup_key(key, ctx) {
+  if (ctx instanceof VDict) {
+    let props = ctx[0];
+    let $ = $list.key_find(props, key);
+    if ($ instanceof Ok) {
+      let value = $[0];
+      return value;
+    } else {
+      return new VNil();
+    }
+  } else {
+    return new VNil();
+  }
+}
+
+function do_count_newlines(loop$s, loop$acc) {
+  while (true) {
+    let s = loop$s;
+    let acc = loop$acc;
+    let $ = $string.split_once(s, "\n");
+    if ($ instanceof Ok) {
+      let rest = $[0][1];
+      loop$s = rest;
+      loop$acc = acc + 1;
+    } else {
+      return acc;
+    }
+  }
+}
+
+function count_newlines(s) {
+  return do_count_newlines(s, 0);
+}
+
+function do_process_provider_blocks(remaining, target, acc, line) {
+  let $ = $string.split_once(remaining, "{{#provider ");
+  if ($ instanceof Ok) {
+    let before = $[0][0];
+    let after_open = $[0][1];
+    let error_line = line + count_newlines(before);
+    return $result.try$(
+      (() => {
+        let _pipe = parse_provider_tag(after_open);
+        return $result.replace_error(
+          _pipe,
+          new TemplateError(
+            error_line,
+            "Malformed {{#provider}} tag: missing provider names or closing }}",
+          ),
+        );
+      })(),
+      (_use0) => {
+        let providers;
+        let after_tag;
+        providers = _use0[0];
+        after_tag = _use0[1];
+        return $result.try$(
+          (() => {
+            let _pipe = find_closing_provider(after_tag, 1);
+            return $result.replace_error(
+              _pipe,
+              new TemplateError(error_line, "Unclosed {{#provider}} block"),
+            );
+          })(),
+          (_use0) => {
+            let block_content;
+            let after_close;
+            block_content = _use0[0];
+            after_close = _use0[1];
+            let should_include = $list.contains(providers, target);
+            let _block;
+            if (should_include) {
+              _block = ((acc + before) + strip_surrounding_newlines(
+                block_content,
+              )) + "\n";
+            } else {
+              _block = acc + strip_trailing_newlines(before);
+            }
+            let new_acc = _block;
+            let new_line = error_line + count_newlines(block_content);
+            return do_process_provider_blocks(
+              after_close,
+              target,
+              new_acc,
+              new_line,
+            );
+          },
+        );
+      },
+    );
+  } else {
+    return new Ok(acc + remaining);
+  }
+}
+
+export function process_provider_blocks(content, target) {
+  let target_str = $types.provider_to_string(target);
+  return do_process_provider_blocks(content, target_str, "", 1);
+}
+
+function is_truthy(value) {
+  if (value instanceof VStr) {
+    let $ = value[0];
+    if ($ === "") {
+      return false;
+    } else {
+      return true;
+    }
+  } else if (value instanceof VBool) {
+    let $ = value[0];
+    if (!$) {
+      return false;
+    } else {
+      return true;
+    }
+  } else if (value instanceof VList) {
+    let $ = value[0];
+    if ($ instanceof $Empty) {
+      return false;
+    } else {
+      return true;
+    }
+  } else if (value instanceof VNil) {
+    return false;
+  } else {
+    return true;
+  }
+}
+
+function value_to_string(value) {
+  if (value instanceof VStr) {
+    let s = value[0];
+    return s;
+  } else if (value instanceof VBool) {
+    let $ = value[0];
+    if ($) {
+      return "true";
+    } else {
+      return "false";
+    }
+  } else if (value instanceof VInt) {
+    let i = value[0];
+    return $int.to_string(i);
+  } else if (value instanceof VFloat) {
+    let f = value[0];
+    return $float.to_string(f);
+  } else if (value instanceof VList) {
+    return "";
+  } else if (value instanceof VDict) {
+    return "";
+  } else {
+    return "";
+  }
+}
+
+function node_to_value(node) {
+  if (node instanceof $yay.NodeNil) {
+    return new VNil();
+  } else if (node instanceof $yay.NodeStr) {
+    let s = node[0];
+    return new VStr(s);
+  } else if (node instanceof $yay.NodeBool) {
+    let b = node[0];
+    return new VBool(b);
+  } else if (node instanceof $yay.NodeInt) {
+    let i = node[0];
+    return new VInt(i);
+  } else if (node instanceof $yay.NodeFloat) {
+    let f = node[0];
+    return new VFloat(f);
+  } else if (node instanceof $yay.NodeSeq) {
+    let items = node[0];
+    return new VList($list.map(items, node_to_value));
+  } else {
+    let pairs = node[0];
+    return new VDict(
+      $list.filter_map(
+        pairs,
+        (pair) => {
+          let $ = pair[0];
+          if ($ instanceof $yay.NodeStr) {
+            let value = pair[1];
+            let key = $[0];
+            return new Ok([key, node_to_value(value)]);
+          } else {
+            return new Error(undefined);
+          }
+        },
+      ),
+    );
+  }
+}
+
+export function build_context(skill, target, provider_meta) {
+  let base_props = toList([
+    ["name", new VStr(skill.name)],
+    ["version", new VStr($semver.to_string(skill.version))],
+    ["description", new VStr(skill.description)],
+    ["provider", new VStr($types.provider_to_string(target))],
+  ]);
+  let optional_props = $list.filter_map(
+    toList([
+      ["license", skill.license],
+      ["homepage", skill.homepage],
+      ["repository", skill.repository],
+    ]),
+    (pair) => {
+      let $ = pair[1];
+      if ($ instanceof Some) {
+        let value = $[0];
+        return new Ok([pair[0], new VStr(value)]);
+      } else {
+        return new Error(undefined);
+      }
+    },
+  );
+  let dep_values = $list.map(
+    skill.dependencies,
+    (dep) => {
+      return new VDict(
+        toList([
+          ["name", new VStr(dep.name)],
+          ["version", new VStr($version_constraint.to_string(dep.version))],
+          ["optional", new VBool(dep.optional)],
+        ]),
+      );
+    },
+  );
+  let _block;
+  let $ = skill.metadata;
+  if ($ instanceof Some) {
+    let m = $[0];
+    let inner = $list.flatten(
+      toList([
+        $list.filter_map(
+          toList([["author", m.author], ["author_email", m.author_email]]),
+          (pair) => {
+            let $1 = pair[1];
+            if ($1 instanceof Some) {
+              let value = $1[0];
+              return new Ok([pair[0], new VStr(value)]);
+            } else {
+              return new Error(undefined);
+            }
+          },
+        ),
+        toList([
+          ["tags", new VList($list.map(m.tags, (t) => { return new VStr(t); }))],
+        ]),
+      ]),
+    );
+    _block = toList([["metadata", new VDict(inner)]]);
+  } else {
+    _block = toList([]);
+  }
+  let metadata_props = _block;
+  let config_values = $list.map(
+    skill.config,
+    (cf) => {
+      let _block$1;
+      let $2 = cf.requirement;
+      if ($2 instanceof Required) {
+        _block$1 = [true, toList([])];
+      } else if ($2 instanceof Optional) {
+        _block$1 = [false, toList([])];
+      } else {
+        let d = $2[0];
+        _block$1 = [false, toList([["default", new VStr(d)]])];
+      }
+      let $1 = _block$1;
+      let required_val;
+      let default_prop;
+      required_val = $1[0];
+      default_prop = $1[1];
+      return new VDict(
+        $list.flatten(
+          toList([
+            toList([
+              ["name", new VStr(cf.name)],
+              ["description", new VStr(cf.description)],
+              ["required", new VBool(required_val)],
+              ["secret", new VBool(cf.secret)],
+            ]),
+            default_prop,
+          ]),
+        ),
+      );
+    },
+  );
+  return new VDict(
+    $list.flatten(
+      toList([
+        base_props,
+        optional_props,
+        toList([["dependencies", new VList(dep_values)]]),
+        metadata_props,
+        toList([["config", new VList(config_values)]]),
+        toList([["meta", node_to_value(provider_meta)]]),
+      ]),
+    ),
+  );
+}
+
+function process_raw_blocks(loop$content, loop$acc) {
+  while (true) {
+    let content = loop$content;
+    let acc = loop$acc;
+    let $ = $string.split_once(content, "{{{{raw}}}}");
+    if ($ instanceof Ok) {
+      let before = $[0][0];
+      let after_open = $[0][1];
+      let $1 = $string.split_once(after_open, "{{{{/raw}}}}");
+      if ($1 instanceof Ok) {
+        let raw_content = $1[0][0];
+        let after_close = $1[0][1];
+        let escaped = $string.replace(
+          raw_content,
+          "{{",
+          escaped_brace_placeholder,
+        );
+        loop$content = after_close;
+        loop$acc = (acc + before) + escaped;
+      } else {
+        return acc + content;
+      }
+    } else {
+      return acc + content;
+    }
+  }
+}
+
+function resolve_this(ctx) {
+  let $ = lookup_key(key_this, ctx);
+  if ($ instanceof VNil) {
+    return ctx;
+  } else {
+    return $;
+  }
+}
+
+function resolve_parts(loop$parts, loop$ctx) {
+  while (true) {
+    let parts = loop$parts;
+    let ctx = loop$ctx;
+    if (parts instanceof $Empty) {
+      return ctx;
+    } else {
+      let part = parts.head;
+      if (part === "this") {
+        let rest = parts.tail;
+        let this_val = resolve_this(ctx);
+        loop$parts = rest;
+        loop$ctx = this_val;
+      } else {
+        let $ = parts.tail;
+        if ($ instanceof $Empty) {
+          let part = parts.head;
+          if (part === "@index") {
+            return lookup_key(key_index, ctx);
+          } else {
+            let part = parts.head;
+            if (part === "@first") {
+              return lookup_key(key_first, ctx);
+            } else {
+              let part = parts.head;
+              if (part === "@last") {
+                return lookup_key(key_last, ctx);
+              } else {
+                let key = parts.head;
+                let rest = $;
+                let value = lookup_key(key, ctx);
+                if (rest instanceof $Empty) {
+                  return value;
+                } else {
+                  loop$parts = rest;
+                  loop$ctx = value;
+                }
+              }
+            }
+          }
+        } else {
+          let key = parts.head;
+          let rest = $;
+          let value = lookup_key(key, ctx);
+          if (rest instanceof $Empty) {
+            return value;
+          } else {
+            loop$parts = rest;
+            loop$ctx = value;
+          }
+        }
+      }
+    }
+  }
+}
+
+function resolve_path(path, ctx) {
+  let parts = $string.split(path, ".");
+  return resolve_parts(parts, ctx);
+}
+
+function render_conditional_block(should_render, block, before, ctx, acc, line) {
+  let _block;
+  let $ = block.else_content;
+  if ($ instanceof Some) {
+    let else_content = $[0];
+    _block = (block.if_content + "{{else}}") + else_content;
+  } else {
+    _block = block.if_content;
+  }
+  let total_content = _block;
+  let after_block_line = line + count_newlines(total_content);
+  if (should_render) {
+    return $result.try$(
+      render_tokens(block.if_content, ctx, line),
+      (_use0) => {
+        let rendered_block;
+        rendered_block = _use0[0];
+        return do_render(
+          block.remaining,
+          ctx,
+          (acc + before) + rendered_block,
+          after_block_line,
+        );
+      },
+    );
+  } else {
+    let $1 = block.else_content;
+    if ($1 instanceof Some) {
+      let else_content = $1[0];
+      return $result.try$(
+        render_tokens(
+          else_content,
+          ctx,
+          line + count_newlines(block.if_content),
+        ),
+        (_use0) => {
+          let rendered_else;
+          rendered_else = _use0[0];
+          return do_render(
+            block.remaining,
+            ctx,
+            (acc + before) + rendered_else,
+            after_block_line,
+          );
+        },
+      );
+    } else {
+      return do_render(block.remaining, ctx, acc + before, after_block_line);
+    }
+  }
+}
+
+function render_tokens(content, ctx, line) {
+  return do_render(content, ctx, "", line);
+}
+
+function do_render(loop$remaining, loop$ctx, loop$acc, loop$line) {
+  while (true) {
+    let remaining = loop$remaining;
+    let ctx = loop$ctx;
+    let acc = loop$acc;
+    let line = loop$line;
+    let $ = $string.split_once(remaining, "{{");
+    if ($ instanceof Ok) {
+      let before = $[0][0];
+      let after_open = $[0][1];
+      let source_line = line + count_newlines(before);
+      let $1 = $string.split_once(after_open, "}}");
+      if ($1 instanceof Ok) {
+        let tag_body = $1[0][0];
+        let after_close = $1[0][1];
+        let tag = $string.trim(tag_body);
+        let after_tag_line = source_line + count_newlines(tag_body);
+        if (tag.startsWith("#if ")) {
+          let path = tag.slice(4);
+          let path$1 = $string.trim(path);
+          return $result.try$(
+            find_block_end_with_else(after_close, "if", source_line),
+            (block) => {
+              let value = resolve_path(path$1, ctx);
+              let should_render = is_truthy(value);
+              return render_conditional_block(
+                should_render,
+                block,
+                before,
+                ctx,
+                acc,
+                after_tag_line,
+              );
+            },
+          );
+        } else if (tag.startsWith("#unless ")) {
+          let path = tag.slice(8);
+          let path$1 = $string.trim(path);
+          return $result.try$(
+            find_block_end_with_else(after_close, "unless", source_line),
+            (block) => {
+              let value = resolve_path(path$1, ctx);
+              let should_render = !is_truthy(value);
+              return render_conditional_block(
+                should_render,
+                block,
+                before,
+                ctx,
+                acc,
+                after_tag_line,
+              );
+            },
+          );
+        } else if (tag.startsWith("#each ")) {
+          let path = tag.slice(6);
+          let path$1 = $string.trim(path);
+          return $result.try$(
+            find_block_end(after_close, "each", source_line),
+            (_use0) => {
+              let block_content;
+              let rest;
+              block_content = _use0[0];
+              rest = _use0[1];
+              let value = resolve_path(path$1, ctx);
+              if (value instanceof VList) {
+                let items = value[0];
+                let len = $list.length(items);
+                return $result.try$(
+                  render_each_items(
+                    block_content,
+                    items,
+                    ctx,
+                    0,
+                    len,
+                    "",
+                    after_tag_line,
+                  ),
+                  (_use0) => {
+                    let rendered_items;
+                    rendered_items = _use0[0];
+                    return do_render(
+                      rest,
+                      ctx,
+                      (acc + before) + rendered_items,
+                      after_tag_line + count_newlines(block_content),
+                    );
+                  },
+                );
+              } else {
+                return do_render(
+                  rest,
+                  ctx,
+                  acc + before,
+                  after_tag_line + count_newlines(block_content),
+                );
+              }
+            },
+          );
+        } else {
+          let value = resolve_path(tag, ctx);
+          let str_value = value_to_string(value);
+          loop$remaining = after_close;
+          loop$ctx = ctx;
+          loop$acc = (acc + before) + str_value;
+          loop$line = after_tag_line;
+        }
+      } else {
+        return new Error(
+          new TemplateError(source_line, "Unbalanced tag: missing closing }}"),
+        );
+      }
+    } else {
+      return new Ok([acc + remaining, line + count_newlines(remaining)]);
+    }
+  }
+}
+
+function render(content, context) {
+  let content$1 = process_raw_blocks(content, "");
+  let content$2 = $string.replace(content$1, "\\{{", escaped_brace_placeholder);
+  return $result.try$(
+    render_tokens(content$2, context, 1),
+    (_use0) => {
+      let output;
+      output = _use0[0];
+      let output$1 = $string.replace(output, escaped_brace_placeholder, "{{");
+      return new Ok(output$1);
+    },
+  );
+}
+
+export function render_template(content, target, skill, provider_meta) {
+  return $result.try$(
+    process_provider_blocks(content, target),
+    (processed) => {
+      let context = build_context(skill, target, provider_meta);
+      return render(processed, context);
+    },
+  );
+}
+
+function render_each_items(template, items, parent_ctx, index, total, acc, line) {
+  if (items instanceof $Empty) {
+    return new Ok([acc, line]);
+  } else {
+    let item = items.head;
+    let rest = items.tail;
+    let is_last = index === (total - 1);
+    let is_first = index === 0;
+    let special_keys = toList([
+      [key_index, new VInt(index)],
+      [key_first, new VBool(is_first)],
+      [key_last, new VBool(is_last)],
+    ]);
+    let _block;
+    if (parent_ctx instanceof VDict) {
+      let props = parent_ctx[0];
+      _block = props;
+    } else {
+      _block = toList([]);
+    }
+    let parent_props = _block;
+    let _block$1;
+    if (item instanceof VDict) {
+      let props = item[0];
+      _block$1 = listPrepend(
+        [key_this, item],
+        $list.append(props, special_keys),
+      );
+    } else {
+      _block$1 = listPrepend([key_this, item], special_keys);
+    }
+    let item_keys = _block$1;
+    let item_ctx = new VDict($list.append(item_keys, parent_props));
+    return $result.try$(
+      render_tokens(template, item_ctx, line),
+      (_use0) => {
+        let rendered;
+        let new_line;
+        rendered = _use0[0];
+        new_line = _use0[1];
+        return render_each_items(
+          template,
+          rest,
+          parent_ctx,
+          index + 1,
+          total,
+          acc + rendered,
+          new_line,
+        );
+      },
+    );
+  }
+}