rapydscript-ns 0.8.3 → 0.8.4

package/release/signatures.json

@@ -1,31 +1,33 @@
 {
-    "ast": "7a1a1800d9ee7af7f7153eee38002e4e9dcfb71e",
-    "baselib-builtins": "50927b38fded9bd9dbe14c42a20dd8e930ac021f",
-    "baselib-containers": "f7ac21a4dfc6311693239ea1eb45e74fae45a3f5",
-    "baselib-errors": "f2423e1e2489bdd7fb8c8725bb76436898c8008c",
-    "baselib-internal": "1b77d40970a8ef2d886132dc7c21c9510d2eb4cd",
-    "baselib-itertools": "ab1f3257642c8d26fab1ff9d392814a459a60cdb",
-    "baselib-str": "8c396e4fae02ae34b6d3d805becf7bfdd36625ee",
-    "compiler": "cfbfceb0439fed3302f78d80b303dca713b25e7b",
-    "errors": "d1b33848d19b141e19cc079cf78421f29b6d2c05",
-    "output/__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
-    "output/classes": "d05c1992cc91b337a4e4ff137b0aa3d626e6624b",
-    "output/codegen": "0519a88c2704fe60b98fe747ca39f6be43b9abf3",
-    "output/comments": "78ec38d8b34da96c078653e2d0d4049d7003906b",
-    "output/exceptions": "c7d90155694c7108e94d0940a160ae83725421d7",
-    "output/functions": "abaa81b171359eb77be6ea87cbdf9d7421d4622b",
-    "output/literals": "fdbfb744fec8dfea1e1c62cb49767c60160fd402",
-    "output/loops": "f59cc623320f57edb01953f7877d712758e9f825",
-    "output/modules": "bd3e3f3f6794fb6e401867b4d011c4e3aab98893",
-    "output/operators": "f8142836a13b75680cb4874391db9e871fad0cad",
-    "output/statements": "7d8dfdc0b43e3e430be7ce3b23ffaf1b41408d8c",
-    "output/stream": "46375cb467477ac898546e818bfdfa5be738c352",
-    "output/utils": "595968f96f6fdcc51eb41c34d64c92bb595e3cb1",
-    "parse": "d5c1a77662dfcff841dfcd368d5dbb129a592f5d",
-    "string_interpolation": "bff1cc76d772d24d35707f6c794f38734ca08376",
-    "tokenizer": "00fc24a41edac9f9b31735e6290348005a623cef",
-    "unicode_aliases": "79ac6eaa5e6be44a5397d62c561f854a8fe7528e",
-    "utils": "c1666db819aa7c8db38697e34e18362e3cb45869",
-    "#compiler#": "d98fcbb15d08dae74d9c7371ea28fea676642e67",
-    "#compiled_with#": "d98fcbb15d08dae74d9c7371ea28fea676642e67"
+    "ast": "c8f6f1be6f7f73b1b9e2bbf470f5e2e5fff879df",
+    "baselib-builtins": "ced189b19392b1f425a1a180b90bc61e5e1b022f",
+    "baselib-containers": "d2f534e6530dfb309b074bf7fac082c65779e778",
+    "baselib-errors": "a9e8c63e450360fd0bd70642d4c107672d395ccf",
+    "baselib-internal": "b020b5154a7ee023ceb5852bf35eeee31e285d87",
+    "baselib-itertools": "425f5c45bbd5de894cae891e71ba1a9e9e2063d5",
+    "baselib-str": "a00bdd267521d31d97cdc76581f955b6fafb4bae",
+    "compiler": "bb16e915c60dc4ffb5bfe98bef411736d19fa297",
+    "errors": "257eca38b6de987e5fd80672bec9b9981847e1bd",
+    "output\\classes": "a88c3c84ded9049d7a5052fb151d51bdbb600dcd",
+    "output\\codegen": "69151b2cd53ff8b3270a122c65e1a0f56735150e",
+    "output\\comments": "63b39620f9d6f407aa2d4ddb557d1c60ef296b05",
+    "output\\exceptions": "e7d9119550403e6c5730d40b9bc9c923a23d6eb7",
+    "output\\functions": "58972ccc4562ab3422317f79f68ea3e00b765279",
+    "output\\jsx": "14f32c048301965de7764c5b74b651bc279de937",
+    "output\\literals": "287ec4222c79f1ebfa2c6efae925e794cbb931ab",
+    "output\\loops": "93afeea09e81382edf1c2f6009f4811430d0ebb8",
+    "output\\modules": "15735b9b07260d11ba231fc3439818bd1a54947e",
+    "output\\operators": "d9ebb70a00cfe6be60c5d75596edf7986f619644",
+    "output\\statements": "94ee0cd084f22aea451b96eb1a9a831084cc4267",
+    "output\\stream": "2723d80bc398468e0828f50fb0837095c52f45dc",
+    "output\\treeshake": "4a490ba097739d924db9e3cd9eb7718db5e24cae",
+    "output\\utils": "e957919bfccb9a3ab510d824a8f2ee3fc2689795",
+    "output\\__init__": "da39a3ee5e6b4b0d3255bfef95601890afd80709",
+    "parse": "1815f278b2b974ed79973f792a4dbcccfb35c2b8",
+    "string_interpolation": "88dce6c2c5ee75126a6838a1506841c6531a0d15",
+    "tokenizer": "6c06a87951cc4cfe6256dfa4f22ab3533967e856",
+    "unicode_aliases": "7fbcbc9c24adcb2e33fac8d69aaafe5047fcc2c2",
+    "utils": "35a2a707c841da851e18c64edac54e7c20b7dfc9",
+    "#compiler#": "724970153770773cd9e1ff1e588f17df9c607ee9",
+    "#compiled_with#": "724970153770773cd9e1ff1e588f17df9c607ee9"
 }

package/session.vim

@@ -1,4 +1,4 @@
-set wildignore+=*.pyj-cached
-set wildignore+=node_modules
-imap <F4> ρσ_
-cmap <F4> ρσ_
+set wildignore+=*.pyj-cached
+set wildignore+=node_modules
+imap <F4> ρσ_
+cmap <F4> ρσ_

package/setup.cfg

@@ -1,2 +1,2 @@
-[rapydscript]
-globals=assert,RapydScript
+[rapydscript]
+globals=assert,RapydScript

package/src/ast.pyj

@@ -600,6 +600,9 @@ class AST_Class(AST_Scope):
         'statements': "[AST_Node*] list of statements in the class scope (excluding method definitions)",
         'dynamic_properties': '[dict] map of dynamic property names to property descriptors of the form {getter:AST_Method, setter:AST_Method',
         'classvars': '[dict] map containing all class variables as keys, to be used to easily test for existence of a class variable',
+        'has_new': "[boolean] true if the class defines a __new__ method",
+        'has_attr_dunders': "[boolean] true if the class defines any of __getattr__/__setattr__/__delattr__/__getattribute__",
+        'class_kwargs': "[array] keyword arguments from class header (e.g. class C(Base, key=val):) as [[key_node, value_node], ...]",
     }
 
     def _walk(self, visitor):
@@ -610,6 +613,9 @@ class AST_Class(AST_Scope):
             self.name._walk(visitor)
             walk_body(self, visitor)
             if (self.parent) self.parent._walk(visitor)
+            if self.class_kwargs:
+                for kw in self.class_kwargs:
+                    kw[1]._walk(visitor)
         )
 
 class AST_Method(AST_Lambda):
@@ -725,7 +731,8 @@ class AST_Except(AST_Block):
     "An `except` node for RapydScript, which resides inside the catch block"
     properties = {
         'argname': "[AST_SymbolCatch] symbol for the exception",
-        'errors': "[AST_SymbolVar*] error classes to catch in this block"
+        'errors': "[AST_SymbolVar*] error classes to catch in this block",
+        'is_star': '[bool] True for except* (exception group) clauses',
     }
 
     def _walk(self, visitor):
@@ -1161,6 +1168,17 @@ class AST_ObjectSpread(AST_Node):
             self.value._walk(visitor)
         )
 
+class AST_Spread(AST_Node):
+    "A *expr spread item inside a list or set literal: [1, *a, 2]"
+    properties = {
+        'expression': "[AST_Node] the expression being spread",
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
 class AST_Set(AST_Node):
     "A set literal"
     properties = {
@@ -1360,6 +1378,80 @@ class TreeWalker:
             self = p
 # }}}
 
+# JSX nodes {{{
+
+class AST_JSXElement(AST_Node):
+    "A JSX element like <div>...</div> or <Component />"
+    properties = {
+        'tag': "[string] The tag name (e.g. 'div', 'MyComponent')",
+        'props': "[AST_JSXAttribute[]] The props/attributes",
+        'children': "[AST_Node[]] The children",
+        'self_closing': "[bool] Whether self-closing (no children)"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            for prop in self.props:
+                prop._walk(visitor)
+            for child in self.children:
+                child._walk(visitor)
+        )
+
+class AST_JSXFragment(AST_Node):
+    "A JSX fragment <>...</>"
+    properties = {
+        'children': "[AST_Node[]] The children"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            for child in self.children:
+                child._walk(visitor)
+        )
+
+class AST_JSXAttribute(AST_Node):
+    "A JSX attribute like prop='val', prop={expr}, or just prop (boolean)"
+    properties = {
+        'name': "[string] The attribute name",
+        'value': "[AST_Node|null] The value (null for boolean attrs)"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            if self.value:
+                self.value._walk(visitor)
+        )
+
+class AST_JSXSpread(AST_Node):
+    "A JSX spread attribute {...expr}"
+    properties = {
+        'expression': "[AST_Node] The spread expression"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
+class AST_JSXText(AST_Node):
+    "Text content inside a JSX element"
+    properties = {
+        'value': "[string] The text content"
+    }
+
+class AST_JSXExprContainer(AST_Node):
+    "A JSX expression container {expr}"
+    properties = {
+        'expression': "[AST_Node] The expression"
+    }
+
+    def _walk(self, visitor):
+        return visitor._visit(self, def():
+            self.expression._walk(visitor)
+        )
+
+# }}}
+
 class Found(Exception):
     pass
 

package/src/baselib-builtins.pyj

@@ -20,6 +20,7 @@ def ρσ_bool(val):
     v'if ((typeof Set === "function" && val instanceof Set) || (typeof Map === "function" && val instanceof Map)) return val.size > 0'
     v'if (!val.constructor || val.constructor === Object) return Object.keys(val).length > 0'
     return True
+ρσ_bool.__name__ = 'bool'
 
 def ρσ_print(*args, **kwargs):
     if v'typeof console' is 'object':
@@ -35,6 +36,7 @@ def ρσ_int(val, base):
     if isNaN(ans):
         raise ValueError('Invalid literal for int with base ' + (base or 10) + ': ' + val)
     return ans
+ρσ_int.__name__ = 'int'
 
 def ρσ_float(val):
     if jstype(val) is "number":
@@ -44,6 +46,7 @@ def ρσ_float(val):
     if isNaN(ans):
         raise ValueError('Could not convert string to float: ' + arguments[0])
     return ans
+ρσ_float.__name__ = 'float'
 
 def ρσ_arraylike_creator():
     names = 'Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array'.split(' ')
@@ -282,6 +285,23 @@ def ρσ_hasattr(obj, name):
 def ρσ_get_module(name):
     return ρσ_modules[name]
 
+def ρσ__import__(name, globals, locals, fromlist, level):
+    # Return the module from the already-compiled ρσ_modules registry.
+    # Like Python: without fromlist (or empty fromlist) returns the top-level
+    # package; with a non-empty fromlist returns the named (possibly dotted) module.
+    # NOTE: the module must have been statically imported elsewhere in the source;
+    # __import__ only provides a runtime reference to an already-compiled module.
+    if v'typeof ρσ_modules' is 'undefined':
+        raise ImportError('No module named \'' + name + '\'')
+    if fromlist is not undefined and fromlist is not None and fromlist.length:
+        lookup = name
+    else:
+        lookup = name.split('.')[0]
+    module = ρσ_modules[lookup]
+    if module is undefined:
+        raise ModuleNotFoundError('No module named \'' + lookup + '\'')
+    return module
+
 def ρσ_pow(x, y, z):
     ans = Math.pow(x, y)
     if z is not undefined:
@@ -322,6 +342,7 @@ def ρσ_hash(obj):
         }
         return ρσ_h;
     }'''
+    v'if (obj.__hash__ === null) throw new TypeError("unhashable type: \'" + (obj.constructor && obj.constructor.name ? obj.constructor.name : "object") + "\'")'
     v'if (typeof obj.__hash__ === "function") return obj.__hash__()'
     v'if (Array.isArray(obj)) throw new TypeError("unhashable type: \'list\'")'
     v'if (typeof ρσ_set === "function" && obj instanceof ρσ_set) throw new TypeError("unhashable type: \'set\'")'
@@ -440,7 +461,7 @@ class ρσ_slice:
 
 v'var abs = Math.abs, max = ρσ_max.bind(Math.max), min = ρσ_max.bind(Math.min), bool = ρσ_bool, type = ρσ_type'
 v'var float = ρσ_float, int = ρσ_int, arraylike = ρσ_arraylike_creator(), ρσ_arraylike = arraylike'
-v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod'
+v'var id = ρσ_id, get_module = ρσ_get_module, pow = ρσ_pow, divmod = ρσ_divmod, __import__ = ρσ__import__'
 v'var dir = ρσ_dir, ord = ρσ_ord, chr = ρσ_chr, bin = ρσ_bin, hex = ρσ_hex, callable = ρσ_callable, round = ρσ_round'
 v'var enumerate = ρσ_enumerate, iter = ρσ_iter, reversed = ρσ_reversed, len = ρσ_len'
 v'var range = ρσ_range, getattr = ρσ_getattr, setattr = ρσ_setattr, hasattr = ρσ_hasattr, issubclass = ρσ_issubclass, hash = ρσ_hash, next = ρσ_next'

package/src/baselib-containers.pyj

@@ -243,6 +243,26 @@ def sorted(iterable, key=None, reverse=False):
     return ans
 # }}}
 
+# tuple {{{
+def ρσ_tuple_constructor(iterable):
+    if iterable is undefined:
+        return v'[]'
+    if ρσ_arraylike(iterable):
+        return Array.prototype.slice.call(iterable)
+    if jstype(iterable[ρσ_iterator_symbol]) is 'function':
+        iterator = iterable.keys() if jstype(Map) is 'function' and v'iterable instanceof Map' else iterable[ρσ_iterator_symbol]()
+        ans = []
+        result = iterator.next()
+        while not result.done:
+            ans.push(result.value)
+            result = iterator.next()
+        return ans
+    return Object.keys(iterable)
+
+ρσ_tuple_constructor.__name__ = 'tuple'
+v'var tuple = ρσ_tuple_constructor'
+# }}}
+
 # set {{{
 v'var ρσ_global_object_id = 0, ρσ_set_implementation'
 
@@ -698,6 +718,12 @@ def ρσ_dict_polyfill():
         return v"{'done':false, 'value':this._s[this._keys[this._i]]}"
     return ans
 
+ρσ_dict_polyfill.prototype.forEach = def(callback):
+    keys = Object.keys(this._store)
+    for v'var ρσ_fi = 0; ρσ_fi < keys.length; ρσ_fi++':
+        entry = this._store[keys[v'ρσ_fi']]
+        callback(entry[1], entry[0], this)
+
 if jstype(Map) is not 'function' or jstype(Map.prototype.delete) is not 'function':
     v'ρσ_dict_implementation = ρσ_dict_polyfill'
 else:
@@ -862,6 +888,15 @@ Object.defineProperties(ρσ_dict.prototype, {
         r = iterator.next()
     return ans
 
+ρσ_dict.prototype.toJSON = def():
+    ans = {}
+    iterator = this.jsmap.entries()
+    r = iterator.next()
+    while not r.done:
+        ans[r.value[0]] = r.value[1]
+        r = iterator.next()
+    return ans
+
 def ρσ_dict_wrap(x):
     ans = new ρσ_dict()
     ans.jsmap = x
@@ -869,4 +904,68 @@ def ρσ_dict_wrap(x):
 
 v'var dict = ρσ_dict, dict_wrap = ρσ_dict_wrap'
 
+v'''
+function ρσ_kwargs_to_dict(kw) {
+    // Augment the plain kwargs object with non-enumerable Python dict methods so
+    // that kw.items(), kw.keys(), kw.values() work in user code, while plain
+    // property access (kw.propname) and Object.keys(kw) are unaffected.
+    //
+    // items/keys/values return dual-mode arrays: they support both Array indexing
+    // (for ρσ_dict.prototype.update which does pairs[i]) and iterator protocol
+    // (for `for k, v in kw.items():` which calls .next()).
+    function _make_seq(arr) {
+        arr._ρσ_i = 0;
+        arr.next = function() {
+            return this._ρσ_i < this.length
+                ? {done: false, value: this[this._ρσ_i++]}
+                : {done: true, value: undefined};
+        };
+        arr[ρσ_iterator_symbol] = function() { this._ρσ_i = 0; return this; };
+        return arr;
+    }
+    function _def(name, fn) {
+        if (!Object.prototype.hasOwnProperty.call(kw, name)) {
+            Object.defineProperty(kw, name, {value: fn, configurable: true, writable: true, enumerable: false});
+        }
+    }
+    _def("items", function() {
+        var ks = Object.keys(kw), arr = [], i;
+        for (i = 0; i < ks.length; i++) arr.push([ks[i], kw[ks[i]]]);
+        return _make_seq(arr);
+    });
+    _def("entries", kw.items);
+    _def("keys", function() {
+        return _make_seq(Object.keys(kw).slice());
+    });
+    _def("values", function() {
+        var ks = Object.keys(kw), arr = [], i;
+        for (i = 0; i < ks.length; i++) arr.push(kw[ks[i]]);
+        return _make_seq(arr);
+    });
+    _def("get", function(k, d) {
+        return Object.prototype.hasOwnProperty.call(kw, k) ? kw[k] : (d !== undefined ? d : null);
+    });
+    _def("__contains__", function(k) { return Object.prototype.hasOwnProperty.call(kw, k); });
+    _def("has", function(k) { return Object.prototype.hasOwnProperty.call(kw, k); });
+    _def("__len__", function() { return Object.keys(kw).length; });
+    kw[ρσ_iterator_symbol] = function() {
+        var ks = Object.keys(kw), i = 0;
+        return {next: function() {
+            return i < ks.length ? {done: false, value: ks[i++]} : {done: true, value: undefined};
+        }};
+    };
+    return kw;
+}
+'''
+
+v"""var ρσ_json_parse = function(text, reviver) {
+    function dict_reviver(key, value) {
+        if (value !== null && typeof value === "object" && !Array.isArray(value) && !(value instanceof ρσ_dict)) {
+            value = ρσ_dict(value);
+        }
+        return reviver ? reviver.call(this, key, value) : value;
+    }
+    return JSON.parse(text, dict_reviver);
+};"""
+
 # }}}

package/src/baselib-errors.pyj

@@ -38,3 +38,47 @@ class ZeroDivisionError(Exception):
 
 class StopIteration(Exception):
     pass
+
+class ImportError(Exception):
+    pass
+
+class ModuleNotFoundError(ImportError):
+    pass
+
+def _is_exc_class(obj):
+    # True when obj is an Error subclass (or Error itself), not a plain predicate function
+    return jstype(obj) is 'function' and (obj is Error or (obj.prototype and isinstance(obj.prototype, Error)))
+
+
+class ExceptionGroup(Exception):
+
+    def __init__(self, message, exceptions):
+        Exception.__init__(self, message)
+        self.exceptions = exceptions if exceptions else []
+
+    def subgroup(self, condition):
+        if _is_exc_class(condition):
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+        elif callable(condition):
+            matched = [e for e in self.exceptions if condition(e)]
+        else:
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+        return ExceptionGroup(self.message, matched) if matched else None
+
+    def split(self, condition):
+        if _is_exc_class(condition):
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+            rest = [e for e in self.exceptions if not isinstance(e, condition)]
+        elif callable(condition):
+            matched = [e for e in self.exceptions if condition(e)]
+            rest = [e for e in self.exceptions if not condition(e)]
+        else:
+            matched = [e for e in self.exceptions if isinstance(e, condition)]
+            rest = [e for e in self.exceptions if not isinstance(e, condition)]
+        return [
+            ExceptionGroup(self.message, matched) if matched else None,
+            ExceptionGroup(self.message, rest) if rest else None
+        ]
+
+    def __repr__(self):
+        return 'ExceptionGroup(' + repr(self.message) + ', ' + repr(self.exceptions) + ')'

package/src/baselib-internal.pyj

@@ -87,6 +87,14 @@ def ρσ_extends(child, parent):
     child.prototype.constructor = child
     Object.setPrototypeOf(child, parent)
 
+def ρσ_object_new(cls):
+    return v'Object.create(cls.prototype)'
+
+def ρσ_new(parent, cls):
+    if parent and jstype(parent.__new__) is 'function':
+        return parent.__new__.apply(parent, v'Array.prototype.slice.call(arguments, 1)')
+    return v'Object.create(cls.prototype)'
+
 ρσ_in = (def ():
     if jstype(Map) is 'function' and jstype(Set) is 'function':
         return def(val, arr):
@@ -131,15 +139,23 @@ def ρσ_Iterable(iterable):
             ans = Object.create(None)
             ans[ρσ_kwargs_symbol] = True
             for v'var i = 0; i < arguments.length; i++':
-                Object.assign(ans, arguments[i])
+                arg = arguments[i]
+                if v'arg && arg.jsmap && typeof arg.jsmap.forEach === "function"':
+                    v'arg.jsmap.forEach(function(v, k) { ans[k] = v; })'
+                else:
+                    Object.assign(ans, arg)
             return ans
     return def():
         ans = Object.create(None)
         ans[ρσ_kwargs_symbol] = True
         for v'var i = 0; i < arguments.length; i++':
-            keys = Object.keys(arguments[i])
-            for v'var j = 0; j < keys.length; j++':
-                ans[keys[j]] = arguments[i][keys[j]]
+            arg = arguments[i]
+            if v'arg && arg.jsmap && typeof arg.jsmap.forEach === "function"':
+                v'arg.jsmap.forEach(function(v, k) { ans[k] = v; })'
+            else:
+                keys = Object.keys(arg)
+                for v'var j = 0; j < keys.length; j++':
+                    ans[keys[j]] = arg[keys[j]]
         return ans
 )()
 
@@ -177,6 +193,8 @@ def ρσ_interpolate_kwargs_constructor(apply, f, supplied_args):
     return this
 
 def ρσ_getitem(obj, key):
+    if v'typeof obj === "function"' and obj.__class_getitem__:
+        return obj.__class_getitem__(key)
     if obj.__getitem__:
         return obj.__getitem__(key)
     if v'typeof ρσ_slice !== "undefined" && key instanceof ρσ_slice':
@@ -458,3 +476,75 @@ def ρσ_instanceof():
                         break
                     cls = p.constructor
     return False
+
+# ── Attribute-dunder support (__getattr__ / __setattr__ / __delattr__ / __getattribute__) ──
+# We use a JavaScript Proxy to intercept attribute access/assignment/deletion on class instances
+# that define any of the four attribute dunders.
+
+# Cache the JS Proxy constructor with a ρσ_ name to avoid collisions with user-defined 'Proxy' classes.
+ρσ_JS_Proxy = v'typeof Proxy === "function" ? Proxy : null'
+
+# Symbol (or fallback string key) used to retrieve the raw underlying target from a wrapped proxy.
+ρσ_proxy_target_symbol = v'typeof Symbol === "function" ? Symbol("ρσ_proxy_target") : "__ρσ_proxy_target__"'
+
+ρσ_attr_proxy_handler = {
+    'get': def(target, prop, receiver):
+        # Always expose the raw target via the sentinel key (used by ρσ_object_* helpers).
+        if prop is ρσ_proxy_target_symbol:
+            return target
+        # Pass through JS symbols (Symbol.iterator, Symbol.toPrimitive, etc.) unchanged.
+        if jstype(prop) is 'symbol':
+            return v'Reflect.get(target, prop, receiver)'
+        # __getattribute__ overrides every attribute lookup (except itself, to avoid infinite recursion).
+        if jstype(target.__getattribute__) is 'function' and prop is not '__getattribute__':
+            try:
+                return target.__getattribute__.call(receiver, prop)
+            except AttributeError:
+                # AttributeError from __getattribute__ → try __getattr__ fallback.
+                if jstype(target.__getattr__) is 'function':
+                    return target.__getattr__.call(receiver, prop)
+                raise
+        # Normal property lookup via prototype chain.
+        val = v'Reflect.get(target, prop, receiver)'
+        # __getattr__ is only called when the attribute is genuinely missing.
+        if val is undefined and jstype(target.__getattr__) is 'function' and not v'(prop in target)':
+            return target.__getattr__.call(receiver, prop)
+        return val
+    ,
+    'set': def(target, prop, value, receiver):
+        if jstype(target.__setattr__) is 'function':
+            target.__setattr__.call(receiver, prop, value)
+            return True
+        # Pass 'target' as receiver (not proxy) to avoid infinite recursion through the Proxy set trap.
+        return v'Reflect.set(target, prop, value, target)'
+    ,
+    'deleteProperty': def(target, prop):
+        if jstype(target.__delattr__) is 'function':
+            # deleteProperty has no receiver; pass target as 'this'.
+            # Inside __delattr__, use ρσ_object_delattr(self, name) for a direct delete.
+            target.__delattr__.call(target, prop)
+            return True
+        return v'Reflect.deleteProperty(target, prop)'
+}
+
+def ρσ_object_setattr(obj, name, value):
+    # Bypass __setattr__ and set directly on the underlying object.
+    # Use this inside __setattr__ to avoid infinite recursion (like object.__setattr__ in Python).
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    v'target[name] = value'
+
+def ρσ_object_getattr(obj, name):
+    # Bypass __getattribute__ and read directly from the underlying object.
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    return target[name]
+
+def ρσ_object_delattr(obj, name):
+    # Bypass __delattr__ and delete directly from the underlying object.
+    target = obj[ρσ_proxy_target_symbol]
+    if target is undefined:
+        target = obj
+    v'delete target[name]'