rapydscript-ns 0.8.4 → 0.9.0

package/test/unit/web-repl.js

@@ -798,7 +798,7 @@ var TESTS = [
             var repl = RS.web_repl();
             var js = bundle_compile(repl, [
                 "from react import forwardRef",
-                "def render(props, ref): return props.x",
+                "def render(props, ref): return props['x']",
                 "FancyInput = forwardRef(render)",
                 "assrt.equal(jstype(FancyInput), 'function')",
                 "assrt.equal(FancyInput({'x': 99}), 99)",
@@ -864,6 +864,136 @@ var TESTS = [
         },
     },
 
+    // ── bytes / bytearray ────────────────────────────────────────────────────
+
+    {
+        name: "bundle_bytes_basic",
+        description: "bytes() construction and basic operations work in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "b = bytes([72, 101, 108, 108, 111])",
+                "assrt.equal(len(b), 5)",
+                "assrt.equal(b[0], 72)",
+                "assrt.equal(b[-1], 111)",
+                "assrt.ok(isinstance(b, bytes))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bytes_from_string",
+        description: "bytes(str, encoding) encodes a string to UTF-8 bytes in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "b = bytes('Hello', 'utf-8')",
+                "assrt.equal(len(b), 5)",
+                "assrt.equal(b[0], 72)",
+                "assrt.equal(b.decode('utf-8'), 'Hello')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bytes_hex",
+        description: "bytes.hex() and bytes.fromhex() round-trip in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "b = bytes([0, 15, 255])",
+                "assrt.equal(b.hex(), '000fff')",
+                "b2 = bytes.fromhex('000fff')",
+                "assrt.ok(b == b2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bytes_slice",
+        description: "bytes slice returns bytes in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "b = bytes([10, 20, 30, 40, 50])",
+                "s = b[1:4]",
+                "assrt.ok(isinstance(s, bytes))",
+                "assrt.equal(len(s), 3)",
+                "assrt.equal(s[0], 20)",
+                "assrt.equal(s[2], 40)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bytearray_mutation",
+        description: "bytearray append/extend/pop work in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "ba = bytearray([1, 2, 3])",
+                "assrt.ok(isinstance(ba, bytearray))",
+                "ba.append(4)",
+                "assrt.equal(len(ba), 4)",
+                "assrt.equal(ba[3], 4)",
+                "p = ba.pop()",
+                "assrt.equal(p, 4)",
+                "assrt.equal(len(ba), 3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bytes_repr",
+        description: "repr(bytes(...)) returns b'...' notation in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "b = bytes([72, 101, 108, 108, 111])",
+                "assrt.equal(repr(b), \"b'Hello'\")",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bytes_literal_syntax",
+        description: "b'...' bytes literal compiles and runs correctly in bundled compiler",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "b = b'Hello'",
+                "assrt.ok(isinstance(b, bytes))",
+                "assrt.equal(len(b), 5)",
+                "assrt.equal(b[0], 72)",
+                "assrt.equal(b[4], 111)",
+                "assrt.ok(b == bytes([72, 101, 108, 108, 111]))",
+                "# hex escapes",
+                "b2 = b'\\x48\\x65\\x6c\\x6c\\x6f'",
+                "assrt.ok(b2 == b)",
+                "# empty literal",
+                "e = b''",
+                "assrt.equal(len(e), 0)",
+                "# adjacent literal concatenation",
+                "c = b'foo' b'bar'",
+                "assrt.equal(len(c), 6)",
+                "assrt.ok(c == bytes([102, 111, 111, 98, 97, 114]))",
+                "# uppercase B prefix",
+                "u = B'ABC'",
+                "assrt.ok(isinstance(u, bytes))",
+                "assrt.equal(u[0], 65)",
+                "# repr shows b'...' notation",
+                "assrt.equal(repr(b'Hi'), \"b'Hi'\")",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     {
         name: "bundle___import__-error",
         description: "__import__ raises ModuleNotFoundError for unknown module in web-repl",
@@ -882,6 +1012,679 @@ var TESTS = [
         },
     },
 
+    // ── Enum ─────────────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_enum_basic",
+        description: "Enum subclass .name and .value attributes work in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from enum import Enum",
+                "class Color(Enum):",
+                "    RED   = 1",
+                "    GREEN = 2",
+                "    BLUE  = 3",
+                "assrt.equal(Color.RED.name,   'RED')",
+                "assrt.equal(Color.RED.value,  1)",
+                "assrt.equal(Color.GREEN.name,  'GREEN')",
+                "assrt.equal(Color.GREEN.value, 2)",
+                "assrt.equal(Color.BLUE.name,   'BLUE')",
+                "assrt.equal(Color.BLUE.value,  3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_enum_identity",
+        description: "Enum members are singletons — Color.RED is Color.RED",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from enum import Enum",
+                "class Color(Enum):",
+                "    RED   = 1",
+                "    GREEN = 2",
+                "assrt.ok(Color.RED is Color.RED)",
+                "assrt.ok(Color.RED is not Color.GREEN)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_enum_iteration",
+        description: "list(Color) and for-loop over an Enum class yield all members in order",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from enum import Enum",
+                "class Color(Enum):",
+                "    RED   = 1",
+                "    GREEN = 2",
+                "    BLUE  = 3",
+                "members = list(Color)",
+                "assrt.equal(len(members), 3)",
+                "assrt.equal(members[0].name, 'RED')",
+                "assrt.equal(members[1].name, 'GREEN')",
+                "assrt.equal(members[2].name, 'BLUE')",
+                "names = []",
+                "for m in Color:",
+                "    names.push(m.name)",
+                "assrt.deepEqual(names, ['RED', 'GREEN', 'BLUE'])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_enum_isinstance",
+        description: "isinstance(Color.RED, Color) and isinstance(Color.RED, Enum) both return True",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from enum import Enum",
+                "class Color(Enum):",
+                "    RED = 1",
+                "assrt.ok(isinstance(Color.RED, Color))",
+                "assrt.ok(isinstance(Color.RED, Enum))",
+                "assrt.ok(not isinstance(1, Color))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_enum_repr_str",
+        description: "repr() and str() of an enum member produce the expected strings",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from enum import Enum",
+                "class Color(Enum):",
+                "    RED = 1",
+                "assrt.equal(repr(Color.RED), '<Color.RED: 1>')",
+                "assrt.equal(str(Color.RED),  'Color.RED')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_dataclasses_basic",
+        description: "@dataclass generates __init__, __repr__, __eq__ in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from dataclasses import dataclass, field, is_dataclass",
+                "@dataclass",
+                "class Point:",
+                "    x: int",
+                "    y: int = 0",
+                "p = Point(3, 4)",
+                "assrt.equal(p.x, 3)",
+                "assrt.equal(p.y, 4)",
+                "assrt.ok(p == Point(3, 4))",
+                "assrt.ok(p is not Point(3, 4))",
+                "assrt.equal(repr(p), 'Point(x=3, y=4)')",
+                "assrt.ok(is_dataclass(p))",
+                "assrt.ok(is_dataclass(Point))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_dataclasses_field_factory",
+        description: "field(default_factory=...) gives each instance its own mutable default",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from dataclasses import dataclass, field",
+                "@dataclass",
+                "class Container:",
+                "    items: list = field(default_factory=list)",
+                "a = Container()",
+                "b = Container()",
+                "a.items.push(1)",
+                "assrt.equal(a.items.length, 1)",
+                "assrt.equal(b.items.length, 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_dataclasses_asdict",
+        description: "asdict() recursively converts a dataclass instance to a plain dict",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from dataclasses import dataclass, asdict",
+                "@dataclass",
+                "class Inner:",
+                "    value: int",
+                "@dataclass",
+                "class Outer:",
+                "    inner: object",
+                "    tag: str",
+                "d = asdict(Outer(Inner(42), 'hello'))",
+                "assrt.equal(d['tag'], 'hello')",
+                "assrt.equal(d['inner']['value'], 42)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_dataclasses_frozen",
+        description: "frozen=True makes fields read-only (writable:false, assignment silently ignored outside strict mode)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from dataclasses import dataclass",
+                "@dataclass(frozen=True)",
+                "class FP:",
+                "    x: int",
+                "    y: int",
+                "fp = FP(1, 2)",
+                "assrt.equal(fp.x, 1)",
+                "assrt.equal(fp.y, 2)",
+                "fp.x = 99",
+                // In non-strict mode, writable:false assignment is silently ignored
+                "assrt.equal(fp.x, 1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_format_dunder",
+        description: "__format__ dunder dispatches from format(), str.format(), and f-strings in web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class Money:",
+                "    def __init__(self, amount):",
+                "        self.amount = amount",
+                "    def __str__(self):",
+                "        return str(self.amount)",
+                "    def __format__(self, spec):",
+                "        if spec == 'usd':",
+                "            return '$' + str(self.amount)",
+                "        return format(self.amount, spec)",
+                "m = Money(42)",
+                "assrt.equal(format(m, 'usd'), '$42')",
+                "assrt.equal(str.format('{:usd}', m), '$42')",
+                "assrt.equal(f'{m:usd}', '$42')",
+                "assrt.equal(format(m, '.2f'), '42.00')",
+                "assrt.equal(f'{m:.2f}', '42.00')",
+                // Default __format__ (no custom __format__ defined)
+                "class Plain:",
+                "    def __str__(self):",
+                "        return 'plain'",
+                "p = Plain()",
+                "assrt.equal(format(p), 'plain')",
+                "assrt.equal(str.format('{}', p), 'plain')",
+                "assrt.equal(f'{p}', 'plain')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── object() builtin ──────────────────────────────────────────────────────
+
+    {
+        name: "bundle_object_sentinel",
+        description: "object() returns distinct instances usable as sentinels",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "s1 = object()",
+                "s2 = object()",
+                "assrt.ok(s1 is not s2)",
+                "assrt.ok(isinstance(s1, object))",
+                "assrt.ok(isinstance(s2, object))",
+                "h1 = hash(s1)",
+                "h2 = hash(s2)",
+                "assrt.ok(h1 is not h2)",
+                "assrt.equal(hash(s1), h1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_object_subclass",
+        description: "class Foo(object) works and isinstance checks succeed",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class Node(object):",
+                "    def __init__(self, val):",
+                "        self.val = val",
+                "n = Node(42)",
+                "assrt.ok(isinstance(n, Node))",
+                "assrt.ok(isinstance(n, object))",
+                "assrt.equal(n.val, 42)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── float.is_integer() ───────────────────────────────────────────────────
+
+    {
+        name: "bundle_float_is_integer",
+        description: "float.is_integer() returns True for whole numbers and False for fractions/inf/nan",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "assrt.equal((1.0).is_integer(), True)",
+                "assrt.equal((1.5).is_integer(), False)",
+                "assrt.equal((0.0).is_integer(), True)",
+                "assrt.equal((-2.0).is_integer(), True)",
+                "assrt.equal((-2.5).is_integer(), False)",
+                "assrt.equal((1e10).is_integer(), True)",
+                "assrt.equal(v'Infinity'.is_integer(), False)",
+                "assrt.equal(v'NaN'.is_integer(), False)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── int.bit_length() ─────────────────────────────────────────────────────
+
+    {
+        name: "bundle_int_bit_length",
+        description: "int.bit_length() returns the number of bits needed to represent the integer",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "assrt.equal((0).bit_length(), 0)",
+                "assrt.equal((1).bit_length(), 1)",
+                "assrt.equal((255).bit_length(), 8)",
+                "assrt.equal((256).bit_length(), 9)",
+                "assrt.equal((1023).bit_length(), 10)",
+                "assrt.equal((1024).bit_length(), 11)",
+                "assrt.equal((-1).bit_length(), 1)",
+                "assrt.equal((-5).bit_length(), 3)",
+                "assrt.equal((-255).bit_length(), 8)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── abc module ───────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_abc_basic",
+        description: "ABC + @abstractmethod raises TypeError when abstract class is instantiated",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from abc import ABC, abstractmethod",
+                "class Shape(ABC):",
+                "    @abstractmethod",
+                "    def area(self): pass",
+                "raised = False",
+                "try:",
+                "    Shape()",
+                "except TypeError:",
+                "    raised = True",
+                "assrt.ok(raised)",
+                "assrt.ok('area' in Shape.__abstractmethods__)",
+                "assrt.equal(len(Shape.__abstractmethods__), 1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_abc_concrete",
+        description: "Concrete ABC subclass can be instantiated; isinstance sees the full chain",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from abc import ABC, abstractmethod",
+                "class Shape(ABC):",
+                "    @abstractmethod",
+                "    def area(self): pass",
+                "class Circle(Shape):",
+                "    def __init__(self, r):",
+                "        self.r = r",
+                "    def area(self):",
+                "        return 3.14159 * self.r * self.r",
+                "c = Circle(5)",
+                "assrt.ok(isinstance(c, Circle))",
+                "assrt.ok(isinstance(c, Shape))",
+                "assrt.ok(isinstance(c, ABC))",
+                "assrt.equal(c.r, 5)",
+                "assrt.ok(abs(c.area() - 78.53975) < 0.001)",
+                "assrt.equal(len(Circle.__abstractmethods__), 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_abc_register",
+        description: "ABC.register() makes isinstance return True for virtual subclasses",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from abc import ABC, abstractmethod",
+                "class MyABC(ABC):",
+                "    @abstractmethod",
+                "    def do_it(self): pass",
+                "class External:",
+                "    def do_it(self): return 42",
+                "MyABC.register(External)",
+                "assrt.ok(isinstance(External(), MyABC))",
+                "class Unrelated:",
+                "    def do_it(self): return 99",
+                "assrt.ok(not isinstance(Unrelated(), MyABC))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_abc_protocol",
+        description: "@runtime_checkable Protocol enables structural isinstance() checks",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from abc import Protocol, runtime_checkable",
+                "@runtime_checkable",
+                "class Drawable(Protocol):",
+                "    def draw(self): pass",
+                "class Canvas:",
+                "    def draw(self):",
+                "        return 'painting'",
+                "class NotDrawable:",
+                "    def paint(self): pass",
+                "assrt.ok(isinstance(Canvas(), Drawable))",
+                "assrt.ok(not isinstance(NotDrawable(), Drawable))",
+                "assrt.ok(not isinstance(42, Drawable))",
+                "assrt.ok('draw' in Drawable.__protocol_attrs__)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── eval / exec ───────────────────────────────────────────────────────
+
+    {
+        name: "bundle_zip_strict",
+        description: "zip(strict=True) raises ValueError on length mismatch in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                // equal-length: no error
+                "assrt.deepEqual(list(zip([1,2], [3,4], strict=True)), [[1,3],[2,4]])",
+                // zero iterables with strict: empty result, no error
+                "assrt.deepEqual(list(zip(strict=True)), [])",
+                // first longer than second
+                "err1 = False",
+                "try:",
+                "    list(zip([1,2], [3], strict=True))",
+                "except ValueError:",
+                "    err1 = True",
+                "assrt.ok(err1)",
+                // second longer than first
+                "err2 = False",
+                "try:",
+                "    list(zip([1], [3,4], strict=True))",
+                "except ValueError:",
+                "    err2 = True",
+                "assrt.ok(err2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_eval_exec",
+        description: "eval and exec builtins work in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                // eval — basic expression
+                "assrt.equal(eval('1 + 2'), 3)",
+                "assrt.equal(eval('10 * 5'), 50)",
+                "assrt.equal(eval('True'), True)",
+                // eval with globals dict
+                "assrt.equal(eval('x + y', {'x': 10, 'y': 5}), 15)",
+                "assrt.equal(eval('a * b', {'a': 3, 'b': 4}), 12)",
+                // eval with locals overriding globals
+                "assrt.equal(eval('x', {'x': 1}, {'x': 99}), 99)",
+                // exec returns None (null in JS)
+                "assrt.equal(exec('1 + 2'), None)",
+                // exec side-effects via mutable object in globals
+                "log = []",
+                "exec(\"log.push('hello')\", {'log': log})",
+                "assrt.equal(log[0], 'hello')",
+                "exec('log.push(1 + 2)', {'log': log})",
+                "assrt.equal(log[1], 3)",
+                // exec with function in globals
+                "out = []",
+                "def _add(a, b): out.push(a + b);",
+                "exec('fn(10, 7)', {'fn': _add, 'out': out})",
+                "assrt.equal(out[0], 17)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── complex numbers ───────────────────────────────────────────────────────
+
+    {
+        name: "bundle_complex_constructor",
+        description: "complex() constructor and .real/.imag attributes work in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "c = complex(3, 4)",
+                "assrt.equal(c.real, 3)",
+                "assrt.equal(c.imag, 4)",
+                "c0 = complex()",
+                "assrt.equal(c0.real, 0)",
+                "assrt.equal(c0.imag, 0)",
+                "c1 = complex(5)",
+                "assrt.equal(c1.real, 5)",
+                "assrt.equal(c1.imag, 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_complex_j_literal",
+        description: "j-suffix imaginary literal compiles and runs correctly in bundled compiler",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "c = 4j",
+                "assrt.equal(c.real, 0)",
+                "assrt.equal(c.imag, 4)",
+                "c2 = 3+4j",
+                "assrt.equal(c2.real, 3)",
+                "assrt.equal(c2.imag, 4)",
+                "assrt.ok(isinstance(c, complex))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_complex_arithmetic",
+        description: "complex arithmetic (+, -, *, /) and abs() work in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "a = complex(1, 2)",
+                "b = complex(3, 4)",
+                "assrt.ok(a + b == complex(4, 6))",
+                "assrt.ok(b - a == complex(2, 2))",
+                "assrt.ok(a * b == complex(-5, 10))",
+                "assrt.ok(b / complex(1, 0) == b)",
+                "assrt.equal(abs(complex(3, 4)), 5)",
+                "assrt.ok(-complex(3, 4) == complex(-3, -4))",
+                "assrt.ok(complex(3, 4).conjugate() == complex(3, -4))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_complex_repr",
+        description: "repr() and str() of complex produce Python-style notation in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "assrt.equal(repr(complex(0, 0)), '0j')",
+                "assrt.equal(repr(complex(1, 0)), '(1+0j)')",
+                "assrt.equal(repr(complex(0, 1)), '1j')",
+                "assrt.equal(repr(complex(3, 4)), '(3+4j)')",
+                "assrt.equal(repr(complex(3, -4)), '(3-4j)')",
+                "assrt.equal(str(complex(3, 4)), '(3+4j)')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_vars_locals_globals",
+        description: "vars(), locals(), globals() work in bundled baselib",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import overload_getitem",
+                "class Point:",
+                "    def __init__(self, x, y):",
+                "        self.x = x",
+                "        self.y = y",
+                "p = Point(7, 9)",
+                "d = vars(p)",
+                "assrt.equal(d['x'], 7)",
+                "assrt.equal(d['y'], 9)",
+                // snapshot — mutation does not affect original
+                "d['x'] = 0",
+                "assrt.equal(p.x, 7)",
+                // vars() with no arg returns empty dict
+                "v = vars()",
+                "assrt.ok(v is not None)",
+                "assrt.ok(isinstance(v, dict))",
+                // locals() returns empty dict
+                "loc = locals()",
+                "assrt.ok(isinstance(loc, dict))",
+                // globals() returns dict
+                "g = globals()",
+                "assrt.ok(isinstance(g, dict))",
+                // vars(obj) returns dict instance
+                "assrt.ok(isinstance(vars(Point(1, 2)), dict))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // -------------------------------------------------------------------------
+    // Context-persistence tests: compile WITHOUT keep_baselib, run in the repl
+    // vm context.  These catch "ReferenceError: ρσ_X is not defined" bugs that
+    // only surface when baselib symbols are `let`-declared (not `var` / function
+    // declarations) and therefore don't persist between vm.runInContext calls.
+    // -------------------------------------------------------------------------
+
+    {
+        name: "repl_in_operator_persistence",
+        description: "ρσ_in accessible after baselib init — 'in' operator regression in web-repl context",
+        run: function () {
+            var repl = RS.web_repl();
+            // Compile WITHOUT keep_baselib so the output does not include the
+            // baselib — the compiled code references ρσ_in from the persistent ctx.
+            var js = repl.compile([
+                "assert 'x' in ['x', 'y', 'z'], \"'x' in list should be True\"",
+                "assert 'a' not in ['x', 'y', 'z'], \"'a' not in list should be True\"",
+                "assert 2 in {1: 'one', 2: 'two'}, '2 in dict should be True'",
+                // Original failing case: 'Math' in globals() must not throw
+                "g = globals()",
+                "result = 'Math' in g",  // just must not throw ReferenceError
+            ].join("\n"), {export_main: true, tree_shake: false});
+            repl.runjs(js);
+        },
+    },
+
+    {
+        name: "repl_kwargs_persistence",
+        description: "ρσ_desugar_kwargs accessible after baselib init — **kwargs in web-repl context",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = repl.compile([
+                "def greet(name, greeting='Hello'):",
+                "    return greeting + ', ' + name + '!'",
+                "result = greet('World', greeting='Hi')",
+                "assert result == 'Hi, World!', 'kwargs call should produce Hi, World!'",
+            ].join("\n"), {export_main: true, tree_shake: false});
+            repl.runjs(js);
+        },
+    },
+
+    {
+        name: "repl_nameerror_persistence",
+        description: "NameError accessible after baselib init — except NameError in web-repl context",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = repl.compile([
+                "caught = False",
+                "try:",
+                "    raise NameError('test error')",
+                "except NameError:",
+                "    caught = True",
+                "assert caught, 'NameError should be catchable in except clause'",
+            ].join("\n"), {export_main: true, tree_shake: false});
+            repl.runjs(js);
+        },
+    },
+
+    {
+        name: "repl_getattr_persistence",
+        description: "ρσ_JS_Proxy/ρσ_attr_proxy_handler accessible after baselib init — __getattr__ in web-repl context",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = repl.compile([
+                "class Magic:",
+                "    def __getattr__(self, name):",
+                "        return name + '_value'",
+                "m = Magic()",
+                "assert m.foo == 'foo_value', '__getattr__ should return foo_value'",
+                "assert m.bar == 'bar_value', '__getattr__ should return bar_value'",
+            ].join("\n"), {export_main: true, tree_shake: false});
+            repl.runjs(js);
+        },
+    },
+
+    {
+        name: "repl_exists_persistence",
+        description: "ρσ_exists accessible after baselib init — existential operator on non-SymbolRef in web-repl context",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = repl.compile([
+                // fns['key'] is a subscript (not SymbolRef) — emits ρσ_exists.c(fns['key'])()
+                "def get_val(): return 42",
+                "fns = {'key': get_val}",
+                "result = fns['key']?()",
+                "assert result == 42, 'existential call via subscript should return 42'",
+                // None value: dict lookup miss returns None, existential function call returns undefined
+                "missing = fns.get('nokey')",
+                "result2 = missing?()",
+                "assert result2 is undefined, 'existential call on None should return undefined'",
+            ].join("\n"), {export_main: true, tree_shake: false});
+            repl.runjs(js);
+        },
+    },
+
 ];
 
 // ---------------------------------------------------------------------------