rapydscript-ns 0.8.3 → 0.9.0

package/test/unit/index.js

@@ -98,6 +98,16 @@ function compile_with_flags(src, flags_obj) {
     return output.toString();
 }
 
+// compile_python_mode simulates the default (legacy_rapydscript=false) behavior:
+// all Python compatibility flags are enabled globally.
+var PYTHON_MODE_FLAGS = ['dict_literals', 'overload_getitem', 'bound_methods',
+                         'hash_literals', 'overload_operators', 'truthiness', 'jsx'];
+function compile_python_mode(src) {
+    var flags = {};
+    PYTHON_MODE_FLAGS.forEach(function(f) { flags[f] = true; });
+    return compile_with_flags(src, flags);
+}
+
 function compile_virtual(src, virtual_files) {
     compiler_module.set_virtual_files(virtual_files);
     try {
@@ -682,6 +692,119 @@ var TESTS = [
         ].join("\n"),
     },
 
+    // ── __new__ constructor hook ───────────────────────────────────────────
+
+    {
+        name: "new_basic",
+        description: "__new__ is called before __init__; returns an instance of the class",
+        src: [
+            "# globals: assrt",
+            "order = []",
+            "class Foo:",
+            "    def __new__(cls):",
+            "        order.append('new')",
+            "        return super().__new__(cls)",
+            "    def __init__(self):",
+            "        order.append('init')",
+            "        self.x = 42",
+            "f = Foo()",
+            "assrt.deepEqual(order, ['new', 'init'])",
+            "assrt.equal(f.x, 42)",
+            "assrt.ok(isinstance(f, Foo))",
+        ].join("\n"),
+        js_checks: [
+            "Foo.__new__(Foo, ...arguments)",
+            "ρσ_instance instanceof Foo",
+        ],
+    },
+
+    {
+        name: "new_singleton",
+        description: "__new__ can implement the singleton pattern",
+        src: [
+            "# globals: assrt",
+            "class Singleton:",
+            "    _instance = None",
+            "    def __new__(cls):",
+            "        if cls._instance is None:",
+            "            cls._instance = super().__new__(cls)",
+            "        return cls._instance",
+            "    def __init__(self):",
+            "        pass",
+            "a = Singleton()",
+            "b = Singleton()",
+            "assrt.ok(a is b)",
+            "assrt.ok(isinstance(a, Singleton))",
+        ].join("\n"),
+    },
+
+    {
+        name: "new_returns_other_type",
+        description: "__new__ returning a non-class instance skips __init__",
+        src: [
+            "# globals: assrt",
+            "init_called = [False]",
+            "class MyInt:",
+            "    def __new__(cls, val):",
+            "        return val * 2",
+            "    def __init__(self, val):",
+            "        init_called[0] = True",
+            "result = MyInt(21)",
+            "assrt.equal(result, 42)",
+            "assrt.equal(init_called[0], False)",
+        ].join("\n"),
+    },
+
+    {
+        name: "new_with_args",
+        description: "__new__ receives the same args as __init__",
+        src: [
+            "# globals: assrt",
+            "class Point:",
+            "    def __new__(cls, x, y):",
+            "        instance = super().__new__(cls)",
+            "        instance._raw_x = x",
+            "        return instance",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "p = Point(3, 4)",
+            "assrt.equal(p.x, 3)",
+            "assrt.equal(p.y, 4)",
+            "assrt.equal(p._raw_x, 3)",
+            "assrt.ok(isinstance(p, Point))",
+        ].join("\n"),
+    },
+
+    {
+        name: "new_subclass_inherits",
+        description: "__new__ in parent class with subclass override",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    def __new__(cls):",
+            "        instance = super().__new__(cls)",
+            "        instance.created_by = 'Base.__new__'",
+            "        return instance",
+            "    def __init__(self):",
+            "        pass",
+            "class Child(Base):",
+            "    def __new__(cls):",
+            "        instance = super().__new__(cls)",
+            "        instance.child_attr = 'set'",
+            "        return instance",
+            "    def __init__(self):",
+            "        pass",
+            "b = Base()",
+            "assrt.equal(b.created_by, 'Base.__new__')",
+            "c = Child()",
+            "assrt.equal(c.created_by, 'Base.__new__')",
+            "assrt.equal(c.child_attr, 'set')",
+            "assrt.ok(isinstance(c, Child))",
+            "assrt.ok(isinstance(c, Base))",
+        ].join("\n"),
+    },
+
     // ── Verbatim JS ───────────────────────────────────────────────────────
 
     {
@@ -692,8 +815,8 @@ var TESTS = [
             'result = v"typeof undefined"',
             'assrt.equal(result, "undefined")',
             "arr = [1, 2, 3]",
-            'len = v"arr.length"',
-            "assrt.equal(len, 3)",
+            'leng = v"arr.length"',
+            "assrt.equal(leng, 3)",
             'assrt.equal(v"Math.max(4, 7)", 7)',
         ].join("\n"),
         js_checks: ["typeof undefined", "arr.length", "Math.max(4, 7)"],
@@ -775,6 +898,102 @@ assrt.equal(fib(15), 610)
         js_checks: ["Circle.prototype", "function double(x)"],
     },
 
+    // ── __import__() ─────────────────────────────────────────────────────
+
+    {
+        name: "__import__-basic",
+        description: "__import__(name) returns the module object for an already-imported module",
+        src: [
+            "# globals: assrt",
+            "from mymodule import square",
+            "m = __import__('mymodule')",
+            "assrt.equal(m.square(4), 16)",
+            "assrt.equal(m.square(7), 49)",
+        ].join("\n"),
+        virtual_files: {
+            mymodule: [
+                "def square(n):",
+                "    return n * n",
+            ].join("\n"),
+        },
+        js_checks: ["__import__"],
+    },
+
+    {
+        name: "__import__-via-import-stmt",
+        description: "__import__(name) also works when module was loaded via 'import x'",
+        src: [
+            "# globals: assrt",
+            "import myutils",
+            "m = __import__('myutils')",
+            "assrt.equal(m.add(3, 4), 7)",
+        ].join("\n"),
+        virtual_files: {
+            myutils: [
+                "def add(a, b):",
+                "    return a + b",
+            ].join("\n"),
+        },
+    },
+
+    {
+        name: "__import__-dotted-no-fromlist",
+        description: "__import__('pkg.sub') without fromlist returns the top-level package",
+        src: [
+            "# globals: assrt",
+            "from pkg.utils import helper",
+            "top = __import__('pkg.utils')",
+            "assrt.equal(top.name, 'pkg')",
+        ].join("\n"),
+        virtual_files: {
+            "pkg": "name = 'pkg'",     // pkg/__init__.pyj content; key is "pkg"
+            "pkg/utils": [
+                "def helper():",
+                "    return 99",
+            ].join("\n"),
+        },
+    },
+
+    {
+        name: "__import__-dotted-with-fromlist",
+        description: "__import__('pkg.sub', fromlist=['fn']) returns the submodule",
+        src: [
+            "# globals: assrt",
+            "from pkg.utils import helper",
+            "sub = __import__('pkg.utils', None, None, ['helper'])",
+            "assrt.equal(sub.helper(), 99)",
+        ].join("\n"),
+        virtual_files: {
+            "pkg": "",                  // pkg/__init__.pyj; key is "pkg"
+            "pkg/utils": [
+                "def helper():",
+                "    return 99",
+            ].join("\n"),
+        },
+    },
+
+    {
+        name: "__import__-error-on-missing",
+        description: "__import__ raises ModuleNotFoundError for a module not in ρσ_modules",
+        src: [
+            "# globals: assrt",
+            "from mymod import fn",
+            "caught = False",
+            "try:",
+            "    __import__('does_not_exist')",
+            "except ModuleNotFoundError as e:",
+            "    caught = True",
+            "    assrt.equal(e.message, \"No module named 'does_not_exist'\")",
+            "assrt.ok(caught)",
+        ].join("\n"),
+        virtual_files: {
+            mymod: [
+                "def fn():",
+                "    return 1",
+            ].join("\n"),
+        },
+    },
+
     // ── Walrus operator (:=) ──────────────────────────────────────────────
 
     {
@@ -2979,10 +3198,11 @@ assrt.equal(fib(15), 610)
             var js_with = ec_with.compile(src, { python_flags: "truthiness" });
             assert.ok(/if\s*\(ρσ_bool\(/.test(js_with),
                 "python_flags='truthiness': expected if(ρσ_bool( in: " + js_with);
-            var ec_without = make_ec(RapydScript, baselib, null);
-            var js_without = ec_without.compile(src, {});
-            assert.ok(!/if\s*\(ρσ_bool\(/.test(js_without),
-                "no python_flags: if(ρσ_bool( should NOT appear in: " + js_without);
+            // Use legacy_rapydscript: true to get legacy mode (no python flags by default)
+            var ec_legacy = make_ec(RapydScript, baselib, null);
+            var js_legacy = ec_legacy.compile(src, { legacy_rapydscript: true });
+            assert.ok(!/if\s*\(ρσ_bool\(/.test(js_legacy),
+                "legacy mode: if(ρσ_bool( should NOT appear in: " + js_legacy);
         },
     },
 
@@ -3008,80 +3228,2082 @@ assrt.equal(fib(15), 610)
         js_checks: ["ρσ_op_add", "__getitem__"],
     },
 
-];
+    // ── JSX ───────────────────────────────────────────────────────────────
 
-// ── Runner ───────────────────────────────────────────────────────────────────
+    {
+        name: "jsx_basic_element",
+        description: "JSX: basic element compiles to React.createElement",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <div>Hello</div>",
+        ].join("\n"),
+        js_checks: ["React.createElement", '"div"', '"Hello"'],
+        skip_run: true,
+    },
 
-function run_tests(filter) {
-    var tests = filter
-        ? TESTS.filter(function (t) { return t.name === filter; })
-        : TESTS;
+    {
+        name: "jsx_self_closing",
+        description: "JSX: self-closing element compiles to React.createElement",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <input type='text' />",
+        ].join("\n"),
+        js_checks: ["React.createElement", '"input"', "type"],
+        skip_run: true,
+    },
 
-    if (tests.length === 0) {
-        console.error(colored("No test found: " + filter, "red"));
-        process.exit(1);
-    }
+    {
+        name: "jsx_string_attribute",
+        description: "JSX: string attributes become object properties",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            '    return <div className="app" id="root">content</div>',
+        ].join("\n"),
+        js_checks: ["React.createElement", "className", '"app"', "id", '"root"'],
+        skip_run: true,
+    },
 
-    var failures = [];
+    {
+        name: "jsx_expression_attribute",
+        description: "JSX: expression attributes compile Python to JS",
+        src: [
+            "from __python__ import jsx",
+            "def render(isActive):",
+            "    return <div disabled={not isActive}>content</div>",
+        ].join("\n"),
+        js_checks: ["React.createElement", "disabled", "isActive"],
+        skip_run: true,
+    },
 
-    tests.forEach(function (test) {
+    {
+        name: "jsx_boolean_attribute",
+        description: "JSX: boolean attributes (no value) compile to true",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <input disabled />",
+        ].join("\n"),
+        js_checks: ["React.createElement", "disabled", "true"],
+        skip_run: true,
+    },
 
-        // Custom run function (for tests that need direct JS-level control)
-        if (typeof test.run === "function") {
-            try {
-                test.run();
-            } catch (e) {
-                failures.push(test.name);
-                var msg = e.stack || String(e);
-                console.log(colored("FAIL  " + test.name, "red") +
-                            " [run]\n      " + msg + "\n");
-                return;
-            }
-            console.log(colored("PASS  " + test.name, "green") +
-                        "  –  " + test.description);
-            return;
-        }
+    {
+        name: "jsx_hyphenated_attribute",
+        description: "JSX: hyphenated attribute names are quoted as object keys",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            '    return <button aria-label="Close">X</button>',
+        ].join("\n"),
+        js_checks: ["React.createElement", '"aria-label"', '"Close"'],
+        skip_run: true,
+    },
 
-        var js;
+    {
+        name: "jsx_expression_child",
+        description: "JSX: expression children compile Python expressions to JS",
+        src: [
+            "from __python__ import jsx",
+            "def render(count):",
+            "    return <h1>Count: {count * 2}</h1>",
+        ].join("\n"),
+        js_checks: ["React.createElement", "count * 2"],
+        skip_run: true,
+    },
 
-        // 1 – compile RapydScript → JS
-        try {
-            js = test.virtual_files ? compile_virtual(test.src, test.virtual_files) : compile(test.src);
-        } catch (e) {
-            failures.push(test.name);
-            console.log(colored("FAIL  " + test.name, "red") +
-                        " [compile error]\n      " + e + "\n");
-            return;
-        }
+    {
+        name: "jsx_nested_elements",
+        description: "JSX: nested elements produce nested React.createElement calls",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <div><span>inner</span></div>",
+        ].join("\n"),
+        js_checks: ["React.createElement", '"div"', '"span"', '"inner"'],
+        skip_run: true,
+    },
 
-        // 2 – verify expected patterns appear in the JS output
-        try {
-            check_js_patterns(test.name, js, test.js_checks);
-            // also check patterns that must NOT appear
-            (test.js_not_checks || []).forEach(function (pat) {
-                var found = (pat instanceof RegExp) ? pat.test(js) : js.indexOf(pat) !== -1;
-                if (found) {
-                    var desc = (pat instanceof RegExp) ? String(pat) : JSON.stringify(pat);
-                    throw new Error("compiled JS unexpectedly contains " + desc + "\n  in test: " + test.name);
-                }
-            });
-        } catch (e) {
-            failures.push(test.name);
-            console.debug("Emitted JS:\n" + js + "\n");
-            console.log(colored("FAIL  " + test.name, "red") +
-                        " [JS pattern mismatch]\n      " + e.message + "\n");
-            return;
-        }
+    {
+        name: "jsx_fragment",
+        description: "JSX: fragments (<>...</>) compile to React.Fragment",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <>",
+            "        <span>First</span>",
+            "        <span>Second</span>",
+            "    </>",
+        ].join("\n"),
+        js_checks: ["React.createElement", "React.Fragment", '"First"', '"Second"'],
+        skip_run: true,
+    },
 
-        // 3 – run the JS; assertions embedded in src catch wrong values
-        try {
-            run_js(js);
-        } catch (e) {
-            failures.push(test.name);
-            var msg = e.stack || String(e);
-            console.log(colored("FAIL  " + test.name, "red") +
-                        " [runtime]\n      " + msg + "\n");
-            return;
+    {
+        name: "jsx_component",
+        description: "JSX: component tags (uppercase) are passed as references",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <MyComponent name='test' />",
+        ].join("\n"),
+        js_checks: ["React.createElement", "MyComponent", "name"],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_dot_component",
+        description: "JSX: dot-notation component tags compile as member expressions",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <Router.Route path='/home' />",
+        ].join("\n"),
+        js_checks: ["React.createElement", "Router.Route"],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_spread_attr",
+        description: "JSX: spread attributes {...props} compile to object spread",
+        src: [
+            "from __python__ import jsx",
+            "def render(props):",
+            "    return <div {...props}>content</div>",
+        ].join("\n"),
+        js_checks: ["React.createElement", "...props"],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_multiline",
+        description: "JSX: multi-line JSX compiles to nested React.createElement calls",
+        src: [
+            "from __python__ import jsx",
+            "def render(title, body):",
+            "    return (",
+            "        <article>",
+            "            <h2>{title}</h2>",
+            "            <p>{body}</p>",
+            "        </article>",
+            "    )",
+        ].join("\n"),
+        js_checks: ["React.createElement", '"article"', '"h2"', '"p"', "title", "body"],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_no_jsx_without_flag",
+        description: "JSX: < in expression is a comparison without the jsx flag",
+        src: [
+            "# globals: assrt",
+            "x = 5",
+            "assrt.equal(x < 10, True)",
+        ].join("\n"),
+        js_checks: ["x < 10"],
+    },
+
+    // ── JSX whitespace and HTML entity handling ──────────────────────────────
+
+    {
+        name: "jsx_nbsp_entity",
+        description: "JSX: &nbsp; is decoded to a non-breaking space (U+00A0) in the JS string",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>Hello&nbsp;World</p>",
+        ].join("\n"),
+        js_checks: [/Hello[\u00a0]World/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_amp_entity",
+        description: "JSX: &amp; is decoded to & in the JS string",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>a &amp; b</p>",
+        ].join("\n"),
+        js_checks: [/"a & b"/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_lt_gt_entities",
+        description: "JSX: &lt; and &gt; are decoded to < and > in the JS string",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>1 &lt; 2 &gt; 0</p>",
+        ].join("\n"),
+        js_checks: [/"1 < 2 > 0"/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_quot_entity",
+        description: "JSX: &quot; is decoded to \" in the JS string",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>&quot;quoted&quot;</p>",
+        ].join("\n"),
+        js_checks: [/null, "\\\"quoted\\\""\)/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_numeric_entity_decimal",
+        description: "JSX: decimal numeric entity &#160; is decoded to U+00A0",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>a&#160;b</p>",
+        ].join("\n"),
+        js_checks: [/a[\u00a0]b/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_numeric_entity_hex",
+        description: "JSX: hex numeric entity &#x00A0; is decoded to U+00A0",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>a&#x00A0;b</p>",
+        ].join("\n"),
+        js_checks: [/a[\u00a0]b/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_no_double_decode",
+        description: "JSX: &amp;lt; decodes to &lt; (not <), entities decoded in one pass",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>&amp;lt;</p>",
+        ].join("\n"),
+        js_checks: [/"&lt;"/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_inline_spaces_preserved",
+        description: "JSX: spaces within inline text are preserved",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <p>Hello World</p>",
+        ].join("\n"),
+        js_checks: [/"Hello World"/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_multiline_whitespace_collapsed",
+        description: "JSX: whitespace-only lines between tags are dropped; text lines are preserved",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return (",
+            "        <p>",
+            "            Hello World",
+            "        </p>",
+            "    )",
+        ].join("\n"),
+        js_checks: [/"Hello World"/],
+        skip_run: true,
+    },
+
+    {
+        name: "jsx_single_space_same_line",
+        description: "JSX: a single space on its own between same-line tags is preserved",
+        src: [
+            "from __python__ import jsx",
+            "def render():",
+            "    return <span>a </span>",
+        ].join("\n"),
+        js_checks: [/"a "/],
+        skip_run: true,
+    },
+
+    // ── React standard library ───────────────────────────────────────────────
+
+    {
+        name: "react_import_usestate",
+        description: "react lib: from react import useState compiles to React.useState reference",
+        src: [
+            "from react import useState",
+            "def Counter():",
+            "    count, setCount = useState(0)",
+            "    return count",
+        ].join("\n"),
+        js_checks: ["React.useState", "useState"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_import_multiple_hooks",
+        description: "react lib: multiple hook imports each resolve to React.*",
+        src: [
+            "from react import useState, useEffect, useMemo, useRef, useCallback",
+            "def Component(items):",
+            "    count, setCount = useState(0)",
+            "    ref = useRef(None)",
+            "    result = useMemo(def(): return items.length;, [items])",
+            "    def cb():",
+            "        setCount(count + 1)",
+            "    fn = useCallback(cb, [count])",
+            "    useEffect(def(): pass;, [])",
+            "    return count",
+        ].join("\n"),
+        js_checks: [
+            "React.useState", "React.useEffect", "React.useMemo",
+            "React.useRef", "React.useCallback",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_jsx_functional_component",
+        description: "react lib: functional component with useState and JSX",
+        src: [
+            "from __python__ import jsx",
+            "from react import useState",
+            "def Counter():",
+            "    count, setCount = useState(0)",
+            "    def increment():",
+            "        setCount(count + 1)",
+            "    return <button onClick={increment}>{count}</button>",
+        ].join("\n"),
+        js_checks: [
+            "React.useState", "React.createElement",
+            '"button"', "increment", "count",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_effect",
+        description: "react lib: useEffect with deps array compiles correctly",
+        src: [
+            "from react import useState, useEffect",
+            "def Timer():",
+            "    count, setCount = useState(0)",
+            "    def tick():",
+            "        setCount(count + 1)",
+            "    useEffect(tick, [count])",
+            "    return count",
+        ].join("\n"),
+        js_checks: ["React.useState", "React.useEffect", "tick", "count"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_context",
+        description: "react lib: createContext and useContext compile correctly",
+        src: [
+            "from react import createContext, useContext",
+            "ThemeContext = createContext('light')",
+            "def ThemedButton():",
+            "    theme = useContext(ThemeContext)",
+            "    return theme",
+        ].join("\n"),
+        js_checks: [
+            "React.createContext", "React.useContext",
+            "ThemeContext", "light",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_reducer",
+        description: "react lib: useReducer with action dispatch compiles correctly",
+        src: [
+            "from react import useReducer",
+            "def reducer(state, action):",
+            "    if action.type == 'increment':",
+            "        return state + 1",
+            "    return state",
+            "def Counter():",
+            "    state, dispatch = useReducer(reducer, 0)",
+            "    return state",
+        ].join("\n"),
+        js_checks: ["React.useReducer", "reducer", "dispatch"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_ref",
+        description: "react lib: useRef for DOM reference compiles correctly",
+        src: [
+            "from __python__ import jsx",
+            "from react import useRef",
+            "def FocusInput():",
+            "    inputRef = useRef(None)",
+            "    def handleClick():",
+            "        inputRef.current.focus()",
+            "    return <input ref={inputRef} />",
+        ].join("\n"),
+        js_checks: [
+            "React.useRef", "inputRef", "current",
+            "React.createElement", '"input"',
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_memo_wrapper",
+        description: "react lib: memo() wraps a component to prevent re-renders",
+        src: [
+            "from __python__ import jsx",
+            "from react import memo",
+            "def Row(props):",
+            "    return <div>{props.label}</div>",
+            "MemoRow = memo(Row)",
+        ].join("\n"),
+        js_checks: ["React.memo", "Row", "MemoRow"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_create_context",
+        description: "react lib: createContext creates a context object",
+        src: [
+            "from react import createContext",
+            "UserContext = createContext(None)",
+        ].join("\n"),
+        js_checks: ["React.createContext", "UserContext"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_forward_ref",
+        description: "react lib: forwardRef passes ref to child component",
+        src: [
+            "from __python__ import jsx",
+            "from react import forwardRef",
+            "def FancyInput(props, ref):",
+            "    return <input ref={ref} />",
+            "FancyInputWithRef = forwardRef(FancyInput)",
+        ].join("\n"),
+        js_checks: ["React.forwardRef", "FancyInput", "FancyInputWithRef"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_fragment_import",
+        description: "react lib: Fragment import can be used as a component tag",
+        src: [
+            "from __python__ import jsx",
+            "from react import Fragment",
+            "def TwoItems():",
+            "    return <Fragment><span>A</span><span>B</span></Fragment>",
+        ].join("\n"),
+        js_checks: ["React.Fragment", "React.createElement", '"span"'],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_id",
+        description: "react lib: useId (React 18) compiles correctly",
+        src: [
+            "from react import useId",
+            "def LabeledInput():",
+            "    id = useId()",
+            "    return id",
+        ].join("\n"),
+        js_checks: ["React.useId", "useId"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_transition",
+        description: "react lib: useTransition (React 18) compiles correctly",
+        src: [
+            "from react import useState, useTransition",
+            "def SearchInput():",
+            "    isPending, startTransition = useTransition()",
+            "    query, setQuery = useState('')",
+            "    def handleChange(e):",
+            "        startTransition(def(): setQuery(e.target.value);)",
+            "    return isPending",
+        ].join("\n"),
+        js_checks: ["React.useTransition", "React.useState", "startTransition"],
+        skip_run: true,
+    },
+
+    {
+        name: "react_class_component",
+        description: "react lib: class component importing Component base class",
+        src: [
+            "from __python__ import jsx",
+            "from react import Component",
+            "class Greeter(Component):",
+            "    def render(self):",
+            "        return <h1>Hello, {self.props.name}</h1>",
+        ].join("\n"),
+        js_checks: [
+            "React.Component", "Greeter", "render",
+            "React.createElement", '"h1"',
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_jsx_list_rendering",
+        description: "react lib: list comprehension renders JSX list of elements",
+        src: [
+            "from __python__ import jsx",
+            "from react import useState",
+            "def TodoList():",
+            "    items, setItems = useState(['a', 'b', 'c'])",
+            "    return (",
+            "        <ul>",
+            "            {[<li key={i}>{item}</li> for i, item in enumerate(items)]}",
+            "        </ul>",
+            "    )",
+        ].join("\n"),
+        js_checks: [
+            "React.useState", "React.createElement",
+            '"ul"', '"li"', "enumerate",
+        ],
+        skip_run: true,
+    },
+
+    // Binding-pattern tests: verify that imported names are wired to React.* in
+    // the compiled output via both the module export and the var binding.
+
+    {
+        name: "react_binding_memo",
+        description: "react lib: memo is exported from module as React.memo and bound via var",
+        src: [
+            "from react import memo",
+            "def A(): return 1",
+            "B = memo(A)",
+        ].join("\n"),
+        // module init: ρσ_modules.react.memo = <something>; and React.memo assignment
+        // import binding: var memo = ρσ_modules.react.memo
+        js_checks: [
+            "React.memo",
+            "ρσ_modules.react.memo",
+            "var memo",
+            "memo(A)",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_binding_usestate",
+        description: "react lib: useState is exported from module as React.useState and bound via var",
+        src: [
+            "from react import useState",
+            "def C():",
+            "    n, setN = useState(0)",
+            "    return n",
+        ].join("\n"),
+        js_checks: [
+            "React.useState",
+            "ρσ_modules.react.useState",
+            "var useState",
+            "useState(0)",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_binding_useeffect",
+        description: "react lib: useEffect is exported from module as React.useEffect and bound via var",
+        src: [
+            "from react import useEffect",
+            "def D():",
+            "    def run(): pass",
+            "    useEffect(run, [])",
+        ].join("\n"),
+        js_checks: [
+            "React.useEffect",
+            "ρσ_modules.react.useEffect",
+            "var useEffect",
+            "useEffect(run",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_binding_forwardref",
+        description: "react lib: forwardRef is exported from module as React.forwardRef and bound via var",
+        src: [
+            "from __python__ import jsx",
+            "from react import forwardRef",
+            "FancyInput = forwardRef(def(props, ref): return <input ref={ref}/>;)",
+        ].join("\n"),
+        js_checks: [
+            "React.forwardRef",
+            "ρσ_modules.react.forwardRef",
+            "var forwardRef",
+            "forwardRef(",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_binding_all_hooks",
+        description: "react lib: every imported hook produces a var binding to ρσ_modules.react.*",
+        src: [
+            "from react import useState, useEffect, useContext, useReducer, useCallback, useMemo, useRef, useLayoutEffect, useId",
+        ].join("\n"),
+        js_checks: [
+            "React.useState", "React.useEffect", "React.useContext",
+            "React.useReducer", "React.useCallback", "React.useMemo",
+            "React.useRef", "React.useLayoutEffect", "React.useId",
+            "var useState", "var useEffect", "var useContext",
+            "var useReducer", "var useCallback", "var useMemo",
+            "var useRef", "var useLayoutEffect", "var useId",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_counter_example",
+        description: "react lib: full counter component from TODO example compiles correctly",
+        src: [
+            "from __python__ import jsx",
+            "from react import useState, useEffect, memo",
+            "def Counter(props):",
+            "    count, setCount = useState(props.initial or 0)",
+            "    def increment():",
+            "        setCount(count + 1)",
+            "    def decrement():",
+            "        setCount(count - 1)",
+            "    def log_change():",
+            "        pass",
+            "    useEffect(log_change, [count])",
+            "    return (",
+            "        <div className='counter'>",
+            "            <h2>{props.title}</h2>",
+            "            <button onClick={decrement}>-</button>",
+            "            <span>{count}</span>",
+            "            <button onClick={increment}>+</button>",
+            "        </div>",
+            "    )",
+            "Counter = memo(Counter)",
+        ].join("\n"),
+        js_checks: [
+            // hooks are wired correctly
+            "React.useState", "React.useEffect", "React.memo",
+            "var useState", "var useEffect", "var memo",
+            // JSX output
+            "React.createElement", '"div"', '"button"', '"span"', '"h2"',
+            // logic
+            "increment", "decrement", "count",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_lazy_suspense",
+        description: "react lib: lazy and Suspense compile correctly",
+        src: [
+            "from __python__ import jsx",
+            "from react import lazy, Suspense",
+            "def Fallback():",
+            "    return <div>Loading...</div>",
+            "def App():",
+            "    return <Suspense fallback={<Fallback/>}></Suspense>",
+        ].join("\n"),
+        js_checks: [
+            "React.lazy", "React.Suspense",
+            "var lazy", "var Suspense",
+            "React.createElement",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_callback_deps",
+        description: "react lib: useCallback dependency array passes through correctly",
+        src: [
+            "from react import useState, useCallback",
+            "def Form():",
+            "    value, setValue = useState('')",
+            "    def onChange(e):",
+            "        setValue(e.target.value)",
+            "    handler = useCallback(onChange, [value])",
+            "    return handler",
+        ].join("\n"),
+        js_checks: [
+            "React.useCallback", "React.useState",
+            "var useCallback", "var useState",
+            "useCallback(onChange",
+        ],
+        skip_run: true,
+    },
+
+    {
+        name: "react_use_memo_deps",
+        description: "react lib: useMemo dependency array passes through correctly",
+        src: [
+            "from react import useState, useMemo",
+            "def Expensive(items):",
+            "    count, setCount = useState(0)",
+            "    def compute(): return items.length * count",
+            "    result = useMemo(compute, [items, count])",
+            "    return result",
+        ].join("\n"),
+        js_checks: [
+            "React.useMemo", "React.useState",
+            "var useMemo", "var useState",
+            "useMemo(compute",
+        ],
+        skip_run: true,
+    },
+
+    // ── JSON support ─────────────────────────────────────────────────────────
+
+    {
+        name: "json_stringify_dict",
+        description: "JSON.stringify on a Python dict produces valid JSON",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals",
+            "d = {'key': 'value', 'num': 42}",
+            "s = JSON.stringify(d)",
+            "assrt.equal(jstype(s), 'string')",
+            "parsed = JSON.parse(s)",
+            "assrt.ok(isinstance(parsed, dict))",
+            "assrt.equal(parsed.get('key'), 'value')",
+            "assrt.equal(parsed.get('num'), 42)",
+        ].join("\n"),
+    },
+
+    {
+        name: "json_parse_returns_dict",
+        description: "JSON.parse returns ρσ_dict instances for objects",
+        src: [
+            "# globals: assrt",
+            "parsed = JSON.parse('{\"a\": 1, \"b\": 2}')",
+            "assrt.ok(isinstance(parsed, dict))",
+            "assrt.equal(parsed.get('a'), 1)",
+            "assrt.equal(parsed.get('b'), 2)",
+            "assrt.equal(len(parsed), 2)",
+        ].join("\n"),
+        // JSON.parse in RapydScript must compile to ρσ_json_parse (not the native global)
+        js_checks: ["ρσ_json_parse"],
+    },
+
+    {
+        name: "json_stringify_nested_dict",
+        description: "JSON.stringify and parse handle nested dicts correctly",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals",
+            "outer = {'inner': {'x': 1, 'y': 2}}",
+            "s = JSON.stringify(outer)",
+            "parsed = JSON.parse(s)",
+            "assrt.ok(isinstance(parsed, dict))",
+            "inner = parsed.get('inner')",
+            "assrt.ok(isinstance(inner, dict))",
+            "assrt.equal(inner.get('x'), 1)",
+            "assrt.equal(inner.get('y'), 2)",
+        ].join("\n"),
+    },
+
+    {
+        name: "json_dict_with_list_values",
+        description: "JSON.stringify/parse handles dicts with list values",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals",
+            "d = {'items': [1, 2, 3], 'name': 'test'}",
+            "s = JSON.stringify(d)",
+            "parsed = JSON.parse(s)",
+            "assrt.ok(isinstance(parsed, dict))",
+            "items = parsed.get('items')",
+            "assrt.ok(Array.isArray(items))",
+            "assrt.equal(items[0], 1)",
+            "assrt.equal(items[2], 3)",
+        ].join("\n"),
+    },
+
+    {
+        name: "json_dict_null_bool_values",
+        description: "JSON.stringify/parse handles None, True, False values",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals",
+            "d = {'a': None, 'b': True, 'c': False}",
+            "s = JSON.stringify(d)",
+            "parsed = JSON.parse(s)",
+            "assrt.ok(isinstance(parsed, dict))",
+            "assrt.equal(parsed.get('a'), None)",
+            "assrt.equal(parsed.get('b'), True)",
+            "assrt.equal(parsed.get('c'), False)",
+        ].join("\n"),
+    },
+
+    {
+        name: "json_parse_array_of_dicts",
+        description: "JSON.parse converts objects inside arrays to dicts",
+        src: [
+            "# globals: assrt",
+            "arr = JSON.parse('[{\"x\": 1}, {\"y\": 2}]')",
+            "assrt.ok(Array.isArray(arr))",
+            "assrt.ok(isinstance(arr[0], dict))",
+            "assrt.ok(isinstance(arr[1], dict))",
+            "assrt.equal(arr[0].get('x'), 1)",
+            "assrt.equal(arr[1].get('y'), 2)",
+        ].join("\n"),
+    },
+
+    {
+        name: "json_roundtrip_dict_comprehension",
+        description: "JSON round-trip works with dict comprehensions",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals",
+            "d = {str(i): i * i for i in range(4)}",
+            "s = JSON.stringify(d)",
+            "parsed = JSON.parse(s)",
+            "assrt.ok(isinstance(parsed, dict))",
+            "assrt.equal(parsed.get('0'), 0)",
+            "assrt.equal(parsed.get('2'), 4)",
+            "assrt.equal(parsed.get('3'), 9)",
+        ].join("\n"),
+    },
+
+    // ── __hash__ dunder ───────────────────────────────────────────────────
+
+    {
+        name: "hash_basic",
+        description: "def __hash__ in a class is dispatched by hash() builtin",
+        src: [
+            "# globals: assrt",
+            "class Point:",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "    def __hash__(self):",
+            "        return hash(self.x) ^ hash(self.y)",
+            "p1 = Point(1, 2)",
+            "p2 = Point(1, 2)",
+            "p3 = Point(3, 4)",
+            "assrt.equal(hash(p1), hash(p2))",
+            "assrt.notEqual(hash(p1), hash(p3))",
+        ].join("\n"),
+        js_checks: ["Point.prototype.__hash__"],
+    },
+
+    {
+        name: "hash_identity",
+        description: "class without __hash__ gets a stable identity hash",
+        src: [
+            "# globals: assrt",
+            "class Foo:",
+            "    def __init__(self, x):",
+            "        self.x = x",
+            "a = Foo(1)",
+            "b = Foo(1)",
+            "h_a1 = hash(a)",
+            "h_a2 = hash(a)",
+            "h_b  = hash(b)",
+            "assrt.equal(h_a1, h_a2)",
+            "assrt.notEqual(h_a1, h_b)",
+        ].join("\n"),
+    },
+
+    {
+        name: "hash_unhashable_via_eq",
+        description: "class that defines __eq__ without __hash__ becomes unhashable (TypeError)",
+        src: [
+            "# globals: assrt",
+            "class Bar:",
+            "    def __init__(self, v):",
+            "        self.v = v",
+            "    def __eq__(self, other):",
+            "        return self.v == other.v",
+            "b = Bar(1)",
+            "caught = False",
+            "try:",
+            "    hash(b)",
+            "except TypeError:",
+            "    caught = True",
+            "assrt.ok(caught, 'hash(Bar()) should raise TypeError')",
+        ].join("\n"),
+        js_checks: [".prototype.__hash__ = null"],
+    },
+
+    {
+        name: "hash_explicit_eq_and_hash",
+        description: "class that defines both __eq__ and __hash__ is hashable",
+        src: [
+            "# globals: assrt",
+            "class Key:",
+            "    def __init__(self, v):",
+            "        self.v = v",
+            "    def __eq__(self, other):",
+            "        return self.v == other.v",
+            "    def __hash__(self):",
+            "        return hash(self.v)",
+            "k1 = Key('x')",
+            "k2 = Key('x')",
+            "assrt.equal(hash(k1), hash(k2))",
+        ].join("\n"),
+        js_checks: ["Key.prototype.__hash__"],
+    },
+
+    {
+        name: "hash_primitives",
+        description: "hash() of primitives follows Python semantics",
+        src: [
+            "# globals: assrt",
+            "assrt.equal(hash(None), 0)",
+            "assrt.equal(hash(True), 1)",
+            "assrt.equal(hash(False), 0)",
+            "assrt.equal(hash(42), 42)",
+            "assrt.equal(hash(42.0), 42)",
+            "assrt.equal(jstype(hash('hello')), 'number')",
+            "assrt.equal(hash('hello'), hash('hello'))",
+        ].join("\n"),
+    },
+
+    // ── __getattr__ / __setattr__ / __delattr__ / __getattribute__ ────────────
+
+    {
+        name: "getattr_dunder_basic",
+        description: "__getattr__ is called as fallback when an attribute is not found",
+        src: [
+            "# globals: assrt",
+            "class Bag:",
+            "    def __getattr__(self, name):",
+            "        return 'missing_' + name",
+            "b = Bag()",
+            "# Missing attributes fall back to __getattr__.",
+            "assrt.equal(b.foo, 'missing_foo')",
+            "assrt.equal(b.bar, 'missing_bar')",
+        ].join("\n"),
+        js_checks: ["ρσ_attr_proxy_handler"],
+    },
+
+    {
+        name: "setattr_dunder_basic",
+        description: "__setattr__ intercepts all attribute assignments including those in __init__",
+        src: [
+            "# globals: assrt",
+            "class Recorder:",
+            "    def __init__(self):",
+            "        # Each assignment goes through __setattr__.",
+            "        self.x = 10",
+            "    def __setattr__(self, name, value):",
+            "        # Store doubled numeric values via bypass.",
+            "        if jstype(value) is 'number':",
+            "            object.__setattr__(self, name, value * 2)",
+            "        else:",
+            "            object.__setattr__(self, name, value)",
+            "r = Recorder()",
+            "# x was doubled by __setattr__ during __init__.",
+            "assrt.equal(r.x, 20, 'x doubled by __setattr__ in __init__')",
+            "r.y = 7",
+            "assrt.equal(r.y, 14, 'y doubled by __setattr__')",
+            "r.name = 'hello'",
+            "assrt.equal(r.name, 'hello', 'string stored as-is')",
+        ].join("\n"),
+        js_checks: ["ρσ_attr_proxy_handler", "ρσ_object_setattr"],
+    },
+
+    {
+        name: "delattr_dunder_basic",
+        description: "__delattr__ intercepts del obj.attr",
+        src: [
+            "# globals: assrt",
+            "class Guarded:",
+            "    def __init__(self):",
+            "        # Track deleted names.",
+            "        object.__setattr__(self, 'deleted', [])",
+            "    def __setattr__(self, name, value):",
+            "        object.__setattr__(self, name, value)",
+            "    def __delattr__(self, name):",
+            "        self.deleted.append(name)",
+            "        object.__delattr__(self, name)",
+            "g = Guarded()",
+            "g.x = 5",
+            "assrt.equal(g.x, 5)",
+            "del g.x",
+            "assrt.ok(g.deleted.indexOf('x') >= 0, 'x recorded as deleted by __delattr__')",
+            "# After deletion the attribute is gone (returns undefined).",
+            "assrt.equal(g.x, undefined, 'x is gone after del')",
+        ].join("\n"),
+        js_checks: ["ρσ_attr_proxy_handler"],
+    },
+
+    {
+        name: "getattribute_dunder_basic",
+        description: "__getattribute__ overrides ALL attribute access",
+        src: [
+            "# globals: assrt",
+            "class AllCaps:",
+            "    def __init__(self):",
+            "        object.__setattr__(self, 'value', 'hello')",
+            "    def __getattribute__(self, name):",
+            "        # Use object.__getattribute__ (compiles to ρσ_object_getattr) to bypass the hook.",
+            "        raw = object.__getattribute__(self, name)",
+            "        if jstype(raw) is 'string':",
+            "            return raw.toUpperCase()",
+            "        return raw",
+            "a = AllCaps()",
+            "assrt.equal(a.value, 'HELLO', '__getattribute__ transforms string values')",
+        ].join("\n"),
+        js_checks: ["ρσ_attr_proxy_handler"],
+    },
+
+    {
+        name: "getattribute_with_getattr_fallback",
+        description: "__getattribute__ raising AttributeError falls back to __getattr__",
+        src: [
+            "# globals: assrt",
+            "class Fallback:",
+            "    def __init__(self):",
+            "        object.__setattr__(self, 'real', 1)",
+            "    def __getattribute__(self, name):",
+            "        if name is 'real':",
+            "            return object.__getattribute__(self, name)",
+            "        raise AttributeError(name)",
+            "    def __getattr__(self, name):",
+            "        return 'fallback'",
+            "f = Fallback()",
+            "assrt.equal(f.real, 1, 'real attribute via __getattribute__')",
+            "assrt.equal(f.anything, 'fallback', 'unknown attribute via __getattr__ fallback')",
+        ].join("\n"),
+        js_checks: ["ρσ_attr_proxy_handler"],
+    },
+
+    {
+        name: "setattr_object_setattr_bypass",
+        description: "object.__setattr__ bypasses __setattr__ to avoid infinite recursion",
+        src: [
+            "# globals: assrt",
+            "class Doubler:",
+            "    def __init__(self):",
+            "        self.x = 5",
+            "    def __setattr__(self, name, value):",
+            "        # Double all numeric values, then store directly.",
+            "        if jstype(value) is 'number':",
+            "            object.__setattr__(self, name, value * 2)",
+            "        else:",
+            "            object.__setattr__(self, name, value)",
+            "d = Doubler()",
+            "assrt.equal(d.x, 10, 'value doubled by __setattr__')",
+            "d.y = 3",
+            "assrt.equal(d.y, 6)",
+            "d.label = 'alice'",
+            "assrt.equal(d.label, 'alice', 'string value stored as-is')",
+        ].join("\n"),
+    },
+
+    {
+        name: "attr_dunders_inheritance",
+        description: "__getattr__ is inherited by subclasses",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    def __getattr__(self, name):",
+            "        return 'from_base'",
+            "class Child(Base):",
+            "    def __init__(self):",
+            "        self.own = 'child_own'",
+            "c = Child()",
+            "assrt.equal(c.own, 'child_own', 'own attribute still direct')",
+            "assrt.equal(c.missing, 'from_base', '__getattr__ inherited from Base')",
+        ].join("\n"),
+        js_checks: ["ρσ_attr_proxy_handler"],
+    },
+
+    {
+        name: "attr_dunders_getattr_with_setattr",
+        description: "__setattr__ stores via bypass, __getattr__ reads back",
+        src: [
+            "# globals: assrt",
+            "class AttrStore:",
+            "    def __init__(self):",
+            "        object.__setattr__(self, '_store', {})",
+            "    def __setattr__(self, name, value):",
+            "        self._store[name] = value",
+            "    def __getattr__(self, name):",
+            "        if name in self._store:",
+            "            return self._store[name]",
+            "        raise AttributeError(name)",
+            "d = AttrStore()",
+            "d.x = 1",
+            "d.y = 2",
+            "assrt.equal(d.x, 1)",
+            "assrt.equal(d.y, 2)",
+            "caught = False",
+            "try:",
+            "    _ = d.z",
+            "except AttributeError:",
+            "    caught = True",
+            "assrt.ok(caught, 'missing attr raises AttributeError')",
+        ].join("\n"),
+    },
+
+    // ── __class_getitem__ ─────────────────────────────────────────────────
+
+    {
+        name: "class_getitem_basic",
+        description: "Class[item] calls __class_getitem__(cls, item) and returns the result",
+        src: [
+            "# globals: assrt",
+            "class Box:",
+            "    def __class_getitem__(cls, item):",
+            "        return cls.__name__ + '[' + str(item) + ']'",
+            "assrt.equal(Box[42], 'Box[42]')",
+            "assrt.equal(Box['x'], 'Box[x]')",
+        ].join("\n"),
+        js_checks: ["Box.__class_getitem__("],
+    },
+
+    {
+        name: "class_getitem_cls_is_class",
+        description: "__class_getitem__ receives the class as cls; can return it",
+        src: [
+            "# globals: assrt",
+            "class Stack:",
+            "    def __class_getitem__(cls, item):",
+            "        return cls",
+            "assrt.ok(Stack[int] is Stack)",
+            "assrt.ok(Stack[str] is Stack)",
+        ].join("\n"),
+    },
+
+    {
+        name: "class_getitem_subclass_inherits",
+        description: "subclass without __class_getitem__ inherits it from parent; cls is the subclass",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    def __class_getitem__(cls, item):",
+            "        return cls.__name__ + '<' + str(item) + '>'",
+            "class Child(Base):",
+            "    pass",
+            "assrt.equal(Base[42], 'Base<42>')",
+            "assrt.equal(Child[42], 'Child<42>')",
+        ].join("\n"),
+    },
+
+    {
+        name: "class_getitem_subclass_overrides",
+        description: "subclass can override __class_getitem__",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    def __class_getitem__(cls, item):",
+            "        return 'base'",
+            "class Child(Base):",
+            "    def __class_getitem__(cls, item):",
+            "        return 'child'",
+            "assrt.equal(Base[1], 'base')",
+            "assrt.equal(Child[1], 'child')",
+        ].join("\n"),
+    },
+
+    {
+        name: "class_getitem_classvar",
+        description: "__class_getitem__ can access class variables via cls",
+        src: [
+            "# globals: assrt",
+            "class Tagged:",
+            "    prefix = 'Tag'",
+            "    def __class_getitem__(cls, item):",
+            "        return cls.prefix + ':' + str(item)",
+            "assrt.equal(Tagged['int'], 'Tag:int')",
+        ].join("\n"),
+    },
+
+    {
+        name: "class_getitem_builtin_name",
+        description: "Built-in types int/str/float/bool have .__name__ so they work as __class_getitem__ arguments",
+        src: [
+            "# globals: assrt",
+            "class TypedList:",
+            "    prefix = 'TypedList'",
+            "    def __class_getitem__(cls, item):",
+            "        return cls.prefix + '[' + item.__name__ + ']'",
+            "assrt.equal(TypedList[int], 'TypedList[int]')",
+            "assrt.equal(TypedList[str], 'TypedList[str]')",
+            "assrt.equal(TypedList[float], 'TypedList[float]')",
+            "assrt.equal(TypedList[bool], 'TypedList[bool]')",
+        ].join("\n"),
+    },
+
+    // ── __init_subclass__ hook ────────────────────────────────────────────
+
+    {
+        name: "init_subclass_basic",
+        description: "__init_subclass__ is called when a subclass is created",
+        src: [
+            "# globals: assrt",
+            "log = []",
+            "class Base:",
+            "    def __init_subclass__(cls, **kwargs):",
+            "        log.append(cls.__name__)",
+            "class Child(Base):",
+            "    pass",
+            "class GrandChild(Child):",
+            "    pass",
+            "assrt.deepEqual(log, ['Child', 'GrandChild'])",
+        ].join("\n"),
+        js_checks: ['.__init_subclass__.call(Child)', '.__init_subclass__.call(GrandChild)'],
+    },
+
+    {
+        name: "init_subclass_cls_is_subclass",
+        description: "__init_subclass__ receives the subclass as cls",
+        src: [
+            "# globals: assrt",
+            "received = []",
+            "class Base:",
+            "    def __init_subclass__(cls, **kwargs):",
+            "        received.append(cls)",
+            "class Child(Base):",
+            "    pass",
+            "assrt.equal(received.length, 1)",
+            "assrt.equal(received[0], Child)",
+        ].join("\n"),
+    },
+
+    {
+        name: "init_subclass_kwargs",
+        description: "keyword arguments from class header are passed to __init_subclass__",
+        src: [
+            "# globals: assrt",
+            "log = []",
+            "class Base:",
+            "    def __init_subclass__(cls, tag=None, **kwargs):",
+            "        log.append(tag)",
+            "class Child(Base, tag='alpha'):",
+            "    pass",
+            "class Other(Base, tag='beta'):",
+            "    pass",
+            "assrt.deepEqual(log, ['alpha', 'beta'])",
+        ].join("\n"),
+        js_checks: ["ρσ_isc_kw"],
+    },
+
+    {
+        name: "init_subclass_super_chain",
+        description: "super().__init_subclass__ propagates to grandparent",
+        src: [
+            "# globals: assrt",
+            "calls = []",
+            "class GrandParent:",
+            "    def __init_subclass__(cls, **kwargs):",
+            "        calls.append('GrandParent:' + cls.__name__)",
+            "class Parent(GrandParent):",
+            "    def __init_subclass__(cls, **kwargs):",
+            "        super().__init_subclass__(**kwargs)",
+            "        calls.append('Parent:' + cls.__name__)",
+            "class Child(Parent):",
+            "    pass",
+            "assrt.deepEqual(calls, ['GrandParent:Parent', 'GrandParent:Child', 'Parent:Child'])",
+        ].join("\n"),
+    },
+
+    {
+        name: "init_subclass_set_classvar",
+        description: "__init_subclass__ can set class variables on the subclass",
+        src: [
+            "# globals: assrt",
+            "class Registry:",
+            "    _registry = []",
+            "    def __init_subclass__(cls, **kwargs):",
+            "        cls._registered = True",
+            "        Registry._registry.append(cls.__name__)",
+            "class A(Registry):",
+            "    pass",
+            "class B(Registry):",
+            "    pass",
+            "assrt.equal(A._registered, True)",
+            "assrt.equal(B._registered, True)",
+            "assrt.deepEqual(Registry._registry, ['A', 'B'])",
+        ].join("\n"),
+    },
+
+    {
+        name: "init_subclass_no_hook_no_call",
+        description: "no __init_subclass__ defined: class definition works normally",
+        src: [
+            "# globals: assrt",
+            "class Base:",
+            "    pass",
+            "class Child(Base):",
+            "    pass",
+            "c = Child()",
+            "assrt.ok(isinstance(c, Child))",
+        ].join("\n"),
+    },
+
+    // ── except* / ExceptionGroup ──────────────────────────────────────────
+
+    {
+        name: "except_star_basic",
+        description: "except* catches matching exceptions from an ExceptionGroup",
+        src: [
+            "# globals: assrt",
+            'eg = ExceptionGroup("errors", [ValueError("bad"), ValueError("again")])',
+            "caught_ve = []",
+            "try:",
+            "    raise eg",
+            "except* ValueError as g:",
+            "    for e in g.exceptions:",
+            "        caught_ve.append(str(e))",
+            "assrt.equal(len(caught_ve), 2)",
+            'assrt.ok(caught_ve[0].indexOf("bad") >= 0)',
+            'assrt.ok(caught_ve[1].indexOf("again") >= 0)',
+        ].join("\n"),
+        js_checks: ["ExceptionGroup", "ρσ_eg_exceptions"],
+    },
+
+    {
+        name: "except_star_multiple_handlers",
+        description: "multiple except* clauses each receive their matching sub-group",
+        src: [
+            "# globals: assrt",
+            'eg = ExceptionGroup("mixed", [ValueError("v1"), TypeError("t1"), ValueError("v2")])',
+            "val_count = 0",
+            "type_count = 0",
+            "try:",
+            "    raise eg",
+            "except* ValueError as g:",
+            "    val_count = len(g.exceptions)",
+            "except* TypeError as g:",
+            "    type_count = len(g.exceptions)",
+            "assrt.equal(val_count, 2)",
+            "assrt.equal(type_count, 1)",
+        ].join("\n"),
+    },
+
+    {
+        name: "except_star_unmatched_reraise",
+        description: "unmatched exceptions from an ExceptionGroup are re-raised",
+        src: [
+            "# globals: assrt",
+            'eg = ExceptionGroup("mixed", [ValueError("v"), KeyError("k")])',
+            "caught = False",
+            "reraised = False",
+            "try:",
+            "    try:",
+            "        raise eg",
+            "    except* ValueError as g:",
+            "        caught = True",
+            "except ExceptionGroup as outer:",
+            "    reraised = True",
+            "    assrt.equal(len(outer.exceptions), 1)",
+            "    assrt.ok(isinstance(outer.exceptions[0], KeyError))",
+            "assrt.ok(caught)",
+            "assrt.ok(reraised)",
+        ].join("\n"),
+    },
+
+    {
+        name: "except_star_non_group",
+        description: "except* also handles a plain (non-ExceptionGroup) exception",
+        src: [
+            "# globals: assrt",
+            "caught = False",
+            "try:",
+            '    raise ValueError("plain")',
+            "except* ValueError as g:",
+            "    caught = True",
+            "    assrt.ok(isinstance(g, ValueError))",
+            "assrt.ok(caught)",
+        ].join("\n"),
+    },
+
+    {
+        name: "except_star_bare",
+        description: "bare except* catches all remaining exceptions",
+        src: [
+            "# globals: assrt",
+            'eg = ExceptionGroup("all", [ValueError("v"), TypeError("t")])',
+            "total = 0",
+            "try:",
+            "    raise eg",
+            "except* as g:",
+            "    total = len(g.exceptions)",
+            "assrt.equal(total, 2)",
+        ].join("\n"),
+    },
+
+    {
+        name: "except_star_exception_group_class",
+        description: "ExceptionGroup class has correct attributes and subgroup/split methods",
+        src: [
+            "# globals: assrt",
+            'eg = ExceptionGroup("demo", [ValueError("v"), TypeError("t"), ValueError("v2")])',
+            "assrt.equal(eg.message, 'demo')",
+            "assrt.equal(len(eg.exceptions), 3)",
+            "sub = eg.subgroup(ValueError)",
+            "assrt.equal(len(sub.exceptions), 2)",
+            "parts = eg.split(ValueError)",
+            "assrt.equal(len(parts[0].exceptions), 2)",
+            "assrt.equal(len(parts[1].exceptions), 1)",
+        ].join("\n"),
+    },
+
+    // ── * and ** unpacking operators ──────────────────────────────────────────
+
+    {
+        name: "list_spread_basic",
+        description: "list spread: [*a, 1, 2] flattens iterable into a new list",
+        src: [
+            "# globals: assrt",
+            "a = [1, 2, 3]",
+            "b = [*a, 4, 5]",
+            "assrt.deepEqual(b, [1, 2, 3, 4, 5])",
+        ].join("\n"),
+        js_checks: [/\.\.\./],
+    },
+
+    {
+        name: "list_spread_middle",
+        description: "list spread: spread in the middle and at both ends",
+        src: [
+            "# globals: assrt",
+            "a = [2, 3]",
+            "b = [1, *a, 4]",
+            "assrt.deepEqual(b, [1, 2, 3, 4])",
+            "x = [10, 20]",
+            "y = [30, 40]",
+            "z = [*x, *y]",
+            "assrt.deepEqual(z, [10, 20, 30, 40])",
+        ].join("\n"),
+    },
+
+    {
+        name: "list_spread_string",
+        description: "list spread: *string unpacks characters",
+        src: [
+            "# globals: assrt",
+            "chars = [*'abc', 'd']",
+            "assrt.deepEqual(chars, ['a', 'b', 'c', 'd'])",
+        ].join("\n"),
+    },
+
+    {
+        name: "list_spread_first",
+        description: "list spread: spread as the very first element",
+        src: [
+            "# globals: assrt",
+            "a = [1, 2]",
+            "b = [*a, 3]",
+            "assrt.deepEqual(b, [1, 2, 3])",
+            "c = [*a]",
+            "assrt.deepEqual(c, [1, 2])",
+        ].join("\n"),
+    },
+
+    {
+        name: "set_spread_basic",
+        description: "set spread: {*a, 1} builds a set from iterable and literals",
+        src: [
+            "# globals: assrt",
+            "a = [1, 2, 3]",
+            "s = {*a, 4}",
+            "assrt.ok(isinstance(s, set))",
+            "assrt.equal(len(s), 4)",
+            "assrt.ok(s.has(1))",
+            "assrt.ok(s.has(4))",
+        ].join("\n"),
+        js_checks: ["ρσ_set(["],
+    },
+
+    {
+        name: "set_spread_multiple",
+        description: "set spread: multiple spreads merge iterables into a set",
+        src: [
+            "# globals: assrt",
+            "a = [1, 2]",
+            "b = [3, 4]",
+            "s = {*a, *b}",
+            "assrt.equal(len(s), 4)",
+            "assrt.ok(s.has(2))",
+            "assrt.ok(s.has(3))",
+        ].join("\n"),
+    },
+
+    {
+        name: "kwargs_spread_expr",
+        description: "**expr in function call accepts arbitrary expression, not just symbol",
+        src: [
+            "# globals: assrt",
+            "def f(a=0, b=0, c=0):",
+            "    return a + b + c",
+            "opts = {'a': 1, 'b': 2, 'c': 3}",
+            "assrt.equal(f(**opts), 6)",
+        ].join("\n"),
+    },
+
+    {
+        name: "kwargs_spread_getattr",
+        description: "**obj.attr in function call spreads attribute access result",
+        src: [
+            "# globals: assrt",
+            "class Cfg:",
+            "    params = {'x': 10, 'y': 20}",
+            "def add(x=0, y=0):",
+            "    return x + y",
+            "assrt.equal(add(**Cfg.params), 30)",
+        ].join("\n"),
+    },
+
+    {
+        name: "star_in_call_existing",
+        description: "*args in function call: existing behaviour still works",
+        src: [
+            "# globals: assrt",
+            "def f(a, b, c):",
+            "    return a + b + c",
+            "args = [1, 2, 3]",
+            "assrt.equal(f(*args), 6)",
+        ].join("\n"),
+    },
+
+    // ── tuple type ────────────────────────────────────────────────────────────
+
+    {
+        name: "tuple_from_list",
+        description: "tuple() converts a list to a plain array",
+        src: [
+            "# globals: assrt",
+            "t = tuple([1, 2, 3])",
+            "assrt.equal(t[0], 1)",
+            "assrt.equal(t[1], 2)",
+            "assrt.equal(t[2], 3)",
+            "assrt.equal(len(t), 3)",
+        ].join("\n"),
+    },
+
+    {
+        name: "tuple_from_string",
+        description: "tuple() converts a string to an array of characters",
+        src: [
+            "# globals: assrt",
+            "t = tuple('abc')",
+            "assrt.equal(t[0], 'a')",
+            "assrt.equal(t[1], 'b')",
+            "assrt.equal(t[2], 'c')",
+            "assrt.equal(len(t), 3)",
+        ].join("\n"),
+    },
+
+    {
+        name: "tuple_empty",
+        description: "tuple() with no args returns an empty array",
+        src: [
+            "# globals: assrt",
+            "t = tuple()",
+            "assrt.equal(len(t), 0)",
+        ].join("\n"),
+    },
+
+    {
+        name: "tuple_annotation_variable",
+        description: "tuple used as a variable type annotation with paren notation compiles and runs",
+        src: [
+            "# globals: assrt",
+            "coords: tuple = (10, 20)",
+            "assrt.equal(coords[0], 10)",
+            "assrt.equal(coords[1], 20)",
+        ].join("\n"),
+        js_checks: [/coords\s*=\s*ρσ_list_decorate\(\s*\[\s*10,\s*20\s*\]/],
+    },
+
+    {
+        name: "tuple_annotation_function_arg",
+        description: "tuple used as a function argument type annotation works",
+        src: [
+            "# globals: assrt",
+            "def first(t: tuple):",
+            "    return t[0]",
+            "assrt.equal(first([7, 8, 9]), 7)",
+        ].join("\n"),
+    },
+
+    {
+        name: "tuple_iterable",
+        description: "tuple() result is iterable with for-in",
+        src: [
+            "# globals: assrt",
+            "t = tuple([10, 20, 30])",
+            "total = 0",
+            "for v in t:",
+            "    total += v",
+            "assrt.equal(total, 60)",
+        ].join("\n"),
+    },
+
+    {
+        name: "list_spread_is_list",
+        description: "result of [*a] is a proper Python list with list methods",
+        src: [
+            "# globals: assrt",
+            "a = [1, 2]",
+            "b = [*a, 3]",
+            "assrt.ok(isinstance(b, list))",
+            "b.append(4)",
+            "assrt.equal(len(b), 4)",
+        ].join("\n"),
+    },
+
+    // ── copy ──────────────────────────────────────────────────────────────
+
+    {
+        name: "copy_primitives",
+        description: "copy.copy returns primitives unchanged",
+        src: [
+            "# globals: assrt",
+            "from copy import copy",
+            "assrt.equal(copy(42), 42)",
+            "assrt.equal(copy('hello'), 'hello')",
+            "assrt.equal(copy(True), True)",
+            "assrt.equal(copy(None), None)",
+        ].join("\n"),
+    },
+
+    {
+        name: "copy_list_shallow",
+        description: "copy.copy of a list returns a shallow copy",
+        src: [
+            "# globals: assrt",
+            "from copy import copy",
+            "orig = [1, [2, 3], 4]",
+            "c = copy(orig)",
+            "assrt.equal(len(c), 3)",
+            "assrt.equal(c[0], 1)",
+            // shallow: inner list is the same object
+            "assrt.ok(c[1] is orig[1])",
+            // modifying the copy does not affect the original
+            "c.append(5)",
+            "assrt.equal(len(orig), 3)",
+            "assrt.equal(len(c), 4)",
+        ].join("\n"),
+    },
+
+    {
+        name: "copy_dict_shallow",
+        description: "copy.copy of a dict returns a shallow copy",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals, overload_getitem",
+            "from copy import copy",
+            "inner = [99]",
+            "orig = {'a': 1, 'b': inner}",
+            "c = copy(orig)",
+            "assrt.equal(c['a'], 1)",
+            // shallow: inner list is the same object
+            "assrt.ok(c['b'] is orig['b'])",
+            "c['x'] = 100",
+            "assrt.ok(not ('x' in orig))",
+        ].join("\n"),
+    },
+
+    {
+        name: "copy_set_shallow",
+        description: "copy.copy of a set returns an independent copy",
+        src: [
+            "# globals: assrt",
+            "from copy import copy",
+            "orig = {1, 2, 3}",
+            "c = copy(orig)",
+            "assrt.equal(len(c), 3)",
+            "c.add(4)",
+            "assrt.equal(len(orig), 3)",
+            "assrt.equal(len(c), 4)",
+        ].join("\n"),
+    },
+
+    {
+        name: "copy_class_instance_shallow",
+        description: "copy.copy of a class instance is shallow",
+        src: [
+            "# globals: assrt",
+            "from copy import copy",
+            "class Point:",
+            "    def __init__(self, x, y):",
+            "        self.x = x",
+            "        self.y = y",
+            "p = Point(1, 2)",
+            "p.data = [10, 20]",
+            "q = copy(p)",
+            "assrt.equal(q.x, 1)",
+            "assrt.equal(q.y, 2)",
+            "assrt.ok(q is not p)",
+            // shallow: mutable attribute is the same object
+            "assrt.ok(q.data is p.data)",
+        ].join("\n"),
+    },
+
+    {
+        name: "copy_custom_copy_hook",
+        description: "__copy__ method is called by copy.copy",
+        src: [
+            "# globals: assrt",
+            "from copy import copy",
+            "class MyObj:",
+            "    def __init__(self, val):",
+            "        self.val = val",
+            "        self.copy_called = False",
+            "    def __copy__(self):",
+            "        result = MyObj(self.val * 2)",
+            "        return result",
+            "obj = MyObj(5)",
+            "c = copy(obj)",
+            "assrt.equal(c.val, 10)",
+        ].join("\n"),
+    },
+
+    {
+        name: "deepcopy_list_nested",
+        description: "copy.deepcopy of a list with nested lists returns independent copies",
+        src: [
+            "# globals: assrt",
+            "from copy import deepcopy",
+            "orig = [1, [2, 3], [4, [5, 6]]]",
+            "d = deepcopy(orig)",
+            "assrt.equal(d[0], 1)",
+            "assrt.equal(d[1][0], 2)",
+            "assrt.equal(d[2][1][0], 5)",
+            // deep: inner lists are different objects
+            "assrt.ok(d[1] is not orig[1])",
+            "assrt.ok(d[2][1] is not orig[2][1])",
+            // mutating copy does not affect original
+            "d[1].append(99)",
+            "assrt.equal(len(orig[1]), 2)",
+        ].join("\n"),
+    },
+
+    {
+        name: "deepcopy_dict_nested",
+        description: "copy.deepcopy of a dict with nested dicts returns independent copies",
+        src: [
+            "# globals: assrt",
+            "from __python__ import dict_literals, overload_getitem",
+            "from copy import deepcopy",
+            "orig = {'a': {'x': 1}, 'b': [2, 3]}",
+            "d = deepcopy(orig)",
+            "assrt.equal(d['a']['x'], 1)",
+            "assrt.ok(d['a'] is not orig['a'])",
+            "assrt.ok(d['b'] is not orig['b'])",
+            "d['a']['x'] = 99",
+            "assrt.equal(orig['a']['x'], 1)",
+        ].join("\n"),
+    },
+
+    {
+        name: "deepcopy_circular",
+        description: "copy.deepcopy handles circular references without infinite recursion",
+        src: [
+            "# globals: assrt",
+            "from copy import deepcopy",
+            "a = [1, 2]",
+            "a.push(a)   # circular reference",
+            "b = deepcopy(a)",
+            "assrt.equal(b[0], 1)",
+            "assrt.equal(b[1], 2)",
+            "assrt.ok(b[2] is b)",  // circularity preserved in the copy
+            "assrt.ok(b is not a)",
+        ].join("\n"),
+    },
+
+    {
+        name: "deepcopy_custom_hook",
+        description: "__deepcopy__(memo) method is called by copy.deepcopy",
+        src: [
+            "# globals: assrt",
+            "from copy import deepcopy",
+            "class Node:",
+            "    def __init__(self, val):",
+            "        self.val = val",
+            "        self.children = []",
+            "    def __deepcopy__(self, memo):",
+            "        result = Node(self.val * 10)",
+            "        return result",
+            "n = Node(7)",
+            "m = deepcopy(n)",
+            "assrt.equal(m.val, 70)",
+            "assrt.ok(m is not n)",
+        ].join("\n"),
+    },
+
+    {
+        name: "deepcopy_class_instance",
+        description: "copy.deepcopy of a class instance deeply copies instance attributes",
+        src: [
+            "# globals: assrt",
+            "from copy import deepcopy",
+            "class Box:",
+            "    def __init__(self, items):",
+            "        self.items = items",
+            "b = Box([1, 2, 3])",
+            "c = deepcopy(b)",
+            "assrt.ok(c is not b)",
+            "assrt.ok(c.items is not b.items)",
+            "c.items.append(4)",
+            "assrt.equal(len(b.items), 3)",
+        ].join("\n"),
+    },
+
+    // ── str.expandtabs ────────────────────────────────────────────────────
+
+    {
+        name: "expandtabs_default",
+        description: "str.expandtabs() with default tabsize=8 replaces tabs with spaces",
+        src: [
+            "# globals: assrt",
+            'assrt.equal(str.expandtabs("\\t"), "        ")',
+            'assrt.equal(str.expandtabs("a\\tb"), "a       b")',
+            'assrt.equal(str.expandtabs("ab\\tc"), "ab      c")',
+        ].join("\n"),
+        js_checks: ["expandtabs"],
+    },
+
+    {
+        name: "expandtabs_custom_tabsize",
+        description: "str.expandtabs(tabsize) respects a custom tabsize",
+        src: [
+            "# globals: assrt",
+            'assrt.equal(str.expandtabs("\\t", 4), "    ")',
+            'assrt.equal(str.expandtabs("a\\tb", 4), "a   b")',
+            'assrt.equal(str.expandtabs("abc\\td", 4), "abc d")',
+            'assrt.equal(str.expandtabs("ab\\tcd", 4), "ab  cd")',
+        ].join("\n"),
+        js_checks: [],
+    },
+
+    {
+        name: "expandtabs_tabsize_zero",
+        description: "str.expandtabs(0) removes all tab characters",
+        src: [
+            "# globals: assrt",
+            'assrt.equal(str.expandtabs("a\\tb\\tc", 0), "abc")',
+            'assrt.equal(str.expandtabs("\\t\\t", 0), "")',
+        ].join("\n"),
+        js_checks: [],
+    },
+
+    {
+        name: "expandtabs_newline_resets_column",
+        description: "str.expandtabs() resets column counter at newlines",
+        src: [
+            "# globals: assrt",
+            'assrt.equal(str.expandtabs("a\\n\\tb", 4), "a\\n    b")',
+            'assrt.equal(str.expandtabs("abc\\n\\td", 4), "abc\\n    d")',
+        ].join("\n"),
+        js_checks: [],
+    },
+
+    {
+        name: "expandtabs_instance_method",
+        description: "expandtabs works as an instance method via str.prototype",
+        src: [
+            "# globals: assrt",
+            "from pythonize import strings",
+            "strings()",
+            'assrt.equal("\\t".expandtabs(), "        ")',
+            'assrt.equal("a\\tb".expandtabs(4), "a   b")',
+        ].join("\n"),
+        js_checks: [],
+    },
+
+    {
+        name: "expandtabs_no_tabs",
+        description: "str.expandtabs() returns string unchanged when no tabs present",
+        src: [
+            "# globals: assrt",
+            'assrt.equal(str.expandtabs("hello world"), "hello world")',
+            'assrt.equal(str.expandtabs(""), "")',
+        ].join("\n"),
+        js_checks: [],
+    },
+
+    // ── legacy_rapydscript default ────────────────────────────────────────
+
+    {
+        name: "legacy_rapydscript_false_enables_overload_operators",
+        description: "default (legacy_rapydscript=false): overload_operators active; a+b uses ρσ_op_add",
+        run: function() {
+            // Use unique variable names so the pattern is only from user code, not baselib
+            var js = compile_python_mode("myval = myarg_a + myarg_b");
+            assert.ok(js.indexOf("ρσ_op_add(myarg_a, myarg_b)") !== -1,
+                "expected ρσ_op_add(myarg_a, myarg_b) in python mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_overload_operators",
+        description: "legacy mode (no flags): a+b uses ρσ_list_add, not ρσ_op_add",
+        run: function() {
+            // compile() uses no scoped_flags → no overload_operators
+            var js = compile("myval = myarg_a + myarg_b");
+            assert.ok(js.indexOf("ρσ_op_add(myarg_a") === -1,
+                "unexpected ρσ_op_add(myarg_a in legacy mode; got:\n" + js);
+            assert.ok(js.indexOf("ρσ_list_add(myarg_a") !== -1,
+                "expected ρσ_list_add(myarg_a in legacy mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_false_enables_dict_literals",
+        description: "default (legacy_rapydscript=false): dict_literals active; {} compiles to ρσ_dict()",
+        run: function() {
+            var js = compile_python_mode("mydict = {}");
+            assert.ok(js.indexOf("dict_literal") !== -1 || js.indexOf("ρσ_dict") !== -1,
+                "expected dict() wrapper with dict_literals enabled (python mode); got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_dict_literals",
+        description: "legacy mode (no flags): {} compiles to a plain JS object literal",
+        run: function() {
+            var js = compile("mydict = {}");
+            // The assignment line should not contain dict_literal or ρσ_dict
+            var lines = js.split("\n").filter(function(l) { return l.indexOf("mydict") !== -1; });
+            var userline = lines.join("\n");
+            assert.ok(userline.indexOf("dict_literal") === -1 && userline.indexOf("ρσ_dict") === -1,
+                "unexpected dict() wrapper in legacy mode; got:\n" + userline);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_false_enables_truthiness",
+        description: "default (legacy_rapydscript=false): truthiness active; if-condition wrapped in ρσ_bool()",
+        run: function() {
+            var js = compile_python_mode("if mycond:\n    pass");
+            assert.ok(/if\s*\(ρσ_bool\(mycond/.test(js),
+                "expected if(ρσ_bool(mycond in python mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_truthiness",
+        description: "legacy mode (no flags): if-condition is not wrapped in ρσ_bool()",
+        run: function() {
+            var js = compile("if mycond:\n    pass");
+            assert.ok(!/if\s*\(ρσ_bool\(mycond/.test(js),
+                "unexpected ρσ_bool(mycond wrapping in legacy mode; got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_false_enables_bound_methods",
+        description: "default (legacy_rapydscript=false): bound_methods active; methods are .bind()-ed",
+        run: function() {
+            var js = compile_python_mode([
+                "class MyFoo:",
+                "    def mybar(self):",
+                "        return 1",
+            ].join("\n"));
+            // Bound methods produce a .bind(this) call in the class prototype setup
+            assert.ok(/mybar.*bind/.test(js) || /bind.*mybar/.test(js),
+                "expected .bind() for mybar with bound_methods enabled (python mode); got:\n" + js);
+        },
+    },
+
+    {
+        name: "legacy_rapydscript_true_no_bound_methods",
+        description: "legacy mode (no flags): methods are not .bind()-ed",
+        run: function() {
+            var js = compile([
+                "class MyFoo:",
+                "    def mybar(self):",
+                "        return 1",
+            ].join("\n"));
+            assert.ok(!/mybar.*bind/.test(js) && !/bind.*mybar/.test(js),
+                "unexpected .bind() for mybar in legacy mode; got:\n" + js);
+        },
+    },
+
+];
+
+// ── Runner ───────────────────────────────────────────────────────────────────
+
+function run_tests(filter) {
+    var tests = filter
+        ? TESTS.filter(function (t) { return t.name === filter; })
+        : TESTS;
+
+    if (tests.length === 0) {
+        console.error(colored("No test found: " + filter, "red"));
+        process.exit(1);
+    }
+
+    var failures = [];
+
+    tests.forEach(function (test) {
+
+        // Custom run function (for tests that need direct JS-level control)
+        if (typeof test.run === "function") {
+            try {
+                test.run();
+            } catch (e) {
+                failures.push(test.name);
+                var msg = e.stack || String(e);
+                console.log(colored("FAIL  " + test.name, "red") +
+                            " [run]\n      " + msg + "\n");
+                return;
+            }
+            console.log(colored("PASS  " + test.name, "green") +
+                        "  –  " + test.description);
+            return;
+        }
+
+        var js;
+
+        // 1 – compile RapydScript → JS
+        try {
+            js = test.virtual_files ? compile_virtual(test.src, test.virtual_files) : compile(test.src);
+        } catch (e) {
+            failures.push(test.name);
+            console.log(colored("FAIL  " + test.name, "red") +
+                        " [compile error]\n      " + e + "\n");
+            return;
+        }
+
+        // 2 – verify expected patterns appear in the JS output
+        try {
+            check_js_patterns(test.name, js, test.js_checks);
+            // also check patterns that must NOT appear
+            (test.js_not_checks || []).forEach(function (pat) {
+                var found = (pat instanceof RegExp) ? pat.test(js) : js.indexOf(pat) !== -1;
+                if (found) {
+                    var desc = (pat instanceof RegExp) ? String(pat) : JSON.stringify(pat);
+                    throw new Error("compiled JS unexpectedly contains " + desc + "\n  in test: " + test.name);
+                }
+            });
+        } catch (e) {
+            failures.push(test.name);
+            console.debug("Emitted JS:\n" + js + "\n");
+            console.log(colored("FAIL  " + test.name, "red") +
+                        " [JS pattern mismatch]\n      " + e.message + "\n");
+            return;
+        }
+
+        // 3 – run the JS; assertions embedded in src catch wrong values
+        // (skipped for tests that produce JSX or other non-executable output)
+        if (!test.skip_run) {
+            try {
+                run_js(js);
+            } catch (e) {
+                failures.push(test.name);
+                var msg = e.stack || String(e);
+                console.log(colored("FAIL  " + test.name, "red") +
+                            " [runtime]\n      " + msg + "\n");
+                return;
+            }
         }
 
         console.log(colored("PASS  " + test.name, "green") +