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

sonolus/build/engine.py

@@ -24,7 +24,7 @@ from sonolus.script.internal.callbacks import (
     update_callback,
     update_spawn_callback,
 )
-from sonolus.script.internal.context import ReadOnlyMemory
+from sonolus.script.internal.context import ProjectContextState, ReadOnlyMemory
 from sonolus.script.options import Options
 from sonolus.script.particle import Particles
 from sonolus.script.project import BuildConfig
@@ -69,12 +69,14 @@ def package_engine(
     engine: EngineData,
     config: BuildConfig | None = None,
     cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
 ):
     if cache is None:
         cache = CompileCache()
 
     config = config or BuildConfig()
-    rom = ReadOnlyMemory()
+    if project_state is None:
+        project_state = ProjectContextState()
     configuration = build_engine_configuration(engine.options, engine.ui)
     if no_gil():
         # process_cpu_count is available in Python 3.13+
@@ -99,7 +101,7 @@ def package_engine(
                 effects=play_mode.effects,
                 particles=play_mode.particles,
                 buckets=play_mode.buckets,
-                rom=rom,
+                project_state=project_state,
                 config=config,
                 thread_pool=thread_pool,
                 cache=cache,
@@ -111,7 +113,7 @@ def package_engine(
                 effects=watch_mode.effects,
                 particles=watch_mode.particles,
                 buckets=watch_mode.buckets,
-                rom=rom,
+                project_state=project_state,
                 update_spawn=watch_mode.update_spawn,
                 config=config,
                 thread_pool=thread_pool,
@@ -121,7 +123,7 @@ def package_engine(
                 build_preview_mode,
                 archetypes=preview_mode.archetypes,
                 skin=preview_mode.skin,
-                rom=rom,
+                project_state=project_state,
                 config=config,
                 thread_pool=thread_pool,
                 cache=cache,
@@ -136,7 +138,7 @@ def package_engine(
                 preprocess=tutorial_mode.preprocess,
                 navigate=tutorial_mode.navigate,
                 update=tutorial_mode.update,
-                rom=rom,
+                project_state=project_state,
                 config=config,
                 thread_pool=thread_pool,
                 cache=cache,
@@ -154,7 +156,7 @@ def package_engine(
             effects=play_mode.effects,
             particles=play_mode.particles,
             buckets=play_mode.buckets,
-            rom=rom,
+            project_state=project_state,
             config=config,
             thread_pool=None,
             cache=cache,
@@ -165,7 +167,7 @@ def package_engine(
             effects=watch_mode.effects,
             particles=watch_mode.particles,
             buckets=watch_mode.buckets,
-            rom=rom,
+            project_state=project_state,
             update_spawn=watch_mode.update_spawn,
             config=config,
             thread_pool=None,
@@ -174,7 +176,7 @@ def package_engine(
         preview_data = build_preview_mode(
             archetypes=preview_mode.archetypes,
             skin=preview_mode.skin,
-            rom=rom,
+            project_state=project_state,
             config=config,
             thread_pool=None,
             cache=cache,
@@ -188,7 +190,7 @@ def package_engine(
             preprocess=tutorial_mode.preprocess,
             navigate=tutorial_mode.navigate,
             update=tutorial_mode.update,
-            rom=rom,
+            project_state=project_state,
             config=config,
             thread_pool=None,
             cache=cache,
@@ -200,7 +202,7 @@ def package_engine(
         watch_data=package_data(watch_data),
         preview_data=package_data(preview_data),
         tutorial_data=package_data(tutorial_data),
-        rom=package_rom(rom),
+        rom=package_rom(project_state.rom),
     )
 
 
@@ -209,7 +211,7 @@ def validate_engine(
     config: BuildConfig | None = None,
 ):
     config = config or BuildConfig()
-    rom = ReadOnlyMemory()
+    project_state = ProjectContextState()
 
     play_mode = engine.play if config.build_play else empty_play_mode()
     watch_mode = engine.watch if config.build_watch else empty_watch_mode()
@@ -222,7 +224,7 @@ def validate_engine(
         effects=play_mode.effects,
         particles=play_mode.particles,
         buckets=play_mode.buckets,
-        rom=rom,
+        project_state=project_state,
         config=config,
         thread_pool=None,
         validate_only=True,
@@ -233,7 +235,7 @@ def validate_engine(
         effects=watch_mode.effects,
         particles=watch_mode.particles,
         buckets=watch_mode.buckets,
-        rom=rom,
+        project_state=project_state,
         update_spawn=watch_mode.update_spawn,
         config=config,
         thread_pool=None,
@@ -242,7 +244,7 @@ def validate_engine(
     build_preview_mode(
         archetypes=preview_mode.archetypes,
         skin=preview_mode.skin,
-        rom=rom,
+        project_state=project_state,
         config=config,
         thread_pool=None,
         validate_only=True,
@@ -256,7 +258,7 @@ def validate_engine(
         preprocess=tutorial_mode.preprocess,
         navigate=tutorial_mode.navigate,
         update=tutorial_mode.update,
-        rom=rom,
+        project_state=project_state,
         config=config,
         thread_pool=None,
         validate_only=True,
@@ -279,7 +281,7 @@ def build_play_mode(
     effects: Effects,
     particles: Particles,
     buckets: Buckets,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
@@ -288,7 +290,7 @@ def build_play_mode(
     return {
         **compile_mode(
             mode=Mode.PLAY,
-            rom=rom,
+            project_state=project_state,
             archetypes=archetypes,
             global_callbacks=None,
             passes=config.passes,
@@ -309,7 +311,7 @@ def build_watch_mode(
     effects: Effects,
     particles: Particles,
     buckets: Buckets,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     update_spawn: Callable[[], float],
     config: BuildConfig,
     thread_pool: Executor | None = None,
@@ -319,7 +321,7 @@ def build_watch_mode(
     return {
         **compile_mode(
             mode=Mode.WATCH,
-            rom=rom,
+            project_state=project_state,
             archetypes=archetypes,
             global_callbacks=[(update_spawn_callback, update_spawn)],
             passes=config.passes,
@@ -337,7 +339,7 @@ def build_watch_mode(
 def build_preview_mode(
     archetypes: list[type[_BaseArchetype]],
     skin: Skin,
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
@@ -346,7 +348,7 @@ def build_preview_mode(
     return {
         **compile_mode(
             mode=Mode.PREVIEW,
-            rom=rom,
+            project_state=project_state,
             archetypes=archetypes,
             global_callbacks=None,
             passes=config.passes,
@@ -367,7 +369,7 @@ def build_tutorial_mode(
     preprocess: Callable[[], None],
     navigate: Callable[[], None],
     update: Callable[[], None],
-    rom: ReadOnlyMemory,
+    project_state: ProjectContextState,
     config: BuildConfig,
     thread_pool: Executor | None = None,
     validate_only: bool = False,
@@ -376,7 +378,7 @@ def build_tutorial_mode(
     return {
         **compile_mode(
             mode=Mode.TUTORIAL,
-            rom=rom,
+            project_state=project_state,
             archetypes=[],
             global_callbacks=[
                 (preprocess_callback, preprocess),

sonolus/build/project.py

@@ -7,6 +7,7 @@ from sonolus.build.compile import CompileCache
 from sonolus.build.engine import package_engine, unpackage_data
 from sonolus.build.level import package_level_data
 from sonolus.script.engine import Engine
+from sonolus.script.internal.context import ProjectContextState
 from sonolus.script.level import ExternalLevelData, ExternalLevelDataDict, Level, LevelData, parse_external_level_data
 from sonolus.script.project import BuildConfig, Project, ProjectSchema
 
@@ -21,7 +22,10 @@ BLANK_AUDIO = (
 
 
 def build_project_to_collection(
-    project: Project, config: BuildConfig | None, cache: CompileCache | None = None
+    project: Project,
+    config: BuildConfig | None,
+    cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
 ) -> Collection:
     collection = load_resources_files_to_collection(project.resources)
     for src_engine, converter in project.converters.items():
@@ -34,7 +38,7 @@ def build_project_to_collection(
     if config.override_resource_level_engines:
         for level in collection.categories.get("levels", {}).values():
             level["item"]["engine"] = project.engine.name
-    add_engine_to_collection(collection, project, project.engine, config, cache=cache)
+    add_engine_to_collection(collection, project, project.engine, config, cache=cache, project_state=project_state)
     for level in project.levels:
         add_level_to_collection(collection, project, level)
     collection.name = f"{project.engine.name}"
@@ -72,8 +76,9 @@ def add_engine_to_collection(
     engine: Engine,
     config: BuildConfig | None,
     cache: CompileCache | None = None,
+    project_state: ProjectContextState | None = None,
 ):
-    packaged_engine = package_engine(engine.data, config, cache=cache)
+    packaged_engine = package_engine(engine.data, config, cache=cache, project_state=project_state)
     item = {
         "name": engine.name,
         "version": engine.version,

sonolus/script/archetype.py

@@ -207,7 +207,7 @@ class _IsScoredDescriptor(SonolusDescriptor):
         if instance is None:
             return self.value
         elif ctx():
-            return ctx().global_state.is_scored_by_archetype_id[instance.id]
+            return ctx().mode_state.is_scored_by_archetype_id[instance.id]
         else:
             return self.value
 
@@ -220,7 +220,7 @@ class _IdDescriptor(SonolusDescriptor):
         if not ctx():
             raise RuntimeError("Archetype id is only available during compilation")
         if instance is None:
-            result = ctx().global_state.archetypes.get(owner)
+            result = ctx().mode_state.archetypes.get(owner)
             if result is None:
                 raise RuntimeError("Archetype is not registered")
             return result
@@ -237,7 +237,7 @@ class _KeyDescriptor(SonolusDescriptor):
 
     def __get__(self, instance, owner):
         if instance is not None and ctx():
-            return ctx().global_state.keys_by_archetype_id[instance.id]
+            return ctx().mode_state.keys_by_archetype_id[instance.id]
         else:
             return self.value
 
@@ -249,8 +249,8 @@ class _ArchetypeLifeDescriptor(SonolusDescriptor):
     def __get__(self, instance, owner):
         if not ctx():
             raise RuntimeError("Archetype life is only available during compilation")
-        if ctx().global_state.mode not in {Mode.PLAY, Mode.WATCH}:
-            raise RuntimeError(f"Archetype life is not available in mode '{ctx().global_state.mode.value}'")
+        if ctx().mode_state.mode not in {Mode.PLAY, Mode.WATCH}:
+            raise RuntimeError(f"Archetype life is not available in mode '{ctx().mode_state.mode.value}'")
         if instance is not None:
             return _deref(ctx().blocks.ArchetypeLife, instance.id * ArchetypeLife._size_(), ArchetypeLife)
         else:
@@ -1115,7 +1115,7 @@ def get_archetype_by_name(name: str) -> AnyArchetype:
     name = name._as_py_()  # type: ignore
     if not isinstance(name, str):
         raise TypeError(f"Invalid name: '{name}'")
-    archetypes_by_name = ctx().global_state.archetypes_by_name
+    archetypes_by_name = ctx().mode_state.archetypes_by_name
     if name not in archetypes_by_name:
         raise KeyError(f"Unknown archetype: '{name}'")
     return archetypes_by_name[name]  # type: ignore
@@ -1129,7 +1129,7 @@ def entity_info_at(index: int) -> PlayEntityInfo | WatchEntityInfo | PreviewEnti
     """
     if not ctx():
         raise RuntimeError("Calling entity_info_at is only allowed within a callback")
-    match ctx().global_state.mode:
+    match ctx().mode_state.mode:
         case Mode.PLAY:
             return _deref(ctx().blocks.EntityInfoArray, index * PlayEntityInfo._size_(), PlayEntityInfo)
         case Mode.WATCH:
@@ -1137,7 +1137,7 @@ def entity_info_at(index: int) -> PlayEntityInfo | WatchEntityInfo | PreviewEnti
         case Mode.PREVIEW:
             return _deref(ctx().blocks.EntityInfoArray, index * PreviewEntityInfo._size_(), PreviewEntityInfo)
         case _:
-            raise RuntimeError(f"Entity info is not available in mode '{ctx().global_state.mode}'")
+            raise RuntimeError(f"Entity info is not available in mode '{ctx().mode_state.mode}'")
 
 
 class PlayEntityInfo(Record):

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)