diff --git a/exercises/practice/acronym/.meta/template.j2 b/exercises/practice/acronym/.meta/template.j2
index 1247953..75ee007 100644
--- a/exercises/practice/acronym/.meta/template.j2
+++ b/exercises/practice/acronym/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["phrase"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["phrase"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/acronym/test-acronym.bats b/exercises/practice/acronym/test-acronym.bats
index 0da2b70..742b96d 100644
--- a/exercises/practice/acronym/test-acronym.bats
+++ b/exercises/practice/acronym/test-acronym.bats
@@ -1,67 +1,68 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-29T23:39:19+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test "basic" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "Portable Network Graphics"
-  assert_success
-  assert_output "PNG"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "Portable Network Graphics"
+    assert_success
+    assert_output "PNG"
 }
 
 @test "lowercase words" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "Ruby on Rails"
-  assert_success
-  assert_output "ROR"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "Ruby on Rails"
+    assert_success
+    assert_output "ROR"
 }
 
 @test "punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "First In, First Out"
-  assert_success
-  assert_output "FIFO"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "First In, First Out"
+    assert_success
+    assert_output "FIFO"
 }
 
 @test "all caps word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "GNU Image Manipulation Program"
-  assert_success
-  assert_output "GIMP"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "GNU Image Manipulation Program"
+    assert_success
+    assert_output "GIMP"
 }
 
 @test "punctuation without whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "Complementary metal-oxide semiconductor"
-  assert_success
-  assert_output "CMOS"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "Complementary metal-oxide semiconductor"
+    assert_success
+    assert_output "CMOS"
 }
 
 @test "very long abbreviation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "Rolling On The Floor Laughing So Hard That My Dogs Came Over And Licked Me"
-  assert_success
-  assert_output "ROTFLSHTMDCOALM"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "Rolling On The Floor Laughing So Hard That My Dogs Came Over And Licked Me"
+    assert_success
+    assert_output "ROTFLSHTMDCOALM"
 }
 
 @test "consecutive delimiters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "Something - I made up from thin air"
-  assert_success
-  assert_output "SIMUFTA"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "Something - I made up from thin air"
+    assert_success
+    assert_output "SIMUFTA"
 }
 
 @test "apostrophes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "Halley's Comet"
-  assert_success
-  assert_output "HC"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "Halley's Comet"
+    assert_success
+    assert_output "HC"
 }
 
 @test "underscore emphasis" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f acronym.awk <<< "The Road _Not_ Taken"
-  assert_success
-  assert_output "TRNT"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f acronym.awk <<< "The Road _Not_ Taken"
+    assert_success
+    assert_output "TRNT"
 }
+
diff --git a/exercises/practice/alphametics/.meta/template.j2 b/exercises/practice/alphametics/.meta/template.j2
index 1ea1280..c8a529a 100644
--- a/exercises/practice/alphametics/.meta/template.j2
+++ b/exercises/practice/alphametics/.meta/template.j2
@@ -1,13 +1,13 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case.description }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "{{ case.input.puzzle }}"
-  assert_success
-  {% if case.expected %}
-  assert_output "{% for letter, digit in case.expected | dictsort %}{{ letter }}={{ digit }}{% if not loop.last %} {% endif %}{% endfor %}"
-  {% else %}
-  refute_output
-  {% endif %}
+{% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "{{ case.input.puzzle }}"
+    assert_success
+{% if case.expected %}
+    assert_output "{% for letter, digit in case.expected | dictsort %}{{ letter }}={{ digit }}{% if not loop.last %} {% endif %}{% endfor %}"
+{% else %}
+    refute_output
+{% endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/alphametics/test-alphametics.bats b/exercises/practice/alphametics/test-alphametics.bats
index 105b710..4f11e1e 100644
--- a/exercises/practice/alphametics/test-alphametics.bats
+++ b/exercises/practice/alphametics/test-alphametics.bats
@@ -1,95 +1,95 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-08-13T17:52:46+00:00
+# generated on 2026-08-14T19:13:41+00:00
 
 @test "puzzle with three letters" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "I + BB == ILL"
-  assert_success
-  
-  assert_output "B=9 I=1 L=0"
-  
+# [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "I + BB == ILL"
+    assert_success
+
+    assert_output "B=9 I=1 L=0"
+
 }
 
 @test "solution must have unique value for each letter" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "A == B"
-  assert_success
-  
-  refute_output
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "A == B"
+    assert_success
+
+    refute_output
+
 }
 
 @test "leading zero solution is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "ACA + DD == BD"
-  assert_success
-  
-  refute_output
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "ACA + DD == BD"
+    assert_success
+
+    refute_output
+
 }
 
 @test "puzzle with two digits final carry" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "A + A + A + A + A + A + A + A + A + A + A + B == BCC"
-  assert_success
-  
-  assert_output "A=9 B=1 C=0"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "A + A + A + A + A + A + A + A + A + A + A + B == BCC"
+    assert_success
+
+    assert_output "A=9 B=1 C=0"
+
 }
 
 @test "puzzle with four letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "AS + A == MOM"
-  assert_success
-  
-  assert_output "A=9 M=1 O=0 S=2"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "AS + A == MOM"
+    assert_success
+
+    assert_output "A=9 M=1 O=0 S=2"
+
 }
 
 @test "puzzle with six letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "NO + NO + TOO == LATE"
-  assert_success
-  
-  assert_output "A=0 E=2 L=1 N=7 O=4 T=9"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "NO + NO + TOO == LATE"
+    assert_success
+
+    assert_output "A=0 E=2 L=1 N=7 O=4 T=9"
+
 }
 
 @test "puzzle with seven letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "HE + SEES + THE == LIGHT"
-  assert_success
-  
-  assert_output "E=4 G=2 H=5 I=0 L=1 S=9 T=7"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "HE + SEES + THE == LIGHT"
+    assert_success
+
+    assert_output "E=4 G=2 H=5 I=0 L=1 S=9 T=7"
+
 }
 
 @test "puzzle with eight letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "SEND + MORE == MONEY"
-  assert_success
-  
-  assert_output "D=7 E=5 M=1 N=6 O=0 R=8 S=9 Y=2"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "SEND + MORE == MONEY"
+    assert_success
+
+    assert_output "D=7 E=5 M=1 N=6 O=0 R=8 S=9 Y=2"
+
 }
 
 @test "puzzle with ten letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"
-  assert_success
-  
-  assert_output "A=5 D=3 E=4 F=7 G=8 N=0 O=2 R=1 S=6 T=9"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "AND + A + STRONG + OFFENSE + AS + A + GOOD == DEFENSE"
+    assert_success
+
+    assert_output "A=5 D=3 E=4 F=7 G=8 N=0 O=2 R=1 S=6 T=9"
+
 }
 
 @test "puzzle with ten letters and 199 addends" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run awk -f alphametics.awk <<< "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE == FORTRESSES"
-  assert_success
-  
-  assert_output "A=1 E=0 F=5 H=8 I=7 L=2 O=6 R=3 S=4 T=9"
-  
+[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run awk -f alphametics.awk <<< "THIS + A + FIRE + THEREFORE + FOR + ALL + HISTORIES + I + TELL + A + TALE + THAT + FALSIFIES + ITS + TITLE + TIS + A + LIE + THE + TALE + OF + THE + LAST + FIRE + HORSES + LATE + AFTER + THE + FIRST + FATHERS + FORESEE + THE + HORRORS + THE + LAST + FREE + TROLL + TERRIFIES + THE + HORSES + OF + FIRE + THE + TROLL + RESTS + AT + THE + HOLE + OF + LOSSES + IT + IS + THERE + THAT + SHE + STORES + ROLES + OF + LEATHERS + AFTER + SHE + SATISFIES + HER + HATE + OFF + THOSE + FEARS + A + TASTE + RISES + AS + SHE + HEARS + THE + LEAST + FAR + HORSE + THOSE + FAST + HORSES + THAT + FIRST + HEAR + THE + TROLL + FLEE + OFF + TO + THE + FOREST + THE + HORSES + THAT + ALERTS + RAISE + THE + STARES + OF + THE + OTHERS + AS + THE + TROLL + ASSAILS + AT + THE + TOTAL + SHIFT + HER + TEETH + TEAR + HOOF + OFF + TORSO + AS + THE + LAST + HORSE + FORFEITS + ITS + LIFE + THE + FIRST + FATHERS + HEAR + OF + THE + HORRORS + THEIR + FEARS + THAT + THE + FIRES + FOR + THEIR + FEASTS + ARREST + AS + THE + FIRST + FATHERS + RESETTLE + THE + LAST + OF + THE + FIRE + HORSES + THE + LAST + TROLL + HARASSES + THE + FOREST + HEART + FREE + AT + LAST + OF + THE + LAST + TROLL + ALL + OFFER + THEIR + FIRE + HEAT + TO + THE + ASSISTERS + FAR + OFF + THE + TROLL + FASTS + ITS + LIFE + SHORTER + AS + STARS + RISE + THE + HORSES + REST + SAFE + AFTER + ALL + SHARE + HOT + FISH + AS + THEIR + AFFILIATES + TAILOR + A + ROOFS + FOR + THEIR + SAFE == FORTRESSES"
+    assert_success
+
+    assert_output "A=1 E=0 F=5 H=8 I=7 L=2 O=6 R=3 S=4 T=9"
+
 }
 
diff --git a/exercises/practice/armstrong-numbers/.meta/template.j2 b/exercises/practice/armstrong-numbers/.meta/template.j2
index ce2e5bf..4375948 100644
--- a/exercises/practice/armstrong-numbers/.meta/template.j2
+++ b/exercises/practice/armstrong-numbers/.meta/template.j2
@@ -5,13 +5,13 @@
 #   https://exercism.org/tracks/awk/exercises/grains
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  {%- set flags="" %}
-  {%- if case["input"]["number"] > 10000000 %}
-    {%- set flags="-M " %}
-  {%- endif %}
-  run gawk {{ flags}}-f {{ solution }} -v num={{ case["input"]["number"] }}
-  assert_success
-  assert_output "{{ case["expected"] | lower }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    {%- set flags="" %}
+    {%- if case["input"]["number"] > 10000000 %}
+        {%- set flags="-M " %}
+    {%- endif %}
+    run gawk {{ flags}}-f {{ solution }} -v num={{ case["input"]["number"] }}
+    assert_success
+    assert_output "{{ case["expected"] | lower }}"
 }
 {% endfor %}
diff --git a/exercises/practice/armstrong-numbers/test-armstrong-numbers.bats b/exercises/practice/armstrong-numbers/test-armstrong-numbers.bats
index 27e4af2..e91dac8 100644
--- a/exercises/practice/armstrong-numbers/test-armstrong-numbers.bats
+++ b/exercises/practice/armstrong-numbers/test-armstrong-numbers.bats
@@ -1,86 +1,86 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:58:47+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 # The two large tests require the -M option to handle big numbers.
 # Refer to the instructions of the Grains exercise:
 #   https://exercism.org/tracks/awk/exercises/grains
 
 @test "Zero is an Armstrong number" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=0
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=0
+    assert_success
+    assert_output "true"
 }
 
 @test "Single-digit numbers are Armstrong numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=5
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=5
+    assert_success
+    assert_output "true"
 }
 
 @test "There are no two-digit Armstrong numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=10
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=10
+    assert_success
+    assert_output "false"
 }
 
 @test "Three-digit number that is an Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=153
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=153
+    assert_success
+    assert_output "true"
 }
 
 @test "Three-digit number that is not an Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=100
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=100
+    assert_success
+    assert_output "false"
 }
 
 @test "Four-digit number that is an Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=9474
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=9474
+    assert_success
+    assert_output "true"
 }
 
 @test "Four-digit number that is not an Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=9475
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=9475
+    assert_success
+    assert_output "false"
 }
 
 @test "Seven-digit number that is an Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=9926315
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=9926315
+    assert_success
+    assert_output "true"
 }
 
 @test "Seven-digit number that is not an Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f armstrong-numbers.awk -v num=9926314
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f armstrong-numbers.awk -v num=9926314
+    assert_success
+    assert_output "false"
 }
 
 @test "Armstrong number containing seven zeroes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -M -f armstrong-numbers.awk -v num=186709961001538790100634132976990
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -M -f armstrong-numbers.awk -v num=186709961001538790100634132976990
+    assert_success
+    assert_output "true"
 }
 
 @test "The largest and last Armstrong number" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -M -f armstrong-numbers.awk -v num=115132219018763992565095597973971522401
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -M -f armstrong-numbers.awk -v num=115132219018763992565095597973971522401
+    assert_success
+    assert_output "true"
 }
 
diff --git a/exercises/practice/atbash-cipher/.meta/template.j2 b/exercises/practice/atbash-cipher/.meta/template.j2
index 00d4ab3..07674f0 100644
--- a/exercises/practice/atbash-cipher/.meta/template.j2
+++ b/exercises/practice/atbash-cipher/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} -v direction={{ case["property"] }} <<< "{{ case["input"]["phrase"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} -v direction={{ case["property"] }} <<< "{{ case["input"]["phrase"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/atbash-cipher/test-atbash-cipher.bats b/exercises/practice/atbash-cipher/test-atbash-cipher.bats
index 674346d..27c8c02 100644
--- a/exercises/practice/atbash-cipher/test-atbash-cipher.bats
+++ b/exercises/practice/atbash-cipher/test-atbash-cipher.bats
@@ -1,103 +1,103 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:58:49+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test "encode yes" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "yes"
-  assert_success
-  assert_output "bvh"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "yes"
+    assert_success
+    assert_output "bvh"
 }
 
 @test "encode no" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "no"
-  assert_success
-  assert_output "ml"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "no"
+    assert_success
+    assert_output "ml"
 }
 
 @test "encode OMG" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "OMG"
-  assert_success
-  assert_output "lnt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "OMG"
+    assert_success
+    assert_output "lnt"
 }
 
 @test "encode spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "O M G"
-  assert_success
-  assert_output "lnt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "O M G"
+    assert_success
+    assert_output "lnt"
 }
 
 @test "encode mindblowingly" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "mindblowingly"
-  assert_success
-  assert_output "nrmwy oldrm tob"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "mindblowingly"
+    assert_success
+    assert_output "nrmwy oldrm tob"
 }
 
 @test "encode numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "Testing,1 2 3, testing."
-  assert_success
-  assert_output "gvhgr mt123 gvhgr mt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "Testing,1 2 3, testing."
+    assert_success
+    assert_output "gvhgr mt123 gvhgr mt"
 }
 
 @test "encode deep thought" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "Truth is fiction."
-  assert_success
-  assert_output "gifgs rhurx grlm"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "Truth is fiction."
+    assert_success
+    assert_output "gifgs rhurx grlm"
 }
 
 @test "encode all the letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=encode <<< "The quick brown fox jumps over the lazy dog."
-  assert_success
-  assert_output "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=encode <<< "The quick brown fox jumps over the lazy dog."
+    assert_success
+    assert_output "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
 }
 
 @test "decode exercism" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=decode <<< "vcvix rhn"
-  assert_success
-  assert_output "exercism"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=decode <<< "vcvix rhn"
+    assert_success
+    assert_output "exercism"
 }
 
 @test "decode a sentence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=decode <<< "zmlyh gzxov rhlug vmzhg vkkrm thglm v"
-  assert_success
-  assert_output "anobstacleisoftenasteppingstone"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=decode <<< "zmlyh gzxov rhlug vmzhg vkkrm thglm v"
+    assert_success
+    assert_output "anobstacleisoftenasteppingstone"
 }
 
 @test "decode numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=decode <<< "gvhgr mt123 gvhgr mt"
-  assert_success
-  assert_output "testing123testing"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=decode <<< "gvhgr mt123 gvhgr mt"
+    assert_success
+    assert_output "testing123testing"
 }
 
 @test "decode all the letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=decode <<< "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
-  assert_success
-  assert_output "thequickbrownfoxjumpsoverthelazydog"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=decode <<< "gsvjf rxpyi ldmul cqfnk hlevi gsvoz abwlt"
+    assert_success
+    assert_output "thequickbrownfoxjumpsoverthelazydog"
 }
 
 @test "decode with too many spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=decode <<< "vc vix    r hn"
-  assert_success
-  assert_output "exercism"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=decode <<< "vc vix    r hn"
+    assert_success
+    assert_output "exercism"
 }
 
 @test "decode with no spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f atbash-cipher.awk -v direction=decode <<< "zmlyhgzxovrhlugvmzhgvkkrmthglmv"
-  assert_success
-  assert_output "anobstacleisoftenasteppingstone"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f atbash-cipher.awk -v direction=decode <<< "zmlyhgzxovrhlugvmzhgvkkrmthglmv"
+    assert_success
+    assert_output "anobstacleisoftenasteppingstone"
 }
 
diff --git a/exercises/practice/bob/.meta/template.j2 b/exercises/practice/bob/.meta/template.j2
index 80cd2c2..52a42a4 100644
--- a/exercises/practice/bob/.meta/template.j2
+++ b/exercises/practice/bob/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< ${{ case["input"]["heyBob"] | repr}}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< ${{ case["input"]["heyBob"] | repr}}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/bob/test-bob.bats b/exercises/practice/bob/test-bob.bats
index d56ffb9..ce969b2 100644
--- a/exercises/practice/bob/test-bob.bats
+++ b/exercises/practice/bob/test-bob.bats
@@ -1,187 +1,187 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:58:53+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test "asking a question" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'Does this cryogenic chamber make me look fat?'
-  assert_success
-  assert_output "Sure."
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'Does this cryogenic chamber make me look fat?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "shouting" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'WATCH OUT!'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'WATCH OUT!'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "forceful question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $"WHAT'S GOING ON?"
-  assert_success
-  assert_output "Calm down, I know what I'm doing!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $"WHAT'S GOING ON?"
+    assert_success
+    assert_output "Calm down, I know what I'm doing!"
 }
 
 @test "silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $''
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $''
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "stating something" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'Tom-ay-to, tom-aaaah-to.'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'Tom-ay-to, tom-aaaah-to.'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "asking a numeric question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'You are, what, like 15?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'You are, what, like 15?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "asking gibberish" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'fffbbcbeab?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'fffbbcbeab?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "question with no letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'4?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'4?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "non-letters with question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $':) ?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $':) ?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "prattling on" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'Wait! Hang on. Are you going to be OK?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'Wait! Hang on. Are you going to be OK?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "ending with whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'Okay if like my  spacebar  quite a bit?   '
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'Okay if like my  spacebar  quite a bit?   '
+    assert_success
+    assert_output "Sure."
 }
 
 @test "multiple line question" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'\nDoes this cryogenic chamber make\n me look fat?'
-  assert_success
-  assert_output "Sure."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'\nDoes this cryogenic chamber make\n me look fat?'
+    assert_success
+    assert_output "Sure."
 }
 
 @test "shouting gibberish" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'FCECDFCAAB'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'FCECDFCAAB'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting a statement containing a question mark" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'DO LIONS EAT PEOPLE? AHHHHH.'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'DO LIONS EAT PEOPLE? AHHHHH.'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'1, 2, 3 GO!'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'1, 2, 3 GO!'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting with special characters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'ZOMG THE %^*@#$(*^ ZOMBIES ARE COMING!!11!!1!'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "shouting with no exclamation mark" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'I HATE THE DENTIST'
-  assert_success
-  assert_output "Whoa, chill out!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'I HATE THE DENTIST'
+    assert_success
+    assert_output "Whoa, chill out!"
 }
 
 @test "prolonged silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'          '
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'          '
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "alternate silence" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'\t\t\t\t\t\t\t\t\t\t'
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'\t\t\t\t\t\t\t\t\t\t'
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "other whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'\n\r \t'
-  assert_success
-  assert_output "Fine. Be that way!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'\n\r \t'
+    assert_success
+    assert_output "Fine. Be that way!"
 }
 
 @test "talking forcefully" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'Hi there!'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'Hi there!'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "using acronyms in regular speech" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $"It's OK if you don't want to go work for NASA."
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $"It's OK if you don't want to go work for NASA."
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "no letters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'1, 2, 3'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'1, 2, 3'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "statement containing question mark" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'Ending with ? means a question.'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'Ending with ? means a question.'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "starting with whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'         hmmmmmmm...'
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'         hmmmmmmm...'
+    assert_success
+    assert_output "Whatever."
 }
 
 @test "non-question ending with whitespace" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f bob.awk <<< $'This is a statement ending with whitespace      '
-  assert_success
-  assert_output "Whatever."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f bob.awk <<< $'This is a statement ending with whitespace      '
+    assert_success
+    assert_output "Whatever."
 }
 
diff --git a/exercises/practice/clock/.meta/template.j2 b/exercises/practice/clock/.meta/template.j2
index 6e753eb..0c160d3 100644
--- a/exercises/practice/clock/.meta/template.j2
+++ b/exercises/practice/clock/.meta/template.j2
@@ -10,24 +10,24 @@
 
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  {%- if case["property"] == "equal" %}
-    {%- set args = [
-          case["property"],
-          case["input"]["clock1"]["hour"],
-          case["input"]["clock1"]["minute"],
-          case["input"]["clock2"]["hour"],
-          case["input"]["clock2"]["minute"]
-        ]
-  %}
-  {%- else %}
-    {%- set args = [case["property"], case["input"]["hour"], case["input"]["minute"]] %}
-    {%- if case["property"] in ["add", "subtract"] %}
-      {%- set args = args + [case["input"]["value"]] %}
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    {%- if case["property"] == "equal" %}
+        {%- set args = [
+              case["property"],
+              case["input"]["clock1"]["hour"],
+              case["input"]["clock1"]["minute"],
+              case["input"]["clock2"]["hour"],
+              case["input"]["clock2"]["minute"]
+            ]
+        %}
+    {%- else %}
+        {%- set args = [case["property"], case["input"]["hour"], case["input"]["minute"]] %}
+        {%- if case["property"] in ["add", "subtract"] %}
+            {%- set args = args + [case["input"]["value"]] %}
+        {%- endif %}
     {%- endif %}
-  {%- endif %}
-  run gawk -f {{ solution }} <<< "{{ args | join(" ") }}"
-  assert_success
-  assert_output "{{ case["expected"] | lower }}"
+    run gawk -f {{ solution }} <<< "{{ args | join(" ") }}"
+    assert_success
+    assert_output "{{ case["expected"] | lower }}"
 }
 {% endfor %}
diff --git a/exercises/practice/clock/test-clock.bats b/exercises/practice/clock/test-clock.bats
index 97013c6..aeeb5ae 100644
--- a/exercises/practice/clock/test-clock.bats
+++ b/exercises/practice/clock/test-clock.bats
@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:03+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 # The AWK program will be given data in the following formats,
 # where the first field is the command, followed by parameters.
@@ -13,366 +13,366 @@ load bats-extra
 
 
 @test "on the hour" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 8 0"
-  assert_success
-  assert_output "08:00"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 8 0"
+    assert_success
+    assert_output "08:00"
 }
 
 @test "past the hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 11 9"
-  assert_success
-  assert_output "11:09"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 11 9"
+    assert_success
+    assert_output "11:09"
 }
 
 @test "midnight is zero hours" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 24 0"
-  assert_success
-  assert_output "00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 24 0"
+    assert_success
+    assert_output "00:00"
 }
 
 @test "hour rolls over" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 25 0"
-  assert_success
-  assert_output "01:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 25 0"
+    assert_success
+    assert_output "01:00"
 }
 
 @test "hour rolls over continuously" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 100 0"
-  assert_success
-  assert_output "04:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 100 0"
+    assert_success
+    assert_output "04:00"
 }
 
 @test "sixty minutes is next hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 1 60"
-  assert_success
-  assert_output "02:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 1 60"
+    assert_success
+    assert_output "02:00"
 }
 
 @test "minutes roll over" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 0 160"
-  assert_success
-  assert_output "02:40"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 0 160"
+    assert_success
+    assert_output "02:40"
 }
 
 @test "minutes roll over continuously" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 0 1723"
-  assert_success
-  assert_output "04:43"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 0 1723"
+    assert_success
+    assert_output "04:43"
 }
 
 @test "hour and minutes roll over" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 25 160"
-  assert_success
-  assert_output "03:40"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 25 160"
+    assert_success
+    assert_output "03:40"
 }
 
 @test "hour and minutes roll over continuously" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 201 3001"
-  assert_success
-  assert_output "11:01"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 201 3001"
+    assert_success
+    assert_output "11:01"
 }
 
 @test "hour and minutes roll over to exactly midnight" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 72 8640"
-  assert_success
-  assert_output "00:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 72 8640"
+    assert_success
+    assert_output "00:00"
 }
 
 @test "negative hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create -1 15"
-  assert_success
-  assert_output "23:15"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create -1 15"
+    assert_success
+    assert_output "23:15"
 }
 
 @test "negative hour rolls over" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create -25 0"
-  assert_success
-  assert_output "23:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create -25 0"
+    assert_success
+    assert_output "23:00"
 }
 
 @test "negative hour rolls over continuously" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create -91 0"
-  assert_success
-  assert_output "05:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create -91 0"
+    assert_success
+    assert_output "05:00"
 }
 
 @test "negative minutes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 1 -40"
-  assert_success
-  assert_output "00:20"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 1 -40"
+    assert_success
+    assert_output "00:20"
 }
 
 @test "negative minutes roll over" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 1 -160"
-  assert_success
-  assert_output "22:20"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 1 -160"
+    assert_success
+    assert_output "22:20"
 }
 
 @test "negative minutes roll over continuously" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 1 -4820"
-  assert_success
-  assert_output "16:40"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 1 -4820"
+    assert_success
+    assert_output "16:40"
 }
 
 @test "negative sixty minutes is previous hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create 2 -60"
-  assert_success
-  assert_output "01:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create 2 -60"
+    assert_success
+    assert_output "01:00"
 }
 
 @test "negative hour and minutes both roll over" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create -25 -160"
-  assert_success
-  assert_output "20:20"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create -25 -160"
+    assert_success
+    assert_output "20:20"
 }
 
 @test "negative hour and minutes both roll over continuously" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "create -121 -5810"
-  assert_success
-  assert_output "22:10"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "create -121 -5810"
+    assert_success
+    assert_output "22:10"
 }
 
 @test "add minutes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 10 0 3"
-  assert_success
-  assert_output "10:03"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 10 0 3"
+    assert_success
+    assert_output "10:03"
 }
 
 @test "add no minutes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 6 41 0"
-  assert_success
-  assert_output "06:41"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 6 41 0"
+    assert_success
+    assert_output "06:41"
 }
 
 @test "add to next hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 0 45 40"
-  assert_success
-  assert_output "01:25"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 0 45 40"
+    assert_success
+    assert_output "01:25"
 }
 
 @test "add more than one hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 10 0 61"
-  assert_success
-  assert_output "11:01"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 10 0 61"
+    assert_success
+    assert_output "11:01"
 }
 
 @test "add more than two hours with carry" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 0 45 160"
-  assert_success
-  assert_output "03:25"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 0 45 160"
+    assert_success
+    assert_output "03:25"
 }
 
 @test "add across midnight" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 23 59 2"
-  assert_success
-  assert_output "00:01"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 23 59 2"
+    assert_success
+    assert_output "00:01"
 }
 
 @test "add more than one day (1500 min = 25 hrs)" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 5 32 1500"
-  assert_success
-  assert_output "06:32"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 5 32 1500"
+    assert_success
+    assert_output "06:32"
 }
 
 @test "add more than two days" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "add 1 1 3500"
-  assert_success
-  assert_output "11:21"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "add 1 1 3500"
+    assert_success
+    assert_output "11:21"
 }
 
 @test "subtract minutes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 10 3 3"
-  assert_success
-  assert_output "10:00"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 10 3 3"
+    assert_success
+    assert_output "10:00"
 }
 
 @test "subtract to previous hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 10 3 30"
-  assert_success
-  assert_output "09:33"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 10 3 30"
+    assert_success
+    assert_output "09:33"
 }
 
 @test "subtract more than an hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 10 3 70"
-  assert_success
-  assert_output "08:53"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 10 3 70"
+    assert_success
+    assert_output "08:53"
 }
 
 @test "subtract across midnight" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 0 3 4"
-  assert_success
-  assert_output "23:59"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 0 3 4"
+    assert_success
+    assert_output "23:59"
 }
 
 @test "subtract more than two hours" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 0 0 160"
-  assert_success
-  assert_output "21:20"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 0 0 160"
+    assert_success
+    assert_output "21:20"
 }
 
 @test "subtract more than two hours with borrow" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 6 15 160"
-  assert_success
-  assert_output "03:35"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 6 15 160"
+    assert_success
+    assert_output "03:35"
 }
 
 @test "subtract more than one day (1500 min = 25 hrs)" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 5 32 1500"
-  assert_success
-  assert_output "04:32"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 5 32 1500"
+    assert_success
+    assert_output "04:32"
 }
 
 @test "subtract more than two days" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "subtract 2 20 3000"
-  assert_success
-  assert_output "00:20"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "subtract 2 20 3000"
+    assert_success
+    assert_output "00:20"
 }
 
 @test "clocks with same time" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 15 37 15 37"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 15 37 15 37"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks a minute apart" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 15 36 15 37"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 15 36 15 37"
+    assert_success
+    assert_output "false"
 }
 
 @test "clocks an hour apart" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 14 37 15 37"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 14 37 15 37"
+    assert_success
+    assert_output "false"
 }
 
 @test "clocks with hour overflow" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 10 37 34 37"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 10 37 34 37"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with hour overflow by several days" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 3 11 99 11"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 3 11 99 11"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative hour" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 22 40 -2 40"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 22 40 -2 40"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative hour that wraps" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 17 3 -31 3"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 17 3 -31 3"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative hour that wraps multiple times" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 13 49 -83 49"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 13 49 -83 49"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with minute overflow" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 0 1 0 1441"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 0 1 0 1441"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with minute overflow by several days" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 2 2 2 4322"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 2 2 2 4322"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative minute" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 2 40 3 -20"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 2 40 3 -20"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative minute that wraps" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 4 10 5 -1490"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 4 10 5 -1490"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative minute that wraps multiple times" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 6 15 6 -4305"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 6 15 6 -4305"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative hours and minutes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 7 32 -12 -268"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 7 32 -12 -268"
+    assert_success
+    assert_output "true"
 }
 
 @test "clocks with negative hours and minutes that wrap" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 18 7 -54 -11513"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 18 7 -54 -11513"
+    assert_success
+    assert_output "true"
 }
 
 @test "full clock and zeroed clock" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f clock.awk <<< "equal 24 0 0 0"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f clock.awk <<< "equal 24 0 0 0"
+    assert_success
+    assert_output "true"
 }
 
diff --git a/exercises/practice/collatz-conjecture/.meta/template.j2 b/exercises/practice/collatz-conjecture/.meta/template.j2
index 2223cec..9138600 100644
--- a/exercises/practice/collatz-conjecture/.meta/template.j2
+++ b/exercises/practice/collatz-conjecture/.meta/template.j2
@@ -1,14 +1,14 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["number"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["number"] }}"
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output "Error: {{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output "Error: {{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/collatz-conjecture/test-collatz-conjecture.bats b/exercises/practice/collatz-conjecture/test-collatz-conjecture.bats
index f64abd2..4d1ac9c 100644
--- a/exercises/practice/collatz-conjecture/test-collatz-conjecture.bats
+++ b/exercises/practice/collatz-conjecture/test-collatz-conjecture.bats
@@ -1,47 +1,47 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:07+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "zero steps for one" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f collatz-conjecture.awk <<< "1"
-  assert_success
-  assert_output "0"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f collatz-conjecture.awk <<< "1"
+    assert_success
+    assert_output "0"
 }
 
 @test "divide if even" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f collatz-conjecture.awk <<< "16"
-  assert_success
-  assert_output "4"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f collatz-conjecture.awk <<< "16"
+    assert_success
+    assert_output "4"
 }
 
 @test "even and odd steps" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f collatz-conjecture.awk <<< "12"
-  assert_success
-  assert_output "9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f collatz-conjecture.awk <<< "12"
+    assert_success
+    assert_output "9"
 }
 
 @test "large number of even and odd steps" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f collatz-conjecture.awk <<< "1000000"
-  assert_success
-  assert_output "152"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f collatz-conjecture.awk <<< "1000000"
+    assert_success
+    assert_output "152"
 }
 
 @test "zero is an error" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f collatz-conjecture.awk <<< "0"
-  assert_failure
-  assert_output "Error: Only positive integers are allowed"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f collatz-conjecture.awk <<< "0"
+    assert_failure
+    assert_output "Error: Only positive integers are allowed"
 }
 
 @test "negative value is an error" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f collatz-conjecture.awk <<< "-15"
-  assert_failure
-  assert_output "Error: Only positive integers are allowed"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f collatz-conjecture.awk <<< "-15"
+    assert_failure
+    assert_output "Error: Only positive integers are allowed"
 }
 
diff --git a/exercises/practice/difference-of-squares/.meta/template.j2 b/exercises/practice/difference-of-squares/.meta/template.j2
index 9517fd5..8820517 100644
--- a/exercises/practice/difference-of-squares/.meta/template.j2
+++ b/exercises/practice/difference-of-squares/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["property"] | camel_to_snake | replace("difference_of_squares", "difference") }},{{ case["input"]["number"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["property"] | camel_to_snake | replace("difference_of_squares", "difference") }},{{ case["input"]["number"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/difference-of-squares/test-difference-of-squares.bats b/exercises/practice/difference-of-squares/test-difference-of-squares.bats
index 57d2542..ebcb79d 100644
--- a/exercises/practice/difference-of-squares/test-difference-of-squares.bats
+++ b/exercises/practice/difference-of-squares/test-difference-of-squares.bats
@@ -1,67 +1,68 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T21:20:57+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "square of sum 1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "square_of_sum,1"
-  assert_success
-  assert_output "1"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "square_of_sum,1"
+    assert_success
+    assert_output "1"
 }
 
 @test "square of sum 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "square_of_sum,5"
-  assert_success
-  assert_output "225"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "square_of_sum,5"
+    assert_success
+    assert_output "225"
 }
 
 @test "square of sum 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "square_of_sum,100"
-  assert_success
-  assert_output "25502500"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "square_of_sum,100"
+    assert_success
+    assert_output "25502500"
 }
 
 @test "sum of squares 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "sum_of_squares,1"
-  assert_success
-  assert_output "1"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "sum_of_squares,1"
+    assert_success
+    assert_output "1"
 }
 
 @test "sum of squares 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "sum_of_squares,5"
-  assert_success
-  assert_output "55"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "sum_of_squares,5"
+    assert_success
+    assert_output "55"
 }
 
 @test "sum of squares 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "sum_of_squares,100"
-  assert_success
-  assert_output "338350"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "sum_of_squares,100"
+    assert_success
+    assert_output "338350"
 }
 
 @test "difference of squares 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "difference,1"
-  assert_success
-  assert_output "0"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "difference,1"
+    assert_success
+    assert_output "0"
 }
 
 @test "difference of squares 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "difference,5"
-  assert_success
-  assert_output "170"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "difference,5"
+    assert_success
+    assert_output "170"
 }
 
 @test "difference of squares 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f difference-of-squares.awk <<< "difference,100"
-  assert_success
-  assert_output "25164150"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f difference-of-squares.awk <<< "difference,100"
+    assert_success
+    assert_output "25164150"
 }
+
diff --git a/exercises/practice/gigasecond/.meta/template.j2 b/exercises/practice/gigasecond/.meta/template.j2
index efda424..cde7aac 100644
--- a/exercises/practice/gigasecond/.meta/template.j2
+++ b/exercises/practice/gigasecond/.meta/template.j2
@@ -1,10 +1,10 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  run gawk -f {{ solution }} <<< '{{ case["input"]["moment"] }}'
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    run gawk -f {{ solution }} <<< '{{ case["input"]["moment"] }}'
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/gigasecond/test-gigasecond.bats b/exercises/practice/gigasecond/test-gigasecond.bats
index 9aa94b0..f51ecf8 100644
--- a/exercises/practice/gigasecond/test-gigasecond.bats
+++ b/exercises/practice/gigasecond/test-gigasecond.bats
@@ -1,45 +1,45 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:23+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test 'date only specification of time' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  run gawk -f gigasecond.awk <<< '2011-04-25'
-  assert_success
-  assert_output "2043-01-01T01:46:40"
+    run gawk -f gigasecond.awk <<< '2011-04-25'
+    assert_success
+    assert_output "2043-01-01T01:46:40"
 }
 
 @test 'second test for date only specification of time' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  run gawk -f gigasecond.awk <<< '1977-06-13'
-  assert_success
-  assert_output "2009-02-19T01:46:40"
+    run gawk -f gigasecond.awk <<< '1977-06-13'
+    assert_success
+    assert_output "2009-02-19T01:46:40"
 }
 
 @test 'third test for date only specification of time' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  run gawk -f gigasecond.awk <<< '1959-07-19'
-  assert_success
-  assert_output "1991-03-27T01:46:40"
+    run gawk -f gigasecond.awk <<< '1959-07-19'
+    assert_success
+    assert_output "1991-03-27T01:46:40"
 }
 
 @test 'full time specified' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  run gawk -f gigasecond.awk <<< '2015-01-24T22:00:00'
-  assert_success
-  assert_output "2046-10-02T23:46:40"
+    run gawk -f gigasecond.awk <<< '2015-01-24T22:00:00'
+    assert_success
+    assert_output "2046-10-02T23:46:40"
 }
 
 @test 'full time with day roll-over' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
 
-  run gawk -f gigasecond.awk <<< '2015-01-24T23:59:59'
-  assert_success
-  assert_output "2046-10-03T01:46:39"
+    run gawk -f gigasecond.awk <<< '2015-01-24T23:59:59'
+    assert_success
+    assert_output "2046-10-03T01:46:39"
 }
 
diff --git a/exercises/practice/grains/.meta/template.j2 b/exercises/practice/grains/.meta/template.j2
index 89312d1..1b82a7c 100644
--- a/exercises/practice/grains/.meta/template.j2
+++ b/exercises/practice/grains/.meta/template.j2
@@ -1,18 +1,18 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
 {%- if case["property"] == "total" %}
-  run gawk -M -f {{ solution }} <<< total
+    run gawk -M -f {{ solution }} <<< total
 {%- else %}
-  run gawk -f {{ solution }} <<< {{ case["input"]["square"] }}
+    run gawk -f {{ solution }} <<< {{ case["input"]["square"] }}
 {%- endif %}
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output "{{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output "{{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/grains/test-grains.bats b/exercises/practice/grains/test-grains.bats
index f092499..e669737 100644
--- a/exercises/practice/grains/test-grains.bats
+++ b/exercises/practice/grains/test-grains.bats
@@ -1,82 +1,82 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:26+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "grains on square 1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 1
-  assert_success
-  assert_output "1"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 1
+    assert_success
+    assert_output "1"
 }
 
 @test "grains on square 2" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 2
-  assert_success
-  assert_output "2"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 2
+    assert_success
+    assert_output "2"
 }
 
 @test "grains on square 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 3
-  assert_success
-  assert_output "4"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 3
+    assert_success
+    assert_output "4"
 }
 
 @test "grains on square 4" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 4
-  assert_success
-  assert_output "8"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 4
+    assert_success
+    assert_output "8"
 }
 
 @test "grains on square 16" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 16
-  assert_success
-  assert_output "32768"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 16
+    assert_success
+    assert_output "32768"
 }
 
 @test "grains on square 32" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 32
-  assert_success
-  assert_output "2147483648"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 32
+    assert_success
+    assert_output "2147483648"
 }
 
 @test "grains on square 64" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 64
-  assert_success
-  assert_output "9223372036854775808"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 64
+    assert_success
+    assert_output "9223372036854775808"
 }
 
 @test "square 0 is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 0
-  assert_failure
-  assert_output "square must be between 1 and 64"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 0
+    assert_failure
+    assert_output "square must be between 1 and 64"
 }
 
 @test "negative square is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< -1
-  assert_failure
-  assert_output "square must be between 1 and 64"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< -1
+    assert_failure
+    assert_output "square must be between 1 and 64"
 }
 
 @test "square greater than 64 is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f grains.awk <<< 65
-  assert_failure
-  assert_output "square must be between 1 and 64"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f grains.awk <<< 65
+    assert_failure
+    assert_output "square must be between 1 and 64"
 }
 
 @test "returns the total number of grains on the board" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -M -f grains.awk <<< total
-  assert_success
-  assert_output "18446744073709551615"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -M -f grains.awk <<< total
+    assert_success
+    assert_output "18446744073709551615"
 }
 
diff --git a/exercises/practice/hamming/.meta/template.j2 b/exercises/practice/hamming/.meta/template.j2
index b85f7da..c7e2f25 100644
--- a/exercises/practice/hamming/.meta/template.j2
+++ b/exercises/practice/hamming/.meta/template.j2
@@ -10,15 +10,15 @@ teardown() {
 }
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file '{{ case["input"]["strand1"] }}' '{{ case["input"]["strand2"] }}'
-  run gawk -f {{ solution }} input.txt
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file '{{ case["input"]["strand1"] }}' '{{ case["input"]["strand2"] }}'
+    run gawk -f {{ solution }} input.txt
 {%- if case["expect_error"] %}
-  assert_failure
-  assert_output --partial "{{ case["expect_error_msg"] }}"
+    assert_failure
+    assert_output --partial "{{ case["expect_error_msg"] }}"
 {%- else %}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 {%- endif %}
 }
 {% endfor %}
diff --git a/exercises/practice/hamming/test-hamming.bats b/exercises/practice/hamming/test-hamming.bats
index 8e6c50e..53940b6 100644
--- a/exercises/practice/hamming/test-hamming.bats
+++ b/exercises/practice/hamming/test-hamming.bats
@@ -1,7 +1,7 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T15:57:01+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 populate_test_file() {
     echo "$1" > input.txt
@@ -13,73 +13,74 @@ teardown() {
 }
 
 @test 'empty strands' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file '' ''
-  run gawk -f hamming.awk input.txt
-  assert_success
-  assert_output "0"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file '' ''
+    run gawk -f hamming.awk input.txt
+    assert_success
+    assert_output "0"
 }
 
 @test 'single letter identical strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'A' 'A'
-  run gawk -f hamming.awk input.txt
-  assert_success
-  assert_output "0"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'A' 'A'
+    run gawk -f hamming.awk input.txt
+    assert_success
+    assert_output "0"
 }
 
 @test 'single letter different strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'G' 'T'
-  run gawk -f hamming.awk input.txt
-  assert_success
-  assert_output "1"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'G' 'T'
+    run gawk -f hamming.awk input.txt
+    assert_success
+    assert_output "1"
 }
 
 @test 'long identical strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'GGACTGAAATCTG' 'GGACTGAAATCTG'
-  run gawk -f hamming.awk input.txt
-  assert_success
-  assert_output "0"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'GGACTGAAATCTG' 'GGACTGAAATCTG'
+    run gawk -f hamming.awk input.txt
+    assert_success
+    assert_output "0"
 }
 
 @test 'long different strands' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'GGACGGATTCTG' 'AGGACGGATTCT'
-  run gawk -f hamming.awk input.txt
-  assert_success
-  assert_output "9"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'GGACGGATTCTG' 'AGGACGGATTCT'
+    run gawk -f hamming.awk input.txt
+    assert_success
+    assert_output "9"
 }
 
 @test 'disallow first strand longer' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'AATG' 'AAA'
-  run gawk -f hamming.awk input.txt
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'AATG' 'AAA'
+    run gawk -f hamming.awk input.txt
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test 'disallow second strand longer' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'ATA' 'AGTG'
-  run gawk -f hamming.awk input.txt
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'ATA' 'AGTG'
+    run gawk -f hamming.awk input.txt
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test 'disallow empty first strand' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file '' 'G'
-  run gawk -f hamming.awk input.txt
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file '' 'G'
+    run gawk -f hamming.awk input.txt
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
 
 @test 'disallow empty second strand' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  populate_test_file 'G' ''
-  run gawk -f hamming.awk input.txt
-  assert_failure
-  assert_output --partial "strands must be of equal length"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    populate_test_file 'G' ''
+    run gawk -f hamming.awk input.txt
+    assert_failure
+    assert_output --partial "strands must be of equal length"
 }
+
diff --git a/exercises/practice/hello-world/.meta/template.j2 b/exercises/practice/hello-world/.meta/template.j2
index 5124f35..622cec2 100644
--- a/exercises/practice/hello-world/.meta/template.j2
+++ b/exercises/practice/hello-world/.meta/template.j2
@@ -1,12 +1,12 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  run gawk -f {{ solution }}
+    run gawk -f {{ solution }}
 
-  # the program's exit status should be success (0)
-  assert_success
+    # the program's exit status should be success (0)
+    assert_success
 
-  # program's output should be the expected text
-  assert_output "{{ case["expected"] }}"
+    # program's output should be the expected text
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/hello-world/test-hello-world.bats b/exercises/practice/hello-world/test-hello-world.bats
index 254bd71..9a66438 100644
--- a/exercises/practice/hello-world/test-hello-world.bats
+++ b/exercises/practice/hello-world/test-hello-world.bats
@@ -1,14 +1,15 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T15:57:02+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test "Say Hi!" {
-  run gawk -f hello-world.awk
+    run gawk -f hello-world.awk
 
-  # the program's exit status should be success (0)
-  assert_success
+    # the program's exit status should be success (0)
+    assert_success
 
-  # program's output should be the expected text
-  assert_output "Hello, World!"
+    # program's output should be the expected text
+    assert_output "Hello, World!"
 }
+
diff --git a/exercises/practice/isbn-verifier/.meta/template.j2 b/exercises/practice/isbn-verifier/.meta/template.j2
index 00db818..dbfc95a 100644
--- a/exercises/practice/isbn-verifier/.meta/template.j2
+++ b/exercises/practice/isbn-verifier/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["isbn"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["isbn"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/isbn-verifier/test-isbn-verifier.bats b/exercises/practice/isbn-verifier/test-isbn-verifier.bats
index 54c09f6..f4b1215 100644
--- a/exercises/practice/isbn-verifier/test-isbn-verifier.bats
+++ b/exercises/practice/isbn-verifier/test-isbn-verifier.bats
@@ -1,152 +1,152 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:35+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "valid isbn" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21508-8"
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21508-8"
+    assert_success
+    assert_output "true"
 }
 
 @test "invalid isbn check digit" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21508-9"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21508-9"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid isbn with a check digit of 10" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21507-X"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21507-X"
+    assert_success
+    assert_output "true"
 }
 
 @test "check digit is a character other than X" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21507-A"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21507-A"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid check digit in isbn is not treated as zero" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "4-598-21507-B"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "4-598-21507-B"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid character in isbn is not treated as zero" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-P1581-X"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-P1581-X"
+    assert_success
+    assert_output "false"
 }
 
 @test "X is only valid as a check digit" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-2X507-9"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-2X507-9"
+    assert_success
+    assert_output "false"
 }
 
 @test "only one check digit is allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21508-96"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21508-96"
+    assert_success
+    assert_output "false"
 }
 
 @test "X is not substituted by the value 10" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-2X507-5"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-2X507-5"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid isbn without separating dashes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3598215088"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3598215088"
+    assert_success
+    assert_output "true"
 }
 
 @test "isbn without separating dashes and X as check digit" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "359821507X"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "359821507X"
+    assert_success
+    assert_output "true"
 }
 
 @test "isbn without check digit and dashes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "359821507"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "359821507"
+    assert_success
+    assert_output "false"
 }
 
 @test "too long isbn and no dashes" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3598215078X"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3598215078X"
+    assert_success
+    assert_output "false"
 }
 
 @test "too short isbn" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "00"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "00"
+    assert_success
+    assert_output "false"
 }
 
 @test "isbn without check digit" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21507"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21507"
+    assert_success
+    assert_output "false"
 }
 
 @test "check digit of X should not be used for 0" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3-598-21515-X"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3-598-21515-X"
+    assert_success
+    assert_output "false"
 }
 
 @test "empty isbn" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< ""
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< ""
+    assert_success
+    assert_output "false"
 }
 
 @test "input is 9 characters" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "134456729"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "134456729"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid characters are not ignored after checking length" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3132P34035"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3132P34035"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid characters are not ignored before checking length" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "3598P215088"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "3598P215088"
+    assert_success
+    assert_output "false"
 }
 
 @test "input is too long but contains a valid isbn" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f isbn-verifier.awk <<< "98245726788"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f isbn-verifier.awk <<< "98245726788"
+    assert_success
+    assert_output "false"
 }
 
diff --git a/exercises/practice/killer-sudoku-helper/.meta/template.j2 b/exercises/practice/killer-sudoku-helper/.meta/template.j2
index 3810a96..447c0f7 100644
--- a/exercises/practice/killer-sudoku-helper/.meta/template.j2
+++ b/exercises/practice/killer-sudoku-helper/.meta/template.j2
@@ -1,13 +1,13 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 {{ case["expected"] | map("join", " ") | join("\n") }}
 END
 )
-  run gawk -f {{ solution }} <<< "{{ ([case["input"]["cage"]["sum"], case["input"]["cage"]["size"]] + case["input"]["cage"]["exclude"]) | join(" ") }}"
-  assert_success
-  assert_output "$expected"
+    run gawk -f {{ solution }} <<< "{{ ([case["input"]["cage"]["sum"], case["input"]["cage"]["size"]] + case["input"]["cage"]["exclude"]) | join(" ") }}"
+    assert_success
+    assert_output "$expected"
 }
 {% endfor %}
diff --git a/exercises/practice/killer-sudoku-helper/test-killer-sudoku-helper.bats b/exercises/practice/killer-sudoku-helper/test-killer-sudoku-helper.bats
index 1854588..f66ee9f 100644
--- a/exercises/practice/killer-sudoku-helper/test-killer-sudoku-helper.bats
+++ b/exercises/practice/killer-sudoku-helper/test-killer-sudoku-helper.bats
@@ -1,151 +1,152 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T01:58:42+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 1
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "1 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "1 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "2" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 2
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "2 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "2 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 3
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "3 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "3 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "4" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 4
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "4 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "4 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 5
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "5 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "5 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "6" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 6
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "6 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "6 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 7
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "7 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "7 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "8" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 8
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "8 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "8 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "9" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 9
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "9 1"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "9 1"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Cage with sum 45 contains all digits 1:9" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 1 2 3 4 5 6 7 8 9
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "45 9"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "45 9"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Cage with only 1 possible combination" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 1 2 4
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "7 3"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "7 3"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Cage with several combinations" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 1 9
 2 8
 3 7
 4 6
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "10 2"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "10 2"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Cage with several combinations that is restricted" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat << END
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat << END
 2 8
 3 7
 END
 )
-  run gawk -f killer-sudoku-helper.awk <<< "10 2 1 4"
-  assert_success
-  assert_output "$expected"
+    run gawk -f killer-sudoku-helper.awk <<< "10 2 1 4"
+    assert_success
+    assert_output "$expected"
 }
+
diff --git a/exercises/practice/leap/.meta/template.j2 b/exercises/practice/leap/.meta/template.j2
index 66d2668..ee11a93 100644
--- a/exercises/practice/leap/.meta/template.j2
+++ b/exercises/practice/leap/.meta/template.j2
@@ -1,10 +1,10 @@
 {{ header }}
 {% for case in cases %}
 @test '{{ case["description"] }}' {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["year"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["year"] }}"
 
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/leap/test-leap.bats b/exercises/practice/leap/test-leap.bats
index c14d0b3..fc05434 100644
--- a/exercises/practice/leap/test-leap.bats
+++ b/exercises/practice/leap/test-leap.bats
@@ -1,77 +1,77 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:42+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test 'year not divisible by 4 in common year' {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "2015"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "2015"
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 2, not divisible by 4 in common year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "1970"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "1970"
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 4, not divisible by 100 in leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "1996"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "1996"
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 4 and 5 is still a leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "1960"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "1960"
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 100, not divisible by 400 in common year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "2100"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "2100"
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 100 but not by 3 is still not a leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "1900"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "1900"
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
 @test 'year divisible by 400 is leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "2000"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "2000"
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 400 but not by 125 is still a leap year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "2400"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "2400"
 
-  assert_success
-  assert_output "true"
+    assert_success
+    assert_output "true"
 }
 
 @test 'year divisible by 200, not divisible by 400 in common year' {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f leap.awk <<< "1800"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f leap.awk <<< "1800"
 
-  assert_success
-  assert_output "false"
+    assert_success
+    assert_output "false"
 }
 
diff --git a/exercises/practice/line-up/.meta/template.j2 b/exercises/practice/line-up/.meta/template.j2
index 4639a15..0e97525 100644
--- a/exercises/practice/line-up/.meta/template.j2
+++ b/exercises/practice/line-up/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["name"] }} {{ case["input"]["number"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["name"] }} {{ case["input"]["number"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/line-up/test-line-up.bats b/exercises/practice/line-up/test-line-up.bats
index 0bd4358..63fd3ec 100644
--- a/exercises/practice/line-up/test-line-up.bats
+++ b/exercises/practice/line-up/test-line-up.bats
@@ -1,180 +1,180 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-08-14T05:36:15+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "format smallest non-exceptional ordinal numeral 4" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Gianna 4"
-  assert_success
-  assert_output "Gianna, you are the 4th customer we serve today. Thank you!"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Gianna 4"
+    assert_success
+    assert_output "Gianna, you are the 4th customer we serve today. Thank you!"
 }
 
 @test "format greatest single digit non-exceptional ordinal numeral 9" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Maarten 9"
-  assert_success
-  assert_output "Maarten, you are the 9th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Maarten 9"
+    assert_success
+    assert_output "Maarten, you are the 9th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Petronila 5"
-  assert_success
-  assert_output "Petronila, you are the 5th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Petronila 5"
+    assert_success
+    assert_output "Petronila, you are the 5th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 6" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Attakullakulla 6"
-  assert_success
-  assert_output "Attakullakulla, you are the 6th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Attakullakulla 6"
+    assert_success
+    assert_output "Attakullakulla, you are the 6th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Kate 7"
-  assert_success
-  assert_output "Kate, you are the 7th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Kate 7"
+    assert_success
+    assert_output "Kate, you are the 7th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 8" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Maximiliano 8"
-  assert_success
-  assert_output "Maximiliano, you are the 8th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Maximiliano 8"
+    assert_success
+    assert_output "Maximiliano, you are the 8th customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 1" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Mary 1"
-  assert_success
-  assert_output "Mary, you are the 1st customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Mary 1"
+    assert_success
+    assert_output "Mary, you are the 1st customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 2" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Haruto 2"
-  assert_success
-  assert_output "Haruto, you are the 2nd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Haruto 2"
+    assert_success
+    assert_output "Haruto, you are the 2nd customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Henriette 3"
-  assert_success
-  assert_output "Henriette, you are the 3rd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Henriette 3"
+    assert_success
+    assert_output "Henriette, you are the 3rd customer we serve today. Thank you!"
 }
 
 @test "format smallest two digit non-exceptional ordinal numeral 10" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Alvarez 10"
-  assert_success
-  assert_output "Alvarez, you are the 10th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Alvarez 10"
+    assert_success
+    assert_output "Alvarez, you are the 10th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 11" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Jacqueline 11"
-  assert_success
-  assert_output "Jacqueline, you are the 11th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Jacqueline 11"
+    assert_success
+    assert_output "Jacqueline, you are the 11th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 12" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Juan 12"
-  assert_success
-  assert_output "Juan, you are the 12th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Juan 12"
+    assert_success
+    assert_output "Juan, you are the 12th customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 13" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Patricia 13"
-  assert_success
-  assert_output "Patricia, you are the 13th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Patricia 13"
+    assert_success
+    assert_output "Patricia, you are the 13th customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 21" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Washi 21"
-  assert_success
-  assert_output "Washi, you are the 21st customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Washi 21"
+    assert_success
+    assert_output "Washi, you are the 21st customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 22 ending in nd even though it is a multiple of 11" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Ingrid 22"
-  assert_success
-  assert_output "Ingrid, you are the 22nd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Ingrid 22"
+    assert_success
+    assert_output "Ingrid, you are the 22nd customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 33 ending in rd even though it is a multiple of 11" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Mario 33"
-  assert_success
-  assert_output "Mario, you are the 33rd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Mario 33"
+    assert_success
+    assert_output "Mario, you are the 33rd customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 52 ending in nd even though it is a multiple of 13" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Quentin 52"
-  assert_success
-  assert_output "Quentin, you are the 52nd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Quentin 52"
+    assert_success
+    assert_output "Quentin, you are the 52nd customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 62" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Nayra 62"
-  assert_success
-  assert_output "Nayra, you are the 62nd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Nayra 62"
+    assert_success
+    assert_output "Nayra, you are the 62nd customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 72 ending in nd even though it is a multiple of 12" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Ugo 72"
-  assert_success
-  assert_output "Ugo, you are the 72nd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Ugo 72"
+    assert_success
+    assert_output "Ugo, you are the 72nd customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 91 ending in st even though it is a multiple of 13" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Boris 91"
-  assert_success
-  assert_output "Boris, you are the 91st customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Boris 91"
+    assert_success
+    assert_output "Boris, you are the 91st customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 100" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "John 100"
-  assert_success
-  assert_output "John, you are the 100th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "John 100"
+    assert_success
+    assert_output "John, you are the 100th customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 101" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Zeinab 101"
-  assert_success
-  assert_output "Zeinab, you are the 101st customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Zeinab 101"
+    assert_success
+    assert_output "Zeinab, you are the 101st customer we serve today. Thank you!"
 }
 
 @test "format non-exceptional ordinal numeral 112" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Knud 112"
-  assert_success
-  assert_output "Knud, you are the 112th customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Knud 112"
+    assert_success
+    assert_output "Knud, you are the 112th customer we serve today. Thank you!"
 }
 
 @test "format exceptional ordinal numeral 123" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Yma 123"
-  assert_success
-  assert_output "Yma, you are the 123rd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Yma 123"
+    assert_success
+    assert_output "Yma, you are the 123rd customer we serve today. Thank you!"
 }
 
 @test "format large number 972 ending in nd even though it is a multiple of 12" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f line-up.awk <<< "Elias 972"
-  assert_success
-  assert_output "Elias, you are the 972nd customer we serve today. Thank you!"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f line-up.awk <<< "Elias 972"
+    assert_success
+    assert_output "Elias, you are the 972nd customer we serve today. Thank you!"
 }
 
diff --git a/exercises/practice/luhn/.meta/template.j2 b/exercises/practice/luhn/.meta/template.j2
index 1b06d0b..4cfc1dc 100644
--- a/exercises/practice/luhn/.meta/template.j2
+++ b/exercises/practice/luhn/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["value"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["value"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/luhn/test-luhn.bats b/exercises/practice/luhn/test-luhn.bats
index 63c7532..5ee7e01 100644
--- a/exercises/practice/luhn/test-luhn.bats
+++ b/exercises/practice/luhn/test-luhn.bats
@@ -1,159 +1,159 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:44+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "single digit strings can not be valid" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "1"
-  assert_success
-  assert_output "false"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "1"
+    assert_success
+    assert_output "false"
 }
 
 @test "a single zero is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "0"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "0"
+    assert_success
+    assert_output "false"
 }
 
 @test "a simple valid SIN that remains valid if reversed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "059"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "059"
+    assert_success
+    assert_output "true"
 }
 
 @test "a simple valid SIN that becomes invalid if reversed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "59"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "59"
+    assert_success
+    assert_output "true"
 }
 
 @test "a valid Canadian SIN" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "055 444 285"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "055 444 285"
+    assert_success
+    assert_output "true"
 }
 
 @test "invalid Canadian SIN" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "055 444 286"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "055 444 286"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid credit card" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "8273 1232 7352 0569"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "8273 1232 7352 0569"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid long number with an even remainder" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "1 2345 6789 1234 5678 9012"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "1 2345 6789 1234 5678 9012"
+    assert_success
+    assert_output "false"
 }
 
 @test "invalid long number with a remainder divisible by 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "1 2345 6789 1234 5678 9013"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "1 2345 6789 1234 5678 9013"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid number with an even number of digits" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "095 245 88"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "095 245 88"
+    assert_success
+    assert_output "true"
 }
 
 @test "valid number with an odd number of spaces" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "234 567 891 234"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "234 567 891 234"
+    assert_success
+    assert_output "true"
 }
 
 @test "valid strings with a non-digit added at the end become invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "059a"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "059a"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid strings with punctuation included become invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "055-444-285"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "055-444-285"
+    assert_success
+    assert_output "false"
 }
 
 @test "valid strings with symbols included become invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "055# 444$ 285"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "055# 444$ 285"
+    assert_success
+    assert_output "false"
 }
 
 @test "single zero with space is invalid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< " 0"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< " 0"
+    assert_success
+    assert_output "false"
 }
 
 @test "more than a single zero is valid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "0000 0"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "0000 0"
+    assert_success
+    assert_output "true"
 }
 
 @test "input digit 9 is correctly converted to output digit 9" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "091"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "091"
+    assert_success
+    assert_output "true"
 }
 
 @test "very long input is valid" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "9999999999 9999999999 9999999999 9999999999"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "9999999999 9999999999 9999999999 9999999999"
+    assert_success
+    assert_output "true"
 }
 
 @test "valid luhn with an odd number of digits and non zero first digit" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "109"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "109"
+    assert_success
+    assert_output "true"
 }
 
 @test "using ascii value for non-doubled non-digit isn't allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "055b 444 285"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "055b 444 285"
+    assert_success
+    assert_output "false"
 }
 
 @test "using ascii value for doubled non-digit isn't allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< ":9"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< ":9"
+    assert_success
+    assert_output "false"
 }
 
 @test "non-numeric, non-space char in the middle with a sum that's divisible by 10 isn't allowed" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f luhn.awk <<< "59%59"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f luhn.awk <<< "59%59"
+    assert_success
+    assert_output "false"
 }
 
diff --git a/exercises/practice/pangram/.meta/template.j2 b/exercises/practice/pangram/.meta/template.j2
index 56d1a77..fa06633 100644
--- a/exercises/practice/pangram/.meta/template.j2
+++ b/exercises/practice/pangram/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< '{{ case["input"]["sentence"] }}'
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< '{{ case["input"]["sentence"] }}'
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/pangram/test-pangram.bats b/exercises/practice/pangram/test-pangram.bats
index 6ee94f9..cc66aa3 100644
--- a/exercises/practice/pangram/test-pangram.bats
+++ b/exercises/practice/pangram/test-pangram.bats
@@ -1,75 +1,75 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:50+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test "empty sentence" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< ''
-  assert_success
-  assert_output "false"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< ''
+    assert_success
+    assert_output "false"
 }
 
 @test "perfect lower case" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'abcdefghijklmnopqrstuvwxyz'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'abcdefghijklmnopqrstuvwxyz'
+    assert_success
+    assert_output "true"
 }
 
 @test "only lower case" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'the quick brown fox jumps over the lazy dog'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'the quick brown fox jumps over the lazy dog'
+    assert_success
+    assert_output "true"
 }
 
 @test "missing the letter 'x'" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'a quick movement of the enemy will jeopardize five gunboats'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'a quick movement of the enemy will jeopardize five gunboats'
+    assert_success
+    assert_output "false"
 }
 
 @test "missing the letter 'h'" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'five boxing wizards jump quickly at it'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'five boxing wizards jump quickly at it'
+    assert_success
+    assert_output "false"
 }
 
 @test "with underscores" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'the_quick_brown_fox_jumps_over_the_lazy_dog'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'the_quick_brown_fox_jumps_over_the_lazy_dog'
+    assert_success
+    assert_output "true"
 }
 
 @test "with numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'the 1 quick brown fox jumps over the 2 lazy dogs'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'the 1 quick brown fox jumps over the 2 lazy dogs'
+    assert_success
+    assert_output "true"
 }
 
 @test "missing letters replaced by numbers" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< '7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< '7h3 qu1ck brown fox jumps ov3r 7h3 lazy dog'
+    assert_success
+    assert_output "false"
 }
 
 @test "mixed case and punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< '"Five quacking Zephyrs jolt my wax bed."'
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< '"Five quacking Zephyrs jolt my wax bed."'
+    assert_success
+    assert_output "true"
 }
 
 @test "a-m and A-M are 26 different characters but not a pangram" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f pangram.awk <<< 'abcdefghijklm ABCDEFGHIJKLM'
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f pangram.awk <<< 'abcdefghijklm ABCDEFGHIJKLM'
+    assert_success
+    assert_output "false"
 }
 
diff --git a/exercises/practice/raindrops/.meta/template.j2 b/exercises/practice/raindrops/.meta/template.j2
index 520aa8a..6f63d67 100644
--- a/exercises/practice/raindrops/.meta/template.j2
+++ b/exercises/practice/raindrops/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} -v num={{ case["input"]["number"] }}
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} -v num={{ case["input"]["number"] }}
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/raindrops/test-raindrops.bats b/exercises/practice/raindrops/test-raindrops.bats
index de1e4c5..06d65e7 100644
--- a/exercises/practice/raindrops/test-raindrops.bats
+++ b/exercises/practice/raindrops/test-raindrops.bats
@@ -1,130 +1,131 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T15:58:11+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "the sound for 1 is 1" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=1
-  assert_success
-  assert_output "1"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=1
+    assert_success
+    assert_output "1"
 }
 
 @test "the sound for 3 is Pling" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=3
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=3
+    assert_success
+    assert_output "Pling"
 }
 
 @test "the sound for 5 is Plang" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=5
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=5
+    assert_success
+    assert_output "Plang"
 }
 
 @test "the sound for 7 is Plong" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=7
-  assert_success
-  assert_output "Plong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=7
+    assert_success
+    assert_output "Plong"
 }
 
 @test "the sound for 6 is Pling as it has a factor 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=6
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=6
+    assert_success
+    assert_output "Pling"
 }
 
 @test "2 to the power 3 does not make a raindrop sound as 3 is the exponent not the base" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=8
-  assert_success
-  assert_output "8"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=8
+    assert_success
+    assert_output "8"
 }
 
 @test "the sound for 9 is Pling as it has a factor 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=9
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=9
+    assert_success
+    assert_output "Pling"
 }
 
 @test "the sound for 10 is Plang as it has a factor 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=10
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=10
+    assert_success
+    assert_output "Plang"
 }
 
 @test "the sound for 14 is Plong as it has a factor of 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=14
-  assert_success
-  assert_output "Plong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=14
+    assert_success
+    assert_output "Plong"
 }
 
 @test "the sound for 15 is PlingPlang as it has factors 3 and 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=15
-  assert_success
-  assert_output "PlingPlang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=15
+    assert_success
+    assert_output "PlingPlang"
 }
 
 @test "the sound for 21 is PlingPlong as it has factors 3 and 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=21
-  assert_success
-  assert_output "PlingPlong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=21
+    assert_success
+    assert_output "PlingPlong"
 }
 
 @test "the sound for 25 is Plang as it has a factor 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=25
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=25
+    assert_success
+    assert_output "Plang"
 }
 
 @test "the sound for 27 is Pling as it has a factor 3" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=27
-  assert_success
-  assert_output "Pling"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=27
+    assert_success
+    assert_output "Pling"
 }
 
 @test "the sound for 35 is PlangPlong as it has factors 5 and 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=35
-  assert_success
-  assert_output "PlangPlong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=35
+    assert_success
+    assert_output "PlangPlong"
 }
 
 @test "the sound for 49 is Plong as it has a factor 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=49
-  assert_success
-  assert_output "Plong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=49
+    assert_success
+    assert_output "Plong"
 }
 
 @test "the sound for 52 is 52" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=52
-  assert_success
-  assert_output "52"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=52
+    assert_success
+    assert_output "52"
 }
 
 @test "the sound for 105 is PlingPlangPlong as it has factors 3, 5 and 7" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=105
-  assert_success
-  assert_output "PlingPlangPlong"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=105
+    assert_success
+    assert_output "PlingPlangPlong"
 }
 
 @test "the sound for 3125 is Plang as it has a factor 5" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f raindrops.awk -v num=3125
-  assert_success
-  assert_output "Plang"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f raindrops.awk -v num=3125
+    assert_success
+    assert_output "Plang"
 }
+
diff --git a/exercises/practice/reverse-string/.meta/template.j2 b/exercises/practice/reverse-string/.meta/template.j2
index 1b06d0b..4cfc1dc 100644
--- a/exercises/practice/reverse-string/.meta/template.j2
+++ b/exercises/practice/reverse-string/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["value"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["value"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/reverse-string/test-reverse-string.bats b/exercises/practice/reverse-string/test-reverse-string.bats
index aa11dc3..9a43d6e 100644
--- a/exercises/practice/reverse-string/test-reverse-string.bats
+++ b/exercises/practice/reverse-string/test-reverse-string.bats
@@ -1,46 +1,47 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T04:26:11+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "an empty string" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f reverse-string.awk <<< ""
-  assert_success
-  assert_output ""
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f reverse-string.awk <<< ""
+    assert_success
+    assert_output ""
 }
 
 @test "a word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f reverse-string.awk <<< "robot"
-  assert_success
-  assert_output "tobor"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f reverse-string.awk <<< "robot"
+    assert_success
+    assert_output "tobor"
 }
 
 @test "a capitalized word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f reverse-string.awk <<< "Ramen"
-  assert_success
-  assert_output "nemaR"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f reverse-string.awk <<< "Ramen"
+    assert_success
+    assert_output "nemaR"
 }
 
 @test "a sentence with punctuation" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f reverse-string.awk <<< "I'm hungry!"
-  assert_success
-  assert_output "!yrgnuh m'I"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f reverse-string.awk <<< "I'm hungry!"
+    assert_success
+    assert_output "!yrgnuh m'I"
 }
 
 @test "a palindrome" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f reverse-string.awk <<< "racecar"
-  assert_success
-  assert_output "racecar"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f reverse-string.awk <<< "racecar"
+    assert_success
+    assert_output "racecar"
 }
 
 @test "an even-sized word" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f reverse-string.awk <<< "drawer"
-  assert_success
-  assert_output "reward"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f reverse-string.awk <<< "drawer"
+    assert_success
+    assert_output "reward"
 }
+
diff --git a/exercises/practice/rna-transcription/.meta/template.j2 b/exercises/practice/rna-transcription/.meta/template.j2
index f1f16fd..33ce509 100644
--- a/exercises/practice/rna-transcription/.meta/template.j2
+++ b/exercises/practice/rna-transcription/.meta/template.j2
@@ -1,29 +1,29 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "{{ case["input"]["dna"] }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "{{ case["input"]["dna"] }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
 @test "Handles invalid character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "ACGTXCTTA"
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "ACGTXCTTA"
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles completely invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "XXXX"
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "XXXX"
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles partially invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} <<< "ACGTXCTTAA"
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} <<< "ACGTXCTTAA"
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
diff --git a/exercises/practice/rna-transcription/test-rna-transcription.bats b/exercises/practice/rna-transcription/test-rna-transcription.bats
index d20ec29..6cdb409 100644
--- a/exercises/practice/rna-transcription/test-rna-transcription.bats
+++ b/exercises/practice/rna-transcription/test-rna-transcription.bats
@@ -1,67 +1,67 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T17:59:59+00:00
+# generated on 2026-08-14T19:13:01+00:00
 
 @test "Empty RNA sequence" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< ""
-  assert_success
-  assert_output ""
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< ""
+    assert_success
+    assert_output ""
 }
 
 @test "RNA complement of cytosine is guanine" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "C"
-  assert_success
-  assert_output "G"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "C"
+    assert_success
+    assert_output "G"
 }
 
 @test "RNA complement of guanine is cytosine" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "G"
-  assert_success
-  assert_output "C"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "G"
+    assert_success
+    assert_output "C"
 }
 
 @test "RNA complement of thymine is adenine" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "T"
-  assert_success
-  assert_output "A"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "T"
+    assert_success
+    assert_output "A"
 }
 
 @test "RNA complement of adenine is uracil" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "A"
-  assert_success
-  assert_output "U"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "A"
+    assert_success
+    assert_output "U"
 }
 
 @test "RNA complement" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "ACGTGGTCTTAA"
-  assert_success
-  assert_output "UGCACCAGAAUU"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "ACGTGGTCTTAA"
+    assert_success
+    assert_output "UGCACCAGAAUU"
 }
 
 @test "Handles invalid character" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "ACGTXCTTA"
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "ACGTXCTTA"
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles completely invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "XXXX"
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "XXXX"
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
 
 @test "Handles partially invalid string" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f rna-transcription.awk <<< "ACGTXCTTAA"
-  assert_failure
-  assert_output "Invalid nucleotide detected."
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f rna-transcription.awk <<< "ACGTXCTTAA"
+    assert_failure
+    assert_output "Invalid nucleotide detected."
 }
diff --git a/exercises/practice/saddle-points/.meta/template.j2 b/exercises/practice/saddle-points/.meta/template.j2
index 95fbeea..cb76137 100644
--- a/exercises/practice/saddle-points/.meta/template.j2
+++ b/exercises/practice/saddle-points/.meta/template.j2
@@ -1,17 +1,17 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 {%- for expect in case["expected"] | sort(attribute="row,column") %}
 {{ expect["row"] }} {{ expect["column"] }}
 {%- endfor %}
 END_EXPECT
 )
-  run gawk -f {{ solution }} <<END_INPUT
+    run gawk -f {{ solution }} <<END_INPUT
 {{ case["input"]["matrix"] | map("join", " ") | join("\n") }}
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 {% endfor %}
diff --git a/exercises/practice/saddle-points/test-saddle-points.bats b/exercises/practice/saddle-points/test-saddle-points.bats
index d5bbd63..b7806a7 100644
--- a/exercises/practice/saddle-points/test-saddle-points.bats
+++ b/exercises/practice/saddle-points/test-saddle-points.bats
@@ -1,141 +1,141 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T21:06:09+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "Can identify single saddle point" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 2 1
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 9 8 7
 5 3 2
 6 6 7
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify that empty matrix has no saddle points" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify lack of saddle points when there are none" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 1 2 3
 3 1 2
 2 3 1
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify multiple saddle points in a column" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 1 2
 2 2
 3 2
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 4 5 4
 3 5 5
 1 5 4
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify multiple saddle points in a row" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 2 1
 2 2
 2 3
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 6 7 8
 5 5 5
 7 5 6
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify saddle point in bottom right corner" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 3 3
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 8 7 9
 6 7 6
 3 2 5
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify saddle points in a non square matrix" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 1 1
 1 3
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 3 1 3
 3 2 4
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify that saddle points in a single column matrix are those with the minimum value" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 2 1
 4 1
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 2
 1
 4
 1
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
 @test "Can identify that saddle points in a single row matrix are those with the maximum value" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  expected=$(cat <<END_EXPECT
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    expected=$(cat <<END_EXPECT
 1 2
 1 4
 END_EXPECT
 )
-  run gawk -f saddle-points.awk <<END_INPUT
+    run gawk -f saddle-points.awk <<END_INPUT
 2 5 3 5
 END_INPUT
-  assert_success
-  assert_output "$expected"
+    assert_success
+    assert_output "$expected"
 }
 
diff --git a/exercises/practice/triangle/.meta/template.j2 b/exercises/practice/triangle/.meta/template.j2
index 8680743..e6a5562 100644
--- a/exercises/practice/triangle/.meta/template.j2
+++ b/exercises/practice/triangle/.meta/template.j2
@@ -1,9 +1,9 @@
 {{ header }}
 {% for case in cases %}
 @test "{{ case["description"] }}, {{ case["property"] }}" {
-  {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f {{ solution }} -v type={{ case["property"] }} <<< "{{ case["input"]["sides"] | join(" ") }}"
-  assert_success
-  assert_output "{{ case["expected"] }}"
+    {% if loop.first %}# {% endif %}[[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f {{ solution }} -v type={{ case["property"] }} <<< "{{ case["input"]["sides"] | join(" ") }}"
+    assert_success
+    assert_output "{{ case["expected"] }}"
 }
 {% endfor %}
diff --git a/exercises/practice/triangle/test-triangle.bats b/exercises/practice/triangle/test-triangle.bats
index ca9d21f..a542f8a 100644
--- a/exercises/practice/triangle/test-triangle.bats
+++ b/exercises/practice/triangle/test-triangle.bats
@@ -1,151 +1,152 @@
 #!/usr/bin/env bats
 load bats-extra
 
-# generated on 2026-06-30T04:50:23+00:00
+# generated on 2026-08-14T19:13:00+00:00
 
 @test "all sides are equal, equilateral" {
-  # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=equilateral <<< "2 2 2"
-  assert_success
-  assert_output "true"
+    # [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=equilateral <<< "2 2 2"
+    assert_success
+    assert_output "true"
 }
 
 @test "any side is unequal, equilateral" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=equilateral <<< "2 3 2"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=equilateral <<< "2 3 2"
+    assert_success
+    assert_output "false"
 }
 
 @test "no sides are equal, equilateral" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=equilateral <<< "5 4 6"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=equilateral <<< "5 4 6"
+    assert_success
+    assert_output "false"
 }
 
 @test "all zero sides is not a triangle, equilateral" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=equilateral <<< "0 0 0"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=equilateral <<< "0 0 0"
+    assert_success
+    assert_output "false"
 }
 
 @test "sides may be floats, equilateral" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=equilateral <<< "0.5 0.5 0.5"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=equilateral <<< "0.5 0.5 0.5"
+    assert_success
+    assert_output "true"
 }
 
 @test "last two sides are equal, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "3 4 4"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "3 4 4"
+    assert_success
+    assert_output "true"
 }
 
 @test "first two sides are equal, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "4 4 3"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "4 4 3"
+    assert_success
+    assert_output "true"
 }
 
 @test "first and last sides are equal, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "4 3 4"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "4 3 4"
+    assert_success
+    assert_output "true"
 }
 
 @test "equilateral triangles are also isosceles, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "4 4 4"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "4 4 4"
+    assert_success
+    assert_output "true"
 }
 
 @test "no sides are equal, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "2 3 4"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "2 3 4"
+    assert_success
+    assert_output "false"
 }
 
 @test "first triangle inequality violation, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "1 1 3"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "1 1 3"
+    assert_success
+    assert_output "false"
 }
 
 @test "second triangle inequality violation, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "1 3 1"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "1 3 1"
+    assert_success
+    assert_output "false"
 }
 
 @test "third triangle inequality violation, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "3 1 1"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "3 1 1"
+    assert_success
+    assert_output "false"
 }
 
 @test "sides may be floats, isosceles" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=isosceles <<< "0.5 0.4 0.5"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=isosceles <<< "0.5 0.4 0.5"
+    assert_success
+    assert_output "true"
 }
 
 @test "no sides are equal, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "5 4 6"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "5 4 6"
+    assert_success
+    assert_output "true"
 }
 
 @test "all sides are equal, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "4 4 4"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "4 4 4"
+    assert_success
+    assert_output "false"
 }
 
 @test "first and second sides are equal, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "4 4 3"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "4 4 3"
+    assert_success
+    assert_output "false"
 }
 
 @test "first and third sides are equal, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "3 4 3"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "3 4 3"
+    assert_success
+    assert_output "false"
 }
 
 @test "second and third sides are equal, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "4 3 3"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "4 3 3"
+    assert_success
+    assert_output "false"
 }
 
 @test "may not violate triangle inequality, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "7 3 2"
-  assert_success
-  assert_output "false"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "7 3 2"
+    assert_success
+    assert_output "false"
 }
 
 @test "sides may be floats, scalene" {
-  [[ $BATS_RUN_SKIPPED == "true" ]] || skip
-  run gawk -f triangle.awk -v type=scalene <<< "0.5 0.4 0.6"
-  assert_success
-  assert_output "true"
+    [[ $BATS_RUN_SKIPPED == "true" ]] || skip
+    run gawk -f triangle.awk -v type=scalene <<< "0.5 0.4 0.6"
+    assert_success
+    assert_output "true"
 }
+