@barefootjs/jinja 0.1.0

package/python/barefootjs/search_params.py

@@ -0,0 +1,89 @@
+"""Python port of packages/adapter-perl/lib/BarefootJS/SearchParams.pm.
+
+Request-scoped SSR view of the query string behind the reactive
+`searchParams()` environment signal. The framework integration builds one
+per request from the request URL and threads it into the template scope as
+`searchParams` (the camelCase JS name the adapters keep, like every other
+signal/prop var); the compiled template reads it via
+`{{ searchParams.get('key') }}`.
+
+This runtime is template-engine- and framework-agnostic (stdlib only),
+matching the rest of the `barefootjs` package.
+
+Semantics mirror the browser's `URLSearchParams.get` exactly under the
+adapters' `?? -> or` lowering: `get()` returns the first value for a key, or
+`None` when the key is absent. The Jinja/Python lowering of `??` should
+coalesce only `None` (Jinja's `x.get(k) or default` would ALSO coalesce a
+present-but-empty string, which is wrong -- the emitter must use
+`x.get(k); ... if v is not None else default` shaped logic, not a bare
+`or`), preserving the distinction JS `??` draws between `null` and `''`.
+"""
+
+from __future__ import annotations
+
+import re
+from typing import Optional
+
+
+def _decode(s: Optional[str]) -> str:
+    """Percent/`+`-decode a query-string component, mirroring
+    `URLSearchParams`'s `application/x-www-form-urlencoded` parsing. Never
+    raises on malformed input (lenient parsing, matching the browser)."""
+    if s is None:
+        s = ""
+    s = s.replace("+", " ")
+    raw = bytearray()
+    i = 0
+    n = len(s)
+    while i < n:
+        ch = s[i]
+        if ch == "%" and i + 2 < n and _is_hex_pair(s[i + 1], s[i + 2]):
+            raw.append(int(s[i + 1 : i + 3], 16))
+            i += 3
+            continue
+        raw.extend(ch.encode("utf-8"))
+        i += 1
+    try:
+        return raw.decode("utf-8")
+    except UnicodeDecodeError:
+        # Lenient: a byte run that isn't valid UTF-8 is kept (with
+        # replacement chars for the invalid bytes) rather than raising --
+        # mirrors Perl's `utf8::decode`, which never dies.
+        return raw.decode("utf-8", errors="replace")
+
+
+def _is_hex_pair(a: str, b: str) -> bool:
+    return a in "0123456789ABCDEFabcdef" and b in "0123456789ABCDEFabcdef"
+
+
+_PAIR_SPLIT_RE = re.compile(r"[&;]")
+
+
+class SearchParams:
+    """new(query=''): parse a raw query string into the reader. A leading
+    '?' is tolerated, '+' decodes to a space, and %XX escapes are decoded."""
+
+    def __init__(self, query: str = ""):
+        query = query or ""
+        if query.startswith("?"):
+            query = query[1:]
+        values: dict[str, list[str]] = {}
+        for pair in _PAIR_SPLIT_RE.split(query):
+            if pair == "":
+                continue
+            if "=" in pair:
+                key, val = pair.split("=", 1)
+            else:
+                key, val = pair, None
+            key = _decode(key)
+            val_decoded = _decode(val) if val is not None else ""
+            values.setdefault(key, []).append(val_decoded)
+        self._values = values
+
+    def get(self, key: str) -> Optional[str]:
+        """First value for `key`, or `None` when the key is absent. A
+        present-but-empty value returns ''."""
+        vals = self._values.get(key)
+        if not vals:
+            return None
+        return vals[0]

package/python/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "barefootjs"
+dynamic = ["version"]
+description = "Python runtime for the @barefootjs/jinja adapter"
+license = {text = "MIT"}
+requires-python = ">=3.10"
+authors = [{ name = "kobaken", email = "kentafly88@gmail.com" }]
+keywords = ["jinja", "jinja2", "barefoot", "ssr", "templates"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = ["jinja2>=3.1"]
+
+[project.urls]
+Homepage = "https://github.com/piconic-ai/barefootjs"
+Repository = "https://github.com/piconic-ai/barefootjs"
+
+[tool.setuptools.packages.find]
+include = ["barefootjs*"]
+
+[tool.setuptools.dynamic]
+version = {file = "VERSION"}

package/python/tests/test_eval_vectors.py

@@ -0,0 +1,88 @@
+"""Golden ParsedExpr-evaluator vectors, ported from
+packages/adapter-perl/t/eval_vectors.t.
+
+Runs `packages/adapter-tests/vectors/eval-vectors.json` -- generated
+from the JS reference evaluator, shared with the Go and Perl evaluators --
+against `barefootjs.evaluator.evaluate`. The evaluator is JS-faithful by
+contract, so unlike the helper vectors there are NO Python-side
+divergences here: each case's real ParsedExpr tree, evaluated against its
+environment, must reproduce the JS-computed expect exactly.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import unittest
+
+from barefootjs import evaluator
+
+VECTORS_PATH = os.path.join(
+    os.path.dirname(__file__), "..", "..", "..", "adapter-tests", "vectors", "eval-vectors.json"
+)
+
+
+def _match(got, expect):
+    """Spec value-compat comparison -- non-finite sentinel hashes, booleans
+    by truthiness (but the evaluator result must ITSELF be a real bool, not
+    a truthy int -- matching a boolean-valued JS operator must return a real
+    boolean), numbers numerically, arrays/hashes recursively, strings by
+    equality."""
+    if expect is None:
+        return got is None
+    if isinstance(expect, dict) and "$num" in expect:
+        kind = expect["$num"]
+        if isinstance(got, bool) or not isinstance(got, (int, float)):
+            return False
+        g = float(got)
+        if kind == "NaN":
+            return g != g
+        inf = float("inf")
+        return g == (inf if kind == "Infinity" else -inf)
+    if isinstance(expect, bool):
+        return isinstance(got, bool) and got == expect
+    if isinstance(expect, list):
+        if not isinstance(got, list) or len(got) != len(expect):
+            return False
+        return all(_match(g, e) for g, e in zip(got, expect))
+    if isinstance(expect, dict):
+        if not isinstance(got, dict) or len(got) != len(expect):
+            return False
+        return all(k in got and _match(got[k], v) for k, v in expect.items())
+    if got is None or isinstance(got, (list, dict)):
+        return False
+    # Numeric comparison only when BOTH are real numbers (not
+    # numeric-looking strings) -- e.g. String(42) must return the string
+    # "42", and evaluating it as the number 42 must NOT pass.
+    want_num = isinstance(expect, (int, float)) and not isinstance(expect, bool)
+    got_num = isinstance(got, (int, float)) and not isinstance(got, bool)
+    if want_num != got_num:
+        return False
+    if want_num:
+        if isinstance(got, int) and isinstance(expect, int):
+            return got == expect
+        return float(got) == float(expect)
+    return got == expect
+
+
+@unittest.skipUnless(os.path.exists(VECTORS_PATH), "eval vectors not available outside the monorepo checkout")
+class EvalVectorsTest(unittest.TestCase):
+    def test_vectors(self):
+        with open(VECTORS_PATH, encoding="utf-8") as fh:
+            doc = json.load(fh)
+
+        self.assertTrue(doc["cases"], "eval-vectors.json contains no cases")
+
+        for case in doc["cases"]:
+            note, expr, env, expect = case["note"], case["expr"], case["env"], case["expect"]
+            with self.subTest(note=note):
+                try:
+                    got = evaluator.evaluate(expr, env)
+                except Exception as exc:  # noqa: BLE001
+                    self.fail(f"{note} raised: {exc!r}")
+                    continue
+                self.assertTrue(_match(got, expect), f"{note}: got {got!r}, want {expect!r}")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/python/tests/test_evaluator.py

@@ -0,0 +1,406 @@
+"""Hand-built ParsedExpr evaluator demonstrations, ported from
+packages/adapter-perl/t/evaluator.t.
+
+Mirrors the Go/Perl `eval_test.go` / `evaluator.t` demonstrations so all
+three backends prove the SAME restriction-lifting on the SAME shapes (a
+reducer/comparator/predicate body the fixed bf_reduce/bf_sort/bf_filter
+catalogues can't express, but the evaluator handles as just another pure
+expression).
+"""
+
+from __future__ import annotations
+
+import json
+import unittest
+
+from barefootjs import evaluator
+
+
+def nid(name):
+    return {"kind": "identifier", "name": name}
+
+
+def nmem(obj, prop):
+    return {"kind": "member", "object": obj, "property": prop, "computed": False}
+
+
+def nbin(op, left, right):
+    return {"kind": "binary", "op": op, "left": left, "right": right}
+
+
+def nstr(value):
+    return {"kind": "literal", "value": value, "literalType": "string"}
+
+
+def nnum(value):
+    return {"kind": "literal", "value": value, "literalType": "number"}
+
+
+def ncall_math(fn, arg):
+    return {"kind": "call", "callee": nmem(nid("Math"), fn), "args": [arg]}
+
+
+def nincludes(obj, needle):
+    return {"kind": "array-method", "method": "includes", "object": obj, "args": [needle]}
+
+
+class EvaluatorTest(unittest.TestCase):
+    def test_fold_arbitrary_reducer_body(self):
+        # acc + item.price * item.qty
+        body = nbin("+", nid("acc"), nbin("*", nmem(nid("item"), "price"), nmem(nid("item"), "qty")))
+        items = [{"price": 5, "qty": 3}, {"price": 2, "qty": 4}]
+        self.assertEqual(evaluator.fold(items, body, "acc", "item", 0, "left"), 23)
+
+    def test_fold_direction_observable_for_string_concat(self):
+        body = nbin("+", nid("acc"), nid("item"))
+        items = ["a", "b", "c"]
+        self.assertEqual(evaluator.fold(items, body, "acc", "item", "", "left"), "abc")
+        self.assertEqual(evaluator.fold(items, body, "acc", "item", "", "right"), "cba")
+
+    def test_sort_by_arbitrary_comparator_abs_of_field_difference(self):
+        cmp = nbin("-", ncall_math("abs", nmem(nid("a"), "v")), ncall_math("abs", nmem(nid("b"), "v")))
+        items = [{"v": -5}, {"v": 3}, {"v": -1}]
+        sorted_items = evaluator.sort_by(items, cmp, "a", "b")
+        self.assertEqual([x["v"] for x in sorted_items], [-1, 3, -5])
+
+    def test_sort_by_descending_via_reversed_comparator(self):
+        cmp = nbin("-", nmem(nid("b"), "x"), nmem(nid("a"), "x"))
+        items = [{"x": 10}, {"x": 30}, {"x": 20}]
+        sorted_items = evaluator.sort_by(items, cmp, "a", "b")
+        self.assertEqual([x["x"] for x in sorted_items], [30, 20, 10])
+
+    def test_nonfinite_division_and_js_stringification(self):
+        def div(a, b):
+            return evaluator.evaluate(nbin("/", nid("a"), nid("b")), {"a": a, "b": b})
+
+        inf = float("inf")
+        self.assertEqual(div(1, 0), inf)
+        self.assertEqual(div(-1, 0), -inf)
+        nan = div(0, 0)
+        self.assertNotEqual(nan, nan)
+
+        self.assertEqual(evaluator._to_string(inf), "Infinity")
+        self.assertEqual(evaluator._to_string(-inf), "-Infinity")
+        self.assertEqual(evaluator._to_string(inf - inf), "NaN")
+
+    def test_captured_free_vars_via_base_env(self):
+        body = nbin("+", nid("acc"), nbin("*", nid("item"), nid("factor")))
+        total = evaluator.fold([1, 2, 3], body, "acc", "item", 0, "left", {"factor": 10})
+        self.assertEqual(total, 60)
+
+        cmp = nbin(
+            "-",
+            ncall_math("abs", nbin("-", nid("a"), nid("pivot"))),
+            ncall_math("abs", nbin("-", nid("b"), nid("pivot"))),
+        )
+        sorted_items = evaluator.sort_by([1, 8, 4], cmp, "a", "b", {"pivot": 5})
+        self.assertEqual(sorted_items, [4, 8, 1])
+
+    def test_boolean_valued_ops_return_real_booleans(self):
+        lt = evaluator.evaluate(nbin("<", nid("a"), nid("b")), {"a": 1, "b": 2})
+        self.assertIsInstance(lt, bool)
+        self.assertEqual(evaluator._to_string(lt), "true")
+
+        cat = evaluator.evaluate(nbin("+", nstr("x"), nbin("<", nid("a"), nid("b"))), {"a": 1, "b": 2})
+        self.assertEqual(cat, "xtrue")
+
+        eq = evaluator.evaluate(nbin("===", nid("a"), nid("b")), {"a": 1, "b": 1})
+        self.assertIsInstance(eq, bool)
+
+        not_ = evaluator.evaluate({"kind": "unary", "op": "!", "argument": nstr("")}, {})
+        self.assertEqual(evaluator._to_string(not_), "true")
+
+        b = evaluator.evaluate({"kind": "call", "callee": nid("Boolean"), "args": [nstr("")]}, {})
+        self.assertIsInstance(b, bool)
+        self.assertEqual(evaluator._to_string(b), "false")
+
+        # `.length` is a string/array property only; a numeric scalar has none.
+        length = evaluator.evaluate(nmem(nid("n"), "length"), {"n": 123})
+        self.assertIsNone(length)
+
+    def test_array_method_includes(self):
+        # `.includes` (#2075) is the one `array-method` in the evaluator
+        # subset, dispatching on the receiver type like the SSR template
+        # lowering does at runtime (`bf.includes`): array -> SameValueZero
+        # membership (the same value rules as `===`, so a numeric 2 does NOT
+        # match the string "2"); string -> substring search; anything else
+        # degrades to false rather than raising.
+        hit = evaluator.evaluate(nincludes(nid("tags"), nstr("go")), {"tags": ["perl", "go"]})
+        self.assertIsInstance(hit, bool)
+        self.assertTrue(hit)
+
+        miss = evaluator.evaluate(nincludes(nid("tags"), nstr("rust")), {"tags": ["perl", "go"]})
+        self.assertIsInstance(miss, bool)
+        self.assertFalse(miss)
+
+        # SameValueZero, not loose equality: the numeric element 2 matches
+        # the numeric needle 2, but the string needle "2" (a different JS
+        # type) does not -- mirroring `===`'s type-sensitivity.
+        num_hit = evaluator.evaluate(nincludes(nid("nums"), nnum(2)), {"nums": [1, 2, 3]})
+        self.assertTrue(num_hit)
+        num_vs_string = evaluator.evaluate(nincludes(nid("nums"), nstr("2")), {"nums": [1, 2, 3]})
+        self.assertFalse(num_vs_string)
+
+        sub = evaluator.evaluate(nincludes(nid("name"), nstr("ar")), {"name": "bare"})
+        self.assertTrue(sub)
+
+        # A non-array, non-string receiver (number, null, object) is not a
+        # JS `.includes` target; the evaluator degrades to false rather than
+        # raising.
+        scalar_recv = evaluator.evaluate(nincludes(nid("n"), nnum(1)), {"n": 42})
+        self.assertFalse(scalar_recv)
+        null_recv = evaluator.evaluate(nincludes(nid("n"), nstr("x")), {"n": None})
+        self.assertFalse(null_recv)
+
+    def test_sort_by_non_array_receiver_returns_empty_list(self):
+        cmp = nbin("-", nid("a"), nid("b"))
+        self.assertEqual(evaluator.sort_by(None, cmp, "a", "b"), [])
+        self.assertEqual(evaluator.sort_by(42, cmp, "a", "b"), [])
+
+    def test_sort_by_is_stable_for_equal_keys(self):
+        cmp = nbin("-", nmem(nid("a"), "k"), nmem(nid("b"), "k"))
+        eq = evaluator.sort_by(
+            [{"k": 1, "id": "a"}, {"k": 1, "id": "b"}, {"k": 1, "id": "c"}], cmp, "a", "b"
+        )
+        self.assertEqual([x["id"] for x in eq], ["a", "b", "c"])
+
+        mixed = evaluator.sort_by(
+            [{"k": 2, "id": "x"}, {"k": 1, "id": "y"}, {"k": 2, "id": "z"}], cmp, "a", "b"
+        )
+        self.assertEqual([x["id"] for x in mixed], ["y", "x", "z"])
+
+    def test_fold_json_and_sort_by_json_decode_and_evaluate(self):
+        rows = [{"duration": 95}, {"duration": 213}, {"duration": 185}]
+
+        reduce_body = json.dumps(nbin("+", nid("sum"), nmem(nid("t"), "duration")))
+        self.assertEqual(evaluator.fold_json(rows, reduce_body, "sum", "t", 0, "left", {}), 493)
+
+        labels = [{"label": "a"}, {"label": "b"}, {"label": "c"}]
+        concat_body = json.dumps(nbin("+", nid("acc"), nmem(nid("x"), "label")))
+        self.assertEqual(evaluator.fold_json(labels, concat_body, "acc", "x", "", "left", {}), "abc")
+        self.assertEqual(evaluator.fold_json(labels, concat_body, "acc", "x", "", "right", {}), "cba")
+
+        cmp_json = json.dumps(nbin("-", nmem(nid("a"), "duration"), nmem(nid("b"), "duration")))
+        sorted_rows = evaluator.sort_by_json(rows, cmp_json, "a", "b", {})
+        self.assertEqual([r["duration"] for r in sorted_rows], [95, 185, 213])
+
+    def test_filter_every_some_find_find_index_over_predicate(self):
+        rows = [{"age": 15}, {"age": 30}, {"age": 18}]
+        pred = nbin(">=", nmem(nid("u"), "age"), nnum(18))
+
+        f = evaluator.filter(rows, pred, "u")
+        self.assertEqual([r["age"] for r in f], [30, 18])
+
+        self.assertTrue(evaluator.some(rows, pred, "u"))
+        self.assertFalse(evaluator.every(rows, pred, "u"))
+
+        self.assertEqual(evaluator.find(rows, pred, "u", True)["age"], 30)
+        self.assertEqual(evaluator.find(rows, pred, "u", False)["age"], 18)
+        self.assertEqual(evaluator.find_index(rows, pred, "u", True), 1)
+        self.assertEqual(evaluator.find_index(rows, pred, "u", False), 2)
+
+        self.assertTrue(evaluator.every([], pred, "u"))
+        self.assertFalse(evaluator.some([], pred, "u"))
+        self.assertIsNone(evaluator.find([], pred, "u"))
+        self.assertEqual(evaluator.find_index([], pred, "u"), -1)
+
+        pred_json = json.dumps(pred)
+        fj = evaluator.filter_json(rows, pred_json, "u")
+        self.assertEqual([r["age"] for r in fj], [30, 18])
+        self.assertFalse(evaluator.every_json(rows, pred_json, "u"))
+        self.assertTrue(evaluator.some_json(rows, pred_json, "u"))
+        self.assertEqual(evaluator.find_json(rows, pred_json, "u", True)["age"], 30)
+        self.assertEqual(evaluator.find_index_json(rows, pred_json, "u", False), 2)
+
+        cap = nbin(">=", nmem(nid("u"), "age"), nid("threshold"))
+        hi = evaluator.filter(rows, cap, "u", {"threshold": 18})
+        lo = evaluator.filter(rows, cap, "u", {"threshold": 100})
+        self.assertEqual(len(hi), 2)
+        self.assertEqual(len(lo), 0)
+        self.assertEqual(evaluator.find_index(rows, cap, "u", True, {"threshold": 100}), -1)
+
+    def test_flat_map_projects_and_flattens_one_level(self):
+        rows = [{"tags": ["a", "b"]}, {"tags": ["c"]}]
+        field = nmem(nid("i"), "tags")
+        self.assertEqual(evaluator.flat_map(rows, field, "i"), ["a", "b", "c"])
+
+        pts = [{"x": 1, "y": 2}, {"x": 3, "y": 4}]
+        tuple_proj = {
+            "kind": "array-literal",
+            "elements": [nmem(nid("p"), "x"), nmem(nid("p"), "y")],
+        }
+        self.assertEqual(evaluator.flat_map(pts, tuple_proj, "p"), [1, 2, 3, 4])
+
+        fj = evaluator.flat_map_json(rows, json.dumps(field), "i")
+        self.assertEqual(fj, ["a", "b", "c"])
+
+    def test_map_items_projects_one_result_per_element_no_flatten(self):
+        tmpl = {
+            "kind": "template-literal",
+            "parts": [
+                {"type": "string", "value": "#"},
+                {"type": "expression", "expr": nid("t")},
+            ],
+        }
+        self.assertEqual(evaluator.map_items(["perl", "go"], tmpl, "t"), ["#perl", "#go"])
+
+        users = [{"name": "Ada"}, {"name": "Grace"}]
+        field = nmem(nid("u"), "name")
+        self.assertEqual(evaluator.map_items(users, field, "u"), ["Ada", "Grace"])
+
+        rows = [{"tags": ["a", "b"]}]
+        self.assertEqual(evaluator.map_items(rows, nmem(nid("i"), "tags"), "i"), [["a", "b"]])
+
+        mj = evaluator.map_json(users, json.dumps(field), "u")
+        self.assertEqual(mj, ["Ada", "Grace"])
+
+    def test_nested_map_call_inside_a_callback_body(self):
+        # #2094: a `.map(cb)` call nested INSIDE a callback body the
+        # evaluator is already given, e.g. a `.flatMap(p => p.tags.map(t =>
+        # '#'+t))` projection (the #1938 blog-showcase shape). The inner
+        # `.map` is a `call` node whose callee is `{kind: 'member', property:
+        # 'map', computed: false}` and whose first arg is an `arrow` node.
+        prefix_tmpl = {
+            "kind": "template-literal",
+            "parts": [
+                {"type": "string", "value": "#"},
+                {"type": "expression", "expr": nid("t")},
+            ],
+        }
+        inner_map = {
+            "kind": "call",
+            "callee": nmem(nmem(nid("p"), "tags"), "map"),
+            "args": [{"kind": "arrow", "params": ["t"], "body": prefix_tmpl}],
+        }
+        self.assertEqual(
+            evaluator.evaluate(inner_map, {"p": {"tags": ["a", "b"]}}),
+            ["#a", "#b"],
+        )
+
+        # 2-param arrow (value, index).
+        idx_body = nbin("+", nid("t"), ncall_math("abs", nid("i")))
+        inner_map_idx = {
+            "kind": "call",
+            "callee": nmem(nid("xs"), "map"),
+            "args": [{"kind": "arrow", "params": ["t", "i"], "body": idx_body}],
+        }
+        self.assertEqual(evaluator.evaluate(inner_map_idx, {"xs": [10, 20]}), [10, 21])
+
+        # doubly-nested .map + .join: posts.flatMap(p => p.tags.map(t =>
+        # '#'+t).join(', ')) -- the #1938 blog-showcase shape, one level
+        # flattened by the outer `flat_map` composition.
+        join_of_map = {
+            "kind": "array-method",
+            "method": "join",
+            "object": inner_map,
+            "args": [nstr(", ")],
+        }
+        self.assertEqual(
+            evaluator.evaluate(join_of_map, {"p": {"tags": ["a", "b"]}}), "#a, #b"
+        )
+        posts = [{"tags": ["a", "b"]}, {"tags": ["c"]}]
+        proj = {
+            "kind": "array-method",
+            "method": "join",
+            "object": {
+                "kind": "call",
+                "callee": nmem(nmem(nid("p"), "tags"), "map"),
+                "args": [{"kind": "arrow", "params": ["t"], "body": prefix_tmpl}],
+            },
+            "args": [nstr(", ")],
+        }
+        self.assertEqual(evaluator.flat_map(posts, proj, "p"), ["#a, #b", "#c"])
+
+    def test_nested_callback_non_list_receiver_evaluates_to_none(self):
+        # Cross-runtime contract (Copilot review on #2095): a nested
+        # `.map`/`.filter` whose receiver is not an array evaluates to
+        # None, matching Go nil / Perl undef / Rust Null / PHP null /
+        # Ruby nil -- never an empty list, so "missing" stays
+        # distinguishable from "empty array".
+        inner_map = {
+            "kind": "call",
+            "callee": nmem(nmem(nid("p"), "tags"), "map"),
+            "args": [{"kind": "arrow", "params": ["t"], "body": nid("t")}],
+        }
+        self.assertIsNone(evaluator.evaluate(inner_map, {"p": {}}))
+        self.assertIsNone(evaluator.evaluate(inner_map, {"p": {"tags": "not-a-list"}}))
+        self.assertEqual(evaluator.evaluate(inner_map, {"p": {"tags": []}}), [])
+
+    def test_nested_filter_call_inside_a_callback_body(self):
+        # #2094: a `.filter(cb)` call nested inside a callback body,
+        # composed with `.length` and a relational comparison (the doc /
+        # #2038 motivating shape): `.filter(u => u.active).length > 0`.
+        inner_filter = {
+            "kind": "call",
+            "callee": nmem(nid("users"), "filter"),
+            "args": [
+                {
+                    "kind": "arrow",
+                    "params": ["u"],
+                    "body": nmem(nid("u"), "active"),
+                }
+            ],
+        }
+        composed = nbin(">", nmem(inner_filter, "length"), nnum(0))
+        self.assertTrue(
+            evaluator.evaluate(
+                composed,
+                {"users": [{"active": True}, {"active": False}]},
+            )
+        )
+        self.assertFalse(
+            evaluator.evaluate(
+                composed,
+                {"users": [{"active": False}, {"active": False}]},
+            )
+        )
+
+        # predicate with comparison + logical operators.
+        pred_body = {
+            "kind": "logical",
+            "op": "&&",
+            "left": nbin(">=", nmem(nid("u"), "age"), nnum(18)),
+            "right": nmem(nid("u"), "active"),
+        }
+        inner_filter2 = {
+            "kind": "call",
+            "callee": nmem(nid("users"), "filter"),
+            "args": [{"kind": "arrow", "params": ["u"], "body": pred_body}],
+        }
+        rows = [{"age": 20, "active": True}, {"age": 15, "active": True}, {"age": 40, "active": False}]
+        self.assertEqual(
+            [r["age"] for r in evaluator.evaluate(inner_filter2, {"users": rows})], [20]
+        )
+
+    def test_array_method_join(self):
+        # #2094: `.join(sep?)` as an `array-method` node, sharing the shape
+        # with `.includes` above. Default separator is `,`; a `None`
+        # (null/undefined) element joins as `''`, NOT the string "null"
+        # (which is what a bare ToString call on `None` produces).
+        def njoin(obj, sep=None):
+            node = {"kind": "array-method", "method": "join", "object": obj}
+            if sep is not None:
+                node["args"] = [sep]
+            return node
+
+        self.assertEqual(
+            evaluator.evaluate(njoin(nid("xs"), nstr("-")), {"xs": ["a", "b", "c"]}), "a-b-c"
+        )
+        self.assertEqual(
+            evaluator.evaluate(njoin(nid("xs")), {"xs": ["a", "b"]}), "a,b"
+        )
+        self.assertEqual(evaluator.evaluate(njoin(nid("xs")), {"xs": []}), "")
+        self.assertEqual(
+            evaluator.evaluate(njoin(nid("xs")), {"xs": ["a", None, "b"]}), "a,,b"
+        )
+
+    def test_length_member_read_on_arrays_and_strings(self):
+        # `.length` on both arrays and strings, needed for a composed case
+        # (`.filter(...).length > 0`); already handled by `_read_property`.
+        self.assertEqual(evaluator.evaluate(nmem(nid("xs"), "length"), {"xs": [1, 2, 3]}), 3)
+        self.assertEqual(evaluator.evaluate(nmem(nid("s"), "length"), {"s": "abc"}), 3)
+        self.assertEqual(evaluator.evaluate(nmem(nid("xs"), "length"), {"xs": []}), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()