sonolus.py 0.10.0__py3-none-any.whl → 0.10.1__py3-none-any.whl

sonolus/backend/optimize/constant_evaluation.py

@@ -158,7 +158,8 @@ class SparseConditionalConstantPropagation(CompilerPass):
                     test_value = values[block]
                     new_test_value = self.evaluate_stmt(block.test, values)
                     if new_test_value != test_value:
-                        assert new_test_value is not UNDEF
+                        if new_test_value is UNDEF:
+                            continue
                         values[block] = new_test_value
                         if new_test_value is NAC:
                             flow_worklist.update(block.outgoing)
@@ -195,7 +196,8 @@ class SparseConditionalConstantPropagation(CompilerPass):
                     test_value = values[p]
                     new_test_value = self.evaluate_stmt(defn, values)
                     if new_test_value != test_value:
-                        assert new_test_value is not UNDEF
+                        if new_test_value is UNDEF:
+                            continue
                         values[p] = new_test_value
                         if new_test_value is NAC:
                             flow_worklist.update(p.outgoing)

sonolus/backend/optimize/optimize.py

@@ -10,6 +10,7 @@ from sonolus.backend.optimize.inlining import InlineVars
 from sonolus.backend.optimize.simplify import (
     CoalesceFlow,
     CoalesceSmallConditionalBlocks,
+    CombineExitBlocks,
     NormalizeSwitch,
     RemoveRedundantArguments,
     RewriteToSwitch,
@@ -55,5 +56,6 @@ STANDARD_PASSES = (
     AdvancedDeadCodeElimination(),
     CoalesceFlow(),
     NormalizeSwitch(),
+    CombineExitBlocks(),
     Allocate(),
 )

sonolus/backend/optimize/simplify.py

@@ -77,6 +77,21 @@ class CoalesceFlow(CompilerPass):
         return entry
 
 
+class CombineExitBlocks(CompilerPass):
+    def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
+        first_exit_block = None
+        for block in traverse_cfg_preorder(entry):
+            if not block.outgoing and not block.phis and not block.statements:
+                if first_exit_block is None:
+                    first_exit_block = block
+                else:
+                    for edge in [*block.incoming]:
+                        edge.dst = first_exit_block
+                        first_exit_block.incoming.add(edge)
+                    block.incoming.clear()
+        return entry
+
+
 class CoalesceSmallConditionalBlocks(CompilerPass):
     def run(self, entry: BasicBlock, config: OptimizerConfig) -> BasicBlock:
         queue = [entry]

sonolus/build/dev_server.py

@@ -117,7 +117,7 @@ class RebuildCommand:
         print("Rebuilding...")
         try:
             start_time = perf_counter()
-            server_state.project_state = ProjectContextState()
+            server_state.project_state = ProjectContextState(dev=True)
             server_state.project = project_module.project
             build_collection(
                 server_state.project,
@@ -156,11 +156,11 @@ class HelpCommand:
         print("Available Commands:\n")
 
         for entry in DETAILED_HELP_TEXT:
-            print(f"  [{entry.alias}] {entry.command}")
+            print(f"[{entry.alias}] {entry.command}")
 
             for paragraph in entry.description:
-                initial_indent = "    "
-                subsequent_indent = "    "
+                initial_indent = "  "
+                subsequent_indent = "  "
                 wrapped = textwrap.fill(
                     paragraph,
                     width=max_width - len(initial_indent),
@@ -260,7 +260,7 @@ def run_server(
     from sonolus.build.cli import build_collection
 
     cache = CompileCache()
-    project_state = ProjectContextState()
+    project_state = ProjectContextState(dev=True)
 
     start_time = perf_counter()
     build_collection(project, build_dir, config, cache=cache, project_state=project_state)

sonolus/script/array.py

@@ -194,7 +194,22 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
 
     @meta_fn
     def __getitem__(self, index: int) -> T:
-        index: Num = Num._accept_(get_positive_index(index, self.size()))
+        return self.get_unchecked(get_positive_index(index, self.size()))
+
+    @meta_fn
+    def get_unchecked(self, index: Num) -> T:
+        """Get the element at the given index possibly without bounds checking.
+
+        The compiler may still determine that the index is out of bounds and throw an error, but it may skip these
+        checks at runtime.
+
+        Args:
+            index: The index to get.
+
+        Returns:
+            The element at the given index.
+        """
+        index = Num._accept_(index)
         if index._is_py_() and 0 <= index._as_py_() < self.size():
             const_index = index._as_py_()
             if isinstance(const_index, float) and not const_index.is_integer():
@@ -213,7 +228,8 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
                 )
             elif callable(self._value):
                 return self.element_type()._from_backing_source_(
-                    lambda offset: self._value((Num(offset) + Num(const_index * self.element_type()._size_())).ir())  # type: ignore
+                    lambda offset: self._value((Num(offset) + Num(const_index * self.element_type()._size_())).ir())
+                    # type: ignore
                 )
             else:
                 raise InternalError("Unexpected array value")
@@ -238,7 +254,20 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
 
     @meta_fn
     def __setitem__(self, index: int, value: T):
-        index: Num = Num._accept_(get_positive_index(index, self.size()))
+        self.set_unchecked(get_positive_index(index, self.size()), value)
+
+    @meta_fn
+    def set_unchecked(self, index: Num, value: T):
+        """Set the element at the given index possibly without bounds checking.
+
+        The compiler may still determine that the index is out of bounds and throw an error, but it may skip these
+        checks at runtime.
+
+        Args:
+            index: The index to set.
+            value: The value to set.
+        """
+        index = Num._accept_(index)
         value = self.element_type()._accept_(value)
         if ctx():
             if isinstance(self._value, list):
@@ -288,7 +317,7 @@ class Array[T, Size](GenericValue, ArrayLike[T], metaclass=ArrayMeta):
             return False
         i = 0
         while i < self.size():
-            if self[i] != other[i]:
+            if self.get_unchecked(i) != other.get_unchecked(i):
                 return False
             i += 1
         return True

sonolus/script/array_like.py

@@ -5,8 +5,10 @@ from abc import abstractmethod
 from collections.abc import Callable, Sequence
 from typing import Any
 
+from sonolus.script.debug import assert_true
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.impl import meta_fn
+from sonolus.script.internal.math_impls import _trunc
 from sonolus.script.iterator import SonolusIterator
 from sonolus.script.maybe import Maybe, Nothing, Some
 from sonolus.script.num import Num
@@ -58,9 +60,37 @@ class ArrayLike[T](Sequence[T]):
             value: The value to set.
         """
 
+    @meta_fn
+    def get_unchecked(self, index: Num) -> T:
+        """Get the element at the given index possibly without bounds checking or conversion of negative indexes.
+
+        The compiler may still determine that the index is out of bounds and throw an error, but it may skip these
+        checks at runtime.
+
+        Args:
+            index: The index to get.
+
+        Returns:
+            The element at the given index.
+        """
+        return self[index]
+
+    @meta_fn
+    def set_unchecked(self, index: Num, value: T):
+        """Set the element at the given index possibly without bounds checking or conversion of negative indexes.
+
+        The compiler may still determine that the index is out of bounds and throw an error, but it may skip these
+        checks at runtime.
+
+        Args:
+            index: The index to set.
+            value: The value to set.
+        """
+        self[index] = value
+
     def __iter__(self) -> SonolusIterator[T]:
         """Return an iterator over the array."""
-        return _ArrayIterator(0, self)
+        return _ArrayIterator(0, self.unchecked())
 
     def __contains__(self, value: Any) -> bool:
         """Return whether any element in the array is equal to the given value.
@@ -70,7 +100,7 @@ class ArrayLike[T](Sequence[T]):
         """
         i = 0
         while i < len(self):
-            if self[i] == value:
+            if self.get_unchecked(i) == value:
                 return True
             i += 1
         return False
@@ -92,9 +122,13 @@ class ArrayLike[T](Sequence[T]):
         """
         if stop is None:
             stop = len(self)
-        i = start
+        else:
+            stop = get_positive_index(stop, len(self), check=False)
+        stop = min(stop, len(self))
+        start = get_positive_index(start, len(self), check=False)
+        i = max(start, 0)
         while i < stop:
-            if self[i] == value:
+            if self.get_unchecked(i) == value:
                 return i
             i += 1
         return -1
@@ -108,7 +142,7 @@ class ArrayLike[T](Sequence[T]):
         count = 0
         i = 0
         while i < len(self):
-            if self[i] == value:
+            if self.get_unchecked(i) == value:
                 count += 1
             i += 1
         return count
@@ -121,7 +155,7 @@ class ArrayLike[T](Sequence[T]):
         """
         i = len(self) - 1
         while i >= 0:
-            if self[i] == value:
+            if self.get_unchecked(i) == value:
                 return i
             i -= 1
         return -1
@@ -139,7 +173,7 @@ class ArrayLike[T](Sequence[T]):
         max_index = 0
         i = 1
         while i < len(self):
-            if key(self[i]) > key(self[max_index]):  # type: ignore
+            if key(self.get_unchecked(i)) > key(self.get_unchecked(max_index)):  # type: ignore
                 max_index = i
             i += 1
         return max_index
@@ -157,7 +191,7 @@ class ArrayLike[T](Sequence[T]):
         min_index = 0
         i = 1
         while i < len(self):
-            if key(self[i]) < key(self[min_index]):  # type: ignore
+            if key(self.get_unchecked(i)) < key(self.get_unchecked(min_index)):  # type: ignore
                 min_index = i
             i += 1
         return min_index
@@ -165,23 +199,25 @@ class ArrayLike[T](Sequence[T]):
     def _max_(self, key: Callable[[T], Any] | None = None) -> T:
         index = self.index_of_max(key=key)
         assert index != -1
-        return self[index]
+        return self.get_unchecked(index)
 
     def _min_(self, key: Callable[[T], Any] | None = None) -> T:
         index = self.index_of_min(key=key)
         assert index != -1
-        return self[index]
+        return self.get_unchecked(index)
 
     def swap(self, i: int, j: int, /):
-        """Swap the values at the given indices.
+        """Swap the values at the given positive indices.
 
         Args:
             i: The first index.
             j: The second index.
         """
-        temp = copy(self[i])
-        self[i] = self[j]
-        self[j] = temp
+        check_positive_index(i, len(self))
+        check_positive_index(j, len(self))
+        temp = copy(self.get_unchecked(i))
+        self.set_unchecked(i, self.get_unchecked(j))
+        self.set_unchecked(j, temp)
 
     def sort(self, *, key: Callable[[T], Any] | None = None, reverse: bool = False):
         """Sort the values in the array in place.
@@ -194,10 +230,10 @@ class ArrayLike[T](Sequence[T]):
             if key is None:
                 key = _identity  # type: ignore
             # May be worth adding a block sort variant for better performance on large arrays in the future
-            _insertion_sort(self, 0, len(self), key, reverse)  # type: ignore
+            _insertion_sort(self.unchecked(), 0, len(self), key, reverse)  # type: ignore
         else:
             # Heap sort is unstable, so if there's a key, we can't rely on it
-            _heap_sort(self, 0, len(self), reverse)  # type: ignore
+            _heap_sort(self.unchecked(), 0, len(self), reverse)  # type: ignore
 
     def shuffle(self):
         """Shuffle the values in the array in place."""
@@ -212,6 +248,10 @@ class ArrayLike[T](Sequence[T]):
             i += 1
             j -= 1
 
+    def unchecked(self) -> ArrayLike[T]:
+        """Return a proxy object that may skip bounds checking and may not support negative indexes."""
+        return UncheckedArrayProxy(self)
+
 
 def _identity[T](value: T) -> T:
     return value
@@ -268,7 +308,7 @@ class _ArrayIterator[V: ArrayLike](Record, SonolusIterator):
 
     def next(self) -> Maybe[V]:
         if self.i < len(self.array):
-            value = self.array[self.i]
+            value = self.array.get_unchecked(self.i)
             self.i += 1
             return Some(value)
         return Nothing
@@ -286,6 +326,12 @@ class _ArrayReverser[V: ArrayLike](Record, ArrayLike):
     def __setitem__(self, index: int, value: V):
         self.array[len(self) - 1 - index] = value
 
+    def get_unchecked(self, index: Num) -> V:
+        return self.array.get_unchecked(len(self) - 1 - index)
+
+    def set_unchecked(self, index: Num, value: V):
+        self.array.set_unchecked(len(self) - 1 - index, value)
+
     def reversed(self) -> ArrayLike[V]:
         return self.array
 
@@ -297,30 +343,99 @@ class _ArrayEnumerator[V: ArrayLike](Record, SonolusIterator):
 
     def next(self) -> Maybe[tuple[int, Any]]:
         if self.i < len(self.array):
-            result = (self.i + self.offset, self.array[self.i])
+            result = (self.i + self.offset, self.array.get_unchecked(self.i))
             self.i += 1
             return Some(result)
         return Nothing
 
 
 @meta_fn
-def get_positive_index(index: int, length: int) -> int:
-    """Get the positive index for the given index in the array of the given length.
+def get_positive_index(
+    index: int | float, length: int | float, *, include_end: bool = False, check: bool = True
+) -> int:
+    """Get the positive index for the given index in the array of the given length, and also perform bounds checking.
 
-    This is used to convert negative indixes relative to the end of the array to positive indices.
+    This is used to convert negative indices relative to the end of the array to positive indices.
 
     Args:
         index: The index to convert.
         length: The length of the array.
+        include_end: Whether to allow the index to be equal to the length of the array (i.e., one past the end).
+        check: Whether to perform bounds checking. Must be a compile-time constant.
 
     Returns:
-        The positive index.
+        The positive integer index.
     """
     if not ctx():
-        return index if index >= 0 else index + length
+        if check:
+            if (include_end and not -length <= index <= length) or (not include_end and not -length <= index < length):
+                raise IndexError("Index out of range")
+            if int(index) != index:
+                raise ValueError("Index must be an integer")
+            if int(length) != length:
+                raise ValueError("Length must be an integer")
+            if length < 0:
+                raise ValueError("Length must be non-negative")
+        return int(index + (index < 0) * length)
     index = Num._accept_(index)
     length = Num._accept_(length)
-    if index._is_py_() and length._is_py_():
-        return Num._accept_(index._as_py_() + length._as_py_() if index._as_py_() < 0 else index._as_py_())
+    if Num._accept_(check)._as_py_():
+        include_end = Num._accept_(include_end)
+        if not include_end._is_py_():
+            is_in_bounds = Num.and_(index >= -length, index < (length + include_end))
+        elif include_end._as_py_():
+            is_in_bounds = Num.and_(index >= -length, index <= length)
+        else:
+            is_in_bounds = Num.and_(index >= -length, index < length)
+        assert_true(Num.and_(is_in_bounds, _trunc(index) == index), "Invalid index")
+        # Skipping length check since typically these are managed by the library and unlikely to be wrong
+    return index + (index < 0) * length
+
+
+@meta_fn
+def check_positive_index(index: int, length: int, include_end: bool = False) -> int | float:
+    """Check that the given index is a valid index for the array of the given length and convert it to an integer.
+
+    Args:
+        index: The index to check.
+        length: The length of the array.
+        include_end: Whether to allow the index to be equal to the length of the array (i.e., one past the end).
+
+    Returns:
+        The index as an integer.
+    """
+    if not ctx():
+        if (include_end and not 0 <= index <= length) or (not include_end and not 0 <= index < length):
+            raise IndexError("Index out of range")
+        if int(index) != index:
+            raise ValueError("Index must be an integer")
+        if int(length) != length:
+            raise ValueError("Length must be an integer")
+        if length < 0:
+            raise ValueError("Length must be non-negative")
+        return int(index)
+    index = Num._accept_(index)
+    length = Num._accept_(length)
+    include_end = Num._accept_(include_end)
+    if not include_end._is_py_():
+        is_in_bounds = Num.and_(index >= 0, index < (length + include_end))
+    elif include_end._as_py_():
+        is_in_bounds = Num.and_(index >= 0, index <= length)
     else:
-        return index + (index < 0) * length
+        is_in_bounds = Num.and_(index >= 0, index < length)
+    assert_true(Num.and_(is_in_bounds, _trunc(index) == index), "Invalid index")
+    # Skipping length check since typically these are managed by the library and unlikely to be wrong
+    return index
+
+
+class UncheckedArrayProxy[T](Record, ArrayLike):
+    array: T
+
+    def __len__(self) -> int:
+        return len(self.array)
+
+    def __getitem__(self, index: int) -> Any:
+        return self.array.get_unchecked(index)
+
+    def __setitem__(self, index: int, value: Any):
+        self.array.set_unchecked(index, value)

sonolus/script/containers.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 from typing import Self
 
-from sonolus.backend.visitor import compile_and_call
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike, get_positive_index
 from sonolus.script.debug import error
@@ -144,11 +143,11 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             assert p == Pair(5, 6)  # The value of p has changed
             ```
         """
-        return self._array[get_positive_index(item, len(self))]
+        return self._array.get_unchecked(get_positive_index(item, self._size))
 
     def __setitem__(self, key: int, value: T):
         """Update the element at the given index."""
-        self._array[get_positive_index(key, len(self))] = value
+        self._array.set_unchecked(get_positive_index(key, self._size), value)
 
     def __delitem__(self, key: int):
         """Remove the element at the given index."""
@@ -160,8 +159,8 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         Args:
             value: The value to append.
         """
-        assert self._size < len(self._array)
-        self._array[self._size] = value
+        assert self._size < len(self._array), "Array is full"
+        self._array.set_unchecked(self._size, value)
         self._size += 1
 
     def append_unchecked(self, value: T):
@@ -172,7 +171,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         Args:
             value: The value to append.
         """
-        self._array[self._size] = value
+        self._array.set_unchecked(self._size, value)
         self._size += 1
 
     def extend(self, values: ArrayLike[T]):
@@ -181,8 +180,12 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         Args:
             values: The values to append.
         """
-        for value in values:
-            self.append(value)
+        assert self._size + len(values) <= len(self._array), "Array is full"
+        i = 0
+        while i < len(values):
+            self._array.set_unchecked(self._size + i, values[i])
+            i += 1
+        self._size += len(values)
 
     def pop(self, index: int | None = None) -> T:
         """Remove and return a copy of the value at the given index.
@@ -194,13 +197,12 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         """
         if index is None:
             index = self._size - 1
-        index = get_positive_index(index, len(self))
-        assert 0 <= index < self._size
-        value = copy(self._array[index])
+        index = get_positive_index(index, self._size)
+        value = copy(self._array.get_unchecked(index))
         self._size -= 1
         if index < self._size:
             for i in range(index, self._size):
-                self._array[i] = self._array[i + 1]
+                self._array.set_unchecked(i, self._array.get_unchecked(i + 1))
         return value
 
     def insert(self, index: int, value: T):
@@ -212,12 +214,12 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             index: The index at which to insert the value. Must be in the range [0, size].
             value: The value to insert.
         """
-        index = clamp(get_positive_index(index, len(self)), 0, self._size)
-        assert self._size < len(self._array)
+        index = clamp(get_positive_index(index, self._size, include_end=True), 0, self._size)
+        assert self._size < len(self._array), "Array is full"
         self._size += 1
         for i in range(self._size - 1, index, -1):
-            self._array[i] = self._array[i - 1]
-        self._array[index] = value
+            self._array.set_unchecked(i, self._array.get_unchecked(i - 1))
+        self._array.set_unchecked(index, value)
 
     def remove(self, value: T) -> bool:
         """Remove the first occurrence of the given value, returning whether the value was removed.
@@ -277,7 +279,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
         if index < 0:
             return False
         if index < self._size - 1:
-            self._array[index] = self._array[self._size - 1]
+            self._array.set_unchecked(index, self._array.get_unchecked(self._size - 1))
         self._size -= 1
         return True
 
@@ -293,7 +295,7 @@ class VarArray[T, Capacity](Record, ArrayLike[T]):
             return False
         i = 0
         while i < len(self):
-            if self[i] != other[i]:
+            if self.get_unchecked(i) != other.get_unchecked(i):
                 return False
             i += 1
         return True
@@ -329,12 +331,8 @@ class ArrayPointer[T](Record, ArrayLike[T]):
         """Return the type of the elements in the array."""
         return cls.type_var_value(T)
 
-    def _check_index(self, index: int):
-        assert 0 <= index < self.size
-
     @meta_fn
     def _get_item(self, item: int) -> T:
-        item = get_positive_index(item, self.size)
         if not ctx():
             raise TypeError("ArrayPointer values cannot be accessed outside of a context")
         return _deref(
@@ -344,14 +342,18 @@ class ArrayPointer[T](Record, ArrayLike[T]):
             self.element_type(),
         )
 
+    def __getitem__(self, item) -> T:
+        return self.get_unchecked(get_positive_index(item, self.size))
+
+    def __setitem__(self, key: int, value: T):
+        self.set_unchecked(get_positive_index(key, self.size), value)
+
     @meta_fn
-    def __getitem__(self, item: int) -> T:
-        compile_and_call(self._check_index, item)
+    def get_unchecked(self, item: int) -> T:
         return self._get_item(item)._get_()
 
     @meta_fn
-    def __setitem__(self, key: int, value: T):
-        compile_and_call(self._check_index, key)
+    def set_unchecked(self, key: int, value: T):
         dst = self._get_item(key)
         if self.element_type()._is_value_type_():
             dst._set_(value)
@@ -519,7 +521,7 @@ class ArrayMap[K, V, Capacity](Record):
             ```
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 return entry.value
         error()
@@ -535,12 +537,12 @@ class ArrayMap[K, V, Capacity](Record):
             value: The value to associate with the key
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 entry.value = value
                 return
-        assert self._size < self.capacity()
-        self._array[self._size] = _ArrayMapEntry(key, value)
+        assert self._size < self.capacity(), "Map is full"
+        self._array.set_unchecked(self._size, _ArrayMapEntry(key, value))
         self._size += 1
 
     def __delitem__(self, key: K):
@@ -552,11 +554,11 @@ class ArrayMap[K, V, Capacity](Record):
             key: The key to remove
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 self._size -= 1
                 if i < self._size:
-                    self._array[i] = self._array[self._size]
+                    self._array.set_unchecked(i, self._array.get_unchecked(self._size))
                 return
         error()
 
@@ -570,7 +572,7 @@ class ArrayMap[K, V, Capacity](Record):
             True if the key is present, False otherwise.
         """
         for i in range(self._size):  # noqa: SIM110
-            if self._array[i].key == key:
+            if self._array.get_unchecked(i).key == key:
                 return True
         return False
 
@@ -586,12 +588,12 @@ class ArrayMap[K, V, Capacity](Record):
             The value associated with the key
         """
         for i in range(self._size):
-            entry = self._array[i]
+            entry = self._array.get_unchecked(i)
             if entry.key == key:
                 value = copy(entry.value)
                 self._size -= 1
                 if i < self._size:
-                    self._array[i] = self._array[self._size]
+                    self._array.set_unchecked(i, self._array.get_unchecked(self._size))
                 return value
         error()
 
@@ -606,7 +608,7 @@ class _ArrayMapKeyIterator[K, V, Capacity](Record, SonolusIterator):
 
     def next(self) -> Maybe[K]:
         if self._index < len(self._map):
-            key = self._map._array[self._index].key
+            key = self._map._array.get_unchecked(self._index).key
             self._index += 1
             return Some(key)
         return Nothing
@@ -618,7 +620,7 @@ class _ArrayMapValueIterator[K, V, Capacity](Record, SonolusIterator):
 
     def next(self) -> Maybe[V]:
         if self._index < len(self._map):
-            value = self._map._array[self._index].value
+            value = self._map._array.get_unchecked(self._index).value
             self._index += 1
             return Some(value)
         return Nothing
@@ -630,7 +632,7 @@ class _ArrayMapEntryIterator[K, V, Capacity](Record, SonolusIterator):
 
     def next(self) -> Maybe[tuple[K, V]]:
         if self._index < len(self._map):
-            entry = self._map._array[self._index]
+            entry = self._map._array.get_unchecked(self._index)
             result = (entry.key, entry.value)
             self._index += 1
             return Some(result)

sonolus/script/debug.py

@@ -18,17 +18,23 @@ debug_log_callback = ContextVar[Callable[[Num], None]]("debug_log_callback")
 
 @meta_fn
 def error(message: str | None = None) -> Never:  # type: ignore
-    """Raise an error.
+    """Raise an error, and if in a dev build, log a message and pause the game.
 
     This function is used to raise an error during runtime.
     When this happens, the game will pause in debug mode. The current callback will also immediately return 0.
+
+    In non-dev builds, this function will terminate the current callback silently.
+
+    Args:
+        message: The message to log.
     """
     message = validate_value(message)._as_py_() or "Error"  # type: ignore
     if not isinstance(message, str):
         raise ValueError("Expected a string")
     if ctx():
-        debug_log(ctx().map_debug_message(message))
-        debug_pause()
+        if ctx().project_state.dev:
+            debug_log(ctx().map_debug_message(message))
+            debug_pause()
         terminate()
     else:
         raise RuntimeError(message)
@@ -40,6 +46,9 @@ def static_error(message: str | None = None) -> Never:
 
     This function is used to raise an error during compile-time if the compiler cannot guarantee that
     this function will not be called during runtime.
+
+    Args:
+        message: The message to log.
     """
     message = validate_value(message)._as_py_() or "Error"  # type: ignore
     if not isinstance(message, str):
@@ -70,19 +79,38 @@ def debug_pause():
 
 @meta_fn
 def notify(message: str):
-    """Log a code that can be decoded by the dev server and pause the game if in debug mode."""
+    """Log a code that can be decoded by the dev server and pause the game if in debug mode and in a dev build.
+
+    Does nothing if not a dev build.
+
+    Args:
+        message: The message to log.
+    """
     message = validate_value(message)._as_py_()  # type: ignore
     if not isinstance(message, str):
         raise ValueError("Expected a string")
     if ctx():
-        debug_log(ctx().map_debug_message(message))
-        debug_pause()
+        if ctx().project_state.dev:
+            debug_log(ctx().map_debug_message(message))
+            debug_pause()
     else:
         print(f"[NOTIFY] {message}")
 
 
 @meta_fn
-def assert_true(value: int | float | bool, message: str | None = None):
+def require(value: int | float | bool, message: str | None = None):
+    """Require a condition to be true, or raise an error.
+
+    Similar to assert, but does not get stripped in non-dev builds.
+
+    If in a dev build, this function will log a message and pause the game if the condition is false.
+
+    In non-dev builds, this function will terminate the current callback silently if the condition is false.
+
+    Args:
+        value: The condition to check.
+        message: The message to log if the condition is false.
+    """
     if not ctx():
         if not value:
             raise AssertionError(message if message is not None else "Assertion failed")
@@ -104,6 +132,13 @@ def assert_true(value: int | float | bool, message: str | None = None):
         set_ctx(t_branch)
 
 
+@meta_fn
+def assert_true(value: int | float | bool, message: str | None = None):
+    if ctx() and not ctx().project_state.dev:
+        return
+    require(value, message)
+
+
 def assert_false(value: int | float | bool, message: str | None = None):
     assert_true(not value, message)
 

sonolus/script/effect.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, check_positive_index
 from sonolus.script.debug import static_error
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
@@ -111,7 +111,10 @@ class EffectGroup(Record, ArrayLike[Effect]):
         return self.size
 
     def __getitem__(self, index: int) -> Effect:
-        assert 0 <= index < self.size
+        check_positive_index(index, self.size)
+        return Effect(self.start_id + index)
+
+    def get_unchecked(self, index: int) -> Effect:
         return Effect(self.start_id + index)
 
     def __setitem__(self, index: int, value: Effect) -> None:

sonolus/script/internal/builtin_impls.py

@@ -3,7 +3,7 @@ from typing import Never, assert_never
 from sonolus.backend.ops import Op
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
-from sonolus.script.debug import error
+from sonolus.script.debug import error, require
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.dict_impl import DictImpl
 from sonolus.script.internal.impl import meta_fn, validate_value
@@ -192,7 +192,7 @@ def _max_num_iterator(iterable, default, key):
     iterator = iterable.__iter__()  # noqa: PLC2801
     initial = iterator.next()
     if initial.is_nothing:
-        assert default is not None
+        require(default is not None, "default must be provided if the iterator is empty")
         return default
     if key is not None:
         result = initial.get_unsafe()
@@ -285,7 +285,7 @@ def _min_num_iterator(iterable, default, key):
     iterator = iterable.__iter__()  # noqa: PLC2801
     initial = iterator.next()
     if initial.is_nothing:
-        assert default is not None
+        require(default is not None, "default must be provided if the iterator is empty")
         return default
     if key is not None:
         result = initial.get_unsafe()
@@ -371,7 +371,7 @@ def _sum(iterable, /, start=0):
 
 
 def _next(iterator):
-    assert isinstance(iterator, SonolusIterator)
+    require(isinstance(iterator, SonolusIterator), "Only subclasses of SonolusIterator are supported as iterators")
     value = iterator.next()
     if value.is_some:
         return value.get_unsafe()

sonolus/script/internal/context.py

@@ -44,17 +44,20 @@ class ProjectContextState:
     const_mappings: dict[Any, int]
     debug_str_mappings: dict[str, int]
     lock: Lock
+    dev: bool
 
     def __init__(
         self,
         rom: ReadOnlyMemory | None = None,
         const_mappings: dict[Any, int] | None = None,
         debug_str_mappings: dict[str, int] | None = None,
+        dev: bool = False,
     ):
         self.rom = ReadOnlyMemory() if rom is None else rom
         self.const_mappings = {} if const_mappings is None else const_mappings
         self.debug_str_mappings = {} if debug_str_mappings is None else debug_str_mappings
         self.lock = Lock()
+        self.dev = dev
 
 
 class ModeContextState:

sonolus/script/internal/math_impls.py

@@ -4,72 +4,72 @@ from sonolus.backend.ops import Op
 from sonolus.script.internal.native import native_function
 
 
-@native_function(Op.Sin)
+@native_function(Op.Sin, const_eval=True)
 def _sin(x: float) -> float:
     return math.sin(x)
 
 
-@native_function(Op.Cos)
+@native_function(Op.Cos, const_eval=True)
 def _cos(x: float) -> float:
     return math.cos(x)
 
 
-@native_function(Op.Tan)
+@native_function(Op.Tan, const_eval=True)
 def _tan(x: float) -> float:
     return math.tan(x)
 
 
-@native_function(Op.Arcsin)
+@native_function(Op.Arcsin, const_eval=True)
 def _asin(x: float) -> float:
     return math.asin(x)
 
 
-@native_function(Op.Arccos)
+@native_function(Op.Arccos, const_eval=True)
 def _acos(x: float) -> float:
     return math.acos(x)
 
 
-@native_function(Op.Arctan)
+@native_function(Op.Arctan, const_eval=True)
 def _atan(x: float) -> float:
     return math.atan(x)
 
 
-@native_function(Op.Arctan2)
+@native_function(Op.Arctan2, const_eval=True)
 def _atan2(y: float, x: float) -> float:
     return math.atan2(y, x)
 
 
-@native_function(Op.Sinh)
+@native_function(Op.Sinh, const_eval=True)
 def _sinh(x: float) -> float:
     return math.sinh(x)
 
 
-@native_function(Op.Cosh)
+@native_function(Op.Cosh, const_eval=True)
 def _cosh(x: float) -> float:
     return math.cosh(x)
 
 
-@native_function(Op.Tanh)
+@native_function(Op.Tanh, const_eval=True)
 def _tanh(x: float) -> float:
     return math.tanh(x)
 
 
-@native_function(Op.Floor)
+@native_function(Op.Floor, const_eval=True)
 def _floor(x: float) -> float:
     return math.floor(x)
 
 
-@native_function(Op.Ceil)
+@native_function(Op.Ceil, const_eval=True)
 def _ceil(x: float) -> float:
     return math.ceil(x)
 
 
-@native_function(Op.Trunc)
+@native_function(Op.Trunc, const_eval=True)
 def _trunc(x: float) -> float:
     return math.trunc(x)
 
 
-@native_function(Op.Round)
+@native_function(Op.Round, const_eval=True)
 def __round(x: float) -> float:
     return round(x)
 
@@ -80,12 +80,12 @@ def _round(x: float, n: int = 0) -> float:
     return __round(x * 10**n) / 10**n
 
 
-@native_function(Op.Frac)
+@native_function(Op.Frac, const_eval=True)
 def frac(x: float) -> float:
     return x % 1
 
 
-@native_function(Op.Log)
+@native_function(Op.Log, const_eval=True)
 def _ln(x: float) -> float:
     return math.log(x)
 
@@ -101,19 +101,19 @@ def _sqrt(x: float) -> float:
     return x**0.5
 
 
-@native_function(Op.Degree)
+@native_function(Op.Degree, const_eval=True)
 def _degrees(x: float) -> float:
     """Convert radians to degrees."""
     return math.degrees(x)
 
 
-@native_function(Op.Radian)
+@native_function(Op.Radian, const_eval=True)
 def _radians(x: float) -> float:
     """Convert degrees to radians."""
     return math.radians(x)
 
 
-@native_function(Op.Rem)
+@native_function(Op.Rem, const_eval=True)
 def _remainder(x: float, y: float) -> float:
     # This is different from math.remainder in Python's math package, which could be confusing
     return math.copysign(abs(x) % abs(y), x)

sonolus/script/internal/native.py

@@ -20,7 +20,7 @@ def native_call(op: Op, *args: int | float | bool) -> Num:
     return Num._from_place_(result)
 
 
-def native_function[**P, R](op: Op) -> Callable[[Callable[P, R]], Callable[P, R]]:
+def native_function[**P, R](op: Op, const_eval: bool = False) -> Callable[[Callable[P, R]], Callable[P, R]]:
     def decorator(fn: Callable[P, int | float | bool]) -> Callable[P, Num]:
         signature = inspect.signature(fn)
 
@@ -30,6 +30,12 @@ def native_function[**P, R](op: Op) -> Callable[[Callable[P, R]], Callable[P, R]
             if len(args) < sum(1 for p in signature.parameters.values() if p.default == inspect.Parameter.empty):
                 raise TypeError(f"Expected {len(signature.parameters)} arguments, got {len(args)}")
             if ctx():
+                if const_eval:
+                    args = tuple(validate_value(arg) for arg in args)
+                    if not all(_is_num(arg) for arg in args):
+                        raise RuntimeError("All arguments must be of type Num")
+                    if all(arg._is_py_() for arg in args):
+                        return Num._accept_(fn(*[arg._as_py_() for arg in args]))
                 bound_args = signature.bind(*args)
                 bound_args.apply_defaults()
                 return native_call(op, *bound_args.args)

sonolus/script/internal/range.py

@@ -41,6 +41,9 @@ class Range(Record, ArrayLike[int]):
     def __getitem__(self, index: int) -> int:
         return self.start + get_positive_index(index, len(self)) * self.step
 
+    def get_unchecked(self, index: Num) -> int:
+        return self.start + index * self.step
+
     def __setitem__(self, index: int, value: int):
         raise TypeError("Range does not support item assignment")
 

sonolus/script/interval.py

@@ -374,9 +374,10 @@ def interp(
     Returns:
         The interpolated value.
     """
-    assert len(xp) == len(fp)
-    assert len(xp) >= 2
+    assert len(xp) == len(fp), "xp and fp must have the same length"
+    assert len(xp) >= 2, "xp and fp must have at least 2 elements"
     for i in range_or_tuple(1, len(xp) - 1):
+        assert xp[i] > xp[i - 1], "xp must be in increasing order"
         # At i == 1, x may be less than x[0], but since we're extrapolating, we use the first segment regardless.
         if x <= xp[i]:
             return remap(xp[i - 1], xp[i], fp[i - 1], fp[i], x)
@@ -402,11 +403,12 @@ def interp_clamped(
     Returns:
         The interpolated value.
     """
-    assert len(xp) == len(fp)
-    assert len(xp) >= 2
+    assert len(xp) == len(fp), "xp and fp must have the same length"
+    assert len(xp) >= 2, "xp and fp must have at least 2 elements"
     if x <= xp[0]:
         return fp[0]
     for i in range_or_tuple(1, len(xp)):
+        assert xp[i] > xp[i - 1], "xp must be in increasing order"
         if x <= xp[i]:
             return remap(xp[i - 1], xp[i], fp[i - 1], fp[i], x)
     return fp[-1]

sonolus/script/particle.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, check_positive_index
 from sonolus.script.debug import static_error
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
@@ -71,7 +71,10 @@ class ParticleGroup(Record, ArrayLike[Particle]):
         return self.size
 
     def __getitem__(self, index: int) -> Particle:
-        assert 0 <= index < self.size
+        check_positive_index(index, self.size)
+        return Particle(self.start_id + index)
+
+    def get_unchecked(self, index: int) -> Particle:
         return Particle(self.start_id + index)
 
     def __setitem__(self, index: int, value: Particle) -> None:

sonolus/script/sprite.py

@@ -4,11 +4,12 @@ from enum import StrEnum
 from typing import Annotated, Any, NewType, dataclass_transform, get_origin
 
 from sonolus.backend.ops import Op
-from sonolus.script.array_like import ArrayLike
+from sonolus.script.array_like import ArrayLike, check_positive_index
 from sonolus.script.debug import static_error
 from sonolus.script.internal.impl import perf_meta_fn
 from sonolus.script.internal.introspection import get_field_specifiers
 from sonolus.script.internal.native import native_function
+from sonolus.script.num import Num
 from sonolus.script.quad import QuadLike, flatten_quad
 from sonolus.script.record import Record
 from sonolus.script.vec import Vec2
@@ -138,7 +139,10 @@ class SpriteGroup(Record, ArrayLike[Sprite]):
         return self.size
 
     def __getitem__(self, index: int) -> Sprite:
-        assert 0 <= index < self.size
+        check_positive_index(index, self.size)
+        return Sprite(self.start_id + index)
+
+    def get_unchecked(self, index: Num) -> Sprite:
         return Sprite(self.start_id + index)
 
     def __setitem__(self, index: int, value: Sprite) -> None:

sonolus/script/transform.py

@@ -325,6 +325,7 @@ class Transform2d(Record):
         Returns:
             A new normalized transform.
         """
+        assert self.a22 != 0, "Cannot normalize transform with a22 == 0"
         return Transform2d(
             self.a00 / self.a22,
             self.a01 / self.a22,

sonolus/script/vec.py

@@ -158,6 +158,7 @@ class Vec2(Record):
             A new vector with magnitude 1.
         """
         magnitude = (self.x**2 + self.y**2) ** 0.5
+        assert magnitude != 0, "Cannot normalize a zero vector"
         return Vec2._quick_construct(x=self.x / magnitude, y=self.y / magnitude)
 
     @perf_meta_fn

{sonolus_py-0.10.0.dist-info → sonolus_py-0.10.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.10.0
+Version: 0.10.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.0.dist-info → sonolus_py-0.10.1.dist-info}/RECORD

@@ -14,81 +14,81 @@ sonolus/backend/utils.py,sha256=OwD1EPh8j-hsfkLzeKNzPQojT_3kklpJou0WTJNoCbc,2337
 sonolus/backend/visitor.py,sha256=PxxIvhP3AzGS3hZMulaF5CO2aswiBMyZc_Hwo040hTk,64421
 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--9moGsXFzrgweWWwHIiEuuMzwetd1IOjjtrCscoNM,21450
+sonolus/backend/optimize/constant_evaluation.py,sha256=_u_VfLmd4Rlq9aKyRSeKb47352CXuf8uNgNhNTK1qe0,21510
 sonolus/backend/optimize/copy_coalesce.py,sha256=AS-TmOoVG2oHxU8fejMxkOdRqfcaWdN53H4POL3G-O4,4797
 sonolus/backend/optimize/dead_code.py,sha256=ZRJ95zJ49R-wZTzJtcSSbl5LYKHWI-byHM3n6jOyAqc,8307
 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/optimize.py,sha256=sY1GFLjAslVgMsLzocC3Ctk0R9SqwybWyqzFB6WMntI,1624
+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=RDNVTKfC7ByRyxY5z30_ShimOAKth_pKlVFV_36pDG4,14082
+sonolus/backend/optimize/simplify.py,sha256=wvhixe0SfditrGMh0nX0Wt0JR00JqAmz4BKBzMoBAVI,14701
 sonolus/backend/optimize/ssa.py,sha256=raQO0furQQRPYb8iIBKfNrJlj-_5wqtI4EWNfLZ8QFo,10834
 sonolus/build/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 sonolus/build/cli.py,sha256=GQHzXGj55pqz84AnOKa21t74Nrbt7gUKfQe88gXIKtI,9357
 sonolus/build/collection.py,sha256=6hniAzriPWBKUeGDkXabNXpbdHiHnqiK9shs6U1OExM,12748
 sonolus/build/compile.py,sha256=KOmncDKmGfgzC_FWB_LTxAl0s9w4wnaDe-luACMlCVs,8397
-sonolus/build/dev_server.py,sha256=WSih91Df2dPIRHdObjZ_sGnL3LKPJgv9m9RD_Zr7BqU,9881
+sonolus/build/dev_server.py,sha256=EOnIgAkFZAKiCwhFqDyKMLkJfYtGdjlacqYWZ2F2mAU,9891
 sonolus/build/engine.py,sha256=No_q4O6PRMwxEPHvSlbaBKVe5CXJswWFZdR3xgfIuI8,14672
 sonolus/build/level.py,sha256=KLqUAtxIuIqrzeFURJA97rdqjA5pcvYSmwNZQhElaMQ,702
 sonolus/build/node.py,sha256=gnX71RYDUOK_gYMpinQi-bLWO4csqcfiG5gFmhxzSec,1330
 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/array.py,sha256=dzuAd72DcVGG8Ix5H69eIZpGiFSoH_rErKFNgQ5DEKI,12399
-sonolus/script/array_like.py,sha256=hUDdDaP306kflVv9YomdHIMXogrVjxsBXCrLvB9QpuE,9681
+sonolus/script/array.py,sha256=0ZUI0alrwKztpQOpZodZPSPafu5cGwaiffBGQbY19LQ,13316
+sonolus/script/array_like.py,sha256=E6S4TW2muXgcyVkhUASQVt7JSYUkpvdJPgHz6YiSHNo,14708
 sonolus/script/bucket.py,sha256=yIod3DgX7Hv7RLe-4Cn81FcydvbkbdMt26FzpRj7oUI,7794
-sonolus/script/containers.py,sha256=L3rzPfN1cDb2m02k9qRyjnGxJx07X3q3MccCaL5tNJ8,18773
-sonolus/script/debug.py,sha256=tok7uKzoVgps0V8ANAlcrZ0NJf5wVWK7ICozn8IVd30,6351
+sonolus/script/containers.py,sha256=qKIyTs5Q_UpQggR6s0AfgWQAvPv-IM2DW9s951koKSc,19303
+sonolus/script/debug.py,sha256=YOq06q5ahWI-uEG5naonOBWF62Qn_Af7JSV_Ra8Zr6E,7415
 sonolus/script/easing.py,sha256=2FUJI_nfp990P_armCcRqHm2329O985glJAhSC6tnxs,11379
-sonolus/script/effect.py,sha256=pYihzdVOS3ekiiTwPVg6czUW1UNv0CJNIk-xBsYRdq8,7792
+sonolus/script/effect.py,sha256=aOxhBmX6I8vUS-bE53YFNBEN3wwdmpraqZjLeCqbgIY,7920
 sonolus/script/engine.py,sha256=etI9dJsQ7V9YZICVNZg54WqpLijPxG8eTPHiV-_EiG8,10687
 sonolus/script/globals.py,sha256=nlXSNS4NRXsgQU2AJImVIs752h1WqsMnShSKgU011c4,10270
 sonolus/script/instruction.py,sha256=Dd-14D5Amo8nhPBr6DNyg2lpYw_rqZkT8Kix3HkfE7k,6793
-sonolus/script/interval.py,sha256=2gjnEr11RExyXGhZuUjRRgx-ZrNynWLPj-b89lQCnLQ,11688
+sonolus/script/interval.py,sha256=vnwm3CiB0rurRolA53wRzb_jTPguvOKnie4glE1MwsE,11986
 sonolus/script/iterator.py,sha256=_ICY_yX7FG0Zbgs3NhVnaIBdVDpAeXjxJ_CQtq30l7Y,3774
 sonolus/script/level.py,sha256=X3-V99ihruYYCcPdch66dHi_ydCWXXn7epviLLjxW8w,8288
 sonolus/script/maybe.py,sha256=VYvTWgEfPzoXqI3i3zXhc4dz0pWBVoHmW8FtWH0GQvM,8194
 sonolus/script/metadata.py,sha256=ttRK27eojHf3So50KQJ-8yj3udZoN1bli5iD-knaeLw,753
 sonolus/script/num.py,sha256=9pahERQcIh16ytoDjJB3u3L6fH1Xh11Y99l8SYxkjMA,15927
 sonolus/script/options.py,sha256=05y_4j2kr8fzct5FLqmSp5ZAjnq6-slmNgtsh4fVEpg,9451
-sonolus/script/particle.py,sha256=rCEJGT7frqJqZLi4EBCqDs4QBvLW6Ys640nD1FxiVec,10326
+sonolus/script/particle.py,sha256=BuBM7fvLAj79upLf9yI4FyZhVUK7-H2dFj0D7UiYS7I,10458
 sonolus/script/pointer.py,sha256=FoOfyD93r0G5d_2BaKfeOT9SqkOP3hq6sqtOs_Rb0c8,1511
 sonolus/script/printing.py,sha256=mNYu9QWiacBBGZrnePZQMVwbbguoelUps9GiOK_aVRU,2096
 sonolus/script/project.py,sha256=4svmMWYihF7olmYSMS5uoSjlnzbd7Ip2zTRY86oL1L8,4629
 sonolus/script/quad.py,sha256=8lZ_5-eWeqePldNGBkNZTuOgS_IRb41URgGwSW4h2T0,14445
 sonolus/script/record.py,sha256=BrQ8k-O4WX9FT_EfoRmNnKC1BZM9gWydZ4R4swh3chc,13051
 sonolus/script/runtime.py,sha256=TjxcfIIPRH6oxlEjWfLHDj1oo7fPfwTBdwETfnhN7h4,33331
-sonolus/script/sprite.py,sha256=q2i9AwFHO6X_li2hgwpP79fSG-ZriX0gMGhr3yTI8p8,18245
+sonolus/script/sprite.py,sha256=d_wqUn7oMbkLZMdvnyDZVBykycTtiwegcarWXMcZMUI,18408
 sonolus/script/stream.py,sha256=Fu02SNjH8j1FQ9_7ncacR9uRIhoWtAZR-sTi8qBT7rA,24707
 sonolus/script/text.py,sha256=wxujIgKYcCfl2AD2_Im8g3vh0lDEHYwTSRZg9wsBPEU,13402
 sonolus/script/timing.py,sha256=DklMvuxcFg3MzXsecUo6Yhdk7pScOJ7STwXvAiTvLKM,3067
-sonolus/script/transform.py,sha256=w5mr7hTuNYU0eTAdnN_wTVibaQa0mZrkl-W-kgewJxQ,21345
+sonolus/script/transform.py,sha256=4aS7-NNzX0v9KMXZ4gIGOaU1Cd-ok7DO_OvIBca0mGU,21418
 sonolus/script/ui.py,sha256=DYPGWIjHj1IFPxW1zaEuIUQx0b32FJPXtiwCvrtJ6oo,7528
 sonolus/script/values.py,sha256=6iJG6h4IDlbcK8FH4GENSHOQc7C_7fCGa34wM80qToA,1629
-sonolus/script/vec.py,sha256=-BV4UpqhYUjWZp1AfwuDqEoc1hLzvoch_C2L9Npk-Rs,8047
+sonolus/script/vec.py,sha256=UIgXRNum420VrXXbkHjZuQx2gFsvgV8tydi9_zOqwuc,8111
 sonolus/script/internal/__init__.py,sha256=T6rzLoiOUaiSQtaHMZ88SNO-ijSjSSv33TKtUwu-Ms8,136
-sonolus/script/internal/builtin_impls.py,sha256=R1h3IOlWzolPfc9yoma2cBN0F5cBhj_JNP-TTdKoBlc,13186
+sonolus/script/internal/builtin_impls.py,sha256=tpNbaH6fLICd8TYj9Hf_wrPSWk3RkhmSPVN9nqOuqj4,13372
 sonolus/script/internal/callbacks.py,sha256=vWzJG8uiJoEtsNnbeZPqOHogCwoLpz2D1MnHY2wVV8s,2801
 sonolus/script/internal/constant.py,sha256=3ycbGkDJVUwcrCZ96vLjAoAARgsvaqDM8rJ_YCrLrvo,4289
-sonolus/script/internal/context.py,sha256=Q_0wfTqjM0BF81dK69OZcIftRF082XtGJLW47SfLpsU,18715
+sonolus/script/internal/context.py,sha256=C0VMHBRppsnwPDVPc03Lpz7tO9djQMB5ELdtpFPMdsk,18779
 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/introspection.py,sha256=guL9_NR2D3OJAnNpeFdyYkO_vVXk-3KQr2-y4YielM0,1133
-sonolus/script/internal/math_impls.py,sha256=nHSLgA7Tcx7jY1p07mYBCeSRmVx713bwdNayCIcaXSE,2652
-sonolus/script/internal/native.py,sha256=DQxmzxgLG_UsLpXhIEtBdO7eIeDFprU78UBDC4OZzw0,1597
+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
-sonolus/script/internal/range.py,sha256=YeqB1TPh7JdvW6kDuA5tpQL5psVxYQjepBZs7RNcP5Y,3426
+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/value.py,sha256=OngrCdmY_h6mV2Zgwqhuo4eYFad0kTk6263UAxctZcY,6963
-sonolus_py-0.10.0.dist-info/METADATA,sha256=DsXCiBAkO45upsutT8V7g_5jfLj9Duu1JCMGegtRSMg,554
-sonolus_py-0.10.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-sonolus_py-0.10.0.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
-sonolus_py-0.10.0.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
-sonolus_py-0.10.0.dist-info/RECORD,,
+sonolus_py-0.10.1.dist-info/METADATA,sha256=hWRJb86bOgMAB7N1x5H_hdY8zK77ZwIia41--jjZTdI,554
+sonolus_py-0.10.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+sonolus_py-0.10.1.dist-info/entry_points.txt,sha256=oTYspY_b7SA8TptEMTDxh4-Aj-ZVPnYC9f1lqH6s9G4,54
+sonolus_py-0.10.1.dist-info/licenses/LICENSE,sha256=JEKpqVhQYfEc7zg3Mj462sKbKYmO1K7WmvX1qvg9IJk,1067
+sonolus_py-0.10.1.dist-info/RECORD,,