rapydscript-ns 0.9.2 → 0.9.4

package/test/unit/web-repl.js

@@ -103,7 +103,6 @@ assert.deepEqual = function (a, b, message) {
 // Compile RapydScript using the web-repl's own compile() path (same as browser)
 function bundle_compile(repl, src) {
     return repl.compile(src, {
-        omit_function_metadata: false,
         tree_shake: false,
         keep_baselib: true,
     });
@@ -271,6 +270,95 @@ var TESTS = [
         },
     },
 
+    {
+        name: "bundle_chainmap_basic",
+        description: "ChainMap construction and first-map-wins lookup work in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "defaults = {'color': 'red', 'user': 'guest'}",
+                "overrides = {'user': 'admin'}",
+                "cm = ChainMap(overrides, defaults)",
+                "assrt.equal(cm['user'], 'admin')",
+                "assrt.equal(cm['color'], 'red')",
+                "assrt.equal(len(cm), 2)",
+                "assrt.ok('color' in cm)",
+                "assrt.ok('missing' not in cm)",
+                "assrt.equal(cm.get('missing', 'fallback'), 'fallback')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_chainmap_writes",
+        description: "ChainMap writes, deletes and updates affect only the first map in the bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "defaults = {'depth': 1}",
+                "cm = ChainMap({}, defaults)",
+                "cm['depth'] = 99",
+                "assrt.equal(cm['depth'], 99)",
+                "assrt.equal(defaults['depth'], 1)",
+                "del cm['depth']",
+                "assrt.equal(cm['depth'], 1)",
+                "cm.update({'a': 1}, b=2)",
+                "assrt.equal(cm['a'], 1)",
+                "assrt.equal(cm['b'], 2)",
+                "assrt.equal(cm.pop('a'), 1)",
+                "assrt.equal(cm.pop('depth', 'dflt'), 'dflt')",
+                "assrt.equal(cm.setdefault('new', 7), 7)",
+                "assrt.equal(cm['new'], 7)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_chainmap_new_child",
+        description: "ChainMap new_child and parents work in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "base = ChainMap({'x': 1})",
+                "child = base.new_child({'x': 2, 'y': 3})",
+                "assrt.equal(child['x'], 2)",
+                "assrt.equal(child['y'], 3)",
+                "assrt.equal(base['x'], 1)",
+                "assrt.equal(child.maps.length, 2)",
+                "parents = child.parents",
+                "assrt.equal(parents['x'], 1)",
+                "assrt.equal(parents.maps.length, 1)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_chainmap_iteration",
+        description: "ChainMap keys/values/items, iteration order and copy work in the bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from collections import ChainMap",
+                "cm = ChainMap({'a': 1, 'b': 2}, {'c': 3})",
+                "assrt.deepEqual(list(cm), ['c', 'a', 'b'])",
+                "assrt.deepEqual(cm.keys(), ['c', 'a', 'b'])",
+                "assrt.deepEqual(cm.values(), [3, 1, 2])",
+                "dup = cm.copy()",
+                "dup['a'] = 100",
+                "assrt.equal(cm['a'], 1)",
+                "assrt.equal(dup['a'], 100)",
+                "assrt.equal(dup['c'], 3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     {
         name: "bundle_operator_overloading",
         description: "overload_operators flag works in the web-repl bundle",
@@ -1233,6 +1321,71 @@ var TESTS = [
         },
     },
 
+    // ── f-string {x=} debugging format ───────────────────────────────────────
+
+    {
+        name: "bundle_fstring_debug_simple",
+        description: "f'{x=}' produces 'x=<value>' for simple variable",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "x = 42",
+                "name = 'Alice'",
+                "flag = True",
+                "assrt.equal(f'{x=}', 'x=42')",
+                "assrt.equal(f'{name=}', \"name=Alice\")",
+                "assrt.equal(f'{flag=}', 'flag=true')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_fstring_debug_expr",
+        description: "f'{expr=}' preserves the full expression text as prefix",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "x = 5",
+                "nums = [10, 20, 30]",
+                "assrt.equal(f'{x*2=}', 'x*2=10')",
+                "assrt.equal(f'{nums[1]=}', 'nums[1]=20')",
+                "assrt.equal(f'{x=} and {x*2=}', 'x=5 and x*2=10')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_fstring_debug_format_spec",
+        description: "f'{x=:.2f}' combines debugging prefix with format spec",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "pi = 3.14159",
+                "n = 1234567",
+                "assrt.equal(f'{pi=:.2f}', 'pi=3.14')",
+                "assrt.equal(f'{n=:,}', 'n=' + (1234567).toLocaleString())",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_fstring_debug_repr",
+        description: "f'{x=!r}' combines debugging prefix with !r repr conversion",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "msg = 'hello'",
+                "nums = [1, 2, 3]",
+                "assrt.equal(f'{msg=!r}', 'msg=\"hello\"')",
+                "assrt.equal(f'{nums=!r}', 'nums=[1, 2, 3]')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     // ── object() builtin ──────────────────────────────────────────────────────
 
     {
@@ -2198,6 +2351,522 @@ var TESTS = [
         },
     },
 
+    // ── float() special string values ────────────────────────────────────────
+
+    {
+        name: "bundle_float_special_inf_nan",
+        description: "float() accepts 'inf', '-inf', 'infinity', 'nan' (and variants) in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                // positive infinity
+                "assrt.equal(float('inf'),       Infinity)",
+                "assrt.equal(float('+inf'),      Infinity)",
+                "assrt.equal(float('INF'),       Infinity)",
+                "assrt.equal(float('infinity'),  Infinity)",
+                "assrt.equal(float('+infinity'), Infinity)",
+                "assrt.equal(float('Infinity'),  Infinity)",
+                "assrt.equal(float('INFINITY'),  Infinity)",
+                // negative infinity
+                "assrt.equal(float('-inf'),      -Infinity)",
+                "assrt.equal(float('-infinity'), -Infinity)",
+                "assrt.equal(float('-Infinity'), -Infinity)",
+                // nan
+                "assrt.ok(isNaN(float('nan')))",
+                "assrt.ok(isNaN(float('NaN')))",
+                "assrt.ok(isNaN(float('NAN')))",
+                "assrt.ok(isNaN(float('+nan')))",
+                "assrt.ok(isNaN(float('-nan')))",
+                // whitespace stripped
+                "assrt.equal(float('  inf  '),  Infinity)",
+                "assrt.equal(float('  -inf '),  -Infinity)",
+                "assrt.ok(isNaN(float('  nan  ')))",
+                // numeric strings still work
+                "assrt.equal(float('3.14'), 3.14)",
+                "assrt.equal(float('-2.5'), -2.5)",
+                // real Infinity passes through
+                "assrt.equal(float(Infinity),  Infinity)",
+                "assrt.equal(float(-Infinity), -Infinity)",
+                // ValueError still raised for bad strings
+                "_err = False",
+                "try:",
+                "    float('bad')",
+                "except ValueError:",
+                "    _err = True",
+                "assrt.ok(_err)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── base64 stdlib ────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_base64_encode_decode",
+        description: "base64 stdlib: b64encode/b64decode round-trips in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from base64 import b64encode, b64decode",
+                // basic encode
+                "enc = b64encode(bytes([77, 97, 110]))",
+                "assrt.equal(enc.decode('ascii'), 'TWFu')",
+                // empty
+                "assrt.equal(len(b64encode(bytes([]))), 0)",
+                // padding variants
+                "assrt.equal(b64encode(bytes([0])).decode('ascii'), 'AA==')",
+                "assrt.equal(b64encode(bytes([0, 0])).decode('ascii'), 'AAA=')",
+                "assrt.equal(b64encode(bytes([0, 0, 0])).decode('ascii'), 'AAAA')",
+                // decode round-trip
+                "msg = bytes([104, 101, 108, 108, 111])",  // hello
+                "assrt.deepEqual(list(b64decode(b64encode(msg))), list(msg))",
+                // decode accepts string input
+                "d = b64decode('TWFu')",
+                "assrt.equal(d[0], 77)",
+                "assrt.equal(d[1], 97)",
+                "assrt.equal(d[2], 110)",
+                // decode strips whitespace
+                "assrt.deepEqual(list(b64decode('aGVs bG8=')), list(msg))",
+                // missing padding accepted
+                "assrt.deepEqual(list(b64decode('aGVsbG8')), list(msg))",
+                // isinstance check
+                "assrt.ok(isinstance(b64encode(bytes([1,2,3])), bytes))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_base64_urlsafe",
+        description: "base64 stdlib: URL-safe encoding and altchars in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from base64 import urlsafe_b64encode, urlsafe_b64decode, b64encode, b64decode",
+                // URL-safe produces no + or /
+                "enc = urlsafe_b64encode(bytes([251, 239, 190]))",
+                "s = enc.decode('ascii')",
+                "assrt.ok(s.indexOf('+') < 0, 'no + in URL-safe')",
+                "assrt.ok(s.indexOf('/') < 0, 'no / in URL-safe')",
+                // -_7- decodes to [251, 254, 254]
+                "dec = urlsafe_b64decode('-_7-')",
+                "assrt.equal(dec[0], 251)",
+                "assrt.equal(dec[1], 254)",
+                "assrt.equal(dec[2], 254)",
+                // round-trip
+                "data = bytes([0, 127, 128, 255])",
+                "assrt.deepEqual(list(urlsafe_b64decode(urlsafe_b64encode(data))), list(data))",
+                // altchars
+                "enc_alt = b64encode(bytes([251, 254, 254]), altchars=bytes([45, 95]))",
+                "assrt.equal(enc_alt.decode('ascii'), '-_7-')",
+                "dec_alt = b64decode('-_7-', altchars=bytes([45, 95]))",
+                "assrt.deepEqual(list(dec_alt), [251, 254, 254])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_base64_b32_b16",
+        description: "base64 stdlib: b32encode/b32decode and b16encode/b16decode in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from base64 import b32encode, b32decode, b16encode, b16decode",
+                // b32 round-trips
+                "b32_msg = bytes([102, 111, 111])",  // 'foo'
+                "b32_enc = b32encode(b32_msg)",
+                "assrt.equal(b32_enc.decode('ascii'), 'MZXW6===')",
+                "assrt.deepEqual(list(b32decode(b32_enc)), list(b32_msg))",
+                // casefold
+                "assrt.deepEqual(list(b32decode('mzxw6===', casefold=True)), list(b32_msg))",
+                // b16 (hex) encoding
+                "b16_msg = bytes([0, 1, 254, 255])",
+                "b16_enc = b16encode(b16_msg)",
+                "assrt.equal(b16_enc.decode('ascii'), '0001FEFF')",
+                "assrt.deepEqual(list(b16decode(b16_enc)), list(b16_msg))",
+                // b16 casefold
+                "assrt.deepEqual(list(b16decode('0001feff', casefold=True)), list(b16_msg))",
+                // b16 Error on bad input
+                "b16_err = False",
+                "try:",
+                "    b16decode('ZZ')",
+                "except ValueError:",
+                "    b16_err = True",
+                "assrt.ok(b16_err, 'b16decode of non-hex raises ValueError')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_base64_encodebytes",
+        description: "base64 stdlib: encodebytes/decodebytes and validate= flag in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from base64 import encodebytes, decodebytes, b64decode",
+                // Note: catch ValueError (base64.Error subclasses ValueError).
+                // Importing 'Error' from base64 in the web-repl context would
+                // shadow the native JS Error constructor, causing issues.
+                // encodebytes wraps at 76 chars per line
+                "data = bytes(list(range(57)))",
+                "enc = encodebytes(data)",
+                "s = enc.decode('ascii')",
+                "assrt.equal(s.charCodeAt(s.length - 1), 10, 'encodebytes ends with newline')",
+                // decodebytes round-trip
+                "assrt.deepEqual(list(decodebytes(enc)), list(data))",
+                // validate=True raises on bad input (caught as ValueError)
+                "b64_err = False",
+                "try:",
+                "    b64decode('aGVs!G8=', validate=True)",
+                "except ValueError:",
+                "    b64_err = True",
+                "assrt.ok(b64_err, 'validate=True should raise ValueError on non-base64 char')",
+                // validate=True passes on good input
+                "good = b64decode('aGVsbG8=', validate=True)",
+                "assrt.equal(good[0], 104)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_multiline_paren_import",
+        description: "multi-line parenthesized import with trailing comma works in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from math import (",
+                "    floor,",
+                "    ceil,",
+                "    sqrt,",
+                ")",
+                "assrt.equal(floor(3.9), 3)",
+                "assrt.equal(ceil(3.1), 4)",
+                "assrt.equal(sqrt(9), 3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_multiline_paren_import_alias",
+        description: "multi-line parenthesized import with aliases and trailing comma works in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from math import (",
+                "    floor as fl,",
+                "    ceil as cl,",
+                ")",
+                "assrt.equal(fl(2.9), 2)",
+                "assrt.equal(cl(2.1), 3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── string stdlib ────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_string_constants",
+        description: "string stdlib: character constants in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from string import (",
+                "    ascii_lowercase, ascii_uppercase, ascii_letters,",
+                "    digits, hexdigits, octdigits,",
+                "    punctuation, whitespace, printable,",
+                ")",
+                // lengths
+                "assrt.equal(len(ascii_lowercase), 26)",
+                "assrt.equal(len(ascii_uppercase), 26)",
+                "assrt.equal(len(ascii_letters),   52)",
+                "assrt.equal(len(digits),    10)",
+                "assrt.equal(len(hexdigits), 22)",
+                "assrt.equal(len(octdigits),  8)",
+                "assrt.equal(len(punctuation), 32)",
+                "assrt.equal(len(whitespace),   6)",
+                "assrt.equal(len(printable), len(digits) + len(ascii_letters) + len(punctuation) + len(whitespace))",
+                // spot-checks
+                "assrt.equal(ascii_letters, ascii_lowercase + ascii_uppercase)",
+                "assrt.ok(digits.indexOf('5') >= 0)",
+                "assrt.ok(hexdigits.indexOf('f') >= 0)",
+                "assrt.ok(punctuation.indexOf('!') >= 0)",
+                "assrt.ok(whitespace.indexOf(' ') >= 0)",
+                "assrt.ok(printable.indexOf('A') >= 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_string_template",
+        description: "string stdlib: Template class in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from string import Template",
+                // basic substitution
+                "t1 = Template('Hello $name!')",
+                "assrt.equal(t1.substitute({'name': 'World'}), 'Hello World!')",
+                // $$ → $
+                "assrt.equal(Template('Price: $$5').substitute({}), 'Price: $5')",
+                // brace form
+                "assrt.equal(Template('${x}bar').substitute({'x': 'foo'}), 'foobar')",
+                // multiple fields
+                "assrt.equal(Template('$a and $b').substitute({'a': '1', 'b': '2'}), '1 and 2')",
+                // numeric value
+                "assrt.equal(Template('n=$n').substitute({'n': 42}), 'n=42')",
+                // safe_substitute leaves missing intact
+                "assrt.equal(Template('$x $y').safe_substitute({'x': 'hi'}), 'hi $y')",
+                // safe_substitute with all keys
+                "assrt.equal(Template('$a').safe_substitute({'a': 'z'}), 'z')",
+                // substitute raises KeyError for missing key
+                "_t_err = False",
+                "try:",
+                "    Template('Hello $missing').substitute({})",
+                "except KeyError:",
+                "    _t_err = True",
+                "assrt.ok(_t_err)",
+                // template attribute
+                "assrt.equal(Template('hello $x').template, 'hello $x')",
+                // class attribute
+                "assrt.equal(Template.delimiter, '$')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_string_formatter",
+        description: "string stdlib: Formatter class in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from string import Formatter",
+                "f = Formatter()",
+                // positional args
+                "assrt.equal(f.format('Hello {}!', 'World'), 'Hello World!')",
+                "assrt.equal(f.format('{0} {1}', 'a', 'b'), 'a b')",
+                "assrt.equal(f.format('{1} {0}', 'a', 'b'), 'b a')",
+                "assrt.equal(f.format('no fields'), 'no fields')",
+                // format specs
+                "assrt.equal(f.format('{:.2f}', 3.14159), '3.14')",
+                "assrt.equal(f.format('{:d}', 42), '42')",
+                "assrt.equal(f.format('{:x}', 255), 'ff')",
+                // {{ }} escaping
+                "assrt.equal(f.format('{{ }}'), '{ }')",
+                // vformat with named kwargs
+                "assrt.equal(f.vformat('{name}', [], {'name': 'Alice'}), 'Alice')",
+                "assrt.equal(f.vformat('{0} {name}', ['hi'], {'name': 'Bob'}), 'hi Bob')",
+                // convert_field
+                "assrt.equal(f.convert_field(42, 's'), '42')",
+                "assrt.equal(f.convert_field('x', None), 'x')",
+                // format_field
+                "assrt.equal(f.format_field(3.14159, '.2f'), '3.14')",
+                "assrt.equal(f.format_field('hi', ''), 'hi')",
+                // get_value
+                "assrt.equal(f.get_value(0, ['a', 'b'], {}), 'a')",
+                "assrt.equal(f.get_value('x', [], {'x': 99}), 99)",
+                // parse
+                "_p = f.parse('lit {0:.2f} end')",
+                "assrt.equal(_p[0][0], 'lit ')",
+                "assrt.equal(_p[0][1], '0')",
+                "assrt.equal(_p[0][2], '.2f')",
+                "assrt.equal(_p[1][0], ' end')",
+                "assrt.equal(_p[1][1], None)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_html_escape_unescape",
+        description: "html stdlib: escape and unescape functions in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from html import escape, unescape",
+                // escape basics
+                "assrt.equal(escape('<'), '&lt;')",
+                "assrt.equal(escape('>'), '&gt;')",
+                "assrt.equal(escape('&'), '&amp;')",
+                "assrt.equal(escape('\"'), '&quot;')",
+                "assrt.equal(escape(\"'\"), '&#x27;')",
+                // quote=False
+                "assrt.equal(escape('A & B', quote=False), 'A &amp; B')",
+                "assrt.equal(escape('\"hi\"', quote=False), '\"hi\"')",
+                // unescape named entities
+                "assrt.equal(unescape('&amp;'), '&')",
+                "assrt.equal(unescape('&lt;'), '<')",
+                "assrt.equal(unescape('&gt;'), '>')",
+                "assrt.equal(unescape('&quot;'), '\"')",
+                "assrt.equal(unescape('&copy;'), '\\u00a9')",
+                "assrt.equal(unescape('&euro;'), '\\u20ac')",
+                // numeric references
+                "assrt.equal(unescape('&#65;'), 'A')",
+                "assrt.equal(unescape('&#x41;'), 'A')",
+                // unknown entity left intact
+                "assrt.equal(unescape('&nosuchentity;'), '&nosuchentity;')",
+                // round-trip
+                "s = '<Hello & \"World\">'",
+                "assrt.equal(unescape(escape(s)), s)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_html_parser_basic",
+        description: "html stdlib: HTMLParser start/end/data callbacks in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from html import HTMLParser",
+                "class _P(HTMLParser):",
+                "    def __init__(self):",
+                "        HTMLParser.__init__(self)",
+                "        self.events = []",
+                "    def handle_starttag(self, tag, attrs):",
+                "        self.events.push(['start', tag])",
+                "    def handle_endtag(self, tag):",
+                "        self.events.push(['end', tag])",
+                "    def handle_data(self, data):",
+                "        self.events.push(['data', data])",
+                "p = _P()",
+                "p.feed('<p>Hello, World!</p>')",
+                "assrt.equal(p.events[0][0], 'start')",
+                "assrt.equal(p.events[0][1], 'p')",
+                "assrt.equal(p.events[1][0], 'data')",
+                "assrt.equal(p.events[1][1], 'Hello, World!')",
+                "assrt.equal(p.events[2][0], 'end')",
+                "assrt.equal(p.events[2][1], 'p')",
+                // entity conversion in data
+                "p2 = _P()",
+                "p2.feed('<p>A &amp; B</p>')",
+                "assrt.equal(p2.events[1][1], 'A & B')",
+                // tag names lowercased
+                "p3 = _P()",
+                "p3.feed('<DIV></DIV>')",
+                "assrt.equal(p3.events[0][1], 'div')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_html_parser_attrs",
+        description: "html stdlib: HTMLParser attribute parsing in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from html import HTMLParser",
+                "class _PA(HTMLParser):",
+                "    def __init__(self):",
+                "        HTMLParser.__init__(self)",
+                "        self.last_attrs = None",
+                "    def handle_starttag(self, tag, attrs):",
+                "        self.last_attrs = attrs",
+                // multiple attrs
+                "p = _PA()",
+                "p.feed('<a href=\"http://example.com\" target=\"_blank\">')",
+                "assrt.equal(p.last_attrs.length, 2)",
+                "assrt.equal(p.last_attrs[0][0], 'href')",
+                "assrt.equal(p.last_attrs[0][1], 'http://example.com')",
+                "assrt.equal(p.last_attrs[1][0], 'target')",
+                "assrt.equal(p.last_attrs[1][1], '_blank')",
+                // valueless attribute
+                "p2 = _PA()",
+                "p2.feed('<input disabled>')",
+                "assrt.equal(p2.last_attrs[0][0], 'disabled')",
+                "assrt.equal(p2.last_attrs[0][1], None)",
+                // self-closing
+                "class _PSC(HTMLParser):",
+                "    def __init__(self):",
+                "        HTMLParser.__init__(self)",
+                "        self.events = []",
+                "    def handle_starttag(self, tag, attrs):",
+                "        self.events.push('start:' + tag)",
+                "    def handle_endtag(self, tag):",
+                "        self.events.push('end:' + tag)",
+                "psc = _PSC()",
+                "psc.feed('<br/>')",
+                "assrt.equal(psc.events.length, 2)",
+                "assrt.equal(psc.events[0], 'start:br')",
+                "assrt.equal(psc.events[1], 'end:br')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_html_parser_special",
+        description: "html stdlib: HTMLParser comments, DOCTYPE, get_starttag_text in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from html import HTMLParser",
+                // comment
+                "class _PC(HTMLParser):",
+                "    def __init__(self):",
+                "        HTMLParser.__init__(self)",
+                "        self.comments = []",
+                "    def handle_comment(self, data):",
+                "        self.comments.push(data)",
+                "pc = _PC()",
+                "pc.feed('<!-- hello -->')",
+                "assrt.equal(pc.comments.length, 1)",
+                "assrt.equal(pc.comments[0], ' hello ')",
+                // doctype
+                "class _PD(HTMLParser):",
+                "    def __init__(self):",
+                "        HTMLParser.__init__(self)",
+                "        self.decls = []",
+                "    def handle_decl(self, decl):",
+                "        self.decls.push(decl)",
+                "pd = _PD()",
+                "pd.feed('<!DOCTYPE html>')",
+                "assrt.equal(pd.decls[0], 'DOCTYPE html')",
+                // get_starttag_text
+                "class _PR(HTMLParser):",
+                "    def __init__(self):",
+                "        HTMLParser.__init__(self)",
+                "        self.raw = None",
+                "    def handle_starttag(self, tag, attrs):",
+                "        self.raw = self.get_starttag_text()",
+                "pr = _PR()",
+                "pr.feed('<img src=\"pic.png\">')",
+                "assrt.equal(pr.raw, '<img src=\"pic.png\">')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_python_modulo",
+        description: "% operator gives Python-style modulo (sign of divisor) in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "assrt.equal(-7 % 3, 2)",
+                "assrt.equal(7 % -3, -2)",
+                "assrt.equal(-7 % -3, -1)",
+                "assrt.equal(7 % 3, 1)",
+                "assrt.equal(0 % 5, 0)",
+                "assrt.equal(-6 % 3, 0)",
+                "assrt.equal(-7.5 % 2, 0.5)",
+                "assrt.equal(7.5 % -2, -0.5)",
+                "x = -7",
+                "x %= 3",
+                "assrt.equal(x, 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
     {
         name: "repl_exists_persistence",
         description: "ρσ_exists accessible after baselib init — existential operator on non-SymbolRef in web-repl context",
@@ -2218,16 +2887,1727 @@ var TESTS = [
         },
     },
 
-];
-
-// ---------------------------------------------------------------------------
-// Runner
-// ---------------------------------------------------------------------------
+    {
+        name: "bundle_asyncio_exceptions_and_primitives",
+        description: "asyncio stdlib: exception classes, Queue/Lock/Event/Semaphore synchronous state in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from asyncio import (",
+                "    CancelledError, TimeoutError, InvalidStateError, RuntimeError,",
+                "    QueueEmpty, QueueFull,",
+                "    Lock, Event, Semaphore, BoundedSemaphore, Queue",
+                ")",
+                // Exception classes
+                "try:",
+                "    raise CancelledError('c')",
+                "except CancelledError as e:",
+                "    assrt.equal(e.message, 'c')",
+                "try:",
+                "    raise TimeoutError('t')",
+                "except TimeoutError as e:",
+                "    assrt.equal(e.message, 't')",
+                "try:",
+                "    raise QueueEmpty('empty')",
+                "except QueueEmpty as e:",
+                "    assrt.equal(e.message, 'empty')",
+                "try:",
+                "    raise QueueFull('full')",
+                "except QueueFull as e:",
+                "    assrt.equal(e.message, 'full')",
+                // Lock
+                "lock = Lock()",
+                "assrt.equal(lock.locked(), False)",
+                "try:",
+                "    lock.release()",
+                "    assrt.ok(False)",
+                "except RuntimeError:",
+                "    assrt.ok(True)",
+                // Event
+                "ev = Event()",
+                "assrt.equal(ev.is_set(), False)",
+                "ev.set()",
+                "assrt.equal(ev.is_set(), True)",
+                "ev.clear()",
+                "assrt.equal(ev.is_set(), False)",
+                // Semaphore
+                "sem = Semaphore(2)",
+                "assrt.equal(sem.locked(), False)",
+                "sem.release()",
+                "assrt.equal(sem.locked(), False)",
+                // BoundedSemaphore
+                "bsem = BoundedSemaphore(1)",
+                "try:",
+                "    bsem.release()",
+                "    assrt.ok(False)",
+                "except ValueError:",
+                "    assrt.ok(True)",
+                // Queue synchronous ops
+                "q = Queue()",
+                "assrt.equal(q.empty(), True)",
+                "q.put_nowait('a')",
+                "q.put_nowait('b')",
+                "assrt.equal(q.qsize(), 2)",
+                "assrt.equal(q.get_nowait(), 'a')",
+                "q.task_done()",
+                "assrt.equal(q.get_nowait(), 'b')",
+                "q.task_done()",
+                "assrt.equal(q.empty(), True)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
 
-function run_tests(filter) {
-    var tests = filter
-        ? TESTS.filter(function (t) { return t.name === filter; })
-        : TESTS;
+    {
+        name: "bundle_asyncio_coroutine_helpers",
+        description: "asyncio stdlib: iscoroutine, iscoroutinefunction, sleep/gather/run return Promises in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from asyncio import iscoroutine, iscoroutinefunction, sleep, gather, create_task, run, shield",
+                // sleep returns a thenable
+                "p = sleep(0)",
+                "assrt.ok(iscoroutine(p))",
+                // gather returns a thenable
+                "p2 = gather(Promise.resolve(1), Promise.resolve(2))",
+                "assrt.ok(iscoroutine(p2))",
+                // create_task / run pass through
+                "p3 = Promise.resolve(99)",
+                "assrt.ok(iscoroutine(create_task(p3)))",
+                "assrt.ok(iscoroutine(run(p3)))",
+                "assrt.ok(iscoroutine(shield(p3)))",
+                // iscoroutine
+                "assrt.ok(not iscoroutine(42))",
+                "assrt.ok(not iscoroutine(None))",
+                "assrt.ok(iscoroutine(sleep(0)))",
+                // iscoroutinefunction
+                "async def _af():",
+                "    return 1",
+                "assrt.ok(iscoroutinefunction(_af))",
+                "def _sf():",
+                "    return 1",
+                "assrt.ok(not iscoroutinefunction(_sf))",
+                // async functions return Promises
+                "assrt.ok(iscoroutine(_af()))",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_asyncio_queue_variants",
+        description: "asyncio stdlib: LifoQueue and PriorityQueue ordering in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from asyncio import Queue, LifoQueue, PriorityQueue, QueueFull, QueueEmpty",
+                // Bounded Queue — QueueFull
+                "q2 = Queue(2)",
+                "q2.put_nowait(1)",
+                "q2.put_nowait(2)",
+                "assrt.equal(q2.full(), True)",
+                "try:",
+                "    q2.put_nowait(3)",
+                "    assrt.ok(False)",
+                "except QueueFull:",
+                "    assrt.ok(True)",
+                // LifoQueue ordering
+                "lq = LifoQueue()",
+                "lq.put_nowait(1)",
+                "lq.put_nowait(2)",
+                "lq.put_nowait(3)",
+                "assrt.equal(lq.get_nowait(), 3)",
+                "assrt.equal(lq.get_nowait(), 2)",
+                "assrt.equal(lq.get_nowait(), 1)",
+                // PriorityQueue ordering (lowest value first)
+                "pq = PriorityQueue()",
+                "pq.put_nowait(30)",
+                "pq.put_nowait(10)",
+                "pq.put_nowait(20)",
+                "assrt.equal(pq.get_nowait(), 10)",
+                "assrt.equal(pq.get_nowait(), 20)",
+                "assrt.equal(pq.get_nowait(), 30)",
+                // QueueEmpty
+                "q3 = Queue()",
+                "try:",
+                "    q3.get_nowait()",
+                "    assrt.ok(False)",
+                "except QueueEmpty:",
+                "    assrt.ok(True)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_asyncio_async_await",
+        description: "asyncio stdlib: async def / await compiles and returns Promise in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from asyncio import sleep, gather, iscoroutine, iscoroutinefunction, get_event_loop",
+                // async functions compile and return Promises
+                "async def _add(a, b):",
+                "    return a + b",
+                "assrt.ok(iscoroutinefunction(_add))",
+                "p = _add(2, 3)",
+                "assrt.ok(iscoroutine(p))",
+                // chained awaits produce a Promise
+                "async def _chain():",
+                "    x = await Promise.resolve(10)",
+                "    y = await Promise.resolve(20)",
+                "    return x + y",
+                "assrt.ok(iscoroutine(_chain()))",
+                // gather of resolved Promises
+                "async def _g():",
+                "    results = await gather(Promise.resolve(1), Promise.resolve(2))",
+                "    return results",
+                "assrt.ok(iscoroutine(_g()))",
+                // event loop stub
+                "loop = get_event_loop()",
+                "assrt.ok(loop is not None)",
+                "assrt.ok(not loop.is_closed())",
+                "assrt.ok(loop.is_running())",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_async_generator_shape",
+        description: "async def with yield returns an async iterator with .next/.send/.asend (web-repl bundle)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "async def aiter():",
+                "    yield 1",
+                "    yield 2",
+                "    yield 3",
+                "it = aiter()",
+                // The wrapper is sync — calling the async generator returns the
+                // iterator immediately, NOT a Promise.
+                "assrt.equal(jstype(it.next), 'function')",
+                "assrt.equal(jstype(it.send), 'function')",   // Python alias
+                "assrt.equal(jstype(it.asend), 'function')",  // async-gen alias
+                "assrt.equal(jstype(it[v'Symbol.asyncIterator']), 'function')",
+                // .next() returns a thenable Promise
+                "p = it.next()",
+                "assrt.equal(jstype(p.then), 'function')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_async_generator_await_inside",
+        description: "async generators may use `await` between yields (web-repl bundle)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "async def gen():",
+                "    a = await Promise.resolve(10)",
+                "    yield a",
+                "    b = await Promise.resolve(20)",
+                "    yield a + b",
+                "it = gen()",
+                "assrt.equal(jstype(it.next), 'function')",
+                "assrt.equal(jstype(it[v'Symbol.asyncIterator']), 'function')",
+                // .next() is thenable even when the body awaits before yielding
+                "assrt.equal(jstype(it.next().then), 'function')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_async_for_compiles_and_resolves",
+        description: "async for loop drives an async generator and resolves to expected values (web-repl bundle)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "async def aiter():",
+                "    yield 'a'",
+                "    yield 'b'",
+                "    yield 'c'",
+                "async def consume():",
+                "    out = []",
+                "    async for x in aiter():",
+                "        out.append(x)",
+                "    return out",
+                "p = consume()",
+                "assrt.equal(jstype(p.then), 'function')",
+                // The resolved value is verified via a microtask callback that
+                // throws on mismatch. Failing the assertion in a Promise chain
+                // surfaces as an unhandled rejection — Node exits non-zero,
+                // failing the test.
+                "v\"p.then(function(v){ if (v.length !== 3 || v[0] !== 'a' || v[1] !== 'b' || v[2] !== 'c') throw new Error('async-for produced ' + JSON.stringify(v)); })\"",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_async_generator_class_method",
+        description: "async generator method on a class compiles and exposes async iterator (web-repl bundle)",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class Counter:",
+                "    def __init__(self, limit):",
+                "        self.limit = limit",
+                "",
+                "    async def values(self):",
+                "        i = 0",
+                "        while i < self.limit:",
+                "            yield i",
+                "            i += 1",
+                "",
+                "it = Counter(3).values()",
+                "assrt.equal(jstype(it.next), 'function')",
+                "assrt.equal(jstype(it.send), 'function')",
+                "assrt.equal(jstype(it.asend), 'function')",
+                "assrt.equal(jstype(it[v'Symbol.asyncIterator']), 'function')",
+                "assrt.equal(jstype(it.next().then), 'function')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_urllib_parse_quote",
+        description: "urllib.parse stdlib: quote, unquote, quote_plus, unquote_plus in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from urllib.parse import quote, unquote, quote_plus, unquote_plus",
+                // quote: basic
+                "assrt.equal(quote('hello world'), 'hello%20world')",
+                "assrt.equal(quote('a/b/c'), 'a/b/c')",          // '/' safe by default
+                "assrt.equal(quote('a/b/c', safe=''), 'a%2Fb%2Fc')",
+                "assrt.equal(quote('abc123-_.~'), 'abc123-_.~')", // RFC 3986 unreserved
+                "assrt.equal(quote('a+b'), 'a%2Bb')",
+                "assrt.equal(quote('!*'), '%21%2A')",             // sub-delimiters encoded
+                // unquote
+                "assrt.equal(unquote('hello%20world'), 'hello world')",
+                "assrt.equal(unquote('a%2Fb'), 'a/b')",
+                "assrt.equal(unquote('a%2Bb'), 'a+b')",           // '+' not decoded by unquote
+                // quote_plus / unquote_plus
+                "assrt.equal(quote_plus('hello world'), 'hello+world')",
+                "assrt.equal(quote_plus('a+b'), 'a%2Bb')",
+                "assrt.equal(unquote_plus('hello+world'), 'hello world')",
+                "assrt.equal(unquote_plus('a%2Bb'), 'a+b')",
+                // round-trips
+                "s = 'a/b c+d=e&f'",
+                "assrt.equal(unquote(quote(s, safe='')), s)",
+                "assrt.equal(unquote_plus(quote_plus(s, safe='')), s)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_urllib_parse_urlencode",
+        description: "urllib.parse stdlib: urlencode, parse_qs, parse_qsl in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from urllib.parse import urlencode, parse_qs, parse_qsl",
+                // urlencode with list of pairs
+                "assrt.equal(urlencode([['a', '1'], ['b', '2']]), 'a=1&b=2')",
+                "assrt.equal(urlencode([['q', 'hello world']]), 'q=hello%20world')",
+                "assrt.equal(urlencode([]), '')",
+                // doseq
+                "assrt.equal(urlencode([['a', ['x', 'y']]], doseq=True), 'a=x&a=y')",
+                // parse_qsl
+                "pairs = parse_qsl('a=1&b=2&a=3')",
+                "assrt.equal(pairs.length, 3)",
+                "assrt.equal(pairs[0][0], 'a')",
+                "assrt.equal(pairs[0][1], '1')",
+                "assrt.equal(pairs[2][0], 'a')",
+                "assrt.equal(pairs[2][1], '3')",
+                "assrt.equal(parse_qsl('a=hello+world')[0][1], 'hello world')",
+                "assrt.equal(parse_qsl('q=a%20b')[0][1], 'a b')",
+                // parse_qs
+                "d = parse_qs('a=1&b=2&a=3')",
+                "assrt.equal(d['a'].length, 2)",
+                "assrt.equal(d['a'][0], '1')",
+                "assrt.equal(d['a'][1], '3')",
+                "assrt.equal(d['b'][0], '2')",
+                "assrt.equal(parse_qs('q=hello+world')['q'][0], 'hello world')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_urllib_parse_urlparse",
+        description: "urllib.parse stdlib: urlsplit, urlparse, urljoin, urlunsplit in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from urllib.parse import urlsplit, urlunsplit, urlparse, urlunparse, urljoin",
+                // urlsplit
+                "r = urlsplit('http://example.com/path?q=1#frag')",
+                "assrt.equal(r.scheme,   'http')",
+                "assrt.equal(r.netloc,   'example.com')",
+                "assrt.equal(r.path,     '/path')",
+                "assrt.equal(r.query,    'q=1')",
+                "assrt.equal(r.fragment, 'frag')",
+                "assrt.equal(r.hostname, 'example.com')",
+                "assrt.equal(r.port,     None)",
+                // authority with user:pass@host:port
+                "r2 = urlsplit('https://user:pw@host:8080/p?x=1')",
+                "assrt.equal(r2.hostname, 'host')",
+                "assrt.equal(r2.port,     8080)",
+                "assrt.equal(r2.username, 'user')",
+                "assrt.equal(r2.password, 'pw')",
+                // urlparse splits params
+                "r3 = urlparse('http://example.com/path;params?q=1#frag')",
+                "assrt.equal(r3.path,   '/path')",
+                "assrt.equal(r3.params, 'params')",
+                // urlunsplit round-trip
+                "assrt.equal(urlunsplit(('http', 'example.com', '/path', 'q=1', 'frag')), 'http://example.com/path?q=1#frag')",
+                "assrt.equal(urlunsplit(('http', 'example.com', '/path', '', '')),         'http://example.com/path')",
+                // urlunparse with params
+                "assrt.equal(urlunparse(('http', 'example.com', '/path', 'par', 'q=1', 'frag')), 'http://example.com/path;par?q=1#frag')",
+                // geturl round-trip
+                "r4 = urlsplit('http://example.com/path?q=1#frag')",
+                "assrt.equal(r4.geturl(), 'http://example.com/path?q=1#frag')",
+                // urljoin
+                "assrt.equal(urljoin('http://example.com/foo',  'bar'),               'http://example.com/bar')",
+                "assrt.equal(urljoin('http://example.com/foo/', 'bar'),               'http://example.com/foo/bar')",
+                "assrt.equal(urljoin('http://example.com/',     '/other'),            'http://example.com/other')",
+                "assrt.equal(urljoin('http://example.com/foo',  'http://other.com/'), 'http://other.com/')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_urllib_error",
+        description: "urllib.error stdlib: URLError and HTTPError exception classes in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from urllib.error import URLError, HTTPError",
+                // URLError
+                "caught_url = False",
+                "try:",
+                "    raise URLError('network failure')",
+                "except URLError as e:",
+                "    caught_url = True",
+                "    assrt.ok('network failure' in str(e.reason))",
+                "assrt.ok(caught_url)",
+                // HTTPError
+                "caught_http = False",
+                "try:",
+                "    raise HTTPError('http://example.com', 404, 'Not Found', {}, None)",
+                "except HTTPError as e:",
+                "    caught_http = True",
+                "    assrt.equal(e.code, 404)",
+                "    assrt.equal(e.msg, 'Not Found')",
+                "    assrt.equal(e.getcode(), 404)",
+                "    assrt.equal(e.geturl(), 'http://example.com')",
+                "assrt.ok(caught_http)",
+                // HTTPError is caught by URLError handler
+                "caught_as_url = False",
+                "try:",
+                "    raise HTTPError('http://x.com', 500, 'Server Error', {}, None)",
+                "except URLError as e:",
+                "    caught_as_url = True",
+                "    assrt.equal(e.code, 500)",
+                "assrt.ok(caught_as_url)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bisect_basic",
+        description: "bisect stdlib: bisect_left, bisect_right, bisect in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from bisect import bisect_left, bisect_right, bisect",
+                "a = [1, 3, 5, 7, 9]",
+                // bisect_left
+                "assrt.equal(bisect_left(a, 0), 0)",
+                "assrt.equal(bisect_left(a, 1), 0)",
+                "assrt.equal(bisect_left(a, 5), 2)",
+                "assrt.equal(bisect_left(a, 9), 4)",
+                "assrt.equal(bisect_left(a, 10), 5)",
+                // bisect_right
+                "assrt.equal(bisect_right(a, 1), 1)",
+                "assrt.equal(bisect_right(a, 5), 3)",
+                "assrt.equal(bisect_right(a, 9), 5)",
+                "assrt.equal(bisect_right(a, 10), 5)",
+                // bisect alias == bisect_right
+                "assrt.equal(bisect(a, 5), bisect_right(a, 5))",
+                // empty list
+                "assrt.equal(bisect_left([], 5), 0)",
+                "assrt.equal(bisect_right([], 5), 0)",
+                // all equal
+                "eq = [3, 3, 3]",
+                "assrt.equal(bisect_left(eq, 3), 0)",
+                "assrt.equal(bisect_right(eq, 3), 3)",
+                // lo/hi bounds
+                "assrt.equal(bisect_left(a, 6, 1, 4), 3)",
+                "assrt.equal(bisect_right(a, 3, 1, 4), 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bisect_insort",
+        description: "bisect stdlib: insort_left, insort_right, insort in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from bisect import insort_left, insort_right, insort",
+                // insort_right basic
+                "r = [1, 3, 5, 7]",
+                "insort_right(r, 4)",
+                "assrt.deepEqual(r, [1, 3, 4, 5, 7])",
+                // insort_left: new value goes to the LEFT of equal elements
+                "l = [1, 3, 3, 5]",
+                "insort_left(l, 3)",
+                "assrt.equal(l[1], 3)",   // new 3 at index 1
+                "assrt.equal(l.length, 5)",
+                // insort alias == insort_right
+                "s = [2, 4, 6]",
+                "insort(s, 5)",
+                "assrt.deepEqual(s, [2, 4, 5, 6])",
+                // build sorted list from scratch
+                "built = []",
+                "for v in [5, 1, 3, 2, 4]:",
+                "    insort(built, v)",
+                "assrt.deepEqual(built, [1, 2, 3, 4, 5])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bisect_key",
+        description: "bisect stdlib: key function parameter in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from bisect import bisect_left, bisect_right",
+                // key extracts first element of each pair; x is the key value
+                "pairs = [[1, 'a'], [3, 'b'], [5, 'c'], [7, 'd']]",
+                "kfn = def(item): return item[0];",
+                "assrt.equal(bisect_left(pairs, 3, 0, None, kfn), 1)",
+                "assrt.equal(bisect_right(pairs, 3, 0, None, kfn), 2)",
+                "assrt.equal(bisect_left(pairs, 4, 0, None, kfn), 2)",
+                "assrt.equal(bisect_right(pairs, 4, 0, None, kfn), 2)",
+                "assrt.equal(bisect_left(pairs, 0, 0, None, kfn), 0)",
+                "assrt.equal(bisect_right(pairs, 8, 0, None, kfn), 4)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_bisect_errors",
+        description: "bisect stdlib: ValueError for negative lo in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from bisect import bisect_left, bisect_right",
+                "caught_left = False",
+                "try:",
+                "    bisect_left([1, 2, 3], 2, -1)",
+                "except ValueError:",
+                "    caught_left = True",
+                "assrt.ok(caught_left)",
+                "caught_right = False",
+                "try:",
+                "    bisect_right([1, 2, 3], 2, -1)",
+                "except ValueError:",
+                "    caught_right = True",
+                "assrt.ok(caught_right)",
+                // strings also work
+                "words = ['bar', 'baz', 'foo', 'qux']",
+                "assrt.equal(bisect_left(words, 'car'), 2)",
+                "assrt.equal(bisect_right(words, 'car'), 2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── http stdlib ──────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_http_status",
+        description: "http stdlib: HTTPStatus constants in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from http import HTTPStatus",
+                "assrt.equal(HTTPStatus.OK,                  200)",
+                "assrt.equal(HTTPStatus.CREATED,             201)",
+                "assrt.equal(HTTPStatus.NO_CONTENT,          204)",
+                "assrt.equal(HTTPStatus.NOT_FOUND,           404)",
+                "assrt.equal(HTTPStatus.INTERNAL_SERVER_ERROR, 500)",
+                "assrt.equal(HTTPStatus.IM_A_TEAPOT,         418)",
+                "assrt.equal(HTTPStatus.MOVED_PERMANENTLY,   301)",
+                "assrt.equal(HTTPStatus.UNAUTHORIZED,        401)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_http_client_basics",
+        description: "http.client stdlib: HTTPConnection, HTTPSConnection, HTTPResponse, exceptions in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from http.client import (HTTPConnection, HTTPSConnection, HTTPResponse,",
+                "                         HTTPException, NotConnected, InvalidURL,",
+                "                         RemoteDisconnected, HTTP_PORT, HTTPS_PORT)",
+                "assrt.equal(HTTP_PORT,  80)",
+                "assrt.equal(HTTPS_PORT, 443)",
+                // URL building
+                "conn = HTTPConnection('example.com')",
+                "assrt.equal(conn._build_url('/path'), 'http://example.com/path')",
+                "conn2 = HTTPConnection('example.com', 8080)",
+                "assrt.equal(conn2._build_url('/api'), 'http://example.com:8080/api')",
+                "sconn = HTTPSConnection('secure.example.com')",
+                "assrt.equal(sconn._build_url('/data'), 'https://secure.example.com/data')",
+                // request() stores state
+                "conn3 = HTTPConnection('api.example.com')",
+                "conn3.request('POST', '/items', 'a=1', {'Content-Type': 'text/plain'})",
+                "assrt.equal(conn3._method, 'POST')",
+                "assrt.equal(conn3._path,   '/items')",
+                "assrt.equal(conn3._body,   'a=1')",
+                "assrt.equal(conn3._headers['content-type'], 'text/plain')",
+                // HTTPResponse accessors
+                "hdrs = {'content-type': 'application/json'}",
+                "resp = HTTPResponse(200, 'OK', hdrs, '{\"n\":42}', 'https://x.com/')",
+                "assrt.equal(resp.status, 200)",
+                "assrt.equal(resp.reason, 'OK')",
+                "assrt.equal(resp.getheader('content-type'), 'application/json')",
+                "assrt.equal(resp.getheader('Content-Type'), 'application/json')",
+                "assrt.equal(resp.getheader('missing', 'def'), 'def')",
+                "assrt.ok(resp.read() is not None)",
+                "assrt.ok(resp.json() is not None)",
+                // exception hierarchy
+                "caught = False",
+                "try:",
+                "    raise NotConnected('nc')",
+                "except HTTPException as e:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_http_cookies_basic",
+        description: "http.cookies stdlib: SimpleCookie parsing and Morsel access in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import overload_getitem",
+                "from http.cookies import SimpleCookie, Morsel, CookieError",
+                // basic parse
+                "c = SimpleCookie()",
+                "c.load('session=abc123; user=alice')",
+                "assrt.ok('session' in c.keys())",
+                "assrt.ok('user' in c.keys())",
+                "assrt.equal(c['session'].value, 'abc123')",
+                "assrt.equal(c['user'].value,    'alice')",
+                // set a cookie
+                "c2 = SimpleCookie()",
+                "c2['token'] = 'xyz'",
+                "assrt.ok('token' in c2.keys())",
+                "assrt.equal(c2['token'].value, 'xyz')",
+                // cookie attributes
+                "c3 = SimpleCookie()",
+                "c3['id'] = '1'",
+                "c3['id']['path']    = '/'",
+                "c3['id']['max-age'] = 3600",
+                "assrt.equal(c3['id']['path'], '/')",
+                "assrt.equal(c3['id']['max-age'], 3600)",
+                // constructor with initial data
+                "c4 = SimpleCookie('x=10; y=20')",
+                "assrt.equal(c4['x'].value, '10')",
+                "assrt.equal(c4['y'].value, '20')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_http_cookies_output",
+        description: "http.cookies stdlib: SimpleCookie.output, Morsel.OutputString in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import overload_getitem",
+                "from http.cookies import SimpleCookie, Morsel, CookieError",
+                // Morsel.OutputString
+                "m = Morsel()",
+                "m.set('token', 'abc', 'abc')",
+                "m._attrs['path']    = '/'",
+                "m._attrs['max-age'] = '3600'",
+                "s = m.OutputString()",
+                "assrt.ok('token=abc' in s)",
+                "assrt.ok('Path=/' in s)",
+                "assrt.ok('Max-Age=3600' in s)",
+                // Morsel.output with header
+                "out = m.output()",
+                "assrt.ok('Set-Cookie: token=abc' in out)",
+                // SimpleCookie.output
+                "c = SimpleCookie()",
+                "c['a'] = '1'",
+                "c['b'] = '2'",
+                "full = c.output()",
+                "assrt.ok('Set-Cookie: a=1' in full)",
+                "assrt.ok('Set-Cookie: b=2' in full)",
+                // CookieError
+                "caught = False",
+                "try:",
+                "    raise CookieError('bad')",
+                "except CookieError as e:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── csv stdlib ────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_csv_reader_basic",
+        description: "csv stdlib: reader parses CSV rows and writer produces CSV text in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "import csv",
+                "from io import StringIO",
+                // reader — list input
+                "rows = []",
+                "for row in csv.reader(['a,b,c', '1,2,3']):",
+                "    rows.push(row)",
+                "assrt.equal(rows.length, 2)",
+                "assrt.deepEqual(rows[0], ['a', 'b', 'c'])",
+                "assrt.deepEqual(rows[1], ['1', '2', '3'])",
+                // reader — quoted field
+                "rows2 = []",
+                "for row in csv.reader(['\"hello, world\",foo']):",
+                "    rows2.push(row)",
+                "assrt.equal(rows2[0][0], 'hello, world')",
+                "assrt.equal(rows2[0][1], 'foo')",
+                // writer
+                "sio = StringIO()",
+                "w = csv.writer(sio)",
+                "w.writerow(['name', 'age'])",
+                "w.writerow(['Alice', 30])",
+                "out = sio.getvalue()",
+                "assrt.ok('name,age' in out)",
+                "assrt.ok('Alice,30' in out)",
+                // round-trip
+                "buf = StringIO()",
+                "w2 = csv.writer(buf)",
+                "w2.writerow(['x', 'needs, quoting', 'y'])",
+                "buf.seek(0)",
+                "rt = []",
+                "for row in csv.reader(buf):",
+                "    rt.push(row)",
+                "assrt.deepEqual(rt[0], ['x', 'needs, quoting', 'y'])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_csv_dictreader",
+        description: "csv stdlib: DictReader reads rows as dicts with automatic fieldnames in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "import csv",
+                // DictReader — fieldnames from first row
+                "rows = []",
+                "for row in csv.DictReader(['name,age', 'Alice,30', 'Bob,25']):",
+                "    rows.push(row)",
+                "assrt.equal(rows.length, 2)",
+                "assrt.equal(rows[0]['name'], 'Alice')",
+                "assrt.equal(rows[0]['age'],  '30')",
+                "assrt.equal(rows[1]['name'], 'Bob')",
+                // DictReader — provided fieldnames
+                "rows2 = []",
+                "for row in csv.DictReader(['Alice,30', 'Bob,25'], fieldnames=['name','age']):",
+                "    rows2.push(row)",
+                "assrt.equal(rows2.length, 2)",
+                "assrt.equal(rows2[0]['name'], 'Alice')",
+                // DictReader — restval for missing field
+                "rows3 = []",
+                "for row in csv.DictReader(['name,age,city', 'Alice,30'], restval='?'):",
+                "    rows3.push(row)",
+                "assrt.equal(rows3[0]['city'], '?')",
+                // DictReader — empty input yields no rows
+                "empty_count = 0",
+                "for row in csv.DictReader([]):",
+                "    empty_count += 1",
+                "assrt.equal(empty_count, 0)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_csv_dictwriter",
+        description: "csv stdlib: DictWriter writes header and rows from dicts in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "import csv",
+                "from io import StringIO",
+                // DictWriter — writeheader + writerow
+                "sio = StringIO()",
+                "dw = csv.DictWriter(sio, ['name', 'score'])",
+                "dw.writeheader()",
+                "dw.writerow({'name': 'Eve', 'score': '99'})",
+                "dw.writerow({'name': 'Frank', 'score': '88'})",
+                "out = sio.getvalue()",
+                "assrt.ok('name,score' in out)",
+                "assrt.ok('Eve,99' in out)",
+                "assrt.ok('Frank,88' in out)",
+                // round-trip DictWriter → DictReader
+                "buf = StringIO()",
+                "dw2 = csv.DictWriter(buf, ['x', 'y'])",
+                "dw2.writeheader()",
+                "dw2.writerow({'x': 'hello', 'y': 'world'})",
+                "buf.seek(0)",
+                "rt = []",
+                "for row in csv.DictReader(buf):",
+                "    rt.push(row)",
+                "assrt.equal(rt.length, 1)",
+                "assrt.equal(rt[0]['x'], 'hello')",
+                "assrt.equal(rt[0]['y'], 'world')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_csv_dialects",
+        description: "csv stdlib: dialect options, register_dialect, list_dialects, field_size_limit in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "import csv",
+                "from io import StringIO",
+                // excel-tab dialect
+                "rows = []",
+                "for row in csv.reader(['a\\tb\\tc'], dialect='excel-tab'):",
+                "    rows.push(row)",
+                "assrt.deepEqual(rows[0], ['a', 'b', 'c'])",
+                // QUOTE_ALL
+                "sio = StringIO()",
+                "w = csv.writer(sio, quoting=csv.QUOTE_ALL)",
+                "w.writerow(['x', 'y'])",
+                "assrt.equal(sio.getvalue(), '\"x\",\"y\"\\r\\n')",
+                // register_dialect / list_dialects / unregister_dialect
+                "csv.register_dialect('pipes', delimiter='|')",
+                "dialects = csv.list_dialects()",
+                "assrt.ok(dialects.indexOf('pipes') >= 0)",
+                "sio2 = StringIO()",
+                "w2 = csv.writer(sio2, dialect='pipes')",
+                "w2.writerow(['a', 'b'])",
+                "assrt.equal(sio2.getvalue(), 'a|b\\r\\n')",
+                "csv.unregister_dialect('pipes')",
+                "assrt.ok(csv.list_dialects().indexOf('pipes') < 0)",
+                // field_size_limit
+                "old = csv.field_size_limit(65536)",
+                "assrt.equal(old, 131072)",
+                "assrt.equal(csv.field_size_limit(), 65536)",
+                "csv.field_size_limit(131072)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_textwrap_wrap",
+        description: "textwrap stdlib: wrap, fill, shorten in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from textwrap import wrap, fill, shorten",
+                // basic wrap
+                "r = wrap('one two three four five', 10)",
+                "assrt.equal(r.length, 3)",
+                "assrt.equal(r[0], 'one two')",
+                "assrt.equal(r[1], 'three four')",
+                "assrt.equal(r[2], 'five')",
+                // short text fits on one line
+                "assrt.deepEqual(wrap('hello', 20), ['hello'])",
+                // empty string
+                "assrt.deepEqual(wrap('', 10), [])",
+                // fill joins with newlines
+                "assrt.equal(fill('one two three', 8), 'one two\\nthree')",
+                // fill with indents
+                "assrt.equal(fill('one two three four', 12, initial_indent='> ', subsequent_indent='  '), '> one two\\n  three four')",
+                // shorten — fits
+                "assrt.equal(shorten('hello world', 20), 'hello world')",
+                // shorten — truncates; 'one two three' (13) + ' [...]' (6) = 19 ≤ 20
+                "assrt.equal(shorten('one two three four five', 20), 'one two three [...]')",
+                // shorten — custom placeholder
+                "assrt.equal(shorten('hello world foo bar', 14, placeholder='...'), 'hello world...')",
+                // shorten — normalises whitespace
+                "assrt.equal(shorten('hello    world', 20), 'hello world')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_textwrap_dedent",
+        description: "textwrap stdlib: dedent in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from textwrap import dedent",
+                // common indent removed
+                "assrt.equal(dedent('  hello\\n  world'), 'hello\\nworld')",
+                // no common indent
+                "assrt.equal(dedent('hello\\n  world'), 'hello\\n  world')",
+                // empty lines ignored when computing margin
+                "assrt.equal(dedent('  hello\\n\\n  world'), 'hello\\n\\nworld')",
+                // partial common indent: '    ' vs '  ' → margin '  '
+                "assrt.equal(dedent('    foo\\n  bar'), '  foo\\nbar')",
+                // leading blank line then indented
+                "assrt.equal(dedent('\\n    foo\\n    bar'), '\\nfoo\\nbar')",
+                // tab-based indent
+                "assrt.equal(dedent('\\thello\\n\\tworld'), 'hello\\nworld')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_textwrap_indent",
+        description: "textwrap stdlib: indent with and without predicate in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from textwrap import indent",
+                // basic
+                "assrt.equal(indent('hello\\nworld', '  '), '  hello\\n  world')",
+                // empty lines not indented by default
+                "assrt.equal(indent('hello\\n\\nworld', '  '), '  hello\\n\\n  world')",
+                // whitespace-only line not indented
+                "assrt.equal(indent('hello\\n   \\nworld', '> '), '> hello\\n   \\n> world')",
+                // custom predicate: indent all lines
+                "_pred = def(line): return True;",
+                "assrt.equal(indent('hello\\n\\nworld', '> ', _pred), '> hello\\n> \\n> world')",
+                // predicate: only lines starting with '#'
+                "_ph = def(line): return line.startsWith('#');",
+                "assrt.equal(indent('# a\\ncode\\n# b', '!! ', _ph), '!! # a\\ncode\\n!! # b')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_textwrap_textwrapper",
+        description: "textwrap stdlib: TextWrapper class with options in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from textwrap import TextWrapper",
+                // basic wrap and fill
+                "tw = TextWrapper(width=10)",
+                "assrt.deepEqual(tw.wrap('one two three'), ['one two', 'three'])",
+                "assrt.equal(tw.fill('one two three'), 'one two\\nthree')",
+                // max_lines with placeholder
+                // width=15, max_lines=2, placeholder=' ...' (4 chars)
+                // line 1: 'alpha beta' (10) fits; line 2 truncated to 'gamma delta ...' (15)
+                "tw2 = TextWrapper(width=15, max_lines=2, placeholder=' ...')",
+                "r2 = tw2.wrap('alpha beta gamma delta epsilon')",
+                "assrt.equal(r2.length, 2)",
+                "assrt.equal(r2[0], 'alpha beta')",
+                "assrt.equal(r2[1], 'gamma delta ...')",
+                // break_long_words=False
+                "tw3 = TextWrapper(width=5, break_long_words=False)",
+                "r3 = tw3.wrap('superlongword short')",
+                "assrt.equal(r3[0], 'superlongword')",
+                "assrt.equal(r3[1], 'short')",
+                // fix_sentence_endings
+                "tw4 = TextWrapper(width=70, fix_sentence_endings=True)",
+                "r4 = tw4.wrap('end of sentence. New sentence.')",
+                "assrt.equal(r4[0], 'end of sentence.  New sentence.')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── logging ──────────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_logging_basic",
+        description: "logging stdlib: StreamHandler with custom stream in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from logging import Logger, StreamHandler, Formatter, DEBUG, INFO, WARNING, ERROR",
+                "class _Buf:",
+                "    def __init__(self):",
+                "        self.lines = []",
+                "    def write(self, s):",
+                "        self.lines.push(s)",
+                "_buf = _Buf()",
+                "_h = StreamHandler(_buf)",
+                "_h.setFormatter(Formatter('%(levelname)s:%(name)s:%(message)s'))",
+                "_h.setLevel(DEBUG)",
+                "_log = Logger('myapp')",
+                "_log.addHandler(_h)",
+                "_log.setLevel(DEBUG)",
+                "_log.propagate = False",
+                "_log.debug('dbg')",
+                "_log.info('hi')",
+                "_log.warning('warn')",
+                "_log.error('err')",
+                "assrt.equal(_buf.lines.length, 4)",
+                "assrt.equal(_buf.lines[0], 'DEBUG:myapp:dbg\\n')",
+                "assrt.equal(_buf.lines[1], 'INFO:myapp:hi\\n')",
+                "assrt.equal(_buf.lines[2], 'WARNING:myapp:warn\\n')",
+                "assrt.equal(_buf.lines[3], 'ERROR:myapp:err\\n')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_logging_levels",
+        description: "logging stdlib: level constants, getLevelName, addLevelName, %-format args",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from logging import getLevelName, addLevelName, DEBUG, INFO, WARNING, ERROR, CRITICAL, NOTSET",
+                "assrt.equal(NOTSET,   0)",
+                "assrt.equal(DEBUG,    10)",
+                "assrt.equal(INFO,     20)",
+                "assrt.equal(WARNING,  30)",
+                "assrt.equal(ERROR,    40)",
+                "assrt.equal(CRITICAL, 50)",
+                "assrt.equal(getLevelName(DEBUG),    'DEBUG')",
+                "assrt.equal(getLevelName(WARNING),  'WARNING')",
+                "assrt.equal(getLevelName(42),       'Level 42')",
+                "assrt.equal(getLevelName('ERROR'),  ERROR)",
+                "assrt.equal(getLevelName('WARN'),   WARNING)",
+                "addLevelName(15, 'VERBOSE')",
+                "assrt.equal(getLevelName(15),         'VERBOSE')",
+                "assrt.equal(getLevelName('VERBOSE'),  15)",
+                // %-format args via Logger
+                "from logging import Logger, StreamHandler, Formatter",
+                "class _B:",
+                "    def __init__(self):",
+                "        self.out = []",
+                "    def write(self, s):",
+                "        self.out.push(s)",
+                "_b = _B()",
+                "_h2 = StreamHandler(_b)",
+                "_h2.setFormatter(Formatter('%(message)s'))",
+                "_l2 = Logger('fmt')",
+                "_l2.addHandler(_h2)",
+                "_l2.setLevel(DEBUG)",
+                "_l2.propagate = False",
+                "_l2.info('x=%d y=%s', 7, 'foo')",
+                "assrt.equal(_b.out[0], 'x=7 y=foo\\n')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_logging_hierarchy",
+        description: "logging stdlib: parent/child logger hierarchy and propagation",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from logging import Logger, StreamHandler, Formatter, DEBUG, INFO",
+                "class _B:",
+                "    def __init__(self):",
+                "        self.out = []",
+                "    def write(self, s):",
+                "        self.out.push(s)",
+                "_b = _B()",
+                "_h = StreamHandler(_b)",
+                "_h.setFormatter(Formatter('%(name)s:%(message)s'))",
+                "_parent = Logger('app')",
+                "_parent.addHandler(_h)",
+                "_parent.setLevel(DEBUG)",
+                "_parent.propagate = False",
+                "_child = Logger('app.sub')",
+                "_child.parent = _parent",
+                "_child.setLevel(DEBUG)",
+                "_child.propagate = True",
+                "_child.info('from child')",
+                "assrt.equal(_b.out.length, 1)",
+                "assrt.equal(_b.out[0], 'app.sub:from child\\n')",
+                // child with propagate=False should NOT reach parent handler
+                "_b2 = _B()",
+                "_h2 = StreamHandler(_b2)",
+                "_h2.setFormatter(Formatter('%(message)s'))",
+                "_child2 = Logger('app.sub2')",
+                "_child2.parent = _parent",
+                "_child2.addHandler(_h2)",
+                "_child2.setLevel(DEBUG)",
+                "_child2.propagate = False",
+                "_child2.info('isolated')",
+                "assrt.equal(_b.out.length, 1)",   // parent buffer unchanged
+                "assrt.equal(_b2.out[0], 'isolated\\n')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_logging_basicconfig",
+        description: "logging stdlib: basicConfig sets up root logger with custom stream",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "import logging",
+                "class _B:",
+                "    def __init__(self):",
+                "        self.out = []",
+                "    def write(self, s):",
+                "        self.out.push(s)",
+                "_b = _B()",
+                "logging.basicConfig(level=logging.DEBUG, format='%(levelname)s:%(message)s', stream=_b)",
+                "logging.debug('d')",
+                "logging.info('i')",
+                "logging.warning('w')",
+                "assrt.equal(_b.out.length, 3)",
+                "assrt.equal(_b.out[0], 'DEBUG:d\\n')",
+                "assrt.equal(_b.out[1], 'INFO:i\\n')",
+                "assrt.equal(_b.out[2], 'WARNING:w\\n')",
+                // disable() suppresses messages at or below the given level
+                "logging.disable(logging.ERROR)",
+                "logging.warning('suppressed')",
+                "logging.error('also suppressed')",
+                "assrt.equal(_b.out.length, 3)",
+                "logging.disable(logging.NOTSET)",  // reset
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── pprint stdlib ────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_pprint_basic",
+        description: "pprint stdlib: pformat of atoms and short containers in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import pformat",
+                // atoms -> repr()
+                "assrt.equal(pformat(None), 'None')",
+                "assrt.equal(pformat(True), 'True')",
+                "assrt.equal(pformat(42), '42')",
+                "assrt.equal(pformat('hi'), '\"hi\"')",
+                // empty containers
+                "assrt.equal(pformat([]), '[]')",
+                "assrt.equal(pformat({}), '{}')",
+                "assrt.equal(pformat(set()), 'set()')",
+                // short containers fit on one line
+                "assrt.equal(pformat([1, 2, 3]), '[1, 2, 3]')",
+                "assrt.equal(pformat({'a': 1, 'b': 2}), '{\"a\": 1, \"b\": 2}')",
+                "assrt.equal(pformat(frozenset([1])), 'frozenset({1})')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_pprint_wrap",
+        description: "pprint stdlib: wide containers break across lines in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import pformat",
+                // wide list breaks one element per line
+                "assrt.equal(pformat([1, 2, 3], width=5), '[1,\\n 2,\\n 3]')",
+                // wide dict breaks, keys sorted by default
+                "assrt.equal(pformat({'name': 'Al', 'age': 3}, width=12), '{\"age\": 3,\\n \"name\": \"Al\"}')",
+                // indent parameter widens inner indentation
+                "assrt.equal(pformat([1, 2, 3], width=5, indent=4), '[   1,\\n    2,\\n    3]')",
+                // single-element containers never break
+                "assrt.equal(pformat([42], width=1), '[42]')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_pprint_features",
+        description: "pprint stdlib: depth, compact, sort_dicts, and pp() in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import pformat, pp",
+                // depth limits expansion
+                "assrt.equal(pformat([1, [2, [3]]], depth=1), '[1, [...]]')",
+                "assrt.equal(pformat([1, [2, [3]]], depth=2), '[1, [2, [...]]]')",
+                // sort_dicts=False keeps insertion order (ρσ_dict preserves it)
+                "d = dict()",
+                "d.set('c', 1)",
+                "d.set('a', 2)",
+                "assrt.equal(pformat(d, sort_dicts=False), '{\"c\": 1, \"a\": 2}')",
+                "assrt.equal(pformat(d, sort_dicts=True), '{\"a\": 2, \"c\": 1}')",
+                // compact packs multiple items per line
+                "compact_out = pformat([1, 2, 3, 4, 5, 6, 7, 8], compact=True, width=15)",
+                "assrt.equal(compact_out, '[1, 2, 3, 4, 5,\\n 6, 7, 8]')",
+                // pp() writes to a custom stream and defaults sort_dicts=False
+                "class _C:",
+                "    def __init__(self):",
+                "        self.parts = []",
+                "    def write(self, s):",
+                "        self.parts.push(s)",
+                "col = _C()",
+                "pp(d, stream=col)",
+                "assrt.equal(col.parts.join(''), '{\"c\": 1, \"a\": 2}\\n')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_pprint_safe",
+        description: "pprint stdlib: saferepr, isreadable, isrecursive, PrettyPrinter in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from pprint import saferepr, isreadable, isrecursive, PrettyPrinter",
+                // saferepr of normal structures == single-line repr
+                "assrt.equal(saferepr([1, 2, 3]), '[1, 2, 3]')",
+                "assrt.equal(saferepr({'a': 1}), '{\"a\": 1}')",
+                // isreadable / isrecursive on plain structures
+                "assrt.ok(isreadable([1, 2, 3]))",
+                "assrt.ok(not isrecursive([1, 2, 3]))",
+                // self-referential list -> recursion detected and marked
+                "cyclic = [1, 2]",
+                "cyclic.push(cyclic)",
+                "assrt.ok(isrecursive(cyclic))",
+                "assrt.ok(not isreadable(cyclic))",
+                "assrt.ok(saferepr(cyclic).indexOf('<Recursion on') >= 0)",
+                // PrettyPrinter class: pformat + instance predicates
+                "p = PrettyPrinter(indent=2, width=8)",
+                "assrt.equal(p.pformat([10, 20, 30]), '[ 10,\\n  20,\\n  30]')",
+                "assrt.ok(p.isrecursive(cyclic))",
+                // invalid args raise ValueError
+                "caught = False",
+                "try:",
+                "    PrettyPrinter(depth=0)",
+                "except ValueError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_type_enforcement_basic",
+        description: "type_enforcement: max args, missing required, type annotations",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import type_enforcement",
+                "def add(a: int, b: int):",
+                "    return a + b",
+                // correct call
+                "assrt.equal(add(2, 3), 5)",
+                // too many positional args
+                "caught = False",
+                "try:",
+                "    add(1, 2, 3)",
+                "except TypeError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+                // missing required arg
+                "caught2 = False",
+                "try:",
+                "    add(1)",
+                "except TypeError:",
+                "    caught2 = True",
+                "assrt.ok(caught2)",
+                // type mismatch
+                "caught3 = False",
+                "try:",
+                "    add('x', 2)",
+                "except TypeError:",
+                "    caught3 = True",
+                "assrt.ok(caught3)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_type_enforcement_posonly",
+        description: "type_enforcement: positional-only args cannot be passed as kwargs",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import type_enforcement",
+                "def sub(a, b, /):",
+                "    return a - b",
+                // valid positional call
+                "assrt.equal(sub(10, 3), 7)",
+                // posonly passed as kwarg → TypeError
+                "caught = False",
+                "try:",
+                "    sub(a=10, b=3)",
+                "except TypeError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+                // mixed: posonly + default normal
+                "def greet(name, /, greeting='Hello'):",
+                "    return greeting + ' ' + name",
+                "assrt.equal(greet('Alice'), 'Hello Alice')",
+                "assrt.equal(greet('Bob', greeting='Hi'), 'Hi Bob')",
+                "caught2 = False",
+                "try:",
+                "    greet(name='Carol')",
+                "except TypeError:",
+                "    caught2 = True",
+                "assrt.ok(caught2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_type_enforcement_kwonly",
+        description: "type_enforcement: keyword-only args must be supplied by name",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import type_enforcement",
+                "def notify(msg, *, urgent):",
+                "    return msg + ('!' if urgent else '.')",
+                // correct kwonly usage
+                "assrt.equal(notify('hi', urgent=True), 'hi!')",
+                "assrt.equal(notify('hi', urgent=False), 'hi.')",
+                // missing required kwonly → TypeError
+                "caught = False",
+                "try:",
+                "    notify('hello')",
+                "except TypeError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+                // optional kwonly with default — no error when omitted
+                "def fmt(val, *, prefix=''):",
+                "    return prefix + str(val)",
+                "assrt.equal(fmt(42), '42')",
+                "assrt.equal(fmt(42, prefix='>> '), '>> 42')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_type_enforcement_class",
+        description: "type_enforcement: class method arg enforcement",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from __python__ import type_enforcement",
+                "class Vec:",
+                "    def __init__(self, x: int, y: int):",
+                "        self.x = x",
+                "        self.y = y",
+                "    def scale(self, factor: int, /, *, clamp=False):",
+                "        v = self.x * factor",
+                "        return min(v, 100) if clamp else v",
+                "v = Vec(3, 4)",
+                "assrt.equal(v.scale(2), 6)",
+                "assrt.equal(v.scale(50, clamp=True), 100)",
+                // type mismatch in __init__
+                "caught = False",
+                "try:",
+                "    Vec('a', 1)",
+                "except TypeError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+                // factor is posonly → cannot be kwarg
+                "caught2 = False",
+                "try:",
+                "    v.scale(factor=2)",
+                "except TypeError:",
+                "    caught2 = True",
+                "assrt.ok(caught2)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_heapq_push_pop",
+        description: "heapq stdlib: heappush and heappop in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from heapq import heappush, heappop",
+                // push in arbitrary order, pop should return sorted
+                "h = []",
+                "heappush(h, 3)",
+                "heappush(h, 1)",
+                "heappush(h, 4)",
+                "heappush(h, 1)",
+                "heappush(h, 5)",
+                "assrt.equal(heappop(h), 1)",
+                "assrt.equal(heappop(h), 1)",
+                "assrt.equal(heappop(h), 3)",
+                "assrt.equal(heappop(h), 4)",
+                "assrt.equal(heappop(h), 5)",
+                "assrt.equal(h.length, 0)",
+                // heappop on empty raises IndexError
+                "caught = False",
+                "try:",
+                "    heappop([])",
+                "except IndexError:",
+                "    caught = True",
+                "assrt.ok(caught)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_heapq_heapify",
+        description: "heapq stdlib: heapify in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from heapq import heapify, heappop",
+                // heapify puts min at root
+                "x = [5, 3, 8, 1, 2, 4]",
+                "heapify(x)",
+                "assrt.equal(x[0], 1)",
+                // heapify + repeated heappop gives sorted order
+                "data = [5, 3, 8, 1, 2, 4]",
+                "heapify(data)",
+                "result = []",
+                "while data.length > 0:",
+                "    result.push(heappop(data))",
+                "assrt.deepEqual(result, [1, 2, 3, 4, 5, 8])",
+                // negative numbers
+                "neg = [-3, -1, -4, -1, -5]",
+                "heapify(neg)",
+                "neg_out = []",
+                "while neg.length > 0:",
+                "    neg_out.push(heappop(neg))",
+                "assrt.deepEqual(neg_out, [-5, -4, -3, -1, -1])",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_heapq_nsmallest_nlargest",
+        description: "heapq stdlib: nsmallest and nlargest in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from heapq import nsmallest, nlargest",
+                "data = [3, 1, 4, 1, 5, 9, 2, 6]",
+                "assrt.deepEqual(nsmallest(3, data), [1, 1, 2])",
+                "assrt.deepEqual(nlargest(3, data), [9, 6, 5])",
+                "assrt.deepEqual(nsmallest(0, data), [])",
+                "assrt.deepEqual(nlargest(0, data), [])",
+                // n > len returns all sorted
+                "assrt.deepEqual(nsmallest(100, [3, 1, 2]), [1, 2, 3])",
+                "assrt.deepEqual(nlargest(100, [3, 1, 2]), [3, 2, 1])",
+                // key function
+                "pairs = [[3, 'c'], [1, 'a'], [4, 'd'], [1, 'b'], [5, 'e']]",
+                "kfn = def(p): return p[0];",
+                "sm = nsmallest(2, pairs, key=kfn)",
+                "assrt.equal(sm[0][0], 1)",
+                "assrt.equal(sm[1][0], 1)",
+                "lg = nlargest(2, pairs, key=kfn)",
+                "assrt.equal(lg[0][0], 5)",
+                "assrt.equal(lg[1][0], 4)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_heapq_replace_pushpop",
+        description: "heapq stdlib: heapreplace and heappushpop in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from heapq import heapify, heappop, heapreplace, heappushpop",
+                // heapreplace: returns old min, inserts new item
+                "r = [1, 3, 5, 7, 9]",
+                "heapify(r)",
+                "old = heapreplace(r, 4)",
+                "assrt.equal(old, 1)",
+                "assrt.equal(r[0], 3)",
+                // heapreplace on empty raises IndexError
+                "caught_rep = False",
+                "try:",
+                "    heapreplace([], 1)",
+                "except IndexError:",
+                "    caught_rep = True",
+                "assrt.ok(caught_rep)",
+                // heappushpop: item > root — returns root
+                "pp = [1, 3, 5]",
+                "heapify(pp)",
+                "assrt.equal(heappushpop(pp, 2), 1)",
+                "assrt.equal(pp[0], 2)",
+                // heappushpop: item <= root — returns item unchanged
+                "pp2 = [5, 7, 9]",
+                "heapify(pp2)",
+                "assrt.equal(heappushpop(pp2, 4), 4)",
+                "assrt.equal(pp2[0], 5)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── parenthesized with (Python 3.10+) ────────────────────────────────────
+
+    {
+        name: "bundle_paren_with_single",
+        description: "parenthesized with: single clause with alias compiles and runs in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class _CM:",
+                "    def __init__(self, val):",
+                "        self.val = val",
+                "    def __enter__(self):",
+                "        return self.val",
+                "    def __exit__(self):",
+                "        pass",
+                "with (_CM(42) as x):",
+                "    assrt.equal(x, 42)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_paren_with_multi",
+        description: "parenthesized with: multi-clause LIFO exit order compiles and runs in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "log = []",
+                "class _CM:",
+                "    def __init__(self, name):",
+                "        self.name = name",
+                "    def __enter__(self):",
+                "        log.push('enter:' + self.name)",
+                "        return self",
+                "    def __exit__(self):",
+                "        log.push('exit:' + self.name)",
+                "with (_CM('a') as a, _CM('b') as b):",
+                "    log.push('body')",
+                "assrt.equal(log[0], 'enter:a')",
+                "assrt.equal(log[1], 'enter:b')",
+                "assrt.equal(log[2], 'body')",
+                "assrt.equal(log[3], 'exit:b')",
+                "assrt.equal(log[4], 'exit:a')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_paren_with_multiline",
+        description: "parenthesized with: multi-line trailing-comma form compiles and runs in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "log = []",
+                "class _CM:",
+                "    def __init__(self, name):",
+                "        self.name = name",
+                "    def __enter__(self):",
+                "        log.push('enter:' + self.name)",
+                "        return self",
+                "    def __exit__(self):",
+                "        log.push('exit:' + self.name)",
+                "with (",
+                "    _CM('x') as x,",
+                "    _CM('y') as y,",
+                "):",
+                "    log.push('body')",
+                "assrt.equal(log[0], 'enter:x')",
+                "assrt.equal(log[1], 'enter:y')",
+                "assrt.equal(log[2], 'body')",
+                "assrt.equal(log[3], 'exit:y')",
+                "assrt.equal(log[4], 'exit:x')",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_paren_with_trailing_comma",
+        description: "parenthesized with: trailing comma accepted in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "class _CM:",
+                "    def __init__(self, val):",
+                "        self.val = val",
+                "    def __enter__(self):",
+                "        return self.val",
+                "    def __exit__(self):",
+                "        pass",
+                "with (_CM(7) as v,):",
+                "    assrt.equal(v, 7)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── statistics ───────────────────────────────────────────────────────────
+
+    {
+        name: "bundle_statistics_averages",
+        description: "statistics stdlib: averages and central location in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import mean, fmean, median, median_low, median_high",
+                "from statistics import mode, multimode, harmonic_mean, geometric_mean",
+                "assrt.equal(mean([1, 2, 3, 4]), 2.5)",
+                "assrt.equal(mean([1, 2, 3]), 2)",
+                "assrt.equal(fmean([1, 2, 3, 4]), 2.5)",
+                "assrt.equal(median([1, 3, 5]), 3)",
+                "assrt.equal(median([1, 3, 5, 7]), 4)",
+                "assrt.equal(median([5, 1, 3]), 3)",            // unsorted input
+                "assrt.equal(median_low([1, 3, 5, 7]), 3)",
+                "assrt.equal(median_high([1, 3, 5, 7]), 5)",
+                "assrt.equal(mode([1, 1, 2, 3, 3, 3]), 3)",
+                "assrt.equal(mode(['x', 'y', 'x']), 'x')",
+                "assrt.deepEqual(multimode([1, 1, 2, 2, 3]), [1, 2])",
+                "assrt.ok(Math.abs(harmonic_mean([40, 60]) - 48.0) < 1e-9)",
+                "assrt.ok(Math.abs(geometric_mean([2, 8]) - 4.0) < 1e-9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_statistics_spread",
+        description: "statistics stdlib: variance, stdev and quantiles in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import variance, pvariance, stdev, pstdev, quantiles",
+                "assrt.equal(variance([1, 2, 3, 4, 5]), 2.5)",
+                "assrt.equal(pvariance([1, 2, 3, 4, 5]), 2.0)",
+                "assrt.ok(Math.abs(stdev([1, 2, 3, 4, 5]) - Math.sqrt(2.5)) < 1e-9)",
+                "assrt.ok(Math.abs(pstdev([1, 2, 3, 4, 5]) - Math.sqrt(2.0)) < 1e-9)",
+                "assrt.deepEqual(quantiles([1, 2, 3, 4]), [1.25, 2.5, 3.75])",
+                "q = quantiles([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], n=10)",
+                "assrt.equal(q.length, 9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_statistics_relations",
+        description: "statistics stdlib: covariance, correlation, linear_regression in the bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import covariance, correlation, linear_regression",
+                "x = [1, 2, 3, 4, 5, 6, 7, 8, 9]",
+                "y = [1, 2, 3, 1, 2, 3, 1, 2, 3]",
+                "assrt.ok(Math.abs(covariance(x, y) - 0.75) < 1e-9)",
+                "assrt.ok(Math.abs(correlation(x, x) - 1.0) < 1e-9)",
+                "lr = linear_regression([1, 2, 3, 4, 5], [2, 4, 6, 8, 10])",
+                "assrt.ok(Math.abs(lr.slope - 2.0) < 1e-9)",
+                "assrt.ok(Math.abs(lr.intercept - 0.0) < 1e-9)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    {
+        name: "bundle_statistics_normaldist",
+        description: "statistics stdlib: NormalDist in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                "from statistics import NormalDist",
+                "nd = NormalDist(100, 15)",
+                "assrt.equal(nd.mean, 100)",
+                "assrt.equal(nd.stdev, 15)",
+                "assrt.equal(nd.variance, 225)",
+                "assrt.ok(Math.abs(nd.cdf(100) - 0.5) < 1e-6)",
+                "assrt.equal(nd.inv_cdf(0.5), 100)",
+                "assrt.equal(nd.zscore(115), 1.0)",
+                "fs = NormalDist.from_samples([1, 2, 3, 4, 5])",
+                "assrt.ok(Math.abs(fs.mean - 3.0) < 1e-9)",
+                // operator overloading dispatches to __add__
+                "combined = nd + NormalDist(50, 20)",
+                "assrt.equal(combined.mean, 150)",
+                "assrt.equal(combined.stdev, 25)",
+            ].join("\n"));
+            run_js(js);
+        },
+    },
+
+    // ── list sort: comparator detection + __lt__ dispatch ────────────────────
+
+    {
+        name: "bundle_sort_comparator_and_lt",
+        description: "list sort: positional comparator and __lt__ dispatch in the web-repl bundle",
+        run: function () {
+            var repl = RS.web_repl();
+            var js = bundle_compile(repl, [
+                // a positional two-argument function is treated as a comparator
+                "assrt.deepEqual(sorted([3, 1, 2, 10], def(x, y): return x - y;), [1, 2, 3, 10])",
+                "m = [5, 2, 8, 1]",
+                "m.sort(def(x, y): return y - x;)",
+                "assrt.deepEqual(m, [8, 5, 2, 1])",
+                // a one-argument function is still a key function
+                "assrt.deepEqual(sorted([3, 1, 2], key=def(x): return -x;), [3, 2, 1])",
+                // custom objects are ordered through their __lt__ method
+                "class Ord:",
+                "    def __init__(self, v):",
+                "        self.v = v",
+                "    def __lt__(self, other):",
+                "        return self.v < other.v",
+                "s = sorted([Ord(3), Ord(1), Ord(2)])",
+                "assrt.deepEqual([s[0].v, s[1].v, s[2].v], [1, 2, 3])",
+            ].join("\n"));
+            run_js(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"));
@@ -2245,12 +4625,20 @@ function run_tests(filter) {
         }
     });
 
+    var passed = tests.length - failures.length;
     console.log("");
     if (failures.length) {
-        console.log(colored(failures.length + " test(s) failed.", "red"));
-    } else {
-        console.log(colored("All " + tests.length + " web-repl tests passed!", "green"));
+        console.log(colored("Failed tests:", "red"));
+        failures.forEach(function (name) {
+            console.log(colored("  ✗ " + name, "red"));
+        });
+        console.log("");
     }
+    var summary = "web-repl tests — " +
+        colored("passed: " + passed, "green") + "  " +
+        (failures.length ? colored("failed: " + failures.length, "red") : colored("failed: 0", "green")) +
+        "  total: " + tests.length;
+    console.log(summary);
     process.exit(failures.length ? 1 : 0);
 }