luvatrix 0.2.4__tar.gz → 0.2.6__tar.gz

{luvatrix-0.2.4/luvatrix.egg-info → luvatrix-0.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luvatrix
-Version: 0.2.4
+Version: 0.2.6
 Summary: Luvatrix runtime and plotting toolkit
 Author: Luvatrix contributors
 License-Expression: LicenseRef-Proprietary

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix/app.py

@@ -3,31 +3,33 @@ from __future__ import annotations
 from collections.abc import Callable
 from contextlib import AbstractContextManager
 from dataclasses import dataclass, field
-from importlib import resources
+from importlib import import_module, resources
 import importlib.util
 import math
 import platform
 from pathlib import Path
-from typing import Any
-
-from luvatrix_core.core.app_runtime import (
-    APP_PROTOCOL_VERSION,
-    AppContext,
-    AppLifecycle,
-    AppManifest,
-    AppRuntime,
-    AppUIRenderer,
-    AppVariant,
-    AppWebConfig,
-    ResolvedAppVariant,
-)
-from luvatrix_core.core.hdi_thread import HDIEvent, HDIThread
-from luvatrix_core.core.interaction_work import InteractionAwareWorkScheduler
-from luvatrix_core.core.sensor_manager import SensorManagerThread, SensorSample
-from luvatrix_core.core.window_matrix import FullRewrite, WriteBatch, WindowMatrix
-from luvatrix_core import accel
+from typing import TYPE_CHECKING, Any
+
+from luvatrix_core.core.protocol_governance import CURRENT_PROTOCOL_VERSION
 from luvatrix_ui.text.wrapping import TextWrapping, layout_text, prepare_text
 
+if TYPE_CHECKING:
+    from luvatrix_core.core.app_runtime import (
+        AppContext,
+        AppLifecycle,
+        AppManifest,
+        AppRuntime,
+        AppUIRenderer,
+        AppVariant,
+        AppWebConfig,
+        ResolvedAppVariant,
+    )
+    from luvatrix_core.core.hdi_thread import HDIEvent
+    from luvatrix_core.core.sensor_manager import SensorSample
+
+
+APP_PROTOCOL_VERSION = CURRENT_PROTOCOL_VERSION
+
 PLATFORM_MACOS = "macos"
 PLATFORM_IOS = "ios"
 PLATFORM_ANDROID = "android"
@@ -1353,6 +1355,8 @@ def draw_rounded_rect_to_matrix(
     antialias: bool = True,
 ):
     """Source-over rasterize a rounded rectangle into an RGBA matrix."""
+    from luvatrix_core import accel
+
     width = int(width)
     height = int(height)
     if width <= 0 or height <= 0:
@@ -1508,6 +1512,8 @@ class MatrixFrame(AbstractContextManager["MatrixFrame"]):
         self._frame = None
 
     def __enter__(self) -> "MatrixFrame":
+        from luvatrix_core import accel
+
         snap = self._ctx.read_matrix_snapshot()
         h, w, _ = snap.shape
         self._frame = accel.zeros((h, w, 4))
@@ -1516,6 +1522,8 @@ class MatrixFrame(AbstractContextManager["MatrixFrame"]):
 
     def __exit__(self, exc_type: object, exc: object, tb: object) -> bool:
         if exc_type is None and self._frame is not None:
+            from luvatrix_core.core.window_matrix import FullRewrite, WriteBatch
+
             self._ctx.submit_write_batch(WriteBatch([FullRewrite(self._frame, take_ownership=True)]))
         return False
 
@@ -1785,6 +1793,11 @@ def validate_app_install(
 
 
 def _manifest_runtime(*, host_os: str | None = None, host_arch: str | None = None) -> AppRuntime:
+    from luvatrix_core.core.app_runtime import AppRuntime
+    from luvatrix_core.core.hdi_thread import HDIThread
+    from luvatrix_core.core.sensor_manager import SensorManagerThread
+    from luvatrix_core.core.window_matrix import WindowMatrix
+
     return AppRuntime(
         matrix=WindowMatrix(1, 1),
         hdi=HDIThread(source=_NoopHDISource()),
@@ -1835,6 +1848,36 @@ def _normalize_host_os(value: str) -> str:
     return aliases[normalized]
 
 
+_LAZY_EXPORTS = {
+    "AppContext": ("luvatrix_core.core.app_runtime", "AppContext"),
+    "AppLifecycle": ("luvatrix_core.core.app_runtime", "AppLifecycle"),
+    "AppManifest": ("luvatrix_core.core.app_runtime", "AppManifest"),
+    "AppRuntime": ("luvatrix_core.core.app_runtime", "AppRuntime"),
+    "AppUIRenderer": ("luvatrix_core.core.app_runtime", "AppUIRenderer"),
+    "AppVariant": ("luvatrix_core.core.app_runtime", "AppVariant"),
+    "AppWebConfig": ("luvatrix_core.core.app_runtime", "AppWebConfig"),
+    "ResolvedAppVariant": ("luvatrix_core.core.app_runtime", "ResolvedAppVariant"),
+    "InteractionAwareWorkScheduler": (
+        "luvatrix_core.core.interaction_work",
+        "InteractionAwareWorkScheduler",
+    ),
+}
+
+
+def __getattr__(name: str) -> object:
+    target = _LAZY_EXPORTS.get(name)
+    if target is None:
+        raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+    module_name, attribute_name = target
+    value = getattr(import_module(module_name), attribute_name)
+    globals()[name] = value
+    return value
+
+
+def __dir__() -> list[str]:
+    return sorted(set(globals()) | _LAZY_EXPORTS.keys())
+
+
 __all__ = [
     "APP_PROTOCOL_VERSION",
     "App",

{luvatrix-0.2.4 → luvatrix-0.2.6/luvatrix.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: luvatrix
-Version: 0.2.4
+Version: 0.2.6
 Summary: Luvatrix runtime and plotting toolkit
 Author: Luvatrix contributors
 License-Expression: LicenseRef-Proprietary

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix.egg-info/SOURCES.txt

@@ -107,6 +107,7 @@ luvatrix_core/templates/native/android/gradle.properties
 luvatrix_core/templates/native/android/gradlew
 luvatrix_core/templates/native/android/settings.gradle.kts
 luvatrix_core/templates/native/android/app/build.gradle.kts
+luvatrix_core/templates/native/android/app/proguard-rules.pro
 luvatrix_core/templates/native/android/app/src/main/AndroidManifest.xml
 luvatrix_core/templates/native/android/app/src/main/assets/luvatrix_bitmap_font.txt
 luvatrix_core/templates/native/android/app/src/main/assets/luvatrix_launch_config.json
@@ -114,12 +115,18 @@ luvatrix_core/templates/native/android/app/src/main/assets/luvatrix_matrix_font_
 luvatrix_core/templates/native/android/app/src/main/cpp/CMakeLists.txt
 luvatrix_core/templates/native/android/app/src/main/cpp/luvatrix_camera_preview.frag
 luvatrix_core/templates/native/android/app/src/main/cpp/luvatrix_camera_preview_shaders.h
+luvatrix_core/templates/native/android/app/src/main/cpp/luvatrix_primitive_batch.frag
+luvatrix_core/templates/native/android/app/src/main/cpp/luvatrix_primitive_batch.vert
+luvatrix_core/templates/native/android/app/src/main/cpp/luvatrix_primitive_batch_shaders.h
 luvatrix_core/templates/native/android/app/src/main/cpp/luvatrix_vulkan_renderer.cpp
 luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/CameraBridge.kt
+luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/LatestFrameMailbox.kt
 luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/LaunchPerformance.kt
+luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/LuvatrixApplication.kt
 luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/LuvatrixVulkanView.kt
 luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/MainActivity.kt
 luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/NativeVulkan.kt
+luvatrix_core/templates/native/android/app/src/main/java/com/luvatrix/app/StartupResources.kt
 luvatrix_core/templates/native/android/app/src/main/python/.gitignore
 luvatrix_core/templates/native/android/app/src/main/python/luvatrix_android_boot.py
 luvatrix_core/templates/native/android/app/src/main/python/luvatrix_launch_config.json
@@ -129,7 +136,14 @@ luvatrix_core/templates/native/android/app/src/main/res/mipmap-xhdpi/ic_launcher
 luvatrix_core/templates/native/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png
 luvatrix_core/templates/native/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png
 luvatrix_core/templates/native/android/app/src/main/res/values/styles.xml
+luvatrix_core/templates/native/android/app/src/release/generated/baselineProfiles/baseline-prof.txt
+luvatrix_core/templates/native/android/app/src/release/generated/baselineProfiles/startup-prof.txt
+luvatrix_core/templates/native/android/app/src/test/java/com/luvatrix/app/BootstrapStateTest.kt
 luvatrix_core/templates/native/android/app/src/test/java/com/luvatrix/app/LaunchTimelineTest.kt
+luvatrix_core/templates/native/android/benchmark/build.gradle.kts
+luvatrix_core/templates/native/android/benchmark/src/main/java/com/luvatrix/benchmark/BaselineProfileGenerator.kt
+luvatrix_core/templates/native/android/benchmark/src/main/java/com/luvatrix/benchmark/StartupBenchmark.kt
+luvatrix_core/templates/native/android/benchmark/src/main/java/com/luvatrix/benchmark/StartupJourney.kt
 luvatrix_core/templates/native/android/scripts/emulator_acceptance.sh
 luvatrix_core/templates/native/android/scripts/sync_python_assets.sh
 luvatrix_core/templates/native/ios/project.yml

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix_core/__init__.py

@@ -1,4 +1,4 @@
 """Luvatrix runtime."""
 
 __all__ = ["__version__"]
-__version__ = "0.2.4"
+__version__ = "0.2.5"

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix_core/accel.py

@@ -266,6 +266,12 @@ def _single_roll_shift(shifts) -> int:
     return int(shifts)
 
 
+def filled_rgba(height: int, width: int, rgba: tuple[int, int, int, int]):
+    """Allocate isolated uint8 RGBA storage filled with one color."""
+    pixel = from_sequence(list(rgba), (1, 1, 4))
+    return broadcast_to_clone(pixel, (int(height), int(width), 4))
+
+
 def _normalize_roll_specs(shifts, dims, ndim: int) -> tuple[tuple[int, int], ...]:
     if isinstance(dims, int):
         axes = (dims,)
@@ -921,10 +927,8 @@ else:
 
     def broadcast_to_clone(x: _PureArray, shape: tuple[int, ...]) -> _PureArray:
         H, W, C = shape
-        src = bytes(x._data[:C])
-        data = bytearray(H * W * C)
-        for i in range(H * W):
-            data[i * C:(i + 1) * C] = src
+        pixel_bytes = C * _pure_item_size(x)
+        data = x._data[:pixel_bytes] * (H * W)
         return _PureArray(data, shape, x.dtype)
 
     def roll(x: _PureArray, shifts, dims=None) -> _PureArray:

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix_core/core/display_runtime.py

@@ -31,6 +31,7 @@ class DisplayRuntime:
         self._target_started = False
         self._last_error: Exception | None = None
         self._last_copy_telemetry: dict[str, int] = {}
+        self._last_presented_revision: int | None = None
 
     def start(self) -> None:
         if self._thread and self._thread.is_alive():
@@ -79,17 +80,22 @@ class DisplayRuntime:
             return None
 
         # Coalesce queued blits to newest revision so frame data and revision stay aligned.
+        dirty_rect = event.dirty_rect
         while True:
             newer = self._matrix.pop_call_blit(timeout=None)
             if newer is None:
                 break
+            dirty_rect = _union_dirty_rects(dirty_rect, newer.dirty_rect)
             event = newer
 
         snapshot = self._matrix.read_revision_snapshot(event.revision)
         if snapshot is None:
             snapshot = self._matrix.read_snapshot()
-        frame = _build_frame(snapshot=snapshot, revision=event.revision)
+        if self._last_presented_revision is None:
+            dirty_rect = None
+        frame = _build_frame(snapshot=snapshot, revision=event.revision, dirty_rect=dirty_rect)
         self._target.present_frame(frame)
+        self._last_presented_revision = event.revision
         self._last_copy_telemetry = snapshot_copy_telemetry()
         return RenderTick(event=event, frame=frame)
 
@@ -122,7 +128,11 @@ class DisplayRuntime:
         return dict(self._last_copy_telemetry)
 
 
-def _build_frame(snapshot: object, revision: int) -> DisplayFrame:
+def _build_frame(
+    snapshot: object,
+    revision: int,
+    dirty_rect: tuple[int, int, int, int] | None = None,
+) -> DisplayFrame:
     if snapshot.ndim != 3 or snapshot.shape[2] != 4:
         raise ValueError(f"invalid snapshot shape: {tuple(snapshot.shape)}")
     if not accel.is_uint8(snapshot):
@@ -133,4 +143,18 @@ def _build_frame(snapshot: object, revision: int) -> DisplayFrame:
         width=int(width),
         height=int(height),
         rgba=snapshot,
+        dirty_rect=dirty_rect,
     )
+
+
+def _union_dirty_rects(
+    first: tuple[int, int, int, int] | None,
+    second: tuple[int, int, int, int] | None,
+) -> tuple[int, int, int, int] | None:
+    if first is None or second is None:
+        return None
+    left = min(first[0], second[0])
+    top = min(first[1], second[1])
+    right = max(first[0] + first[2], second[0] + second[2])
+    bottom = max(first[1] + first[3], second[1] + second[3])
+    return (left, top, right - left, bottom - top)

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix_core/core/unified_runtime.py

@@ -166,6 +166,8 @@ class UnifiedRuntime:
         present_fps: int | None = None,
         display_timeout: float = 0.0,
         on_targets_started: "Callable[[], None] | None" = None,
+        before_lifecycle_init: "Callable[[], None] | None" = None,
+        defer_hdi_polling_until_first_frame: bool = False,
         defer_optional_sensor_polling_until_first_frame: bool = False,
     ) -> UnifiedRunResult:
         if max_ticks is not None and max_ticks <= 0:
@@ -173,6 +175,12 @@ class UnifiedRuntime:
         rate = FrameRateController(target_fps=target_fps, present_fps=present_fps)
         app_path = Path(app_dir).resolve()
         manifest = self._app_runtime.load_manifest(app_path)
+        effective_render_mode = self._render_mode
+        if effective_render_mode == "auto":
+            if manifest.render_preferred == "matrix":
+                effective_render_mode = "matrix"
+            elif manifest.render_preferred == "scene" and self._scene_target is not None:
+                effective_render_mode = "scene"
         debug_policy_profile = self._app_runtime.resolve_debug_policy_profile(manifest)
         granted = self._app_runtime.resolve_capabilities(manifest)
         ctx = self._app_runtime.build_context(granted_capabilities=granted, manifest=manifest)
@@ -196,9 +204,9 @@ class UnifiedRuntime:
         stopped_by_energy_safety = False
         started = False
         active_targets: list[object] = []
-        if self._scene_target is not None and self._render_mode in ("auto", "scene"):
+        if self._scene_target is not None and effective_render_mode in ("auto", "scene"):
             active_targets.append(self._scene_target)
-        if self._render_mode == "matrix" or (self._render_mode == "auto" and self._scene_target is None):
+        if effective_render_mode == "matrix" or (effective_render_mode == "auto" and self._scene_target is None):
             active_targets.append(self._target)
         self._configure_target_debug_menu(
             manifest.app_id,
@@ -218,7 +226,12 @@ class UnifiedRuntime:
                 repeat_latest=False,
             )
             scene_present_loop_started = True
-        ctx.hdi.start()
+        required_hdi_capability = any(
+            capability.startswith("hdi.") for capability in manifest.required_capabilities
+        )
+        hdi_started = not (defer_hdi_polling_until_first_frame and not required_hdi_capability)
+        if hdi_started:
+            ctx.hdi.start()
         required_sensor_capability = any(
             capability.startswith("sensor.") for capability in manifest.required_capabilities
         )
@@ -228,15 +241,22 @@ class UnifiedRuntime:
         if sensor_manager_started:
             ctx.sensor_manager.start()
         deferred_sensor_deadline = time.perf_counter() + 0.1
+        deferred_hdi_deadline = time.perf_counter() + 0.1
         last = time.perf_counter()
         was_active = self._is_active()
         try:
+            if before_lifecycle_init is not None:
+                before_lifecycle_init()
             lifecycle.init(ctx)
             tick_idx = 0
             while max_ticks is None or tick_idx < max_ticks:
                 for active_target in active_targets:
                     active_target.pump_events()
-                if self._scene_display_runtime is not None and self._scene_display_runtime.last_error is not None:
+                if (
+                    scene_present_loop_started
+                    and self._scene_display_runtime is not None
+                    and self._scene_display_runtime.last_error is not None
+                ):
                     raise self._scene_display_runtime.last_error
                 if any(bool(active_target.should_close()) for active_target in active_targets):
                     stopped_by_target_close = True
@@ -265,8 +285,7 @@ class UnifiedRuntime:
                 self._app_loop_rate.mark()
                 ticks_run += 1
                 tick_idx += 1
-                if self._scene_display_runtime is None and rate.should_present(now):
-                    tick = None
+                if not scene_present_loop_started and rate.should_present(now):
                     matrix_tick = self._display_runtime.run_once(timeout=display_timeout)
                     if matrix_tick is not None:
                         frames_presented += 1
@@ -274,12 +293,21 @@ class UnifiedRuntime:
                 if not sensor_manager_started:
                     scene_frames = (
                         self._scene_display_runtime.frames_presented
-                        if self._scene_display_runtime is not None
+                        if scene_present_loop_started and self._scene_display_runtime is not None
                         else 0
                     )
                     if frames_presented > 0 or scene_frames > 0 or time.perf_counter() >= deferred_sensor_deadline:
                         ctx.sensor_manager.start()
                         sensor_manager_started = True
+                if not hdi_started:
+                    scene_frames = (
+                        self._scene_display_runtime.frames_presented
+                        if scene_present_loop_started and self._scene_display_runtime is not None
+                        else 0
+                    )
+                    if frames_presented > 0 or scene_frames > 0 or time.perf_counter() >= deferred_hdi_deadline:
+                        ctx.hdi.start()
+                        hdi_started = True
                 sleep_for = rate.compute_sleep(
                     loop_started_at=now,
                     loop_finished_at=time.perf_counter(),
@@ -298,7 +326,8 @@ class UnifiedRuntime:
             try:
                 lifecycle.stop(ctx)
             finally:
-                ctx.hdi.stop()
+                if hdi_started:
+                    ctx.hdi.stop()
                 ctx.sensor_manager.stop()
                 if started:
                     if scene_present_loop_started and self._scene_display_runtime is not None:
@@ -307,7 +336,7 @@ class UnifiedRuntime:
                             self._scene_display_runtime.run_once(timeout=0.0, repeat_latest=True)
                     for active_target in reversed(active_targets):
                         active_target.stop()
-        if self._scene_display_runtime is not None:
+        if scene_present_loop_started and self._scene_display_runtime is not None:
             frames_presented = self._scene_display_runtime.frames_presented
             self._frames_presented = frames_presented
         return UnifiedRunResult(

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix_core/core/window_matrix.py

@@ -84,16 +84,31 @@ class CallBlitEvent:
     event_id: int
     revision: int
     ts_ns: int
+    # ``None`` denotes a global rewrite or transform that invalidates all pixels.
+    dirty_rect: tuple[int, int, int, int] | None = None
 
 
 class WindowMatrix:
-    """Canonical RGBA255 matrix with atomic write-batch commits."""
+    """Canonical RGBA255 matrix with atomic write-batch commits.
 
-    def __init__(self, height: int, width: int, background: tuple[int, int, int, int] = (0, 0, 0, 255)) -> None:
+    ``lazy=True`` keeps dimensions and event state available for scene-only
+    runtimes without allocating RGBA storage. The first matrix read or write
+    materializes storage; a first full rewrite directly becomes that storage.
+    """
+
+    def __init__(
+        self,
+        height: int,
+        width: int,
+        background: tuple[int, int, int, int] = (0, 0, 0, 255),
+        *,
+        lazy: bool = False,
+    ) -> None:
         if height <= 0 or width <= 0:
             raise ValueError("height and width must be > 0")
         self.height = height
         self.width = width
+        self._background = tuple(background)
         self._write_lock = threading.Lock()
         self._event_lock = threading.Lock()
         self._event_cv = threading.Condition(self._event_lock)
@@ -103,20 +118,26 @@ class WindowMatrix:
         self._revision_snapshot_enabled = os.getenv("LUVATRIX_ENABLE_REVISIONED_SNAPSHOT", "0").strip() == "1"
         self._revision_snapshot: object | None = None
         self._revision_snapshot_revision = 0
-        bg = accel.from_sequence(list(background), (1, 1, 4))
-        self._matrix = accel.broadcast_to_clone(bg, (height, width, 4))
-        if self._revision_snapshot_enabled:
-            self._revision_snapshot = accel.clone(self._matrix)
+        self._matrix: object | None = None
+        if not lazy:
+            self._materialize_locked()
 
     @property
     def revision(self) -> int:
         return self._revision
 
+    @property
+    def is_materialized(self) -> bool:
+        """Whether the RGBA backing store has been allocated."""
+        with self._write_lock:
+            return self._matrix is not None
+
     def read_snapshot(self) -> object:
         """Safe read view for external consumers."""
         with self._write_lock:
+            matrix = self._materialize_locked()
             started = time.perf_counter_ns()
-            out = accel.clone(self._matrix)
+            out = accel.clone(matrix)
             add_copy_telemetry(
                 copy_count=1,
                 copy_bytes=accel.numel(out),
@@ -129,6 +150,7 @@ class WindowMatrix:
         with self._write_lock:
             if not self._revision_snapshot_enabled:
                 return None
+            self._materialize_locked()
             if self._revision_snapshot is None:
                 return None
             if int(revision) != int(self._revision_snapshot_revision):
@@ -137,13 +159,26 @@ class WindowMatrix:
 
     def _unsafe_matrix_view(self) -> object:
         """Internal-only no-copy handle."""
-        return self._matrix
+        with self._write_lock:
+            return self._materialize_locked()
+
+    def _materialize_locked(self) -> object:
+        matrix = self._matrix
+        if matrix is not None:
+            return matrix
+        matrix = accel.filled_rgba(self.height, self.width, self._background)
+        self._matrix = matrix
+        if self._revision_snapshot_enabled:
+            self._revision_snapshot = accel.clone(matrix)
+            self._revision_snapshot_revision = int(self._revision)
+        return matrix
 
     def submit_write_batch(self, batch: WriteBatch) -> CallBlitEvent:
         if not batch.operations:
             raise ValueError("write batch must include at least one operation")
 
         with self._write_lock:
+            dirty_rect = _dirty_rect_for_operations(batch.operations, self.width, self.height)
             offending_pixels = 0
             if len(batch.operations) == 1 and isinstance(batch.operations[0], FullRewrite):
                 op = batch.operations[0]
@@ -154,10 +189,10 @@ class WindowMatrix:
                 )
             elif self._is_localized_commit_batch(batch.operations):
                 prepared, offending_pixels = self._prepare_localized_ops(batch.operations)
-                self._apply_prepared_localized_ops(prepared)
+                self._apply_prepared_localized_ops(self._materialize_locked(), prepared)
             else:
                 stage_started = time.perf_counter_ns()
-                staged = accel.clone(self._matrix)
+                staged = accel.clone(self._materialize_locked())
                 add_copy_telemetry(
                     copy_count=1,
                     copy_bytes=accel.numel(staged),
@@ -180,6 +215,7 @@ class WindowMatrix:
                 event_id=self._next_event_id,
                 revision=self._revision,
                 ts_ns=time.time_ns(),
+                dirty_rect=dirty_rect,
             )
             self._next_event_id += 1
 
@@ -299,22 +335,28 @@ class WindowMatrix:
             raise TypeError(f"Unsupported localized write op: {type(op)!r}")
         return prepared, offending_pixels
 
-    def _apply_prepared_localized_ops(self, prepared: list[tuple[str, int, int, int, int, object]]) -> None:
+    def _apply_prepared_localized_ops(
+        self,
+        matrix: object,
+        prepared: list[tuple[str, int, int, int, int, object]],
+    ) -> None:
         for kind, x, y, width, height, payload in prepared:
             if kind == "column":
-                self._matrix[:, x, :] = payload
+                matrix[:, x, :] = payload
                 continue
             if kind == "row":
-                self._matrix[y, :, :] = payload
+                matrix[y, :, :] = payload
                 continue
             if kind == "rect":
-                self._matrix[y : y + height, x : x + width, :] = payload
+                matrix[y : y + height, x : x + width, :] = payload
                 continue
             raise RuntimeError(f"Unsupported prepared localized write kind: {kind}")
 
     def _refresh_revision_snapshot(self) -> None:
         if not self._revision_snapshot_enabled:
             return
+        if self._matrix is None:
+            return
         started = time.perf_counter_ns()
         self._revision_snapshot = accel.clone(self._matrix)
         self._revision_snapshot_revision = int(self._revision)
@@ -339,6 +381,49 @@ def _validate_rect(x: int, y: int, width: int, height: int, matrix_width: int, m
         raise ValueError("rect exceeds matrix bounds")
 
 
+def _dirty_rect_for_operations(
+    operations: list[WriteOp],
+    matrix_width: int,
+    matrix_height: int,
+) -> tuple[int, int, int, int] | None:
+    """Return the affected pixel bounds, or ``None`` when every pixel changed."""
+    rect: tuple[int, int, int, int] | None = (0, 0, 0, 0)
+    for operation in operations:
+        if isinstance(operation, (FullRewrite, ShiftFrame, Multiply)):
+            return None
+        if isinstance(operation, ReplaceRect):
+            candidate = (operation.x, operation.y, operation.width, operation.height)
+        elif isinstance(operation, ReplaceColumn):
+            candidate = (operation.index, 0, 1, matrix_height)
+        elif isinstance(operation, PushColumn):
+            candidate = (operation.index, 0, matrix_width - operation.index, matrix_height)
+        elif isinstance(operation, ReplaceRow):
+            candidate = (0, operation.index, matrix_width, 1)
+        elif isinstance(operation, PushRow):
+            candidate = (0, operation.index, matrix_width, matrix_height - operation.index)
+        else:
+            return None
+        rect = _union_dirty_rect(rect, candidate)
+    return rect
+
+
+def _union_dirty_rect(
+    first: tuple[int, int, int, int] | None,
+    second: tuple[int, int, int, int] | None,
+) -> tuple[int, int, int, int] | None:
+    if first is None or second is None:
+        return None
+    if first[2] == 0 or first[3] == 0:
+        return second
+    if second[2] == 0 or second[3] == 0:
+        return first
+    left = min(first[0], second[0])
+    top = min(first[1], second[1])
+    right = max(first[0] + first[2], second[0] + second[2])
+    bottom = max(first[1] + first[3], second[1] + second[3])
+    return (left, top, right - left, bottom - top)
+
+
 def _coerce_float32(value: object, expected_shape: tuple[int, ...], label: str) -> object:
     return accel.coerce_float32(value, expected_shape, label)
 

{luvatrix-0.2.4 → luvatrix-0.2.6}/luvatrix_core/platform/android/runner.py

@@ -86,12 +86,14 @@ def write_android_launch_config(
     _ensure_android_generated_gitignore(project)
     dest = project / "app" / "src" / "main" / "assets" / "luvatrix_launch_config.json"
     dest.parent.mkdir(parents=True, exist_ok=True)
-    display = _read_app_display_config(app_dir)
+    manifest = _read_app_manifest(app_dir)
+    display = _read_app_display_config(manifest)
+    resolved_render_mode = _resolve_manifest_render_mode(render_mode, manifest)
     data = {
         "app_dir": "luvatrix_app",
         "source_app_dir": str(app_dir),
         "render_scale": float(render_scale),
-        "render_mode": render_mode,
+        "render_mode": resolved_render_mode,
         "target_fps": target_fps,
         "present_fps": present_fps,
         "low_latency_mode": bool(low_latency_mode),
@@ -126,12 +128,15 @@ def _ensure_android_generated_gitignore(project_dir: Path) -> Path:
     return gitignore
 
 
-def _read_app_display_config(app_dir: Path) -> dict[str, int]:
-    manifest = app_dir / "app.toml"
+def _read_app_manifest(app_dir: Path) -> dict[str, object]:
     try:
-        raw = tomllib.loads(manifest.read_text(encoding="utf-8"))
+        raw = tomllib.loads((app_dir / "app.toml").read_text(encoding="utf-8"))
     except Exception:
         return {}
+    return raw if isinstance(raw, dict) else {}
+
+
+def _read_app_display_config(raw: dict[str, object]) -> dict[str, int]:
     display = raw.get("display")
     if not isinstance(display, dict):
         return {}
@@ -146,6 +151,16 @@ def _read_app_display_config(app_dir: Path) -> dict[str, int]:
     return out
 
 
+def _resolve_manifest_render_mode(requested: str, raw: dict[str, object]) -> str:
+    if requested != "auto":
+        return requested
+    render = raw.get("render")
+    if not isinstance(render, dict):
+        return requested
+    preferred = str(render.get("preferred") or "").strip()
+    return preferred if preferred in ("matrix", "scene") else requested
+
+
 def _android_device_logical_display_config(*, device_id: str | None = None) -> dict[str, int]:
     adb = shutil.which("adb")
     if adb is None: