rapydscript-ns 0.8.3 → 0.8.4

package/.agignore

@@ -1 +1 @@
-lib/*
+lib/*

package/.github/workflows/ci.yml

@@ -1,38 +1,38 @@
-name: CI
-on: [push, pull_request]
-env:
-    CI: 'true'
-
-jobs:
-    test:
-        name: Test on ${{ matrix.os }} LANG ${{ matrix.lang }}
-        runs-on: ${{ matrix.os }}
-        env:
-          LANG: ${{ matrix.lang }}
-          LC_ALL: ${{ matrix.lang }}
-        strategy:
-            matrix:
-                include:
-                    - { os: ubuntu-latest, lang: en_US.UTF-8 }
-                    - { os: ubuntu-latest, lang: de_DE.UTF-8}
-                    - { os: ubuntu-latest, lang: hi_IN.UTF-8 }
-
-                    - { os: macos-latest, lang: en_US.UTF-8 }
-                    - { os: windows-latest, lang: en_US.UTF-8 }
-
-        steps:
-            - name: Checkout source code
-              uses: actions/checkout@master
-              with:
-                fetch-depth: 10
-
-            - name: Set up Node ${{ matrix.node }}
-              uses: actions/setup-node@master
-
-            - name: Install deps
-              run:
-                npm install --no-optional
-
-            - name: Test
-              run:
-                npm test
+name: CI
+on: [push, pull_request]
+env:
+    CI: 'true'
+
+jobs:
+    test:
+        name: Test on ${{ matrix.os }} LANG ${{ matrix.lang }}
+        runs-on: ${{ matrix.os }}
+        env:
+          LANG: ${{ matrix.lang }}
+          LC_ALL: ${{ matrix.lang }}
+        strategy:
+            matrix:
+                include:
+                    - { os: ubuntu-latest, lang: en_US.UTF-8 }
+                    - { os: ubuntu-latest, lang: de_DE.UTF-8}
+                    - { os: ubuntu-latest, lang: hi_IN.UTF-8 }
+
+                    - { os: macos-latest, lang: en_US.UTF-8 }
+                    - { os: windows-latest, lang: en_US.UTF-8 }
+
+        steps:
+            - name: Checkout source code
+              uses: actions/checkout@master
+              with:
+                fetch-depth: 10
+
+            - name: Set up Node ${{ matrix.node }}
+              uses: actions/setup-node@master
+
+            - name: Install deps
+              run:
+                npm install --no-optional
+
+            - name: Test
+              run:
+                npm test

package/=template.pyj

@@ -1,5 +1,5 @@
-# vim:fileencoding=utf-8
-# License: BSD Copyright: %YEAR%, %USER% <%MAIL%>
-from __python__ import hash_literals
-
-%HERE%
+# vim:fileencoding=utf-8
+# License: BSD Copyright: %YEAR%, %USER% <%MAIL%>
+from __python__ import hash_literals
+
+%HERE%

package/CHANGELOG.md

@@ -1,3 +1,11 @@
+version 0.8.4
+=======================
+  * Added support for jsx
+  * Added support for basic React components
+  * support for __new__, __getattr__, __setattr__, __delattr__, __class_getitem__, __init_subclass__
+  * added `copy` standard library
+
+
 version 0.8.0 - 0.8.3
 =======================
 

package/HACKING.md

@@ -1,103 +1,103 @@
-Hacking the RapydScript compiler
-=================================
-
-The RapydScript compiler is written in RapydScript itself and uses the
-RapydScript import system to modularize its code. The compiler source code is
-in the `src` directory. The compiled compiler is by default in the `release`
-directory. 
-
-In order to start hacking on the compiler, run the command
-
-```
-bin/rapydscript self --complete --test
-```
-
-This will generate a build of the compiler in the `dev` directory. Now, the
-rapydscript command will automatically use this build, rather than the one in
-release. If you want to go back to the release build, simply delete the `dev`
-directory.
-
-
-Code organization
--------------------
-
-The way the compiler works, given some RapydScript source code:
-
-* The source code is lexed into a stream of tokens (`src/tokenzier.pyj`)
-
-* The tokens are parsed into a Abstract Syntax Tree (`src/parse.pyj and src/ast.pyj`)
-
-* During parsing any import statement are resolved (this is different from
-  python, where imports happen at run-time, not compile time).
-
-* The Abstract Syntax Tree is transformed into the output JavaScript (`src/output/*.pyj`)
-
-* Various bits of functionality in RapydScript depend upon the *Base Library*
-  (`src/baselib*.pyj`). This includes things like the basic container types
-  (list/set/dict) string functions such as `str.format()`, etc. The baselib
-  is automatically inserted into the start of the output JavaScript.
-
-The RapydScript standard library can be found in `src/lib`. The various tools,
-such as the linter, gettext support, the REPL, etc. are in the `tools`
-directory.
-
-Tests
---------
-
-The tests are in the test directory and can be run using the command:
-```
-rapydscript test
-```
-
-You can run individual test files by providing the name of the file, as
-
-```
-rapydscript test classes
-```
-
-Modifying the compiler
--------------------------
-
-Edit the files in the `src` directory to make your changes, then use the
-`./try` script to test them.  This script will compile an updated version of
-the compiler with your changes, if any, and use it to run the snippet of code
-you pass to it.
-
-For example:
-
-```
-./try 'print("Hello world")'
-```
-
-will compile `print ("Hello world")` and show you the output on stdout. You can
-tell it to omit the baselib, so you can focus on the output, with the `-m`
-switch, like this:
-
-```
-./try -m 'print("Hello world")'
-```
-
-You can also have it not print out the JavaScript, instead directly executing the output
-JavaScript with the `-x` switch, like this
-
-```
-./try -x 'print("Hello world")'
-```
-
-If you want to test longer sections of code, you can use the `-f` switch to
-pass in the path to a RapydScript file to compile, like this:
-
-```
-./try -f myfile.pyj
-```
-
-Once you are happy with your changes, you can build the compiler and run the
-test suite, all with a single command:
-
-```
-./build
-```
-
-This will build the compiler with the updated version of itself and then run
-the test suite. If all test pass you can commit your changes and send a pull
-request :)
+Hacking the RapydScript compiler
+=================================
+
+The RapydScript compiler is written in RapydScript itself and uses the
+RapydScript import system to modularize its code. The compiler source code is
+in the `src` directory. The compiled compiler is by default in the `release`
+directory. 
+
+In order to start hacking on the compiler, run the command
+
+```
+bin/rapydscript self --complete --test
+```
+
+This will generate a build of the compiler in the `dev` directory. Now, the
+rapydscript command will automatically use this build, rather than the one in
+release. If you want to go back to the release build, simply delete the `dev`
+directory.
+
+
+Code organization
+-------------------
+
+The way the compiler works, given some RapydScript source code:
+
+* The source code is lexed into a stream of tokens (`src/tokenzier.pyj`)
+
+* The tokens are parsed into a Abstract Syntax Tree (`src/parse.pyj and src/ast.pyj`)
+
+* During parsing any import statement are resolved (this is different from
+  python, where imports happen at run-time, not compile time).
+
+* The Abstract Syntax Tree is transformed into the output JavaScript (`src/output/*.pyj`)
+
+* Various bits of functionality in RapydScript depend upon the *Base Library*
+  (`src/baselib*.pyj`). This includes things like the basic container types
+  (list/set/dict) string functions such as `str.format()`, etc. The baselib
+  is automatically inserted into the start of the output JavaScript.
+
+The RapydScript standard library can be found in `src/lib`. The various tools,
+such as the linter, gettext support, the REPL, etc. are in the `tools`
+directory.
+
+Tests
+--------
+
+The tests are in the test directory and can be run using the command:
+```
+rapydscript test
+```
+
+You can run individual test files by providing the name of the file, as
+
+```
+rapydscript test classes
+```
+
+Modifying the compiler
+-------------------------
+
+Edit the files in the `src` directory to make your changes, then use the
+`./try` script to test them.  This script will compile an updated version of
+the compiler with your changes, if any, and use it to run the snippet of code
+you pass to it.
+
+For example:
+
+```
+./try 'print("Hello world")'
+```
+
+will compile `print ("Hello world")` and show you the output on stdout. You can
+tell it to omit the baselib, so you can focus on the output, with the `-m`
+switch, like this:
+
+```
+./try -m 'print("Hello world")'
+```
+
+You can also have it not print out the JavaScript, instead directly executing the output
+JavaScript with the `-x` switch, like this
+
+```
+./try -x 'print("Hello world")'
+```
+
+If you want to test longer sections of code, you can use the `-f` switch to
+pass in the path to a RapydScript file to compile, like this:
+
+```
+./try -f myfile.pyj
+```
+
+Once you are happy with your changes, you can build the compiler and run the
+test suite, all with a single command:
+
+```
+./build
+```
+
+This will build the compiler with the updated version of itself and then run
+the test suite. If all test pass you can commit your changes and send a pull
+request :)

package/LICENSE

@@ -1,24 +1,24 @@
-Copyright (c) 2015-, Kovid Goyal <kovid@kovidgoyal.net>
-Copyright (c) 2013-2014, Alexander Tsepkov <atsepkov@pyjeon.com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+Copyright (c) 2015-, Kovid Goyal <kovid@kovidgoyal.net>
+Copyright (c) 2013-2014, Alexander Tsepkov <atsepkov@pyjeon.com>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/PYTHON_DIFFERENCES_REPORT.md

@@ -47,12 +47,12 @@ and notes which items are covered by tests.
 | 35 | `complex()` / `j` suffix | No complex number type | ✓ Yes | Noted in python_features.pyj #42, #59 (skipped) |
 | 36 | `b'...'` bytes literals | No bytes type; use `encodings` module | ✓ Yes | Noted in python_features.pyj #43 (skipped) |
 | 37 | `except*` (exception groups) | Not supported (Python 3.11+) | ✓ Yes | Noted in python_features.pyj #44 (skipped) |
-| 38 | `__new__` constructor hook | Not supported | ✓ Yes | Noted in python_features.pyj #45 (skipped) |
+| 38 | `__new__` constructor hook | Supported — `def __new__(cls, ...)` with `super().__new__(cls)` | ✓ Yes | Now supported; see unit tests `new_basic`, `new_singleton`, etc. |
 | 39 | `__del__` destructor | Not supported | ✓ Yes | Noted in python_features.pyj #46 (skipped) |
 | 40 | `__hash__` for set/dict membership | Not dispatched; uses JS identity (`===`) | ✓ Yes | Noted in python_features.pyj #47 (skipped) |
 | 41 | `__getattr__`/`__setattr__`/`__delattr__` | Not supported | ✓ Yes | Noted in python_features.pyj #48 (skipped) |
 | 42 | `__getattribute__` | Not supported | ✓ Yes | Noted in python_features.pyj #49 |
-| 43 | `__class_getitem__` | Not supported | ✓ Yes | Noted in python_features.pyj #51 (skipped) |
+| 43 | `__class_getitem__` | Supported — `Class[item]` compiles to `Class.__class_getitem__(item)` at compile time; implicit classmethod, subclasses inherit with correct `cls` | ✓ Yes | Now supported; see unit tests `class_getitem_*` |
 | 44 | `__init_subclass__` | Not supported | ✓ Yes | Noted in python_features.pyj #52 (skipped) |
 
 ---

package/PYTHON_FEATURE_COVERAGE.md

@@ -7,6 +7,7 @@
 | `super()` — 0-arg and 2-arg forms | `super().method()` and `super(Cls, self).method()` both work |
 | `except TypeA, TypeB as e:` | RapydScript comma-separated form; catches multiple exception types |
 | `except (TypeA, TypeError) as e:` | Tuple form also supported |
+| `except*` / `ExceptionGroup` (Python 3.11+) | Full support: `ExceptionGroup` class with `subgroup()`/`split()`; `except*` dispatches to typed handlers, re-raises unmatched; bare `except*:` catches all remaining |
 | `try / else` | `else` block runs only when no exception was raised |
 | `for / else` | `else` block runs when loop completes without `break`; nested break isolation works |
 | `while / else` | `else` block runs when loop condition becomes `False` without a `break`; nested `break` isolation correct |
@@ -22,6 +23,7 @@
 | `str.casefold()` | Maps to `.toLowerCase()` |
 | `str.removeprefix(prefix)` | Returns unchanged string if prefix not found |
 | `str.removesuffix(suffix)` | Returns unchanged string if suffix not found |
+| `str.expandtabs(tabsize=8)` | Replaces `\t` with spaces to the next tab stop; `\n`/`\r` reset the column counter; `tabsize=0` removes all tabs; available as an instance method after `from pythonize import strings; strings()` |
 | `str * n` string repetition | Works when `from __python__ import overload_operators` is active |
 | `list * n` / `n * list` | Works with `overload_operators`; returns a proper RapydScript list |
 | `list + list` concatenation | `[1,2] + [3,4]` returns `[1, 2, 3, 4]`; `+=` extends in-place. No flag required. |
@@ -34,6 +36,9 @@
 | `+=`, `-=`, `*=`, `/=`, `//=`, `**=`, `%=`, `&=`, `\|=`, `^=`, `<<=`, `>>=` | All augmented assignments work |
 | `raise X from Y` exception chaining | Sets `__cause__` on the thrown exception; `from None` also supported |
 | Starred assignment `a, *b, c = ...` | Works |
+| `[*a, 1, *b]` list spread | Works; any iterable; translates to `[...a, 1, ...b]` |
+| `{*a, 1, *b}` set spread | Works; translates to `ρσ_set([...a, 1, ...b])` |
+| `**expr` in function calls | Works with any expression (variable, attr access, call, dict literal), not just plain names |
 | `@classmethod`, `@staticmethod`, `@property` / `@prop.setter` | All work |
 | `{**dict1, **dict2}` dict spread | Works as merge replacement for the missing `\|` operator |
 | `dict.fromkeys()` | Works with `dict_literals` flag |
@@ -59,12 +64,17 @@
 | **Truthiness / `__bool__`** | Full Python truthiness via `from __python__ import truthiness`: empty `[]`, `{}`, `set()`, `''` are falsy; `__bool__` is dispatched; `and`/`or` return operand values; `not`, `if`, `while`, `assert`, ternary all use `ρσ_bool()`. |
 | `frozenset(iterable)` | Immutable set: construction from list/set/iterable; `in`, `len()`, iteration, `copy()`, `union()`, `intersection()`, `difference()`, `symmetric_difference()`, `issubset()`, `issuperset()`, `isdisjoint()` — all return `frozenset`. `isinstance(x, frozenset)` works. Compares equal to a `set` with the same elements via `__eq__`. No mutation methods (`add`, `remove`, etc.). |
 | `issubclass(cls, classinfo)` | Checks prototype chain; `classinfo` may be a class or tuple of classes; every class is a subclass of itself; raises `TypeError` for non-class arguments. |
-| `hash(obj)` | Numbers hash by value (int identity, float → int form if whole); strings use djb2; `None` → 0; booleans → 0/1; objects with `__hash__` dispatch to it; class instances get a stable identity hash; `list`, `set`, `dict` raise `TypeError`. |
+| `hash(obj)` and `__hash__` dunder | Numbers hash by value (int identity, float → int form if whole); strings use djb2; `None` → 0; booleans → 0/1; `def __hash__(self)` in a class is dispatched by `hash()`; class instances without `__hash__` get a stable identity hash; defining `__eq__` without `__hash__` makes the class unhashable (Python semantics — `hash()` raises `TypeError`); `list`, `set`, `dict` raise `TypeError`. |
+| `__getattr__` / `__setattr__` / `__delattr__` / `__getattribute__` dunders | Full attribute-access interception via JS `Proxy`. Classes defining any of these automatically wrap instances. `__getattr__` is called only for missing attributes; `__getattribute__` overrides all lookups; `__setattr__` intercepts every assignment (including those in `__init__`); `__delattr__` intercepts `del obj.attr`. Use `object.__setattr__(self, name, value)` / `object.__getattribute__(self, name)` / `object.__delattr__(self, name)` (compiled to `ρσ_object_setattr` / `ρσ_object_getattr` / `ρσ_object_delattr`) to bypass the hooks and avoid infinite recursion. Subclasses automatically inherit proxy wrapping. Requires a JS environment that supports `Proxy`; gracefully degrades to plain attribute access in environments without `Proxy`. |
+| `__class_getitem__` dunder | `Class[item]` dispatches at compile time to `Class.__class_getitem__(item)`. Behaves as an implicit `@classmethod`: `cls` is bound to the calling class. Subclasses inherit `__class_getitem__` and receive the subclass as `cls`. Multi-argument subscripts (`Class[A, B]`) are passed as a JS array. |
+| `__init_subclass__` hook | Called automatically on the parent class whenever a subclass is created (e.g. `class Child(Base):`). Implicit `@classmethod`: `cls` receives the new subclass. Keyword arguments in the class header (`class Child(Base, tag='x'):`) are forwarded to `__init_subclass__` as keyword arguments. `super().__init_subclass__(**kwargs)` propagates up the hierarchy. No explicit call needed — the compiler emits it after inheritance setup and identity properties are assigned. |
 | `next(iterator[, default])` | Advances a JS-protocol iterator (`{done, value}`); returns `default` when exhausted if provided, otherwise raises `StopIteration`. Works with `iter()`, `range()`, `enumerate()`, generators, and any object with a `.next()` or `__next__()` method. |
 | `StopIteration` exception | Defined as a builtin exception class; raised by `next()` when an iterator is exhausted and no default is given. |
 | `iter(callable, sentinel)` | Two-argument form calls `callable` (no args) repeatedly until the return value equals `sentinel` (strict `===`). Returns a lazy iterator compatible with `for` loops, `next()`, `list()`, and all iterator consumers. Works with plain functions and callable objects (`__call__`). |
 | `dict \| dict` and `dict \|= dict` (Python 3.9+) | Dict merge via `\|` creates a new merged dict (right-side values win); `\|=` updates in-place. Requires `from __python__ import overload_operators, dict_literals`. |
 | `slice(start, stop[, step])` | Full Python `slice` class: 1-, 2-, and 3-argument forms; `.start`, `.stop`, `.step` attributes; `.indices(length)` → `(start, stop, step)`; `str()` / `repr()`; `isinstance(s, slice)`; equality `==`; use as subscript `lst[s]` (read, write, `del`) all work. |
+| `__import__(name[, globals, locals, fromlist, level])` | Runtime lookup in the compiled module registry (`ρσ_modules`). Without `fromlist` (or empty `fromlist`) returns the top-level package, matching Python's semantics. `ImportError` / `ModuleNotFoundError` raised for unknown modules. **Constraint**: the module must have been statically imported elsewhere in the source so it is present in `ρσ_modules`. |
+| `ImportError`, `ModuleNotFoundError` | Both defined as runtime exception classes; `ModuleNotFoundError` is a subclass of `ImportError` (same as Python 3.6+). |
 
 ---
 
@@ -72,18 +82,16 @@
 
 | Feature                             | Priority                                                               |
 |-------------------------------------|------------------------------------------------------------------------|
-| `complex(real, imag)`               | 🟢 Low — no complex number type                                        |
 | `vars()` / `locals()` / `globals()` | 🟢 Low — not defined; use direct attribute access                      |
-| `str.expandtabs(tabsize)`           | 🟢 Low                                                                 |
 | `int.bit_length()`                  | 🟢 Low — useful for bit manipulation                                   |
 | `float.is_integer()`                | 🟢 Low                                                                 |
 | `exec(code)`                        | 🟢 Low — use `v'eval(...)'` for inline JS evaluation                  |
 | `eval(expr)`                        | 🟢 Low — use `v'eval(...)'` for inline JS evaluation                  |
-| `__import__(name)`                  | 🟢 Low — not supported; use `import` statement                        |
 | `input(prompt)`                     | 🟢 Low — not built in; use `prompt()` via `v'prompt(...)'`            |
 | `bytes(x)` / `bytearray(x)`        | 🟢 Low — no built-in bytes type; use `Uint8Array` via verbatim JS     |
 | `object()`                          | 🟢 Low — base `object` type not exposed; use plain `{}` or a class    |
 | `abc` module — `ABC`, `@abstractmethod`, `Protocol` | 🟢 Low — no abc module; no enforcement of abstract methods |
+| `complex(real, imag)`               | 🟢 Low — no complex number type                                        |
 | `compile()`                         | 🔴 N/A — Python compile/code objects have no JS equivalent            |
 | `memoryview(obj)`                   | 🔴 N/A — no buffer protocol in browser context                        |
 | `open(path)`                        | 🔴 N/A — no filesystem access in browser context                      |
@@ -99,15 +107,8 @@
 | `__slots__` enforcement                       | 🟢 Low — accepted but does not restrict attribute assignment         |
 | Complex number literals `3+4j`                | 🟢 Low — no `j` suffix; no complex type                              |
 | `b'...'` bytes literals                       | 🟢 Low — no `b` prefix; use the `encodings` module for encoding work |
-| `except*` (exception groups, Python 3.11+)    | 🟢 Low — no parser support                                           |
-| `__new__` constructor hook                    | 🟢 Low — no alternative constructor support                          |
 | `__del__` destructor / finalizer              | 🟢 Low — JS has no guaranteed finalizer                              |
-| `__hash__` dunder                             | 🟢 Low — not dispatched; set/dict use `===` object identity          |
-| `__getattr__` / `__setattr__` / `__delattr__` | 🟢 Low — no attribute-access interception                            |
-| `__getattribute__`                            | 🟢 Low — no attribute-lookup override                                |
 | `__format__` dunder                           | 🟢 Low — `format()` builtin not defined; `__format__` not dispatched |
-| `__class_getitem__`                           | 🟢 Low — no `MyClass[T]` generic subscript syntax                    |
-| `__init_subclass__` hook                      | 🟢 Low                                                               |
 
 ---
 
@@ -125,10 +126,10 @@ Modules with a `src/lib/` implementation available are marked ✅. All others ar
 | `functools`   | ✅           | `reduce`, `partial`, `wraps`, `lru_cache`                                                     |
 | `itertools`   | ✅           | Common iteration tools                                                                        |
 | `numpy`       | ✅           | Full numpy-like library in `src/lib/numpy.pyj`; `numpy.random` and `numpy.linalg` sub-modules |
+| `copy`        | ✅           | `copy()` shallow copy and `deepcopy()` (circular-ref-safe via memo Map); `__copy__` / `__deepcopy__(memo)` hooks honoured; handles list, set, frozenset, dict, class instances, and plain JS objects |
 | `typing`      | ❌           | `List`, `Dict`, `Optional`, `Union`, `Tuple`, `Generic`, `TypeVar` — none available           |
 | `dataclasses` | ❌           | `@dataclass`, `field()`, `asdict()`, `astuple()` not available                                |
 | `contextlib`  | ❌           | `contextmanager`, `suppress`, `ExitStack`, `asynccontextmanager` not available                |
-| `copy`        | ❌           | `copy()` / `deepcopy()` not available                                                         |
 | `string`      | ❌           | Character constants, `Template`, `Formatter` not available                                    |
 | `json`        | ❌           | No Python wrapper; JS `JSON.parse` / `JSON.stringify` work directly via verbatim JS           |
 | `datetime`    | ❌           | `date`, `time`, `datetime`, `timedelta` not available                                         |
@@ -174,7 +175,6 @@ Features that exist in RapydScript but behave differently from standard Python:
 | Keyword-only param enforcement | Passing positionally raises `TypeError` | Passing positionally raises no error — the extra positional arg is silently discarded and the default value is used |
 | `is` / `is not` with `NaN` | `math.nan is math.nan` → `True` (same object) | `x is NaN` compiles to `isNaN(x)` (not `x === NaN`), making NaN checks work correctly |
 | Arithmetic type coercion | `1 + '1'` raises `TypeError` | `1 + '1'` → `'11'`; JS coerces the number to a string |
-| `list + list` | Concatenation returns a new list | Now matches Python: `[1,2] + [3,4]` returns `[1, 2, 3, 4]`; `+=` extends the list in-place. No `overload_operators` flag required. (Pre-existing JS `+` coercion is replaced by a lightweight `ρσ_list_add` helper.) |
 | `<`, `>`, `<=`, `>=` on lists / containers | Element-wise lexicographic comparison | Falls through to JS coercion — operands are stringified first (e.g. `[10] < [9]` is `True` because `'[10]' < '[9]'`). Comparison dunders (`__lt__` etc.) can be defined and called directly but are not auto-dispatched by these operators. |
 | Default `{}` dict — missing key | `KeyError` raised | Returns `undefined`; use `from __python__ import dict_literals, overload_getitem` to get `KeyError` |
 | Default `{}` dict — numeric keys | Integer keys are stored as integers | Numeric keys are auto-coerced to strings by the JS engine: `d[1]` and `d['1']` refer to the same slot |