skill-universe 1.1.0

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

@@ -0,0 +1,1638 @@
+import * as $option from "../gleam_stdlib/gleam/option.mjs";
+import { None, Some } from "../gleam_stdlib/gleam/option.mjs";
+import * as $string from "../gleam_stdlib/gleam/string.mjs";
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import * as $yay from "../yay/yay.mjs";
+import { Ok, Error, toList, makeError } from "./gleam.mjs";
+import * as $error from "./skillc/error.mjs";
+import * as $semver from "./skillc/semver.mjs";
+import * as $template from "./skillc/template.mjs";
+import * as $types from "./skillc/types.mjs";
+import { ConfigField, Optional, Required, Skill, SkillMetadata } from "./skillc/types.mjs";
+import * as $version_constraint from "./skillc/version_constraint.mjs";
+
+const FILEPATH = "test/template_test.gleam";
+
+export function provider_block_included_test() {
+  let content = "before\n{{#provider \"openclaw\"}}openclaw content{{/provider}}\nafter";
+  let $ = $template.process_provider_blocks(content, new $types.OpenClaw());
+  let result;
+  if ($ instanceof Ok) {
+    result = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      20,
+      "provider_block_included_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 605, end: 686, pattern_start: 616, pattern_end: 626 }
+    )
+  }
+  $should.be_true($string.contains(result, "openclaw content"));
+  $should.be_true($string.contains(result, "before"));
+  return $should.be_true($string.contains(result, "after"));
+}
+
+export function provider_block_excluded_test() {
+  let content = "before\n{{#provider \"openclaw\"}}openclaw content{{/provider}}\nafter";
+  let $ = $template.process_provider_blocks(content, new $types.ClaudeCode());
+  let result;
+  if ($ instanceof Ok) {
+    result = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      29,
+      "provider_block_excluded_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 990, end: 1077, pattern_start: 1001, pattern_end: 1011 }
+    )
+  }
+  $should.be_false($string.contains(result, "openclaw content"));
+  $should.be_true($string.contains(result, "before"));
+  return $should.be_true($string.contains(result, "after"));
+}
+
+export function multi_provider_block_included_test() {
+  let content = "{{#provider \"openclaw\" \"codex\"}}shared content{{/provider}}";
+  let $ = $template.process_provider_blocks(content, new $types.OpenClaw());
+  let result_openclaw;
+  if ($ instanceof Ok) {
+    result_openclaw = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      39,
+      "multi_provider_block_included_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1381,
+        end: 1475,
+        pattern_start: 1392,
+        pattern_end: 1411
+      }
+    )
+  }
+  let $1 = $template.process_provider_blocks(content, new $types.Codex());
+  let result_codex;
+  if ($1 instanceof Ok) {
+    result_codex = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      41,
+      "multi_provider_block_included_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 1478,
+        end: 1566,
+        pattern_start: 1489,
+        pattern_end: 1505
+      }
+    )
+  }
+  $should.be_true($string.contains(result_openclaw, "shared content"));
+  return $should.be_true($string.contains(result_codex, "shared content"));
+}
+
+export function multi_provider_block_excluded_test() {
+  let content = "{{#provider \"openclaw\" \"codex\"}}shared content{{/provider}}";
+  let $ = $template.process_provider_blocks(content, new $types.ClaudeCode());
+  let result;
+  if ($ instanceof Ok) {
+    result = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      50,
+      "multi_provider_block_excluded_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1839,
+        end: 1926,
+        pattern_start: 1850,
+        pattern_end: 1860
+      }
+    )
+  }
+  return $should.be_false($string.contains(result, "shared content"));
+}
+
+export function empty_provider_block_test() {
+  let content = "before{{#provider \"openclaw\"}}{{/provider}}after";
+  let $ = $template.process_provider_blocks(content, new $types.OpenClaw());
+  let result;
+  if ($ instanceof Ok) {
+    result = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      57,
+      "empty_provider_block_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2099,
+        end: 2180,
+        pattern_start: 2110,
+        pattern_end: 2120
+      }
+    )
+  }
+  $should.be_true($string.contains(result, "before"));
+  return $should.be_true($string.contains(result, "after"));
+}
+
+export function nested_provider_blocks_test() {
+  let content = "{{#provider \"openclaw\"}}outer{{#provider \"openclaw\"}}inner{{/provider}}end{{/provider}}";
+  let $ = $template.process_provider_blocks(content, new $types.OpenClaw());
+  let result;
+  if ($ instanceof Ok) {
+    result = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      65,
+      "nested_provider_blocks_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 2442,
+        end: 2523,
+        pattern_start: 2453,
+        pattern_end: 2463
+      }
+    )
+  }
+  $should.be_true($string.contains(result, "outer"));
+  return $should.be_true($string.contains(result, "inner"));
+}
+
+export function unclosed_provider_block_returns_error_test() {
+  let content = "before\n{{#provider \"openclaw\"}}no closing tag";
+  let result = $template.process_provider_blocks(content, new $types.OpenClaw());
+  return $should.be_error(result);
+}
+
+export function malformed_provider_tag_returns_error_test() {
+  let content = "{{#provider \"openclaw\" some content";
+  let result = $template.process_provider_blocks(content, new $types.OpenClaw());
+  return $should.be_error(result);
+}
+
+export function unclosed_provider_error_has_line_number_test() {
+  let content = "line 1\nline 2\n{{#provider \"openclaw\"}}no close";
+  let result = $template.process_provider_blocks(content, new $types.OpenClaw());
+  $should.be_error(result);
+  let line;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.TemplateError) {
+      line = $.line;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "template_test",
+        628,
+        "unclosed_provider_error_has_line_number_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 18133,
+          end: 18190,
+          pattern_start: 18144,
+          pattern_end: 18181
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      628,
+      "unclosed_provider_error_has_line_number_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 18133,
+        end: 18190,
+        pattern_start: 18144,
+        pattern_end: 18181
+      }
+    )
+  }
+  $should.equal(line, 3);
+  return $should.be_true($string.contains(msg, "Unclosed"));
+}
+
+function test_skill() {
+  let $ = $semver.parse("1.0.0");
+  let v;
+  if ($ instanceof Ok) {
+    v = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      715,
+      "test_skill",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 20589,
+        end: 20629,
+        pattern_start: 20600,
+        pattern_end: 20605
+      }
+    )
+  }
+  return new Skill(
+    "test-skill",
+    "A test skill",
+    v,
+    new Some("MIT"),
+    new None(),
+    new None(),
+    new Some(new SkillMetadata(new Some("Test"), new None(), toList([]))),
+    toList([]),
+    toList([new ConfigField("api_key", "API key", new Required(), true)]),
+  );
+}
+
+export function if_with_empty_string_is_falsy_test() {
+  let meta = new $yay.NodeMap(
+    toList([[new $yay.NodeStr("empty_field"), new $yay.NodeStr("")]]),
+  );
+  let result = $template.render_template(
+    "before{{#if meta.empty_field}}hidden{{/if}}after",
+    new $types.OpenClaw(),
+    test_skill(),
+    meta,
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      659,
+      "if_with_empty_string_is_falsy_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 19130,
+        end: 19160,
+        pattern_start: 19141,
+        pattern_end: 19151
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+function assert_parse_vc(input) {
+  let $ = $version_constraint.parse(input);
+  let vc;
+  if ($ instanceof Ok) {
+    vc = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      739,
+      "assert_parse_vc",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 21146,
+        end: 21197,
+        pattern_start: 21157,
+        pattern_end: 21163
+      }
+    )
+  }
+  return vc;
+}
+
+function test_provider_meta() {
+  return new $yay.NodeMap(
+    toList([
+      [new $yay.NodeStr("emoji"), new $yay.NodeStr("🧪")],
+      [
+        new $yay.NodeStr("requires"),
+        new $yay.NodeMap(
+          toList([
+            [
+              new $yay.NodeStr("bins"),
+              new $yay.NodeSeq(
+                toList([new $yay.NodeStr("python3"), new $yay.NodeStr("curl")]),
+              ),
+            ],
+          ]),
+        ),
+      ],
+    ]),
+  );
+}
+
+export function variable_name_test() {
+  let result = $template.render_template(
+    "Hello {{name}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      95,
+      "variable_name_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3468,
+        end: 3498,
+        pattern_start: 3479,
+        pattern_end: 3489
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "Hello test-skill"));
+}
+
+export function variable_version_test() {
+  let result = $template.render_template(
+    "v{{version}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      107,
+      "variable_version_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3742,
+        end: 3772,
+        pattern_start: 3753,
+        pattern_end: 3763
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "v1.0.0"));
+}
+
+export function variable_description_test() {
+  let result = $template.render_template(
+    "{{description}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      119,
+      "variable_description_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 4013,
+        end: 4043,
+        pattern_start: 4024,
+        pattern_end: 4034
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "A test skill"));
+}
+
+export function variable_meta_field_test() {
+  let result = $template.render_template(
+    "Icon: {{meta.emoji}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      131,
+      "variable_meta_field_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 4294,
+        end: 4324,
+        pattern_start: 4305,
+        pattern_end: 4315
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "Icon: 🧪"));
+}
+
+export function undefined_variable_renders_empty_test() {
+  let result = $template.render_template(
+    "before{{nonexistent}}after",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      143,
+      "undefined_variable_renders_empty_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 4592,
+        end: 4622,
+        pattern_start: 4603,
+        pattern_end: 4613
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+export function nested_metadata_access_test() {
+  let result = $template.render_template(
+    "{{#each meta.requires.bins}}{{this}} {{/each}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      156,
+      "nested_metadata_access_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 4927,
+        end: 4957,
+        pattern_start: 4938,
+        pattern_end: 4948
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "python3"));
+  return $should.be_true($string.contains(output, "curl"));
+}
+
+export function if_block_truthy_test() {
+  let result = $template.render_template(
+    "{{#if meta.emoji}}has emoji{{/if}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      173,
+      "if_block_truthy_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 5455,
+        end: 5485,
+        pattern_start: 5466,
+        pattern_end: 5476
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "has emoji"));
+}
+
+export function unless_block_test() {
+  let result = $template.render_template(
+    "{{#unless meta.nonexistent}}no field{{/unless}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      185,
+      "unless_block_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 5753,
+        end: 5783,
+        pattern_start: 5764,
+        pattern_end: 5774
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "no field"));
+}
+
+export function if_block_falsy_path_test() {
+  let result = $template.render_template(
+    "before{{#if meta.nonexistent}}hidden{{/if}}after",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      198,
+      "if_block_falsy_path_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 6119,
+        end: 6149,
+        pattern_start: 6130,
+        pattern_end: 6140
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+export function if_block_false_bool_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    _record.metadata,
+    _record.dependencies,
+    toList([new ConfigField("test", "test", new Optional(), false)]),
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "{{#each config}}{{#if this.required}}req{{/if}}{{#unless this.required}}opt{{/unless}}{{/each}}",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      220,
+      "if_block_false_bool_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 6691,
+        end: 6721,
+        pattern_start: 6702,
+        pattern_end: 6712
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "opt"));
+  return $should.be_false($string.contains(output, "req"));
+}
+
+export function each_block_test() {
+  let result = $template.render_template(
+    "{{#each config}}{{this.name}} {{/each}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      233,
+      "each_block_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 7023,
+        end: 7053,
+        pattern_start: 7034,
+        pattern_end: 7044
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "api_key"));
+}
+
+export function each_block_at_index_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    _record.metadata,
+    _record.dependencies,
+    toList([
+      new ConfigField("a", "", new Optional(), false),
+      new ConfigField("b", "", new Optional(), false),
+    ]),
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "{{#each config}}{{@index}}:{{this.name}} {{/each}}",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      260,
+      "each_block_at_index_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 7631,
+        end: 7661,
+        pattern_start: 7642,
+        pattern_end: 7652
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "0:a"));
+  return $should.be_true($string.contains(output, "1:b"));
+}
+
+export function each_block_at_first_last_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    _record.metadata,
+    _record.dependencies,
+    toList([
+      new ConfigField("first", "", new Optional(), false),
+      new ConfigField("middle", "", new Optional(), false),
+      new ConfigField("last", "", new Optional(), false),
+    ]),
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "{{#each config}}{{#if @first}}[FIRST]{{/if}}{{#if @last}}[LAST]{{/if}}{{this.name}} {{/each}}",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      294,
+      "each_block_at_first_last_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 8470,
+        end: 8500,
+        pattern_start: 8481,
+        pattern_end: 8491
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "[FIRST]first"));
+  $should.be_true($string.contains(output, "[LAST]last"));
+  $should.be_false($string.contains(output, "[FIRST]middle"));
+  return $should.be_false($string.contains(output, "[LAST]middle"));
+}
+
+export function each_empty_list_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    _record.metadata,
+    _record.dependencies,
+    toList([]),
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "before{{#each config}}item{{/each}}after",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      310,
+      "each_empty_list_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 8983,
+        end: 9013,
+        pattern_start: 8994,
+        pattern_end: 9004
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+export function if_else_truthy_renders_if_branch_test() {
+  let result = $template.render_template(
+    "{{#if meta.emoji}}has emoji{{else}}no emoji{{/if}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      326,
+      "if_else_truthy_renders_if_branch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 9482,
+        end: 9512,
+        pattern_start: 9493,
+        pattern_end: 9503
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "has emoji"));
+  return $should.be_false($string.contains(output, "no emoji"));
+}
+
+export function if_else_falsy_renders_else_branch_test() {
+  let result = $template.render_template(
+    "{{#if meta.nonexistent}}yes{{else}}no{{/if}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      339,
+      "if_else_falsy_renders_else_branch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 9853,
+        end: 9883,
+        pattern_start: 9864,
+        pattern_end: 9874
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "no"));
+  return $should.be_false($string.contains(output, "yes"));
+}
+
+export function unless_else_truthy_renders_else_branch_test() {
+  let result = $template.render_template(
+    "{{#unless meta.emoji}}hidden{{else}}shown{{/unless}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      352,
+      "unless_else_truthy_renders_else_branch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 10225,
+        end: 10255,
+        pattern_start: 10236,
+        pattern_end: 10246
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "shown"));
+  return $should.be_false($string.contains(output, "hidden"));
+}
+
+export function unless_else_falsy_renders_unless_branch_test() {
+  let result = $template.render_template(
+    "{{#unless meta.nonexistent}}shown{{else}}hidden{{/unless}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      365,
+      "unless_else_falsy_renders_unless_branch_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 10610,
+        end: 10640,
+        pattern_start: 10621,
+        pattern_end: 10631
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "shown"));
+  return $should.be_false($string.contains(output, "hidden"));
+}
+
+export function if_else_with_variables_test() {
+  let result = $template.render_template(
+    "{{#if meta.emoji}}Icon: {{meta.emoji}}{{else}}Name: {{name}}{{/if}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      378,
+      "if_else_with_variables_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 10987,
+        end: 11017,
+        pattern_start: 10998,
+        pattern_end: 11008
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "Icon:"));
+}
+
+export function if_else_falsy_with_variables_test() {
+  let result = $template.render_template(
+    "{{#if meta.nonexistent}}hidden{{else}}fallback: {{name}}{{/if}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      390,
+      "if_else_falsy_with_variables_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 11313,
+        end: 11343,
+        pattern_start: 11324,
+        pattern_end: 11334
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "fallback: test-skill"));
+}
+
+export function nested_if_else_test() {
+  let result = $template.render_template(
+    "{{#if meta.emoji}}{{#if meta.nonexistent}}inner{{else}}outer else{{/if}}{{else}}top else{{/if}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      402,
+      "nested_if_else_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 11672,
+        end: 11702,
+        pattern_start: 11683,
+        pattern_end: 11693
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "outer else"));
+  $should.be_false($string.contains(output, "inner"));
+  return $should.be_false($string.contains(output, "top else"));
+}
+
+export function if_else_empty_else_block_test() {
+  let result = $template.render_template(
+    "before{{#if meta.nonexistent}}content{{else}}{{/if}}after",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      416,
+      "if_else_empty_else_block_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 12100,
+        end: 12130,
+        pattern_start: 12111,
+        pattern_end: 12121
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+export function backslash_escape_test() {
+  let result = $template.render_template(
+    "\\{{not processed}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      432,
+      "backslash_escape_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 12536,
+        end: 12566,
+        pattern_start: 12547,
+        pattern_end: 12557
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "{{not processed}}"));
+}
+
+export function raw_block_test() {
+  let result = $template.render_template(
+    "{{{{raw}}}}{{name}} should not be replaced{{{{/raw}}}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      444,
+      "raw_block_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 12846,
+        end: 12876,
+        pattern_start: 12857,
+        pattern_end: 12867
+      }
+    )
+  }
+  $should.be_false($string.contains(output, "test-skill"));
+  return $should.be_true($string.contains(output, "{{name}}"));
+}
+
+export function context_includes_provider_test() {
+  let result = $template.render_template(
+    "Provider: {{provider}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      461,
+      "context_includes_provider_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 13375,
+        end: 13405,
+        pattern_start: 13386,
+        pattern_end: 13396
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "Provider: openclaw"));
+}
+
+export function context_includes_top_level_fields_test() {
+  let result = $template.render_template(
+    "{{name}} {{version}} {{description}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      473,
+      "context_includes_top_level_fields_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 13692,
+        end: 13722,
+        pattern_start: 13703,
+        pattern_end: 13713
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "test-skill"));
+  $should.be_true($string.contains(output, "1.0.0"));
+  return $should.be_true($string.contains(output, "A test skill"));
+}
+
+export function unclosed_if_block_fails_test() {
+  let result = $template.render_template(
+    "{{#if meta.emoji}}unclosed",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  return $should.be_error(result);
+}
+
+export function unclosed_provider_block_fails_test() {
+  let result = $template.render_template(
+    "{{#if meta.emoji}}unclosed if and also {{unbalanced",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  return $should.be_error(result);
+}
+
+export function unclosed_each_block_fails_test() {
+  let result = $template.render_template(
+    "{{#each config}}no closing tag",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  return $should.be_error(result);
+}
+
+export function unclosed_unless_block_fails_test() {
+  let result = $template.render_template(
+    "{{#unless meta.emoji}}no closing tag",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  return $should.be_error(result);
+}
+
+export function each_dependencies_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    _record.metadata,
+    toList([
+      new $types.Dependency("helper-skill", assert_parse_vc("^1.0.0"), false),
+      new $types.Dependency("extra-skill", assert_parse_vc("~2.0.0"), true),
+    ]),
+    _record.config,
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "{{#each dependencies}}{{this.name}}({{this.version}}) {{/each}}",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      555,
+      "each_dependencies_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 15985,
+        end: 16015,
+        pattern_start: 15996,
+        pattern_end: 16006
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "helper-skill(^1.0.0)"));
+  return $should.be_true($string.contains(output, "extra-skill(~2.0.0)"));
+}
+
+export function metadata_author_in_context_test() {
+  let result = $template.render_template(
+    "Author: {{metadata.author}}",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      568,
+      "metadata_author_in_context_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 16353,
+        end: 16383,
+        pattern_start: 16364,
+        pattern_end: 16374
+      }
+    )
+  }
+  return $should.be_true($string.contains(output, "Author: Test"));
+}
+
+export function metadata_tags_in_context_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    new Some(new SkillMetadata(new None(), new None(), toList(["web", "api"]))),
+    _record.dependencies,
+    _record.config,
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "{{#each metadata.tags}}{{this}} {{/each}}",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      587,
+      "metadata_tags_in_context_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 16816,
+        end: 16846,
+        pattern_start: 16827,
+        pattern_end: 16837
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "web"));
+  return $should.be_true($string.contains(output, "api"));
+}
+
+export function template_error_has_line_number_test() {
+  let result = $template.render_template(
+    "line 1\nline 2\n{{#if meta.emoji}}unclosed",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  $should.be_error(result);
+  let line;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.TemplateError) {
+      line = $.line;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "template_test",
+        606,
+        "template_error_has_line_number_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 17437,
+          end: 17494,
+          pattern_start: 17448,
+          pattern_end: 17485
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      606,
+      "template_error_has_line_number_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 17437,
+        end: 17494,
+        pattern_start: 17448,
+        pattern_end: 17485
+      }
+    )
+  }
+  $should.equal(line, 3);
+  return $should.be_true($string.contains(msg, "Unclosed"));
+}
+
+export function unbalanced_tag_error_has_line_number_test() {
+  let result = $template.render_template(
+    "line 1\nline 2\nline 3\n{{unbalanced",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  $should.be_error(result);
+  let line;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.TemplateError) {
+      line = $.line;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "template_test",
+        620,
+        "unbalanced_tag_error_has_line_number_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 17821,
+          end: 17879,
+          pattern_start: 17832,
+          pattern_end: 17870
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      620,
+      "unbalanced_tag_error_has_line_number_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 17821,
+        end: 17879,
+        pattern_start: 17832,
+        pattern_end: 17870
+      }
+    )
+  }
+  return $should.equal(line, 4);
+}
+
+export function unless_with_truthy_value_excludes_content_test() {
+  let result = $template.render_template(
+    "before{{#unless meta.emoji}}hidden{{/unless}}after",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      645,
+      "unless_with_truthy_value_excludes_content_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 18719,
+        end: 18749,
+        pattern_start: 18730,
+        pattern_end: 18740
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+export function if_with_empty_list_is_falsy_test() {
+  let _block;
+  let _record = test_skill();
+  _block = new Skill(
+    _record.name,
+    _record.description,
+    _record.version,
+    _record.license,
+    _record.homepage,
+    _record.repository,
+    _record.metadata,
+    toList([]),
+    toList([]),
+  );
+  let skill = _block;
+  let result = $template.render_template(
+    "before{{#if config}}shown{{/if}}after",
+    new $types.OpenClaw(),
+    skill,
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      672,
+      "if_with_empty_list_is_falsy_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 19475,
+        end: 19505,
+        pattern_start: 19486,
+        pattern_end: 19496
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}
+
+export function each_with_simple_string_items_test() {
+  let result = $template.render_template(
+    "{{#each metadata.tags}}[{{this}}]{{/each}}",
+    new $types.OpenClaw(),
+    (() => {
+      let _record = test_skill();
+      return new Skill(
+        _record.name,
+        _record.description,
+        _record.version,
+        _record.license,
+        _record.homepage,
+        _record.repository,
+        new Some(
+          new SkillMetadata(
+            new None(),
+            new None(),
+            toList(["web", "api", "test"]),
+          ),
+        ),
+        _record.dependencies,
+        _record.config,
+      );
+    })(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      694,
+      "each_with_simple_string_items_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 20021,
+        end: 20051,
+        pattern_start: 20032,
+        pattern_end: 20042
+      }
+    )
+  }
+  return $should.equal(output, "[web][api][test]");
+}
+
+export function undefined_deep_nested_path_resolves_empty_test() {
+  let result = $template.render_template(
+    "before{{a.b.c.d}}after",
+    new $types.OpenClaw(),
+    test_skill(),
+    test_provider_meta(),
+  );
+  let output;
+  if (result instanceof Ok) {
+    output = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "template_test",
+      706,
+      "undefined_deep_nested_path_resolves_empty_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 20311,
+        end: 20341,
+        pattern_start: 20322,
+        pattern_end: 20332
+      }
+    )
+  }
+  return $should.equal(output, "beforeafter");
+}