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

sonolus/backend/finalize.py

@@ -1,7 +1,7 @@
 from math import isfinite, isinf, isnan
 
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.node import EngineNode, FunctionNode
 from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import BasicBlock, traverse_cfg_reverse_postorder
 from sonolus.backend.place import BlockPlace
@@ -18,18 +18,18 @@ def cfg_to_engine_node(entry: BasicBlock):
         }
         match outgoing:
             case {**other} if not other:
-                statements.append(ConstantNode(value=len(block_indexes)))
+                statements.append(len(block_indexes))
             case {None: target, **other} if not other:
-                statements.append(ConstantNode(value=block_indexes[target]))
+                statements.append(block_indexes[target])
             case {0: f_branch, None: t_branch, **other} if not other:
                 statements.append(
                     FunctionNode(
                         func=Op.If,
-                        args=[
+                        args=(
                             ir_to_engine_node(block.test),
-                            ConstantNode(value=block_indexes[t_branch]),
-                            ConstantNode(value=block_indexes[f_branch]),
-                        ],
+                            block_indexes[t_branch],
+                            block_indexes[f_branch],
+                        ),
                     )
                 )
             case {None: default_branch, **other} if len(other) == 1:
@@ -37,11 +37,11 @@ def cfg_to_engine_node(entry: BasicBlock):
                 statements.append(
                     FunctionNode(
                         func=Op.If,
-                        args=[
+                        args=(
                             ir_to_engine_node(IRPureInstr(Op.Equal, args=[block.test, IRConst(cond)])),
-                            ConstantNode(value=block_indexes[cond_branch]),
-                            ConstantNode(value=block_indexes[default_branch]),
-                        ],
+                            block_indexes[cond_branch],
+                            block_indexes[default_branch],
+                        ),
                     )
                 )
             case dict() as targets:
@@ -49,23 +49,31 @@ def cfg_to_engine_node(entry: BasicBlock):
                 default = len(block_indexes)
                 conds = [cond for cond in targets if cond is not None]
                 if min(conds) == 0 and max(conds) == len(conds) - 1 and all(int(cond) == cond for cond in conds):
-                    args.extend(ConstantNode(value=block_indexes[targets[cond]]) for cond in range(len(conds)))
+                    args.extend(block_indexes[targets[cond]] for cond in range(len(conds)))
                     if None in targets:
                         default = block_indexes[targets[None]]
-                    args.append(ConstantNode(value=default))
-                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, args))
+                    args.append(default)
+                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, tuple(args)))
                 else:
                     for cond, target in targets.items():
                         if cond is None:
                             default = block_indexes[target]
                             continue
-                        args.append(ConstantNode(value=cond))
-                        args.append(ConstantNode(value=block_indexes[target]))
-                    args.append(ConstantNode(value=default))
-                    statements.append(FunctionNode(Op.SwitchWithDefault, args))
-        block_statements.append(FunctionNode(Op.Execute, statements))
-    block_statements.append(ConstantNode(value=0))
-    return FunctionNode(Op.Block, [FunctionNode(Op.JumpLoop, block_statements)])
+                        args.append(cond)
+                        args.append(block_indexes[target])
+                    args.append(default)
+                    statements.append(FunctionNode(Op.SwitchWithDefault, tuple(args)))
+        block_statements.append(FunctionNode(Op.Execute, tuple(statements)))
+    block_statements.append(0)
+    result = FunctionNode(Op.Block, (FunctionNode(Op.JumpLoop, tuple(block_statements)),))
+    for block in block_indexes:
+        # Clean up without relying on gc
+        del block.incoming
+        del block.outgoing
+        del block.phis
+        del block.statements
+        del block.test
+    return result
 
 
 def ir_to_engine_node(stmt) -> EngineNode:
@@ -73,32 +81,30 @@ def ir_to_engine_node(stmt) -> EngineNode:
         case int(value) | float(value) | IRConst(value=int(value) | float(value)):
             value = float(value)
             if value.is_integer():
-                return ConstantNode(value=int(value))
+                return int(value)
             elif isfinite(value):
-                return ConstantNode(value=value)
+                return value
             elif isinf(value):
                 # Read values from ROM
-                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=1 if value > 0 else 2)])
+                return FunctionNode(Op.Get, args=(3000, 1 if value > 0 else 2))
             elif isnan(value):
                 # Read value from ROM
-                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=0)])
+                return FunctionNode(Op.Get, args=(3000, 0))
             else:
                 raise ValueError(f"Invalid constant value: {value}")
         case IRPureInstr(op=op, args=args) | IRInstr(op=op, args=args):
-            return FunctionNode(func=op, args=[ir_to_engine_node(arg) for arg in args])
+            return FunctionNode(func=op, args=tuple(ir_to_engine_node(arg) for arg in args))
         case IRGet(place=place):
             return ir_to_engine_node(place)
         case BlockPlace() as place:
             if place.offset == 0:
                 index = ir_to_engine_node(place.index)
             elif place.index == 0:
-                index = ConstantNode(value=place.offset)
+                index = place.offset
             else:
-                index = FunctionNode(
-                    func=Op.Add, args=[ir_to_engine_node(place.index), ConstantNode(value=place.offset)]
-                )
-            return FunctionNode(func=Op.Get, args=[ir_to_engine_node(place.block), index])
+                index = FunctionNode(func=Op.Add, args=(ir_to_engine_node(place.index), place.offset))
+            return FunctionNode(func=Op.Get, args=(ir_to_engine_node(place.block), index))
         case IRSet(place=place, value=value):
-            return FunctionNode(func=Op.Set, args=[*ir_to_engine_node(place).args, ir_to_engine_node(value)])
+            return FunctionNode(func=Op.Set, args=(*ir_to_engine_node(place).args, ir_to_engine_node(value)))
         case _:
             raise TypeError(f"Unsupported IR statement: {stmt}")

sonolus/backend/interpret.py

@@ -2,7 +2,7 @@ import math
 import operator
 import random
 
-from sonolus.backend.node import ConstantNode, EngineNode
+from sonolus.backend.node import EngineNode, FunctionNode
 from sonolus.backend.ops import Op
 
 
@@ -24,8 +24,8 @@ class Interpreter:
         self.log = []
 
     def run(self, node: EngineNode) -> float:
-        if isinstance(node, ConstantNode):
-            return node.value
+        if not isinstance(node, FunctionNode):
+            return node
         func = node.func
         args = node.args
         match func:

sonolus/backend/node.py

@@ -1,40 +1,18 @@
 import textwrap
-from dataclasses import dataclass, field
+from typing import NamedTuple
 
 from sonolus.backend.ops import Op
 
-type EngineNode = ConstantNode | FunctionNode
+type EngineNode = int | float | FunctionNode
 
 
-@dataclass(slots=True)
-class ConstantNode:
-    value: float
-    _hash: int = field(init=False, repr=False)
-
-    def __post_init__(self):
-        self._hash = hash(self.value)
-
-    def __hash__(self):
-        return hash(self.value)
-
-
-@dataclass(slots=True)
-class FunctionNode:
+class FunctionNode(NamedTuple):
     func: Op
-    args: list[EngineNode]
-    _hash: int = field(init=False, repr=False)
-
-    def __post_init__(self):
-        self._hash = hash((self.func, tuple(self.args)))
-
-    def __hash__(self):
-        return self._hash
+    args: tuple[EngineNode, ...]
 
 
 def format_engine_node(node: EngineNode) -> str:
-    if isinstance(node, ConstantNode):
-        return str(node.value)
-    elif isinstance(node, FunctionNode):
+    if isinstance(node, FunctionNode):
         match len(node.args):
             case 0:
                 return f"{node.func.name}()"
@@ -45,4 +23,4 @@ def format_engine_node(node: EngineNode) -> str:
                     textwrap.indent('\n'.join(format_engine_node(arg) for arg in node.args), '  ')
                 }\n)"
     else:
-        raise ValueError(f"Invalid engine node: {node}")
+        return str(node)

sonolus/backend/optimize/liveness.py

@@ -24,15 +24,18 @@ class LivenessAnalysis(CompilerPass):
             block.live_phi_targets = set()
             block.array_defs_in = set()
             block.array_defs_out = None
+            last_live_set = set()
             for statement in block.statements:
-                statement.live = set()
+                if isinstance(statement, IRSet):
+                    last_live_set = set()
+                statement.live = last_live_set
                 statement.visited = False
                 statement.uses = self.get_uses(statement, set())
                 statement.defs = self.get_defs(statement)
                 statement.is_array_init = False  # True if this may be the first assignment to an array
                 statement.array_defs = self.get_array_defs(statement)
             if not isinstance(block.test, IRConst):
-                block.test.live = set()
+                block.test.live = last_live_set
                 block.test.uses = self.get_uses(block.test, set())
         self.preprocess_arrays(entry)
 

sonolus/backend/visitor.py

@@ -1006,7 +1006,9 @@ class Visitor(ast.NodeVisitor):
         return validate_value({self.visit(k): self.visit(v) for k, v in zip(node.keys, node.values, strict=True)})
 
     def visit_Set(self, node):
-        raise NotImplementedError("Set literals are not supported")
+        from sonolus.script.containers import FrozenNumSet
+
+        return self.handle_call(node, FrozenNumSet.of, *(self.visit(elt) for elt in node.elts))
 
     def visit_ListComp(self, node):
         raise NotImplementedError("List comprehensions are not supported")

sonolus/build/compile.py

@@ -32,9 +32,11 @@ class CompileCache:
         self._cache = {}
         self._lock = Lock()
         self._event = Event()
+        self._accessed_hashes = set()
 
     def get(self, entry_hash: int) -> EngineNode | None:
         with self._lock:
+            self._accessed_hashes.add(entry_hash)
             if entry_hash not in self._cache:
                 self._cache[entry_hash] = None  # Mark as being compiled
                 return None
@@ -47,10 +49,21 @@ class CompileCache:
 
     def set(self, entry_hash: int, node: EngineNode) -> None:
         with self._lock:
+            self._accessed_hashes.add(entry_hash)
             self._cache[entry_hash] = node
             self._event.set()
             self._event.clear()
 
+    def reset_accessed(self) -> None:
+        with self._lock:
+            self._accessed_hashes.clear()
+
+    def prune_unaccessed(self) -> None:
+        with self._lock:
+            unaccessed_hashes = set(self._cache.keys()) - self._accessed_hashes
+            for h in unaccessed_hashes:
+                del self._cache[h]
+
 
 def compile_mode(
     mode: Mode,

sonolus/build/dev_server.py

@@ -119,6 +119,7 @@ class RebuildCommand:
         print("Rebuilding...")
         try:
             start_time = perf_counter()
+            server_state.cache.reset_accessed()
             server_state.project_state = ProjectContextState.from_build_config(server_state.config)
             server_state.project = project_module.project
             build_collection(
@@ -128,6 +129,7 @@ class RebuildCommand:
                 cache=server_state.cache,
                 project_state=server_state.project_state,
             )
+            server_state.cache.prune_unaccessed()
             end_time = perf_counter()
             print(f"Rebuild completed in {end_time - start_time:.2f} seconds")
         except CompilationError:

sonolus/build/node.py

@@ -1,7 +1,7 @@
 from threading import Lock
 from typing import TypedDict
 
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.node import EngineNode, FunctionNode
 
 
 class ValueOutputNode(TypedDict):
@@ -32,19 +32,17 @@ class OutputNodeGenerator:
             return self.indexes[node]
 
         match node:
-            case ConstantNode(value):
-                index = len(self.nodes)
-                self.nodes.append({"value": value})
-                self.indexes[node] = index
-                return index
             case FunctionNode(func, args):
                 arg_indexes = [self._add(arg) for arg in args]
                 index = len(self.nodes)
                 self.nodes.append({"func": func.value, "args": arg_indexes})
                 self.indexes[node] = index
                 return index
-            case _:
-                raise ValueError("Invalid node")
+            case constant:
+                index = len(self.nodes)
+                self.nodes.append({"value": constant})
+                self.indexes[node] = index
+                return index
 
     def get(self):
         return self.nodes

sonolus/script/archetype.py

@@ -12,6 +12,7 @@ from sonolus.backend.ir import IRConst, IRExpr, IRInstr, IRPureInstr, IRStmt
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
 from sonolus.script.bucket import Bucket, Judgment
+from sonolus.script.debug import 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
@@ -581,7 +582,6 @@ class _BaseArchetype:
     def _init_fields(cls):
         if cls._field_init_done:
             return
-        cls._field_init_done = True
         for mro_entry in cls.mro()[1:]:
             if hasattr(mro_entry, "_field_init_done"):
                 mro_entry._init_fields()
@@ -706,6 +706,7 @@ class _BaseArchetype:
             [inspect.Parameter(name, inspect.Parameter.POSITIONAL_OR_KEYWORD) for name in cls._memory_fields_]
         )
         cls._post_init_fields()
+        cls._field_init_done = True
 
     @property
     @abstractmethod
@@ -1210,6 +1211,8 @@ class EntityRef[A: _BaseArchetype](Record):
 
     Usage:
         ```python
+        ref = EntityRef[MyArchetype](index=123)
+
         class MyArchetype(PlayArchetype):
             ref_1: EntityRef[OtherArchetype] = imported()
             ref_2: EntityRef[Any] = imported()
@@ -1238,6 +1241,12 @@ class EntityRef[A: _BaseArchetype](Record):
             return hash(id(self._ref_))
         return super().__hash__()
 
+    @meta_fn
+    def __bool__(self):
+        if ctx():
+            static_error("EntityRef cannot be used in a boolean context. Check index directly instead.")
+        return True
+
     @meta_fn
     def get(self) -> A:
         """Get the entity."""

sonolus/script/containers.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 from collections.abc import Callable
 from typing import Any, Protocol, Self
 
+from sonolus.backend.visitor import compile_and_call
 from sonolus.script.archetype import AnyArchetype, EntityRef
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike, get_positive_index
@@ -441,6 +442,56 @@ class ArraySet[T, Capacity](Record):
         self._values.clear()
 
 
+class FrozenNumSet[Size](Record):
+    _values: Array[Num, Size]
+
+    @classmethod
+    @meta_fn
+    def of(cls, *values: Num) -> Self:
+        if ctx():
+            try:
+                num_values = [Num._accept_(v) for v in values]
+            except TypeError:
+                raise TypeError("Only sets of numeric values are supported") from None
+            if all(v._is_py_() for v in num_values):
+                const_values = [v._as_py_() for v in num_values]
+                arr = Array[Num, len(const_values)]._with_value([Num(v) for v in sorted(const_values)])
+                return cls(arr)
+            else:
+                arr = Array[Num, len(values)](*values)
+                compile_and_call(arr.sort)
+        else:
+            arr = Array[Num, len(values)](*sorted(values))
+        return cls(arr)
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __contains__(self, value: Num) -> bool:
+        if len(self) < 8:
+            return value in self._as_tuple()
+        else:
+            left = 0
+            right = len(self) - 1
+            while left <= right:
+                mid = (left + right) // 2
+                mid_value = self._values.get_unchecked(mid)
+                if mid_value == value:
+                    return True
+                elif mid_value < value:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+            return False
+
+    def __iter__(self) -> SonolusIterator[Num]:
+        return self._values.__iter__()
+
+    @meta_fn
+    def _as_tuple(self) -> tuple[Num, ...]:
+        return tuple(self._values.get_unchecked(i) for i in range(Num._accept_(len(self))._as_py_()))
+
+
 class _ArrayMapEntry[K, V](Record):
     key: K
     value: V

sonolus/script/internal/context.py

@@ -551,7 +551,11 @@ def context_to_cfg(context: Context) -> BasicBlock:
             edge = FlowEdge(src=blocks[current], dst=blocks[target], cond=condition)
             blocks[current].outgoing.add(edge)
             blocks[target].incoming.add(edge)
-    return blocks[context]
+    result = blocks[context]
+    for current in tuple(iter_contexts(context)):
+        # Break cycles so memory can be cleaned without gc
+        del current.outgoing
+    return result
 
 
 def unique[T](iterable: Iterable[T]) -> list[T]:

sonolus/script/internal/impl.py

@@ -77,6 +77,10 @@ def try_validate_value(value: Any) -> Value | None:
             return TupleImpl._accept_(value)
         case dict():
             return DictImpl._accept_(value)
+        case set() | frozenset():
+            from sonolus.script.containers import FrozenNumSet
+
+            return FrozenNumSet.of(*value)
         case (
             PartialGeneric()
             | TypeVar()
@@ -90,11 +94,7 @@ def try_validate_value(value: Any) -> Value | None:
             | super()
         ):
             return BasicConstantValue.of(value)
-        case special_form if value in {
-            Literal,
-            Annotated,
-            Union,
-        }:
+        case special_form if value == Literal or value == Annotated or value == Union:  # noqa: PLR1714, SIM109
             return TypingSpecialFormConstant.of(special_form)
         case other_type if get_origin(value) in {Literal, Annotated, UnionType, tuple, type}:
             return BasicConstantValue.of(other_type)

sonolus/script/internal/tuple_impl.py

@@ -91,6 +91,12 @@ class TupleImpl(TransientValue):
         other = TupleImpl._accept_(other)
         return TupleImpl._accept_(self.value + other.value)
 
+    def __contains__(self, item):
+        for element in self.value:  # noqa: SIM110
+            if element == item:
+                return True
+        return False
+
     @staticmethod
     @meta_fn
     def _is_tuple_impl(value: Any) -> bool:

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.10.9
+Version: 0.11.1
 Summary: Sonolus engine development in Python
 Project-URL: Documentation, https://sonolus.py.qwewqa.xyz/
 Project-URL: Repository, https://github.com/qwewqa/sonolus.py

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

@@ -3,15 +3,15 @@ sonolus/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/backend/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/backend/blocks.py,sha256=3peyb9eYBy0s53xNVJ1KmK4IgoyVkkwG-lqDQ_VZTHc,18531
 sonolus/backend/excepthook.py,sha256=ezsTi8hPXSUhqZ7-H0rmkWcndBQcZFAShF543zzaEPM,1912
-sonolus/backend/finalize.py,sha256=ivl32G7rDSVZl2EEI1HvOHpLdhhOh-ZjavwBZgPe9uA,5286
-sonolus/backend/interpret.py,sha256=B0jqlLmEGoyO2mxpcvwRwV17Tq_gOE9wLNt26Q5QOfs,14306
+sonolus/backend/finalize.py,sha256=MRp_ATPreSmBGn8N6iwesS50rFWH9FIiQI6_Ea8RVTM,5090
+sonolus/backend/interpret.py,sha256=dnm0SJFfI4KIE6Ca2tKrLq10XwBC9EPSqN7OOYtA8Ws,14304
 sonolus/backend/ir.py,sha256=eyNXorOQY4zgKOvN4kO1MdJF3sU8H0Qw5RTPqbEjJHY,3854
 sonolus/backend/mode.py,sha256=NkcPZJm8dn83LX35uP24MtQOCnfRDFZ280dHeEEfauE,613
-sonolus/backend/node.py,sha256=eEzPP14jzWJp2xrZCAaPlNtokxdoqg0bSM7xQiwx1j8,1254
+sonolus/backend/node.py,sha256=w5y2GwSc2E9rQvGJNaMzvPW_FYjjfHw4QDUmKs1dAnc,714
 sonolus/backend/ops.py,sha256=5weB_vIxbkwCSJuzYZyKUk7vVXsSIEDJYRlvE-2ke8A,10572
 sonolus/backend/place.py,sha256=7qwV732hZ4WP-9GNN8FQSEKssPJZELip1wLXTWfop7Y,4717
 sonolus/backend/utils.py,sha256=OwD1EPh8j-hsfkLzeKNzPQojT_3kklpJou0WTJNoCbc,2337
-sonolus/backend/visitor.py,sha256=UuyOqHlX-On_gHlJTJAYoXFRk63JuAnheLcavVzXQZw,64362
+sonolus/backend/visitor.py,sha256=lEq_lkCh74_mK_saE4JeRI9_mM8MMeWRzw4mqJ0Et7c,64450
 sonolus/backend/optimize/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/backend/optimize/allocate.py,sha256=CuumoMphkpQlGRNeKLHT4FBGE0XVj5pwhfNdrqiLFSs,7535
 sonolus/backend/optimize/constant_evaluation.py,sha256=_u_VfLmd4Rlq9aKyRSeKb47352CXuf8uNgNhNTK1qe0,21510
@@ -20,7 +20,7 @@ sonolus/backend/optimize/dead_code.py,sha256=ZRJ95zJ49R-wZTzJtcSSbl5LYKHWI-byHM3
 sonolus/backend/optimize/dominance.py,sha256=3jAgXqXTbuYLpXvIm8UB06NkIOLtaoVp7pBVPcLb5vY,3259
 sonolus/backend/optimize/flow.py,sha256=xUoBpWIYi-NjqXahA6obAZaPvLj_HaDNNv7cO13e2ps,7192
 sonolus/backend/optimize/inlining.py,sha256=BEXjPbJMGTJbgA4ydC38TbEuYEFqb6oxDS0roZTmuds,10417
-sonolus/backend/optimize/liveness.py,sha256=KYQlXdKuwnRvY9JeAjwm1bzPbFwshcUxtYs7ycMRS-M,7279
+sonolus/backend/optimize/liveness.py,sha256=cj0oUrqItVjj58ZQq86nRBO5k0fuTxbmWkvrSv3H-pY,7420
 sonolus/backend/optimize/optimize.py,sha256=2gW0n1AIlwgVjY6teQlt9YP-GsFUxU-mr1ZqAZamnUo,1672
 sonolus/backend/optimize/passes.py,sha256=YyFKy6qCwcR_Ua2_SXpcBODfvBbm_ygVYcqloOlfDZI,1911
 sonolus/backend/optimize/simplify.py,sha256=wvhixe0SfditrGMh0nX0Wt0JR00JqAmz4BKBzMoBAVI,14701
@@ -28,18 +28,18 @@ 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=KOmncDKmGfgzC_FWB_LTxAl0s9w4wnaDe-luACMlCVs,8397
-sonolus/build/dev_server.py,sha256=u-p3wVdIPNTHjFLNZzPdW4JlFmeVbqqEle_O3otUhyw,10607
+sonolus/build/compile.py,sha256=YKqldBTWAXz5kzsS9Qmwy3FdrFloYZWvapR5QWsx2G0,8862
+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=gnX71RYDUOK_gYMpinQi-bLWO4csqcfiG5gFmhxzSec,1330
+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=ck_LR8z0ipVq3T9b735VwvQI2mxVUyjHylr4BFagXT8,49631
+sonolus/script/archetype.py,sha256=TZ9Semvzh6zHtUyJGN7ZrLYkux4zgqxFhrh-dGiaLEo,49907
 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=SnLXflwlX47EMQmTWnSzm9NYCi-as8lWnKzgCIK0PmM,26940
+sonolus/script/containers.py,sha256=KKySXTh_ON9hut1ScMS31ewRNnVd4t7OwpIZg2bPhno,28676
 sonolus/script/debug.py,sha256=21_bvhP2cZ4kwS3Spxp8tP6ojIfmthQxlq4gtqrt0lo,7757
 sonolus/script/easing.py,sha256=2FUJI_nfp990P_armCcRqHm2329O985glJAhSC6tnxs,11379
 sonolus/script/effect.py,sha256=SfJxSNF3RlPCRXnkt62ZlWhCXw3mmmRCsoMsvTErUP0,7960
@@ -72,12 +72,12 @@ 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=56pPjiPy8ZaxY3t5iEufsOMEj6BSy31G-5SoYqS6tPo,19694
+sonolus/script/internal/context.py,sha256=fRvdxkx7EILU54-ogR1HSjLOZnH2PVw2gQri9m86K5Y,19852
 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=U9D8A207yBbA-R9Qa9xE9zK4f0uDvGbHuFhwaIO81Ew,3364
+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/math_impls.py,sha256=ox2pBJ6ELRO0LdLn_RZxgHHs_PCgQOHIhmDkwmLxJaU,2975
 sonolus/script/internal/native.py,sha256=zOuRtgI3XJ_ExyR_ZkvbDABVc_JIWaKl62lFEL_bMaw,2007
@@ -85,10 +85,10 @@ sonolus/script/internal/random.py,sha256=6Ku5edRcDUh7rtqEEYCJz0BQavw69RALsVHS25z
 sonolus/script/internal/range.py,sha256=j94uV1NTZoCdZ8mOw3v51vD8L7h8l5vZpOAp6breD9I,3521
 sonolus/script/internal/simulation_context.py,sha256=LGxLTvxbqBIhoe1R-SfwGajNIDwIJMVsHle0kvzd500,4818
 sonolus/script/internal/transient.py,sha256=y2AWABqF1aoaP6H4_2u4MMpNioC4OsZQCtPyNI0txqo,1634
-sonolus/script/internal/tuple_impl.py,sha256=DPNdmmRmupU8Ah4_XKq6-PdT336l4nt15_uCJKQGkkk,3587
+sonolus/script/internal/tuple_impl.py,sha256=WaI5HSF5h03ddXiSHEwzY9ttfsPUItaf86Y5VbZypek,3754
 sonolus/script/internal/value.py,sha256=OngrCdmY_h6mV2Zgwqhuo4eYFad0kTk6263UAxctZcY,6963
-sonolus_py-0.10.9.dist-info/METADATA,sha256=iSSv7Kjw-_TmCXbf8qFfFtO3zd8nqyTsQ7YpxgHVoqc,554
-sonolus_py-0.10.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.10.9.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.10.9.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.10.9.dist-info/RECORD,,
+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,,