@barefootjs/jinja 0.1.0

package/python/tests/test_search_params.py

@@ -0,0 +1,50 @@
+"""BarefootJS.SearchParams -- Python-specific concerns, ported from
+packages/adapter-perl/t/search_params.t.
+
+The cross-language VALUE semantics of `get` are owned by the
+language-independent golden vectors (`search_params_get` in
+`test_helper_vectors.py`), so Go/Perl/Python parity there is mechanical.
+This file covers only what those value vectors can't: the lazy factory
+seam, lenient parsing (never raises), and UTF-8 decoding.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from barefootjs import BarefootJS, SearchParams
+
+
+class SearchParamsTest(unittest.TestCase):
+    def test_lazy_factory(self):
+        sp = BarefootJS.search_params("sort=price")
+        self.assertIsInstance(sp, SearchParams)
+        self.assertEqual(sp.get("sort"), "price")
+        self.assertIsInstance(BarefootJS.search_params(), SearchParams)
+
+    def test_none_composition_coalesces_only_none(self):
+        # The adapters lower `searchParams().get(k) ?? d` to a Python
+        # expression that coalesces only `None` (not a bare `or`, which
+        # would also default a present-but-empty value) -- so an absent key
+        # falls back to the author's default while a present-but-empty
+        # value keeps ''.
+        absent = BarefootJS.search_params("other=x")
+        got = absent.get("sort")
+        self.assertEqual(got if got is not None else "none", "none")
+
+        empty = BarefootJS.search_params("sort=")
+        got = empty.get("sort")
+        self.assertEqual(got if got is not None else "none", "")
+
+    def test_utf8_percent_decoding(self):
+        sp = BarefootJS.search_params("q=%E2%9C%93")
+        self.assertEqual(sp.get("q"), "✓")
+
+    def test_lenient_parsing_never_raises(self):
+        BarefootJS.search_params(None)  # should not raise
+        self.assertIsNone(BarefootJS.search_params("&&&").get("x"))
+        self.assertIsNone(BarefootJS.search_params("=novalue").get("x"))
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_spread_attrs.py

@@ -0,0 +1,86 @@
+"""`BarefootJS.spread_attrs` -- ported from packages/adapter-perl/t/spread_attrs.t.
+
+JSX intrinsic-element spread runtime helper (#1407 follow-up). Mirrors the
+JS `spreadAttrs` runtime and the Go/Perl adapters' equivalents so SSR output
+stays byte-equal across every adapter -- cross-adapter parity regressions
+surface here first.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from barefootjs import BarefootJS
+
+
+class _PureBackend:
+    """`spread_attrs` only reaches the backend for `mark_raw`, which is the
+    identity here."""
+
+    def mark_raw(self, s):
+        return s
+
+
+def run(bag):
+    bf = BarefootJS(None, {"backend": _PureBackend()})
+    return str(bf.spread_attrs(bag))
+
+
+class SpreadAttrsTest(unittest.TestCase):
+    def test_basic_shapes(self):
+        self.assertEqual(run(None), "")
+        self.assertEqual(run({}), "")
+        self.assertEqual(run("not a hash"), "")
+        self.assertEqual(run({"id": "a"}), 'id="a"')
+
+    def test_alphabetic_key_order(self):
+        self.assertEqual(run({"id": "a", "class": "on"}), 'class="on" id="a"')
+
+    def test_key_remapping(self):
+        self.assertEqual(run({"className": "foo"}), 'class="foo"')
+        self.assertEqual(run({"htmlFor": "x"}), 'for="x"')
+        self.assertEqual(run({"dataPriority": "high"}), 'data-priority="high"')
+        # SVG XML attrs are case-sensitive -- preserve verbatim.
+        self.assertEqual(run({"viewBox": "0 0 10 10"}), 'viewBox="0 0 10 10"')
+        self.assertEqual(run({"clipPathUnits": "userSpaceOnUse"}), 'clipPathUnits="userSpaceOnUse"')
+        # JS-reference parity (#1411): a leading uppercase letter emits a
+        # leading dash.
+        self.assertEqual(run({"XData": "x"}), '-x-data="x"')
+
+    def test_event_handlers_js_predicate_parity(self):
+        self.assertEqual(run({"onClick": "fn", "id": "a"}), 'id="a"')
+        self.assertEqual(run({"on_custom": "fn", "id": "a"}), 'id="a"')
+        self.assertEqual(run({"on0": "fn", "id": "a"}), 'id="a"')
+        self.assertEqual(run({"oncology": "x"}), 'oncology="x"')
+
+    def test_children_skipped_ref_passed_through(self):
+        self.assertEqual(run({"children": "x", "id": "a"}), 'id="a"')
+        # JS `spreadAttrs` does NOT filter `ref` (`applyRestAttrs` does --
+        # that's a separate divergence).
+        self.assertEqual(run({"ref": "x", "id": "a"}), 'id="a" ref="x"')
+
+    def test_boolean_values(self):
+        # Contract: callers MUST use a real Python bool for boolean
+        # attributes -- unlike Perl, no sentinel object is needed.
+        self.assertEqual(run({"hidden": True, "id": "a"}), 'hidden id="a"')
+        self.assertEqual(run({"hidden": False, "id": "a"}), 'id="a"')
+        # Plain numeric 0 renders as a value (matches `tabindex="0"`).
+        self.assertEqual(run({"tabindex": 0}), 'tabindex="0"')
+
+    def test_nullish_skip(self):
+        self.assertEqual(run({"a": None, "b": "x"}), 'b="x"')
+
+    def test_html_escape(self):
+        self.assertEqual(run({"title": '<b>"x"</b>'}), 'title="&lt;b&gt;&#34;x&#34;&lt;/b&gt;"')
+        self.assertEqual(run({"alt": "tom & jerry"}), 'alt="tom &amp; jerry"')
+
+    def test_style_object_lowering(self):
+        self.assertEqual(
+            run({"style": {"backgroundColor": "red", "color": "white"}}),
+            'style="background-color:red;color:white"',
+        )
+        self.assertEqual(run({"style": "color:red"}), 'style="color:red"')
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_template_primitives.py

@@ -0,0 +1,347 @@
+"""JS-compat helper coverage (#1189), ported from
+packages/adapter-perl/t/template_primitives.t.
+
+Covers the array/string method surface NOT already exercised byte-for-byte
+by the shared golden vectors (`test_helper_vectors.py`) -- receiver-type
+dispatch edge cases, mutation isolation (a helper must return a NEW list,
+never alias the caller's), and the structured `sort` comparator dispatch.
+"""
+
+from __future__ import annotations
+
+import json
+import unittest
+
+from barefootjs import BarefootJS
+
+
+class _PureBackend:
+    def encode_json(self, data):
+        return json.dumps(data, separators=(",", ":"), sort_keys=True)
+
+    def mark_raw(self, s):
+        return s
+
+    def materialize(self, value):
+        return value() if callable(value) else value
+
+    def render_named(self, *args, **kwargs):
+        return ""
+
+
+def _is_nan(n):
+    return isinstance(n, float) and n != n
+
+
+class TemplatePrimitivesTest(unittest.TestCase):
+    def setUp(self):
+        self.bf = BarefootJS(None, {"backend": _PureBackend()})
+
+    def test_json(self):
+        self.assertEqual(self.bf.json({"a": 1}), '{"a":1}')
+        self.assertEqual(self.bf.json([1, 2, 3]), "[1,2,3]")
+        self.assertEqual(self.bf.json("hi"), '"hi"')
+        self.assertEqual(self.bf.json(None), "null")
+
+    def test_string(self):
+        self.assertEqual(self.bf.string(42), "42")
+        self.assertEqual(self.bf.string("hi"), "hi")
+        self.assertEqual(self.bf.string(None), "")
+        # Python has a real boolean type -- no Perl-style divergence.
+        self.assertEqual(self.bf.string(True), "true")
+        self.assertEqual(self.bf.string(False), "false")
+        self.assertEqual(self.bf.string(1.0), "1")
+
+    def test_number(self):
+        self.assertEqual(self.bf.number("3.14"), 3.14)
+        self.assertEqual(self.bf.number(42), 42)
+        self.assertTrue(_is_nan(self.bf.number("not a num")))
+        self.assertTrue(_is_nan(self.bf.number(None)))
+
+    def test_floor_ceil_round(self):
+        self.assertEqual(self.bf.floor(3.7), 3)
+        self.assertEqual(self.bf.floor(-3.2), -4)
+        self.assertTrue(_is_nan(self.bf.floor("not")))
+
+        self.assertEqual(self.bf.ceil(3.1), 4)
+        self.assertEqual(self.bf.ceil(-3.7), -3)
+        self.assertTrue(_is_nan(self.bf.ceil("not")))
+
+        self.assertEqual(self.bf.round(3.5), 4)
+        self.assertEqual(self.bf.round(3.4), 3)
+        # JS Math.round ties go toward +Infinity, not away from zero.
+        self.assertEqual(self.bf.round(-1.5), -1)
+        self.assertEqual(self.bf.round(-1.6), -2)
+        self.assertTrue(_is_nan(self.bf.round("not")))
+
+    def test_includes_dispatch(self):
+        # `Array.prototype.includes(x)` + `String.prototype.includes(sub)`
+        # lower to the same `bf.includes(recv, elem)` shape -- see #1448
+        # Tier A. `BarefootJS.includes` dispatches on `recv`'s Python type:
+        # a `list` scans elements via `evaluator._same_value_zero` (#2075 --
+        # SameValueZero, handling None/undefined parity, and no
+        # numeric/string coercion -- see the cross-type cases below);
+        # anything else (a `dict`, or a scalar) falls back to a substring
+        # search via `js_string` coercion.
+        self.assertTrue(self.bf.includes(["a", "b", "c"], "b"))
+        self.assertFalse(self.bf.includes(["a", "b", "c"], "z"))
+        self.assertTrue(self.bf.includes([1, 2, 3], 2))
+        self.assertFalse(self.bf.includes([], "a"))
+        self.assertTrue(self.bf.includes([None, "a"], None))
+        self.assertFalse(self.bf.includes(["a", "b"], None))
+
+        # SameValueZero never coerces across types.
+        self.assertFalse(self.bf.includes([2], "2"))
+        self.assertTrue(self.bf.includes([2], 2))
+        self.assertTrue(self.bf.includes(["2"], "2"))
+
+        self.assertTrue(self.bf.includes("hello world", "world"))
+        self.assertFalse(self.bf.includes("hello world", "earth"))
+        self.assertTrue(self.bf.includes("hello", ""))
+        self.assertFalse(self.bf.includes("", "x"))
+        self.assertFalse(self.bf.includes(None, "x"))
+
+        self.assertFalse(self.bf.includes({"a": 1}, "a"))
+
+    def test_index_of_last_index_of(self):
+        arr = ["a", "b", "c", "b", "d"]
+        self.assertEqual(self.bf.index_of(arr, "a"), 0)
+        self.assertEqual(self.bf.index_of(arr, "b"), 1)
+        self.assertEqual(self.bf.index_of(arr, "d"), 4)
+        self.assertEqual(self.bf.index_of(arr, "z"), -1)
+        self.assertEqual(self.bf.index_of([], "a"), -1)
+        self.assertEqual(self.bf.index_of("not an array", "a"), -1)
+
+        self.assertEqual(self.bf.last_index_of(arr, "b"), 3)
+        self.assertEqual(self.bf.last_index_of(arr, "a"), 0)
+        self.assertEqual(self.bf.last_index_of(arr, "z"), -1)
+
+        self.assertEqual(self.bf.index_of([None, "x", None], None), 0)
+        self.assertEqual(self.bf.last_index_of([None, "x", None], None), 2)
+
+    def test_at(self):
+        arr = ["a", "b", "c"]
+        self.assertEqual(self.bf.at(arr, 0), "a")
+        self.assertEqual(self.bf.at(arr, 2), "c")
+        self.assertEqual(self.bf.at(arr, -1), "c")
+        self.assertEqual(self.bf.at(arr, -3), "a")
+        self.assertIsNone(self.bf.at(arr, 3))
+        self.assertIsNone(self.bf.at(arr, -4))
+        self.assertIsNone(self.bf.at([], 0))
+        self.assertIsNone(self.bf.at(None, 0))
+        self.assertIsNone(self.bf.at({"a": 1}, 0))
+
+    def test_concat_mutation_isolation(self):
+        self.assertEqual(self.bf.concat(["a", "b"], ["c", "d"]), ["a", "b", "c", "d"])
+        self.assertEqual(self.bf.concat(None, ["a"]), ["a"])
+        self.assertEqual(self.bf.concat(["a"], None), ["a"])
+
+        left = ["a", "b"]
+        right = ["c", "d"]
+        out = self.bf.concat(left, right)
+        out.append("mutated")
+        self.assertEqual(left, ["a", "b"])
+        self.assertEqual(right, ["c", "d"])
+
+    def test_slice_mutation_isolation_and_clamping(self):
+        arr = ["a", "b", "c", "d", "e"]
+        self.assertEqual(self.bf.slice(arr, 1, 3), ["b", "c"])
+        self.assertEqual(self.bf.slice(arr, 2, None), ["c", "d", "e"])
+        self.assertEqual(self.bf.slice(arr, -2, None), ["d", "e"])
+        self.assertEqual(self.bf.slice(arr, 0, -1), ["a", "b", "c", "d"])
+        self.assertEqual(self.bf.slice(arr, 100, None), [])
+        self.assertEqual(self.bf.slice(arr, 3, 1), [])
+        self.assertEqual(self.bf.slice(None, 0, None), [])
+
+        src = ["a", "b", "c"]
+        out = self.bf.slice(src, 0, 2)
+        out.append("mutated")
+        self.assertEqual(src, ["a", "b", "c"])
+
+    def test_reverse_mutation_isolation(self):
+        self.assertEqual(self.bf.reverse(["a", "b", "c"]), ["c", "b", "a"])
+        self.assertEqual(self.bf.reverse([]), [])
+
+        src = ["a", "b", "c"]
+        out = self.bf.reverse(src)
+        out.append("mutated")
+        self.assertEqual(src, ["a", "b", "c"])
+        self.assertEqual(self.bf.reverse(None), [])
+
+    def test_trim(self):
+        self.assertEqual(self.bf.trim("   padded   "), "padded")
+        self.assertEqual(self.bf.trim(""), "")
+        self.assertEqual(self.bf.trim(None), "")
+        self.assertEqual(self.bf.trim({"a": 1}), "")
+        self.assertEqual(self.bf.trim(42), "42")
+
+    def test_split(self):
+        self.assertEqual(self.bf.split("a,b,c", ","), ["a", "b", "c"])
+        self.assertEqual(self.bf.split("a.b.c", "."), ["a", "b", "c"])
+        self.assertEqual(self.bf.split("a,", ","), ["a", ""])
+        self.assertEqual(self.bf.split(",a", ","), ["", "a"])
+        self.assertEqual(self.bf.split("abc", ""), ["a", "b", "c"])
+        self.assertEqual(self.bf.split("", ""), [])
+        self.assertEqual(self.bf.split("abc", ","), ["abc"])
+        self.assertEqual(self.bf.split("a,b,c"), ["a,b,c"])
+        self.assertEqual(self.bf.split("a,b,c,d", ",", 2), ["a", "b"])
+        self.assertEqual(self.bf.split("a,b", ",", 0), [])
+        self.assertEqual(self.bf.split(None, ","), [""])
+        self.assertEqual(self.bf.split(42, ","), ["42"])
+
+    def test_starts_with_ends_with_positions(self):
+        self.assertTrue(self.bf.starts_with("hello world", "hello"))
+        self.assertTrue(self.bf.starts_with("anything", ""))
+        self.assertTrue(self.bf.ends_with("hello world", "world"))
+        self.assertTrue(self.bf.starts_with("abc", "b", 1))
+        self.assertFalse(self.bf.starts_with("abc", "a", 99))
+        self.assertTrue(self.bf.starts_with("abc", "a", -5))
+        self.assertTrue(self.bf.ends_with("abc", "b", 2))
+        self.assertTrue(self.bf.ends_with("abc", "c", 99))
+        self.assertFalse(self.bf.ends_with("abc", "a", -1))
+
+    def test_replace(self):
+        self.assertEqual(self.bf.replace("hello world", "o", "0"), "hell0 world")
+        self.assertEqual(self.bf.replace("abc", "", "X"), "Xabc")
+        self.assertEqual(self.bf.replace("ab", "a", "$&"), "$&b")
+
+    def test_repeat(self):
+        self.assertEqual(self.bf.repeat("ab", 3), "ababab")
+        self.assertEqual(self.bf.repeat("ab", 0), "")
+        self.assertEqual(self.bf.repeat("ab", -2), "")
+        self.assertEqual(self.bf.repeat("ab", 2.9), "abab")
+
+    def test_pad_start_pad_end(self):
+        self.assertEqual(self.bf.pad_start("42", 5, "0"), "00042")
+        self.assertEqual(self.bf.pad_end("42", 5, "."), "42...")
+        self.assertEqual(self.bf.pad_start("42", 5), "   42")
+        self.assertEqual(self.bf.pad_start("x", 5, "ab"), "ababx")
+        self.assertEqual(self.bf.pad_start("hello", 3, "0"), "hello")
+        self.assertEqual(self.bf.pad_start("42", 5, ""), "42")
+        self.assertEqual(self.bf.pad_start("7", 4.9, "0"), "0007")
+
+    def test_sort_structured_comparator_dispatch(self):
+        items = [
+            {"name": "c", "price": 30},
+            {"name": "a", "price": 10},
+            {"name": "b", "price": 20},
+        ]
+        self.assertEqual(
+            self.bf.sort(
+                items,
+                {"keys": [{"key_kind": "field", "key": "price", "compare_type": "numeric", "direction": "asc"}]},
+            ),
+            [{"name": "a", "price": 10}, {"name": "b", "price": 20}, {"name": "c", "price": 30}],
+        )
+        self.assertEqual(
+            self.bf.sort(
+                items,
+                {"keys": [{"key_kind": "field", "key": "price", "compare_type": "numeric", "direction": "desc"}]},
+            ),
+            [{"name": "c", "price": 30}, {"name": "b", "price": 20}, {"name": "a", "price": 10}],
+        )
+        self.assertEqual(
+            self.bf.sort([3, 1, 2], {"keys": [{"key_kind": "self", "compare_type": "numeric", "direction": "asc"}]}),
+            [1, 2, 3],
+        )
+
+        # Mutation isolation.
+        src = [{"price": 3}, {"price": 1}, {"price": 2}]
+        out = self.bf.sort(
+            src, {"keys": [{"key_kind": "field", "key": "price", "compare_type": "numeric", "direction": "asc"}]}
+        )
+        out.append({"price": 99})
+        self.assertEqual(src, [{"price": 3}, {"price": 1}, {"price": 2}])
+
+        self.assertEqual(
+            self.bf.sort(None, {"keys": [{"key_kind": "self", "compare_type": "numeric", "direction": "asc"}]}), []
+        )
+        self.assertEqual(self.bf.sort([], {"keys": [{"key_kind": "field", "key": "price"}]}), [])
+
+    def test_sort_multi_key_tie_break(self):
+        items = [{"p": 1, "name": "b"}, {"p": 1, "name": "a"}, {"p": 0, "name": "c"}]
+        self.assertEqual(
+            self.bf.sort(
+                items,
+                {
+                    "keys": [
+                        {"key_kind": "field", "key": "p", "compare_type": "numeric", "direction": "asc"},
+                        {"key_kind": "field", "key": "name", "compare_type": "string", "direction": "asc"},
+                    ]
+                },
+            ),
+            [{"p": 0, "name": "c"}, {"p": 1, "name": "a"}, {"p": 1, "name": "b"}],
+        )
+
+    def test_sort_auto_compare(self):
+        self.assertEqual(
+            self.bf.sort([3, 1, 2], {"keys": [{"key_kind": "self", "compare_type": "auto", "direction": "asc"}]}),
+            [1, 2, 3],
+        )
+        self.assertEqual(
+            self.bf.sort(
+                ["charlie", "alice", "bob"],
+                {"keys": [{"key_kind": "self", "compare_type": "auto", "direction": "asc"}]},
+            ),
+            ["alice", "bob", "charlie"],
+        )
+
+
+class EvalDelegationTest(unittest.TestCase):
+    """Verifies `bf.*_eval` methods correctly delegate to the `evaluator`
+    module (JSON-string seam wiring), not just the underlying evaluator
+    functions tested directly in test_evaluator.py / test_eval_vectors.py."""
+
+    def setUp(self):
+        self.bf = BarefootJS(None, {"backend": _PureBackend()})
+
+    def _node(self, **kwargs):
+        return kwargs
+
+    def test_sort_eval(self):
+        cmp = self._node(
+            kind="binary",
+            op="-",
+            left={"kind": "member", "object": {"kind": "identifier", "name": "a"}, "property": "v"},
+            right={"kind": "member", "object": {"kind": "identifier", "name": "b"}, "property": "v"},
+        )
+        out = self.bf.sort_eval([{"v": 3}, {"v": 1}, {"v": 2}], json.dumps(cmp), "a", "b")
+        self.assertEqual([x["v"] for x in out], [1, 2, 3])
+
+    def test_reduce_eval(self):
+        body = self._node(
+            kind="binary",
+            op="+",
+            left={"kind": "identifier", "name": "acc"},
+            right={"kind": "identifier", "name": "item"},
+        )
+        out = self.bf.reduce_eval([1, 2, 3], json.dumps(body), "acc", "item", 0)
+        self.assertEqual(out, 6)
+
+    def test_filter_every_some_find_eval(self):
+        pred = self._node(
+            kind="binary",
+            op=">=",
+            left={"kind": "member", "object": {"kind": "identifier", "name": "u"}, "property": "age"},
+            right={"kind": "literal", "value": 18},
+        )
+        pred_json = json.dumps(pred)
+        rows = [{"age": 15}, {"age": 30}, {"age": 18}]
+        self.assertEqual([r["age"] for r in self.bf.filter_eval(rows, pred_json, "u")], [30, 18])
+        self.assertFalse(self.bf.every_eval(rows, pred_json, "u"))
+        self.assertTrue(self.bf.some_eval(rows, pred_json, "u"))
+        self.assertEqual(self.bf.find_eval(rows, pred_json, "u")["age"], 30)
+        self.assertEqual(self.bf.find_index_eval(rows, pred_json, "u", forward=False), 2)
+
+    def test_flat_map_eval_and_map_eval(self):
+        field = self._node(kind="member", object={"kind": "identifier", "name": "i"}, property="tags")
+        rows = [{"tags": ["a", "b"]}, {"tags": ["c"]}]
+        self.assertEqual(self.bf.flat_map_eval(rows, json.dumps(field), "i"), ["a", "b", "c"])
+
+        name_field = self._node(kind="member", object={"kind": "identifier", "name": "u"}, property="name")
+        users = [{"name": "Ada"}, {"name": "Grace"}]
+        self.assertEqual(self.bf.map_eval(users, json.dumps(name_field), "u"), ["Ada", "Grace"])
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/vector-divergences.json

@@ -0,0 +1,42 @@
+{
+  "version": 1,
+  "backend": "python",
+  "runner": "packages/adapter-jinja/python/tests/test_helper_vectors.py",
+  "spec": "spec/template-helpers.md",
+  "divergences": {
+    "add/beyond the safe-integer edge rounds as a double": {
+      "expect": 9007199254740993,
+      "reason": "Python int arithmetic is exact (arbitrary precision), not double-rounded"
+    },
+    "div/zero divisor yields Infinity": {
+      "throws": true,
+      "exception": "ZeroDivisionError",
+      "reason": "Python native / raises ZeroDivisionError on a zero divisor"
+    },
+    "number/empty string coerces to 0": {
+      "expect": { "$num": "NaN" },
+      "reason": "deliberate: empty input must not silently zero downstream arithmetic (matches the Perl port)"
+    },
+    "number/null coerces to 0": {
+      "expect": { "$num": "NaN" },
+      "reason": "deliberate: unset props must not silently zero downstream arithmetic (matches the Perl port)"
+    },
+    "string/null renders as the string \"null\"": {
+      "expect": "",
+      "reason": "deliberate: an unset prop must not surface a literal \"null\" in HTML (matches the Perl port)"
+    },
+    "sort/localeCompare orders case-insensitively (ICU collation)": {
+      "expect": ["B", "a"],
+      "reason": "Python str comparison is codepoint order, not ICU collation"
+    },
+    "sort/relational compare on numeric strings is lexical": {
+      "expect": ["9", "10"],
+      "reason": "the \"auto\" compare goes numeric when both keys look_like_number (Perl/Go parity)"
+    },
+    "reduce/numeric-string items concatenate under JS +": {
+      "expect": 11.0,
+      "reason": "numeric folds parse numeric strings instead of concatenating (Perl/Go parity)"
+    }
+  },
+  "unsupported": {}
+}