rapydscript-ns 0.8.3 → 0.9.0

package/test/unit/web-repl.js

@@ -119,6 +119,70 @@ function run_js(js) {
     });
 }
 
+// Minimal React stub — mirrors the one in web-repl/env.js so that compiled
+// code that imports from the react library can run in a plain Node vm context.
+var REACT_STUB = (function () {
+    var Fragment = Symbol("React.Fragment");
+    function createElement(type, props) {
+        var children = Array.prototype.slice.call(arguments, 2);
+        return { type: type, props: Object.assign({ children: children.length === 1 ? children[0] : children }, props) };
+    }
+    function useState(initial) {
+        var s = typeof initial === "function" ? initial() : initial;
+        return [s, function (v) { s = typeof v === "function" ? v(s) : v; }];
+    }
+    function useEffect(fn)    { fn(); }
+    function useLayoutEffect(fn) { fn(); }
+    function useMemo(fn)      { return fn(); }
+    function useCallback(fn)  { return fn; }
+    function useRef(initial)  { return { current: initial }; }
+    function useContext(ctx)  { return ctx && ctx._currentValue !== undefined ? ctx._currentValue : undefined; }
+    function useReducer(reducer, initial) { return [initial, function (a) {}]; }
+    function useImperativeHandle(ref, create) { if (ref) ref.current = create(); }
+    function useDebugValue() {}
+    function useId() { return ":r" + (Math.random() * 1e9 | 0) + ":"; }
+    function useTransition() { return [false, function (fn) { fn(); }]; }
+    function useDeferredValue(v) { return v; }
+    function useSyncExternalStore(sub, get) { return get(); }
+    function useInsertionEffect(fn) { fn(); }
+    function createContext(def) { return { _currentValue: def }; }
+    function createRef() { return { current: null }; }
+    function forwardRef(render) { return function (props) { return render(props, null); }; }
+    function memo(C)  { return C; }
+    function lazy(f)  { return f; }
+    function cloneElement(el, props) { return Object.assign({}, el, { props: Object.assign({}, el.props, props) }); }
+    function isValidElement(o) { return o !== null && typeof o === "object" && o.type !== undefined; }
+    function Component() {}
+    Component.prototype.setState = function (u) { this.state = Object.assign({}, this.state, typeof u === "function" ? u(this.state) : u); };
+    function PureComponent() {}
+    PureComponent.prototype = Object.create(Component.prototype);
+    PureComponent.prototype.constructor = PureComponent;
+    return {
+        Fragment: Fragment, createElement: createElement,
+        useState: useState, useEffect: useEffect, useLayoutEffect: useLayoutEffect,
+        useMemo: useMemo, useCallback: useCallback, useRef: useRef,
+        useContext: useContext, useReducer: useReducer,
+        useImperativeHandle: useImperativeHandle, useDebugValue: useDebugValue,
+        useId: useId, useTransition: useTransition, useDeferredValue: useDeferredValue,
+        useSyncExternalStore: useSyncExternalStore, useInsertionEffect: useInsertionEffect,
+        createContext: createContext, createRef: createRef, forwardRef: forwardRef,
+        memo: memo, lazy: lazy, cloneElement: cloneElement, isValidElement: isValidElement,
+        Component: Component, PureComponent: PureComponent,
+        StrictMode: {}, Suspense: {}, Profiler: {},
+    };
+})();
+
+// Run compiled JS in a vm context that also has a React stub available.
+function run_js_with_react(js) {
+    return vm.runInNewContext(js, {
+        __name__          : "<test>",
+        console           : console,
+        assrt             : assert,
+        ρσ_last_exception : undefined,
+        React             : REACT_STUB,
+    });
+}
+
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
@@ -555,6 +619,41 @@ var TESTS = [
         },
     },
 
+    {
+        name: "bundle_tuple_annotation_variable",
+        description: "variable type annotation with tuple does not become a function call",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "# globals: assrt",
+                "range_limits: tuple = (0, 100)",
+                "assrt.equal(range_limits[0], 0)",
+                "assrt.equal(range_limits[1], 100)",
+            ].join("\n"));
+            // Ensure it compiled to an assignment, not a call
+            if (/range_limits\s*\(/.test(js)) throw new Error("range_limits was compiled as a function call:\n" + js);
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_tuple_annotation_function_arg",
+        description: "function argument type annotation with tuple and int works at runtime",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "# globals: assrt",
+                "def clamp(val: int, bounds: tuple) -> int:",
+                "    lo, hi = bounds",
+                "    return max(lo, min(hi, val))",
+                "range_limits: tuple = (0, 100)",
+                "assrt.equal(clamp(150, range_limits), 100)",
+                "assrt.equal(clamp(-5,  range_limits), 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     {
         name: "bundle_list_concatenation",
         description: "list + list returns a concatenated list in the bundled baselib",
@@ -579,6 +678,1013 @@ var TESTS = [
         },
     },
 
+    // ── React stub tests ─────────────────────────────────────────────────────
+    // These tests require a React mock in the vm context because the compiled
+    // react.pyj module initialises with `React.*` references at load time.
+
+    {
+        name: "bundle_react_stub_memo",
+        description: "web-repl React stub: memo() returns its argument (identity wrapper)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import memo",
+                "def MyComp(props): return props.x",
+                "Memoised = memo(MyComp)",
+                "assrt.equal(Memoised, MyComp)",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_usestate",
+        description: "web-repl React stub: useState returns [initialValue, setter]",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useState",
+                "state, setState = useState(42)",
+                "assrt.equal(state, 42)",
+                "assrt.equal(jstype(setState), 'function')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_useeffect",
+        description: "web-repl React stub: useEffect calls its callback immediately",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useEffect",
+                "ran = [False]",
+                "def effect(): ran[0] = True",
+                "useEffect(effect, [])",
+                "assrt.ok(ran[0])",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_usememo",
+        description: "web-repl React stub: useMemo returns the computed value",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useMemo",
+                "result = useMemo(def(): return 6 * 7;, [])",
+                "assrt.equal(result, 42)",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_useref",
+        description: "web-repl React stub: useRef returns {current: initialValue}",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useRef",
+                "ref = useRef(None)",
+                "assrt.equal(ref.current, None)",
+                "ref.current = 'hello'",
+                "assrt.equal(ref.current, 'hello')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_usereducer",
+        description: "web-repl React stub: useReducer returns [initialState, dispatch]",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import useReducer",
+                "def reducer(state, action):",
+                "    if action == 'inc': return state + 1",
+                "    return state",
+                "state, dispatch = useReducer(reducer, 0)",
+                "assrt.equal(state, 0)",
+                "assrt.equal(jstype(dispatch), 'function')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_createcontext",
+        description: "web-repl React stub: createContext returns a context with default value",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import createContext, useContext",
+                "ThemeCtx = createContext('dark')",
+                "theme = useContext(ThemeCtx)",
+                "assrt.equal(theme, 'dark')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_forwardref",
+        description: "web-repl React stub: forwardRef wraps the render function",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from react import forwardRef",
+                "def render(props, ref): return props['x']",
+                "FancyInput = forwardRef(render)",
+                "assrt.equal(jstype(FancyInput), 'function')",
+                "assrt.equal(FancyInput({'x': 99}), 99)",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    {
+        name: "bundle_react_stub_jsx_and_memo",
+        description: "web-repl React stub: JSX component wrapped with memo compiles and runs",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import jsx",
+                "from react import useState, memo",
+                "def Counter(props):",
+                "    count, setCount = useState(props.initial or 0)",
+                "    return <span>{count}</span>",
+                "MemoCounter = memo(Counter)",
+                "assrt.equal(jstype(MemoCounter), 'function')",
+                "el = MemoCounter({'initial': 7})",
+                "assrt.equal(el.type, 'span')",
+            ].join("\n"));
+            run_js_with_react(js);
+        },
+    },
+
+    // ── __import__() ─────────────────────────────────────────────────────
+
+    {
+        name: "bundle___import__-basic",
+        description: "__import__(name) returns a stdlib module reference in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import Counter",
+                "m = __import__('collections')",
+                // m.Counter should be the same object as the statically-imported Counter
+                "assrt.ok(m.Counter is Counter)",
+                "c = m.Counter('aabb')",
+                "top = c.most_common(1)",
+                "assrt.equal(top[0][0], 'a')",
+                "assrt.equal(top[0][1], 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle___import__-fromlist",
+        description: "__import__ with fromlist returns the exact named module",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import deque",
+                "m = __import__('collections', None, None, ['deque'])",
+                "d = m.deque([1, 2, 3])",
+                "assrt.equal(len(d), 3)",
+                "assrt.equal(d.popleft(), 1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── 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",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import Counter",
+                "caught = False",
+                "try:",
+                "    __import__('no_such_module')",
+                "except ModuleNotFoundError as e:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── 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);
+        },
+    },
+
 ];
 
 // ---------------------------------------------------------------------------