sonolus.py 0.11.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

sonolus/build/compile.py

@@ -80,7 +80,7 @@ def compile_mode(
 
     mode_state = ModeContextState(
         mode,
-        {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
+        archetypes,
     )
     nodes = OutputNodeGenerator()
     results = {}
@@ -147,9 +147,10 @@ def compile_mode(
                 archetype_data["exports"] = [*archetype._exported_keys_]
 
             callback_items = [
-                (cb_name, cb_info, getattr(archetype, cb_name))
+                (cb_name, cb_info, archetype._callbacks_[cb_name])
                 for cb_name, cb_info in archetype._supported_callbacks_.items()
-                if getattr(archetype, cb_name) not in archetype._default_callbacks_
+                if cb_name in archetype._callbacks_
+                and archetype._callbacks_[cb_name] not in archetype._default_callbacks_
             ]
 
             if thread_pool is not None:

sonolus/script/archetype.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 import inspect
 from abc import abstractmethod
-from collections.abc import Callable
+from collections.abc import Callable, Sequence
 from dataclasses import dataclass
 from enum import Enum, StrEnum
 from types import FunctionType
@@ -11,8 +11,9 @@ from typing import Annotated, Any, ClassVar, Self, TypedDict, get_origin
 from sonolus.backend.ir import IRConst, IRExpr, IRInstr, IRPureInstr, IRStmt
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
+from sonolus.backend.visitor import compile_and_call
 from sonolus.script.bucket import Bucket, Judgment
-from sonolus.script.debug import static_error
+from sonolus.script.debug import runtime_checks_enabled, static_error
 from sonolus.script.internal.callbacks import PLAY_CALLBACKS, PREVIEW_CALLBACKS, WATCH_ARCHETYPE_CALLBACKS, CallbackInfo
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.descriptor import SonolusDescriptor
@@ -208,7 +209,7 @@ class _IsScoredDescriptor(SonolusDescriptor):
         if instance is None:
             return self.value
         elif ctx():
-            return ctx().mode_state.is_scored_by_archetype_id[instance.id]
+            return ctx().mode_state.is_scored_by_archetype_id.get_unchecked(instance.id)
         else:
             return self.value
 
@@ -222,7 +223,7 @@ class _IdDescriptor(SonolusDescriptor):
             raise RuntimeError("Archetype id is only available during compilation")
         if instance is None:
             result = ctx().mode_state.archetypes.get(owner)
-            if result is None:
+            if result is None or owner in ctx().mode_state.compile_time_only_archetypes:
                 raise RuntimeError("Archetype is not registered")
             return result
         else:
@@ -238,7 +239,7 @@ class _KeyDescriptor(SonolusDescriptor):
 
     def __get__(self, instance, owner):
         if instance is not None and ctx():
-            return ctx().mode_state.keys_by_archetype_id[instance.id]
+            return ctx().mode_state.keys_by_archetype_id.get_unchecked(instance.id)
         else:
             return self.value
 
@@ -428,7 +429,7 @@ class _BaseArchetype:
 
     _imported_keys_: ClassVar[dict[str, int]]
     _exported_keys_: ClassVar[dict[str, int]]
-    _callbacks_: ClassVar[list[Callable]]
+    _callbacks_: ClassVar[dict[str, Callable]]
     _data_constructor_signature_: ClassVar[inspect.Signature]
     _spawn_signature_: ClassVar[inspect.Signature]
 
@@ -492,17 +493,67 @@ class _BaseArchetype:
 
     @classmethod
     @meta_fn
-    def at(cls, index: int) -> Self:
+    def _compile_time_id(cls):
+        if not ctx():
+            raise RuntimeError("Archetype id is only available during compilation")
+        result = ctx().mode_state.archetypes.get(cls)
+        if result is None:
+            raise RuntimeError("Archetype is not registered")
+        return result
+
+    @classmethod
+    @meta_fn
+    def at(cls, index: int, check: bool = True) -> Self:
+        """Access the entity of this archetype at the given index.
+
+        Args:
+            index: The index of the entity to reference.
+            check: If true, raises an error if the entity at the index is not of this archetype or of a subclass of
+            this archetype. If false, no validation is performed.
+
+        Returns:
+            The entity at the given index.
+        """
+        if not ctx():
+            raise RuntimeError("Archetype.at is only available during compilation")
+        compile_and_call(cls._check_is_at, index, check=check)
         result = cls._new()
         result._data_ = _ArchetypeReferenceData(index=Num._accept_(index))
         return result
 
     @classmethod
+    def is_at(cls, index: int, strict: bool = False) -> bool:
+        """Return whether the entity at the given index is of this archetype.
+
+        Args:
+            index: The index of the entity to check.
+            strict: If true, only returns true if the entity is exactly of this archetype. If false, also returns true
+            if the entity is of a subclass of this archetype.
+
+        Returns:
+            Whether the entity at the given index is of this archetype.
+        """
+        if strict:
+            return index >= 0 and cls._compile_time_id() == entity_info_at(index).archetype_id
+        else:
+            mro_ids = cls._get_mro_id_array(entity_info_at(index).archetype_id)
+            return index >= 0 and cls._compile_time_id() in mro_ids
+
+    @classmethod
+    def _check_is_at(cls, index: int, check: bool):
+        if not check or not runtime_checks_enabled():
+            return
+        assert index >= 0, "Entity index must be non-negative"
+        assert cls._compile_time_id() in cls._get_mro_id_array(entity_info_at(index).archetype_id), (
+            "Entity at index is not of the expected archetype"
+        )
+
+    @staticmethod
     @meta_fn
-    def is_at(cls, index: int) -> bool:
+    def _get_mro_id_array(archetype_id: int) -> Sequence[int]:
         if not ctx():
-            raise RuntimeError("is_at is only available during compilation")
-        return entity_info_at(index).archetype_id == cls.id
+            raise RuntimeError("Archetype._get_mro_id_array is only available during compilation")
+        return ctx().get_archetype_mro_id_array(archetype_id)
 
     @classmethod
     @meta_fn
@@ -563,13 +614,16 @@ class _BaseArchetype:
             return
         if cls.name is None or cls.name in {getattr(mro_entry, "name", None) for mro_entry in cls.mro()[1:]}:
             cls.name = cls.__name__.removeprefix(cls._removable_prefix)
-        cls._callbacks_ = []
+        cls._callbacks_ = {}
         for name in cls._supported_callbacks_:
-            cb = getattr(cls, name)
-            if cb in cls._default_callbacks_:
-                continue
-            cls._callbacks_.append(cb)
+            for mro_entry in cls.mro():
+                if name in mro_entry.__dict__:
+                    cb = mro_entry.__dict__[name]
+                    if cb not in cls._default_callbacks_:
+                        cls._callbacks_[name] = cb
+                        break
         cls._field_init_done = False
+        cls._is_concrete_archetype_ = True
         cls.id = _IdDescriptor()
         cls._key_ = cls.key
         cls.key = _KeyDescriptor(cls.key)
@@ -585,6 +639,14 @@ class _BaseArchetype:
         for mro_entry in cls.mro()[1:]:
             if hasattr(mro_entry, "_field_init_done"):
                 mro_entry._init_fields()
+        if sum(issubclass(base, _BaseArchetype) for base in cls.__bases__) > 1:
+            raise TypeError("Multiple inheritance of Archetypes is not supported")
+        mro_from_archetype_parents = set(
+            type("Dummy", tuple(base for base in cls.__bases__ if issubclass(base, _BaseArchetype)), {}).mro()
+        )
+        # Archetype parents would have already initialized relevant fields, so only consider the current class
+        # and mixins that were not already included via an archetype parent
+        mro_excluding_archetype_parents = [entry for entry in cls.mro() if entry not in mro_from_archetype_parents]
         field_specifiers = get_field_specifiers(
             cls,
             skip={
@@ -600,7 +662,9 @@ class _BaseArchetype:
                 "_default_callbacks_",
                 "_callbacks_",
                 "_field_init_done",
+                "_is_concrete_archetype_",
             },
+            included_classes=mro_excluding_archetype_parents,
         ).items()
         if not hasattr(cls, "_imported_fields_"):
             cls._imported_fields_ = {}
@@ -653,6 +717,13 @@ class _BaseArchetype:
                     f"Missing field annotation for '{name}', "
                     f"expected exactly one of imported, exported, entity_memory, or shared_memory"
                 )
+            if (
+                name in cls._imported_fields_
+                or name in cls._exported_fields_
+                or name in cls._memory_fields_
+                or name in cls._shared_memory_fields_
+            ):
+                raise ValueError(f"Field '{name}' is already defined in a superclass")
             field_type = validate_concrete_type(value.__args__[0])
             match field_info.storage:
                 case _StorageType.IMPORTED:
@@ -771,6 +842,18 @@ class _BaseArchetype:
         new_cls = type(name, (cls,), cls_dict)
         return new_cls
 
+    @meta_fn
+    def _delegate(self, name: str, default: int | float | None = None):
+        name = validate_value(name)._as_py_()
+        if hasattr(super(), name):
+            fn = getattr(super(), name)
+            if ctx():
+                return compile_and_call(fn)
+            else:
+                return fn()
+        else:
+            return default
+
 
 class PlayArchetype(_BaseArchetype):
     """Base class for play mode archetypes.
@@ -808,26 +891,28 @@ class PlayArchetype(_BaseArchetype):
 
         Runs first when the level is loaded.
         """
+        self._delegate("preprocess")
 
     def spawn_order(self) -> float:
         """Return the spawn order of the entity.
 
         Runs when the level is loaded after [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess].
         """
-        return 0.0
+        return self._delegate("spawn_order", default=0.0)
 
     def should_spawn(self) -> bool:
         """Return whether the entity should be spawned.
 
         Runs each frame while the entity is the first entity in the spawn queue.
         """
-        return True
+        return self._delegate("should_spawn", default=True)
 
     def initialize(self):
         """Initialize this entity.
 
         Runs when this entity is spawned.
         """
+        self._delegate("initialize")
 
     def update_sequential(self):
         """Perform non-parallel actions for this frame.
@@ -839,6 +924,7 @@ class PlayArchetype(_BaseArchetype):
         [`update_parallel`][sonolus.script.archetype.PlayArchetype.update_parallel]
         for better performance.
         """
+        self._delegate("update_sequential")
 
     def update_parallel(self):
         """Perform parallel actions for this frame.
@@ -847,18 +933,21 @@ class PlayArchetype(_BaseArchetype):
 
         This is where most gameplay logic should be placed.
         """
+        self._delegate("update_parallel")
 
     def touch(self):
         """Handle user input.
 
         Runs after [`update_sequential`][sonolus.script.archetype.PlayArchetype.update_sequential] each frame.
         """
+        self._delegate("touch")
 
     def terminate(self):
         """Finalize before despawning.
 
         Runs when the entity is despawned.
         """
+        self._delegate("terminate")
 
     @property
     @meta_fn
@@ -966,20 +1055,22 @@ class WatchArchetype(_BaseArchetype):
 
         Runs first when the level is loaded.
         """
+        self._delegate("preprocess")
 
     def spawn_time(self) -> float:
         """Return the spawn time of the entity."""
-        return 0.0
+        return self._delegate("spawn_time", default=0.0)
 
     def despawn_time(self) -> float:
         """Return the despawn time of the entity."""
-        return 0.0
+        return self._delegate("despawn_time", default=0.0)
 
     def initialize(self):
         """Initialize this entity.
 
         Runs when this entity is spawned.
         """
+        self._delegate("initialize")
 
     def update_sequential(self):
         """Perform non-parallel actions for this frame.
@@ -990,6 +1081,7 @@ class WatchArchetype(_BaseArchetype):
         Other logic should typically be placed in
         [`update_parallel`][sonolus.script.archetype.PlayArchetype.update_parallel] for better performance.
         """
+        self._delegate("update_sequential")
 
     def update_parallel(self):
         """Parallel update callback.
@@ -998,12 +1090,14 @@ class WatchArchetype(_BaseArchetype):
 
         This is where most gameplay logic should be placed.
         """
+        self._delegate("update_parallel")
 
     def terminate(self):
         """Finalize before despawning.
 
         Runs when the entity is despawned.
         """
+        self._delegate("terminate")
 
     @property
     @meta_fn
@@ -1074,12 +1168,14 @@ class PreviewArchetype(_BaseArchetype):
 
         Runs first when the level is loaded.
         """
+        self._delegate("preprocess")
 
     def render(self):
         """Render the entity.
 
         Runs after `preprocess`.
         """
+        self._delegate("render")
 
     @property
     @meta_fn
@@ -1248,11 +1344,19 @@ class EntityRef[A: _BaseArchetype](Record):
         return True
 
     @meta_fn
-    def get(self) -> A:
-        """Get the entity."""
+    def get(self, *, check: bool = True) -> A:
+        """Get the entity this reference points to.
+
+        Args:
+            check: If true, raises an error if the referenced entity is not of this archetype or of a subclass of
+            this archetype. If false, no validation is performed.
+
+        Returns:
+            The entity this reference points to.
+        """
         if ref := getattr(self, "_ref_", None):
             return ref
-        return self.archetype().at(self.index)
+        return self.archetype().at(self.index, check=check)
 
     @meta_fn
     def get_as(self, archetype: type[_BaseArchetype]) -> _BaseArchetype:
@@ -1261,9 +1365,17 @@ class EntityRef[A: _BaseArchetype](Record):
             raise TypeError("Using get_as in level data is not supported.")
         return self.with_archetype(archetype).get()
 
-    def archetype_matches(self) -> bool:
-        """Check if entity at the index is precisely of the archetype."""
-        return self.index >= 0 and self.archetype().is_at(self.index)
+    def archetype_matches(self, strict: bool = False) -> bool:
+        """Check if entity at the index is of this archetype.
+
+        Args:
+            strict: If true, only returns true if the entity is exactly of this archetype. If false, also returns true
+            if the entity is of a subclass of this archetype.
+
+        Returns:
+            Whether the entity at the given index is of this archetype.
+        """
+        return self.archetype().is_at(self.index, strict=strict)
 
     def _to_list_(self, level_refs: dict[Any, str] | None = None) -> list[DataValue | str]:
         ref = getattr(self, "_ref_", None)

sonolus/script/debug.py

@@ -102,6 +102,14 @@ def notify(message: str):
         print(f"[NOTIFY] {message}")
 
 
+@meta_fn
+def runtime_checks_enabled() -> bool:
+    if ctx():
+        return ctx().project_state.runtime_checks != RuntimeChecks.NONE
+    else:
+        return True
+
+
 @meta_fn
 def require(value: int | float | bool, message: str | None = None):
     """Require a condition to be true, or raise an error.
@@ -212,7 +220,7 @@ def visualize_cfg(
     project_state = ProjectContextState()
     mode_state = ModeContextState(
         mode,
-        {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
+        archetypes,
     )
 
     cfg = callback_to_cfg(project_state, mode_state, fn, callback, archetype=archetype)  # type: ignore

sonolus/script/internal/context.py

@@ -94,25 +94,36 @@ class ProjectContextState:
 
 class ModeContextState:
     archetypes: dict[type, int]
+    compile_time_only_archetypes: set[type]
     archetypes_by_name: dict[str, type]
     keys_by_archetype_id: Sequence[int]
     is_scored_by_archetype_id: Sequence[bool]
+    archetype_mro_id_array_rom_indexes: Sequence[int] | None = None
     environment_mappings: dict[_GlobalInfo, int]
     environment_offsets: dict[Block, int]
     mode: Mode
     lock: Lock
 
-    def __init__(self, mode: Mode, archetypes: dict[type, int] | None = None):
+    def __init__(self, mode: Mode, archetypes: list[type] | None = None):
         from sonolus.script.array import Array
 
-        self.archetypes = archetypes or {}
+        archetypes = [*archetypes] if archetypes is not None else []
+        seen_archetypes = {*archetypes}
+        compile_time_only_archetypes = set()
+        for type_ in [*archetypes]:
+            for entry in type_.mro():
+                if getattr(entry, "_is_concrete_archetype_", False) and entry not in seen_archetypes:
+                    archetypes.append(entry)
+                    seen_archetypes.add(entry)
+                    compile_time_only_archetypes.add(entry)
+        self.archetypes = {type_: idx for idx, type_ in enumerate(archetypes)}
+        self.compile_time_only_archetypes = compile_time_only_archetypes
         self.archetypes_by_name = {type_.name: type_ for type_, _ in self.archetypes.items()}  # type: ignore
-        ordered_archetypes = sorted(self.archetypes, key=lambda a: self.archetypes[a])
         self.keys_by_archetype_id = (
-            Array(*((getattr(a, "_key_", -1)) for a in ordered_archetypes)) if archetypes else Array[int, Literal[0]]()
+            Array(*((getattr(a, "_key_", -1)) for a in archetypes)) if archetypes else Array[int, Literal[0]]()
         )
         self.is_scored_by_archetype_id = (
-            Array(*((getattr(a, "_is_scored_", False)) for a in ordered_archetypes))
+            Array(*((getattr(a, "_is_scored_", False)) for a in archetypes))
             if archetypes
             else Array[bool, Literal[0]]()
         )
@@ -121,6 +132,27 @@ class ModeContextState:
         self.mode = mode
         self.lock = Lock()
 
+    def _init_archetype_mro_info(self, rom: ReadOnlyMemory):
+        from sonolus.script.array import Array
+        from sonolus.script.num import Num
+
+        with self.lock:
+            if self.archetype_mro_id_array_rom_indexes is not None:
+                return
+            archetype_mro_id_values = []
+            archetype_mro_id_offsets = []
+            for type_ in self.archetypes:
+                mro_ids = [self.archetypes[entry] for entry in type_.mro() if entry in self.archetypes]
+                archetype_mro_id_offsets.append(len(archetype_mro_id_values))
+                archetype_mro_id_values.append(len(mro_ids))
+                archetype_mro_id_values.extend(mro_ids)
+            archetype_mro_id_array_place = rom[tuple(archetype_mro_id_values)]
+
+            archetype_mro_id_rom_indexes = Array[int, len(archetype_mro_id_offsets)]._with_value(
+                [Num._accept_(offset + archetype_mro_id_array_place.index) for offset in archetype_mro_id_offsets]
+            )
+            self.archetype_mro_id_array_rom_indexes = archetype_mro_id_rom_indexes
+
 
 class CallbackContextState:
     callback: str
@@ -371,6 +403,15 @@ class Context:
                 self.mode_state.archetypes[type_] = len(self.mode_state.archetypes)
             return self.mode_state.archetypes[type_]
 
+    def get_archetype_mro_id_array(self, archetype_id: int) -> Sequence[int]:
+        from sonolus.script.containers import ArrayPointer
+        from sonolus.script.num import Num
+        from sonolus.script.pointer import _deref
+
+        self.mode_state._init_archetype_mro_info(self.rom)
+        rom_index = self.mode_state.archetype_mro_id_array_rom_indexes[archetype_id]
+        return ArrayPointer[int](_deref(self.blocks.EngineRom, rom_index, Num), self.blocks.EngineRom, rom_index + 1)
+
 
 def ctx() -> Context | Any:  # Using Any to silence type checker warnings if it's None
     return context_var.get()

sonolus/script/internal/introspection.py

@@ -1,4 +1,5 @@
 import inspect
+from collections.abc import Sequence
 from typing import Annotated
 
 _missing = object()
@@ -11,9 +12,15 @@ def get_field_specifiers(
     globals=None,  # noqa: A002
     locals=None,  # noqa: A002
     eval_str=True,
+    included_classes: Sequence[type] | None = None,
 ):
     """Like inspect.get_annotations, but also turns class attributes into Annotated."""
-    results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
+    if included_classes is not None:
+        results = {}
+        for entry in reversed(included_classes):
+            results.update(inspect.get_annotations(entry, eval_str=eval_str))
+    else:
+        results = inspect.get_annotations(cls, globals=globals, locals=locals, eval_str=eval_str)
     for key, value in results.items():
         class_value = getattr(cls, key, _missing)
         if class_value is not _missing and key not in skip:

{sonolus_py-0.11.1.dist-info → sonolus_py-0.12.0.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.11.1
+Version: 0.12.0
 Summary: Sonolus engine development in Python
 Project-URL: Documentation, https://sonolus.py.qwewqa.xyz/
 Project-URL: Repository, https://github.com/qwewqa/sonolus.py
 Project-URL: Issues, https://github.com/qwewqa/sonolus.py/issues
 Project-URL: Changelog, https://sonolus.py.qwewqa.xyz/changelog/
 License-File: LICENSE
-Requires-Python: >=3.12
+Requires-Python: >=3.12.5
 Description-Content-Type: text/markdown
 
 # Sonolus.py

{sonolus_py-0.11.1.dist-info → sonolus_py-0.12.0.dist-info}/RECORD

@@ -28,19 +28,19 @@ sonolus/backend/optimize/ssa.py,sha256=raQO0furQQRPYb8iIBKfNrJlj-_5wqtI4EWNfLZ8Q
 sonolus/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/build/cli.py,sha256=uLY7JG3PTAb2a1bbjulFlgUGDzsHXyRAfkGV0lbuMgQ,10538
 sonolus/build/collection.py,sha256=6hniAzriPWBKUeGDkXabNXpbdHiHnqiK9shs6U1OExM,12748
-sonolus/build/compile.py,sha256=YKqldBTWAXz5kzsS9Qmwy3FdrFloYZWvapR5QWsx2G0,8862
+sonolus/build/compile.py,sha256=m4v4wYWnI6ebot4-fJi9a7eoF0WIo3uPOPy0_NpLgK0,8855
 sonolus/build/dev_server.py,sha256=yHD3KGqzebdqcEBOC5JDlNptzlH8Sq4i-DNnh_zXWCA,10705
 sonolus/build/engine.py,sha256=jMymxbBXu-ekv71uU8TF2KbFaHs3yGjyJAztd1SoRDs,14808
 sonolus/build/level.py,sha256=KLqUAtxIuIqrzeFURJA97rdqjA5pcvYSmwNZQhElaMQ,702
 sonolus/build/node.py,sha256=Dhuz_-UlRd-EJC7-AP1NuyvrjHWNo7jGssniRh4dZhI,1239
 sonolus/build/project.py,sha256=Uuz82QtTNFdklrVJ_i7EPp8hSjyOxLU1xAeOloa6G00,8579
 sonolus/script/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-sonolus/script/archetype.py,sha256=TZ9Semvzh6zHtUyJGN7ZrLYkux4zgqxFhrh-dGiaLEo,49907
+sonolus/script/archetype.py,sha256=qK1tcREt56qJPh1zw_cjZGz0UUQngLGXUDA1HmwNpY8,55083
 sonolus/script/array.py,sha256=EbrNwl_WuJ0JjjkX0s_VJNXWqvYdm_ljTbyrDEMLGUY,13348
 sonolus/script/array_like.py,sha256=E6S4TW2muXgcyVkhUASQVt7JSYUkpvdJPgHz6YiSHNo,14708
 sonolus/script/bucket.py,sha256=LNePLmCwgXfKLmH4Z7ZcTFKWR32eq4AnnagI7jacrsU,7782
 sonolus/script/containers.py,sha256=KKySXTh_ON9hut1ScMS31ewRNnVd4t7OwpIZg2bPhno,28676
-sonolus/script/debug.py,sha256=21_bvhP2cZ4kwS3Spxp8tP6ojIfmthQxlq4gtqrt0lo,7757
+sonolus/script/debug.py,sha256=sWMZ-c68GggD8eUZJUPRXxxDjtCt9j8X4-_FUgTvUNE,7856
 sonolus/script/easing.py,sha256=2FUJI_nfp990P_armCcRqHm2329O985glJAhSC6tnxs,11379
 sonolus/script/effect.py,sha256=SfJxSNF3RlPCRXnkt62ZlWhCXw3mmmRCsoMsvTErUP0,7960
 sonolus/script/engine.py,sha256=etI9dJsQ7V9YZICVNZg54WqpLijPxG8eTPHiV-_EiG8,10687
@@ -72,13 +72,13 @@ sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtU
 sonolus/script/internal/builtin_impls.py,sha256=1fo6UuWlaLoqpVwFSrFS5BabNeRCdS2T2mjsS4BPYcY,13603
 sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
 sonolus/script/internal/constant.py,sha256=3ycbGkDJVUwcrCZ96vLjAoAARgsvaqDM8rJ_YCrLrvo,4289
-sonolus/script/internal/context.py,sha256=fRvdxkx7EILU54-ogR1HSjLOZnH2PVw2gQri9m86K5Y,19852
+sonolus/script/internal/context.py,sha256=dhWQS7fFPMhb0FJyw3y--0HlBtwuYANdIYiv7u_96jk,22023
 sonolus/script/internal/descriptor.py,sha256=XRFey-EjiAm_--KsNl-8N0Mi_iyQwlPh68gDp0pKf3E,392
 sonolus/script/internal/dict_impl.py,sha256=alu_wKGSk1kZajNf64qbe7t71shEzD4N5xNIATH8Swo,1885
 sonolus/script/internal/error.py,sha256=ZNnsvQVQAnFKzcvsm6-sste2lo-tP5pPI8sD7XlAZWc,490
 sonolus/script/internal/generic.py,sha256=_3d5Rn_tn214-77fPE67vdbdqt1PQF8-2WB_XDu5YRg,7551
 sonolus/script/internal/impl.py,sha256=R88cl4nLcfF0UhA9qdYRBOsl4nMx8ucgz8l7_oRY-l8,3503
-sonolus/script/internal/introspection.py,sha256=guL9_NR2D3OJAnNpeFdyYkO_vVXk-3KQr2-y4YielM0,1133
+sonolus/script/internal/introspection.py,sha256=q6c83G_jmuLSoYSJj8ln0XtuwNEdndE0PkLbNWOhGmk,1421
 sonolus/script/internal/math_impls.py,sha256=ox2pBJ6ELRO0LdLn_RZxgHHs_PCgQOHIhmDkwmLxJaU,2975
 sonolus/script/internal/native.py,sha256=zOuRtgI3XJ_ExyR_ZkvbDABVc_JIWaKl62lFEL_bMaw,2007
 sonolus/script/internal/random.py,sha256=6Ku5edRcDUh7rtqEEYCJz0BQavw69RALsVHS25z50pI,1695
@@ -87,8 +87,8 @@ sonolus/script/internal/simulation_context.py,sha256=LGxLTvxbqBIhoe1R-SfwGajNIDw
 sonolus/script/internal/transient.py,sha256=y2AWABqF1aoaP6H4_2u4MMpNioC4OsZQCtPyNI0txqo,1634
 sonolus/script/internal/tuple_impl.py,sha256=WaI5HSF5h03ddXiSHEwzY9ttfsPUItaf86Y5VbZypek,3754
 sonolus/script/internal/value.py,sha256=OngrCdmY_h6mV2Zgwqhuo4eYFad0kTk6263UAxctZcY,6963
-sonolus_py-0.11.1.dist-info/METADATA,sha256=RUqohCNBMfRgWQrbN51EW2yocoNb136sH8eRKCr_T_o,554
-sonolus_py-0.11.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.11.1.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.11.1.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.11.1.dist-info/RECORD,,
+sonolus_py-0.12.0.dist-info/METADATA,sha256=ncmBBjgZ1BHrxEb9xrtEIa_CiF8pK-lknGve69U3_LY,556
+sonolus_py-0.12.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.12.0.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.12.0.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.12.0.dist-info/RECORD,,