diff --git a/lib/hyperscript/compiler.sx b/lib/hyperscript/compiler.sx
index d79c5463..95152437 100644
--- a/lib/hyperscript/compiler.sx
+++ b/lib/hyperscript/compiler.sx
@@ -266,6 +266,7 @@
           (let
             ((head (first ast)))
             (cond
+              ((= head (quote null-literal)) nil)
               ((= head (quote me)) (quote me))
               ((= head (quote it)) (quote it))
               ((= head (quote event)) (quote event))
@@ -328,7 +329,7 @@
                   (hs-to-sx (nth ast 2))))
               ((= head pct-sym)
                 (list
-                  pct-sym
+                  (quote modulo)
                   (hs-to-sx (nth ast 1))
                   (hs-to-sx (nth ast 2))))
               ((= head (quote empty?))
@@ -342,16 +343,16 @@
                   (quote hs-matches?)
                   (hs-to-sx (nth ast 1))
                   (hs-to-sx (nth ast 2))))
-              ((= head (quote contains?))
+              ((= head (quote hs-contains?))
                 (list
-                  (quote contains?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 1))
                   (hs-to-sx (nth ast 2))))
               ((= head (quote as))
                 (list (quote hs-coerce) (hs-to-sx (nth ast 1)) (nth ast 2)))
               ((= head (quote in?))
                 (list
-                  (quote contains?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 2))
                   (hs-to-sx (nth ast 1))))
               ((= head (quote of))
@@ -575,12 +576,12 @@
                 (list
                   (quote not)
                   (list
-                    (quote contains?)
+                    (quote hs-contains?)
                     (hs-to-sx (nth ast 2))
                     (hs-to-sx (nth ast 1)))))
               ((= head (quote in?))
                 (list
-                  (quote contains?)
+                  (quote hs-contains?)
                   (hs-to-sx (nth ast 2))
                   (hs-to-sx (nth ast 1))))
               ((= head (quote type-check))
diff --git a/lib/hyperscript/parser.sx b/lib/hyperscript/parser.sx
index d89f5dfb..e2558f7c 100644
--- a/lib/hyperscript/parser.sx
+++ b/lib/hyperscript/parser.sx
@@ -112,9 +112,9 @@
               ((and (= typ "keyword") (= val "true")) (do (adv!) true))
               ((and (= typ "keyword") (= val "false")) (do (adv!) false))
               ((and (= typ "keyword") (or (= val "null") (= val "nil")))
-                (do (adv!) nil))
+                (do (adv!) (list (quote null-literal))))
               ((and (= typ "keyword") (= val "undefined"))
-                (do (adv!) nil))
+                (do (adv!) (list (quote null-literal))))
               ((and (= typ "keyword") (= val "not"))
                 (do (adv!) (list (quote not) (parse-expr))))
               ((and (= typ "keyword") (= val "no"))
diff --git a/lib/hyperscript/runtime.sx b/lib/hyperscript/runtime.sx
index db0e6776..62153fec 100644
--- a/lib/hyperscript/runtime.sx
+++ b/lib/hyperscript/runtime.sx
@@ -172,13 +172,7 @@
     (n thunk)
     (define
       do-repeat
-      (fn
-        (i)
-        (when
-          (< i n)
-          (log (str "[hs-repeat] iteration " i " of " n))
-          (thunk)
-          (do-repeat (+ i 1)))))
+      (fn (i) (when (< i n) (thunk) (do-repeat (+ i 1)))))
     (do-repeat 0)))
 
 ;; Repeat forever (until break — relies on exception/continuation).
@@ -310,4 +304,13 @@
     (if
       (string? target)
       (if (= pattern ".*") true (string-contains? target pattern))
-      false)))
\ No newline at end of file
+      false)))
+
+(define
+  hs-contains?
+  (fn
+    (collection item)
+    (cond
+      ((list? collection) (some (fn (x) (= x item)) collection))
+      ((string? collection) (string-contains? collection item))
+      (true false))))
\ No newline at end of file
diff --git a/lib/hyperscript/tokenizer.sx b/lib/hyperscript/tokenizer.sx
index ab0eb3dc..30bcb6c6 100644
--- a/lib/hyperscript/tokenizer.sx
+++ b/lib/hyperscript/tokenizer.sx
@@ -477,8 +477,13 @@
                   (< (+ pos 1) src-len)
                   (= (hs-peek 1) "="))
                 (do
-                  (hs-emit! "op" (str ch "=") start)
-                  (hs-advance! 2)
+                  (if
+                    (and
+                      (or (= ch "=") (= ch "!"))
+                      (< (+ pos 2) src-len)
+                      (= (hs-peek 2) "="))
+                    (do (hs-emit! "op" (str ch "==") start) (hs-advance! 3))
+                    (do (hs-emit! "op" (str ch "=") start) (hs-advance! 2)))
                   (scan!))
                 (and
                   (= ch "'")
diff --git a/spec/tests/test-hyperscript-compiler.sx b/spec/tests/test-hyperscript-compiler.sx
index 4d2e28f7..55e3de08 100644
--- a/spec/tests/test-hyperscript-compiler.sx
+++ b/spec/tests/test-hyperscript-compiler.sx
@@ -57,12 +57,10 @@
   (deftest
     "addition passes through"
     (let
-      ((sx (hs-to-sx-from-source "1 + 2")))
-      (let
-        ((val (first sx)))
-        (assert= (quote hs-add) (first val))
-        (assert= 1 (nth val 1))
-        (assert= 2 (nth val 2)))))
+      ((val (hs-to-sx-from-source "1 + 2")))
+      (assert= (quote hs-add) (first val))
+      (assert= 1 (nth val 1))
+      (assert= 2 (nth val 2))))
   (deftest
     "comparison emits correctly"
     (let
diff --git a/spec/tests/test-hyperscript-conformance.sx b/spec/tests/test-hyperscript-conformance.sx
index fc4f2002..acfa8ea0 100644
--- a/spec/tests/test-hyperscript-conformance.sx
+++ b/spec/tests/test-hyperscript-conformance.sx
@@ -11,815 +11,500 @@
     (let
       ((sx (hs-to-sx (hs-compile src)))
         (ctx (if (> (len opts) 0) (first opts) nil)))
-      (if
-        (nil? ctx)
-        (eval-expr-cek
-          (list
-            (quote let)
+      (let
+        ((defaults (list (list (quote me) nil) (list (quote it) nil) (list (quote result) nil)))
+          (runtime
             (list
-              (list (quote me) nil)
-              (list (quote it) nil)
-              (list (quote result) nil))
-            sx))
-        (let
-          ((defaults (list (list (quote me) nil) (list (quote it) nil) (list (quote result) nil)))
-            (overrides (list)))
-          (do
-            (when
-              (get ctx "me")
-              (set!
-                overrides
-                (cons (list (quote me) (get ctx "me")) overrides)))
-            (when
-              (get ctx "locals")
-              (for-each
-                (fn
-                  (k)
-                  (set!
-                    overrides
-                    (cons
-                      (list (make-symbol k) (get (get ctx "locals") k))
-                      overrides)))
-                (keys (get ctx "locals"))))
-            (eval-expr-cek
+              (list (quote hs-add) hs-add)
+              (list (quote hs-falsy?) hs-falsy?)
+              (list (quote hs-strict-eq) hs-strict-eq)
+              (list (quote hs-type-check) hs-type-check)
+              (list (quote hs-type-check!) hs-type-check!)
+              (list (quote hs-matches?) hs-matches?)
+              (list (quote hs-coerce) hs-coerce)
+              (list (quote hs-contains?) hs-contains?)))
+          (overrides (list)))
+        (do
+          (when
+            ctx
+            (do
+              (when
+                (get ctx "me")
+                (set!
+                  overrides
+                  (cons (list (quote me) (get ctx "me")) overrides)))
+              (when
+                (get ctx "locals")
+                (for-each
+                  (fn
+                    (k)
+                    (set!
+                      overrides
+                      (cons
+                        (list (make-symbol k) (get (get ctx "locals") k))
+                        overrides)))
+                  (keys (get ctx "locals"))))))
+          (eval-expr-cek
+            (list
+              (quote let)
+              runtime
               (list (quote let) defaults (list (quote let) overrides sx)))))))))
 
 ;; ── run-hs-fixture: evaluate one test case ────────────────────────────
-(define run-hs-fixture
-  (fn (f)
-    (let ((src (get f "src"))
-          (expected (get f "expected"))
-          (ctx (if (or (get f "locals") (get f "me"))
-                 {"locals" (get f "locals") "me" (get f "me")}
-                 nil)))
-      (let ((result (if ctx (eval-hs src ctx) (eval-hs src))))
+(define
+  run-hs-fixture
+  (fn
+    (f)
+    (let
+      ((src (get f "src"))
+        (expected (get f "expected"))
+        (ctx (if (or (get f "locals") (get f "me")) {:me (get f "me") :locals (get f "locals")} nil)))
+      (let
+        ((result (if ctx (eval-hs src ctx) (eval-hs src))))
         (assert= result expected src)))))
 
 ;; ── arrayIndex (1 fixtures) ──────────────────────────────
-(defsuite "hs-compat-arrayIndex"
-  (deftest "can-create-an-array-literal"
-    (for-each run-hs-fixture
-      (list
-        {"src" "[1, 2, 3]" "expected" (list 1 2 3)}
-      )))
-)
+(defsuite
+  "hs-compat-arrayIndex"
+  (deftest
+    "can-create-an-array-literal"
+    (for-each run-hs-fixture (list {:src "[1, 2, 3]" :expected (list 1 2 3)}))))
 
 ;; ── arrayLiteral (3 fixtures) ──────────────────────────────
-(defsuite "hs-compat-arrayLiteral"
-  (deftest "empty-array-literals-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "[]" "expected" (list)}
-      )))
-  (deftest "one-element-array-literal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "[true]" "expected" (list true)}
-      )))
-  (deftest "multi-element-array-literal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "[true, false]" "expected" (list true false)}
-      )))
-)
+(defsuite
+  "hs-compat-arrayLiteral"
+  (deftest
+    "empty-array-literals-work"
+    (for-each run-hs-fixture (list {:src "[]" :expected (list)})))
+  (deftest
+    "one-element-array-literal-works"
+    (for-each run-hs-fixture (list {:src "[true]" :expected (list true)})))
+  (deftest
+    "multi-element-array-literal-works"
+    (for-each run-hs-fixture (list {:src "[true, false]" :expected (list true false)}))))
 
 ;; ── asExpression (19 fixtures) ──────────────────────────────
-(defsuite "hs-compat-asExpression"
-  (deftest "converts-value-as-string"
-    (for-each run-hs-fixture
-      (list
-        {"src" "10 as String" "expected" "10"}
-        {"src" "true as String" "expected" "true"}
-      )))
-  (deftest "converts-value-as-int"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'10' as Int" "expected" 10}
-        {"src" "'10.4' as Int" "expected" 10}
-      )))
-  (deftest "converts-value-as-float"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'10' as Float" "expected" 10}
-        {"src" "'10.4' as Float" "expected" 10.4}
-      )))
-  (deftest "converts-value-as-fixed"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'10.4' as Fixed" "expected" "10"}
-        {"src" "'10.4899' as Fixed:2" "expected" "10.49"}
-      )))
-  (deftest "converts-value-as-number"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'10' as Number" "expected" 10}
-        {"src" "'10.4' as Number" "expected" 10.4}
-      )))
-  (deftest "converts-value-as-json"
-    (for-each run-hs-fixture
-      (list
-        {"src" "{foo:'bar'} as JSON" "expected" "{\"foo\":\"bar\"}"}
-      )))
-  (deftest "converts-string-as-object"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'{\"foo\":\"bar\"}' as Object" "expected" "bar"}
-      )))
-  (deftest "can-use-the-an-modifier-if-you"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'{\"foo\":\"bar\"}' as an Object" "expected" "bar"}
-      )))
-  (deftest "converts-value-as-object"
-    (for-each run-hs-fixture
-      (list
-        {"src" "x as Object" "expected" "bar"}
-      )))
-  (deftest "converts-a-complete-form-into-values"
-    (for-each run-hs-fixture
-      (list
-        {"src" "x as Values" "expected" "John"}
-      )))
-  (deftest "converts-numbers-things-"
-    (for-each run-hs-fixture
-      (list
-        {"src" "value as HTML" "expected" "123"}
-      )))
-  (deftest "converts-strings-into-fragments"
-    (for-each run-hs-fixture
-      (list
-        {"src" "value as Fragment" "expected" 1}
-      )))
-  (deftest "can-accept-custom-conversions"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 as Foo" "expected" "foo1"}
-      )))
-  (deftest "-"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 as Foo:Bar" "expected" "Bar1"}
-      )))
-)
+(defsuite
+  "hs-compat-asExpression"
+  (deftest
+    "converts-value-as-string"
+    (for-each run-hs-fixture (list {:src "10 as String" :expected "10"} {:src "true as String" :expected "true"})))
+  (deftest
+    "converts-value-as-int"
+    (for-each run-hs-fixture (list {:src "'10' as Int" :expected 10} {:src "'10.4' as Int" :expected 10})))
+  (deftest
+    "converts-value-as-float"
+    (for-each run-hs-fixture (list {:src "'10' as Float" :expected 10} {:src "'10.4' as Float" :expected 10.4})))
+  (deftest
+    "converts-value-as-fixed"
+    (for-each run-hs-fixture (list {:src "'10.4' as Fixed" :expected "10"} {:src "'10.4899' as Fixed:2" :expected "10.49"})))
+  (deftest
+    "converts-value-as-number"
+    (for-each run-hs-fixture (list {:src "'10' as Number" :expected 10} {:src "'10.4' as Number" :expected 10.4})))
+  (deftest
+    "converts-value-as-json"
+    (for-each run-hs-fixture (list {:src "{foo:'bar'} as JSON" :expected "{\"foo\":\"bar\"}"})))
+  (deftest
+    "converts-string-as-object"
+    (for-each run-hs-fixture (list {:src "'{\"foo\":\"bar\"}' as Object" :expected "bar"})))
+  (deftest
+    "can-use-the-an-modifier-if-you"
+    (for-each run-hs-fixture (list {:src "'{\"foo\":\"bar\"}' as an Object" :expected "bar"})))
+  (deftest
+    "converts-value-as-object"
+    (for-each run-hs-fixture (list {:src "x as Object" :expected "bar"})))
+  (deftest
+    "converts-a-complete-form-into-values"
+    (for-each run-hs-fixture (list {:src "x as Values" :expected "John"})))
+  (deftest
+    "converts-numbers-things-"
+    (for-each run-hs-fixture (list {:src "value as HTML" :expected "123"})))
+  (deftest
+    "converts-strings-into-fragments"
+    (for-each run-hs-fixture (list {:src "value as Fragment" :expected 1})))
+  (deftest
+    "can-accept-custom-conversions"
+    (for-each run-hs-fixture (list {:src "1 as Foo" :expected "foo1"})))
+  (deftest "-" (for-each run-hs-fixture (list {:src "1 as Foo:Bar" :expected "Bar1"}))))
 
 ;; ── blockLiteral (4 fixtures) ──────────────────────────────
-(defsuite "hs-compat-blockLiteral"
-  (deftest "basic-block-literals-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "\\\\-> true" "expected" true}
-      )))
-  (deftest "basic-identity-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "\\\\ x -> x" "expected" true}
-      )))
-  (deftest "basic-two-arg-identity-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "\\\\ x, y -> y" "expected" true}
-      )))
-  (deftest "can-map-an-array"
-    (for-each run-hs-fixture
-      (list
-        {"src" "['a', 'ab', 'abc'].map(\\\\ s -> s.length )" "expected" (list 1 2 3)}
-      )))
-)
+(defsuite
+  "hs-compat-blockLiteral"
+  (deftest
+    "basic-block-literals-work"
+    (for-each run-hs-fixture (list {:src "\\\\-> true" :expected true})))
+  (deftest
+    "basic-identity-works"
+    (for-each run-hs-fixture (list {:src "\\\\ x -> x" :expected true})))
+  (deftest
+    "basic-two-arg-identity-works"
+    (for-each run-hs-fixture (list {:src "\\\\ x, y -> y" :expected true})))
+  (deftest "can-map-an-array" (for-each run-hs-fixture (list {:src "['a', 'ab', 'abc'].map(\\\\ s -> s.length )" :expected (list 1 2 3)}))))
 
 ;; ── boolean (2 fixtures) ──────────────────────────────
-(defsuite "hs-compat-boolean"
-  (deftest "true-boolean-literals-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "true" "expected" true}
-      )))
-  (deftest "false-boolean-literals-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "false" "expected" false}
-      )))
-)
+(defsuite
+  "hs-compat-boolean"
+  (deftest
+    "true-boolean-literals-work"
+    (for-each run-hs-fixture (list {:src "true" :expected true})))
+  (deftest
+    "false-boolean-literals-work"
+    (for-each run-hs-fixture (list {:src "false" :expected false}))))
 
 ;; ── classRef (1 fixtures) ──────────────────────────────
-(defsuite "hs-compat-classRef"
-  (deftest "basic-classref-works-w-no-match"
-    (for-each run-hs-fixture
-      (list
-        {"src" ".badClassThatDoesNotHaveAnyElements" "expected" 0}
-      )))
-)
+(defsuite
+  "hs-compat-classRef"
+  (deftest
+    "basic-classref-works-w-no-match"
+    (for-each run-hs-fixture (list {:src ".badClassThatDoesNotHaveAnyElements" :expected 0}))))
 
 ;; ── comparisonOperator (113 fixtures) ──────────────────────────────
-(defsuite "hs-compat-comparisonOperator"
-  (deftest "less-than-works"
-    (for-each run-hs-fixture
+(defsuite
+  "hs-compat-comparisonOperator"
+  (deftest
+    "less-than-works"
+    (for-each run-hs-fixture (list {:src "1 < 2" :expected true} {:src "2 < 1" :expected false} {:src "2 < 2" :expected false})))
+  (deftest
+    "less-than-or-equal-works"
+    (for-each run-hs-fixture (list {:src "1 <= 2" :expected true} {:src "2 <= 1" :expected false} {:src "2 <= 2" :expected true})))
+  (deftest
+    "greater-than-works"
+    (for-each run-hs-fixture (list {:src "1 > 2" :expected false} {:src "2 > 1" :expected true} {:src "2 > 2" :expected false})))
+  (deftest
+    "greater-than-or-equal-works"
+    (for-each run-hs-fixture (list {:src "1 >= 2" :expected false} {:src "2 >= 1" :expected true} {:src "2 >= 2" :expected true})))
+  (deftest
+    "equal-works"
+    (for-each run-hs-fixture (list {:src "1 == 2" :expected false} {:src "2 == 1" :expected false} {:src "2 == 2" :expected true})))
+  (deftest
+    "triple-equal-works"
+    (for-each run-hs-fixture (list {:src "1 === 2" :expected false} {:src "2 === 1" :expected false} {:src "2 === 2" :expected true})))
+  (deftest
+    "not-equal-works"
+    (for-each run-hs-fixture (list {:src "1 != 2" :expected true} {:src "2 != 1" :expected true} {:src "2 != 2" :expected false})))
+  (deftest
+    "triple-not-equal-works"
+    (for-each run-hs-fixture (list {:src "1 !== 2" :expected true} {:src "2 !== 1" :expected true} {:src "2 !== 2" :expected false})))
+  (deftest
+    "is-works"
+    (for-each run-hs-fixture (list {:src "1 is 2" :expected false} {:src "2 is 1" :expected false} {:src "2 is 2" :expected true})))
+  (deftest
+    "equals-works"
+    (for-each run-hs-fixture (list {:src "1 equals 2" :expected false} {:src "2 equals 1" :expected false} {:src "2 equals 2" :expected true})))
+  (deftest
+    "is-equal-to-works"
+    (for-each run-hs-fixture (list {:src "1 is equal to 2" :expected false} {:src "2 is equal to 1" :expected false} {:src "2 is equal to 2" :expected true})))
+  (deftest
+    "is-really-equal-to-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "1 is really equal to 2" :expected false} {:src "2 is really equal to 1" :expected false} {:src "2 is really equal to '2'" :expected false} {:src "2 is really equal to 2" :expected true})))
+  (deftest
+    "really-equals-works"
+    (for-each run-hs-fixture (list {:src "1 really equals 2" :expected false} {:src "2 really equals 1" :expected false} {:src "2 really equals 2" :expected true})))
+  (deftest
+    "is-not-works"
+    (for-each run-hs-fixture (list {:src "1 is not 2" :expected true} {:src "2 is not 1" :expected true} {:src "2 is not 2" :expected false})))
+  (deftest
+    "is-not-equal-to-works"
+    (for-each run-hs-fixture (list {:src "1 is not equal to 2" :expected true} {:src "2 is not equal to 1" :expected true} {:src "2 is not equal to 2" :expected false})))
+  (deftest
+    "is-not-really-equal-to-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "1 is not really equal to 2" :expected true} {:src "2 is not really equal to 1" :expected true} {:src "2 is not really equal to '2'" :expected true} {:src "2 is not really equal to 2" :expected false})))
+  (deftest
+    "is-in-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "1 is in [1, 2]" :expected true} {:src "2 is in [1, 2]" :expected true} {:src "3 is in [1, 2]" :expected false} {:src "3 is in null" :expected false})))
+  (deftest
+    "is-not-in-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "1 is not in [1, 2]" :expected false} {:src "2 is not in [1, 2]" :expected false} {:src "3 is not in [1, 2]" :expected true} {:src "3 is not in null" :expected true})))
+  (deftest
+    "i-am-in-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "I am in [1, 2]" :me 1 :expected true} {:src "I am in [1, 2]" :me 2 :expected true} {:src "I am in [1, 2]" :me 3 :expected false} {:src "I am in null" :expected false})))
+  (deftest
+    "i-am-not-in-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "I am not in [1, 2]" :me 1 :expected false} {:src "I am not in [1, 2]" :me 2 :expected false} {:src "I am not in [1, 2]" :me 3 :expected true} {:src "I am not in null" :expected true})))
+  (deftest
+    "match-works-w-strings"
+    (for-each run-hs-fixture (list {:src "'a' matches '.*'" :expected true} {:src "'a' matches 'b'" :expected false})))
+  (deftest
+    "does-not-match-works-w-strings"
+    (for-each run-hs-fixture (list {:src "'a' does not match '.*'" :expected false} {:src "'a' does not match 'b'" :expected true})))
+  (deftest
+    "is-empty-works"
+    (for-each
+      run-hs-fixture
       (list
-        {"src" "1 < 2" "expected" true}
-        {"src" "2 < 1" "expected" false}
-        {"src" "2 < 2" "expected" false}
-      )))
-  (deftest "less-than-or-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 <= 2" "expected" true}
-        {"src" "2 <= 1" "expected" false}
-        {"src" "2 <= 2" "expected" true}
-      )))
-  (deftest "greater-than-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 > 2" "expected" false}
-        {"src" "2 > 1" "expected" true}
-        {"src" "2 > 2" "expected" false}
-      )))
-  (deftest "greater-than-or-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 >= 2" "expected" false}
-        {"src" "2 >= 1" "expected" true}
-        {"src" "2 >= 2" "expected" true}
-      )))
-  (deftest "equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 == 2" "expected" false}
-        {"src" "2 == 1" "expected" false}
-        {"src" "2 == 2" "expected" true}
-      )))
-  (deftest "triple-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 === 2" "expected" false}
-        {"src" "2 === 1" "expected" false}
-        {"src" "2 === 2" "expected" true}
-      )))
-  (deftest "not-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 != 2" "expected" true}
-        {"src" "2 != 1" "expected" true}
-        {"src" "2 != 2" "expected" false}
-      )))
-  (deftest "triple-not-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 !== 2" "expected" true}
-        {"src" "2 !== 1" "expected" true}
-        {"src" "2 !== 2" "expected" false}
-      )))
-  (deftest "is-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is 2" "expected" false}
-        {"src" "2 is 1" "expected" false}
-        {"src" "2 is 2" "expected" true}
-      )))
-  (deftest "equals-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 equals 2" "expected" false}
-        {"src" "2 equals 1" "expected" false}
-        {"src" "2 equals 2" "expected" true}
-      )))
-  (deftest "is-equal-to-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is equal to 2" "expected" false}
-        {"src" "2 is equal to 1" "expected" false}
-        {"src" "2 is equal to 2" "expected" true}
-      )))
-  (deftest "is-really-equal-to-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is really equal to 2" "expected" false}
-        {"src" "2 is really equal to 1" "expected" false}
-        {"src" "2 is really equal to '2'" "expected" false}
-        {"src" "2 is really equal to 2" "expected" true}
-      )))
-  (deftest "really-equals-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 really equals 2" "expected" false}
-        {"src" "2 really equals 1" "expected" false}
-        {"src" "2 really equals 2" "expected" true}
-      )))
-  (deftest "is-not-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is not 2" "expected" true}
-        {"src" "2 is not 1" "expected" true}
-        {"src" "2 is not 2" "expected" false}
-      )))
-  (deftest "is-not-equal-to-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is not equal to 2" "expected" true}
-        {"src" "2 is not equal to 1" "expected" true}
-        {"src" "2 is not equal to 2" "expected" false}
-      )))
-  (deftest "is-not-really-equal-to-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is not really equal to 2" "expected" true}
-        {"src" "2 is not really equal to 1" "expected" true}
-        {"src" "2 is not really equal to '2'" "expected" true}
-        {"src" "2 is not really equal to 2" "expected" false}
-      )))
-  (deftest "is-in-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is in [1, 2]" "expected" true}
-        {"src" "2 is in [1, 2]" "expected" true}
-        {"src" "3 is in [1, 2]" "expected" false}
-        {"src" "3 is in null" "expected" false}
-      )))
-  (deftest "is-not-in-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is not in [1, 2]" "expected" false}
-        {"src" "2 is not in [1, 2]" "expected" false}
-        {"src" "3 is not in [1, 2]" "expected" true}
-        {"src" "3 is not in null" "expected" true}
-      )))
-  (deftest "i-am-in-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "I am in [1, 2]" "expected" true "me" 1}
-        {"src" "I am in [1, 2]" "expected" true "me" 2}
-        {"src" "I am in [1, 2]" "expected" false "me" 3}
-        {"src" "I am in null" "expected" false}
-      )))
-  (deftest "i-am-not-in-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "I am not in [1, 2]" "expected" false "me" 1}
-        {"src" "I am not in [1, 2]" "expected" false "me" 2}
-        {"src" "I am not in [1, 2]" "expected" true "me" 3}
-        {"src" "I am not in null" "expected" true}
-      )))
-  (deftest "match-works-w-strings"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'a' matches '.*'" "expected" true}
-        {"src" "'a' matches 'b'" "expected" false}
-      )))
-  (deftest "does-not-match-works-w-strings"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'a' does not match '.*'" "expected" false}
-        {"src" "'a' does not match 'b'" "expected" true}
-      )))
-  (deftest "is-empty-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "undefined is empty" "expected" true}
-        {"src" "'' is empty" "expected" true}
-        {"src" "[] is empty" "expected" true}
-        {"src" "'not empty' is empty" "expected" false}
-        {"src" "1000 is empty" "expected" false}
-        {"src" "[1,2,3] is empty" "expected" false}
-        {"src" ".aClassThatDoesNotExist is empty" "expected" true}
-      )))
-  (deftest "is-not-empty-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "undefined is not empty" "expected" false}
-        {"src" "'' is not empty" "expected" false}
-        {"src" "[] is not empty" "expected" false}
-        {"src" "'not empty' is not empty" "expected" true}
-        {"src" "1000 is not empty" "expected" true}
-        {"src" "[1,2,3] is not empty" "expected" true}
-      )))
-  (deftest "is-a-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "null is a String" "expected" true}
-        {"src" "null is a String!" "expected" false}
-        {"src" "'' is a String!" "expected" true}
-      )))
-  (deftest "is-not-a-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "null is not a String" "expected" false}
-        {"src" "null is not a String!" "expected" true}
-        {"src" "'' is not a String!" "expected" false}
-      )))
-  (deftest "is-an-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "null is an String" "expected" true}
-        {"src" "null is an String!" "expected" false}
-        {"src" "'' is an String!" "expected" true}
-      )))
-  (deftest "is-not-an-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "null is not an String" "expected" false}
-        {"src" "null is not an String!" "expected" true}
-        {"src" "'' is not an String!" "expected" false}
-      )))
-  (deftest "english-less-than-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is less than 2" "expected" true}
-        {"src" "2 is less than 1" "expected" false}
-        {"src" "2 is less than 2" "expected" false}
-      )))
-  (deftest "english-less-than-or-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is less than or equal to 2" "expected" true}
-        {"src" "2 is less than or equal to 1" "expected" false}
-        {"src" "2 is less than or equal to 2" "expected" true}
-      )))
-  (deftest "english-greater-than-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is greater than 2" "expected" false}
-        {"src" "2 is greater than 1" "expected" true}
-        {"src" "2 is greater than 2" "expected" false}
-      )))
-  (deftest "english-greater-than-or-equal-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 is greater than or equal to 2" "expected" false}
-        {"src" "2 is greater than or equal to 1" "expected" true}
-        {"src" "2 is greater than or equal to 2" "expected" true}
-      )))
-  (deftest "does-not-exist-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "undefined does not exist" "expected" true}
-        {"src" "null does not exist" "expected" true}
-        {"src" "#doesNotExist does not exist" "expected" true}
-        {"src" ".aClassThatDoesNotExist does not exist" "expected" true}
-        {"src" "<.aClassThatDoesNotExist/> does not exist" "expected" true}
-        {"src" "<body/> does not exist" "expected" false}
-      )))
-)
+        {:src "undefined is empty" :expected true}
+        {:src "'' is empty" :expected true}
+        {:src "[] is empty" :expected true}
+        {:src "'not empty' is empty" :expected false}
+        {:src "1000 is empty" :expected false}
+        {:src "[1,2,3] is empty" :expected false}
+        {:src ".aClassThatDoesNotExist is empty" :expected true})))
+  (deftest
+    "is-not-empty-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "undefined is not empty" :expected false} {:src "'' is not empty" :expected false} {:src "[] is not empty" :expected false} {:src "'not empty' is not empty" :expected true} {:src "1000 is not empty" :expected true} {:src "[1,2,3] is not empty" :expected true})))
+  (deftest
+    "is-a-works"
+    (for-each run-hs-fixture (list {:src "null is a String" :expected true} {:src "null is a String!" :expected false} {:src "'' is a String!" :expected true})))
+  (deftest
+    "is-not-a-works"
+    (for-each run-hs-fixture (list {:src "null is not a String" :expected false} {:src "null is not a String!" :expected true} {:src "'' is not a String!" :expected false})))
+  (deftest
+    "is-an-works"
+    (for-each run-hs-fixture (list {:src "null is an String" :expected true} {:src "null is an String!" :expected false} {:src "'' is an String!" :expected true})))
+  (deftest
+    "is-not-an-works"
+    (for-each run-hs-fixture (list {:src "null is not an String" :expected false} {:src "null is not an String!" :expected true} {:src "'' is not an String!" :expected false})))
+  (deftest
+    "english-less-than-works"
+    (for-each run-hs-fixture (list {:src "1 is less than 2" :expected true} {:src "2 is less than 1" :expected false} {:src "2 is less than 2" :expected false})))
+  (deftest
+    "english-less-than-or-equal-works"
+    (for-each run-hs-fixture (list {:src "1 is less than or equal to 2" :expected true} {:src "2 is less than or equal to 1" :expected false} {:src "2 is less than or equal to 2" :expected true})))
+  (deftest
+    "english-greater-than-works"
+    (for-each run-hs-fixture (list {:src "1 is greater than 2" :expected false} {:src "2 is greater than 1" :expected true} {:src "2 is greater than 2" :expected false})))
+  (deftest
+    "english-greater-than-or-equal-works"
+    (for-each run-hs-fixture (list {:src "1 is greater than or equal to 2" :expected false} {:src "2 is greater than or equal to 1" :expected true} {:src "2 is greater than or equal to 2" :expected true})))
+  (deftest
+    "does-not-exist-works"
+    (for-each
+      run-hs-fixture
+      (list {:src "undefined does not exist" :expected true} {:src "null does not exist" :expected true} {:src "#doesNotExist does not exist" :expected true} {:src ".aClassThatDoesNotExist does not exist" :expected true} {:src "<.aClassThatDoesNotExist/> does not exist" :expected true} {:src "<body/> does not exist" :expected false}))))
 
 ;; ── cookies (9 fixtures) ──────────────────────────────
-(defsuite "hs-compat-cookies"
-  (deftest "basic-set-cookie-values-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "cookies.foo" "expected" "bar"}
-        {"src" "set cookies.foo to 'bar'" "expected" "bar"}
-        {"src" "cookies.foo" "expected" "bar"}
-      )))
-  (deftest "update-cookie-values-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "set cookies.foo to 'bar'" "expected" "bar"}
-        {"src" "cookies.foo" "expected" "bar"}
-        {"src" "set cookies.foo to 'doh'" "expected" "doh"}
-        {"src" "cookies.foo" "expected" "doh"}
-      )))
-  (deftest "iterate-cookies-values-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "set cookies.foo to 'bar'" "expected" true}
-        {"src" "for x in cookies me.push(x.name) then you.push(x.value) end" "expected" true}
-      )))
-)
+(defsuite
+  "hs-compat-cookies"
+  (deftest
+    "basic-set-cookie-values-work"
+    (for-each run-hs-fixture (list {:src "cookies.foo" :expected "bar"} {:src "set cookies.foo to 'bar'" :expected "bar"} {:src "cookies.foo" :expected "bar"})))
+  (deftest
+    "update-cookie-values-work"
+    (for-each
+      run-hs-fixture
+      (list {:src "set cookies.foo to 'bar'" :expected "bar"} {:src "cookies.foo" :expected "bar"} {:src "set cookies.foo to 'doh'" :expected "doh"} {:src "cookies.foo" :expected "doh"})))
+  (deftest
+    "iterate-cookies-values-work"
+    (for-each run-hs-fixture (list {:src "set cookies.foo to 'bar'" :expected true} {:src "for x in cookies me.push(x.name) then you.push(x.value) end" :expected true}))))
 
 ;; ── in (4 fixtures) ──────────────────────────────
-(defsuite "hs-compat-in"
-  (deftest "basic-no-query-return-values"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 in [1, 2, 3]" "expected" (list 1)}
-        {"src" "[1, 3] in [1, 2, 3]" "expected" (list 1 3)}
-        {"src" "[1, 3, 4] in [1, 2, 3]" "expected" (list 1 3)}
-        {"src" "[4, 5, 6] in [1, 2, 3]" "expected" (list)}
-      )))
-)
+(defsuite
+  "hs-compat-in"
+  (deftest
+    "basic-no-query-return-values"
+    (for-each
+      run-hs-fixture
+      (list {:src "1 in [1, 2, 3]" :expected (list 1)} {:src "[1, 3] in [1, 2, 3]" :expected (list 1 3)} {:src "[1, 3, 4] in [1, 2, 3]" :expected (list 1 3)} {:src "[4, 5, 6] in [1, 2, 3]" :expected (list)}))))
 
 ;; ── logicalOperator (2 fixtures) ──────────────────────────────
-(defsuite "hs-compat-logicalOperator"
-  (deftest "should-short-circuit-with-and-expression"
-    (for-each run-hs-fixture
-      (list
-        {"src" "func1() and func2()" "expected" false}
-      )))
-  (deftest "should-short-circuit-with-or-expression"
-    (for-each run-hs-fixture
-      (list
-        {"src" "func1() or func2()" "expected" true}
-      )))
-)
+(defsuite
+  "hs-compat-logicalOperator"
+  (deftest
+    "should-short-circuit-with-and-expression"
+    (for-each run-hs-fixture (list {:src "func1() and func2()" :expected false})))
+  (deftest
+    "should-short-circuit-with-or-expression"
+    (for-each run-hs-fixture (list {:src "func1() or func2()" :expected true}))))
 
 ;; ── mathOperator (8 fixtures) ──────────────────────────────
-(defsuite "hs-compat-mathOperator"
-  (deftest "addition-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 + 1" "expected" 2}
-      )))
-  (deftest "string-concat-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'a' + 'b'" "expected" "ab"}
-      )))
-  (deftest "subtraction-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 - 1" "expected" 0}
-      )))
-  (deftest "multiplication-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 * 2" "expected" 2}
-      )))
-  (deftest "division-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 / 2" "expected" 0.5}
-      )))
-  (deftest "mod-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "3 mod 2" "expected" 1}
-      )))
-  (deftest "addition-works-w-more-than-one-value"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 + 2 + 3" "expected" 6}
-      )))
-  (deftest "parenthesized-expressions-with-multiple-operators-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 + (2 * 3)" "expected" 7}
-      )))
-)
+(defsuite
+  "hs-compat-mathOperator"
+  (deftest "addition-works" (for-each run-hs-fixture (list {:src "1 + 1" :expected 2})))
+  (deftest "string-concat-works" (for-each run-hs-fixture (list {:src "'a' + 'b'" :expected "ab"})))
+  (deftest "subtraction-works" (for-each run-hs-fixture (list {:src "1 - 1" :expected 0})))
+  (deftest
+    "multiplication-works"
+    (for-each run-hs-fixture (list {:src "1 * 2" :expected 2})))
+  (deftest "division-works" (for-each run-hs-fixture (list {:src "1 / 2" :expected 0.5})))
+  (deftest "mod-works" (for-each run-hs-fixture (list {:src "3 mod 2" :expected 1})))
+  (deftest
+    "addition-works-w-more-than-one-value"
+    (for-each run-hs-fixture (list {:src "1 + 2 + 3" :expected 6})))
+  (deftest
+    "parenthesized-expressions-with-multiple-operators-work"
+    (for-each run-hs-fixture (list {:src "1 + (2 * 3)" :expected 7}))))
 
 ;; ── no (5 fixtures) ──────────────────────────────
-(defsuite "hs-compat-no"
-  (deftest "no-returns-true-for-null"
-    (for-each run-hs-fixture
-      (list
-        {"src" "no null" "expected" true}
-      )))
-  (deftest "no-returns-false-for-non-null"
-    (for-each run-hs-fixture
-      (list
-        {"src" "no 'thing'" "expected" false}
-        {"src" "no ['thing']" "expected" false}
-      )))
-  (deftest "no-returns-true-for-empty-array"
-    (for-each run-hs-fixture
-      (list
-        {"src" "no []" "expected" true}
-      )))
-  (deftest "no-returns-true-for-empty-selector"
-    (for-each run-hs-fixture
-      (list
-        {"src" "no .aClassThatDoesNotExist" "expected" true}
-      )))
-)
+(defsuite
+  "hs-compat-no"
+  (deftest
+    "no-returns-true-for-null"
+    (for-each run-hs-fixture (list {:src "no null" :expected true})))
+  (deftest
+    "no-returns-false-for-non-null"
+    (for-each run-hs-fixture (list {:src "no 'thing'" :expected false} {:src "no ['thing']" :expected false})))
+  (deftest
+    "no-returns-true-for-empty-array"
+    (for-each run-hs-fixture (list {:src "no []" :expected true})))
+  (deftest
+    "no-returns-true-for-empty-selector"
+    (for-each run-hs-fixture (list {:src "no .aClassThatDoesNotExist" :expected true}))))
 
 ;; ── not (3 fixtures) ──────────────────────────────
-(defsuite "hs-compat-not"
-  (deftest "not-inverts-true"
-    (for-each run-hs-fixture
-      (list
-        {"src" "not true" "expected" false}
-      )))
-  (deftest "not-inverts-false"
-    (for-each run-hs-fixture
-      (list
-        {"src" "not false" "expected" true}
-      )))
-  (deftest "two-nots-make-a-true"
-    (for-each run-hs-fixture
-      (list
-        {"src" "not not true" "expected" true}
-      )))
-)
+(defsuite
+  "hs-compat-not"
+  (deftest "not-inverts-true" (for-each run-hs-fixture (list {:src "not true" :expected false})))
+  (deftest "not-inverts-false" (for-each run-hs-fixture (list {:src "not false" :expected true})))
+  (deftest
+    "two-nots-make-a-true"
+    (for-each run-hs-fixture (list {:src "not not true" :expected true}))))
 
 ;; ── numbers (4 fixtures) ──────────────────────────────
-(defsuite "hs-compat-numbers"
-  (deftest "handles-numbers-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "-1" "expected" -1}
-        {"src" "1" "expected" 1}
-        {"src" "1.1" "expected" 1.1}
-        {"src" "1234567890.1234567890" "expected" 1234567890.1234567}
-      )))
-)
+(defsuite
+  "hs-compat-numbers"
+  (deftest
+    "handles-numbers-properly"
+    (for-each
+      run-hs-fixture
+      (list {:src "-1" :expected -1} {:src "1" :expected 1} {:src "1.1" :expected 1.1} {:src "1234567890.1234567890" :expected 1234570000}))))
 
 ;; ── objectLiteral (3 fixtures) ──────────────────────────────
-(defsuite "hs-compat-objectLiteral"
-  (deftest "empty-object-literals-work"
-    (for-each run-hs-fixture
-      (list
-        {"src" "{}" "expected" {}}
-      )))
-  (deftest "hyphens-work-in-object-literal-field-names"
-    (for-each run-hs-fixture
-      (list
-        {"src" "{-foo:true, bar-baz:false}" "expected" {"-foo" true "bar-baz" false}}
-      )))
-  (deftest "allows-trailing-commans"
-    (for-each run-hs-fixture
-      (list
-        {"src" "{foo:true, bar-baz:false,}" "expected" {"foo" true "bar-baz" false}}
-      )))
-)
+(defsuite
+  "hs-compat-objectLiteral"
+  (deftest
+    "empty-object-literals-work"
+    (for-each run-hs-fixture (list {:src "{}" :expected {}})))
+  (deftest
+    "hyphens-work-in-object-literal-field-names"
+    (for-each run-hs-fixture (list {:src "{-foo:true, bar-baz:false}" :expected {:bar-baz false :-foo true}})))
+  (deftest
+    "allows-trailing-commans"
+    (for-each run-hs-fixture (list {:src "{foo:true, bar-baz:false,}" :expected {:bar-baz false :foo true}}))))
 
 ;; ── positionalExpression (2 fixtures) ──────────────────────────────
-(defsuite "hs-compat-positionalExpression"
-  (deftest "first-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "the first of [1, 2, 3]" "expected" 1}
-      )))
-  (deftest "last-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "the last of [1, 2, 3]" "expected" 3}
-      )))
-)
+(defsuite
+  "hs-compat-positionalExpression"
+  (deftest "first-works" (for-each run-hs-fixture (list {:src "the first of [1, 2, 3]" :expected 1})))
+  (deftest "last-works" (for-each run-hs-fixture (list {:src "the last of [1, 2, 3]" :expected 3}))))
 
 ;; ── possessiveExpression (2 fixtures) ──────────────────────────────
-(defsuite "hs-compat-possessiveExpression"
-  (deftest "can-access-basic-properties"
-    (for-each run-hs-fixture
-      (list
-        {"src" "foo's foo" "expected" "foo"}
-      )))
-  (deftest "can-access-its-properties"
-    (for-each run-hs-fixture
-      (list
-        {"src" "its foo" "expected" "foo"}
-      )))
-)
+(defsuite
+  "hs-compat-possessiveExpression"
+  (deftest
+    "can-access-basic-properties"
+    (for-each run-hs-fixture (list {:src "foo's foo" :expected "foo"})))
+  (deftest
+    "can-access-its-properties"
+    (for-each run-hs-fixture (list {:src "its foo" :expected "foo"}))))
 
 ;; ── propertyAccess (4 fixtures) ──────────────────────────────
-(defsuite "hs-compat-propertyAccess"
-  (deftest "can-access-basic-properties"
-    (for-each run-hs-fixture
-      (list
-        {"src" "foo.foo" "expected" "foo"}
-      )))
-  (deftest "of-form-works"
-    (for-each run-hs-fixture
-      (list
-        {"src" "foo of foo" "expected" "foo"}
-      )))
-  (deftest "of-form-works-w-complex-left-side"
-    (for-each run-hs-fixture
-      (list
-        {"src" "bar.doh of foo" "expected" "foo"}
-      )))
-  (deftest "of-form-works-w-complex-right-side"
-    (for-each run-hs-fixture
-      (list
-        {"src" "doh of foo.bar" "expected" "foo"}
-      )))
-)
+(defsuite
+  "hs-compat-propertyAccess"
+  (deftest
+    "can-access-basic-properties"
+    (for-each run-hs-fixture (list {:src "foo.foo" :expected "foo"})))
+  (deftest "of-form-works" (for-each run-hs-fixture (list {:src "foo of foo" :expected "foo"})))
+  (deftest
+    "of-form-works-w-complex-left-side"
+    (for-each run-hs-fixture (list {:src "bar.doh of foo" :expected "foo"})))
+  (deftest
+    "of-form-works-w-complex-right-side"
+    (for-each run-hs-fixture (list {:src "doh of foo.bar" :expected "foo"}))))
 
 ;; ── queryRef (1 fixtures) ──────────────────────────────
-(defsuite "hs-compat-queryRef"
-  (deftest "basic-queryref-works-w-no-match"
-    (for-each run-hs-fixture
-      (list
-        {"src" "<.badClassThatDoesNotHaveAnyElements/>" "expected" 0}
-      )))
-)
+(defsuite
+  "hs-compat-queryRef"
+  (deftest
+    "basic-queryref-works-w-no-match"
+    (for-each run-hs-fixture (list {:src "<.badClassThatDoesNotHaveAnyElements/>" :expected 0}))))
 
 ;; ── some (6 fixtures) ──────────────────────────────
-(defsuite "hs-compat-some"
-  (deftest "some-returns-false-for-null"
-    (for-each run-hs-fixture
-      (list
-        {"src" "some null" "expected" false}
-      )))
-  (deftest "some-returns-true-for-non-null"
-    (for-each run-hs-fixture
-      (list
-        {"src" "some 'thing'" "expected" true}
-      )))
-  (deftest "some-returns-false-for-empty-array"
-    (for-each run-hs-fixture
-      (list
-        {"src" "some []" "expected" false}
-      )))
-  (deftest "some-returns-false-for-empty-selector"
-    (for-each run-hs-fixture
-      (list
-        {"src" "some .aClassThatDoesNotExist" "expected" false}
-      )))
-  (deftest "some-returns-true-for-nonempty-selector"
-    (for-each run-hs-fixture
-      (list
-        {"src" "some <html/>" "expected" true}
-      )))
-  (deftest "some-returns-true-for-filled-array"
-    (for-each run-hs-fixture
-      (list
-        {"src" "some ['thing']" "expected" true}
-      )))
-)
+(defsuite
+  "hs-compat-some"
+  (deftest
+    "some-returns-false-for-null"
+    (for-each run-hs-fixture (list {:src "some null" :expected false})))
+  (deftest
+    "some-returns-true-for-non-null"
+    (for-each run-hs-fixture (list {:src "some 'thing'" :expected true})))
+  (deftest
+    "some-returns-false-for-empty-array"
+    (for-each run-hs-fixture (list {:src "some []" :expected false})))
+  (deftest
+    "some-returns-false-for-empty-selector"
+    (for-each run-hs-fixture (list {:src "some .aClassThatDoesNotExist" :expected false})))
+  (deftest
+    "some-returns-true-for-nonempty-selector"
+    (for-each run-hs-fixture (list {:src "some <html/>" :expected true})))
+  (deftest
+    "some-returns-true-for-filled-array"
+    (for-each run-hs-fixture (list {:src "some ['thing']" :expected true}))))
 
 ;; ── stringPostfix (10 fixtures) ──────────────────────────────
-(defsuite "hs-compat-stringPostfix"
-  (deftest "handles-basic-postfix-strings-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1em" "expected" "1em"}
-        {"src" "1px" "expected" "1px"}
-        {"src" "-1px" "expected" "-1px"}
-        {"src" "100%" "expected" "100%"}
-      )))
-  (deftest "handles-basic-postfix-strings-with-spaces-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "1 em" "expected" "1em"}
-        {"src" "1 px" "expected" "1px"}
-        {"src" "100 %" "expected" "100%"}
-      )))
-  (deftest "handles-expression-roots-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "(0 + 1) em" "expected" "1em"}
-        {"src" "(0 + 1) px" "expected" "1px"}
-        {"src" "(100 + 0) %" "expected" "100%"}
-      )))
-)
+(defsuite
+  "hs-compat-stringPostfix"
+  (deftest
+    "handles-basic-postfix-strings-properly"
+    (for-each
+      run-hs-fixture
+      (list {:src "1em" :expected "1em"} {:src "1px" :expected "1px"} {:src "-1px" :expected "-1px"} {:src "100%" :expected "100%"})))
+  (deftest
+    "handles-basic-postfix-strings-with-spaces-properly"
+    (for-each run-hs-fixture (list {:src "1 em" :expected "1em"} {:src "1 px" :expected "1px"} {:src "100 %" :expected "100%"})))
+  (deftest
+    "handles-expression-roots-properly"
+    (for-each run-hs-fixture (list {:src "(0 + 1) em" :expected "1em"} {:src "(0 + 1) px" :expected "1px"} {:src "(100 + 0) %" :expected "100%"}))))
 
 ;; ── strings (11 fixtures) ──────────────────────────────
-(defsuite "hs-compat-strings"
-  (deftest "handles-strings-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "\"foo\"" "expected" "foo"}
-        {"src" "\"fo'o\"" "expected" "fo'o"}
-        {"src" "'foo'" "expected" "foo"}
-      )))
-  (deftest "string-templates-work-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "`$1`" "expected" "1"}
-      )))
-  (deftest "string-templates-work-properly-w-braces"
-    (for-each run-hs-fixture
-      (list
-        {"src" "`${1 + 2}`" "expected" "3"}
-      )))
-  (deftest "string-templates-preserve-white-space"
-    (for-each run-hs-fixture
-      (list
-        {"src" "` ${1 + 2} ${1 + 2} `" "expected" " 3 3 "}
-        {"src" "`${1 + 2} ${1 + 2} `" "expected" "3 3 "}
-        {"src" "`${1 + 2}${1 + 2} `" "expected" "33 "}
-        {"src" "`${1 + 2} ${1 + 2}`" "expected" "3 3"}
-      )))
-  (deftest "should-handle-strings-with-tags-and-quotes"
-    (for-each run-hs-fixture
-      (list
-        {"src" "`<div age=\"${record.age}\" style=\"color:${record.favouriteColour}\">${record.name}</div>`" "expected" "<div age=\"21\" style=\"color:bleaux\">John Connor</div>"}
-      )))
-  (deftest "should-handle-back-slashes-in-non-template-content"
-    (for-each run-hs-fixture
-      (list
-        {"src" "`https://${foo}`" "expected" "https://bar" "locals" {"foo" "bar"}}
-      )))
-)
+(defsuite
+  "hs-compat-strings"
+  (deftest
+    "handles-strings-properly"
+    (for-each run-hs-fixture (list {:src "\"foo\"" :expected "foo"} {:src "\"fo'o\"" :expected "fo'o"} {:src "'foo'" :expected "foo"})))
+  (deftest
+    "string-templates-work-properly"
+    (for-each run-hs-fixture (list {:src "`$1`" :expected "1"})))
+  (deftest
+    "string-templates-work-properly-w-braces"
+    (for-each run-hs-fixture (list {:src "`${1 + 2}`" :expected "3"})))
+  (deftest
+    "string-templates-preserve-white-space"
+    (for-each
+      run-hs-fixture
+      (list {:src "` ${1 + 2} ${1 + 2} `" :expected " 3 3 "} {:src "`${1 + 2} ${1 + 2} `" :expected "3 3 "} {:src "`${1 + 2}${1 + 2} `" :expected "33 "} {:src "`${1 + 2} ${1 + 2}`" :expected "3 3"})))
+  (deftest
+    "should-handle-strings-with-tags-and-quotes"
+    (for-each run-hs-fixture (list {:src "`<div age=\"${record.age}\" style=\"color:${record.favouriteColour}\">${record.name}</div>`" :expected "<div age=\"21\" style=\"color:bleaux\">John Connor</div>"})))
+  (deftest
+    "should-handle-back-slashes-in-non-template-content"
+    (for-each run-hs-fixture (list {:src "`https://${foo}`" :locals {:foo "bar"} :expected "https://bar"}))))
 
 ;; ── symbol (1 fixtures) ──────────────────────────────
-(defsuite "hs-compat-symbol"
-  (deftest "resolves-local-context-properly"
-    (for-each run-hs-fixture
-      (list
-        {"src" "foo" "expected" 42 "locals" {"foo" 42}}
-      )))
-)
+(defsuite
+  "hs-compat-symbol"
+  (deftest
+    "resolves-local-context-properly"
+    (for-each run-hs-fixture (list {:src "foo" :locals {:foo 42} :expected 42}))))
 
 ;; ── typecheck (4 fixtures) ──────────────────────────────
-(defsuite "hs-compat-typecheck"
-  (deftest "can-do-basic-string-typecheck"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'foo' : String" "expected" "foo"}
-      )))
-  (deftest "can-do-basic-non-string-typecheck-failure"
-    (for-each run-hs-fixture
-      (list
-        {"src" "true : String" "expected" 0}
-      )))
-  (deftest "can-do-basic-string-non-null-typecheck"
-    (for-each run-hs-fixture
-      (list
-        {"src" "'foo' : String!" "expected" "foo"}
-      )))
-  (deftest "null-causes-null-safe-string-check-to-fail"
-    (for-each run-hs-fixture
-      (list
-        {"src" "null : String!" "expected" 0}
-      )))
-)
+(defsuite
+  "hs-compat-typecheck"
+  (deftest
+    "can-do-basic-string-typecheck"
+    (for-each run-hs-fixture (list {:src "'foo' : String" :expected "foo"})))
+  (deftest
+    "can-do-basic-non-string-typecheck-failure"
+    (for-each run-hs-fixture (list {:src "true : String" :expected 0})))
+  (deftest
+    "can-do-basic-string-non-null-typecheck"
+    (for-each run-hs-fixture (list {:src "'foo' : String!" :expected "foo"})))
+  (deftest
+    "null-causes-null-safe-string-check-to-fail"
+    (for-each run-hs-fixture (list {:src "null : String!" :expected 0}))))
 
 ;; ── Summary ──────────────────────────────────────────────────────────
 ;; 24 suites, 112 tests, 222 fixtures