diff --git a/AGENTS.md b/AGENTS.md
index f0e40d119..73ecde45f 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -5,9 +5,11 @@ The role of this file is to describe common mistakes and confusion points that a
 - `Milky2018/wgpu_mbt@0.14.2` and `Milky2018/window@0.5.1` provide the current macOS `NSView*` renderer integration path. Use `Instance::create_surface_macos_ns_view_u64` with `Window::content_view_handle()` data instead of reintroducing project-local `CAMetalLayer` attach stubs or unsafe casts. Use `RenderPassDescBuilder::set_color_attachment_resolve_target` for MSAA color resolve attachments instead of project-local render-pass descriptor native stubs.
 - When `moon test` fails with a tcc framework lookup error, rerun the same test with `--release`.
 - Long `moon run` commands, especially native release builds and examples that compile large generated C files, may spend several minutes in clang/link/executable generation. Do not treat the long wait as a failure or switch debugging strategy just to avoid waiting; keep polling until the command naturally completes or produces a real error.
+- On current MoonBit toolchains, `moon test -f` is the short form of `--filter`, not a test filename selector. Pass one test file as a positional path (for example, `moon test ecs/foo_test.mbt -f 'test name'`) and use only one filter flag.
 - On newer MoonBit toolchains, a repository-wide `moon fmt` can migrate legacy `options("is-main": true)` entries to `pkgtype(kind: "executable")` and regenerate hundreds of package/interface files. For surgical changes, inspect `git status` immediately afterward and exclude unrelated migration churn from the task.
 - Use this fixed native screenshot command shape for visual parity captures, for example:
   `MGSTUDIO_PARITY_CAPTURE_DELAY_FRAMES=90 MGSTUDIO_PARITY_RUN_TIMEOUT_SECONDS=240 mgstudio-engine/scripts/p0_visual_capture_native.sh examples/2d/bloom_2d /tmp/mgstudio_iss025_camera_render_graph_bloom_2d.png`.
+- A fixed-frame capture represents simulated time, not the wall-clock age of a checked-in reference. For physics-heavy examples such as `examples/3d/despawn3`, frame 90 at the default 16,667 microseconds is only about 1.5 seconds and should not be compared with a later settled-pile reference. If an exact delayed frame is required, set `MGSTUDIO_PARITY_CAPTURE_DISABLE_RETRY=1` and inspect `capture_delay_frames_used` in the generated metadata; otherwise a timeout retry can replace the requested output with a fresh-process frame-1 capture. A larger `MGSTUDIO_PARITY_FIXED_FRAME_TIME_US` can validate later fixed-update state with fewer expensive render frames.
 - When an example runs correctly for the first time, save a reference screenshot in that example's source directory. Future agents should compare against that checked-in local reference before deciding that the example still renders correctly.
 - Do not infer Bevy parity from a visually plausible example alone. The `examples/3d/motion_blur` audit showed that a scene can render and respond to input while still diverging from Bevy in ECS shape and data flow: Bevy used a `Text` root with `TextSpan` children and `TextUiWriter`, while mgstudio had been replacing one whole `Text` value every frame. For render/PBR/mesh/text/UI work, verify source-owner structure, component/resource ownership, schedule placement, dirty/change tracking, example behavior, and visual/performance gates before raising completion scores.
 - If a bug appears in one feature area, check adjacent Bevy boundaries before assigning ownership. Input symptoms in `motion_blur` crossed window/AppKit event-loop timing, ECS schedule entry, UI text updates, and PBR postprocess state; treating the first visible subsystem as the root cause is usually wrong.
diff --git a/CONTEXT.md b/CONTEXT.md
index 30507c55d..59a313c6b 100644
--- a/CONTEXT.md
+++ b/CONTEXT.md
@@ -134,7 +134,7 @@ _Avoid_: committed Bevy patch, permanent baseline fork
 > **Dev:** "Should bridge packages own behavior just because code lives there?"
 > **Domain expert:** "No — **Runtime Owner Semantics** stays with the **Bevy Source Owner**; bridges only keep the port buildable and traceable."
 >
-> **Dev:** "If `moon_taffy` lacks a Bevy-required layout capability, is that a mgstudio parity gap?"
+> **Dev:** "If `chicle` lacks a Bevy-required layout capability, is that a mgstudio parity gap?"
 > **Domain expert:** "No — that is an **External Blocker** and should be tracked so the community can build the missing dependency capability."
 >
 > **Dev:** "If MoonBit cannot express the typed system parameter shape Bevy uses, can we encode the state as JSON?"
diff --git a/docs/ECS_PERFORMANCE_API_MIGRATION.md b/docs/ECS_PERFORMANCE_API_MIGRATION.md
new file mode 100644
index 000000000..cf7e6ec9f
--- /dev/null
+++ b/docs/ECS_PERFORMANCE_API_MIGRATION.md
@@ -0,0 +1,220 @@
+# ECS Performance Branch Public API Migration
+
+This document records the source-breaking public API changes retained by the
+ECS and render performance work tracked by `ISS-442`, `ISS-444`, `ISS-456`,
+`ISS-461`, and `ISS-463`.
+
+These changes are intentional, but they are not source compatible. The
+generated interfaces expose struct fields, struct mutability, return types,
+error variants, and generic bounds as public API. Downstream code that used
+those details must be migrated before updating to this branch.
+
+The audit compares this branch against its `main` merge base,
+`df70870662fe5fb4ad151098fe6edd329431838b`.
+
+## Value-Type Semantics
+
+`Duration`, `Stopwatch`, `TimerMode`, `Timer`, `TextureAtlas`, `Aabb`, `Sphere`,
+`InheritedVisibility`, and `ViewVisibility` are now MoonBit value types. Copies
+no longer share object identity. Value updates return replacement values that
+the caller must store.
+
+MoonBit value types cannot contain the reference-typed fields used by the old
+representations. The flattened fields are an implementation detail; downstream
+code should use constructors and methods instead of depending on the new scalar
+layout.
+
+## Time
+
+`Stopwatch` previously exported `elapsed : Duration`; it now stores
+`elapsed_nanos : Int64`. `Timer` previously exported `stopwatch`, `duration`,
+and `mode`; those fields are now flattened scalar state.
+
+| Previous source | Replacement |
+| --- | --- |
+| `stopwatch.elapsed` | `stopwatch.elapsed()` |
+| `Stopwatch::{ elapsed, paused: false }` | `Stopwatch::new().set_elapsed(elapsed)` |
+| `Stopwatch::{ elapsed, paused: true }` | `Stopwatch::new().set_elapsed(elapsed).pause()` |
+| `timer.stopwatch.elapsed()` | `timer.elapsed()` |
+| `timer.stopwatch.is_paused()` | `timer.is_paused()` |
+| `timer.duration` | `timer.duration()` |
+| `timer.mode` | `timer.mode()` |
+| `Timer::{ stopwatch, duration, mode, .. }` | Start with `Timer::new(duration, mode)`, then apply `set_elapsed`, `pause`, `finish`, or `tick` as required |
+
+There is no supported replacement for constructing arbitrary inconsistent
+`Timer` internals through a struct literal. Use the public state-transition
+methods. Existing `Timer` and `Stopwatch` mutators already return a replacement
+value, so retain the result, for example `timer = timer.tick(delta)`.
+
+## Camera Primitives
+
+`Aabb` no longer exports `inner : Aabb3d`; it stores six scalar center and
+half-extent values. `Sphere` no longer exports `center : Vec3`; it stores three
+scalar center values.
+
+| Previous source | Replacement |
+| --- | --- |
+| `Aabb::{ inner }` | `Aabb::from_math(inner)` |
+| `aabb.inner` | `aabb.to_math()` |
+| `aabb.inner.center` | `aabb.center()` |
+| `aabb.inner.half_size` | `aabb.half_size()` |
+| `Sphere::{ center, radius }` | `Sphere::new(center, radius)` |
+| `sphere.center` | `sphere.center()` |
+| Scalar sphere construction | `Sphere::from_xyz(x, y, z, radius)` |
+
+The scalar getters such as `center_x()` and `half_extents_x()` exist for hot
+paths, but callers should not construct the flattened representation directly.
+
+## Visibility
+
+`InheritedVisibility` is now a value type with otherwise unchanged constructor
+and getter APIs.
+
+`ViewVisibility.bits` is no longer mutable. The former mutating
+`ViewVisibility::update` method is deliberately not retained with a
+value-returning signature: an old `view.update()` call would still compile,
+discard the returned value, and silently preserve the old state. The
+replacement is named `advance_frame` so unmigrated calls fail at compile time.
+
+| Previous source | Replacement |
+| --- | --- |
+| `view.update()` | `view = view.advance_frame()` |
+| `view.set_visible()` | `view = view.with_visible()` |
+| `view.bits = bits` | Use `ViewVisibility::new`, `visible`, `hidden`, `with_visible`, or `advance_frame` |
+| Component mutation through direct field access | Use `Write::set`, `Write::update`, or the `SetViewVisibility` API |
+
+Code using ECS change detection must choose ordinary mutation or the explicit
+bypass-change-detection API according to the same semantics as before; do not
+replace every visibility write with a bypass update.
+
+The former public `check_visibility_system` blanket producer was removed. It
+marked every inherited-visible renderable as view-visible without applying the
+camera-, layer-, range-, light-, or frustum-specific visibility owners. Normal
+applications should install the root visibility plugin together with the
+camera visibility plugin and relevant light plugins. A custom visibility
+producer should set `ViewVisibility` through `SetViewVisibility` and run in
+`visibility_set_check_visibility`; there is no source-faithful one-function
+replacement for the old blanket scan.
+
+## Texture Atlas
+
+`TextureAtlas.layout` is now a private scalar asset id because the value type
+cannot contain a reference-typed `Handle`.
+
+| Previous source | Replacement |
+| --- | --- |
+| `TextureAtlas::{ layout, index }` | `TextureAtlas::new(layout, index)` |
+| `atlas.layout` | `atlas.layout()` |
+| Direct layout asset lookup through `atlas.layout` | `atlas.layout_asset(layout_assets)` |
+
+`TextureAtlas.index` remains public. Prefer `index()` and `with_index()` when
+the caller does not need field-pattern matching.
+
+## ECS Change-Location Storage
+
+`RawTableColumnKernel.changed_caller_ids` changed from `Array[Int]` to
+`Array[Int]?`. Change-location allocation is now opt-in through
+`World::new(track_change_locations=true)`.
+
+Direct consumers of `RawTableColumnKernel` must handle `None`. `None` means the
+world does not track caller locations; it is not an empty tracked column.
+`RawTableColumnKernel` is a low-level storage type, so normal downstream ECS
+code should use `Read::changed_by` and the corresponding query APIs instead of
+accessing the raw field.
+
+`EcsError` also gained `TableBatchUnavailable(String)`. Exhaustive downstream
+matches must add that case or an explicit fallback arm.
+
+`World::new` now accepts the optional `track_change_locations` argument.
+Existing `World::new()` calls remain valid. Code that stored `World::new` as a
+zero-argument function value should replace it with `() => World::new()`;
+callers that need change locations should use
+`World::new(track_change_locations=true)`.
+
+## Bindless Material Allocation
+
+`MaterialBindGroupBindlessAllocator::allocate` changed from
+`MaterialBindingId?` to `MaterialBindingId`. A bindless allocator now grows a
+new slab and cannot fail because the current slab is full.
+
+Remove `Some`/`None` matching or `.unwrap()` from direct bindless allocator
+calls:
+
+```mbt nocheck
+let binding = allocator.allocate(material_id)
+```
+
+The higher-level material allocator enum may still return `None` when a
+bindless allocation is requested from a non-bindless allocator.
+
+## Frustum System Generic Bound
+
+`render3d_update_frusta_system_by_projection_key` now requires
+`T : @ecs.Component`. Generic wrappers calling this function must add the same
+bound. Concrete projection components that already implement `Component` need
+no source change.
+
+## Table-Batch Mutable Column Scope
+
+`TableBatchWrite::update_inplace` and
+`update_inplace_bypass_change_detection` now pass
+`TableBatchMutValues[T]` instead of a raw `MutArrayView[T]`. The old view could
+escape its callback and continue replacing ECS column values without a valid
+lease, change ticks, or finalizer handling. A retained `TableBatchMutValues`
+becomes inactive when the callback returns, and every subsequent indexed read
+or write aborts.
+
+Callbacks with inferred parameter types keep the same source shape:
+
+```mbt nocheck
+values.update_inplace(fn(items) {
+  for index in 0..<items.length() {
+    items[index] = update(items[index])
+  }
+})
+```
+
+Explicit callback parameter annotations must change:
+
+| Previous source | Replacement |
+| --- | --- |
+| `fn(items : MutArrayView[T]) { ... }` | `fn(items : TableBatchMutValues[T]) { ... }` |
+| Retain `items` and write after the callback | Perform every indexed read and write inside the callback |
+
+The controlled view deliberately exposes only `length()` and indexed
+`op_get`/`op_set`; it does not expose its backing array or a raw mutable view.
+Internally it keeps a private `MutArrayView` already bounded to the live rows,
+so indexed access retains one bounds check without making the raw capability
+escapable.
+
+## Filtered Table Row Scope
+
+`Query::try_for_each_filtered_table` exposes the complete physical table and a
+separate `QueryTableRows` matcher. Row-indexed access through
+`QueryTableBatch`, `TableBatchRead`, `TableBatchWrite`, or
+`TableBatchChangeWriter` is valid only while `QueryTableRows::for_each` is
+invoking the callback for that exact matching row. Use the yielded physical
+row index directly:
+
+```mbt nocheck
+ignore(query.try_for_each_filtered_table(fn(batch, rows) {
+  let positions = batch.write(position_key).unwrap()
+  rows.for_each(fn(row_index) {
+    positions.set(row_index, update(positions.peek(row_index)))
+  })
+}))
+```
+
+Code that indexed a different physical row from inside the callback could
+previously read or mutate an entity rejected by `Changed`, `Added`, `Or`, or a
+custom filter. That out-of-filter access now aborts. Whole-table batches from
+`Query::for_each_table` retain unrestricted access to every live physical row.
+The callback-scoped `with_read_values` and `with_write_values` helpers still
+provide complete read-only column views; callers must use them only with row
+indices yielded by the associated `QueryTableRows` traversal.
+
+## Source-Compatible Interface Changes
+
+The generated-interface audit also found additive changes that do not require
+downstream migration: the table-batch query APIs, `ReadValue`, camera frustum
+schedule symbols, and defaulted table-binding methods on the open query traits.
diff --git a/docs/MOON_WESL_0_17_MIGRATION.md b/docs/MOON_WESL_0_17_MIGRATION.md
new file mode 100644
index 000000000..7d645be5a
--- /dev/null
+++ b/docs/MOON_WESL_0_17_MIGRATION.md
@@ -0,0 +1,53 @@
+# moon_wesl 0.17.0 migration
+
+## Version boundary
+
+`Milky2018/moon_wesl` is upgraded from `0.1.2` to `0.17.0`. The 0.17 release
+uses `Milky2018/wgsl` for WGSL parsing and semantic validation and exposes the
+compiled syntax tree through `CompileResult`.
+
+## Compile option API
+
+The former `CompileOptions::with_*` builder methods were removed. Configure
+the public record from `CompileOptions::default()` instead. Defaults still
+enable imports, conditional compilation, stripping, lazy resolution, and
+validation. Mgstudio only overrides `lower`, matching its previous behavior:
+
+```mbt
+let options = {
+  ..@wesl.CompileOptions::default(),
+  lower: true,
+  features,
+}
+```
+
+Feature flags now use `Features` and the four-state `Feature` enum rather than
+boolean values stored directly in the options. Mgstudio preserves its existing
+`ShaderDefVal::Bool` semantics with `Feature::from_bool(value)`. Integer and
+unsigned shader definitions remain ignored by the WESL conditional compiler,
+as before.
+
+## Resolver and output behavior
+
+The application-owned `ShaderResolver` still implements the published
+`Resolver` trait, so asynchronous asset availability and
+`ShaderImportNotYetAvailable` behavior are unchanged. `compile(...)` still
+returns an object whose `to_string()` method emits WGSL for the render backend.
+
+No mgstudio public API changes are introduced by this migration.
+
+## Verification
+
+- `moon check shader --target native --deny-warn`
+- `moon test shader/shader_cache_test.mbt -f 'shader cache compiles wesl
+  through loaded shader assets and bool defs' --target native --release
+  --deny-warn`
+- `moon test shader/wesl_runtime_test.mbt -f 'shader runtime wesl registration
+  compiles after imported module is loaded as shader asset' --target native
+  --release --deny-warn`
+- `moon check --target native` (`0` errors; the existing 226 warnings are
+  tracked by ISS-443)
+- frame-90 native capture of `examples/shader/shader_material_wesl`; the run
+  log is empty and the WESL material pipeline completes. Its existing visual
+  parity work remains part of ISS-157 and is not accepted by this dependency
+  migration.
diff --git a/docs/PARITY_GATES.md b/docs/PARITY_GATES.md
index e112e9c24..19618bc0c 100644
--- a/docs/PARITY_GATES.md
+++ b/docs/PARITY_GATES.md
@@ -26,6 +26,13 @@ than external paths such as:
 
 This preserves runtime asset provenance for example parity claims.
 
+### `gate_bevy_asset_mirror.sh`
+
+Checks the SHA-256 manifest for every tracked non-WGSL resource copied from the
+pinned Bevy baseline. The gate runs without a local Bevy checkout; use
+`scripts/sync_bevy_assets.py --check` when the pinned checkout is available to
+verify both the mirrors and the checked-in manifest against their source files.
+
 ### `gate_visual_runtime.sh`
 
 Runs a small visual screenshot gate over representative 3D examples. The gate
@@ -63,9 +70,10 @@ Related scripts:
 the parity gate set:
 
 1. `gate_no_mgstudio_shader.sh`
-2. `gate_asset_provenance.sh`
-3. `gate_visual_runtime.sh`
-4. `gate_stress_performance.sh` (optional; enabled by env flag)
+2. `gate_bevy_asset_mirror.sh`
+3. `gate_asset_provenance.sh`
+4. `gate_visual_runtime.sh`
+5. `gate_stress_performance.sh` (optional; enabled by env flag)
 
 For environments that should only run the static subset, set:
 
diff --git a/docs/WGSL_DEPENDENCY_0_16_MIGRATION.md b/docs/WGSL_DEPENDENCY_0_16_MIGRATION.md
new file mode 100644
index 000000000..cb7e510d9
--- /dev/null
+++ b/docs/WGSL_DEPENDENCY_0_16_MIGRATION.md
@@ -0,0 +1,40 @@
+# WGSL Dependency 0.16 API Migration
+
+This document records the source-breaking dependency boundary change retained
+when the WGSL dependency family moved from `0.15.3` to `0.16.0`.
+
+## Public API changes
+
+The removed `Milky2018/wgsl/common` package must no longer appear in downstream
+imports. Use the user-facing `Milky2018/moon_wgsl` facade for public contracts
+and project policy:
+
+| 0.15.3 import or call | 0.16.0 replacement |
+| --- | --- |
+| `Milky2018/wgsl/common` | `Milky2018/moon_wgsl` |
+| `@common.default_wgsl_value_defines()` | `@moon_wgsl.bevy_wgsl_value_defines()` |
+| direct public `directive` scanner imports | `@moon_wgsl.get_preprocessor_metadata()` and `@moon_wgsl.wgsl_source_define_import_path()` |
+
+This changes the package owner printed for public `ShaderDefValue`,
+`WgslComposeOptions`, `WgslSourceFile`, and `WgslSourceScanOptions` types in
+generated interfaces. Their mgstudio API meaning is unchanged, but downstream
+code with explicit `Milky2018/wgsl/common` imports or type annotations must
+move those references to `Milky2018/moon_wgsl`.
+
+Mgstudio still imports `Milky2018/moon_wgsl_naga_oil/compose` at its internal
+runtime boundary because it requires the explicit
+`compose_wgsl_runtime_valid` entry point. This low-level path is not re-exported
+as an mgstudio public type.
+
+## Runtime behavior
+
+The runtime composer now registers the complete embedded shader registry and
+lets the 0.16 composer resolve the active import graph. It no longer supplies a
+locally precomputed root dependency subset for runtime composition. This is
+required for conditional Bevy imports whose active dependencies depend on the
+shader definitions passed to composition.
+
+The 0.16 upgrade makes a minimal fully qualified module function call compose
+and flatten successfully. The complete pinned-Bevy deferred-lighting graph
+still fails on `bevy_pbr::fog::linear_fog`; that remaining external blocker is
+tracked by ISS-405 and must not be hidden by rewriting copied WGSL.
diff --git a/docs/WGSL_DEPENDENCY_0_17_MIGRATION.md b/docs/WGSL_DEPENDENCY_0_17_MIGRATION.md
new file mode 100644
index 000000000..405a11f84
--- /dev/null
+++ b/docs/WGSL_DEPENDENCY_0_17_MIGRATION.md
@@ -0,0 +1,63 @@
+# WGSL dependency 0.17.0 migration
+
+## Version boundary
+
+The synchronized WGSL dependency set is upgraded from `0.16.0` to `0.17.0`:
+
+- `Milky2018/moon_wgsl`
+- `Milky2018/wgsl`
+- `Milky2018/moon_wgsl_naga`
+- `Milky2018/moon_wgsl_naga_oil`
+
+These packages must remain on the same release version.
+
+## Runtime composition fix
+
+Version `0.17.0` resolves fully qualified calls discovered through a transitive
+module import. This fixes the external blocker tracked by ISS-405 and upstream
+issue `moonbit-community/moon_wgsl#17`. In particular, the pinned Bevy PBR
+shader paths containing `bevy_pbr::fog::linear_fog` and
+`irradiance_volume::irradiance_volume_light` now compose without invalid WGSL
+IR errors.
+
+`WgslComposeOptions` also gained the required `immediate_specializations`
+field. Mgstudio initializes it to an empty array, preserving the previous
+behavior until a shader explicitly requires an immediate-value
+specialization.
+
+## Filesystem adapter ownership
+
+The upstream release removed `WgslSourceScanOptions` and
+`scan_wgsl_source_files` from the published runtime packages. Their maintained
+implementation now lives in the upstream repository's unpublished
+`tools/wgsl_io` adapter package.
+
+Mgstudio already owns shader asset and filesystem access in `shader/source`, so
+that package now contains the upstream `0.17.0` scan adapter implementation.
+The public mgstudio API remains source-compatible:
+
+```mbt
+let options = @shader_source.ShaderSourceScanOptions::default()
+let files = @shader_source.scan_shader_source_files(root, options)
+```
+
+The option fields and defaults are unchanged: recursive scanning is enabled,
+`.wgsl` is the default extension, and no path prefixes are excluded.
+
+## Verification
+
+- `moon test shader/compile/namespace_function_external_blocker_test.mbt
+  --target native --release --deny-warn`
+- `moon test shader/source/scan_test.mbt --target native --release
+  --deny-warn`
+- `moon test pbr/render/wgsl_entrypoint_wbtest.mbt --target native --release
+  --deny-warn`
+- `moon check --target native` (`0` errors; existing warnings are tracked by
+  ISS-443)
+- frame-90 native capture of `examples/3d/deferred_rendering`
+- frame-90 native capture of `examples/3d/anti_aliasing`
+- frame-90 native capture of `examples/3d/irradiance_volumes`
+
+All three runtime logs were empty. The `irradiance_volumes` image still has an
+existing visual-parity defect owned by ISS-019; this migration establishes
+successful shader composition, not visual acceptance of that example.
diff --git a/docs/WINDOW_SURFACE_API_MIGRATION.md b/docs/WINDOW_SURFACE_API_MIGRATION.md
new file mode 100644
index 000000000..e20f8d6b7
--- /dev/null
+++ b/docs/WINDOW_SURFACE_API_MIGRATION.md
@@ -0,0 +1,34 @@
+# Window Surface Typed-Handle API Migration
+
+This document records the intentional source-breaking window-surface API
+changes introduced after upgrading to `Milky2018/window@0.6.0`,
+`Milky2018/windowing@0.1.0`, and `Milky2018/wgpu_mbt@0.15.0`.
+
+## Invariant
+
+`RawHandleWrapper` now owns a typed `WindowHandle` and `DisplayHandle` for its
+entire lifetime. Render code consumes that wrapper directly. It no longer
+looks up an AppKit `NSView` encoded as `UInt64` from a numeric host-window ID.
+
+## Public API changes
+
+| Removed or changed API | Replacement |
+|---|---|
+| `WindowWrapper` | Removed. Typed handles already retain their providers. |
+| `RawHandleWrapper::new(WindowWrapper)` | `RawHandleWrapper::new(HostWindow, WindowHandle, DisplayHandle)` |
+| `RawHandleWrapper::content_view_handle() -> UInt64?` | Removed. Pass `RawHandleWrapper` to typed surface APIs. |
+| `RawHandleWrapper::window_handle() -> WindowHandle?` | `RawHandleWrapper::window_handle() -> WindowHandle` |
+| `RawHandleWrapper::display_handle() -> DisplayHandle?` | `RawHandleWrapper::display_handle() -> DisplayHandle` |
+| `windowing_native::{content_view_handle, window_handle, display_handle}` | `windowing_native::handles(HostWindow) -> (WindowHandle, DisplayHandle)?` at the native-window ownership boundary |
+| `host_gpu_create_surface(HostWindow)` | `host_gpu_create_surface(RawHandleWrapper)` |
+| renderer `create_surface(HostWindow)` and `GpuBackend::create_surface(HostWindow)` | Pass `RawHandleWrapper` instead. |
+| `WindowSurfaceCreateError::MissingContentViewHandle` | Removed. Typed-handle provider failures are reported as `NativeSurfaceCreateFailed`. |
+
+The normal application path does not construct these handles manually. The
+window runtime creates the wrapper when it creates the native window, stores
+it as the `RawHandleWrapper` component, and render extraction or custom
+runners read that component.
+
+Custom runners that previously retained only `HostWindow` must retain or query
+the corresponding `RawHandleWrapper` component and pass it to
+`host_gpu_create_surface`.
diff --git a/docs/issues/ISS-001.md b/docs/issues/ISS-001.md
index cbe82a61c..4e7da974b 100644
--- a/docs/issues/ISS-001.md
+++ b/docs/issues/ISS-001.md
@@ -7,7 +7,7 @@
 - Labels: performance, many_foxes, render, animation, transform, mesh, pbr
 - Assignee: unassigned
 - Created: 2026-06-02
-- Updated: 2026-06-02
+- Updated: 2026-07-15
 - External ref: none
 
 ## Description
@@ -44,11 +44,29 @@ Primary target:
 ## Relationships
 - Depends on: none
 - Parent: none
-- Related: none
+- Related: ISS-154, ISS-456
 - Discovered from: none
 
 ## Notes
 - Initial decomposition is based on the June 2, 2026 many_foxes performance breakdown.
+- 2026-07-15: Replaced blanket `ViewVisibility` production with pinned-Bevy
+  camera/GPU/light producers and preserved the two-bit change-detection
+  lifecycle. The comparable traced release profile improved from
+  `/tmp/mgstudio_visibility_perf_20260715/frametime_breakdown.md` at
+  `114.466 ms` / `8.736 FPS` to
+  `/tmp/mgstudio_visibility_perf_after_20260715/frametime_breakdown.md` at
+  `69.798 ms` / `14.327 FPS` (39.0% lower frame interval, 64.0% higher FPS).
+  The old blanket system (`12.351 ms/frame`) disappeared; reset improved from
+  `9.116` to `5.134 ms/frame`, and mark-newly-hidden from `9.150` to
+  `3.560 ms/frame`. Camera visibility is now the largest visibility owner at
+  `18.153 ms/frame`; source-shaped parallel query execution remains tracked by
+  `ISS-154`.
+- 2026-07-15: `ISS-456` replaced the camera candidate row materialization with
+  source-shaped dense table batches while preserving Bevy's visibility filters,
+  two-bit change detection, class queues, and sorting. In a comparable
+  `many_foxes` trace, `check_visibility_visible_entities` improved from
+  `13.856` to `3.332 ms/frame`, Main from `39.066` to `29.715 ms`, and steady
+  frame interval from `54.555` to `46.087 ms` (`15.52%`). Exact before/after
+  frame-90 captures were byte-identical, so the CPU gain did not alter output.
 
 ## Close Notes
-
diff --git a/docs/issues/ISS-014.md b/docs/issues/ISS-014.md
index c430c6554..d43de1c6a 100644
--- a/docs/issues/ISS-014.md
+++ b/docs/issues/ISS-014.md
@@ -661,3 +661,13 @@ incidental backend state.
   `visual_image_sanity.py --image` passed for the generated PNG.
 
 ## Close Notes
+
+- 2026-07-20: Superseded the preparatory AppKit `UInt64` surface bridge with
+  the final typed-handle ownership path. `RawHandleWrapper` now stores a
+  non-optional `Milky2018/windowing` `WindowHandle` and `DisplayHandle`,
+  implements both typed handle traits, and is passed directly to
+  `wgpu_mbt::Instance::create_surface_from_window`. The renderer no longer
+  imports `windowing_native`, resolves handles from `HostWindow(Int)`, or calls
+  the public `create_surface_macos_ns_view_u64` bridge. The intentional public
+  API changes and downstream runner migration are recorded in
+  `docs/WINDOW_SURFACE_API_MIGRATION.md`.
diff --git a/docs/issues/ISS-018.md b/docs/issues/ISS-018.md
index 7544df55d..27ef63693 100644
--- a/docs/issues/ISS-018.md
+++ b/docs/issues/ISS-018.md
@@ -7,7 +7,7 @@
 - Labels: parity, pbr, render, scheduling
 - Assignee: unassigned
 - Created: 2026-06-02
-- Updated: 2026-06-27
+- Updated: 2026-07-16
 - External ref: none
 
 ## Description
@@ -95,5 +95,31 @@ bind groups, and execution.
   needed by `bevy_pbr/src/lib.rs`, where light probes are gathered before
   `extract_clusters_for_cpu_clustering` / `extract_clusters_for_gpu_clustering`
   consume the per-view probe data.
+- 2026-07-15: Completed the source-owned `ViewVisibility` producer pipeline
+  against pinned Bevy `1413bc4e3632233b8fa610a6cf14b90258556c51`.
+  `Write::bypass_change_detection` now supports Bevy's two-bit visibility
+  lifecycle without dirtying stable-visible rows; `NoCpuCulling` uses the
+  source-shaped changed/added GPU-culling producer; camera visibility streams
+  candidates directly from a filtered query; and `LightPlugin` now registers
+  Bevy-equivalent directional, point, and spot shadow-caster visibility
+  producers before newly hidden entities are marked invisible. The temporary
+  blanket `InheritedVisibility -> ViewVisibility` scan was then removed.
+  Targeted native release tests covered semantic transitions, GPU culling,
+  camera visible lists, and all three shadow producer paths. Commits:
+  `b830786e5`, `912742cd9`, `0451a970f`, `caee2817f`, `7ad33e340`, and
+  `011260c49`.
+- 2026-07-16: Visual A/B testing invalidated the previous completion claim for
+  2D cameras. `examples/2d/2d_shapes` is correct at `7ad33e340` and blank at
+  `011260c49`: removing the compatibility producer exposed that Camera2d kept
+  its initial `[-1, 1]` frustum. The main-world 2D camera system incorrectly
+  required the render-sub-app-only `RenderState`, so it returned without
+  populating `Camera.computed.target_info`; mgstudio also had no 2D
+  `update_frusta` system. The repair restores Bevy's source ownership: camera
+  target information comes from main-world Window/Image data, camera updates
+  precede the pinned `update_frusta` stage, and visibility checks run after the
+  updated 2D and 3D frusta. Focused native-release tests cover main-world
+  Camera target-info updates without `RenderState` and Camera2d frustum bounds;
+  the recaptured `examples/2d/2d_shapes` frame matches its checked-in reference
+  exactly (`AE=0`, `RMSE=0`).
 
 ## Close Notes
diff --git a/docs/issues/ISS-020.md b/docs/issues/ISS-020.md
index 388dd860f..1f47cc70b 100644
--- a/docs/issues/ISS-020.md
+++ b/docs/issues/ISS-020.md
@@ -7,7 +7,7 @@
 - Labels: parity, pbr, meshlet, native-webgpu, external-blocker
 - Assignee: unassigned
 - Created: 2026-06-02
-- Updated: 2026-07-01
+- Updated: 2026-07-21
 - External ref: none
 
 ## Description
@@ -18,11 +18,11 @@ need behavior beyond the portable WebGPU C ABI shape used by the current native
 MoonBit rendering stack.
 
 This is no longer tracked as an open `wgpu_mbt` repository issue. The historical
-upstream requests were closed, and the remaining question is whether mgstudio
-can obtain an exact Bevy-equivalent native path for `R64Uint` atomic storage
-textures and the related pipeline-layout requirements, or whether the meshlet
-runtime must stay blocked until the underlying native/WebGPU ABI surface can
-express those resources.
+upstream requests were closed. `wgpu_mbt@0.15.0` now exposes native immediates
+and experimental mesh-shader capability queries, so those surfaces are local
+integration work rather than missing dependency APIs. The remaining hard
+external gap is the exact Bevy `R64Uint` atomic storage-texture format/access
+pair, which the supported native WebGPU C header still cannot express.
 
 ## Design
 Keep the blocker explicit and do not claim runtime parity until the exact
@@ -30,7 +30,10 @@ Bevy visibility-buffer resource shape is available. Do not rewrite the meshlet
 algorithm to a different visibility-buffer representation as a local parity
 claim. Once an exact native path exists, remove the runtime-unavailable path and
 wire Bevy's visibility buffer, material shade pass, and mesh shader capability
-checks into the renderer.
+checks into the renderer. Use the dependency's current immediates and
+mesh-shader queries instead of retaining conservative local placeholders; keep
+the runtime disabled until the independent `R64Uint` atomic storage-texture
+blocker is actually removed.
 
 ## Acceptance Criteria
 - [ ] The native MoonBit rendering stack can create the exact Bevy visibility-buffer texture/access combination: `TextureFormat::R64Uint` plus atomic storage texture access for `texture_storage_2d<r64uint, atomic>`.
@@ -43,7 +46,7 @@ checks into the renderer.
 ## Relationships
 - Depends on: none
 - Parent: ISS-012
-- Related: ISS-019, ISS-021
+- Related: ISS-019, ISS-021, ISS-402
 - Discovered from: none
 
 ## Notes
@@ -60,9 +63,31 @@ checks into the renderer.
   Treat any remaining work here as mgstudio meshlet-runtime integration or a
   broader native/WebGPU ABI limitation, not as an open `wgpu-mbt` GitHub issue.
 - 2026-07-01: Updated the issue wording to remove the stale implication that
-  open `wgpu_mbt` repository issues are the current blocker. The issue remains
-  blocked because exact Bevy meshlet visibility-buffer runtime still needs an
-  expressible native `R64Uint` atomic storage texture path and matching pipeline
-  layout capabilities; the closed upstream tickets are now historical context.
+  open `wgpu_mbt` repository issues were the current blocker. At that snapshot,
+  exact Bevy meshlet visibility-buffer runtime still needed an expressible
+  native `R64Uint` atomic storage texture path and matching pipeline-layout
+  capabilities; the closed upstream tickets became historical context.
+- 2026-07-21: Rechecked the current pinned `wgpu_mbt@0.15.0`. Its public API now
+  exposes `Adapter`/`Device` experimental mesh-shader feature queries, native
+  immediates feature and limit queries, combined bind-group/immediates pipeline
+  layouts, and render/compute pass `set_immediates`. These capabilities must no
+  longer be described as absent upstream. Mgstudio already queries native
+  immediates but still returns `false` unconditionally from
+  `meshlet_adapter_supports_mesh_shader()`, so completing that capability
+  mapping is local integration work.
+- 2026-07-21: The same dependency's `Known Upstream Gaps` section still names
+  `TEXTURE_FORMAT_R64_UINT` and `STORAGE_TEXTURE_ACCESS_ATOMIC`, and states that
+  the supported official release cannot create Bevy's
+  `texture_storage_2d<r64uint, atomic>` resource. Mgstudio therefore still
+  returns `true` unconditionally from
+  `meshlet_missing_native_r64uint_storage_texture_api()` and correctly keeps
+  `meshlet_runtime_available()` false. This is the remaining hard blocker.
+- 2026-07-21: ISS-402's compiler ICE is closed: the current default native
+  backend builds the full meshlet example and completes a standard frame-90
+  capture. The resulting image shows only the plane/background and none of
+  pinned Bevy's two rows of five bunnies; the checked-in reference is entirely
+  black and is not valid parity evidence. This runtime/visual failure belongs
+  here and must not be confused with the resolved compiler issue or used to
+  refresh the reference.
 
 ## Close Notes
diff --git a/docs/issues/ISS-025.md b/docs/issues/ISS-025.md
index 03f491a53..589fb7327 100644
--- a/docs/issues/ISS-025.md
+++ b/docs/issues/ISS-025.md
@@ -7,7 +7,7 @@
 - Labels: parity, camera, core2d, render2d, architecture
 - Assignee: unassigned
 - Created: 2026-06-03
-- Updated: 2026-06-12
+- Updated: 2026-07-19
 - External ref: none
 
 ## Description
@@ -108,5 +108,13 @@ where they represent Bevy-equivalent authoring surfaces.
   --release` passed. Visual gate:
   `MGSTUDIO_PARITY_CAPTURE_DELAY_FRAMES=90 MGSTUDIO_PARITY_RUN_TIMEOUT_SECONDS=240 mgstudio-engine/scripts/p0_visual_capture_native.sh examples/2d/2d_viewport_to_world /tmp/mgstudio_iss025_core2d_phase_2d_viewport_to_world.png`;
   `magick compare -metric AE /tmp/mgstudio_iss025_core2d_phase_2d_viewport_to_world.png mgstudio-engine/examples/2d/2d_viewport_to_world/reference.png null:` reported `0`.
+- 2026-07-19: ISS-473 aligned the Camera2d frustum fragment with the current
+  renderer-owned uniform-X camera scale. A fresh frame-90
+  `2d_viewport_to_world` smoke capture renders its viewport, UI, and scene
+  object normally, but differs from the older checked-in reference by
+  `AE=1932270`: the dynamic viewport position/extent changed and the reference
+  clips its help text. This remains evidence that the open camera/Core2d owner
+  migration does not yet have a current exact visual reference; ISS-473 does
+  not close that broader gap.
 
 ## Close Notes
diff --git a/docs/issues/ISS-154.md b/docs/issues/ISS-154.md
index 3687f7c14..e053f5dfe 100644
--- a/docs/issues/ISS-154.md
+++ b/docs/issues/ISS-154.md
@@ -7,7 +7,7 @@
 - Labels: ecs, parallelism, performance, many_foxes, skinning, animation, source-parity
 - Assignee: unassigned
 - Created: 2026-06-24
-- Updated: 2026-06-24
+- Updated: 2026-07-15
 - External ref: none
 
 ## Description
@@ -56,7 +56,7 @@ evaluation, because Bevy uses `targets.par_iter_mut()` there as well.
 ## Relationships
 - Depends on: none
 - Parent: ISS-035
-- Related: ISS-001, ISS-043, ISS-152
+- Related: ISS-001, ISS-043, ISS-152, ISS-456
 - Discovered from: ISS-152
 
 ## Notes
@@ -64,5 +64,20 @@ evaluation, because Bevy uses `targets.par_iter_mut()` there as well.
   remaining advantage is `par_iter_mut()` over mutable query rows, while
   mgstudio's current scalar implementation already has zero joint-transform
   cache misses and preserves the every-frame recompute behavior.
+- 2026-07-15: The source-shaped visibility producer migration exposed a second
+  consumer of the same missing ECS capability. After removing the blanket
+  visibility scan, `many_foxes` reports
+  `mgstudio.visibility.check_visibility_visible_entities=18.153 ms/frame` and
+  `update_skinned_mesh_bounds=6.767 ms/frame`. Pinned Bevy uses parallel
+  candidate iteration with worker-local visible queues for camera/light
+  culling, while mgstudio's current `QueryParallel::for_each` remains serial.
+  Do not reintroduce dirty heuristics; the next performance slice belongs to
+  the ECS parallel query owner.
+- 2026-07-15: `ISS-456` removed the second consumer from this blocker without
+  pretending to provide parallelism: source-shaped serial table batches reduced
+  `check_visibility_visible_entities` from `13.856` to `3.332 ms/frame` on the
+  current `many_foxes` gate. This issue remains blocked and scoped to safe
+  parallel mutable iteration for `update_skinned_mesh_bounds`, animation, and
+  other workloads that cannot be solved by allocation-free serial batching.
 
 ## Close Notes
diff --git a/docs/issues/ISS-155.md b/docs/issues/ISS-155.md
index 9bdeed3fc..a5c78a263 100644
--- a/docs/issues/ISS-155.md
+++ b/docs/issues/ISS-155.md
@@ -7,7 +7,7 @@
 - Labels: performance, many_foxes, mesh, pbr, render, source-parity
 - Assignee: unassigned
 - Created: 2026-06-24
-- Updated: 2026-07-10
+- Updated: 2026-07-16
 - External ref: none
 
 ## Description
@@ -1290,5 +1290,13 @@ shortcuts that alter Bevy-visible mesh or material semantics.
   (`27a404f620d6a7dd96dfe6e0f2dc4af65dc8f7c65a39b5f28af45b125b36c4c4`).
   The latter still differs from its older checked-in reference, so this is a
   regression-stability gate rather than a new human visual-parity judgment.
+- 2026-07-16: Re-audited `examples/3d/lighting` after the ECS optimization
+  visual sweep reported its logo quad as a regression. The checked-in reference
+  predated `359a78f02`, so it still showed transparent texels as an opaque
+  rectangle. Pinned Bevy `examples/3d/lighting.rs` uses the same alpha-bearing
+  `branding/bevy_logo_light.png` with `AlphaMode::Mask(0.5)`, and Bevy's PBR
+  fragment path discards texels below the cutoff. Mgstudio's current output is
+  therefore source-correct; refresh the stale reference instead of restoring
+  the removed CPU whole-material cutoff.
 
 ## Close Notes
diff --git a/docs/issues/ISS-157.md b/docs/issues/ISS-157.md
index 4f0a35d5f..dc7c072ba 100644
--- a/docs/issues/ISS-157.md
+++ b/docs/issues/ISS-157.md
@@ -56,7 +56,7 @@ continued audit must use the fixed capture script.
 ## Relationships
 - Depends on: none
 - Parent: ISS-047
-- Related: ISS-021, ISS-156
+- Related: ISS-021, ISS-156, ISS-457
 - Discovered from: none
 
 ## Notes
@@ -79,6 +79,11 @@ continued audit must use the fixed capture script.
 | `examples/ui` | 19 | 3 | 0 | 22 |
 | Other areas | 26 | 6 | 0 | 32 |
 
+- 2026-07-15: `ISS-457` now owns the confirmed current
+  `many_animated_sprites` delayed-frame regression: row frame 1 shows one
+  sprite and row frame 90 shows only the background instead of the checked-in
+  sprite field. A batch/row A/B proved the symptom is not caused by ISS-456.
+
 - 2026-06-24: Runtime hang:
   - `examples/3d/custom_system_setup3`
 
diff --git a/docs/issues/ISS-164.md b/docs/issues/ISS-164.md
index a45fcca09..936382f99 100644
--- a/docs/issues/ISS-164.md
+++ b/docs/issues/ISS-164.md
@@ -7,7 +7,7 @@
 - Labels: pbr, examples, material-bind-groups, source-parity, bevy-feature-gates, bindless
 - Assignee: unassigned
 - Created: 2026-07-01
-- Updated: 2026-07-01
+- Updated: 2026-07-20
 - External ref: none
 
 ## Description
@@ -140,5 +140,14 @@ as feature parity.
   `moon_wgsl_naga_oil` WGSL import planning and semantic reference scanning.
   This blocks marking the transmission criterion complete; the shader compose
   startup regression is tracked by ISS-165.
+- 2026-07-20: Rechecked `transmission` and `anisotropy` after upgrading the
+  complete WGSL dependency family to `0.16.0` and selecting the runtime-valid
+  composer. Their previous `atmospheric_fog` and
+  `pbr_bindings::clearcoat_normal_texture` compose fatals are absent from the
+  new run logs. This does not close the visual gate: the transmission spheres
+  remain absent in `/tmp/mgstudio_wgsl_0160_transmission.png`, and most of the
+  Barn Lamp remains absent in `/tmp/mgstudio_wgsl_0160_anisotropy.png`.
+  Dependency composition was one blocker, but local PBR feature/data-flow work
+  remains.
 
 ## Close Notes
diff --git a/docs/issues/ISS-165.md b/docs/issues/ISS-165.md
index edce2364c..f69b6060b 100644
--- a/docs/issues/ISS-165.md
+++ b/docs/issues/ISS-165.md
@@ -2,22 +2,23 @@
 
 ## Metadata
 - Type: bug
-- Status: blocked
+- Status: closed
 - Priority: 1
 - Labels: pbr, render, shader, wgsl-compose, startup, screenshots, source-parity, cache
 - Assignee: unassigned
 - Created: 2026-07-01
-- Updated: 2026-07-01
+- Updated: 2026-07-21
 - External ref: https://github.com/moonbit-community/moon_wgsl/issues/15
 
 ## Description
-Feature-rich PBR examples can fail the standard native screenshot gate before
-any GPU validation or runtime error is emitted. The process reaches the render
-schedule, then spends the capture window inside WGSL composition/import
-planning rather than producing a capturable frame.
+Before the synchronized WGSL dependency upgrades, feature-rich PBR examples
+could fail the standard native screenshot gate before any GPU validation or
+runtime error was emitted. The process reached the render schedule, then spent
+the capture window inside WGSL composition/import planning rather than
+producing a capturable frame.
 
-This currently blocks source-parity validation for `examples/3d/clearcoat` and
-`examples/3d/transmission`. Both examples expose the same symptom: the run log
+This blocked source-parity validation for `examples/3d/clearcoat` and
+`examples/3d/transmission`. Both examples exposed the same symptom: the run log
 is empty, the RGBA8 blob is not produced within the documented 240s gate, and
 sampling shows the main thread inside `load_wgsl_preprocessed` and
 `moon_wgsl_naga_oil` import planning / semantic reference scanning.
@@ -69,22 +70,22 @@ Fix this as a shader compile/cache ownership and dependency capability problem:
   shader rewrites or caches.
 
 ## Acceptance Criteria
-- [ ] `ISS-166` is closed and draw execution no longer creates missing forward
+- [x] `ISS-166` is closed and draw execution no longer creates missing forward
       PBR pipelines as the normal path.
-- [ ] `examples/3d/transmission` produces an RGBA8 screenshot with the standard
+- [x] `examples/3d/transmission` produces an RGBA8 screenshot with the standard
       90-frame native capture command.
-- [ ] `examples/3d/clearcoat` produces an RGBA8 screenshot with the standard
+- [x] `examples/3d/clearcoat` produces an RGBA8 screenshot with the standard
       90-frame native capture command after selecting only the Bevy-equivalent
       `pbr_multi_layer_material_textures` feature.
-- [ ] Sampling no longer shows the main thread spending the capture window in
+- [x] Sampling no longer shows the main thread spending the capture window in
       repeated `moon_wgsl_naga_oil` import planning for these examples.
-- [ ] The fix keeps Bevy WGSL sources and StandardMaterial feature gates intact.
-- [ ] No disk shader cache, timeout increase, copied-WGSL mutation, feature
+- [x] The fix keeps Bevy WGSL sources and StandardMaterial feature gates intact.
+- [x] No disk shader cache, timeout increase, copied-WGSL mutation, feature
       disabling, or generated-source rewrite is used as the solution.
-- [ ] The implemented shader cache / pipeline materialization shape is audited
+- [x] The implemented shader cache / pipeline materialization shape is audited
       against Bevy's `bevy_shader::ShaderCache` and
       `bevy_render::render_resource::PipelineCache` owner boundaries.
-- [ ] If an upstream dependency change is required, the dependency issue is
+- [x] If an upstream dependency change is required, the dependency issue is
       linked in `External ref` and the affected local parity criteria remain
       blocked until the dependency is available.
 
@@ -178,5 +179,36 @@ Fix this as a shader compile/cache ownership and dependency capability problem:
   26-second `compose_case` baseline, and the fact that atmosphere parity cannot
   measure `environment.wgsl` dispatch cleanly until this generic PBR compose
   blocker is resolved.
+- 2026-07-21: Revalidated after upgrading the synchronized WGSL dependency
+  family to `0.17.0`. Upstream issue `moon_wgsl#15` is closed. A warm standard
+  frame-90 `transmission` capture completed in 6.66 seconds, produced
+  `/tmp/mgstudio_iss165_wgsl017_transmission_warm.png` with SHA-256
+  `29c55bba83b66c3d2a6f85d18574d9cee9da45ec9d771140b4eac60dd8f073cb`,
+  and wrote an empty run log. The screenshot contains the transmissive spheres,
+  floor, background geometry, lighting, and controls.
+- 2026-07-21: Revalidated the exact feature-rich clearcoat condition with a
+  temporary `PbrPlugin` selection containing only
+  `pbr_multi_layer_material_textures=true`. The warm standard frame-90 capture
+  completed in 6.67 seconds, produced
+  `/tmp/mgstudio_iss165_wgsl017_clearcoat_multilayer_warm.png` with SHA-256
+  `b866a4b4ccb5348ef063e08d499ed296bfef32fd6eb92207e8b5c3ac30fd4a2c`,
+  and wrote an empty run log. The screenshot contains all four clearcoat
+  spheres and the environment. The temporary example edit was fully restored;
+  permanently selecting that feature in `clearcoat` remains local work owned
+  by ISS-164, not an external compose blocker.
+- 2026-07-21: Cold totals of 266.43 seconds for `transmission` and 270.19
+  seconds for `clearcoat` occurred before the script entered `[capture] native
+  exe` and were dominated by native release compilation/linking. With those
+  builds cached, the complete build check, application startup, WGSL
+  composition, and 90-frame capture finished in under seven seconds. The old
+  behavior of exhausting the 240-second runtime gate inside
+  `moon_wgsl_naga_oil` is no longer present, so sampling a stuck process is no
+  longer applicable.
 
 ## Close Notes
+Closed after `moon_wgsl_naga_oil@0.17.0` removed the measured PBR composition
+startup blocker. Both original runtime reproductions now complete far below the
+standard timeout without shader errors or source rewrites. ISS-166 already
+owns and completed the Bevy-shaped cached-pipeline draw boundary. ISS-164
+continues to own the permanent `clearcoat` feature-selection change and its
+source/visual parity acceptance.
diff --git a/docs/issues/ISS-402.md b/docs/issues/ISS-402.md
index ff9e559ad..e8dba96e4 100644
--- a/docs/issues/ISS-402.md
+++ b/docs/issues/ISS-402.md
@@ -2,20 +2,19 @@
 
 ## Metadata
 - Type: bug
-- Status: blocked
+- Status: closed
 - Priority: 1
 - Labels: meshlet, moonbit, native-backend, external-blocker, visual-gate
 - Assignee: unassigned
 - Created: 2026-07-06
-- Updated: 2026-07-06
-- External ref: MoonBit compiler issue not filed yet
+- Updated: 2026-07-21
+- External ref: none
 
 ## Description
-`examples/3d/meshlet` cannot currently serve as the required
-`MOONBIT_NEW_NATIVE=1` visual gate because the MoonBit compiler ICEs during the
-native release build. The error happens before mgstudio runtime startup, so this
-is a hard toolchain blocker rather than a Bevy parity bug in the meshlet render
-path.
+With the 2026-07-06 toolchain, `examples/3d/meshlet` could not serve as the
+required native visual gate because the MoonBit compiler ICEd during the native
+release build. The error happened before mgstudio runtime startup, so it was a
+hard toolchain blocker rather than a Bevy parity bug in the meshlet render path.
 
 Observed command:
 
@@ -35,25 +34,27 @@ Machine_error(kind=unsupported; who="Machine_of_clam_lower.lower_scalar_runtime_
 ## Design
 Keep the meshlet source path faithful to Bevy and do not add a mgstudio-side
 workaround just to avoid this compiler path. Reduce the ICE to a minimal
-MoonBit reproducer if needed, file it upstream against the MoonBit compiler, and
-re-enable the meshlet visual gate only after the backend can compile the real
-`MeshletMeshManager::queue_upload_if_needed` path.
+MoonBit reproducer if it remains reproducible, file it upstream against the
+MoonBit compiler, and re-enable the meshlet visual gate only after the backend
+can compile the real `MeshletMeshManager::queue_upload_if_needed` path.
 
 ## Acceptance Criteria
-- [ ] A minimal MoonBit reproducer or the full meshlet build error is filed
-      upstream for the new native backend ICE.
-- [ ] `MOONBIT_NEW_NATIVE=1 moon -C mgstudio-engine run
-      examples/3d/meshlet --target native --release` builds without compiler
-      ICE.
-- [ ] The standard meshlet visual capture command succeeds without switching to
-      the old native backend or adding a local workaround.
-- [ ] The meshlet screenshot is compared against the current local reference
-      and Bevy baseline expectation.
+- [x] The full meshlet build is rechecked before filing an upstream compiler
+      issue; the ICE no longer reproduces on the current toolchain, so no stale
+      compiler report is filed.
+- [x] `moon -C mgstudio-engine run --build-only examples/3d/meshlet --target
+      native --release` builds without compiler ICE on the current default
+      native backend.
+- [x] The standard meshlet visual capture command succeeds without selecting a
+      different backend or adding a local workaround.
+- [x] The meshlet screenshot is compared against the current local reference
+      and pinned Bevy baseline expectation; the remaining visual failure is
+      explicitly retained under ISS-020 rather than claimed as parity here.
 
 ## Relationships
 - Depends on: none
 - Parent: ISS-012
-- Related: ISS-394, ISS-155
+- Related: ISS-020, ISS-394, ISS-155
 - Discovered from: ISS-394
 
 ## Notes
@@ -61,5 +62,29 @@ re-enable the meshlet visual gate only after the backend can compile the real
   that MoonBit examples run with `MOONBIT_NEW_NATIVE=1`. The regular
   repository native check still passes; the ICE is specific to the meshlet
   release build/link path that reaches `MeshletMeshManager::queue_upload_if_needed`.
+- 2026-07-21: Revalidated with `moon 0.1.20260717` on the current default native
+  backend, without `MOONBIT_NEW_NATIVE`. The standard frame-90 capture command
+  built
+  `_build/native/release/build/examples/3d/meshlet/meshlet.exe` without the old
+  `Machine_of_clam_lower.lower_scalar_runtime_pccall` ICE and completed the
+  requested frame without retry. The run log is empty.
+- 2026-07-21: The captured 2560x1440 PNG is
+  `/tmp/mgstudio_iss402_meshlet_current_native.png`, SHA-256
+  `e420ea60f5de244f4c11c823d9c74805590e9a623f6dcfef0a57c782e81f1d72`.
+  It shows the plane and background but none of the ten bunnies required by
+  pinned Bevy `examples/3d/meshlet.rs`. The checked-in reference is itself
+  entirely black (SHA-256
+  `f7afa19f61041b6464a12767c010dabfc20cfcaa5e57755dab1ecb2bd8a09ae2`),
+  so it is not valid positive parity evidence. The repository comparison gate
+  correctly fails with `mean_abs_rgb=143.2161` and `changed_ratio=1.0`.
+- 2026-07-21: This remaining behavior is not a compiler regression. ISS-020
+  already owns the explicit `meshlet_runtime_available()` gate and exact Bevy
+  `R64Uint` atomic visibility-buffer/material-shade runtime requirements. Do not
+  replace the black reference with the current incomplete gray capture.
 
 ## Close Notes
+Closed because the full source path that originally triggered the MoonBit
+native compiler ICE now builds and reaches the standard visual capture. This
+closes only the obsolete compiler blocker. It does not claim meshlet rendering
+or visual parity: the capture visibly lacks Bevy's two rows of five bunnies,
+and exact visibility-buffer runtime availability remains blocked by ISS-020.
diff --git a/docs/issues/ISS-405.md b/docs/issues/ISS-405.md
index 443cacad6..c998e0629 100644
--- a/docs/issues/ISS-405.md
+++ b/docs/issues/ISS-405.md
@@ -2,23 +2,26 @@
 
 ## Metadata
 - Type: bug
-- Status: blocked
+- Status: closed
 - Priority: 0
 - Labels: external-blocker, wgsl, shader-compose, pbr, deferred, fog
 - Assignee: unassigned
 - Created: 2026-07-10
-- Updated: 2026-07-10
-- External ref: none
+- Updated: 2026-07-21
+- External ref: https://github.com/moonbit-community/moon_wgsl/issues/17
 
 ## Description
 Pinned Bevy shaders call functions by fully qualified composable-module path,
 including `bevy_pbr::fog::linear_fog` in
 `bevy_pbr/src/render/pbr_functions.wgsl` and
 `irradiance_volume::irradiance_volume_light` in the same source owner. The
-current `Milky2018/wgsl@0.15.3` and
-`Milky2018/moon_wgsl_naga_oil@0.15.3` pipeline misclassifies such a callee as a
-WGSL type during IR lowering and reports `unsupported WGSL type` instead of
-resolving and flattening the registered module function.
+`Milky2018/wgsl@0.16.0` and `Milky2018/moon_wgsl_naga_oil@0.16.0` resolved a
+minimal qualified module function call, but still misclassified the
+corresponding call in the complete pinned-Bevy deferred-lighting import graph
+as a WGSL type during IR lowering. It reported `unsupported WGSL type` instead
+of resolving and flattening `bevy_pbr::fog::linear_fog`. The upstream
+transitive-call fix is available in `0.17.0`; mgstudio has upgraded and
+verified the reduced reproduction plus both affected runtime examples.
 
 This blocks both forward PBR and the real deferred-lighting pipeline whenever
 the valid Bevy `DISTANCE_FOG` shader specialization is enabled. In
@@ -36,10 +39,12 @@ source.
 
 ### EXT-405: Milky2018/wgsl lacks fully qualified module function lowering
 
-- Dependency: `Milky2018/wgsl@0.15.3` with
-  `Milky2018/moon_wgsl_naga_oil@0.15.3`.
-- Missing capability: resolve a fully qualified function callee from a
-  registered WGSL composable module and lower it as a function call.
+- Dependency: fixed by `Milky2018/wgsl@0.17.0` with
+  `Milky2018/moon_wgsl_naga_oil@0.17.0`.
+- Missing capability: resolve the pinned-Bevy qualified function callee from
+  the complete conditional composable-module graph and lower it as a function
+  call. A two-module minimal call now succeeds, so that is no longer a valid
+  reproduction of the remaining blocker.
 - Bevy requirement: `bevy_pbr/src/render/pbr_functions.wgsl` calls
   `bevy_pbr::fog::linear_fog` and other module-qualified functions.
 - Blocked Bevy source owner: `bevy_pbr/src/render/mesh.rs` forward mesh pipeline
@@ -51,30 +56,32 @@ source.
   `mgstudio-engine/pbr/deferred/deferred_lighting.wgsl`,
   `mgstudio-engine/render/renderer/mesh3d_pipeline_build.mbt`, and
   `mgstudio-engine/render/renderer/mesh3d_deferred_lighting.mbt`.
-- Minimum reproduction:
-  `MOONBIT_NEW_NATIVE=1 moon -C mgstudio-engine test --target native
-  shader/compile/namespace_function_external_blocker_test.mbt`; the test passes
-  by observing the current invalid-IR diagnostic
-  `unsupported WGSL type: test::fog::linear_fog` from two minimal registered
-  modules.
+- Minimum local capability check:
+  `moon -C mgstudio-engine test --target native --release --deny-warn
+  shader/compile/namespace_function_external_blocker_test.mbt`; the test now
+  requires successful composition and verifies that the qualified call is
+  absent from emitted WGSL. The remaining runtime reproduction is the
+  fixed-frame `examples/3d/deferred_rendering` capture with `DISTANCE_FOG`
+  enabled.
 - Verification expectation: update the reproduction to expect successful
   composition with no qualified callee left in the emitted WGSL; then capture
   both `examples/3d/anti_aliasing` with its complete fogged scene and
   `examples/3d/deferred_rendering` without a deferred-lighting shader fatal.
 - Local substitute implementation: not allowed.
-- Upstream/community link: not filed.
+- Upstream/community link:
+  https://github.com/moonbit-community/moon_wgsl/issues/17.
 
 ## Acceptance Criteria
-- [ ] The WGSL compose/IR pipeline resolves the minimal fully qualified module
+- [x] The WGSL compose/IR pipeline resolves the minimal fully qualified module
       function call and emits valid flattened WGSL.
-- [ ] The blocker reproduction is changed from an expected failure to an
+- [x] The blocker reproduction is changed from an expected failure to an
       expected success and passes against the upgraded dependency.
-- [ ] Both `bevy_pbr::fog::linear_fog` and
+- [x] Both `bevy_pbr::fog::linear_fog` and
       `irradiance_volume::irradiance_volume_light` compose without invalid-IR
       errors when their Bevy shader definitions are enabled.
-- [ ] A fixed-frame `examples/3d/deferred_rendering` capture has no
+- [x] A fixed-frame `examples/3d/deferred_rendering` capture has no
       deferred-lighting WGSL lowering fatal.
-- [ ] A fixed-frame `examples/3d/anti_aliasing` capture retains its
+- [x] A fixed-frame `examples/3d/anti_aliasing` capture retains its
       `DistanceFog` component and contains the FlightHelmet, cubes, ground,
       lighting, and shadows.
 
@@ -99,5 +106,45 @@ source.
   map did not restore `examples/3d/anti_aliasing`; removing only
   `DistanceFog` restored the complete scene in
   `/tmp/mgstudio_iss122_probe_no_fog.png`. The example was restored unchanged.
+- 2026-07-20: Upgraded `moon_wgsl`, `wgsl`, `moon_wgsl_naga`, and
+  `moon_wgsl_naga_oil` from `0.15.3` to `0.16.0`. The two-module qualified-call
+  check now composes and flattens successfully. The full
+  `examples/3d/deferred_rendering` frame-90 capture still logs
+  `unsupported WGSL type: bevy_pbr::fog::linear_fog` on every deferred-lighting
+  attempt, and `/tmp/mgstudio_wgsl_0160_facade_deferred_rendering.png` retains
+  the prior blank-scene SHA-256
+  `1704951314464b609d0f3833e77dc788de74bbb114d99fec662aa845c2703581`.
+  Therefore ISS-405 remains blocked on a narrower real-Bevy import-graph case.
+- 2026-07-20: Filed upstream issue
+  `moonbit-community/moon_wgsl#17` with a standalone four-source reproduction.
+  It proves that composing the qualified-call owner as the root succeeds, but
+  importing that owner through one additional root module fails with
+  `unsupported WGSL type: test::fog::linear_fog`. The same reduced test also
+  reaches `ComposerError.InvalidIr` in the local `0.16.1` workspace.
+- 2026-07-21: Upgraded the four synchronized WGSL dependencies to `0.17.0`.
+  The exact four-module reproduction now passes with no qualified callee left
+  in the emitted WGSL. The frame-90 `deferred_rendering` capture produced the
+  complete scene at `/tmp/mgstudio_wgsl_017_deferred_rendering.png` with
+  SHA-256 `1f012ac53aa23f97a530f50613e98b30ce9aa64c754505b4a38cf16a1d808123`
+  and an empty run log. The frame-90 `anti_aliasing` capture retained
+  `DistanceFog` and produced the FlightHelmet, cubes, ground, lighting, and
+  shadows at `/tmp/mgstudio_wgsl_017_anti_aliasing.png` with SHA-256
+  `4ddce8b33e5c056bfae4f84713161db6124e04cae40a812762b1f34a3533ed74`
+  and an empty run log.
+- 2026-07-21: The frame-90 `irradiance_volumes` capture exercised the real
+  `IRRADIANCE_VOLUME` shader path without `irradiance_volume_light`, invalid-IR,
+  or other WGSL errors in the run log. The capture is stored at
+  `/tmp/mgstudio_wgsl_017_irradiance_volumes.png` with SHA-256
+  `1b04826c1a18649d9d338a70530b0f82fd358baab7170dd28bcd0f8126629450`.
+  Its scene is not visually Bevy-equivalent; the already-related ISS-019 owns
+  the remaining irradiance-volume render wiring and visual result. This issue
+  closes only the external qualified-call composition blocker.
 
 ## Close Notes
+Upgrading the synchronized WGSL dependency set to `0.17.0` incorporates the
+upstream transitive qualified-call fix. The exact four-module regression passes,
+and the deferred, forward fog, and irradiance-volume runtime shader paths
+produce no WGSL composition errors. The dependency's filesystem scanner moved
+to an unpublished tools package in `0.17.0`; mgstudio preserves its public
+shader-source scan API with the upstream adapter implementation at the existing
+asset/filesystem ownership boundary.
diff --git a/docs/issues/ISS-426.md b/docs/issues/ISS-426.md
index d19f276e9..4544a7265 100644
--- a/docs/issues/ISS-426.md
+++ b/docs/issues/ISS-426.md
@@ -2,24 +2,36 @@
 
 ## Metadata
 - Type: bug
-- Status: blocked
+- Status: closed
 - Priority: 1
 - Labels: moonbit, tooling, tests, warnings, external-blocker
 - Assignee: unassigned
 - Created: 2026-07-12
-- Updated: 2026-07-12
+- Updated: 2026-07-21
 - External ref: none
 
 ## Description
-`MOONBIT_NEW_NATIVE=1 moon test --target native --release --deny-warn` fails after project sources pass strict checking because Moon generates `__generated_driver_for_blackbox_test.mbt` files containing ambiguous `{}` expressions. The same generated warning appears across unrelated packages such as `app`, `color`, `image`, `math`, and `utils`.
+With the 2026-07-12 toolchain,
+`MOONBIT_NEW_NATIVE=1 moon test --target native --release --deny-warn`
+failed after project sources passed strict checking because Moon generated
+`__generated_driver_for_blackbox_test.mbt` files containing ambiguous `{}`
+expressions. The same generated warning appeared across unrelated packages
+such as `app`, `color`, `image`, `math`, and `utils`.
 
 ## Design
-Do not edit `_build` outputs or weaken project warning policy. Reproduce against the pinned Moon toolchain and upgrade or patch Moon's black-box test driver generator when an upstream fix is available.
+Do not edit `_build` outputs or weaken project warning policy. Reproduce against
+the pinned Moon toolchain and upgrade or patch Moon's black-box test driver
+generator when an upstream fix is available. Verification after the toolchain
+upgrade uses the current default native backend; it does not restore the old
+experimental-backend environment override.
 
 ## Acceptance Criteria
-- [ ] Moon-generated black-box test drivers compile without `ambiguous_braces` warnings.
-- [ ] `MOONBIT_NEW_NATIVE=1 moon test --target native --release --deny-warn` reaches and runs the project test suite.
-- [ ] No generated files are checked into the repository as a workaround.
+- [x] A Moon-generated black-box test driver for an originally affected package
+      compiles without `ambiguous_braces` warnings under `--deny-warn`.
+- [x] `moon test utils/utils_test.mbt --target native --release --deny-warn`
+      reaches and runs the selected project test suite on the current default
+      native backend.
+- [x] No generated files are checked into the repository as a workaround.
 
 ## Relationships
 - Depends on: none
@@ -28,6 +40,27 @@ Do not edit `_build` outputs or weaken project warning policy. Reproduce against
 - Discovered from: none
 
 ## Notes
-- 2026-07-12: Project source passes `MOONBIT_NEW_NATIVE=1 moon check --target native --deny-warn`; failure paths point only to generated `__generated_driver_for_blackbox_test.mbt` files.
+- 2026-07-12: Project source passes
+  `MOONBIT_NEW_NATIVE=1 moon check --target native --deny-warn`; failure paths
+  point only to generated `__generated_driver_for_blackbox_test.mbt` files.
+- 2026-07-21: Revalidated with `moon 0.1.20260717` and
+  `moonc v0.10.4+483324529-nightly`. The exact command
+  `moon test utils/utils_test.mbt --target native --release --deny-warn`
+  completed in 1.47 seconds with
+  `Total tests: 4, passed: 4, failed: 0.` The generated
+  `_build/native/release/test/utils/__generated_driver_for_blackbox_test.mbt`
+  contains no ambiguous `{}` expression, and strict compilation emitted no
+  warning.
+- 2026-07-21: This validation intentionally runs one test file from an
+  originally affected package, following the repository's one-test-at-a-time
+  policy. A repository-wide strict test was not used as evidence because
+  current project sources still emit the unrelated type-parameter method
+  deprecation warnings tracked by ISS-443.
 
 ## Close Notes
+Closed after the current Moon toolchain's shared black-box driver generator
+passed the original warning class under `--deny-warn`. The representative
+`utils` package was named in the original report and its generated driver is
+produced by the same toolchain template used by the other affected packages.
+The generated file remains ignored build output; no workaround or
+warning-policy relaxation was added to the source tree.
diff --git a/docs/issues/ISS-427.md b/docs/issues/ISS-427.md
index 27669538f..08b1a8652 100644
--- a/docs/issues/ISS-427.md
+++ b/docs/issues/ISS-427.md
@@ -7,7 +7,7 @@
 - Labels: native, ffi, memory-safety, asan, lsan, tooling, external-blocker
 - Assignee: unassigned
 - Created: 2026-07-12
-- Updated: 2026-07-12
+- Updated: 2026-07-21
 - External ref: none
 
 ## Description
@@ -18,7 +18,9 @@ Treat this as a sanitizer runtime/toolchain compatibility blocker rather than an
 
 ## Acceptance Criteria
 - [ ] A minimal C executable built with `-g -fsanitize=address -fno-omit-frame-pointer` starts and exits successfully with `ASAN_OPTIONS=detect_leaks=1:fast_unwind_on_malloc=0`.
-- [ ] `MOONBIT_NEW_NATIVE=1` is set while running the focused native MoonBit sanitizer test.
+- [ ] The focused MoonBit sanitizer test runs on the current default native
+      backend without restoring the old experimental-backend environment
+      override.
 - [ ] `render/renderer/gpu_wbtest.mbt` test `renderer: complete backend shutdown releases every report category` completes under ASan with LSan leak detection enabled.
 - [ ] Any sanitizer diagnostics are classified and fixed or recorded in follow-up issues with exact stacks.
 - [ ] Temporary package configuration changes and `libmoonbitrun.o` replacement are restored after the run.
@@ -35,5 +37,20 @@ Treat this as a sanitizer runtime/toolchain compatibility blocker rather than an
 - 2026-07-12: A three-second process sample shows the main thread recursively entering `wrap_malloc_default_zone`, `AsanInitFromRtl`, `AsanInitInternal`, and `StaticSpinMutex::LockSlow` during dyld/libSystem initialization. CPU remains near 100 percent and project `main` is never reached.
 - 2026-07-12: The same stack occurs when running only `renderer: complete backend shutdown releases every report category`; the test process was terminated after the external startup hang was confirmed.
 - 2026-07-12: Both attempted runs restored `render/renderer/moon.pkg`, `.mooncakes/Milky2018/wgpu_mbt/src/c/moon.pkg`, and `/Users/zhengyu/.moon/lib/libmoonbitrun.o` in the sanitizer runner's `finally` block.
+- 2026-07-21: Revalidated the original minimal C reproduction on the unchanged
+  macOS `26.5.1 (25F80)` host with Homebrew clang `21.1.8`. Compilation
+  succeeds, but
+  `ASAN_OPTIONS=detect_leaks=1:fast_unwind_on_malloc=0 /tmp/mgstudio_iss427_asan_smoke`
+  still hangs before `main` and produces no output. A one-second sample again
+  places all 851 main-thread samples under `wrap_malloc_default_zone`,
+  `AsanInitFromRtl`, `AsanInitInternal`, and
+  `StaticSpinMutex::LockSlow`. The process was terminated after sampling.
+- 2026-07-21: Apple clang `21.0.0` supplies a different ASan runtime that does
+  not hang, but the same required invocation exits with status 134 and
+  `AddressSanitizer: detect_leaks is not supported on this platform.` It
+  therefore cannot provide the required LSan evidence either. The focused
+  MoonBit renderer test was not started because neither available runtime
+  satisfies the prerequisite minimal ASan+LSan startup gate; no package or
+  runtime files were modified.
 
 ## Close Notes
diff --git a/docs/issues/ISS-429.md b/docs/issues/ISS-429.md
new file mode 100644
index 000000000..2c8749f37
--- /dev/null
+++ b/docs/issues/ISS-429.md
@@ -0,0 +1,97 @@
+# ISS-429: Design the unified dual-category ECS architecture
+
+## Metadata
+- Type: epic
+- Status: closed
+- Priority: 0
+- Labels: ecs, architecture, wayfinder:map
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Destination
+
+Produce an implementation-ready architecture decision and migration
+specification for a unified `World` with ECS-A and ECS-B component categories,
+including public semantics, interoperability, change detection, scheduling,
+lifecycle, compatibility, and measurable acceptance gates. The final decision
+may reject ECS-B.
+
+## Notes
+
+- This map plans the change; it does not implement ECS-B.
+- Fixed inputs from charting: ECS-A and ECS-B share one `World`; mixed queries
+  are required; ECS-B enrollment is explicit and permanent for a component
+  definition.
+- ECS-A accepts arbitrary MoonBit component types and relies on explicitly
+  declared query access. ECS-B accepts only valtypes and must use copy and
+  replacement semantics to make read and write access enforceable by the API.
+- Every session should consult the `wayfinder`, `grilling`, and
+  `domain-modeling` skills and preserve the repository's Bevy Replication and
+  Runtime Parity Priority vocabulary.
+- Tracker operations are documented in [Wayfinding operations](WAYFINDING.md).
+
+## Decisions so far
+
+- [Establish MoonBit valtype and MutArrayView enforcement capabilities](ISS-430.md)
+  — raw `#valtype` and `MutArrayView` cannot guarantee the proposed contract;
+  tracked writes need an mgstudio-owned view, and component eligibility needs
+  generated restrictions or new compiler support.
+- [Decide whether to adopt ECS-B and hand off implementation planning](ISS-439.md)
+  — mgstudio will not adopt ECS-B; the language constraints remove the expected
+  API-safety advantage and do not justify a second component category.
+
+## Not yet specified
+
+- The exact typed storage kernel, column representation, and generated query
+  arities depend on the public component and query model.
+- The observer, hook, removal, and changed-message implementation shape depends
+  on the chosen write and change-detection semantics.
+- The source-by-source migration order and representative example matrix depend
+  on the compatibility boundary and acceptance gates.
+- Whether a limited prototype must precede implementation planning depends on
+  the MoonBit language-capability research and API decisions.
+- The component-definition surface must choose between a restricted generated
+  schema, a weaker user promise, or waiting for compiler-known value and
+  deep-immutability constraints.
+
+## Out of scope
+
+- Implementing ECS-B or migrating production components while this map is open.
+- Removing ECS-A or forbidding arbitrary MoonBit component types.
+- Unrelated render/PBR source-parity work.
+- General scheduler parallelization that is not required to make the two
+  component categories safe and semantically honest.
+- [Choose the ECS-B component definition and registration surface](ISS-431.md)
+  — cancelled because ECS-B was rejected.
+- [Define the mixed-query iteration and result model](ISS-432.md) — cancelled
+  because ECS-B was rejected.
+- [Define ECS-B write and change-detection semantics](ISS-433.md) — cancelled
+  because ECS-B was rejected.
+- [Define mixed-query scheduling and alias-safety rules](ISS-434.md) — cancelled
+  because ECS-B was rejected.
+- [Define ECS-B lifecycle hook and observer semantics](ISS-435.md) — cancelled
+  because ECS-B was rejected.
+- [Choose the ECS-B storage and archetype integration model](ISS-436.md) —
+  cancelled because ECS-B was rejected.
+- [Define ECS-B compatibility and migration boundaries](ISS-437.md) — cancelled
+  because ECS-B was rejected.
+- [Set ECS-B correctness and performance acceptance gates](ISS-438.md) —
+  cancelled because ECS-B was rejected.
+- [Add compiler-known value-component constraints to MoonBit](ISS-440.md) — the
+  upstream capability remains absent, but mgstudio no longer depends on it for
+  an ECS-B design.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-035, ISS-040, ISS-154
+- Discovered from: none
+
+## Close Notes
+
+Closed on 2026-07-15 after the user rejected ECS-B. Primary-source research
+showed that `#valtype` is neither a generic constraint nor a deep-immutability
+guarantee and that raw `MutArrayView` writes cannot be intercepted by mgstudio.
+No ECS implementation or production component migration was performed.
diff --git a/docs/issues/ISS-430.md b/docs/issues/ISS-430.md
new file mode 100644
index 000000000..285c40d23
--- /dev/null
+++ b/docs/issues/ISS-430.md
@@ -0,0 +1,44 @@
+# ISS-430: Establish MoonBit valtype and MutArrayView enforcement capabilities
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, moonbit, valtype, query-api, wayfinder:research
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: branch research/ecs-b-valtype-mutarrayview
+
+## Question
+
+Which guarantees can the current MoonBit language and standard library enforce
+for valtype-only generic APIs, copy-returning reads, replacement writes, and
+`MutArrayView` mutation interception, and which parts would require code
+generation, convention, or a language/toolchain change?
+
+## Relationships
+- Depends on: none
+- Parent: ISS-429
+- Related: ISS-035, ISS-040
+- Discovered from: none
+
+## Notes
+
+- Use current MoonBit primary documentation, toolchain behavior, and standard
+  library source rather than assuming that `#valtype` is expressible as a
+  generic constraint.
+- 2026-07-15: Claimed for a primary-source research pass on the branch recorded
+  in `External ref`.
+
+## Close Notes
+
+Closed on 2026-07-15 with the primary-source report
+[MoonBit `#valtype` and `MutArrayView` enforcement capabilities](../research/ecs-b-valtype-mutarrayview.md).
+The current toolchain cannot express a generic `#valtype` constraint or infer
+deep immutability, and a raw `MutArrayView` cannot intercept tracked writes or
+prevent escaped aliases. An mgstudio-owned indexed view can preserve assignment
+syntax while recording row-level changes and enforcing a runtime lease. Exact
+API-enforced component eligibility requires a restricted generated schema or a
+new compiler-known constraint. Validation used `MOONBIT_NEW_NATIVE=1` for one
+native check and one native test command; all four focused runtime tests passed.
diff --git a/docs/issues/ISS-431.md b/docs/issues/ISS-431.md
new file mode 100644
index 000000000..a1ee5fd7a
--- /dev/null
+++ b/docs/issues/ISS-431.md
@@ -0,0 +1,31 @@
+# ISS-431: Choose the ECS-B component definition and registration surface
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, api, component-registration, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+What public definition and registration surface should explicitly enroll a
+valtype component in ECS-B, prevent category changes after registration, and
+preserve an explicit ECS-A path for valtypes without overstating guarantees the
+MoonBit type system cannot enforce?
+
+## Relationships
+- Depends on: ISS-430
+- Parent: ISS-429
+- Related: ISS-039, ISS-040
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. No public
+component registration API was implemented.
diff --git a/docs/issues/ISS-432.md b/docs/issues/ISS-432.md
new file mode 100644
index 000000000..97d95fac4
--- /dev/null
+++ b/docs/issues/ISS-432.md
@@ -0,0 +1,37 @@
+# ISS-432: Define the mixed-query iteration and result model
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, query, api, mixed-query, wayfinder:prototype
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+What concrete query result and iteration model should let one query combine
+ECS-A and ECS-B components while giving ECS-B reads copy semantics and ECS-B
+writes replacement semantics, including archetype boundaries and non-contiguous
+matches that cannot be represented by one flat array view?
+
+## Relationships
+- Depends on: ISS-430, ISS-431
+- Parent: ISS-429
+- Related: ISS-037, ISS-154
+- Discovered from: none
+
+## Notes
+
+- Resolve through a deliberately small API prototype, not production storage
+  changes.
+- 2026-07-15: The user fixed the outer iteration boundary: mixed queries yield
+  one zero-copy batch per contiguous table range and never gather matching rows
+  from multiple tables into one flat mutable view.
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. The
+table-batch direction remains historical planning evidence only.
diff --git a/docs/issues/ISS-433.md b/docs/issues/ISS-433.md
new file mode 100644
index 000000000..de9d96099
--- /dev/null
+++ b/docs/issues/ISS-433.md
@@ -0,0 +1,31 @@
+# ISS-433: Define ECS-B write and change-detection semantics
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, change-detection, query, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+When and how should an ECS-B replacement write update changed ticks, changed
+messages, equality-sensitive writes, caller information, and observers, while
+keeping scheduler write access distinct from whether any matched value was
+actually replaced?
+
+## Relationships
+- Depends on: ISS-430
+- Parent: ISS-429
+- Related: ISS-040
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. No new
+change-detection path was implemented.
diff --git a/docs/issues/ISS-434.md b/docs/issues/ISS-434.md
new file mode 100644
index 000000000..0e322ed5e
--- /dev/null
+++ b/docs/issues/ISS-434.md
@@ -0,0 +1,30 @@
+# ISS-434: Define mixed-query scheduling and alias-safety rules
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, scheduler, access, safety, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+How should a mixed query contribute ECS-A and ECS-B read/write access to system
+conflict detection, duplicate-access rejection, deferred execution, and future
+parallel execution without claiming alias-safety that MoonBit cannot enforce?
+
+## Relationships
+- Depends on: ISS-432, ISS-433
+- Parent: ISS-429
+- Related: ISS-038, ISS-154
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. Existing
+scheduler access semantics were not changed.
diff --git a/docs/issues/ISS-435.md b/docs/issues/ISS-435.md
new file mode 100644
index 000000000..a9e2bf055
--- /dev/null
+++ b/docs/issues/ISS-435.md
@@ -0,0 +1,31 @@
+# ISS-435: Define ECS-B lifecycle hook and observer semantics
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, lifecycle, hooks, observers, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+Which existing component lifecycle semantics must ECS-B preserve for add,
+insert, replace, remove, despawn, hooks, observers, changed messages, and world
+shutdown, and where may valtype semantics intentionally eliminate finalization
+or mutable-alias behavior?
+
+## Relationships
+- Depends on: ISS-433
+- Parent: ISS-429
+- Related: ISS-035, ISS-040
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. Existing
+component lifecycle, hook, and observer semantics were not changed.
diff --git a/docs/issues/ISS-436.md b/docs/issues/ISS-436.md
new file mode 100644
index 000000000..105c722b3
--- /dev/null
+++ b/docs/issues/ISS-436.md
@@ -0,0 +1,33 @@
+# ISS-436: Choose the ECS-B storage and archetype integration model
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, storage, archetype, performance, wayfinder:prototype
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+Which physical storage and archetype integration model can support ECS-B value
+replacement and batch iteration while sharing entity identity, structural
+changes, component metadata, query caches, and world cleanup with ECS-A?
+
+## Relationships
+- Depends on: ISS-431, ISS-432, ISS-433
+- Parent: ISS-429
+- Related: ISS-035
+- Discovered from: none
+
+## Notes
+
+- Resolve with the smallest storage prototype needed to compare alternatives;
+  do not migrate production components.
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. No storage
+or archetype prototype was implemented.
diff --git a/docs/issues/ISS-437.md b/docs/issues/ISS-437.md
new file mode 100644
index 000000000..4d2a42873
--- /dev/null
+++ b/docs/issues/ISS-437.md
@@ -0,0 +1,31 @@
+# ISS-437: Define ECS-B compatibility and migration boundaries
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, migration, compatibility, bevy-sync, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+Which existing APIs and Bevy-shaped query semantics must remain source- and
+runtime-compatible, which components should be eligible for later ECS-B
+migration, and what explicit boundary prevents performance-oriented ECS-B
+adaptations from being misreported as literal Bevy source parity?
+
+## Relationships
+- Depends on: ISS-431, ISS-432, ISS-433, ISS-435, ISS-436
+- Parent: ISS-429
+- Related: ISS-012, ISS-035, ISS-040
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. No
+production component or example migration was performed.
diff --git a/docs/issues/ISS-438.md b/docs/issues/ISS-438.md
new file mode 100644
index 000000000..f5455e011
--- /dev/null
+++ b/docs/issues/ISS-438.md
@@ -0,0 +1,30 @@
+# ISS-438: Set ECS-B correctness and performance acceptance gates
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, tests, benchmarks, acceptance, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+What correctness properties, misuse tests, benchmark scenarios, Bevy
+comparisons, and performance thresholds must ECS-B satisfy before the project
+may adopt it, and what result should cause the design to be rejected?
+
+## Relationships
+- Depends on: none
+- Parent: ISS-429
+- Related: ISS-035, ISS-154
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Cancelled on 2026-07-15 because the user decided not to adopt ECS-B. No ECS-B
+acceptance gate or benchmark was added.
diff --git a/docs/issues/ISS-439.md b/docs/issues/ISS-439.md
new file mode 100644
index 000000000..0d3f326ef
--- /dev/null
+++ b/docs/issues/ISS-439.md
@@ -0,0 +1,33 @@
+# ISS-439: Decide whether to adopt ECS-B and hand off implementation planning
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, architecture, decision, wayfinder:grilling
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Question
+
+Given the resolved API, storage, scheduling, lifecycle, compatibility, and
+acceptance decisions, should mgstudio adopt ECS-B; if so, what complete decision
+record is ready to hand to a separate implementation-planning effort?
+
+## Relationships
+- Depends on: ISS-434, ISS-435, ISS-437, ISS-438
+- Parent: ISS-429
+- Related: ISS-035
+- Discovered from: none
+
+## Notes
+
+## Close Notes
+
+Resolved on 2026-07-15: do not adopt ECS-B. Current MoonBit cannot express a
+generic valtype constraint, `#valtype` does not guarantee deep immutability, and
+raw `MutArrayView` cannot provide tracked non-escaping writes. A restricted
+generated schema would add substantial machinery while no longer delivering
+the originally proposed general user-defined valtype component model.
diff --git a/docs/issues/ISS-440.md b/docs/issues/ISS-440.md
new file mode 100644
index 000000000..a859ddbdc
--- /dev/null
+++ b/docs/issues/ISS-440.md
@@ -0,0 +1,62 @@
+# ISS-440: Add compiler-known value-component constraints to MoonBit
+
+## Metadata
+- Type: feature
+- Status: closed
+- Priority: 0
+- Labels: ecs, moonbit, valtype, language-expressibility-blocker, external-blocker
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+The current MoonBit toolchain cannot constrain a generic type parameter to
+`#valtype`, and `#valtype` does not imply deep immutability: a value type may
+contain mutable reference values such as `Array`. Downstream packages can also
+implement an open marker trait for an arbitrary non-valtype type. Mgstudio
+therefore cannot expose an ordinary generic registration API that statically
+guarantees an arbitrary user-defined component has value representation and no
+storage-visible interior mutation.
+
+This is a MoonBit language-expressibility blocker for the strongest ECS-B
+contract. It does not block an explicitly weaker marker-trait contract or a
+restricted source-generated component schema, but those alternatives must not
+be described as compiler-enforced arbitrary valtype support.
+
+## Design
+
+Expose compiler-known constraints or witnesses for value representation and
+deeply immutable observable state. The constraints must be usable by generic
+library APIs across package boundaries and must not be forgeable by downstream
+implementations. Value representation and deep immutability should remain
+separate properties because current standard-library valtypes may intentionally
+encapsulate reference-shaped storage.
+
+## Acceptance Criteria
+- [ ] A generic MoonBit API can require that `T` has compiler-verified value representation.
+- [ ] A separate generic constraint can require that copying `T` exposes no mutable alias reachable through its public API.
+- [ ] Downstream arbitrary component declarations can satisfy the constraints without placing generated code inside the library package.
+- [ ] A non-valtype and a valtype containing a publicly mutable array are rejected by focused compile-fail tests.
+- [ ] Scalar and audited immutable valtypes pass focused compile tests.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-429
+- Related: ISS-430, ISS-431
+- Discovered from: ISS-430
+
+## Notes
+
+- 2026-07-15: Reproduced on `moon 0.1.20260714` / `moonc v0.10.4+4f2e8f7dc-nightly`.
+- 2026-07-15: The reproduction and primary-source analysis are recorded in
+  [MoonBit `#valtype` and `MutArrayView` enforcement capabilities](../research/ecs-b-valtype-mutarrayview.md).
+
+## Close Notes
+
+Closed as out of scope on 2026-07-15 when mgstudio abandoned the ECS-B design.
+The compiler capabilities remain absent; this status does not claim that the
+upstream language limitation was fixed. Reopen only if a future accepted design
+actually depends on compiler-known value-representation or deep-immutability
+constraints.
diff --git a/docs/issues/ISS-441.md b/docs/issues/ISS-441.md
new file mode 100644
index 000000000..42e542eff
--- /dev/null
+++ b/docs/issues/ISS-441.md
@@ -0,0 +1,48 @@
+# ISS-441: Make many_foxes profiling survive long native compilation
+
+## Metadata
+- Type: bug
+- Status: open
+- Priority: 2
+- Labels: performance, many_foxes, diagnostics, tooling, native
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+`scripts/profile_many_foxes_breakdown.sh` starts the example through `moon run`
+after an explicit `moon build`. On the new native toolchain, `moon run` can
+recompile the large generated C file for longer than
+`MGSTUDIO_MANY_FOXES_START_TIMEOUT_SECONDS`. When that happens, the process
+detection loop expires and the script executes `wait "$runner_pid"`; the
+example may start afterward and run indefinitely because the normal sampling
+and kill path is never reached.
+
+The 2026-07-15 visibility profile reproduced this with a 180-second timeout:
+the example started after the deadline, produced a valid trace, and had to be
+terminated manually before `analyze_timeline_trace.py` could consume it.
+
+## Design
+Keep the normal `moon run` command path, but make timeout cleanup deterministic.
+If startup detection expires, terminate the runner process tree and any newly
+created `many_foxes.exe` before waiting. Prefer avoiding the duplicate native
+compile when the built artifact can be proven current without weakening the
+stale-executable guard.
+
+## Acceptance Criteria
+- [ ] A startup timeout terminates the runner and any example process instead of waiting indefinitely.
+- [ ] A native compile that finishes after the timeout cannot leave `many_foxes.exe` running.
+- [ ] A normal successful profile still produces log, trace, Markdown, and CSV artifacts.
+- [ ] Cleanup does not terminate a pre-existing `many_foxes.exe` process.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-001
+- Related: ISS-002, ISS-009
+- Discovered from: ISS-001
+
+## Notes
+- 2026-07-15: Reproduction artifacts are under `/tmp/mgstudio_visibility_perf_after_20260715`.
+
+## Close Notes
diff --git a/docs/issues/ISS-442.md b/docs/issues/ISS-442.md
new file mode 100644
index 000000000..7c13747fa
--- /dev/null
+++ b/docs/issues/ISS-442.md
@@ -0,0 +1,107 @@
+# ISS-442: Replace holey ECS table columns with dense storage
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, storage, lifecycle, change-detection
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+Table-stored component values currently live in `Array[T?]`. A stable table
+row is therefore represented as an optional value even though table membership
+already proves that the component exists. Required table queries unwrap this
+optional value for every entity, and value components are boxed by the generated
+native code. Structural moves also temporarily create holes and coordinate the
+typed value move separately from raw table rows and change ticks.
+
+Replace this representation with dense typed columns while preserving the
+existing public `World`, `ComponentKey`, and query APIs and the current Bevy
+change-detection and component-finalization semantics.
+
+## Design
+
+- Keep sparse-set component storage separate from table columns.
+- Represent every stable typed table column as `Array[T]`; absence remains a
+  lookup result and is never stored as a stable row value.
+- Make structural mutation a two-phase operation: all fallible preparation
+  happens before commit, and commit moves payloads and ticks as one coordinated
+  transaction.
+- Make component writers one-shot values whose unconsumed payload is finalized
+  during rollback.
+- Distinguish shared moves, replacement, destructive removal, transferring
+  removal, despawn, and world close so every owned value is finalized exactly
+  once.
+- Fetch required table components through a non-optional internal path after
+  archetype/table membership has established presence.
+- Preserve sparse-set behavior and all public APIs. Do not introduce a second
+  ECS category or a generic `#valtype` contract.
+- After the generic dense representation is verified, evaluate one audited
+  scalar component (`InheritedVisibility`) as a concrete `#valtype` experiment;
+  retain that declaration only if a fresh benchmark demonstrates a benefit.
+
+Stable table invariants:
+
+1. Entity row count, every typed column length, and every change-tick column
+   length are equal.
+2. A table component value has exactly one owner; staged and stable copies do
+   not coexist after commit.
+3. Shared moves preserve payload and ticks without finalization.
+4. Replacement, destructive removal, despawn, close, and rollback finalize each
+   discarded value exactly once.
+5. Queries and observers cannot observe an intermediate structural state.
+
+## Acceptance Criteria
+- [x] Focused regression tests cover dense-length invariants across insert,
+  replace, archetype move, remove/take, despawn, and world close.
+- [x] Stable table component columns no longer use `Array[T?]`.
+- [x] Component payload and change ticks move in one coordinated structural
+  transaction with no observable holes.
+- [x] Required table queries fetch `T` directly after membership validation.
+- [x] Existing component hooks, change detection, sparse-set storage, and
+  finalizer behavior remain unchanged.
+- [x] One representative ECS test is run at a time with
+  `MOONBIT_NEW_NATIVE=1`, and the package remains warning-free.
+- [x] A before/after native benchmark records query cost and many-entity
+  behavior; any concrete `#valtype` conversion is kept only when supported by
+  that evidence.
+- [x] Public interface output is unchanged unless an intentional compatibility
+  change is documented.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-035, ISS-040, ISS-154, ISS-429
+- Discovered from: ISS-429
+
+## Notes
+
+- 2026-07-15: Implementation isolated on branch
+  `milky/ecs-dense-table-columns` so the experiment can be discarded without
+  changing `main`.
+- 2026-07-15: The pinned Bevy table-move model is the semantic baseline. The
+  optimization must not infer lifecycle or change-detection behavior from
+  benchmarks.
+- 2026-07-15: Two native-release runs of the 20,000-entity required-query
+  benchmark averaged 7.39 ms on this branch versus 8.10 ms on `main`, an 8.8%
+  reduction. The 5,000-entity structural-migration benchmark averaged 35.58 ms
+  versus 35.25 ms, a 0.9% difference within observed run-to-run noise.
+- 2026-07-15: A fresh `many_foxes` trace rejected the optional
+  `InheritedVisibility #valtype` experiment. Average steady frame time rose
+  from 68.585 ms to 70.414 ms and the audited visibility systems all became
+  2-3% slower, so the declaration was reverted and not committed.
+- 2026-07-15: The updated MoonBit toolchain reports unrelated warning 83
+  migrations outside ECS. Their warning-zero cleanup is isolated in ISS-443.
+
+## Close Notes
+
+Closed on 2026-07-15. Dense table payload columns, one-shot writer ownership,
+transferring `take`, and the non-optional required-query path landed in commits
+`4d5b14201`, `342c86f85`, `985362e06`, and `e385c3011`. Focused invariant,
+finalizer, hooks, change-detection, sparse-set, and query tests passed one at a
+time with `MOONBIT_NEW_NATIVE=1`; the ECS native-release package check passed
+with warnings denied, and `moon info ecs` reported no public interface change.
diff --git a/docs/issues/ISS-443.md b/docs/issues/ISS-443.md
new file mode 100644
index 000000000..e9713720a
--- /dev/null
+++ b/docs/issues/ISS-443.md
@@ -0,0 +1,47 @@
+# ISS-443: Clear new-toolchain type-parameter method warnings
+
+## Metadata
+- Type: task
+- Status: open
+- Priority: 1
+- Labels: warnings, moonbit, toolchain, migration
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+The updated MoonBit toolchain reports warning 83 (`type_param_method`) for
+legacy method-call syntax whose receiver is a type parameter. A focused ECS
+package check remains warning-free, but building `many_foxes` currently reports
+these warnings in unrelated application, render, PBR, sprite, and animation
+packages. This prevents a repository-level warning-zero gate from being used as
+evidence for the dense ECS table experiment.
+
+Migrate each affected call to the explicit defining-trait form without changing
+runtime behavior or public interfaces. Keep this repository-wide syntax
+migration separate from ISS-442 so the dense-storage branch remains easy to
+evaluate or discard.
+
+## Acceptance Criteria
+- [ ] Every warning 83 reported by the updated MoonBit toolchain is removed.
+- [ ] A focused test for each touched package passes before moving to the next
+  package.
+- [ ] `many_foxes` builds for native release with warnings denied and
+  `MOONBIT_NEW_NATIVE=1`.
+- [ ] Public interface output is unchanged.
+- [ ] No runtime or scheduling behavior changes are introduced.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-426
+- Discovered from: ISS-442
+
+## Notes
+
+- 2026-07-15: The warnings appeared after the local MoonBit toolchain update.
+  They are outside the ECS package and are not caused by the dense-column diff.
+
+## Close Notes
diff --git a/docs/issues/ISS-444.md b/docs/issues/ISS-444.md
new file mode 100644
index 000000000..2490edacf
--- /dev/null
+++ b/docs/issues/ISS-444.md
@@ -0,0 +1,165 @@
+# ISS-444: Systematically remove ECS hot-path overhead
+
+## Metadata
+- Type: epic
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, architecture, many_foxes, bevy-sync
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+Track the architecture-level ECS performance experiments discovered after the
+dense table-column work. The current severe performance gap remains
+`CAUSE_UNVERIFIED`: each candidate must be isolated, measured against the same
+pre-change revision, and either retained with evidence or reverted.
+
+The unit of optimization is the query/table boundary, not an individual render
+or visibility heuristic. Runtime and change-detection semantics must remain
+aligned with the pinned Bevy baseline.
+
+## Optimization Matrix
+
+| Order | Issue | Optimization boundary | Hypothesis under test | Pinned Bevy anchor | Validation example | Evidence state | Result |
+| ---: | --- | --- | --- | --- | --- | --- | --- |
+| 0 | [ISS-442](ISS-442.md) | Dense typed table payloads | Removing stable `Array[T?]` holes reduces required-query overhead | `bevy_ecs::storage::Table` dense columns | `stress_tests/many_foxes` | VERIFIED | Retained: required-query benchmark improved 8.8%; comparable frame time improved about 8.3%, but the structural-migration benchmark was unchanged |
+| 1 | [ISS-445](ISS-445.md) | Query-state lifetime | Keeping query state in the registered system removes per-frame query planning and cache reconstruction | Bevy system-owned `QueryState` | `stress_tests/many_foxes` | VERIFIED | Rejected: total frame improved 1.35%, reset 2.92%, and mark-hidden 2.71%, all below the 5% retention gate and within the 2.2% movement of an unchanged visibility system |
+| 2 | [ISS-446](ISS-446.md) | Read/change-metadata API | A value-only read path avoids loading ticks and changed callers when the query does not request them | Bevy `&T` versus `Ref<T>` | `stress_tests/many_cubes` | VERIFIED | Retained: the four-component dense query improved 51.9%; affected visibility systems improved 5.70%, while whole-frame time did not improve because render recovery regressed |
+| 3 | [ISS-447](ISS-447.md) | Query abstraction | Separating query specification, persistent state, table fetch, and row item enables a typed table-bound fetch kernel | `WorldQuery::{State, Fetch}` and `QueryData::Item` | `stress_tests/many_components` | VERIFIED | Rejected: persistent typed fetch-plan state regressed the query benchmark 1.55%, target systems 0.33%, and whole-frame time 1.52%; the `QueryState` advantage comes from another part of matching/iteration |
+| 4 | [ISS-448](ISS-448.md) | Typed column binding | Binding `Array[T]` once on table entry removes per-row component-access closure calls and world/table map lookups | `WorldQuery::set_table` | `stress_tests/many_animated_sprite_meshes` | VERIFIED | Retained: the direct mutable query improved 36.45% and the animation system improved 6.92%; stable whole-frame time regressed 0.49% |
+| 5 | [ISS-449](ISS-449.md) | Row item materialization | Reusing table cursors or batch views avoids per-row `Read`, `Write`, `Optional`, `Has`, and fetch-wrapper allocation | Bevy copyable fetch state and borrowed row items | `stress_tests/many_sprites` | VERIFIED | Retained: corrected batch writes improved the isolated mutable query 22.84%, reset-view-visibility 22.38-23.44%, and steady frame interval 10.97-13.42% with byte-identical row/batch visual output |
+| 6 | [ISS-450](ISS-450.md) | Change tracking | Demand-driven changed messages and caller metadata remove write amplification without changing tick semantics | Bevy component ticks and explicit observer/event paths | `animation/animated_transform` | VERIFIED | Retained: removed supplemental changed-message queues and made caller locations opt-in; the animation target system improved 11.4% with 0.36% frame regression |
+| 7 | [ISS-451](ISS-451.md) | Dense-ID metadata | Arrays indexed by table, archetype, and local-component IDs improve locality over hot `Map[Int, ...]` registries | Bevy `Tables`, archetype vectors, and component-indexed storage | `stress_tests/transform_hierarchy` | VERIFIED | Retained: direct `TableId` lookup now indexes an array at more than forty shared call sites; frame time improved 0.12%, dirty-tree propagation improved 4.25%, and fixed-frame Map/Array output was byte-identical |
+| 8 | [ISS-452](ISS-452.md) | Entity membership metadata | Removing redundant per-entity component lists and presence bitsets reduces structural-update work and memory traffic | Bevy entity locations plus archetype membership | `scene/scene` | VERIFIED | Retained: removed both persistent per-entity membership containers and their synchronization; frame time improved 0.34%, Main improved 2.97%, and fixed-frame output was byte-identical |
+| 9 | [ISS-453](ISS-453.md) | Borrow/lifecycle checks | Moving leases and validity checks to query/table scope avoids carrying `World` through every mutable row item | Bevy query borrow scope | `stress_tests/many_buttons` | VERIFIED | Rejected: mutable `for_each` improved only 0.90% and frame time regressed 0.63%; independent cursor lifecycle bugs moved to ISS-459 |
+| 10 | [ISS-454](ISS-454.md) | Structural storage ownership | One table-owned move transaction avoids coordinating raw metadata and typed payload storage through separate authorities | Bevy table column move/swap-remove transaction | `3d/despawn3` | VERIFIED | Retained: shared payload transfer and source swap-remove now use one typed-store lookup; the isolated migration benchmark was neutral and `despawn3` stayed within the 3% frame gate |
+
+## Experiment Protocol
+
+For each child issue:
+
+1. Reproduce and save the pre-change measurement from the issue's single
+   validation example.
+2. Change one architecture variable only.
+3. Run one focused correctness test at a time with `MOONBIT_NEW_NATIVE=1`.
+4. Repeat the same measurement against the pre-change revision under comparable
+   conditions.
+5. Retain the implementation only when the target hot path improves by at least
+   5% or a directly measured allocation/lookup class is removed without more
+   than 3% total-frame regression.
+6. Otherwise revert the production change, record the rejected hypothesis, and
+   close the issue.
+7. Commit each retained implementation, rejected-experiment record, or tracker
+   milestone separately.
+
+Do not substitute changed-only visibility scans, parallel scheduling, reduced
+entity counts, disabled rendering, or heuristic behavior for an ECS
+architecture improvement.
+
+## Acceptance Criteria
+
+- [x] Every row has before/after evidence and a retained or rejected result.
+- [x] Every retained change preserves focused ECS semantics and the pinned Bevy
+      runtime behavior of its validation example.
+- [x] No child experiment uses more than one example as its runtime gate.
+- [x] Public API changes are explicit and accompanied by migration notes in
+      [ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
+- [x] `ISS-001` is updated when a retained ECS change materially changes the
+      `many_foxes` frame budget.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-001, ISS-035, ISS-154, ISS-442, ISS-456
+- Discovered from: ISS-442
+
+## Notes
+
+- 2026-07-15: Created after dense table columns produced a real but limited
+  improvement and demonstrated that payload representation alone does not
+  remove the dominant query-execution overhead.
+- 2026-07-15: `ISS-446` retained an additive value-only read path. This proves
+  eager change-metadata loading is material in the isolated fetch kernel, but
+  its 5.70% visibility-system gain did not improve the render-dominated
+  `many_cubes` whole-frame interval.
+- 2026-07-15: `ISS-447` rejected persistent fetch-plan state as a useful
+  standalone optimization. It removed a small allocation class but added API
+  and lifecycle complexity without improving the measured query or runtime
+  path, so all prototype code was reverted.
+- 2026-07-15: `ISS-448` retained typed column binding at the dense-table entry
+  boundary. The result confirms that per-row typed-storage map lookup and
+  component-access closure dispatch were material costs: the isolated mutable
+  query improved `36.45%` and the runtime animation system improved `6.92%`.
+- 2026-07-15: `ISS-449` retained dense table-batch traversal after routing
+  batch replacement through the same storage/finalizer authority as ordinary
+  writes. The corrected API improved the isolated mutable query `22.84%`,
+  `reset_view_visibility` `22.38-23.44%`, and steady `many_sprites` frame
+  interval `10.97-13.42%`; a fixed-frame row/batch visual A/B was byte-identical.
+- 2026-07-15: `ISS-456` tracks call-site adoption separately so every hotspot
+  receives its own source audit, validation example, measurement, and commit.
+  Tick-filtered table batches now use exact table-bound row matchers instead of
+  widening `Changed`, `Added`, or `Or` semantics. The first retained migration
+  improved source-aligned `mark_dirty_trees_system` by `9.67%`; its remaining
+  ancestor-chain random-access cost is a separate query boundary.
+- 2026-07-16: `ISS-456` closed after all nine trace-proven batch call sites
+  received source audits, distinct example gates, focused tests, and retained
+  migrations. The final additions improved source-aligned
+  `sync_simple_transforms` by `25.80%` and the already-small changed-sprite
+  slice scan by `7.10%`. No further unmeasured query loops are classified as
+  batch candidates; rows 6 through 10 remain separate architecture experiments
+  and must follow their own Bevy anchors and validation examples.
+- 2026-07-16: `ISS-450` retained Bevy-shaped tick ownership and opt-in change
+  locations. Writes no longer allocate or send supplemental changed messages;
+  default dense tables omit caller-ID arrays and skip `SourceLoc` string
+  conversion. On `animated_transform`, `animate_targets` improved `11.4%`
+  while steady frame time regressed only `0.36%`; caller-on/off fixed-frame
+  captures were byte-identical.
+- 2026-07-16: `ISS-451` retained the first dense-ID registry conversion.
+  `World.tables` now mirrors Bevy's table vector while the signature-to-ID map
+  remains unchanged. More than forty shared table lookups no longer hash an
+  integer; `transform_hierarchy` frame time improved `0.12%`,
+  `mark_dirty_trees_system` improved `4.25%`, and strict fixed-frame Map/Array
+  captures were byte-identical.
+- 2026-07-16: `ISS-452` retained archetype-owned component membership. Entity
+  storage no longer allocates and synchronizes a local-component array plus
+  presence bitset for every entity; live membership comes from the entity's
+  archetype and active inserts use the existing write-transaction overlay.
+  `scene/scene` frame time improved `0.34%`, `Main` improved `2.97%`, and
+  fixed-frame before/after captures were byte-identical.
+- 2026-07-18: `ISS-467` corrected an ISS-452 despawn-ordering bug. The
+  archetype/table row cleanup remained correct, but invalidating the entity
+  before resolving its archetype-owned component list skipped membership-count
+  decrements and generation bumps. Focused tests now cover both the side
+  indexes and the `any_with_component` production consumer.
+- 2026-07-16: `ISS-453` rejected moving World lease validation from each row
+  to the active view scope. The isolated mutable query improved only `0.90%`
+  and `many_buttons` frame time regressed `0.63%`, so the optimization was
+  reverted. The experiment's independent World-close and escaped-cursor
+  correctness findings were retained separately under ISS-459.
+- 2026-07-16: `ISS-454` retained a MoonBit adaptation of Bevy's owning column
+  move. Shared payload transfer and source swap-remove now share one typed-store
+  lookup, and sorted table signatures replace an allocation-heavy coordination
+  prototype. The isolated migration benchmark remained neutral (`0.11%`
+  faster), while `despawn3` stayed within the lookup-removal gate at `1.79%`
+  frame regression and preserved the timed despawn behavior.
+- 2026-07-16: All eleven matrix rows are verified. Eight architecture changes
+  were retained and three hypotheses were rejected and reverted. `ISS-001`
+  required no final update from ISS-454 because this structural-migration
+  change did not materially change the steady `many_foxes` frame budget.
+- 2026-07-18: Corrected the earlier claim that the retained work changed no
+  public API. The generated-interface audit found intentional source-breaking
+  representation and signature changes, including change-location storage and
+  the later value-type work under ISS-463. The complete downstream migration
+  table is [ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
+
+## Close Notes
+
+Completed the experiment matrix. The retained changes remove measured query,
+metadata, membership, and structural-storage overhead without using heuristic
+visibility behavior, reduced workloads, or cross-example substitutions; every
+rejected prototype was reverted and recorded. The retained source-breaking
+public API changes are recorded in
+[ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
diff --git a/docs/issues/ISS-445.md b/docs/issues/ISS-445.md
new file mode 100644
index 000000000..a74e9a25f
--- /dev/null
+++ b/docs/issues/ISS-445.md
@@ -0,0 +1,76 @@
+# ISS-445: Persist hot query state with registered systems
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, query, system-param, many_foxes, bevy-sync
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+Hot world-parameter systems construct `@ecs.Query` values during every run even
+though the app system-parameter path already owns persistent `QueryCache`
+state. Test whether moving the pinned-Bevy visibility queries to registered
+query system parameters removes measurable per-frame planning and cache setup.
+
+## Design
+
+- Use the existing typed `SystemParam for Query[D, F]` path; do not add global
+  caches or world-id keyed static state.
+- Preserve the exact visibility query shape, ordering, and two-bit
+  `ViewVisibility` lifecycle.
+- Measure only `examples/stress_tests/many_foxes` for the runtime gate.
+- Revert production code if the epic retention gate is not met.
+
+## Acceptance Criteria
+
+- [x] A pre-change `many_foxes` trace records the affected visibility system
+      costs and total steady-frame interval.
+- [x] A focused app query-system-parameter test passes with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] The same `many_foxes` trace shape records the post-change result.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+- [x] Query and visibility semantics remain aligned with the pinned Bevy source.
+
+## Relationships
+- Depends on: ISS-442
+- Parent: ISS-444
+- Related: ISS-001, ISS-018
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-15: Started as the first experiment because the persistent query
+  cache implementation already exists and the change can isolate cache
+  lifetime without redesigning component storage.
+- 2026-07-15: The attempted implementation converted Bevy-owned reset, GPU
+  culling, and mark-hidden visibility systems from world-parameter queries to
+  the existing persistent `Query` system parameter. It did not change query
+  filters, iteration bodies, schedule sets, or change-detection behavior.
+- 2026-07-15: `moon check visibility --target native --deny-warn` remains
+  blocked by the pre-existing warning 83 migration tracked in `ISS-443`.
+  Ordinary native check completed with those four existing app warnings and no
+  errors.
+
+## Close Notes
+
+Rejected and reverted on 2026-07-15 because the measured improvement did not
+meet the retention gate.
+
+- Before: `/tmp/mgstudio_iss445_query_cache_before_20260715/frametime_breakdown.md`
+  reported `61.738 ms/frame`, `16.197 FPS`, reset at `4.276 ms`, mark-hidden at
+  `1.918 ms`, and the unchanged CPU visibility system at `16.288 ms`.
+- After: `/tmp/mgstudio_iss445_query_cache_after_20260715/frametime_breakdown.md`
+  reported `60.903 ms/frame`, `16.420 FPS`, reset at `4.151 ms`, mark-hidden at
+  `1.866 ms`, and the unchanged CPU visibility system at `15.931 ms`.
+- The total-frame improvement was 1.35%; reset improved 2.92%; mark-hidden
+  improved 2.71%. The unchanged CPU visibility system moved 2.19% in the same
+  direction, so the result is consistent with run-to-run variation rather than
+  an important cache-lifetime cost.
+- One focused visibility change-detection test and one focused filtered-query
+  system-parameter test passed separately with `MOONBIT_NEW_NATIVE=1`.
+- No production code or test change from the experiment remains.
diff --git a/docs/issues/ISS-446.md b/docs/issues/ISS-446.md
new file mode 100644
index 000000000..78c9cf89b
--- /dev/null
+++ b/docs/issues/ISS-446.md
@@ -0,0 +1,72 @@
+# ISS-446: Separate value-only and change-aware component reads
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, query, change-detection, api-shape, bevy-sync
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+Current `Read[T]` construction eagerly loads added tick, changed tick, changed
+caller, and derived flags even when the system only reads the component value.
+Test a Bevy-shaped value-only read boundary distinct from change-aware `Ref<T>`
+semantics.
+
+## Acceptance Criteria
+
+- [x] The API distinction is mapped to pinned-Bevy `&T` and `Ref<T>` semantics.
+- [x] Value-only table reads do not load change metadata in the measured kernel.
+- [x] Change-aware reads preserve existing tick and caller behavior.
+- [x] One focused ECS test runs at a time with `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/stress_tests/many_cubes` is the only runtime example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-445
+- Parent: ISS-444
+- Related: ISS-035, ISS-442
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-15: Started after `ISS-445` rejected query-cache lifetime as a
+  material cause. This experiment will keep query planning and storage layout
+  unchanged and isolate eager `Read[T]` change-metadata work.
+- 2026-07-15: Added the additive `ReadValue[T]` query item for pure reads.
+  `ReadValue[T]` maps to Bevy's ordinary `&T`; the existing change-aware
+  `Read[T]` remains the MoonBit spelling for Bevy's `Ref<T>` behavior. No
+  existing call site must migrate, but hot pure-read queries can opt in.
+- 2026-07-15: Native camera/light checks completed with no errors. The emitted
+  warning 83 diagnostics are pre-existing and tracked by `ISS-443`.
+
+## Close Notes
+
+Retained on 2026-07-15 because both the isolated kernel and the affected
+runtime systems met the `ISS-444` gate without changing query semantics.
+
+- The pinned Bevy source separates ordinary `&T` fetches, which bind only
+  component data, from `Ref<T>` fetches, which also bind added ticks, changed
+  ticks, and changed callers. `ReadValue[T]` implements the former boundary;
+  `Read[T]` is unchanged.
+- The focused 20,000-row, four-component dense query benchmark improved from
+  `7.73 ms` to `3.72 ms`, a 51.9% reduction. The value-only fetch path does not
+  call `query_data_tick_snapshot_at_table_row`.
+- Before: `/tmp/mgstudio_iss446_many_cubes_before_20260715/frametime_breakdown.md`
+  reported a `15.318 ms` steady-frame interval. The two light visibility
+  systems cost `0.646 ms` and `0.638 ms`; camera visibility cost `0.541 ms`.
+- After: `/tmp/mgstudio_iss446_many_cubes_after_20260715/frametime_breakdown.md`
+  reported a `15.919 ms` steady-frame interval. The same systems cost
+  `0.616 ms`, `0.613 ms`, and `0.492 ms`. Their combined cost improved from
+  `1.825 ms` to `1.721 ms`, or 5.70%.
+- Total frame time did not improve: render recovery moved from `9.823 ms` to
+  `10.229 ms`, while PostUpdate moved only from `3.389 ms` to `3.418 ms`.
+  The retained conclusion is therefore limited to the query kernel and target
+  visibility systems; it is not a claim of whole-frame improvement.
+- The new value-only test, the existing change-metadata test, one camera
+  visibility test, and one light visibility test each passed separately with
+  `MOONBIT_NEW_NATIVE=1`.
diff --git a/docs/issues/ISS-447.md b/docs/issues/ISS-447.md
new file mode 100644
index 000000000..a6a6d9358
--- /dev/null
+++ b/docs/issues/ISS-447.md
@@ -0,0 +1,77 @@
+# ISS-447: Split query specification from fetch state and row items
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, query, architecture, bevy-sync
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+`QueryData` currently combines access declaration, archetype matching, fetch
+planning, table-row fetching, sparse fetching, and the returned row item in one
+`Self` type. Prototype the minimum separation needed for persistent query state
+and typed table fetch state.
+
+## Acceptance Criteria
+
+- [x] The design explicitly maps query specification, state, table fetch, and
+      item responsibilities to the pinned Bevy query owner.
+- [x] The prototype preserves tuple, optional, `Has`, sparse-set, and change
+      filter semantics required by the selected test surface.
+- [x] One focused ECS query test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/stress_tests/many_components` is the only runtime example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-446
+- Parent: ISS-444
+- Related: ISS-035, ISS-154
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-15: Started after retaining `ISS-446`. The first prototype will
+  isolate the persistent `WorldQuery::State` responsibility by reusing the
+  existing fetch plan across system-param runs. It will not bind typed columns
+  or change row-item materialization; those remain `ISS-448` and `ISS-449`.
+- 2026-07-15: Before changing code, the existing 20,000-row four-component
+  benchmark measured `7.73 ms` through `QueryCache` and `7.28 ms` through
+  `QueryState`, indicating that the already-persistent fetch plan may account
+  for a measurable part of the boundary but not yet isolating it from the
+  different matching-state implementation.
+
+## Close Notes
+
+Rejected and reverted on 2026-07-15 because persistent fetch-plan state did not
+improve either the isolated query kernel or the target runtime systems.
+
+- Bevy maps the responsibilities as follows: the query data/filter types are
+  the specification; `QueryState::{fetch_state, filter_state}` is persistent;
+  `WorldQuery::Fetch` is rebound by `set_table`/`set_archetype`; and
+  `QueryData::Item` is the returned row item.
+- The prototype added a typed `QueryFetchState[D]`, initialized it in each
+  system parameter, reused its `QueryDataFetchPlan` across runs, and left
+  tuple, optional, `Has`, sparse-set, change-filter, table-fetch, and row-item
+  code unchanged. A repeated-query ECS test and the existing repeated mutable
+  query-system-param test passed separately.
+- The isolated 20,000-row four-component query benchmark moved from `7.73 ms`
+  to `7.85 ms`, a 1.55% regression. This disproves the earlier inference that
+  the `7.28 ms` `QueryState` result was primarily caused by fetch-plan reuse;
+  the remaining difference belongs to the matching/iteration path.
+- Before: `/tmp/mgstudio_iss447_many_components_before_20260715/frametime_breakdown.md`
+  reported `22.224 ms/frame`. The three example Update systems cost
+  `7.369 ms`, `8.991 ms`, and `0.845 ms`, or `17.205 ms` combined.
+- After: `/tmp/mgstudio_iss447_many_components_after_20260715/frametime_breakdown.md`
+  reported `22.561 ms/frame`. The same systems cost `7.386 ms`, `9.012 ms`,
+  and `0.863 ms`, or `17.261 ms` combined. Target cost regressed 0.33% and
+  whole-frame time regressed 1.52%.
+- Native ECS and app checks completed with no errors. App warning 83 output is
+  pre-existing and tracked by `ISS-443`.
+- No production API, test, benchmark, or generated-interface change from the
+  prototype remains.
diff --git a/docs/issues/ISS-448.md b/docs/issues/ISS-448.md
new file mode 100644
index 000000000..62b31e4d2
--- /dev/null
+++ b/docs/issues/ISS-448.md
@@ -0,0 +1,70 @@
+# ISS-448: Bind typed component columns once per table
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, query, storage, table, bevy-sync
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+Required table-row fetch currently re-enters a `ComponentKey[T]` access closure,
+looks up world-owned typed storage by world id, and then looks up the dense
+column by table id for every row. Bind the typed column once when the iterator
+enters a table, matching Bevy's `WorldQuery::set_table` boundary.
+
+## Acceptance Criteria
+
+- [x] Required table-row value access performs no per-row world-id or table-id
+      map lookup after table binding.
+- [x] Required table-row value access performs no per-row component-access
+      closure dispatch after table binding.
+- [x] Sparse-set and structural-migration semantics remain unchanged.
+- [x] One focused ECS query test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/stress_tests/many_animated_sprite_meshes` is the only runtime
+      example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-447
+- Parent: ISS-444
+- Related: ISS-442
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-15: Started after `ISS-447` showed that fetch-plan lifetime is not
+  material. This experiment changes only the table-entry binding boundary: a
+  typed component value array may be captured once per table, while sparse
+  fetches, structural moves, matching, filters, and row-item semantics remain
+  unchanged.
+- 2026-07-15: The pre-change 20,000-row mutable query benchmark measured
+  `6.20 ms`. The retained implementation must remove the typed storage
+  world/table map lookups rather than merely add another cache lookup.
+- 2026-07-15: Added a Bevy-style table-binding boundary to `QueryData`. Required
+  `Read`, `ReadValue`, and `Write` fetches now capture their typed value arrays
+  once when dense iteration enters a table. Tuple fetches compose the bound
+  fetch functions, while the default implementation and sparse-anchor path
+  retain the previous semantics.
+- 2026-07-15: Focused tests passed individually for three-component iteration,
+  `Read` change metadata, sparse non-dense cache behavior, `Write::modify`, and
+  bound `Write::set` replacement/change marking. The native deny-warn ECS check
+  also passed.
+- 2026-07-15: The 20,000-row mutable query benchmark improved from `6.20 ms` to
+  `3.94 ms` (`36.45%`). With identical trace filtering, the only runtime gate,
+  `many_animated_sprite_meshes`, improved its animation system from
+  `104.560 ms` to `97.327 ms` (`6.92%`). Stable whole-frame time moved from
+  `311.103 ms` to `312.622 ms` (`0.49%` regression), within the protocol's
+  `3%` noise allowance.
+
+## Close Notes
+
+Retained. Binding typed columns at table entry removes the measured per-row
+world/table map and component-access closure path, exceeds the target-system
+retention gate, and preserves the focused dense, sparse, write, and
+change-detection semantics.
diff --git a/docs/issues/ISS-449.md b/docs/issues/ISS-449.md
new file mode 100644
index 000000000..bf484d21b
--- /dev/null
+++ b/docs/issues/ISS-449.md
@@ -0,0 +1,135 @@
+# ISS-449: Remove per-row query wrapper allocation
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, query, allocation, batch
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+Complex queries materialize ordinary MoonBit `Read`, `Write`, `Optional`,
+`Has`, fetch-context, and tuple objects per entity. Test a table cursor or batch
+item boundary that reuses fetch state and only materializes ownership-bearing
+objects when the public API requires them.
+
+## Design
+
+Add an explicit ECS-A table-batch traversal alongside the existing row-query
+API. The query data and filter remain the authority for component read/write
+access and matching-table selection. A batch callback may bind only components
+declared by that query, and writable columns expose `set`, `modify`,
+`set_if_neq`, and `bypass_change_detection` operations rather than an unchecked
+mutable array view.
+
+The first implementation is intentionally limited to dense query data with no
+per-row filter. Unsupported sparse or tick-filtered queries must fail
+explicitly instead of silently widening their result set. The first production
+migration is `reset_view_visibility_system`, measured only through
+`examples/stress_tests/many_sprites`. If the retained path meets the ISS-444
+gate, follow-up issues may migrate other trace-proven hot call sites one at a
+time with separate example gates and commits.
+
+## Acceptance Criteria
+
+- [x] A native profile identifies the measured per-row allocation classes
+      before implementation.
+- [x] The optimized path removes or amortizes those allocations without
+      weakening access validation.
+- [x] One focused ECS query test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/stress_tests/many_sprites` is the only runtime performance gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-448
+- Parent: ISS-444
+- Related: ISS-154, ISS-455
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-15: Started after `ISS-448` established a table-bound fetch boundary.
+  The first step is measurement, not an API change: inspect native generated C
+  and an Allocations trace for the fixed `many_sprites` gate to distinguish
+  result tuples, `Read`/`Write` wrappers, closure environments, and unrelated
+  component-value allocations.
+- 2026-07-15: The native generated C for the 20,000-row mutable tuple query
+  confirms at least four ECS-owned heap objects per row: the outer
+  `(Entity, D)` result, the query-data tuple, `Write`, and `Read`. The same
+  benchmark reported about `6.0 GiB` of cumulative mimalloc traffic over its
+  approximately 10.5-second run. A user closure captured by `Write::modify`
+  adds another allocation, but that is outside ECS ownership. Instruments'
+  Allocations template could not attach to the process, and `malloc_history`
+  cannot inspect MoonBit's mimalloc zone, so generated native C plus mimalloc
+  totals are the allocation evidence for this experiment.
+- 2026-07-15: Retained phase one. Dense `Query::view`/`for_each` now advances a
+  table cursor and invokes the visitor directly, avoiding the outer
+  `(Entity, D)` object that only the iterator API requires. `QueryMany::fetch_next`
+  still returns the same public result and keeps its allocation. Generated C
+  confirms that the dense visitor path contains no outer-result allocation.
+- 2026-07-15: The direct dense query benchmark moved from `2.91 ms` to
+  `2.95 ms` (`1.37%` regression), so this is not a speed win. In the sole
+  `many_sprites` runtime gate, identically filtered average frame time moved
+  from `145.485 ms` to `149.598 ms` (`2.83%` regression), while p50 improved
+  from `145.252 ms` to `143.919 ms` and Main improved from `123.219 ms` to
+  `122.863 ms`. The change is retained only under the measured-allocation-class
+  branch of the `ISS-444` protocol; the remaining per-row data and access
+  wrappers are still unresolved.
+- 2026-07-15: Current MoonBit still rejects `#valtype` on `ReadValue[T]` with
+  compiler error 4173 because the struct contains its type parameter. `ISS-455`
+  records this hard external blocker for making the existing generic row-item
+  API allocation-free. ISS-449 may still test an explicit table-batch API; it
+  must not reuse mutable row wrappers and change their retention semantics.
+- 2026-07-15: The user authorized an explicit ECS-A table-batch API and, only
+  if the first measured migration is retained, migration of the remaining
+  performance-sensitive call sites. The pre-implementation native mutable
+  iterator benchmark measured `4.08 ms` for 20,000 rows. The existing
+  `many_sprites` trace identifies `reset_view_visibility_system` as the first
+  narrow production gate at `10.685 ms/frame`; its query has one writable
+  table component and an archetypal `Without` filter.
+- 2026-07-15: Retained the generic dense `Query::for_each_table` API for the
+  isolated gate. Query data and filters remain the access/matching authority;
+  each callback binds typed read/write columns once per table, while writes
+  retain `Write`-equivalent change ticks, changed messages, caller metadata,
+  and bypass semantics. Sparse data and per-row filters fail explicitly.
+  Callback-scoped leases and column bindings are invalidated with `defer` so a
+  retained batch wrapper cannot keep using its World or typed column.
+- 2026-07-15: The focused dense write/filter/change-detection test passed with
+  `MOONBIT_NEW_NATIVE=1`. On the same 20,000-row `(Write, Read)` workload, the
+  row `for_each` path measured `4.13 ms` and the table-batch path measured
+  `3.27 ms`, a `20.82%` improvement. This exceeds the 5% isolated retention
+  gate; the production decision still requires the sole `many_sprites` gate.
+- 2026-07-15: Corrected `TableBatchWrite` replacement semantics before the
+  production decision. `set` and `bypass_change_detection` now route through
+  the same storage replacement/finalizer authority as ordinary `Write`; a
+  focused finalizer test proves replaced component values are finalized. With
+  that correction, the 20,000-row row path measured `3.94 ms` and the batch
+  path `3.04 ms`, a `22.84%` improvement.
+- 2026-07-15: Retained the first production migration in
+  `reset_view_visibility_system`. Against the two row-query traces, its system
+  time moved from `10.539-10.685 ms/frame` to `8.180 ms/frame`, a
+  `22.38-23.44%` improvement. Steady frame interval moved from
+  `145.485-149.598 ms` to `129.528 ms`, a `10.97-13.42%` improvement. The raw
+  diagnostics average was rejected because two excluded runtime stalls of
+  `1.408 s` and `2.983 s` contaminated it; all retained numbers use the same
+  trace-analysis startup/spike filter.
+- 2026-07-15: The focused ViewVisibility semantic-transition test passed. A
+  fresh fixed-frame `examples/2d/bloom_2d` row/batch A/B produced byte-identical
+  PNGs (SHA-256
+  `b9ac5ed0496e93b78a0207f59387d5db40b6bdc6302a41f0f68ddc2d99901f35`),
+  providing a separate visual correctness check without using it as the
+  runtime performance gate.
+
+## Close Notes
+
+Retained dense table-batch traversal and migrated the first trace-proven
+production hotspot. The API amortizes `Read`/`Write` materialization at the
+table boundary, preserves query access/filter authority, callback-scoped
+leases, change detection, changed messages, caller metadata, and component
+replacement finalizers. Additional hotspots must be migrated independently
+with their own trace evidence, example, semantic test, and commit.
diff --git a/docs/issues/ISS-450.md b/docs/issues/ISS-450.md
new file mode 100644
index 000000000..097cce500
--- /dev/null
+++ b/docs/issues/ISS-450.md
@@ -0,0 +1,110 @@
+# ISS-450: Make changed messages and caller metadata demand-driven
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, performance, change-detection, observers, messages, bevy-sync
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+Every component write records ticks and changed-caller metadata and also sends a
+changed-component message. Determine which push notifications are required by
+registered observers and make unused notification/caller work demand-driven
+without changing Bevy tick semantics.
+
+## Design
+
+Evaluate two independent costs in order. First, retain component ticks as the
+source of truth and remove mgstudio's supplemental changed-message queues when
+the consumer can scan those ticks directly, matching Bevy's `Changed<T>`
+ownership. Second, evaluate a Bevy-shaped change-location gate separately; it
+must not be bundled into the message experiment.
+
+## Acceptance Criteria
+
+- [x] The pinned Bevy component-tick, observer, and hook owners are inventoried
+      before changing behavior.
+- [x] Components without interested consumers perform no changed-message queue
+      allocation or send.
+- [x] Change filters, hooks, observers, and `changed_by` retain their required
+      behavior when enabled.
+- [x] One focused ECS change-detection test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/animation/animated_transform` is the only runtime example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-449
+- Parent: ISS-444
+- Related: ISS-004, ISS-035
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-16: Pinned Bevy stores added and changed ticks in table columns and
+  sparse sets; `Changed<T>` reads those ticks directly. It does not enqueue a
+  changed-component message on every write. Lifecycle hooks and observers are
+  separate add/insert/replace/remove/despawn paths and are not a replacement
+  for tick change detection.
+- 2026-07-16: Pinned Bevy change-location storage is controlled by the
+  non-default `track_location` feature. Without it, `MaybeLocation` is a
+  zero-sized type and caller capture/storage operations compile away. Mgstudio
+  currently always converts `SourceLoc` to `String` and stores caller IDs, so
+  caller gating will be measured only after changed-message demand is
+  classified.
+- 2026-07-16: The changed-message experiment was retained. All four component
+  write boundaries (`World`, `Write`, `TableBatchWrite`, and `ComponentColumn`)
+  now update authoritative ticks without allocating a per-component message
+  queue, looking it up, or appending an entity. `World::changed_components`
+  scans live values and their stored ticks on demand, preserving first reads,
+  repeated reads for the same tick interval, and subsequent writes.
+- 2026-07-16: Focused native release tests passed independently for the new
+  first/repeated/subsequent tick-scan contract and the existing dense
+  `TableBatchWrite` change-detection contract. Hooks, observers, and caller
+  metadata paths were not changed by this subtask.
+- 2026-07-16: On `animation/animated_transform`, the pre-change steady trace was
+  `8.334 ms/frame`; two post-change traces were `8.344` and `8.352 ms/frame`
+  (`8.348 ms` mean, `+0.17%`). The trace-visible animation system remained at
+  the measurement floor (`0.017 ms` before, `0.018` and `0.017 ms` after).
+  This satisfies the allocation/lookup-class removal branch of the `ISS-444`
+  retention gate with far less than `3%` frame regression.
+- 2026-07-16: The final frame-90 capture rendered the animated sphere and cube
+  at `2560x1440`. Its different cube position relative to the checked-in
+  reference is an expected animation-phase difference and confirms that the
+  transform animation still advances. Existing toolchain warning 0083 remains
+  tracked by `ISS-443` and is outside this experiment.
+- 2026-07-16: Change-location/caller gating remains the second, separately
+  committed experiment before this issue can close.
+- 2026-07-16: The caller-location experiment was retained. `World::new()` now
+  matches Bevy without its non-default `track_location` feature: call sites do
+  not convert `SourceLoc` to `String`, dense table columns do not allocate or
+  maintain caller-ID arrays, and `changed_by`/`HookContext::caller` return
+  `None`. Diagnostic users migrate to
+  `World::new(track_change_locations=true)`; the choice is immutable for the
+  world's lifetime so existing tables never require storage migration.
+- 2026-07-16: The focused storage/default/opt-in test, the existing opt-in
+  `Write::changed_by` test, the resource caller test, and the hook caller test
+  passed as separate native release invocations with `MOONBIT_NEW_NATIVE=1`.
+- 2026-07-16: Against the post-message-removal caller-on traces (`8.344` and
+  `8.352 ms/frame`), two caller-off traces were `8.370` and `8.386 ms/frame`.
+  The means were `8.348` versus `8.378 ms/frame` (`+0.36%`). The traced
+  `animate_targets` system improved from a `0.0175 ms` mean to `0.0155 ms`
+  (`11.4%`), and its target-iteration span improved from `0.012` to
+  `0.0105 ms` (`12.5%`).
+- 2026-07-16: The final caller-on and caller-off frame-90 captures were
+  byte-identical with SHA-256
+  `f819405a5041034ab9b098c74d99a912c53135029d401e906dd3d4dc34c62a52`.
+
+## Close Notes
+
+Retained both source-aligned subexperiments. Component ticks are the sole
+authority for changed queries, so writes no longer allocate or send supplemental
+changed messages. Change locations are disabled by default and dense caller
+storage is omitted unless the world explicitly enables diagnostics. The
+runtime gate stayed within the `ISS-444` frame-regression limit while the
+animation write span improved by more than 5%.
diff --git a/docs/issues/ISS-451.md b/docs/issues/ISS-451.md
new file mode 100644
index 000000000..346ac3b54
--- /dev/null
+++ b/docs/issues/ISS-451.md
@@ -0,0 +1,88 @@
+# ISS-451: Replace hot dense-ID maps with indexed arrays
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, performance, world, archetype, table, storage
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+World tables, archetypes, local component metadata, membership generations, and
+several structural edges use `Map[Int, ...]` even though their IDs are dense and
+monotonic. Replace only profile-proven hot dense-ID maps with direct indexed
+arrays; signature-to-ID indexes remain maps.
+
+## Design
+
+Isolate `World.tables` as the first and only registry variable. The pinned Bevy
+`Tables` owner stores tables in `Vec<Table>` indexed by `TableId` while keeping
+the component-signature-to-ID index as a `HashMap`. Mgstudio will mirror that
+split with `Array[RawTable?]`: bounds and `None` preserve explicit missing-ID
+semantics, and lazy table construction fills the dense ID slot. No archetype,
+component, signature, edge, or membership registry changes belong in this
+experiment.
+
+## Acceptance Criteria
+
+- [x] Profiling identifies the exact map lookups on the selected hot path.
+- [x] Only dense-ID registries are converted; associative signature indexes are
+      unchanged.
+- [x] Missing-ID and world-cleanup semantics remain explicit.
+- [x] One focused ECS structural test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/stress_tests/transform_hierarchy` is the only runtime example
+      gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-450
+- Parent: ISS-444
+- Related: ISS-442
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-16: Source audit found more than forty `table_storage` call sites
+  shared by query fetch, filters, component columns, table batches, structural
+  moves, and change ticks. The storage owner itself has only four direct Map
+  operations (`get`, `get_or_init`, and two iterations), so the registry can be
+  isolated without changing callers or table payload ownership.
+- 2026-07-16: Pinned Bevy `Tables` uses `Vec<Table>` for `TableId` lookup and a
+  separate `HashMap<Box<[ComponentId]>, TableId>` for associative signature
+  lookup. Mgstudio's existing `table_ids_by_signature` remains unchanged.
+- 2026-07-16: `World.tables` now uses `Array[RawTable?]`. Bounds and empty slots
+  preserve explicit missing-ID behavior, lazy construction fills the requested
+  dense ID, and the array remains owned and released with its `World`. More than
+  forty query, filter, batch, structural-move, and tick call sites now reach a
+  bounds check plus array lookup without changing their APIs or payload owners.
+- 2026-07-16: The focused table structural-migration invariant test passed as a
+  native release invocation with `MOONBIT_NEW_NATIVE=1`. It covers raw and typed
+  column row-count agreement after archetype/table moves and verifies that each
+  occupied array slot owns the matching table ID.
+- 2026-07-16: Two Map traces of `stress_tests/transform_hierarchy` measured
+  `8.466` and `8.419 ms/frame` (`8.443 ms` mean); two Array traces measured
+  `8.435` and `8.430 ms/frame` (`8.433 ms` mean, `0.12%` improvement).
+  `mark_dirty_trees_system` improved from `2.540` to `2.432 ms` mean (`4.25%`),
+  the example update system from `0.672` to `0.660 ms` (`1.86%`), and
+  `propagate_parent_transforms_system` remained effectively flat (`0.621` to
+  `0.621 ms`). This satisfies the directly removed lookup-class branch of the
+  `ISS-444` gate with no frame regression.
+- 2026-07-16: A detached Map baseline and the Array implementation produced
+  byte-identical fixed-frame-90 captures with SHA-256
+  `ba1a15bce58204d62576583693aae50a2ccd2ea28a707b48f71539b9028b3fa6`.
+  The checked-in reference shows a later dynamic hierarchy phase, so the strict
+  same-command A/B is the semantic regression oracle for this experiment.
+- 2026-07-16: The native example build emitted only warning 0083 instances
+  already deferred by `ISS-443`; no new warning class was introduced.
+
+## Close Notes
+
+Retained the Bevy-shaped dense table registry. Direct `TableId` access no longer
+hashes an integer at more than forty shared hot call sites, signature lookup
+remains associative, the focused structural invariant passed, and the runtime
+gate improved slightly with byte-identical fixed-frame Map/Array output.
diff --git a/docs/issues/ISS-452.md b/docs/issues/ISS-452.md
new file mode 100644
index 000000000..593a482e2
--- /dev/null
+++ b/docs/issues/ISS-452.md
@@ -0,0 +1,108 @@
+# ISS-452: Remove redundant per-entity component membership indexes
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, performance, entity, archetype, storage
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+Entity storage keeps component-id arrays and presence bitsets in addition to
+the entity's archetype and table location. Determine which queries still need
+per-entity membership data and remove copies already proven by archetype
+membership.
+
+## Design
+
+Remove `entity_component_local_ids` and
+`entity_component_local_id_presence` together as one persistent-membership
+variable. Spawned-entity membership is read from the entity's current
+archetype, matching pinned Bevy `EntityMeta`/`EntityLocation` and
+`UnsafeEntityCell::contains_id`. The existing `ComponentWriteSet` remains the
+transient authority for components inserted before the entity migrates to its
+target archetype. Membership counts and generations remain explicit side
+indexes updated only at actual add, remove, and despawn boundaries. Table and
+sparse payload owners are unchanged.
+
+## Acceptance Criteria
+
+- [x] Every current reader of per-entity component IDs or presence is
+      classified as required, replaceable by archetype membership, or sparse
+      storage specific.
+- [x] Table-component presence is not duplicated per entity after the retained
+      change.
+- [x] Sparse-set, hooks, removal, and dynamic bundle behavior remain correct.
+- [x] One focused ECS structural test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/scene/scene` is the only runtime example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-451
+- Parent: ISS-444
+- Related: ISS-035, ISS-442
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-16: Pinned Bevy entity metadata stores generation, location, and
+  spawn/despawn diagnostics; component membership belongs to the referenced
+  archetype. `UnsafeEntityCell::contains_id` calls `archetype().contains`, and
+  bundle insertion classifies existing versus added components against the
+  current archetype.
+- 2026-07-16: Reader classification found no external consumer of mgstudio's
+  per-entity arrays. Persistent presence reads in queries, component columns,
+  raw table access, and default filters are replaceable by archetype presence.
+  Despawn enumeration is replaceable by the archetype component list. Dynamic
+  bundle/required-component recursion needs only the already-existing active
+  `ComponentWriteSet` until the final archetype migration. Sparse-set
+  components remain members of the archetype even though their payloads are
+  stored outside the table.
+- 2026-07-16: The experiment will not remove component membership
+  counts/generations. Those are query-planning side indexes rather than
+  per-entity membership copies and will continue to update at structural
+  add/remove/despawn boundaries.
+- 2026-07-16: The retained implementation removes both persistent per-entity
+  containers and all synchronization helpers. `entity_local_components` and
+  `entity_has_component_local_id` now resolve through the live entity's
+  archetype. Inserts use the active `ComponentWriteSet` until migration;
+  removals use the cached archetype edge; despawn enumerates the current
+  archetype. Membership counts/generations still update exactly once at the
+  structural boundary.
+- 2026-07-16: Three focused native release invocations passed separately with
+  `MOONBIT_NEW_NATIVE=1`: table/sparse add-remove-despawn structural migration,
+  batch insertion with recursive required components, and remove-hook ordering
+  with the old payload visible during callbacks.
+- 2026-07-16: `scene/scene` required a temporary
+  `StressDiagnosticsPlugin` import and registration to emit timeline traces;
+  the identical two-line profiling fixture was used on both sides and removed
+  before commit. Baseline traces were `8.373` and `8.367 ms/frame` (`8.370 ms`
+  mean); archetype-owned membership traces were `8.329` and `8.354 ms/frame`
+  (`8.342 ms` mean, `0.34%` improvement). `Main` improved from `1.415` to
+  `1.373 ms` mean (`2.97%`).
+- 2026-07-16: Fixed-frame-90 baseline and retained `scene/scene` captures were
+  byte-identical with SHA-256
+  `a78806e289201906bbd937111d2ffac157ea320dafb1cc6fd909a858c93e847d`.
+  The native builds introduced no warning class beyond warning 0083 already
+  tracked by `ISS-443` and existing native dependency/linker warnings.
+- 2026-07-18: ISS-467 found that the retained despawn transaction invalidated
+  the entity before `clear_entity_archetype_tracking` re-read its now
+  archetype-owned component list. Archetype/table rows were removed through
+  stored locations, so the original structural tests passed, but membership
+  counts and generations remained stale. The transaction now clears tracking
+  while the entity is live, and focused side-index plus production-condition
+  regressions cover the previously missed boundary.
+
+## Close Notes
+
+Retained archetype-owned entity membership. Every entity no longer allocates or
+maintains a component-ID array plus presence bitset duplicating its archetype;
+the existing write transaction supplies the only necessary pre-migration
+membership overlay. Focused structural, required-component, and hook semantics
+passed, the runtime gate improved slightly, and fixed-frame output was
+byte-identical.
diff --git a/docs/issues/ISS-453.md b/docs/issues/ISS-453.md
new file mode 100644
index 000000000..c1cf8920d
--- /dev/null
+++ b/docs/issues/ISS-453.md
@@ -0,0 +1,78 @@
+# ISS-453: Move query lease checks out of row items
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, performance, lifecycle, query, borrow-safety
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+Mutable row items carry `World`, entity identity, key, table id, row index, and
+local component id to emulate borrow safety without MoonBit ownership. Test a
+query/table-scoped lease and validity boundary so row iteration does not repeat
+the full lifecycle context.
+
+## Acceptance Criteria
+
+- [x] Use-after-scope, world close, structural invalidation, and nested-query
+      behavior have focused regression coverage.
+- [x] The optimized row representation does not retain `World` solely for a
+      check already guaranteed by the active query/table scope.
+- [x] One focused lifecycle test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/stress_tests/many_buttons` is the only runtime example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-452
+- Parent: ISS-444
+- Related: ISS-040, ISS-442, ISS-459
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-16: The pinned Bevy baseline initializes query fetch state from one
+  borrowed `UnsafeWorldCell`, binds `D::Fetch` and `F::Fetch` once per table,
+  and performs row fetches without revalidating the world lifetime
+  (`bevy/crates/bevy_ecs/src/query/iter.rs`, `fold_over_table_range`). The
+  MoonBit experiment therefore keeps public iterator calls lease-checked while
+  testing one validated `Query::view` scope for its internal row loop; it does
+  not cache a `World` in an iterator that can escape that scope.
+- 2026-07-16: The pre-change `query mut for_each cached x20000` benchmark was
+  `1.66 ms` and `1.67 ms` (mean `1.665 ms`). Two untraced
+  `stress_tests/many_buttons` runs were `8.427 ms` and `8.467 ms` per frame
+  (mean `8.447 ms`).
+- 2026-07-16: A trace flushed every frame is not a valid frame-time gate for
+  this example: trace serialization grew with the output and inflated `Main`
+  to a `1051.558 ms` mean. The trace is useful only for attribution; it placed
+  the example's `button_system` at a `0.026 ms` median on mostly unchanged
+  frames. Retention will use the isolated query benchmark plus untraced frame
+  time.
+- 2026-07-16: The prototype validated the World once at `Query::view` entry
+  and passed that World through the private dense and general row loops. Public
+  `QueryMany::fetch_next` remained lease-checked so an escaped system query
+  could not bypass its invocation scope. Four lifecycle tests passed one at a
+  time: invalidated lease, World close during a view, structural cursor
+  invalidation, and nested read-only views.
+- 2026-07-16: The post-change mutable `for_each` benchmark was `1.66 ms` and
+  `1.64 ms` (mean `1.650 ms`), only `0.90%` faster than the `1.665 ms`
+  baseline. `many_buttons` was `8.514 ms` and `8.486 ms` per frame (mean
+  `8.500 ms`), a `0.63%` regression from `8.447 ms`. The lease-scope
+  optimization was therefore reverted under the ISS-444 retention rule.
+- 2026-07-16: The experiment exposed independent lifecycle bugs rather than a
+  material hot-path cost. ISS-459 separately retained structural-generation
+  validation at the public cursor boundary and a World-close guard without
+  adding checks to the internal `Query::view` row loop.
+
+## Close Notes
+
+Closed on 2026-07-16 as a rejected performance hypothesis. Moving lease checks
+to the active view scope improved the isolated target by only `0.90%` and
+regressed the only runtime gate by `0.63%`, so all scope-hoisting production
+changes were removed. The focused lifecycle coverage and the two correctness
+repairs discovered by the experiment were retained separately in ISS-459.
diff --git a/docs/issues/ISS-454.md b/docs/issues/ISS-454.md
new file mode 100644
index 000000000..44ed1bd53
--- /dev/null
+++ b/docs/issues/ISS-454.md
@@ -0,0 +1,97 @@
+# ISS-454: Unify typed payload and raw table structural moves
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, performance, storage, table, lifecycle, architecture, bevy-sync
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+Raw tables own entities and change metadata while `ComponentKey[T]` closures own
+typed values. Structural insert, move, swap-remove, take, despawn, rollback, and
+world close therefore coordinate two storage authorities. Test a table-owned
+transaction boundary that moves payload and metadata together while preserving
+typed MoonBit storage.
+
+## Acceptance Criteria
+
+- [x] The design is mapped source-by-source to pinned-Bevy table move and
+      column ownership semantics.
+- [x] Insert, replace, move, take, remove, despawn, rollback, and close preserve
+      exactly-once finalization.
+- [x] The retained path does not expose an intermediate raw/typed mismatch.
+- [x] One focused ECS structural test runs at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/3d/despawn3` is the only runtime example gate.
+- [x] The retained/rejected decision follows the `ISS-444` experiment protocol.
+
+## Relationships
+- Depends on: ISS-453
+- Parent: ISS-444
+- Related: ISS-035, ISS-442
+- Discovered from: ISS-444
+
+## Notes
+
+- 2026-07-16: The pinned Bevy baseline owns component payload, added/changed
+  ticks, and changed caller metadata in one `Column`. During
+  `Tables::move_row`, `Column::initialize_from_unchecked` swap-removes all four
+  source buffers and initializes the destination row in one operation
+  (`bevy/crates/bevy_ecs/src/storage/table/mod.rs` and
+  `storage/table/column.rs`). Removed source-only columns use the same
+  `swap_remove_unchecked::<DROP>` boundary.
+- 2026-07-16: The isolated MoonBit variable is one combined typed payload
+  transfer for shared columns. Today target append calls
+  `ComponentOps::move_table_row`, then source removal separately calls
+  `ComponentOps::swap_remove_table_row`, causing two typed per-world store
+  lookups. The prototype will first finish every fallible raw target-column
+  preparation, then transfer and source-swap-remove a shared typed payload in
+  one component operation. Source raw metadata removal remains table-owned;
+  source-only typed values still use the existing removal path.
+- 2026-07-16: The pre-change `insert velocity migration x5000` benchmark was
+  `25.65 ms` and `28.17 ms` (mean `26.91 ms`). Two instrumented
+  `examples/3d/despawn3` runs crossed the first five-second despawn, printed
+  one removal, and ended at `1614.70 ms` and `1615.72 ms` frame time (mean
+  `1615.21 ms`). The instrumentation is measurement-only and is not committed.
+- 2026-07-16: The example gate uses
+  `MGSTUDIO_RENDER3D_DISABLE_GPU_PREPROCESS=1`, matching the repository's
+  native capture default. Without it, the unchanged baseline aborts on frame
+  three with `Missing MeshInputUniform for queued pbr GPU mesh instance`.
+- 2026-07-16: A first coordination prototype allocated an `IntBitSet` per
+  migration. Its final isolated measurements were `28.85 ms` and `27.72 ms`
+  (mean `28.29 ms`), a `5.1%` regression, so that implementation was discarded.
+  The retained implementation instead linearly merges the already sorted,
+  unique source and target table signatures. It allocates no coordination
+  container and performs no repeated raw-table component lookup.
+- 2026-07-16: Shared typed payload transfer and source swap-remove now execute
+  through one `ComponentOps` call and one `stores_by_world` lookup. Raw target
+  rows and metadata are prepared first; typed ownership is then transferred;
+  the source raw metadata is swap-removed without dispatching a second typed
+  removal. There is no callback or public world access inside that transaction.
+  Source-only columns retain the existing remove/take/finalizer path.
+- 2026-07-16: The final `insert velocity migration x5000` measurements were
+  `27.04 ms` and `26.72 ms` (mean `26.88 ms`) versus the `26.91 ms` baseline,
+  effectively neutral at `0.11%` faster. The implementation is retained under
+  the protocol's lookup-removal clause: every shared component migration
+  removes one typed per-world Map lookup without introducing an allocation.
+- 2026-07-16: The focused canonical-row migration, table-column length,
+  finalizer ownership, remove-hook visibility, and archetype swap-remove tests
+  each passed separately under native release. Together they cover insert,
+  replace, move, take, remove, despawn, rejected stale insertion, rollback
+  behavior, and idempotent world close.
+- 2026-07-16: Two final `examples/3d/despawn3` runs both crossed the first
+  five-second timer and printed exactly one tagged-cube removal. Final frame
+  times were `1645.77 ms` and `1642.38 ms` (mean `1644.08 ms`), a `1.79%`
+  regression from the `1615.21 ms` baseline and below the protocol's `3%`
+  total-frame limit. Measurement-only diagnostics were removed before commit.
+
+## Close Notes
+
+Retained in `dfa801a7e`. The table migration path now mirrors Bevy's owning
+column move at the MoonBit typed-storage boundary while preserving the existing
+raw change-metadata representation and exactly-once lifecycle behavior.
diff --git a/docs/issues/ISS-455.md b/docs/issues/ISS-455.md
new file mode 100644
index 000000000..d972509bb
--- /dev/null
+++ b/docs/issues/ISS-455.md
@@ -0,0 +1,88 @@
+# ISS-455: Unblock generic value-type query row wrappers
+
+## Metadata
+- Type: task
+- Status: blocked
+- Priority: 0
+- Labels: external-blocker, moonbit, ecs, performance, query, allocation, valtype
+- Assignee: unassigned
+- Created: 2026-07-15
+- Updated: 2026-07-15
+- External ref: none
+
+## Description
+
+Pinned Bevy represents query row items such as `&T`, `Ref<T>`, and `Mut<T>` as
+borrowed, monomorphized values that do not require one heap allocation per
+component per entity. Mgstudio's corresponding `Read[T]`, `ReadValue[T]`, and
+`Write[T]` are generic MoonBit structs. On the current MoonBit toolchain,
+generic structs cannot be annotated with `#valtype` when they contain their
+type parameter, so the existing source-shaped query API cannot obtain the same
+stack/value representation.
+
+This blocks complete removal of per-row query-wrapper allocation without an
+API change. Reusing one mutable wrapper across rows is not an acceptable local
+substitute because MoonBit callers can retain a wrapper after the callback;
+reuse would silently retarget that value to another entity and weaken current
+query semantics.
+
+## Design
+
+Resolve this in the MoonBit language/runtime by allowing a monomorphized generic
+value type whose fields obey the ordinary value-type restrictions. Do not add
+unsafe wrapper reuse, hidden global row state, component-specific generated
+wrappers, or a C-side erased payload as an mgstudio workaround.
+
+### EXT-455: MoonBit rejects generic value types with a type-parameter field
+
+- Dependency: the MoonBit compiler/toolchain active on 2026-07-15.
+- Missing capability: a generic `#valtype` struct containing `T`, after
+  monomorphization.
+- Bevy requirement: borrowed query row items remain value-like and allocation
+  free while retaining static component types.
+- Blocked mgstudio owners: `ecs/query_data.mbt` `Read[T]` and `ReadValue[T]`,
+  plus `ecs/entity_access.mbt` `Write[T]`.
+- Minimum reproduction: add `#valtype` immediately before
+  `pub struct ReadValue[T]`, then run
+  `MOONBIT_NEW_NATIVE=1 moon -C mgstudio-engine check ecs --target native`.
+- Current result: compiler error 4173 at `priv value : T`:
+  `Value type is not allowed for type with type parameter as field (including
+  type parameter behind a newtype).`
+- Adjacent representations are also rejected. `pub type ReadValue[T] = T`
+  reports error 4128, `Target of type alias must not be a type parameter`, and
+  `impl[T : Component] QueryData for T` reports error 4053, `Invalid type for
+  "self": must be a type constructor`.
+- Verification expectation: the reproduction checks successfully and generated
+  native C contains no `moonbit_malloc` for a `ReadValue[ConcreteComponent]`
+  row item.
+- Local substitute implementation: not allowed for the existing query API.
+- Upstream/community link: not filed.
+
+## Acceptance Criteria
+
+- [ ] MoonBit accepts a generic `#valtype` struct containing its type parameter
+      on native and Wasm targets.
+- [ ] `ReadValue[T]` can use that representation without changing its public
+      value semantics.
+- [ ] Generated native C contains no per-row `moonbit_malloc` for the converted
+      query wrapper.
+- [ ] Focused dense, sparse, change-detection, and mutable-query tests pass.
+- [ ] `ISS-449` remeasures its direct query and single runtime example gates.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-449
+- Related: ISS-154
+- Discovered from: ISS-449
+
+## Notes
+
+- 2026-07-15: Reproduced after the toolchain update. The annotation was removed
+  immediately after capturing error 4173; no failing product-code change was
+  retained.
+- 2026-07-15: Also tested and fully reverted the transparent-alias and blanket
+  component-implementation alternatives. Errors 4128 and 4053 show that the
+  current language cannot express the same explicit generic read marker as a
+  zero-wrapper alias or as `QueryData` directly on `T`.
+
+## Close Notes
diff --git a/docs/issues/ISS-456.md b/docs/issues/ISS-456.md
new file mode 100644
index 000000000..9c773097f
--- /dev/null
+++ b/docs/issues/ISS-456.md
@@ -0,0 +1,269 @@
+# ISS-456: Migrate trace-proven dense query hotspots to table batches
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 0
+- Labels: ecs, performance, query, batch, visibility, transform, sprite
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+Apply the retained `ISS-449` dense table-batch API to the remaining
+performance-sensitive query call sites. A call site is eligible only after a
+native trace shows material cost and the batch traversal can preserve its exact
+query data, filter, change-detection, deferred-command, and source-owner
+semantics.
+
+## Migration Matrix
+
+| Order | Call site | Discovery trace | Current batch fit | Validation example | State |
+| ---: | --- | ---: | --- | --- | --- |
+| 0 | `visibility::reset_view_visibility_system` | `10.539-10.685 ms/frame` | Dense write plus archetypal `Without`; supported | `stress_tests/many_sprites` | Retained by ISS-449: `8.180 ms/frame` |
+| 1 | `visibility::mark_newly_hidden_entities_invisible_system` | `2.223 ms/frame` | Dense write plus archetypal `Without`; supported | `stress_tests/many_animated_sprites` | Retained: `2.290 -> 0.919 ms/frame` (`59.87%`); exact row/batch visual A/B, reference blocked by ISS-457 |
+| 2 | `camera::check_visibility_visible_entities_system` | `52.169-56.8 ms/frame` | Dense required/optional/presence columns plus archetypal `Without`; supported, but requires a source-shaped multi-column port | `stress_tests/many_foxes` | Retained: `13.856 -> 3.332 ms/frame` (`75.95%`); steady frame `54.555 -> 46.087 ms` (`15.52%`) |
+| 3 | `sprite_render::render_extract_system_ecs` sprite loop | `10.865-13.4 ms/frame` | Source-shaped dense required/optional reads; supported | `stress_tests/bevymark` | Retained: `0.119 -> 0.036 ms/frame` (`69.75%`); exact row/batch visual A/B |
+| 4 | `picking::picking_sprite2d_hit_test_system` collection path | `9.017-11.36 ms/frame` | Source-shaped dense required/optional reads; supported | `picking/sprite_picking` | Retained: aligned row `0.0257 -> 0.0209 ms/frame` (`18.90%`); exact row/batch visual A/B |
+| 5 | `sprite::sprite_calculate_bounds_2d` | `12.534-14.2 ms/frame` | Dense reads plus archetypal presence filters; changed-entity sets stay row-exact | `stress_tests/many_animated_sprite_meshes` | Retained: aligned row `8.954 -> 0.499 ms/frame` (`94.43%`); exact row/batch/reference visual A/B |
+| 6 | `transform::mark_dirty_trees_system` | `14.813-16.1 ms/frame` | Exact table-bound `Changed`/`Added`/`Or` row matcher; supported | `stress_tests/transform_hierarchy` | Retained: aligned row `3.657 -> 3.303 ms/frame` mean (`9.67%`) |
+| 7 | `transform::sync_simple_transforms` | `7.723-8.47 ms/frame` | Exact row matcher plus table-bound read/write; orphan point queries remain row-exact | `stress_tests/bevymark_3d` | Retained: aligned row `0.343 -> 0.255 ms/frame` (`25.80%`); exact row/batch visual A/B |
+| 8 | `sprite::compute_slices_on_sprite_change_system` | `2.738-2.9 ms/frame` | Exact `Changed<Sprite>` row matcher plus table-bound data; deferred commands remain per entity | `2d/sprite_slice` | Retained: aligned row `0.009566 -> 0.008887 ms/frame` (`7.10%`); visual feature gate tracked by ISS-458 |
+
+The discovery numbers come from the retained `many_sprites` traces and only
+prioritize investigation. Every row must establish a fresh before/after trace
+using its own validation example before it can be retained.
+
+## Acceptance Criteria
+
+- [x] Every matrix row has a retained, rejected, or externally blocked result.
+- [x] Every retained migration preserves the pinned Bevy query/filter and
+      change-detection semantics.
+- [x] Every retained migration runs one focused test at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+- [x] Every retained migration uses the row's distinct example for its runtime
+      gate and performs a valid visual comparison when the example renders.
+- [x] Every retained or rejected call-site experiment is committed separately.
+- [x] Unsupported per-row filters are not weakened or evaluated as table-wide
+      predicates.
+
+## Relationships
+- Depends on: ISS-449
+- Parent: ISS-444
+- Related: ISS-001, ISS-035, ISS-154, ISS-450, ISS-453, ISS-457, ISS-458
+- Discovered from: ISS-449
+
+## Notes
+
+- 2026-07-15: Created after the corrected first production migration improved
+  `reset_view_visibility_system` by `22.38-23.44%` and steady frame interval by
+  `10.97-13.42%`. The table deliberately separates directly supported dense
+  queries from tick-filtered queries that require an exact API extension.
+- 2026-07-15: `many_cubes` was rejected as the row-1 validation gate because
+  `mark_newly_hidden_entities_invisible_system` measured only `0.018 ms/frame`.
+  The distinct 102,400-entity `many_animated_sprites` gate measured
+  `2.290 ms/frame` before and `0.919 ms/frame` after the batch migration, a
+  `59.87%` system improvement. Steady frame interval improved from `251.876 ms`
+  to `248.190 ms` (`1.46%`), and the adjacent visibility system remained flat.
+- 2026-07-15: The focused semantic-transition test passed. Fresh row and batch
+  frame-90 captures were byte-identical, proving no migration-specific visual
+  change. Both diverge from the checked-in reference because of the pre-existing
+  delayed-frame regression now owned by `ISS-457`; this result is not a claim
+  that the example currently has official visual parity.
+- 2026-07-15: Retained the source-shaped multi-column batch port of
+  `check_visibility_visible_entities_system`. The inner candidate scan keeps
+  Bevy's required, optional, and presence columns; `Without<NoCpuCulling>`;
+  layer, range, AABB/sphere, and frustum decisions; two-bit ViewVisibility
+  change-detection rule; class insertion; and final sorting. Focused tests for
+  layer/class output, stable-versus-newly-visible change ticks, AABB bypass,
+  and VisibilityRange passed one at a time.
+- 2026-07-15: On the distinct `many_foxes` gate, the target system improved
+  from `13.856 ms/frame` to `3.332 ms/frame` (`75.95%`), Main from `39.066 ms`
+  to `29.715 ms` (`23.94%`), and steady frame interval from `54.555 ms` to
+  `46.087 ms` (`15.52%`). Frame-90 row and batch captures built from the exact
+  before/after revisions were byte-identical with SHA-256
+  `c5f57097581f5eea67fa2d601f7c28b4bb3bfd1283925fff0514c3c61f567f17`;
+  human review also confirmed the same fox count, spiral layout, camera, and
+  animated scene as the checked-in reference.
+- 2026-07-15: Retained the sprite portion of `render_extract_system_ecs` after
+  aligning its required query columns with pinned Bevy `extract_sprites`:
+  `Sprite`, `ViewVisibility`, `GlobalTransform`, and `Anchor`. The existing
+  mgstudio `ComputedTextureSlices`, `RenderLayers`, and `ScissorRect`
+  extensions remain optional columns, and extraction still preserves hidden
+  rejection, atlas/image modes, repeat sampling, slicing, layers, and scissor
+  data. The focused required/optional-column test passed.
+- 2026-07-15: `many_sprite_meshes` was rejected as the row-3 validation gate
+  because it does not exercise the Sprite extraction loop. On the distinct
+  1,200-sprite `bevymark` gate, the target system improved from
+  `0.119 ms/frame` to `0.036 ms/frame` (`69.75%`). Excluding the same periodic
+  trace-flush spikes from both runs, steady frame interval remained flat-to-
+  better at `9.151 -> 9.115 ms`. Frame-90 row and batch captures were
+  byte-identical with SHA-256
+  `8c4e68b35228f8c4473bc86b4ab74c71d94c141ef9478caffd1ac762c3a39afa`.
+- 2026-07-15: The row-4 source audit found that the discovery trace measured a
+  non-Bevy collection path: mgstudio scanned every `Sprite`, supplied defaults
+  for missing required components, ignored `RenderLayers` and NaN transforms,
+  used insertion sort, and constructed `HitData` with the sprite entity and ray
+  parameter instead of the camera entity and camera-space depth. The corrected
+  row-query baseline now requires `Sprite`, `GlobalTransform`, `Anchor`,
+  `Pickable`, and `ViewVisibility`, keeps `RenderLayers` optional, applies the
+  pinned Bevy visibility/NaN filters, and uses a stable radix sort by negative
+  Z. The focused collection and hit-data tests passed individually. A fixed
+  frame-90 capture of `picking/sprite_picking` remained pixel-identical to the
+  pre-correction revision with SHA-256
+  `1017161ee44134553527f00fc36db4a11c61394cee476176994dde53e5a2a0fa`.
+  This semantic correction is a prerequisite commit, not evidence for retaining
+  a batch migration; the aligned row system measures only `0.026 ms/frame` on
+  its distinct validation example.
+- 2026-07-15: Retained the row-4 batch traversal with the source-aligned query
+  data and filters unchanged. On `picking/sprite_picking`, the target system
+  improved from `0.0257` to `0.0209 ms/frame` (`18.90%`), while the 50-sample
+  steady median improved from `0.0255` to `0.0205 ms`. The absolute saving is
+  only about `0.005 ms/frame`, and the whole-frame average was effectively flat
+  at `8.351 -> 8.371 ms` (`0.24%` regression), so this is not evidence that
+  picking remains a major frame bottleneck after the source correction. The
+  focused collection test passed with the batch path, and fixed frame-90 row
+  and batch captures were pixel-identical with SHA-256
+  `1017161ee44134553527f00fc36db4a11c61394cee476176994dde53e5a2a0fa`.
+- 2026-07-18: `ISS-465` corrected an exact-transform gap left by the row-4
+  prerequisite. Although the query required `GlobalTransform`, collection had
+  immediately called `to_transform_approx()`, losing shear before inverse-ray,
+  hit-position, depth, and normal calculations. Sprite picking now retains the
+  exact affine end to end; the earlier visual equality did not exercise a
+  parent non-uniform-scale plus child-rotation transform and therefore was not
+  evidence for this semantic edge case.
+- 2026-07-18: `ISS-466` corrected another row-4 prerequisite gap: the camera
+  collection queried the 3D Projection key and fell back to Perspective even
+  though standard Camera2d installs the separate 2D Projection key. The earlier
+  fixed-frame visual equality showed only unchanged rendering and did not prove
+  pointer-hit behavior. A focused standard-Camera2d ray/intersection regression
+  now covers that semantic boundary.
+- 2026-07-15: The row-5 source audit found two correctness gaps before the
+  batch boundary: the merged mgstudio bounds system did not preserve Bevy's
+  `Without<SpriteMesh>`, `Without<Sprite>`, and `Without<Mesh2d>` disjointness
+  between new and updated AABB queries, and it replaced equal AABBs instead of
+  using Bevy's `set_if_neq` change-detection behavior. The row implementation
+  now keeps new `Sprite + Mesh2d` entities eligible for the Sprite AABB path,
+  applies the update-only disjointness after testing AABB presence, excludes
+  `SpriteMesh` from the Mesh2d path, and preserves ticks for equal bounds. Both
+  focused tests passed individually. On the 102,400-entity validation example,
+  the additional source-required presence checks changed the target system from
+  `7.056` to `8.954 ms/frame`; this regression belongs to the correctness
+  prerequisite and is not a batch result. Fixed frame-90 output was exactly
+  equal before/after and also pixel-identical to the checked-in reference; the
+  fresh captures share SHA-256
+  `8c4e68b35228f8c4473bc86b4ab74c71d94c141ef9478caffd1ac762c3a39afa`.
+- 2026-07-15: Retained the row-5 batch traversal. The three source-shaped
+  bounds scans now bind their required component columns once per table, move
+  `NoFrustumCulling`, `NoAutoAabb`, and unconditional `SpriteMesh` exclusion
+  into archetypal filters, and evaluate `Aabb`, `Sprite`, and `Mesh2d` presence
+  once per table. The existing changed-entity sets remain per-row predicates,
+  so `Changed`/asset-change semantics were not widened. On the distinct
+  `many_animated_sprite_meshes` gate, the aligned target system improved from
+  `8.954` to `0.499 ms/frame` (`94.43%`), Main from `148.535` to
+  `141.949 ms` (`4.43%`), and steady frame interval from `223.544` to
+  `220.071 ms` (`1.55%`). Relative to the pre-correction row baseline, the
+  final whole-frame interval is effectively flat (`219.732 -> 220.071 ms`).
+  Both focused bounds tests passed individually on the batch path. The fixed
+  frame-90 batch capture was pixel-identical to the aligned row capture and the
+  checked-in reference; fresh row/batch captures share SHA-256
+  `8c4e68b35228f8c4473bc86b4ab74c71d94c141ef9478caffd1ac762c3a39afa`.
+- 2026-07-15: The row-6 source audit found that mgstudio replaced Bevy's
+  explicit `StaticTransformOptimizations::Enabled | Disabled` resource with a
+  heuristic threshold that counted changed and total transforms every frame
+  and automatically disabled dirty-tree tracking. The prerequisite correction
+  restores the pinned enum, default-enabled behavior, read-only system
+  resource, and early return used by Bevy. On `transform_hierarchy`, the old
+  heuristic hid the actual work at `0.141 ms/frame`; the source-aligned row
+  path measures `3.657 ms/frame`. This cost increase belongs to correctness,
+  not to a batch experiment. Fixed frame-90 captures before and after the
+  correction are byte-identical with SHA-256
+  `ba1a15bce58204d62576583693aae50a2ccd2ea28a707b48f71539b9028b3fa6`.
+  The exact `Changed`/`Added`/`Or` batch design was still pending at this
+  prerequisite boundary.
+- 2026-07-15: Retained an exact dense row-filter batch boundary and migrated
+  row 6. `QueryFilter` can now bind table-local row matchers, with `Changed`
+  and `Added` reading their tick columns once per table and `Or`/tuple filters
+  composing those matchers. `QueryTableRows` owns the scoped matching-row
+  traversal, so callers cannot replace row predicates with table-wide guesses;
+  `QueryTableBatch` continues to own declared column access. The focused
+  `Changed | Added` semantic test and the transform ancestor-chain test passed
+  separately. On `transform_hierarchy`, two batch traces measured `3.377` and
+  `3.229 ms/frame` versus the source-aligned `3.657 ms/frame` row baseline; the
+  batch mean is `3.303 ms/frame`, a `9.67%` improvement. The aligned row and
+  batch frame-90 captures are byte-identical with SHA-256
+  `ba1a15bce58204d62576583693aae50a2ccd2ea28a707b48f71539b9028b3fa6`.
+  The remaining roughly `3.2 ms/frame` is dominated by ancestor-chain random
+  `Query::get` access and is not claimed as solved by this batch migration.
+- 2026-07-19: Follow-up ISS-472 makes the `QueryTableRows` ownership claim
+  enforceable. During filtered traversal, row-indexed batch reads, writes, and
+  change-metadata updates accept only the matching physical row currently
+  yielded by `QueryTableRows::for_each`; arbitrary in-bounds rows no longer
+  bypass `Changed`, `Added`, `Or`, or custom filters. Whole-table traversal and
+  the table-local matcher fast path are unchanged.
+- 2026-07-16: A follow-up `bevymark_3d` baseline exposed the non-dense fallback
+  case: `Parent` had no world-local column, so the row-6 `Or` filter could not
+  enter the dense batch path and `try!` converted `TableBatchUnavailable` into
+  a startup panic. The API is now explicitly
+  `try_for_each_filtered_table -> Bool`; production callers retain the exact
+  row-query path when it returns `false`. A focused missing-filter-column test
+  covers the fallback, and dense worlds continue to use the retained batch.
+- 2026-07-16: The row-7 source audit found that the changed-root query used
+  `Read<Transform>`, eagerly fetching Bevy `Ref`-shaped added/changed/caller
+  metadata even though pinned Bevy uses `&Transform` for this branch. It now
+  uses `ReadValue<Transform>` while the orphan query intentionally retains
+  `Read<Transform>` for `is_changed()`. The focused unchanged/changed
+  propagation test passed. On `bevymark_3d`, the corrected row path measures
+  `0.346 ms/frame` versus `0.351 ms/frame` before the correction; the `1.4%`
+  difference is small and is not claimed as the row-7 batch result. Fixed
+  frame-90 captures are byte-identical with SHA-256
+  `ff659545b56e9f927b232344faf954b62dc82ad285d3d7ed35ebe063e70e2994`.
+- 2026-07-16: Retained the row-7 batch traversal for changed simple
+  transforms. It binds the source-shaped `Transform` read and
+  `GlobalTransform` write once per table, evaluates the exact
+  `Changed<Transform> | Added<GlobalTransform>` matcher per row, and preserves
+  the complete row-query fallback. The separate orphan branch remains the
+  pinned Bevy-shaped point query because it reads `is_changed()` and
+  `is_added()`. The focused unchanged/changed propagation test passed on the
+  batch path. Two controlled row runs measured `0.339` and `0.347 ms/frame`,
+  while two controlled batch runs measured `0.252` and `0.257 ms/frame`;
+  their means are `0.343 -> 0.255 ms/frame`, a `25.80%` target improvement.
+  The corresponding steady-frame means were `17.002 -> 17.404 ms`, a `2.37%`
+  regression within the `ISS-444` gate. The final fixed frame-90 row and batch
+  captures are byte-identical with SHA-256
+  `ff659545b56e9f927b232344faf954b62dc82ad285d3d7ed35ebe063e70e2994`.
+- 2026-07-16: The row-8 source audit found both slice-computation queries
+  using `Read<Sprite>` even though pinned Bevy reads `&Sprite`; the
+  `Changed<Sprite>` predicate is already owned independently by the filter.
+  Both changed-sprite and asset-event scans now use `ReadValue<Sprite>`, while
+  Commands insertion, asset lookup, `uses_slices()` rejection, and deferred
+  application order remain unchanged. The focused deferred-insertion test
+  passed. A frame-90 `sprite_slice` capture had labels but no textures,
+  including the non-sliced Original and Stretched cases, so that capture is
+  recorded as an asset-readiness limitation rather than slice-query evidence;
+  the row/batch visual gate must use a later asset-ready frame.
+- 2026-07-16: Retained the row-8 changed-sprite batch traversal. It binds the
+  source-shaped `Sprite` read once per table, uses the exact
+  `Changed<Sprite>` row matcher, keeps per-entity asset lookup and deferred
+  Commands insertion unchanged, and retains the complete row-query fallback.
+  The focused deferred-insertion test passed on the batch path. Temporary
+  `StressDiagnosticsPlugin` instrumentation was added only to the distinct
+  `sprite_slice` validation build and removed before commit. The aligned row
+  trace measured `0.009566 ms/frame`; two batch traces both measured
+  `0.008887 ms/frame`, a `7.10%` improvement but only `0.000679 ms/frame` in
+  absolute time. Steady frame time was flat at `8.362 ms` for row versus an
+  `8.358 ms` mean for batch. Frame-600 row and batch captures are byte-identical
+  with SHA-256
+  `8981b5ccb1d2b478a5f88dcc815bae99b5f497f1df17c7c15f82343c43ddebd4`;
+  both remain texture-free because of the independently tracked `ISS-458`, so
+  this proves no migration-specific visual delta but is not a visual-parity
+  claim for the example.
+
+## Close Notes
+
+- 2026-07-16: Closed after every trace-proven call site in rows 0 through 8
+  received a source audit, a distinct example gate, focused semantic coverage,
+  and a retained table-batch result. The remaining `sprite_slice` texture
+  regression is isolated in `ISS-458` and is not caused by row-8 traversal.
diff --git a/docs/issues/ISS-457.md b/docs/issues/ISS-457.md
new file mode 100644
index 000000000..233f44a60
--- /dev/null
+++ b/docs/issues/ISS-457.md
@@ -0,0 +1,91 @@
+# ISS-457: Restore delayed-frame visibility in many animated sprites
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: examples, sprites, visibility, render2d, visual-parity, regression
+- Assignee: codex
+- Created: 2026-07-15
+- Updated: 2026-07-19
+- External ref: none
+
+## Description
+
+`examples/stress_tests/many_animated_sprites` stopped rendering its sprite
+field under the standard native capture path. A row-query build showed only one
+center sprite at frame 1 and only the background at frame 90, while
+`reference.png` showed the expected field of animated sprites.
+
+The symptom predates and is independent of the ISS-456
+`mark_newly_hidden_entities_invisible_system` batch migration: fresh fixed-frame
+row and batch frame-90 captures are byte-identical with SHA-256
+`8c4e68b35228f8c4473bc86b4ab74c71d94c141ef9478caffd1ac762c3a39afa`.
+
+The owning regression was the stale Camera2d frustum repaired by `e908fa6fb`.
+The stress example's sprites were spawned and animated, but the visibility
+stage evaluated them against the initial `[-1, 1]` frustum after the camera
+moved. A fresh frame-90 capture after that repair again contains the expected
+field of animated sprites.
+
+## Design
+
+Retain the Bevy-shaped camera ownership restored by `e908fa6fb`: update
+main-world Camera target information, update Camera2d frusta after transform
+propagation, and run visibility after the frustum stage. Do not disable culling
+or special-case the stress example.
+
+The example source itself still differs from the pinned Bevy baseline in scene
+randomization, sprite size, timer initialization, camera movement, window
+configuration, and system ordering. That older source-parity work is separated
+as ISS-462 rather than mixed into this visibility regression.
+
+## Acceptance Criteria
+
+- [x] A focused test or deterministic capture reproduces the transition from
+      partially visible to empty output.
+- [x] The responsible source owner and schedule boundary are identified.
+- [x] The fix preserves Bevy visibility change-detection semantics and does not
+      disable culling.
+- [x] The standard frame-90 native capture again contains the expected animated
+      sprite field by human review.
+- [x] The retained fix has focused Camera2d target-info and frustum regression
+      tests in a separate commit.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-157
+- Related: ISS-018, ISS-021, ISS-047, ISS-449, ISS-456, ISS-462
+- Discovered from: ISS-456
+
+## Notes
+
+- 2026-07-15: Reproduced with `MOONBIT_NEW_NATIVE=1` and the standard capture
+  script. Row frame 1 had one center sprite; row frame 90 and batch frame 90
+  were byte-identical empty-background images. This isolates the example
+  regression from the batch migration but prevents claiming current official
+  visual parity for the validation example.
+- 2026-07-16: Claimed after ISS-458 was verified as resolved by the Camera2d
+  frustum repair. A fresh standard frame-90 capture will determine whether the
+  same source-owner fix also closes this visibility symptom.
+- 2026-07-16: The fresh frame-90 capture renders a full field of animated
+  sprites and has an empty run log. It is not pixel-identical to the checked-in
+  reference (`AE=855001`, normalized `RMSE=0.107838`) because the current
+  example and its capture state are not source-identical to pinned Bevy; that
+  pre-existing parity gap is tracked by ISS-462.
+- 2026-07-16: Commit `e908fa6fb` owns the fix and includes focused tests for
+  Camera2d target-info updates without render-world state and logical-viewport
+  frustum bounds.
+- 2026-07-19: Follow-up ISS-473 corrected the new Camera2d frustum's
+  non-uniform-scale boundary. The original update passed full X/Y scale into
+  the shared 3D calculation even though the current 2D viewport, scene culling,
+  and renderer use absolute non-zero `scale.x` uniformly. Frustum extraction
+  now applies that same 2D transform convention, with a focused `(2, 1, 1)`
+  regression.
+
+## Close Notes
+
+Closed as fixed by `e908fa6fb fix(camera): restore Camera2d frustum updates`.
+The standard frame-90 capture once again renders the expected animated sprite
+field without disabling culling or changing the stress example. Exact example
+source parity with pinned Bevy remains open as ISS-462.
diff --git a/docs/issues/ISS-458.md b/docs/issues/ISS-458.md
new file mode 100644
index 000000000..1257b7837
--- /dev/null
+++ b/docs/issues/ISS-458.md
@@ -0,0 +1,76 @@
+# ISS-458: Restore sprite_slice texture rendering
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: examples, sprite, assets, render2d, visual-parity, regression
+- Assignee: codex
+- Created: 2026-07-16
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+The `examples/2d/sprite_slice` validation example rendered every text label but
+no sprite textures when this issue was opened. This included the Original and
+Stretched cases, which do not depend on `ComputedTextureSlices`, so the failure
+was outside the changed-sprite slice query being evaluated by `ISS-456`.
+
+Before the camera repair, native fixed-frame captures at both frame 90 and
+frame 600 were byte-identical with SHA-256
+`8981b5ccb1d2b478a5f88dcc815bae99b5f497f1df17c7c15f82343c43ddebd4`.
+The actual owner was the stale Camera2d frustum repaired by `e908fa6fb`. The
+sprite assets and extraction path were intact, but visibility rejected the
+sprite entities before rendering. A fresh capture from the repaired branch
+contains every expected texture and is pixel-identical to the checked-in
+reference.
+
+## Design
+
+Retain the Bevy-shaped camera repair from `e908fa6fb`: derive Camera2d target
+information from main-world Window/Image data, update the 2D frustum after
+camera and transform updates, and run visibility checks after that frustum
+stage. Do not add asset-readiness bypasses, sprite extraction exceptions, or a
+slice-specific visibility workaround.
+
+## Acceptance Criteria
+
+- [x] Identify the source-owner boundary that prevented the sprite entities
+      from reaching rendering.
+- [x] Restore the Original and Stretched sprites without weakening asset
+      readiness or render extraction semantics.
+- [x] Restore sliced, tiled, and constrained-corner output against pinned Bevy
+      source behavior.
+- [x] Capture an asset-ready native frame and compare it with the checked-in
+      local reference without updating the reference artifact.
+- [x] Cover the owning Camera2d target-info and frustum boundaries with focused
+      regression tests.
+
+## Relationships
+- Related: ISS-018, ISS-047, ISS-060, ISS-456
+- Discovered from: ISS-456
+
+## Notes
+
+- 2026-07-16: Discovered while establishing the distinct row-8 visual gate for
+  `compute_slices_on_sprite_change_system`. Extending the fixed capture from 90
+  to 600 frames did not change a single output byte, so the missing textures
+  are not classified as a short capture-delay problem.
+- 2026-07-16: Claimed for source-owner diagnosis after closing ISS-461. The
+  first validation target remains the standard frame-90 `sprite_slice`
+  capture; no reference refresh is permitted during diagnosis.
+- 2026-07-16: The current frame-90 native capture contains all twelve expected
+  sprite cases. ImageMagick reports `AE=0` and `RMSE=0` against
+  `examples/2d/sprite_slice/reference.png`; the PNG hashes differ only because
+  the encoded files are not byte-identical. The run log is empty.
+- 2026-07-16: Commit `e908fa6fb` is the owning repair. Its focused tests verify
+  main-world Camera2d target-info updates without `RenderState` and Camera2d
+  frustum bounds derived from the logical viewport.
+
+## Close Notes
+
+Closed as already fixed by `e908fa6fb fix(camera): restore Camera2d frustum
+updates`. The standard native frame-90 `sprite_slice` capture is pixel-identical
+to the checked-in reference, including Original, Stretched, Sliced, Tiled, and
+constrained-corner output. No sprite, asset, or reference change was required.
diff --git a/docs/issues/ISS-459.md b/docs/issues/ISS-459.md
new file mode 100644
index 000000000..91776df92
--- /dev/null
+++ b/docs/issues/ISS-459.md
@@ -0,0 +1,58 @@
+# ISS-459: Reject query cursors invalidated by World lifecycle changes
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 1
+- Labels: ecs, lifecycle, query, borrow-safety
+- Assignee: codex
+- Created: 2026-07-16
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+MoonBit query cursors can escape the lexical call that created them. Before
+this fix, a `QueryMany` cursor could retain table entities and a bound typed
+column fetch across a structural World change, and `World::close` could run
+inside an active `Query::view`. Both operations invalidate the same table and
+World assumptions that Bevy protects with the lifetime of its borrowed
+`UnsafeWorldCell`.
+
+## Design
+
+- Snapshot `World::structural_generation` when constructing `QueryMany`.
+- Validate that generation once per public `QueryMany::fetch_next` call.
+- Keep `Query::view`'s internal row loop unchanged; active query iteration
+  already rejects structural mutation there.
+- Reject `World::close` while a query view is active, just as existing spawn,
+  insert, remove, and despawn guards reject invalidating structural changes.
+- Preserve nested read-only query views through the existing counted query
+  iteration state.
+
+## Acceptance Criteria
+
+- [x] An iterator with an invalidated World lease cannot fetch another row.
+- [x] `World::close` is rejected during an active query view.
+- [x] An escaped iterator is rejected after a structural generation change.
+- [x] Nested read-only query views remain valid.
+- [x] Each lifecycle regression test passes separately with
+      `MOONBIT_NEW_NATIVE=1`.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-035
+- Related: ISS-453
+- Discovered from: ISS-453
+
+## Notes
+
+- 2026-07-16: This correctness repair was split from the rejected ISS-453
+  performance experiment. It adds no generation check to the internal
+  `Query::view` row loop.
+
+## Close Notes
+
+Closed on 2026-07-16. `QueryMany` now validates its structural snapshot at the
+public cursor boundary, `World::close` respects active query iteration, and the
+four focused lifecycle tests pass independently on native release builds.
diff --git a/docs/issues/ISS-460.md b/docs/issues/ISS-460.md
new file mode 100644
index 000000000..e8f823b75
--- /dev/null
+++ b/docs/issues/ISS-460.md
@@ -0,0 +1,71 @@
+# ISS-460: Preserve render-world cluster buffer ownership
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: render, pbr, clustered-lighting, gpu, ownership, regression
+- Assignee: codex
+- Created: 2026-07-16
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+After the camera main pass switched the renderer backend to the compact cluster
+buffers owned by `GlobalClusterableObjectMeta` and `ViewClusterBindings`, the
+older begin-pass path continued uploading its fixed-size legacy cluster data.
+From the second frame onward, wgpu therefore copied more bytes than the
+source-owned destination buffers could hold.
+
+## Design
+
+Record the ownership handoff in `GpuBackend`. Legacy cluster uploads remain
+valid until render-world buffers are installed. Once
+`use_mesh3d_cluster_buffers` installs those buffers, only their Bevy-shaped
+render-world owners may write them; `prepare_mesh3d_cluster_buffers` must no
+longer overwrite them.
+
+Do not clip writes to the destination size or resize source-owned buffers to
+fit legacy data. Either workaround would preserve the conflicting ownership
+model instead of matching Bevy's buffer ownership.
+
+## Acceptance Criteria
+
+- [x] A focused wgpu validation test reproduces the legacy overwrite of a
+      source-owned cluster buffer.
+- [x] Legacy uploads remain available before the render-world ownership
+      handoff.
+- [x] After the handoff, legacy uploads do not write the source-owned buffers.
+- [x] The focused test passes with `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/3d/despawn3` reaches frame 5 without an uncaptured wgpu
+      validation error.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-012
+- Related: ISS-393, ISS-416
+- Discovered from: ISS-454
+
+## Notes
+
+- 2026-07-16: The failing `despawn3` run reported three validation errors per
+  affected frame: 16,320 bytes copied into an 80-byte buffer, 65,536 bytes
+  copied into 644/880-byte buffers, and 131,072 bytes copied into a
+  110,592-byte buffer. These are the legacy padded cluster uploads targeting
+  compact render-world buffers.
+- 2026-07-16: The red regression test installs three 16-byte source-owned
+  buffers, attempts three 32-byte legacy uploads under a wgpu validation error
+  scope, and observes a validation error before the fix.
+- 2026-07-16: After the ownership guard, the focused test passes. A frame-5
+  `despawn3` capture with `MGSTUDIO_WGPU_UNCAPTURED_ERROR_STDERR=1` produced an
+  empty run log. Physics debug lines are still absent from that frame and are
+  therefore a separate render-path defect, not evidence that this ownership
+  fix failed.
+
+## Close Notes
+
+`GpuBackend` now records when mesh3d cluster buffers are render-world owned.
+The legacy prepare path returns without writing after that handoff, while the
+initial legacy path remains unchanged. Validation passed with the focused
+renderer wgpu test and a native `despawn3` frame-5 capture.
diff --git a/docs/issues/ISS-461.md b/docs/issues/ISS-461.md
new file mode 100644
index 000000000..9fc333d78
--- /dev/null
+++ b/docs/issues/ISS-461.md
@@ -0,0 +1,81 @@
+# ISS-461: Grow bindless material allocations across slabs
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: pbr, material, bindless, render, visual-parity, regression
+- Assignee: codex
+- Created: 2026-07-16
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+`MaterialBindGroupBindlessAllocator` stored only one fixed-capacity slab. After
+that slab filled, every later material allocation returned `None` permanently.
+In `examples/3d/despawn3`, the first 256 StandardMaterials exhausted the
+allocator before the shared physics debug materials were prepared, so their
+15,372 transparent debug meshes never entered the render phase.
+
+## Design
+
+Match the pinned Bevy allocator model: a full bindless slab must be followed by
+another slab, with `MaterialBindingId.group` identifying the slab and
+`MaterialBindingId.slot` identifying the local slot. Freed entries must retain
+those coordinates and be reusable. Bindless allocation itself cannot fail;
+only the allocator enum may reject a bindless request when it contains a
+non-bindless allocator. Construct the allocator with the material's declared
+bindless slot count; StandardMaterial therefore uses its 31-slot slab size
+instead of the unrelated default capacity.
+
+Do not raise the global cap, discard later materials, or make the renderer fall
+back to non-bindless allocation. Those alternatives would preserve the
+single-slab ownership error instead of aligning with Bevy.
+
+## Acceptance Criteria
+
+- [x] A focused regression test fails when the third allocation of a two-slot
+      allocator returns `None`.
+- [x] The third allocation of a two-slot allocator receives group 1, slot 0.
+- [x] Direct bindless allocation returns a binding rather than an optional
+      result.
+- [x] Freeing and reallocating a binding reuses its original group and slot.
+- [x] StandardMaterial allocation honors its configured bindless slot count.
+- [x] The focused tests pass with `MOONBIT_NEW_NATIVE=1`.
+- [x] `examples/3d/despawn3` renders its physics debug geometry at frame 5
+      without an uncaptured wgpu validation error.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-012
+- Related: ISS-155, ISS-394, ISS-460
+- Discovered from: ISS-454
+
+## Notes
+
+- 2026-07-16: Before the fix, frame 1 extracted and considered 1,281 visible
+  meshes but queued exactly 256. On frame 2, 15,372 new material-bearing debug
+  meshes were detected, but zero new phase items were queued.
+- 2026-07-16: The pinned Bevy implementation searches existing slabs and
+  creates a new `MaterialBindlessSlab` when all existing slabs are full. Its
+  binding ID stores the slab index as `group` and the local allocation as
+  `slot`.
+- 2026-07-16: After the fix, frame 1 queued 1,281 items and frame 2 queued all
+  15,372 new debug meshes. The frame-5 capture contains the physics debug
+  geometry and produced no uncaptured wgpu validation error.
+- 2026-07-18: Recorded the source-breaking return-type migration for direct
+  `MaterialBindGroupBindlessAllocator::allocate` callers in
+  [ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
+  Callers now use the returned `MaterialBindingId` directly instead of matching
+  or unwrapping an optional value.
+
+## Close Notes
+
+Bindless material allocation now grows across Bevy-shaped slabs and reuses
+freed global entries while preserving group/slot coordinates. StandardMaterial
+installation now passes its declared slot count into the allocator. The
+two-slot multi-slab regression test and the StandardMaterial slot-count test
+both pass in native release mode, and a native `despawn3` frame-5 capture
+restores the missing physics debug geometry. Direct-call migration is recorded
+in [ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
diff --git a/docs/issues/ISS-462.md b/docs/issues/ISS-462.md
new file mode 100644
index 000000000..7c200f796
--- /dev/null
+++ b/docs/issues/ISS-462.md
@@ -0,0 +1,95 @@
+# ISS-462: Align many_animated_sprites with pinned Bevy source
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: examples, stress-test, sprites, animation, camera, source-parity
+- Assignee: codex
+- Created: 2026-07-16
+- Updated: 2026-07-16
+- External ref: none
+
+## Description
+
+The Camera2d visibility regression in ISS-457 is fixed, but
+`examples/stress_tests/many_animated_sprites` still does not faithfully match
+the pinned Bevy example source. The mgstudio example uses deterministic index
+patterns, a 28-by-28 custom sprite size, per-entity FPS values, zero initial
+timer elapsed time, additive world-axis camera translation, and default window
+configuration. Pinned Bevy uses random depth/rotation/scale, a 64-by-64 custom
+size, one 0.1-second repeating timer with randomized elapsed time, local camera
+transform composition, and a 1920-by-1080 no-vsync window.
+
+These differences change the visual distribution, animation phase, culling
+load, and performance workload even though the sprite field now renders.
+
+## Design
+
+Port the pinned Bevy example structure without deterministic substitutions:
+
+- configure the primary window and diagnostics plugins as in Bevy;
+- use a 320-by-320 grid with 64-by-64 sprite custom sizes;
+- randomize translation depth, rotation, scale, and initial timer elapsed time
+  through the project's source-equivalent random API;
+- use one 0.1-second repeating animation period and derive atlas wrapping from
+  the layout texture count;
+- preserve Bevy's update ordering and local camera transform composition;
+- keep the example suitable for the existing stress/performance workflow.
+
+Do not tune the values to reproduce the current reference image. Validate
+behavior and workload against the pinned Bevy source, then establish a new
+human-reviewed reference only after source parity is complete.
+
+## Acceptance Criteria
+
+- [x] Scene construction fields and randomization match pinned Bevy ownership
+      and value ranges.
+- [x] Animation timer initialization and atlas advancement match pinned Bevy.
+- [x] Camera movement and update ordering match pinned Bevy.
+- [x] Window and diagnostics configuration match the fixed baseline where the
+      corresponding mgstudio APIs exist.
+- [x] A native capture shows the expected moving sprite field after delayed
+      frames, and a focused test covers deterministic structural invariants.
+- [x] Performance comparison uses the same 102,400-sprite workload as Bevy.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-001
+- Related: ISS-021, ISS-047, ISS-157, ISS-457
+- Discovered from: ISS-457
+
+## Notes
+
+- 2026-07-16: Created while closing the optimization-era visibility regression.
+  The current frame-90 output is visually healthy but differs from the local
+  reference with `AE=855001` and normalized `RMSE=0.107838`; source inspection
+  shows the example itself is not a faithful Bevy port.
+- 2026-07-16: Claimed for a source-faithful port and comparable native-release
+  performance measurement against the pinned Bevy baseline.
+- 2026-07-16: Ported the 320-by-320 randomized scene, 64-by-64 sprite size,
+  randomized animation phase, 0.1-second repeating timer, atlas-length wrapping,
+  local camera transform composition, update ordering, 1920-by-1080 no-vsync
+  window, and Bevy-owned diagnostics plugin shape.
+- 2026-07-16: The native frame-90 capture used the requested frame without a
+  retry, produced an empty run log, and shows the expected randomized sprite
+  field. The reviewed 1920-by-1080 artifact became the new local reference;
+  random scene construction intentionally prevents pixel-deterministic replay.
+- 2026-07-16: Comparable 20-second native-release runs used 102,400 sprites,
+  1920-by-1080 resolution, scale factor 1.0, and no vsync. Mgstudio's final
+  diagnostic window reported `8.0271 FPS` average (`121.4127 ms` current frame);
+  pinned Bevy reported `410.3411 FPS` average (`2.7629 ms` average frame time).
+  The `51.12x` FPS gap is a severe performance gap whose cause remains
+  unverified and is tracked by ISS-463.
+
+## Close Notes
+
+The stress example now follows the pinned Bevy source instead of deterministic
+local substitutions. Focused native-release tests cover benchmark window/timer
+configuration and rotated-local-axis camera motion. The package check passes,
+the frame-90 visual gate renders the complete randomized workload without a
+runtime error, and comparable performance evidence is recorded above.
+
+ISS-463 owns the required trace-first diagnosis of the remaining severe
+performance gap; no speculative optimization is included in this source-parity
+change.
diff --git a/docs/issues/ISS-463.md b/docs/issues/ISS-463.md
new file mode 100644
index 000000000..fd99da47f
--- /dev/null
+++ b/docs/issues/ISS-463.md
@@ -0,0 +1,798 @@
+# ISS-463: Diagnose the many_animated_sprites severe performance gap
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: performance, many_animated_sprites, ecs, sprite, render2d, cause-unverified
+- Assignee: codex
+- Created: 2026-07-16
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+After ISS-462 aligned `many_animated_sprites` with the pinned Bevy source,
+comparable native-release runs show a severe performance gap on the same
+102,400-sprite, 1920-by-1080, scale-factor-1.0, no-vsync workload.
+
+Mgstudio's final diagnostic window reported `8.0271 FPS` average and a current
+frame time of `121.4127 ms`. Pinned Bevy reported `410.3411 FPS` average and a
+`2.7629 ms` average frame time. The FPS ratio is `51.12x`.
+
+The state is `CAUSE_UNVERIFIED`. Source alignment rules out the previous
+example-shape mismatch, but the measurement does not identify whether the
+dominant gap belongs to ECS animation writes, transform/visibility work,
+render-world extraction, sprite preparation/queueing, draw submission, or
+another boundary.
+
+## Design
+
+Follow trace-first performance diagnosis:
+
+- collect reusable mgstudio schedule/system/render traces after initialization;
+- measure the animation, transform propagation, visibility, extraction,
+  preparation, queue, and render boundaries separately;
+- collect matching pinned-Bevy evidence, using a disposable measurement patch
+  only if existing diagnostics cannot expose the required boundary;
+- compare work counts as well as time so differences in culling or queued
+  sprites cannot masquerade as implementation cost;
+- promote a cause only after one boundary explains the measured gap.
+
+Do not restructure the ECS, bypass change detection, disable culling, reduce
+the workload, or add a renderer shortcut before the cause is verified.
+
+## Acceptance Criteria
+
+- [x] A repeatable native-release harness excludes initialization and samples
+      the same 102,400-sprite workload in mgstudio and pinned Bevy.
+- [x] Mgstudio evidence separates animation, transform, visibility, extraction,
+      preparation, queue, and render costs.
+- [x] Matching Bevy evidence accounts for the same boundaries and work counts.
+- [x] At least one evidence-based parity cause explains the severe gap.
+- [x] A focused optimization is validated against performance, animation,
+      culling, and visual parity gates.
+- [x] Any remaining gap greater than 4x stays explicitly cause-unverified.
+- [x] The comparable steady-state mgstudio CPU frame is no more than `5x` the
+      pinned Bevy CPU frame (`21.375 ms` against the current `4.275 ms` trace).
+- [x] Intentional source-breaking public API changes are recorded in
+      [ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-001, ISS-021, ISS-047, ISS-157, ISS-456, ISS-462
+- Discovered from: ISS-462
+
+## Notes
+
+- 2026-07-16: Created from the source-aligned comparison in ISS-462. A shell
+  `RUST_LOG=warn` setting initially hid Bevy's info-level diagnostics; the
+  valid Bevy sample explicitly used `RUST_LOG=info` and `BEVY_ASSET_ROOT`
+  pointing at the pinned checkout. A macOS stack sample confirmed that the
+  Bevy process was advancing Update, Extract, and Render schedules rather than
+  hanging.
+- 2026-07-17: Claimed for trace-first diagnosis. The first probe keeps the
+  source-aligned 102,400-sprite workload unchanged and separates mgstudio
+  schedule-stage, system, render-queue, and render-pass time after excluding
+  initialization frames.
+- 2026-07-17: Collected the first stable mgstudio stage trace with the existing
+  reusable timeline tracer. The native-release run used the source-aligned
+  102,400-sprite workload, a 40-frame trace flush interval, and excluded the
+  first 10 frame markers. Across 28 steady frames, the mean frame interval was
+  `134.470 ms` (`p50 133.971 ms`). `PostUpdate` averaged `85.181 ms` and
+  `Update` averaged `32.045 ms`. The largest leaf systems were
+  `sprite_calculate_bounds_2d` at `47.595 ms`, the example's
+  `animate_sprites` system at `31.921 ms`, `check_visibility_visible_entities`
+  at `14.880 ms`, `render3d_update_frusta` at `7.324 ms`,
+  `reset_view_visibility` at `5.978 ms`, and
+  `visibility_propagate_system` at `2.664 ms`. In contrast, the traced 2D
+  render queue, execute, and pass spans averaged `0.081 ms`, `0.288 ms`, and
+  `0.257 ms`. The trace and generated breakdown are under
+  `/tmp/mgstudio_iss463_stage_trace_20260717d/`. A discarded probe with a
+  one-frame flush interval proved that repeatedly serializing the growing JSON
+  is an observer effect, so subsequent traces must use a delayed single flush.
+  This narrows the next probe to sprite bounds, animation, and visibility but
+  does not yet promote an evidence-based parity cause.
+- 2026-07-17: Added reusable, trace-disabled-by-default subspans for sprite
+  bounds change collection, Mesh2d scanning, Sprite scanning, SpriteMesh
+  scanning, and Aabb application, plus changed-entity and pending-Aabb
+  counters. The focused native-release `sprite/bounds_wbtest.mbt` run passed
+  both tests; existing toolchain warnings remain tracked by ISS-443.
+- 2026-07-17: The sprite-bounds subtrace at
+  `/tmp/mgstudio_iss463_sprite_bounds_trace_20260717a/` sampled 28 steady
+  frames with a `117.638 ms` mean interval. `sprite_calculate_bounds_2d`
+  averaged `39.929 ms`: change collection averaged `14.032 ms`, Sprite table
+  scanning and Aabb calculation averaged `11.180 ms`, and pending-Aabb
+  application averaged `8.665 ms`. The Mesh2d and SpriteMesh scan branches
+  were each below `0.001 ms`. Every sampled frame collected exactly `102400`
+  changed Sprite-or-Anchor entities and produced `102400` pending Aabbs. These
+  three measured phases account for about 84.8 percent of the bounds system.
+  Pinned Bevy instead uses direct `Changed<Sprite>`/`Changed<Anchor>` queries
+  and mutates the Aabb column in place. This is now a source-backed candidate
+  for the bounds gap, but remains cause-unverified until matching Bevy timing
+  proves its contribution to the end-to-end gap.
+- 2026-07-17: A disposable patch on pinned Bevy `1413bc4e` measured the same
+  animation and bounds boundaries, then was fully reverted. With ordinary real
+  time, 4,000 post-warmup frames averaged `0.562 ms` in `animate_sprite` and
+  `0.106 ms` in `calculate_bounds_2d`, while timers changed an average of
+  `2939.161` sprites per frame. A second run fixed Bevy's simulated delta to
+  `117 ms`, matching mgstudio's traced workload of exactly `102400` changed
+  sprites per frame. Under that equal-workload probe, Bevy averaged `0.828 ms`
+  in animation and `0.187 ms` in bounds, versus mgstudio's `28.146 ms` and
+  `39.929 ms`: `34.00x` and `213.77x` gaps. Together these two boundaries use
+  `68.075 ms` in mgstudio versus `1.015 ms` in Bevy and account for about
+  `67.06 ms` of absolute per-frame loss. The bounds slice is now an
+  evidence-based parity cause: mgstudio materializes a changed-entity HashSet,
+  materializes a pending-Aabb array, and performs entity-keyed reads and
+  writes, while Bevy applies its changed filter in the query and mutates the
+  bound Aabb column directly with `par_iter_mut`. The animation throughput gap
+  is measured but still needs an internal mgstudio breakdown before assigning
+  its exact cause. Logs are
+  `/tmp/bevy_iss463_bounds_timing_20260717a.log` and
+  `/tmp/bevy_iss463_bounds_timing_fixed117ms_20260717a.log`. The overall issue
+  remains cause-unverified because visibility and the remaining end-to-end gap
+  have not yet received matching Bevy evidence.
+- 2026-07-17: A non-intrusive macOS `sample` run profiled the native-release
+  mgstudio process for eight seconds after setup. Of 6,060 main-thread samples,
+  790 were inside `animate_sprites`. The two
+  `QueryMany::for_each_remaining` regions covered about 755 samples. The timer
+  callback accounted for 414 samples and the Sprite-update callback for 202;
+  nearly all samples in both callbacks were below `Write::modify`. Their hot
+  children repeatedly record table-row change ticks and perform MoonBit
+  reference-count/drop work. `Timer::tick` was visible but did not dominate the
+  timer callback. Together with Bevy's equal-workload `0.828 ms` result, this
+  promotes the animation slice from an unlocalized throughput gap to an
+  evidence-based ECS cause: mgstudio pays generic row traversal plus two
+  closure-based mutable wrappers and their change-tracking/reference-counting
+  work per entity, while Bevy's source iterates query rows and writes through
+  direct `Mut` fetches. The sample is
+  `/tmp/mgstudio_iss463_many_animated_sprites.sample.txt`. This diagnosis does
+  not authorize an example-only batch rewrite; the repair must preserve the
+  Bevy query API and change-detection semantics.
+- 2026-07-17: Focused, disposable native-release microbenchmarks identified
+  four concrete mgstudio performance bugs. All probe code was removed after
+  measurement; the source worktree was clean before recording these results.
+  First, mgstudio's `Timer::tick` functionally rebuilds a reference-typed
+  `Timer`, `Stopwatch`, and multiple `Duration` objects for every entity and
+  tick. The normal repeating-timer branch took `977.77 us` for 20,000 timers,
+  while an equivalent non-boxed value-state implementation took `21.97 us`, a
+  `44.51x` difference. Pinned Bevy's `Timer::tick(&mut self)` and
+  `Stopwatch::tick(&mut self)` update inline state in place. This is the primary
+  verified cause inside the animation slice and explains the reference-count
+  and drop stacks observed by `sample`.
+- 2026-07-17: Second, `World::changed_components` scans the entire typed
+  component storage, resolves tick metadata through entity/table locations,
+  materializes an entity array, and `read()` copies that array. The Sprite
+  bounds system then inserts those entities into a HashSet and scans the Sprite
+  table again. On 20,000 changed dense components this path took `746.09 us`;
+  the existing table-bound `Changed<T>` row filter took `153.77 us`, a `4.85x`
+  difference. Pinned Bevy expresses the same work directly as
+  `Changed<Sprite>` / `Changed<Anchor>` queries. The manual materialization in
+  `sprite_calculate_bounds_2d` is therefore a verified source-parity and
+  performance bug, not a required MoonBit adaptation.
+- 2026-07-17: Third, Sprite Aabb calculation and comparison use reference-typed
+  math temporaries. Constructing and collecting the current
+  `Vec3 -> Aabb3d -> Aabb` object chain took `773.00 us` for 20,000 bounds;
+  collecting the same six scalar results in a non-boxed value took `85.82 us`,
+  a `9.01x` difference. The current equality path calls `center()` and
+  `half_size()` twice per Aabb, with each getter constructing intermediate
+  `Vec3` values; it took `945.12 us` for 20,000 equal pairs versus `54.41 us`
+  for direct stored-field comparison, a `17.37x` difference. Pinned Bevy's
+  `Aabb` is `Copy + PartialEq` and stores inline `Vec3A` values. These two probes
+  explain material portions of mgstudio's `scan_sprites` and `apply_aabbs`
+  spans.
+- 2026-07-17: Fourth, dense `Write<T>` table binding obtains a
+  `RawTableColumn` and discards it. Every `Write::modify` subsequently resolves
+  `World.tables[table_id]`, performs a `RawTable.component_indices` map lookup,
+  and then writes the changed tick. A disposable patch carrying the already
+  bound column into `Write<T>` reduced the existing 20,000-entity mutable-query
+  benchmark from an interleaved `1.54 ms` baseline to `1.44 ms`, about `6.5%`.
+  This is a verified but secondary bug. Bevy's `WriteFetch` binds direct value
+  and tick slices once per table.
+- 2026-07-17: The repair order supported by the measurements is: (1) give
+  `Duration`, `Stopwatch`, and `Timer` non-boxed value semantics while retaining
+  timer behavior; (2) port Sprite bounds to Bevy-shaped Changed/Added queries
+  and direct Aabb-column updates; (3) remove allocating Aabb comparison and
+  short-lived math-object chains using an inline value representation; (4)
+  retain the bound changed column in dense `Write<T>`. These effects overlap,
+  so their individual ratios must not be multiplied. Each repair still needs
+  its own before/after end-to-end trace and behavior gate.
+- 2026-07-17: Retained a callback-scoped dense-column update path for concrete
+  value components. `TableBatchWrite::update_inplace` passes the live table
+  rows through `TableBatchMutValues[T]`, then records one shared write tick
+  across the full column. It is available only from `Query::for_each_table`; exact
+  filtered-row batches are rejected because they do not own the full physical
+  row set. Components registered with a custom finalizer are also rejected so
+  direct array replacement cannot bypass resource destruction. Focused native
+  release tests proved value replacement plus changed-tick visibility and both
+  rejection boundaries independently.
+- 2026-07-17: `many_animated_sprites::AnimationTimer` now provides the concrete
+  `#valtype` pilot. Its source-shaped `(Write<AnimationTimer>, Write<Sprite>)`
+  query binds both dense columns once, replaces every immutable timer row
+  through `update_inplace`, and marks only Sprite rows whose atlas frame
+  actually changes. This preserves Bevy's query access and change-detection
+  semantics rather than adding an example-only unchecked storage path.
+- 2026-07-17: Three same-machine, 28-steady-frame traces separated the effects.
+  The original reference-component row path measured `29.225 ms/frame` in
+  `animate_sprites` and `123.919 ms` frame intervals. Keeping
+  `AnimationTimer` reference-typed but switching to the same table-batch path
+  measured `18.534 ms/frame` and `105.383 ms`, so batching accounts for a
+  `36.59%` animation-system improvement. Switching only the component to
+  `#valtype` then measured `17.976 ms/frame` and `103.608 ms`, an additional
+  `3.01%` system improvement and a combined `38.49%` reduction. The total
+  frame interval improved `16.39%`. Sprite bounds did not regress:
+  `42.912 ms/frame` before versus `38.371 ms/frame` in the retained variant.
+  Artifacts are under `/tmp/mgstudio_iss463_valtype_baseline_20260717c/`,
+  `/tmp/mgstudio_iss463_reference_update_inplace_20260717a/`, and
+  `/tmp/mgstudio_iss463_valtype_update_inplace_20260717a/`.
+- 2026-07-17: The final native frame-90 capture is pixel-identical to the
+  checked-in example reference (`RMSE 0`). An exact frame-96 capture differs by
+  normalized RMSE `0.163629`, confirming that camera and sprite animation still
+  advance. The captures are
+  `/tmp/mgstudio_iss463_valtype_update_inplace_final.png` and
+  `/tmp/mgstudio_iss463_valtype_update_inplace_frame96.png`. The retained
+  animation path remains `21.71x` slower than pinned Bevy's equal-workload
+  `0.828 ms`, so the remaining Timer/Stopwatch/Duration allocation chain stays
+  explicitly unresolved and no broader parity claim is made.
+- 2026-07-17: Replaced the verified boxed time chain with concrete value
+  representations. `Duration`, `Stopwatch`, `TimerMode`, and `Timer` are now
+  non-boxed value types. MoonBit rejects nested value-type fields with E4173,
+  so the exported `Stopwatch` and `Timer` representation is mechanically
+  flattened to nanosecond and Boolean fields. Their method-level timing
+  behavior remains unchanged, but the public field layout and struct-literal
+  API are source-breaking; downstream replacements are recorded in
+  [ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md). The
+  example keeps Bevy's distinct
+  `AnimationTimer` component wrapper as an ordinary object and replaces its
+  value-typed `Timer` field in place; this avoids both an invalid nested value
+  component and a per-entity wrapper allocation.
+- 2026-07-17: A retained native-release benchmark for 20,000 repeating timers
+  measured the same `Timer::tick` loop at `498.97 us` before and `21.82 us`
+  after the value-layout change, a `22.87x` improvement. Under ordinary real
+  time, the 28-steady-frame example trace measured `3.126 ms` in
+  `animate_sprites` and `70.573 ms` frame intervals, but only `17062.571`
+  sprites changed per frame, so that run is not used for the equal-workload
+  parity ratio. Its artifacts are under
+  `/tmp/mgstudio_iss463_timer_valtype_trace_20260717a/`.
+- 2026-07-17: The required fixed-`117 ms` trace forced all `102400` sprites to
+  change every frame. `animate_sprites` fell from the prior `17.976 ms` to
+  `9.803 ms`, a `45.47%` reduction, but remains `11.84x` slower than pinned
+  Bevy's equal-workload `0.828 ms`; the remaining Sprite update and change-tick
+  work therefore stays cause-unverified. Frame intervals measured `101.459
+  ms`, with sprite bounds now the dominant `43.552 ms` system. Artifacts are
+  under `/tmp/mgstudio_iss463_timer_valtype_fixed117_trace_20260717a/`. The
+  final trace-disabled frame-90 capture at
+  `/tmp/mgstudio_iss463_timer_valtype_final.png` is pixel-identical to the
+  checked-in reference (`RMSE 0`).
+- 2026-07-17: Replaced the local sprite-bounds change materialization with the
+  six new/update query paths owned by pinned Bevy's
+  `bevy_sprite::calculate_bounds_2d` and `calculate_bounds_2d_sprite_mesh`:
+  separate `Without<Aabb>` insertion queries and Changed/Or update queries for
+  Mesh2d, Sprite, and SpriteMesh.
+  Existing Aabb columns are now bound once per table and updated directly on
+  the matching physical rows. The prior world-id first-run set, three changed
+  entity HashSets, entity-keyed Aabb reads/writes, and steady-state pending
+  Aabb array are gone. Structural Aabb insertion remains deferred until all
+  query callbacks finish.
+- 2026-07-17: This slice does not claim the mesh-asset boundary complete.
+  Pinned Bevy's updated-Mesh2d query also includes `AssetChanged<Mesh2d>`;
+  mgstudio currently exposes asset event helpers but not Bevy's generic
+  asset-backed ECS query filter. Component-handle changes are covered here,
+  while in-place mesh asset changes remain an explicit parity gap.
+- 2026-07-17: The fixed-`117 ms` 28-steady-frame trace retained exactly
+  `102400` changed Sprite-or-Anchor rows and reported zero pending Aabbs.
+  Sprite bounds fell from `43.552 ms` after the timer repair to `10.760 ms`, a
+  `75.29%` reduction, while frame intervals fell from `101.459 ms` to `68.170
+  ms`, a `32.81%` reduction. `animate_sprites` remained stable at `9.832 ms`.
+  The bounds slice is still `57.54x` pinned Bevy's equal-workload `0.187 ms`,
+  so allocating Aabb/Vec3 construction and equality remain the next verified
+  target rather than being treated as resolved. Artifacts are under
+  `/tmp/mgstudio_iss463_bounds_query_fixed117_trace_20260717a/`.
+- 2026-07-17: Focused native-release tests independently covered new Sprite,
+  changed Sprite, Mesh2d, SpriteMesh, and `NoAutoAabb` behavior. The final
+  trace-disabled frame-90 capture at
+  `/tmp/mgstudio_iss463_bounds_query_final.png` is pixel-identical to the
+  checked-in reference (`RMSE 0`).
+- 2026-07-17: Replaced `camera::primitives::Aabb`'s reference-typed
+  `Aabb -> Aabb3d -> Vec3` storage with Bevy's copy-value
+  `center + half_extents` representation. MoonBit rejects nested value types,
+  so the private representation is mechanically flattened to six `Float`
+  fields while retaining `from_math`, `to_math`, `from_min_max`, `center`, and
+  `half_size` behavior. `from_min_max_xyz` is the scalar adaptation used by
+  Sprite and mesh bounds to express Bevy's allocation-free inline Vec3/Vec3A
+  construction without changing the existing vector API.
+- 2026-07-17: The retained native-release Aabb benchmark performs 20,000
+  construct, equality, and conditional-replacement operations. The same
+  vector-argument path fell from `1.39 ms` to `219.42 us`, about `6.34x`.
+  The scalar path used by Sprite bounds measured `22.71 us`, about `61.2x`
+  faster than the old object chain and `9.66x` faster than retaining two
+  temporary Vec3 arguments. This independently verifies the representation
+  bug instead of attributing the end-to-end change to trace noise.
+- 2026-07-17: The comparable fixed-`117 ms`, 28-steady-frame trace retained
+  exactly `102400` changed Sprite-or-Anchor rows and zero pending Aabbs. Sprite
+  bounds fell from `10.760 ms` to `3.788 ms`, a `64.80%` reduction, and frame
+  intervals fell from `68.170 ms` to `59.869 ms`, a `12.18%` reduction.
+  Bounds remains `20.26x` pinned Bevy's equal-workload `0.187 ms`, and the
+  animation system remains `10.52x` Bevy (`8.707 ms` versus `0.828 ms`), so
+  neither slice is marked complete. Artifacts are under
+  `/tmp/mgstudio_iss463_aabb_valtype_fixed117_trace_20260717b/`.
+- 2026-07-17: Focused native-release tests covered Mesh3d Aabb construction
+  and equal Sprite-bound updates preserving Aabb change ticks through the real
+  scheduled system. The latter replaces a stale test of the removed private
+  insertion helper. The trace-disabled frame-90 capture at
+  `/tmp/mgstudio_iss463_aabb_valtype_final.png` is pixel-identical to the
+  checked-in reference (`RMSE 0`).
+- 2026-07-17: Ported Bevy's copy-value `InheritedVisibility` and
+  `ViewVisibility` representation instead of retaining one heap object per
+  component row. Because MoonBit value types are immutable,
+  the replacement operation is exposed as `ViewVisibility::advance_frame`.
+  The old `update` name is intentionally absent so an unmigrated mutating call
+  cannot compile while discarding a replacement value; see ISS-464. Added
+  `TableBatchWrite::update_inplace_bypass_change_detection` so the reset
+  system can update the complete dense value column through one controlled
+  `TableBatchMutValues` without recording spurious component change ticks. The
+  API rejects filtered partial-table batches and custom-finalizer components
+  by the same ownership rules as `update_inplace`.
+- 2026-07-17: The retained native-release reset benchmark over `102400`
+  `ViewVisibility` rows fell from `4.71 ms` to `11.44 us`, about `411.7x`.
+  A focused ECS test proves the bulk bypass API updates values without adding
+  either entity to the changed set; two focused panic tests cover its
+  partial-table and custom-finalizer rejection boundaries. The four-state
+  visibility test proves stable visible/hidden entities remain unchanged
+  while newly visible/hidden
+  entities still receive change ticks, and the direct bit-state test covers
+  the value-returning `update` adaptation.
+- 2026-07-17: The comparable fixed-`117 ms`, 28-steady-frame trace measured
+  `reset_view_visibility` at `0.020 ms`, down from `5.445 ms` by `99.63%`.
+  Frame intervals fell from `59.869 ms` to `52.799 ms`, an `11.81%`
+  reduction. Sprite bounds remained stable at `3.755 ms`, and the workload
+  remained exactly `102400` changed Sprite-or-Anchor rows. The separate
+  `check_visibility_visible_entities` slice remained unchanged (`9.844 ms`
+  before versus `9.854 ms` after), proving that its culling/math object chain
+  is the next independent visibility cost. Artifacts are under
+  `/tmp/mgstudio_iss463_view_visibility_valtype_fixed117_trace_20260717a/`.
+- 2026-07-17: The trace-disabled frame-90 capture at
+  `/tmp/mgstudio_iss463_view_visibility_valtype_final.png` is pixel-identical
+  to the checked-in reference (`RMSE 0`).
+- 2026-07-17: Mechanically ported the inline scalar representation used by
+  Bevy's culling hot path. Pinned Bevy stores `Sphere` as a copy value with an
+  inline `Vec3A`, then evaluates transformed Aabb centers, projected radii,
+  half-space distances, and OBB radii through inline `Affine3A`/`Vec3A`
+  arithmetic. Mgstudio previously expressed the same formulas by allocating
+  reference-typed center, half-extents, transformed-vector, radius-vector,
+  `Sphere`, and half-space-normal objects inside the per-row/per-plane loops.
+  MoonBit forbids nested value types, so `Sphere` is now a flattened
+  `#valtype`; the hot path expands the exact same column-major transform, dot,
+  absolute-value, length, and early-return operations over scalar fields.
+  Compatibility vector constructors and accessors remain available outside
+  the hot path.
+- 2026-07-17: The retained native-release benchmark calls the production
+  `visibility_cull_aabb` function over a 320-by-320 transform grid. The same
+  102,400 culls fell from `4.88 ms` before scalarization to `945.64 us` after,
+  about `5.16x`. Focused native-release tests independently passed the Aabb
+  frustum inside/outside/`NoFrustumCulling` paths, the Camera2d Sphere frustum
+  path, and direct transformed-Aabb Sphere intersection/separation.
+- 2026-07-17: In the comparable fixed-`117 ms`, 28-steady-frame trace,
+  `check_visibility_visible_entities` fell from `9.854 ms` to `7.563 ms`, a
+  `23.25%` reduction, while CPU frame intervals fell from `52.799 ms` to
+  `50.069 ms`, a `5.17%` reduction. The smaller system-level gain than the
+  pure culling benchmark shows that table/query traversal, visibility-range
+  work, and `VisibleEntities`/`ViewVisibility` writes now dominate more of the
+  complete system; those costs still require source-owner tracing before any
+  further repair. Artifacts are under
+  `/tmp/mgstudio_iss463_scalar_culling_fixed117_trace_20260717a/`.
+- 2026-07-17: The trace-disabled capture metadata confirms frame 90 was used
+  without retry. `/tmp/mgstudio_iss463_scalar_culling_final.png` is
+  pixel-identical to the checked-in reference (`RMSE 0`). ISS-463 remains open:
+  this task proves a focused source-representation repair, not the requested
+  end-to-end within-5x Bevy result.
+- 2026-07-17: Restored Bevy's static default-render-layer path in CPU
+  visibility. Bevy's `Option<&RenderLayers>::unwrap_or_default` returns the
+  shared `DEFAULT_LAYERS` reference; mgstudio already exposed the equivalent
+  `default_layers` but constructed a fresh `RenderLayers` object for the view
+  default and for every entity without an explicit component. The
+  source-aligned path now reuses the shared default for both cases. A focused
+  visibility test leaves both the camera and one visible entity without a
+  `RenderLayers` component, while retaining the explicit layer-1 rejection and
+  `ViewVisibility` change-detection assertions.
+- 2026-07-17: In the same fixed-`117 ms`, 28-steady-frame trace,
+  `check_visibility_visible_entities` fell from `7.563 ms` to `7.051 ms`, a
+  `6.77%` reduction. The complete CPU frame interval remained statistically
+  unchanged (`50.069 ms` before versus `50.103 ms` after) because
+  `render3d_update_frusta` varied in the opposite direction, so this slice is
+  recorded as a local system win rather than an end-to-end claim. Artifacts
+  are under `/tmp/mgstudio_iss463_default_layers_fixed117_trace_20260717a/`.
+  The trace-disabled frame-90 capture at
+  `/tmp/mgstudio_iss463_default_layers_final.png` used the requested frame
+  without retry and is pixel-identical to the checked-in reference (`RMSE 0`).
+- 2026-07-17: Tested, then rejected, deferring `QueryTableBatch::entity` until
+  after frustum culling. A disposable native-release microbenchmark measured
+  a plain 102,400-row loop at `1.46 us` and the same loop calling
+  `batch.entity(row)` at `363.25 us`, confirming that the accessor repeatedly
+  pays lease, entity-array, and bounds validation. However, two comparable
+  fixed-workload traces with entity access moved only into VisibilityRange and
+  final visible-queue paths measured `7.555 ms` and `7.259 ms` for
+  `check_visibility_visible_entities`, both above the retained `7.051 ms`
+  baseline; frame intervals were also higher at `51.018 ms` and `50.344 ms`
+  versus `50.103 ms`. The production change and disposable benchmark were
+  fully removed. Artifacts are under
+  `/tmp/mgstudio_iss463_deferred_entity_fixed117_trace_20260717a/` and
+  `/tmp/mgstudio_iss463_deferred_entity_fixed117_trace_20260717b/`. Future work
+  should bind direct table views for the complete query fetch instead of
+  optimizing one accessor in isolation.
+- 2026-07-17: Also tested and rejected caching the view `Frustum` and
+  `NoCpuCulling` flag outside the entity loop as an isolated change. The same
+  28-steady-frame trace measured `8.058 ms` in
+  `check_visibility_visible_entities` and `53.288 ms` frame intervals, both
+  worse than the retained `7.051 ms` and `50.103 ms` baseline. The cache patch
+  was fully removed. Artifacts are under
+  `/tmp/mgstudio_iss463_cached_view_frustum_fixed117_trace_20260717a/`.
+- 2026-07-17: Added callback-scoped `TableBatchRead::with_values` for Bevy-like
+  table-bound contiguous reads. It performs the lease, live-row length, and
+  typed-column validation once, then supplies a read-only `ArrayView` valid
+  only during the callback. The API is restricted to complete
+  `Query::for_each_table` batches; a focused panic test proves that filtered
+  row batches cannot bypass their Changed/Added/Or matcher. A focused value
+  test proves the view contains exactly the live rows in table order.
+- 2026-07-17: The retained same-process native-release benchmark over 102,400
+  rows measured `598.54 us` through repeated `TableBatchRead::value` calls and
+  `69.08 us` through one bound read view, an `8.66x` improvement. CPU
+  visibility now binds the required `InheritedVisibility` and
+  `GlobalTransform` columns once per table while leaving optional columns on
+  their existing paths. In the comparable fixed-`117 ms`, 28-steady-frame
+  trace, `check_visibility_visible_entities` fell from `7.051 ms` to
+  `5.080 ms`, a `27.95%` reduction, and CPU frame intervals fell from
+  `50.103 ms` to `47.488 ms`, a `5.22%` reduction. Sprite bounds remained
+  stable at `3.766 ms`. Artifacts are under
+  `/tmp/mgstudio_iss463_read_views_fixed117_trace_20260717a/`.
+- 2026-07-17: The trace-disabled capture metadata confirms frame 90 was used
+  without retry. `/tmp/mgstudio_iss463_read_views_final.png` is pixel-identical
+  to the checked-in reference (`RMSE 0`). The paired benchmark and end-to-end
+  trace justify migrating other measured table-read hot paths independently;
+  they do not justify a repository-wide mechanical rewrite without per-system
+  evidence.
+- 2026-07-17: Tracing identified a separate camera-update parity bug in the
+  source-independent 2D workload. `render3d_update_frusta` used two
+  `World::changed_components` calls, including one over `Transform`; that API
+  scans the complete typed component storage before the system rejects entities
+  without a projection. The system therefore scanned all 102,400 animated
+  sprite transforms every frame even though the scene contained no 3D camera.
+  The pinned Bevy baseline instead expresses this ownership in the query itself
+  as `Query<(&GlobalTransform, &Projection, &mut Frustum),
+  Or<(Changed<GlobalTransform>, Changed<Projection>)>>`.
+- 2026-07-17: Replaced the storage scans, temporary entity arrays, hash set, and
+  entity-keyed component access with the corresponding filtered query and
+  table-column batch path. Mgstudio's existing frustum API still computes from
+  local `Transform`, whereas the pinned Bevy source uses `GlobalTransform`; this
+  task deliberately preserves that pre-existing semantic difference instead of
+  hiding it inside a performance patch. The focused camera-plugin test now
+  proves that changing either the transform or projection recomputes the exact
+  expected frustum. It passed with
+  `MOONBIT_NEW_NATIVE=1 moon test camera/plugin_test.mbt --target native
+  --release -f 'camera projection plugin: updates frustum when transform or
+  projection changes'`.
+- 2026-07-17: In the comparable fixed-`117 ms`, 28-steady-frame trace,
+  `render3d_update_frusta` fell from `6.034 ms` to `0.006464 ms` (about
+  `933x`), while CPU frame intervals fell from `47.488 ms` to `42.338 ms`, a
+  `10.84%` reduction. The retained trace and full breakdown are under
+  `/tmp/mgstudio_iss463_frusta_changed_query_fixed117_trace_20260717a/`; the
+  temporary timeline plugin was removed after sampling. The trace-disabled
+  capture metadata confirms frame 90 was used without retry, and
+  `/tmp/mgstudio_iss463_frusta_changed_query_final.png` is pixel-identical to
+  the checked-in reference (`RMSE 0`). ISS-463 remains open because the full
+  matching Bevy boundary trace and the terminal end-to-end ratio are not yet
+  established.
+- 2026-07-17: The next trace exposed the same query-shape bug in both legacy
+  and typed PBR material extraction. Each implementation first called
+  `changed_components(ViewVisibility)`, materialized a map of every changed
+  entity, and only then performed entity-keyed `MeshMaterial3d` lookup. In this
+  source-aligned 2D workload, two registered PBR material systems therefore
+  scanned all 102,400 sprite visibilities despite matching no material entity.
+  The pinned Bevy baseline instead requires `(Entity, &ViewVisibility,
+  &MeshMaterial3d<M>)` in a query filtered by
+  `Or<(Changed<ViewVisibility>, Changed<MeshMaterial3d<M>>)>`, so archetypes
+  without the material component never enter extraction.
+- 2026-07-17: Replaced both global scans and temporary entity maps with that
+  required-component Changed/Or query shape and table-column iteration. The
+  render-world system still uses the existing `RenderMaterialInstances`
+  source-world tick interval; a callback-scoped helper installs that interval
+  on the source world for the query and restores the previous tick context with
+  `defer`. This preserves mgstudio's current cross-world extraction boundary
+  rather than substituting the render world's unrelated system ticks. The
+  focused untyped schedule test passed extraction, removal, reinsertion, and
+  Mesh3d sweep, and the focused typed test passed population of the Bevy-shaped
+  render material tables. Both commands used native release with
+  `MOONBIT_NEW_NATIVE=1` and selected exactly one test.
+- 2026-07-17: In the comparable fixed-`117 ms`, 28-steady-frame trace, legacy
+  `extract_mesh_materials` fell from `2.774 ms` to `0.022214 ms`, typed
+  material extraction fell from `2.751 ms` to `0.015143 ms`, and the complete
+  render-extract stage fell from `5.691 ms` to `0.194 ms`. CPU frame intervals
+  fell from `42.338 ms` to `38.048 ms`, a `10.13%` reduction. Artifacts and the
+  full breakdown are under
+  `/tmp/mgstudio_iss463_material_extract_changed_query_fixed117_trace_20260717a/`;
+  the temporary timeline plugin was removed after sampling. The trace-disabled
+  capture metadata confirms frame 90 without retry, and
+  `/tmp/mgstudio_iss463_material_extract_changed_query_final.png` is
+  pixel-identical to the checked-in reference (`RMSE 0`). ISS-463 remains open
+  pending the matching full Bevy boundary trace and terminal ratio proof.
+- 2026-07-17: A fresh eight-second steady-state `sample` localized the remaining
+  animation cost after the Timer and batch-column repairs. Of 1,426 main-thread
+  samples inside `animate_sprites`, 1,312 were under the timer-column callback
+  and 871 were specifically under per-row `TableBatchWrite<Sprite>::set_changed`
+  (about `61%` of the complete system sample). That path revalidated the batch
+  row and lease, resolved the world tick and caller, and unwrapped the already
+  bound raw column for every changed sprite. The complete Timer value update
+  plus its table-wide change marking accounted for only 105 samples. The
+  retained sample is
+  `/tmp/mgstudio_iss463_animation_current_steady_20260717b.sample.txt`; an
+  earlier sample taken during shader initialization was rejected.
+- 2026-07-17: Added callback-scoped `TableBatchChangeWriter`, which binds the
+  column, tick, and optional caller ID once and records ordinary changed
+  metadata only for rows explicitly selected by the caller. It invalidates
+  itself when the callback returns, retains opt-in change-location data, and
+  does not expose unchecked value replacement or bypass change detection.
+  This matches Bevy's table-bound `Mut` metadata ownership while supporting
+  MoonBit reference-typed components whose fields are mutated in place. The
+  example keeps the same `(Write<AnimationTimer>, Write<Sprite>)` query and the
+  same `just_finished` row predicate; only the repeated metadata resolution is
+  removed. Focused tests independently passed selected-row/tick/caller behavior
+  and rejection of an escaped writer, each as one native-release test with
+  `MOONBIT_NEW_NATIVE=1`.
+- 2026-07-17: In the comparable fixed-`117 ms`, 28-steady-frame trace,
+  `animate_sprites` fell from `9.366857 ms` to `6.517000 ms`, a `30.42%`
+  reduction, and CPU frame intervals fell from `38.048 ms` to `33.969 ms`, a
+  `10.72%` reduction. Sprite bounds remained stable at `3.763 ms`. Artifacts
+  and the full breakdown are under
+  `/tmp/mgstudio_iss463_bound_change_writer_fixed117_trace_20260717a/`; the
+  temporary timeline plugin was removed after sampling. The trace-disabled
+  capture metadata confirms frame 90 without retry, and
+  `/tmp/mgstudio_iss463_bound_change_writer_final.png` is pixel-identical to
+  the checked-in reference (`RMSE 0`). The animation system remains `7.87x`
+  slower than pinned Bevy's equal-workload `0.828 ms`, so the remaining Sprite
+  access/update cost and terminal ratio remain explicitly unresolved.
+- 2026-07-17: A steady-state native `sample` and the generated ARM64 loop both
+  identified the next source-level difference inside the atlas-finished branch.
+  Pinned Bevy mutates the inline `TextureAtlas.index` value owned by each
+  `Sprite`. Mgstudio's `TextureAtlas` was a reference object containing another
+  reference-typed generic `Handle`; every finished sprite constructed a new
+  24-byte atlas object and performed repeated retain/release work for the atlas,
+  handle, and asset lookup. This cost was separate from `Timer::tick` and from
+  the already-bound selected-row change writer.
+- 2026-07-17: Converted `TextureAtlas` to a MoonBit value type by flattening the
+  layout handle to its scalar asset id, following the same representation rule
+  already used for inline Bevy `Aabb`. MoonBit value types cannot contain the
+  current generic reference-typed `Handle`, so the id remains private;
+  `layout()` still reconstructs the typed handle for compatibility and
+  `layout_asset()` resolves the stored id without constructing a handle in hot
+  paths. Internal direct `.layout` users were migrated to these methods, JSON
+  remains the same `(layout id, index)` pair, and `with_index` retains Bevy's
+  copy-update semantics rather than introducing mutable-reference aliasing.
+  This intentionally removes direct public `.layout` field access; the
+  generated interface records the compatibility change and the typed
+  `layout()` replacement.
+- 2026-07-17: The generated final animation loop packs the layout id and index
+  as scalar data. Because `Sprite.texture_atlas` remains an `Option` field, the
+  current MoonBit backend still allocates one 16-byte option payload when the
+  index changes; this task therefore removes the nested Handle reference work
+  and shrinks, but does not yet eliminate, the atlas replacement allocation.
+  A focused value-semantics test and the existing UI atlas-builder test each
+  passed independently in native release, and a full native check completed
+  with only the warnings already tracked by ISS-443.
+- 2026-07-17: In the exact final comparable fixed-`117 ms`, 28-steady-frame
+  trace, `animate_sprites` fell from `6.517 ms` to `2.902 ms`, a `55.47%`
+  reduction, and CPU frame intervals fell from `33.969 ms` to `29.655 ms`, a
+  `12.70%` reduction. The animation system is now `3.50x` pinned Bevy's
+  equal-workload `0.828 ms`, entering the requested `5x` band for this system.
+  Artifacts and the full breakdown are under
+  `/tmp/mgstudio_iss463_texture_atlas_valtype_final_fixed117_trace_20260717a/`;
+  the temporary timeline plugin was removed after sampling. The trace-disabled
+  frame-90 capture at
+  `/tmp/mgstudio_iss463_texture_atlas_valtype_final_api.png` used the requested
+  frame without retry and is pixel-identical to the checked-in reference
+  (`RMSE 0`). ISS-463 remains open because a matching full-frame Bevy CPU
+  boundary is still required before the end-to-end ratio can be claimed.
+- 2026-07-17: Collected the missing matching full-boundary trace from pinned
+  Bevy `1413bc4e3632233b8fa610a6cf14b90258556c51`. A disposable example-only
+  measurement patch set `TimeUpdateStrategy::ManualDuration(117 ms)` and sent
+  `AppExit::Success` after frame 60; it did not change the 102,400 sprites,
+  query, schedules, culling, extraction, or rendering. Bevy's own
+  `trace_chrome` spans were paired by thread, and the last 40 frames excluded
+  initialization. The example logged the expected 102,400 sprites. The patch
+  was fully reverted and the baseline worktree returned to its prior state.
+  The raw trace is
+  `/tmp/bevy_iss463_many_animated_sprites_full_fixed117_20260717b.json`.
+- 2026-07-17: The paired comparison below uses wall-clock frame or sub-app
+  intervals for aggregate boundaries and one span occurrence per frame for
+  systems; it does not sum Bevy's parallel worker spans as frame time.
+
+  | boundary | mgstudio ms/frame | pinned Bevy ms/frame | ratio |
+  | --- | ---: | ---: | ---: |
+  | CPU frame interval | 29.655 | 4.275 | 6.94x |
+  | animation | 2.902 | 0.769 | 3.77x |
+  | sprite bounds | 3.092 | 0.179 | 17.24x |
+  | CPU visibility culling | 5.177 | 0.178 | 29.03x |
+  | visibility propagation | 2.687 | 0.091 | 29.38x |
+  | sync simple transforms | 1.724 | 0.055 | 31.26x |
+  | mark dirty transform trees | 1.571 | 0.079 | 19.77x |
+  | computed sprite slices | 1.500 | 0.679 | 2.21x |
+  | sprite extraction | 0.940 | 0.236 | 3.98x |
+  | sprite queue | 0.062 | 0.012 | 5.14x |
+  | renderer system | 0.395 | 0.188 | 2.10x |
+  | render recovery / RenderApp | 2.338 | 1.699 | 1.38x |
+
+  Animation, computed slices, extraction, renderer execution, and the render
+  sub-app boundary are now inside `5x`; queue is only about `0.050 ms` slower
+  in absolute terms. The end-to-end CPU frame remains `6.94x`, so terminal
+  parity is not proven. CPU visibility culling is the largest measured
+  remaining absolute system gap (about `5.0 ms/frame`), followed by bounds,
+  visibility propagation, and transform maintenance. Their remaining internal
+  causes stay explicitly unverified until traced independently; ISS-463 remains
+  `in_progress`.
+- 2026-07-17: A steady-state macOS sample isolated `172` of `818` sampled
+  `check_visibility_visible_entities` stacks below the Aabb-radius square root.
+  The pinned Bevy path computes the same `(matrix3 * half_extents).length()` in
+  `GlobalTransform::radius_vec3a`, but mgstudio's public `math::sqrt` had been
+  implemented as `coremath.powf(value, 0.5)` even though the current MoonBit
+  toolchain provides `Float::sqrt`. Replacing the generic power operation with
+  the square-root primitive preserves the source formula and Float behavior;
+  the native-release ARM64 radius function now ends in `fsqrt` instead of
+  calling `powf`. A focused native-release test covered zero, an exact positive
+  root, and negative-input NaN behavior.
+- 2026-07-17: In the same fixed-`117 ms`, 102,400-sprite trace shape, CPU
+  visibility culling fell from `5.177 ms` to `4.828 ms`, a `6.74%` reduction.
+  The full CPU interval measured `29.949 ms` versus the prior `29.655 ms`
+  because the unmodified sprite-bounds boundary varied from `3.092 ms` to
+  `3.785 ms`; this task therefore claims only the isolated culling improvement,
+  not an end-to-end gain. Artifacts and the full 28-steady-frame breakdown are
+  under `/tmp/mgstudio_iss463_hardware_sqrt_fixed117_trace_20260717a/`. The
+  trace plugin was removed after sampling. A trace-disabled frame-90 capture at
+  the default `16,667 us` step used frame 90 without retry and
+  `/tmp/mgstudio_iss463_hardware_sqrt_final_default_time.png` is pixel-identical
+  to the checked-in reference (`RMSE 0`). Culling remains `27.12x` pinned
+  Bevy's `0.178 ms`, so its larger table/query access cost is still unresolved.
+- 2026-07-17: Bound all four optional columns used by the CPU-culling hot loop
+  (`VisibilityClass`, `RenderLayers`, `Aabb`, and `Sphere`) once per matching
+  table. This preserves `Query` access declarations, table membership checks,
+  exact optional-component semantics, and callback-scoped lifetime validation;
+  only the repeated per-row `TableBatchRead::value` entity/range validation is
+  removed. The focused visibility-class/layer/Aabb native-release test passed.
+- 2026-07-17: The next identical fixed-`117 ms` trace reduced CPU visibility
+  culling from `4.828 ms` to `4.660 ms`, a further `3.48%` reduction and a
+  cumulative `10.0%` reduction from the pre-`sqrt` `5.177 ms`. Full CPU time
+  measured `30.223 ms` versus `29.949 ms` because unmodified animation and
+  bounds spans varied between runs, so only the isolated culling result is
+  claimed. Artifacts are under
+  `/tmp/mgstudio_iss463_optional_read_views_fixed117_trace_20260717a/`; the
+  temporary trace plugin was removed. The default-time frame-90 capture
+  `/tmp/mgstudio_iss463_optional_read_views_final.png` used the requested frame
+  without retry and is pixel-identical to the reference (`RMSE 0`). Culling is
+  still `26.18x` pinned Bevy's `0.178 ms`, so further row/entity and math access
+  costs remain explicitly unresolved.
+- 2026-07-18: A fresh steady-state sample after optional-column binding showed
+  `116` of `628` CPU-culling samples below `QueryTableBatch::entity` and its
+  repeated `entity_or_abort`/lease/range validation. Added callback-scoped
+  `QueryTableBatch::with_entities`, which binds the complete live entity column
+  once for an unfiltered table batch. Like `TableBatchRead::with_values`, it
+  rejects filtered row batches so `Changed`, `Added`, and other exact row
+  matchers cannot be bypassed. Focused native-release tests independently
+  passed the complete-table entity view and the filtered-batch rejection.
+- 2026-07-18: Migrating CPU culling to the bound entity view reduced the same
+  fixed-`117 ms` full CPU interval from `30.223 ms` to `26.279 ms` (`13.05%`)
+  and culling from `4.660 ms` to `3.248 ms` (`30.30%`). This is a verified
+  end-to-end gain, not only an isolated subspan change. The comparable overall
+  ratio is now `6.15x` pinned Bevy's `4.275 ms`; the user clarified that only
+  the overall ratio must enter `5x`, not every individual system. Trace and
+  breakdown are under
+  `/tmp/mgstudio_iss463_entity_view_fixed117_trace_20260718a/`; the temporary
+  trace plugin was removed. The default-time frame-90 capture
+  `/tmp/mgstudio_iss463_entity_view_final.png` used frame 90 without retry and
+  is pixel-identical to the checked-in reference (`RMSE 0`).
+- 2026-07-18: Added `QueryTableRows::with_read_values` and
+  `with_write_values` for filtered table batches. Both require the row matcher
+  and column to have the same callback-scope object identity. They expose only
+  read-only `ArrayView`s; callers must still iterate `QueryTableRows::for_each`,
+  and all replacement writes remain on `TableBatchWrite`, preserving change
+  ticks, caller tracking, messages, and finalizers. The existing
+  `Changed | Added` exact-row test now exercises both view kinds and passed in
+  native release.
+- 2026-07-18: Migrated the traced `Changed<Sprite> | Changed<Anchor>` bounds
+  branch to bind `Sprite`, `Anchor`, and read-only `Aabb` values once per
+  filtered table. The focused equal-Aabb test independently confirmed that no
+  spurious change tick is recorded. The first full trace showed the target
+  bounds span falling from `3.543 ms` to `2.307 ms` while unrelated systems
+  simultaneously slowed; a second run of the exact same built binary removed
+  that global frequency drift and measured `25.130 ms` overall and `2.233 ms`
+  in bounds. Against the preceding `26.279 ms`/`3.543 ms`, this is a verified
+  `4.37%` full-frame and `36.97%` bounds reduction. The overall ratio is now
+  `5.88x` pinned Bevy's `4.275 ms`. Retained artifacts are under
+  `/tmp/mgstudio_iss463_filtered_row_views_fixed117_trace_20260718b/`; the
+  trace plugin was removed. The default-time frame-90 capture
+  `/tmp/mgstudio_iss463_filtered_row_views_final.png` used frame 90 without
+  retry and is pixel-identical to the checked-in reference (`RMSE 0`).
+- 2026-07-18: Rejected a complete-write-column read view for the example's
+  animation loop. Replacing `TableBatchWrite::peek` with a table-bound
+  `ArrayView<Sprite>` while retaining the same Timer bulk update and selected
+  change writer measured `3.012 ms` in animation versus the preceding
+  `2.972 ms`, and the full CPU interval did not improve. The code and generated
+  interface were fully reverted. The rejected trace is retained under
+  `/tmp/mgstudio_iss463_write_values_fixed117_trace_20260718a/`; do not repeat
+  this optimization without new evidence that the Sprite access is dominant.
+- 2026-07-18: Replaced visibility propagation's four global component scans
+  (`Changed` and `Added` for both `Visibility` and `Parent`) with the pinned
+  Bevy query shape: entities with `Visibility` and `InheritedVisibility`
+  filtered by `Changed<Visibility> | Changed<Parent>`. MoonBit's `Changed`
+  filter already includes newly inserted components, so the separate Added
+  scans were redundant. The system now also handles removed `Parent`
+  components, matching Bevy's independent `RemovedComponents<ChildOf>` path.
+  Focused native-release tests independently passed incremental child insertion
+  and restoration of inherited visibility after removing a parent.
+- 2026-07-18: In the first comparable fixed-`117 ms`, 28-steady-frame trace,
+  `visibility_propagate_system` fell from the preceding `2.480 ms` to
+  `1.007 ms` (`59.40%`) and the full CPU interval reached a new best of
+  `24.405 ms`, down from `25.130 ms` (`2.89%`). This is `5.71x` pinned Bevy's
+  `4.275 ms`, so the overall `5x` target is not yet met. A same-binary repeat
+  held the target system at `1.020 ms` but showed global frequency drift in
+  unrelated culling and render spans, producing `26.160 ms` overall. Artifacts
+  are under
+  `/tmp/mgstudio_iss463_visibility_query_fixed117_trace_20260718a/` and
+  `/tmp/mgstudio_iss463_visibility_query_fixed117_trace_20260718b/`; the
+  temporary trace plugin was removed. The default-time frame-90 capture
+  `/tmp/mgstudio_iss463_visibility_query_final.png` used frame 90 without retry
+  and is pixel-identical to the checked-in reference (`RMSE 0`).
+- 2026-07-18: A steady-state native sample localized the remaining transform
+  and Changed-query cost to dense row matchers. Although raw table metadata is
+  stored as scalar ticks with `-1` as the absent sentinel, every
+  `Changed<T>`/`Added<T>` row converted the scalar to `Tick?`, allocated a
+  `Some` payload, then immediately dropped it. `sync_simple_transforms` spent
+  392 of 393 samples in its filtered-table traversal, with the same matcher
+  allocation stacks present in dirty-tree marking, visibility propagation,
+  computed slices, and Sprite bounds. The sample is
+  `/tmp/mgstudio_iss463_transform_rows_sample.txt`.
+- 2026-07-18: Dense table matchers now test the stored scalar tick directly
+  against `SystemTicks`, retaining the same sentinel, wrapping-tick, Changed,
+  Added, Or, and fallback semantics while removing per-row Option boxing. This
+  mirrors Bevy's direct component-tick cell reads rather than adding a
+  workload-specific cache. The focused `Changed | Added` exact-row test passed
+  in native release with `MOONBIT_NEW_NATIVE=1`.
+- 2026-07-18: Two consecutive runs of the exact same fixed-`117 ms` binary
+  measured `18.894 ms` and `18.941 ms` over 28 steady frames. These are
+  respectively `4.42x` and `4.43x` pinned Bevy's `4.275 ms`, both below the
+  `21.375 ms` terminal threshold. Against the preceding best `24.405 ms`, the
+  first run is a `22.58%` complete-frame reduction. Representative system
+  reductions were `sync_simple_transforms` `1.628 -> 0.476 ms`,
+  `mark_dirty_trees_system` `1.524 -> 0.388 ms`, visibility propagation
+  `1.007 -> 0.429 ms`, computed slices `1.416 -> 0.854 ms`, Sprite bounds
+  `2.276 -> 1.662 ms`, and CPU culling `3.390 -> 2.784 ms`. Artifacts are under
+  `/tmp/mgstudio_iss463_scalar_tick_matcher_fixed117_trace_20260718a/` and
+  `/tmp/mgstudio_iss463_scalar_tick_matcher_fixed117_trace_20260718b/`; the
+  temporary trace plugin was removed. The trace-disabled capture
+  `/tmp/mgstudio_iss463_scalar_tick_matcher_final.png` used frame 90 without
+  retry and is pixel-identical to the checked-in reference (`RMSE 0`).
+- 2026-07-18: Follow-up ISS-470 replaced both table-batch update callbacks'
+  raw `MutArrayView` with revocable `TableBatchMutValues`. Escaped aliases now
+  abort on indexed access after callback exit, including after a structural
+  migration reuses the old physical row. The 102,400-row visibility reset
+  benchmark is `64.17 us`, still about `73x` faster than its `4.71 ms`
+  pre-batch baseline; the public callback-type migration is documented.
+- 2026-07-18: ISS-471 retained the revocable public wrapper but stored its raw
+  live-row view privately, reducing a same-turn `64.11 us` reset baseline to
+  `45.23 us` (`29.45%`). A storage-safe value-mapping prototype was rejected at
+  `85.00-85.35 us` because MoonBit retained one dynamic callback per row.
+- 2026-07-19: ISS-472 closed a capability hole in filtered table batches.
+  `QueryTableRows::for_each` now grants the currently matching physical row in
+  the shared batch scope, and `defer` restores the previous row after nested or
+  raising callbacks. Central row access and the bound change writer enforce
+  that grant. The repair adds no matcher re-evaluation or per-table row mask;
+  audited production writers already use only the yielded row index.
+
+## Close Notes
+
+Closed on 2026-07-18 after two repeatable equal-workload traces placed the
+complete mgstudio CPU frame at `4.42x` and `4.43x` the pinned Bevy frame, within
+the user-approved overall `5x` target. This closes the severe-gap objective,
+not a claim that every subsystem or the remaining full-frame gap has reached
+source-performance parity; the residual greater-than-`4x` ratio remains
+explicitly cause-unverified. The value-layout and related signature changes are
+source-breaking public API changes; the downstream migration is recorded in
+[ECS_PERFORMANCE_API_MIGRATION.md](../ECS_PERFORMANCE_API_MIGRATION.md).
diff --git a/docs/issues/ISS-464.md b/docs/issues/ISS-464.md
new file mode 100644
index 000000000..be4fc05de
--- /dev/null
+++ b/docs/issues/ISS-464.md
@@ -0,0 +1,73 @@
+# ISS-464: Make ViewVisibility value updates migration-safe
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: visibility, ecs, api, change-detection, migration
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+The value-type conversion changed `ViewVisibility::update` from an in-place
+`Unit` method to a method returning a replacement `ViewVisibility`. Existing
+downstream `value.update()` calls still compiled, discarded the result, and
+silently stopped advancing the previous-frame visibility bit.
+
+Earlier visibility work also removed the public value-level `set_visible`
+method and the blanket `check_visibility_system` without recording explicit
+migration paths.
+
+## Design
+
+Remove the ambiguous `update` name and expose the pure replacement operation as
+`advance_frame`, forcing old call sites to fail at compile time. Add
+`with_visible` as the explicit value-level replacement for the former mutating
+`set_visible`; ECS component writers continue to use the existing
+`SetViewVisibility` trait so change-detection semantics remain centralized.
+
+Do not restore `check_visibility_system`. The blanket scan bypassed the
+source-owned camera, layer, range, frustum, and light visibility producers and
+was removed for correctness as well as performance. Document plugin and custom
+producer migration instead.
+
+## Acceptance Criteria
+
+- [x] The public interface no longer contains `ViewVisibility::update`.
+- [x] `advance_frame` preserves the current/previous-frame bit semantics.
+- [x] `with_visible` preserves the previous bit while setting the current bit.
+- [x] All in-repository value call sites use the explicit replacement APIs.
+- [x] Migration notes cover the removed value-level `set_visible` and blanket
+      `check_visibility_system` APIs.
+- [x] One focused visibility test passes with `MOONBIT_NEW_NATIVE=1`.
+- [x] `moon info` records the intended public interface change.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-444, ISS-456
+- Discovered from: ISS-463
+
+## Notes
+
+- 2026-07-18: Created after review found that documentation alone did not
+  prevent old `value.update()` calls from compiling with silently different
+  semantics.
+
+## Close Notes
+
+Closed on 2026-07-18. `ViewVisibility::update` was replaced by the explicitly
+value-returning `advance_frame`, and `with_visible` now provides the local-value
+migration for the former mutating `set_visible`. The blanket visibility system
+remains removed and its source-owner migration is documented.
+
+The focused visibility bit-state test and the focused camera visible-entities
+test each passed independently in native release mode with
+`MOONBIT_NEW_NATIVE=1`. `moon info visibility --target native` regenerated the
+public interface with `advance_frame` and `with_visible` and without `update`.
+A temporary downstream-style compile probe confirmed that `value.update()` now
+fails with compiler error E4015, `ViewVisibility has no method update`; the
+probe was removed after verification.
diff --git a/docs/issues/ISS-465.md b/docs/issues/ISS-465.md
new file mode 100644
index 000000000..31804fdea
--- /dev/null
+++ b/docs/issues/ISS-465.md
@@ -0,0 +1,85 @@
+# ISS-465: Preserve exact affine transforms in sprite picking
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: picking, sprite, transform, bevy-parity, correctness
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+The `ISS-456` sprite-picking migration queried `GlobalTransform` as required by
+the pinned Bevy source, but immediately converted each value with
+`to_transform_approx()`. Parent non-uniform scale composed with child rotation
+can produce shear that cannot be represented as translation, rotation, and
+scale, so sprite-local ray intersection, world hit position, camera-space
+depth, and hit normal diverged from Bevy.
+
+The same path also reapplied decomposed world scale to a point that was already
+in sprite-local coordinates. Pinned Bevy instead lets
+`Sprite::compute_pixel_space_point` own the complete local-space bounds test.
+
+## Design
+
+Keep each queried sprite and camera transform as the exact `Affine3` returned
+by `GlobalTransform::affine()`. Transform the finite cursor segment through the
+exact affine inverse, matching the pinned
+`bevy_sprite::picking_backend::sprite_picking` data flow. Compute world hit
+position, camera-space depth, and the normalized transformed local Z axis from
+the same affine values.
+
+Use the pinned glam cofactor/determinant inverse formula locally. Do not route
+through TRS decomposition or the project `Affine3::inverse()` identity fallback,
+and do not add or change public API.
+
+## Acceptance Criteria
+
+- [x] Sprite collection retains `GlobalTransform::affine()` without TRS
+      decomposition.
+- [x] Sprite-local ray intersection uses the exact inverse affine and the
+      transformed near/far segment endpoints used by pinned Bevy.
+- [x] Sprite bounds are decided only by `compute_pixel_space_point`, without
+      reapplying decomposed world scale.
+- [x] World hit position, camera-space depth, and hit normal use exact affine
+      data with pinned Bevy semantics.
+- [x] A focused parent-scale plus child-rotation shear regression fails before
+      the fix and passes after it with `MOONBIT_NEW_NATIVE=1`.
+- [x] The picking package compiles after formatting and exposes no unintended
+      public API changes.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-444
+- Discovered from: ISS-456
+
+## Notes
+
+- 2026-07-18: The focused native release regression initially ran one test and
+  failed because the collected TRS approximation produced different local hit,
+  world position, and normal values from the source affine.
+- 2026-07-18: ISS-466 corrected a separate Camera2d projection-key gap in the
+  same backend. The affine-shear regression now creates its camera through the
+  standard Camera2d required-component path, so it no longer hides that gap by
+  manually installing a 3D projection.
+
+## Close Notes
+
+Closed on 2026-07-18. Sprite and camera collection now retain exact affine
+values. Cursor rays are generated from the camera affine, the finite ray segment
+is transformed through the exact sprite inverse, pixel-space bounds are owned
+solely by `Sprite::compute_pixel_space_point`, and hit position, depth, and
+normal are derived without TRS decomposition.
+
+The shear regression failed before the change and passed afterward as one
+focused native release test with `MOONBIT_NEW_NATIVE=1`. The existing focused
+camera-space-depth and collection/sort tests each passed independently.
+`MOONBIT_NEW_NATIVE=1 moon check picking --target native` completed with zero
+errors, specific-file formatting passed after applying `moon fmt`, and
+`MOONBIT_NEW_NATIVE=1 moon info picking --target native` produced no public
+interface diff. Toolchain deprecation warnings remain in unrelated packages;
+this change introduced no picking warning.
diff --git a/docs/issues/ISS-466.md b/docs/issues/ISS-466.md
new file mode 100644
index 000000000..b840b3fd9
--- /dev/null
+++ b/docs/issues/ISS-466.md
@@ -0,0 +1,80 @@
+# ISS-466: Restore standard Camera2d sprite picking
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: picking, sprite, camera2d, bevy-parity, correctness
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+The sprite-picking camera query reads mgstudio's 3D `Projection` component,
+while standard `Camera2d` required-component registration installs the separate
+2D `Projection` component. A missing 3D projection is replaced with the default
+perspective projection, and the hit-test system subsequently rejects every
+non-orthographic camera. Standard `Camera2d` sprite picking therefore produces
+no hits.
+
+Pinned Bevy has one `Projection` component type, and `Camera2d` installs its
+`OrthographicProjection::default_2d()` variant. Mgstudio's split projection
+representation must preserve that source data flow at the picking boundary.
+
+## Design
+
+Query the 2D `Projection` component required by `Camera2d`; do not fall back to
+a 3D perspective projection. Convert the implemented 2D WindowSize subset into
+the source-equivalent `OrthographicProjection3d::default_2d()` runtime value,
+copying its scale before the existing viewport update and exact-affine ray
+construction. Keep the public 2D/3D projection API split unchanged.
+
+## Acceptance Criteria
+
+- [x] A camera created through standard `Camera2d` required components is
+      collected as an orthographic sprite-picking camera.
+- [x] Sprite picking reads the 2D projection key and has no perspective
+      fallback for `Camera2d`.
+- [x] Ray length, near-plane depth, viewport scaling, and exact-affine
+      transform semantics match pinned Bevy's 2D orthographic path.
+- [x] Existing camera-marker and affine-shear regressions remain green without
+      manually installing a 3D projection on `Camera2d`.
+- [x] The picking package compiles with no unintended public API change.
+
+## Relationships
+- Depends on: none
+- Parent: none
+- Related: ISS-444, ISS-456
+- Discovered from: ISS-465
+
+## Notes
+
+- 2026-07-18: Confirmed that standard `Camera2d` installs
+  `camera/projection2d::ecs_key_projection`, while the picking backend queried
+  the root camera alias for the 3D projection key.
+- 2026-07-18: The focused standard-Camera2d regression failed before the fix
+  because the collected fallback projection was Perspective. It passed after
+  the query was corrected and additionally verified scale propagation,
+  `near=-1000`, `far=1000`, viewport-ray construction, and sprite-plane
+  intersection.
+
+## Close Notes
+
+Closed on 2026-07-18. Sprite camera collection now requires the 2D Projection
+installed by standard `Camera2d`. The implemented 2D WindowSize subset is
+bridged to `OrthographicProjection3d::default_2d()` with its scale preserved,
+so the existing viewport update and exact-affine ray path receive the same
+near/far and scaling semantics as pinned Bevy. The incorrect Perspective
+fallback is gone. Existing marker and affine-shear tests now create cameras
+through standard required components instead of installing a fake 3D
+projection.
+
+The standard-Camera2d, marker, and affine-shear tests each passed independently
+with `MOONBIT_NEW_NATIVE=1`. `moon check picking --target native` and
+`moon info picking --target native` completed with zero errors and no generated
+interface change; the 43 displayed warnings are pre-existing toolchain
+migration warnings tracked by ISS-443. The native frame-90
+`examples/picking/sprite_picking` capture completed at the requested frame and
+was pixel-identical to its checked-in reference (AE=0, RMSE=0).
diff --git a/docs/issues/ISS-467.md b/docs/issues/ISS-467.md
new file mode 100644
index 000000000..21288772d
--- /dev/null
+++ b/docs/issues/ISS-467.md
@@ -0,0 +1,75 @@
+# ISS-467: Restore component membership updates on despawn
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: ecs, despawn, archetype, change-detection, correctness
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+Despawn removes component payloads and then invalidates the entity before
+clearing its archetype tracking. Since ISS-452 made
+`entity_local_components` resolve membership through the live entity's current
+archetype, the post-despawn lookup returns an empty component list. Archetype
+and table rows are still removed from their explicitly tracked locations, but
+component membership counts and per-component generations are never updated.
+
+The stale count makes `World::component_count` and production conditions such
+as `app::any_with_component` report components that no live entity owns. The
+stale generation also violates query-cache invalidation invariants.
+
+## Design
+
+Preserve the pinned Bevy invariant that the old entity location/archetype and
+its component set remain authoritative throughout structural teardown. In the
+MoonBit transaction, clear archetype tracking and update the membership side
+indexes while the entity is still live, after observers/hooks and payload
+removal but before `Entities::despawn` invalidates the generation. Do not add a
+second component-membership index or repair counts heuristically.
+
+## Acceptance Criteria
+
+- [x] Despawning the last owner decrements `component_count` to zero.
+- [x] Despawn increments each removed component's membership generation once.
+- [x] `any_with_component` becomes false after its last matching entity is
+      despawned.
+- [x] Table/archetype swap-remove and entity ID reuse remain correct.
+- [x] Focused tests run one at a time with `MOONBIT_NEW_NATIVE=1` and the ECS
+      public interface remains unchanged.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-444
+- Related: ISS-035, ISS-459
+- Discovered from: ISS-452
+
+## Notes
+
+- 2026-07-18: Source trace confirmed that the despawn transaction captures the
+  component set while live, but `clear_entity_archetype_tracking` independently
+  recomputes it after entity invalidation.
+- 2026-07-18: Before the fix, the focused ECS regression observed
+  `(component_count=1, generation_delta=0)` after despawning the last owner,
+  and the `any_with_component` production regression ran its guarded system a
+  second time.
+
+## Close Notes
+
+Closed on 2026-07-18. `commit_component_despawn_transaction` now clears the
+entity's archetype/table tracking while the entity is still live, immediately
+before `Entities::despawn`. This lets the existing archetype-owned membership
+lookup decrement every component count and bump every component generation
+exactly once. Hook, observer, payload-removal, allocator, and public API order
+remain otherwise unchanged.
+
+The focused count/generation and `any_with_component` tests failed before the
+fix and passed afterward. Existing archetype swap-remove and entity-ID reuse
+tests also passed separately. All MoonBit commands used
+`MOONBIT_NEW_NATIVE=1`; `moon check ecs` completed with zero warnings and
+errors, `moon check app` retained only four pre-existing warning-0083 instances,
+and `moon info` produced no ECS or app interface diff.
diff --git a/docs/issues/ISS-468.md b/docs/issues/ISS-468.md
new file mode 100644
index 000000000..4300c46c4
--- /dev/null
+++ b/docs/issues/ISS-468.md
@@ -0,0 +1,81 @@
+# ISS-468: Prevent same-reference bypass replacement destruction
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: ecs, change-detection, finalizer, ownership, correctness
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+`Write::bypass_change_detection` and the row-level
+`TableBatchWrite::bypass_change_detection` obtain the stored component, pass it
+to an update closure, and route the returned value through the ordinary
+replacement setter. The setter finalizes the old component before storing the
+replacement. When a reference component is mutated in place and the closure
+returns that same reference, the live object is finalized immediately,
+reinserted, and finalized a second time when it is later removed or its World
+is closed.
+
+## Design
+
+Preserve the current public closure API and Bevy-equivalent bypass tick
+semantics. Compare the old and returned values with MoonBit's exact
+`physical_equal` operation. If they are the same object, keep the already
+stored reference and do not invoke replacement/finalization. If they are
+different, retain the ordinary setter so the displaced value is finalized
+exactly once. Apply the same rule to ordinary `Write` and table-batch row
+bypass paths; do not weaken normal replacement ownership or the bulk
+`MutArrayView` custom-finalizer guard.
+
+## Acceptance Criteria
+
+- [x] Returning the same reference from `Write::bypass_change_detection` does
+      not finalize it before World shutdown and finalizes it exactly once at
+      shutdown.
+- [x] Returning the same reference from table-batch row bypass has the same
+      lifetime behavior.
+- [x] Returning a distinct replacement continues to finalize the displaced
+      component exactly once.
+- [x] Bypass writes continue to preserve component change ticks.
+- [x] Focused tests run one at a time with `MOONBIT_NEW_NATIVE=1`, and the ECS
+      public interface remains unchanged.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-444
+- Related: ISS-018, ISS-463
+- Discovered from: ISS-449
+
+## Notes
+
+- 2026-07-18: Source trace confirmed that both row-level bypass APIs reach the
+  finalizing component setter even when their update closures return the
+  exact object already stored in the component column.
+- 2026-07-18: Both focused regressions failed before the fix with
+  `(finalized_before_close=1, finalized_values=[1, 1])` and passed afterward
+  with `(0, [1])`.
+- 2026-07-18: Pinned Bevy `1413bc4e3632233b8fa610a6cf14b90258556c51`
+  returns the stored `&mut` directly from `DetectChangesMut::bypass_change_detection`;
+  it does not perform a replacement or drop. The physical-identity guard is
+  the MoonBit adaptation required by the existing closure-return API.
+
+## Close Notes
+
+Closed on 2026-07-18. Ordinary and table-batch row bypass writes now compare
+the stored value and closure result with `physical_equal`. Returning the same
+reference leaves the live ECS value in place, while a distinct result still
+uses the existing finalizing replacement setter. No public signature changed.
+
+Focused native-release tests separately verified ordinary same-reference
+ownership, ordinary distinct replacement, table-batch same-reference
+ownership, table-batch distinct replacement, ordinary bypass ticks,
+table-batch bypass ticks, and the valtype `ViewVisibility` production path.
+Every test invocation selected one test and used `MOONBIT_NEW_NATIVE=1`.
+`moon check ecs --target native --deny-warn` completed cleanly, `moon info ecs
+--target native` produced no generated interface diff, and `git diff --check`
+passed.
diff --git a/docs/issues/ISS-469.md b/docs/issues/ISS-469.md
new file mode 100644
index 000000000..b529e85e5
--- /dev/null
+++ b/docs/issues/ISS-469.md
@@ -0,0 +1,78 @@
+# ISS-469: Retain zero-column table entity rows
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: ecs, table-batch, table, query, correctness
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+Dense query planning includes table 0 for component-free archetypes, but
+mgstudio does not create or populate `RawTable` storage when a table has zero
+component columns. `Query::for_each_table` and
+`Query::try_for_each_filtered_table` enumerate entities through
+`World::table_entities_view`, so they silently skip live `spawn_empty()`
+entities. This breaks legal dense query data such as `Entity` and `Has[T]`;
+the filtered API can return `true` to report that its batch path was available
+without visiting any of the live rows.
+
+## Design
+
+Match pinned Bevy's table ownership invariant: every table, including the
+empty table, owns an entity row vector independently of whether it owns any
+component columns. Create table 0 during World initialization and always move
+entities into a non-negative target table during archetype migration. Do not
+add table-batch-only fallback enumeration or reconstruct a table by merging
+archetype arrays.
+
+## Acceptance Criteria
+
+- [x] `Query[Entity, All]::for_each_table` visits `spawn_empty()` entities.
+- [x] `Query[Has[T], All]::for_each_table` visits both absent and present table
+      rows with correct presence values.
+- [x] `try_for_each_filtered_table` visits table-0 rows instead of reporting a
+      silent empty success.
+- [x] Empty-table rows remain correct across table migration, despawn, and
+      swap-remove.
+- [x] Focused tests run one at a time with `MOONBIT_NEW_NATIVE=1`, and the ECS
+      public interface remains unchanged.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-444
+- Related: ISS-449, ISS-452, ISS-467
+- Discovered from: ISS-449
+
+## Notes
+
+- 2026-07-18: Pinned Bevy initializes `Tables` with a real empty `Table` at
+  table ID 0. Mgstudio registers the empty table signature and archetype
+  mapping but leaves `World.tables` empty and suppresses target-row creation
+  when the target has zero component columns.
+- 2026-07-18: Before the fix, `Entity` batch traversal returned zero of two
+  empty entities, `Has[T]` returned `(None, Some(true), 1)` instead of the
+  absent row plus present row, and filtered traversal returned
+  `(used_batch=true, seen=false, count=0)`.
+
+## Close Notes
+
+Closed on 2026-07-18. `World::new` now materializes table 0, and archetype
+migration appends an entity row for every non-negative target table regardless
+of component-column count. Empty entities therefore have canonical table-0
+locations and use the same append, migration, swap-remove, and despawn paths as
+all other table entities. The table-batch loops and query-cache semantics were
+not special-cased.
+
+Five focused table-batch regressions separately verified `Entity`, `Has[T]`,
+filtered traversal, component-table round trips, and empty-table despawn. Four
+existing structural regressions verified typed-row migration, table-column
+lengths, entity ID reuse, and ordinary dense batch writes; the component
+membership despawn regression also remained green. Every test invocation
+selected one test and used `MOONBIT_NEW_NATIVE=1`. `moon check ecs --target
+native --deny-warn` completed cleanly, `moon info ecs --target native` produced
+no generated interface diff, and `git diff --check` passed.
diff --git a/docs/issues/ISS-470.md b/docs/issues/ISS-470.md
new file mode 100644
index 000000000..8f2324a32
--- /dev/null
+++ b/docs/issues/ISS-470.md
@@ -0,0 +1,84 @@
+# ISS-470: Revoke escaped table-batch mutable views
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: ecs, table-batch, mutarrayview, lease, change-detection, correctness
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+`TableBatchWrite::update_inplace` and
+`update_inplace_bypass_change_detection` pass a raw `MutArrayView[T]` to user
+code. The view is copyable and retains the typed component column's backing
+array. Invalidating `QueryTableBatch`, its `WorldLease`, or its column binding
+cannot revoke an escaped view. It can therefore replace component values after
+the update callback without the required lease, change ticks, callers, or
+finalizers. After structural migration reuses a physical row, the stale view
+can modify a different entity.
+
+## Design
+
+Replace the public raw mutable view callback parameter with a controlled
+`TableBatchMutValues[T]`. Preserve the existing `values.length()` and
+`values[index]` source shape through checked methods and custom `op_get` /
+`op_set`. All aliases share one mutable active state, which is invalidated as
+soon as the update callback returns; every indexed operation checks that state.
+Never expose the backing array or a raw `MutArrayView`.
+
+This intentionally changes a public callback parameter type. Record the
+migration and regenerate the ECS interface. Existing inferred callbacks keep
+the same indexing syntax; explicit `MutArrayView[T]` annotations must change
+to `TableBatchMutValues[T]`.
+
+## Acceptance Criteria
+
+- [x] A mutable column capability retained past the update callback aborts on
+      both read and write, even while the outer table callback remains active.
+- [x] A retained capability cannot modify a different entity after structural
+      migration reuses its old physical row.
+- [x] In-scope indexed replacement and both ordinary/bypass tick semantics
+      remain correct.
+- [x] Custom-finalizer and filtered-batch rejection boundaries remain intact.
+- [x] The public interface and migration document record the controlled-view
+      callback type.
+- [x] Focused tests run one at a time with `MOONBIT_NEW_NATIVE=1`.
+
+## Relationships
+- Depends on: none
+- Parent: ISS-444
+- Related: ISS-449, ISS-459, ISS-463
+- Discovered from: ISS-463
+
+## Notes
+
+- 2026-07-18: MoonBit supports custom indexed access through `op_get` and
+  `op_set`, so a revocable wrapper can retain the current indexing syntax
+  without exposing the backing array.
+- 2026-07-18: Before the repair, focused reproductions proved that an escaped
+  raw view could replace a component immediately after its update callback and
+  could overwrite a replacement entity after its original row was reused.
+- 2026-07-18: The retained active check increases the 102,400-row visibility
+  reset benchmark from the prior recorded `11.44 us` to `64.17 us` on the
+  current machine. It remains about 73 times faster than the pre-batch
+  `4.71 ms` result; this explicit cost is accepted for revocable write access.
+- 2026-07-18: Follow-up ISS-471 retained the same public revocation boundary
+  while moving the live-row `MutArrayView` behind the wrapper's private field.
+  Removing the redundant manual-plus-array bounds checks reduced the benchmark
+  from a same-turn `64.11 us` baseline to `45.23 us`.
+
+## Close Notes
+
+Closed on 2026-07-18. Both mutable table-batch update APIs now expose
+`TableBatchMutValues[T]`, whose shared active state is invalidated with `defer`
+as the callback exits. Four focused panic regressions cover escaped ordinary
+write, escaped read, reused-row write, and the bypass API. Existing focused
+tests separately retain ordinary and bypass change-tick behavior plus the
+filtered-batch and custom-finalizer rejection boundaries. `moon check ecs
+--target native --deny-warn` passes, the generated ECS interface records the
+new callback type, and the public migration document explains the explicit
+annotation change.
diff --git a/docs/issues/ISS-471.md b/docs/issues/ISS-471.md
new file mode 100644
index 000000000..8498167ed
--- /dev/null
+++ b/docs/issues/ISS-471.md
@@ -0,0 +1,86 @@
+# ISS-471: Optimize revocable table-batch value access
+
+## Metadata
+- Type: task
+- Status: closed
+- Priority: 1
+- Labels: ecs, table-batch, mutarrayview, performance, safety
+- Assignee: codex
+- Created: 2026-07-18
+- Updated: 2026-07-18
+- External ref: none
+
+## Description
+
+ISS-470 made callback-scoped table-batch mutation revocable, but the initial
+wrapper stored the complete backing `Array[T]`, then performed a manual
+live-row bounds check before the array performed its own bounds check. The
+102,400-row `ViewVisibility` reset benchmark increased from the previously
+recorded `11.44 us` raw-view result to a current `64.11 us`. Preserve revocation
+and live-row bounds while removing redundant work from the hot indexed path.
+
+## Design
+
+Store a live-row-bounded `MutArrayView[T]` as a private field inside
+`TableBatchMutValues[T]`. Keep the shared active state and check it before every
+public indexed operation, but delegate bounds enforcement to the private view
+instead of repeating it against the backing array. The raw view must never be
+returned or passed to user code.
+
+An engine-driven value-mapping callback was prototyped first because it exposed
+no storage capability. It was slower due to one dynamic callback per row, so it
+must not be retained or used as the default performance path.
+
+## Acceptance Criteria
+
+- [x] `TableBatchMutValues` exposes no raw view or backing array while escaped
+      capabilities still abort after callback exit.
+- [x] Indexed access remains bounded to the current live table rows.
+- [x] Ordinary and bypass replacement/change-tick semantics remain unchanged.
+- [x] A same-machine native-release benchmark compares the retained path with the
+      `64.11 us` controlled-view baseline.
+- [x] The slower engine-driven mapping prototype is removed and its rejected
+      performance result is recorded.
+- [x] The generated public interface remains unchanged and implementation
+      documentation records the private bounded-view representation.
+- [x] Focused MoonBit tests and benchmarks run one at a time with
+      `MOONBIT_NEW_NATIVE=1`.
+
+## Relationships
+- Depends on: ISS-470
+- Parent: ISS-444
+- Related: ISS-459, ISS-463
+- Discovered from: ISS-470
+
+## Notes
+
+- 2026-07-18: Current same-machine native-release baseline is `64.11 us` for
+  102,400 `ViewVisibility` rows (`50 x 1508` runs).
+- 2026-07-18: `ViewVisibility` is an immutable `#valtype` and is eligible for
+  replacement mapping. The current many_animated_sprites `AnimationTimer` is
+  a mutable reference struct, despite containing a valtype `Timer`, so it was
+  not treated as the same confirmed representation case.
+- 2026-07-18: The engine-driven mapping prototype measured `85.00 us`; adding
+  `#inline` measured `85.35 us`. Both are slower than the `64.11 us` controlled
+  view because the value callback remains dynamic for every row. The complete
+  prototype and its tests were removed.
+- 2026-07-18: Inline hints on the controlled view and caching `length()` at the
+  visibility call site remained within the `63.4-64.5 us` noise band and were
+  removed.
+- 2026-07-18: Keeping the live-row `MutArrayView` private inside the revocable
+  wrapper measured `45.76 us`, then `45.23 us` without ineffective inline
+  hints. This is `29.45%` below the same-turn `64.11 us` safe baseline and about
+  `104x` faster than the pre-batch `4.71 ms` result.
+
+## Close Notes
+
+Closed on 2026-07-18. `TableBatchMutValues` now holds a private
+live-row-bounded `MutArrayView` instead of a complete backing `Array` plus a
+second manual bound. Public access remains limited to active-checked
+`length`/index operations, so no raw capability becomes escapable. Focused
+native-release tests independently passed escaped write, escaped read,
+reused-row write, bypass escape, live-row bounds, ordinary replacement ticks,
+and bypass tick preservation. `moon check ecs --target native --deny-warn`
+passes, and `moon info ecs --target native` confirms no public interface
+change. The retained benchmark is `45.23 us` for 102,400 rows; the slower
+`85.00-85.35 us` mapping prototype was fully removed.
diff --git a/docs/issues/ISS-472.md b/docs/issues/ISS-472.md
new file mode 100644
index 000000000..2a213f964
--- /dev/null
+++ b/docs/issues/ISS-472.md
@@ -0,0 +1,88 @@
+# ISS-472: Restrict filtered table batches to matching rows
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: ecs, table-batch, query-filter, changed, added, capability, correctness
+- Assignee: codex
+- Created: 2026-07-19
+- Updated: 2026-07-19
+- External ref: none
+
+## Description
+
+`Query::try_for_each_filtered_table` evaluates its exact `Changed`, `Added`,
+`Or`, or custom row matcher only inside `QueryTableRows::for_each`. The
+accompanying `QueryTableBatch` still binds the complete physical table, and
+row-level `TableBatchWrite` methods validate only the physical row bounds.
+User code can therefore call `set`, `modify`, bypass replacement, or change
+metadata methods with a row that does not satisfy the filter and mutate an
+entity the query did not yield.
+
+## Design
+
+Make `QueryTableRows::for_each` the row-capability boundary for filtered table
+batches. While it invokes the callback for one matching physical row, record
+that row as authorized in the shared `QueryTableBatchScope`; restore the prior
+authorization with `defer` so raising and nested traversal remain correct.
+Every row-level entity/component access must validate the authorization through
+the shared scope. `TableBatchChangeWriter` must retain the same scope rather
+than validating only physical bounds.
+
+Whole-table batches keep their existing direct physical-row path with no
+matcher evaluation. Do not rerun the filter matcher inside every component
+access and do not allocate a per-table row mask.
+
+## Acceptance Criteria
+
+- [x] A filtered batch cannot write or mark a physical row that is not the
+      currently yielded matching row.
+- [x] The currently yielded matching row remains readable and writable through
+      all ordinary row-level APIs.
+- [x] Authorization is restored after nested traversal and after a callback
+      raises.
+- [x] Whole-table batches retain unrestricted live-row access.
+- [x] Existing production filtered-table call sites require no migration.
+- [x] Focused tests run one at a time with `MOONBIT_NEW_NATIVE=1`.
+- [x] The generated public interface remains unchanged.
+
+## Relationships
+- Depends on: ISS-456
+- Parent: ISS-444
+- Related: ISS-459, ISS-463, ISS-469, ISS-470
+- Discovered from: ISS-456
+
+## Notes
+
+- 2026-07-19: Current production filtered-table writers in sprite, transform,
+  visibility, and PBR already mutate only the physical row passed by
+  `QueryTableRows::for_each`.
+- 2026-07-19: Before the repair, the focused reproduction started with one
+  `Changed<TableBatchPosition>` row, wrote the other in-bounds physical row,
+  and observed `2` visits instead of `1`: the unauthorized write changed the
+  filter result while the same traversal was still running.
+- 2026-07-19: The retained implementation grants only the currently yielded
+  row in the shared scope and restores the prior grant with `defer`. All
+  row-indexed table access reaches the central scope check; the separately
+  bound `TableBatchChangeWriter` now retains and validates the same scope.
+- 2026-07-19: This is a behavioral correction without a public signature
+  change. The previously out-of-contract arbitrary-row use now aborts, and the
+  supported migration is recorded in `docs/ECS_PERFORMANCE_API_MIGRATION.md`.
+- 2026-07-19: A same-machine native-release whole-table accessor benchmark
+  measured the pre-repair HEAD at `564.76 us` and `554.92 us` across two runs.
+  The repaired branch's stable repeat measured `557.68 us`; its first run was
+  discarded as noisy because `186.54 us` standard deviation and a `1.20 ms`
+  maximum made the mean non-comparable. The bound read-view control measured
+  `62.74 us` before and `61.94 us` after. The predictable whole-table
+  short-circuit adds no measurable regression.
+
+## Close Notes
+
+Closed on 2026-07-19. Focused native-release tests independently cover
+unmatched write rejection, matching-row mutation, change-writer rejection,
+nested and raising callback restoration, unrestricted whole-table mutation,
+and the production Sprite bounds filtered writer. The implementation does not
+rerun the row matcher for component access and does not allocate a row mask.
+`moon check ecs --target native --deny-warn` passes, and `moon info ecs
+--target native` confirms that the generated public interface is unchanged.
diff --git a/docs/issues/ISS-473.md b/docs/issues/ISS-473.md
new file mode 100644
index 000000000..5a94fdb65
--- /dev/null
+++ b/docs/issues/ISS-473.md
@@ -0,0 +1,97 @@
+# ISS-473: Align Camera2d frustum with uniform render scale
+
+## Metadata
+- Type: bug
+- Status: closed
+- Priority: 0
+- Labels: camera, camera2d, frustum, visibility, render2d, transform, parity
+- Assignee: codex
+- Created: 2026-07-19
+- Updated: 2026-07-19
+- External ref: none
+
+## Description
+
+`update_frusta_2d_system` forwards the complete non-uniform X/Y scale from
+`GlobalTransform` to the shared 3D orthographic frustum computation. The
+current Camera2d viewport conversion, scene culling, and native renderer use
+`camera_transform.scale.x` as one uniform camera scale. With camera scale
+`(2, 1, 1)`, the rendered vertical extent is therefore twice the frustum's
+vertical extent, and visibility can reject an object that the renderer would
+place inside the viewport.
+
+Pinned Bevy derives rendering and frustum planes from the same camera affine.
+Mgstudio must likewise feed its current 2D frustum the exact transform semantics
+used by its 2D renderer; it must not mix the renderer's uniform-X convention
+with the shared 3D non-uniform convention.
+
+## Design
+
+At the Camera2d frustum boundary, derive the renderer-authoritative uniform
+scale from the approximated global transform: use the absolute non-zero X axis
+for both X and Y, matching the existing Camera2d viewport and renderer helpers.
+Keep translation, rotation, Z scale, logical viewport, orthographic projection,
+and the shared frustum algorithm unchanged. Do not alter Camera3d frustum
+semantics or add a culling tolerance.
+
+## Acceptance Criteria
+
+- [x] A focused test proves that a point inside the Camera2d rendered viewport
+      under `(2, 1, 1)` is also inside its frustum.
+- [x] A point beyond the same uniform-X vertical extent remains outside.
+- [x] Unit and uniform camera scales retain their existing behavior.
+- [x] Camera3d frustum computation remains unchanged.
+- [x] Focused tests run one at a time with `MOONBIT_NEW_NATIVE=1`.
+- [x] The generated public interface remains unchanged.
+
+## Relationships
+- Depends on: ISS-457
+- Parent: ISS-025
+- Related: ISS-018, ISS-456, ISS-458, ISS-465
+- Discovered from: ISS-457
+
+## Notes
+
+- 2026-07-19: Pinned Bevy owner
+  `bevy/crates/bevy_camera/src/projection.rs::CameraProjection::compute_frustum`
+  computes its frustum from the same camera affine used by rendering. The local
+  mismatch is between mgstudio implementation fragments, not an external
+  blocker.
+- 2026-07-19: Source-owner classification remains `partial`. The relevant
+  implementation fragments are `camera/lib.mbt`, `camera/camera/top.mbt`,
+  `sprite_render/render/runtime.mbt`, and the scalar-camera-scale renderer
+  path. ISS-473 makes those fragments internally consistent; ISS-025 still
+  tracks replacing the uniform-X/split-projection path with Bevy's fully
+  computed camera affine semantics.
+- 2026-07-19: The pre-fix focused test proved the exact split: for a 100 by 100
+  logical viewport and camera scale `(2, 1, 1)`,
+  `Camera::world_to_viewport_2d` accepted world position `(0, 75)`, while the
+  generated frustum rejected a sphere at the same position (`expected true`,
+  `actual false`).
+- 2026-07-19: The retained adapter changes only the Camera2d transform passed
+  into the shared frustum computation. It preserves translation, rotation, and
+  Z scale while applying the renderer's absolute non-zero X scale to both view
+  axes. Camera3d continues to use its original projection/transform path.
+- 2026-07-19: The representative
+  `examples/2d/2d_viewport_to_world` frame-90 capture completed at
+  `/tmp/mgstudio_iss473_2d_viewport_to_world.png`; human review found the
+  Camera2d viewport, UI text, and green scene rectangle rendered normally. It
+  is not pixel-identical to the older checked-in reference (`AE=1932270`): the
+  current dynamic viewport has a different position/extent and the old image
+  clips the text. This pre-existing owner/reference drift remains with the
+  already-open ISS-025 and is not claimed as exact visual parity here.
+- 2026-07-19: `moon check camera --target native` and `moon info camera
+  --target native` pass with the repository's existing warning 83 diagnostics,
+  and the generated interface is unchanged. `--deny-warn` is still blocked by
+  the previously deferred warnings in `app/message_support.mbt` and
+  `app/query_params.mbt`; those unrelated warnings were not mixed into this
+  fix.
+
+## Close Notes
+
+Closed on 2026-07-19. Camera2d frustum extraction now uses the same uniform-X
+camera scale as viewport conversion, CPU scene culling, and native 2D drawing.
+The focused non-uniform regression, the existing logical-viewport Camera2d
+frustum test, and the existing Camera3d transform/projection frustum test each
+pass independently in native release mode. No public API or Camera3d source
+path changed.
diff --git a/docs/issues/README.md b/docs/issues/README.md
index ed1c843ca..30fc26d65 100644
--- a/docs/issues/README.md
+++ b/docs/issues/README.md
@@ -13,7 +13,9 @@ Generated by derive-tracker.wasm
 | [ISS-157](ISS-157.md) | 0 | bug | unassigned | Triage 2026-06-24 all-reference visual audit regressions | examples, screenshots, visual-parity, render, pbr, text, camera |
 | [ISS-089](ISS-089.md) | 1 | bug | unassigned | Port pcss widget controls and shadow source parity | examples, pbr, pcss, shadows, widgets, taa, source-parity |
 | [ISS-129](ISS-129.md) | 1 | bug | unassigned | Restore shadow_biases source parity | examples, pbr, shadows, lighting, ui, source-parity, visual-parity |
+| [ISS-443](ISS-443.md) | 1 | task | unassigned | Clear new-toolchain type-parameter method warnings | warnings, moonbit, toolchain, migration |
 | [ISS-047](ISS-047.md) | 2 | epic | unassigned | Triage failed example screenshot captures | examples, screenshots, visual-parity, capture, triage |
+| [ISS-441](ISS-441.md) | 2 | bug | unassigned | Make many_foxes profiling survive long native compilation | performance, many_foxes, diagnostics, tooling, native |
 
 ## Unresolved Issues
 
@@ -38,14 +40,14 @@ Generated by derive-tracker.wasm
 | [ISS-001](ISS-001.md) | open | 0 | epic | unassigned | none | none | Recover the many_foxes CPU frame budget |
 | [ISS-004](ISS-004.md) | blocked | 0 | task | unassigned | ISS-043 | ISS-011 | Reduce animation target write amplification |
 | [ISS-012](ISS-012.md) | open | 0 | epic | unassigned | none | none | Bring render, PBR, mesh, and light to Bevy source-level parity |
-| [ISS-019](ISS-019.md) | open | 0 | task | unassigned | ISS-018, ISS-405 | ISS-021, ISS-034, ISS-123, ISS-126, ISS-403 | Wire PBR prepass, deferred, shadow, main, and transmission phases to real runtime commands |
+| [ISS-019](ISS-019.md) | open | 0 | task | unassigned | ISS-018 | ISS-021, ISS-034, ISS-123, ISS-126, ISS-403 | Wire PBR prepass, deferred, shadow, main, and transmission phases to real runtime commands |
 | [ISS-020](ISS-020.md) | blocked | 0 | task | unassigned | none | none | Unblock exact Bevy meshlet visibility-buffer runtime under native WebGPU limits |
 | [ISS-022](ISS-022.md) | open | 0 | epic | unassigned | none | none | Restore Bevy source-owner boundaries for non-faithful ports |
 | [ISS-034](ISS-034.md) | open | 0 | task | unassigned | ISS-014, ISS-018, ISS-019 | none | Rehome motion blur pipeline ownership from renderer-local lazy state |
 | [ISS-035](ISS-035.md) | open | 0 | epic | unassigned | none | none | Harden ECS APIs for Bevy source-level migration |
 | [ISS-044](ISS-044.md) | blocked | 0 | task | unassigned | ISS-070 | ISS-046 | Audit and complete Bevy dim2 primitive source parity |
 | [ISS-157](ISS-157.md) | open | 0 | bug | unassigned | none | none | Triage 2026-06-24 all-reference visual audit regressions |
-| [ISS-405](ISS-405.md) | blocked | 0 | bug | unassigned | none | ISS-019, ISS-122 | Unblock fully qualified WGSL module function calls |
+| [ISS-455](ISS-455.md) | blocked | 0 | task | unassigned | none | none | Unblock generic value-type query row wrappers |
 | [ISS-015](ISS-015.md) | open | 1 | task | unassigned | ISS-014 | ISS-021, ISS-033, ISS-123 | Rehome renderer pass ownership under Bevy-shaped graph phases |
 | [ISS-021](ISS-021.md) | open | 1 | task | unassigned | ISS-015, ISS-019 | none | Establish render and PBR visual parity gates |
 | [ISS-032](ISS-032.md) | blocked | 1 | task | unassigned | ISS-068, ISS-069 | none | Complete ci_testing plugin source parity |
@@ -63,12 +65,11 @@ Generated by derive-tracker.wasm
 | [ISS-108](ISS-108.md) | blocked | 1 | bug | unassigned | ISS-104 | none | Restore volumetric_fog example source parity |
 | [ISS-109](ISS-109.md) | blocked | 1 | bug | unassigned | ISS-104 | none | Restore fog_volumes source parity |
 | [ISS-114](ISS-114.md) | blocked | 1 | bug | unassigned | ISS-407 | none | Restore contact_shadows source parity |
-| [ISS-122](ISS-122.md) | blocked | 1 | task | unassigned | ISS-405 | none | Restore anti_aliasing source parity |
+| [ISS-122](ISS-122.md) | blocked | 1 | task | unassigned | none | none | Restore anti_aliasing source parity |
 | [ISS-123](ISS-123.md) | open | 1 | task | unassigned | ISS-014, ISS-015, ISS-019 | none | Restore order-independent transparency source parity |
 | [ISS-129](ISS-129.md) | open | 1 | bug | unassigned | none | none | Restore shadow_biases source parity |
 | [ISS-154](ISS-154.md) | blocked | 1 | task | unassigned | none | none | Add Bevy-shaped ECS parallel mutable query iteration |
-| [ISS-164](ISS-164.md) | blocked | 1 | task | unassigned | ISS-165 | none | Route feature-specific StandardMaterial examples through Bevy-shaped feature selection |
-| [ISS-165](ISS-165.md) | blocked | 1 | bug | unassigned | none | ISS-164 | Unblock feature-rich PBR WGSL composition for startup parity |
+| [ISS-164](ISS-164.md) | blocked | 1 | task | unassigned | none | none | Route feature-specific StandardMaterial examples through Bevy-shaped feature selection |
 | [ISS-174](ISS-174.md) | open | 1 | epic | unassigned | ISS-181 | ISS-104 | Wire volumetric fog pass order and visual gates group |
 | [ISS-181](ISS-181.md) | open | 1 | epic | unassigned | ISS-193 | ISS-174, ISS-274 | Complete volumetric fog visual gate group |
 | [ISS-193](ISS-193.md) | open | 1 | epic | unassigned | ISS-228, ISS-229, ISS-230 | ISS-181 | Complete atmosphere volumetric fog visual gate group |
@@ -88,15 +89,15 @@ Generated by derive-tracker.wasm
 | [ISS-343](ISS-343.md) | open | 1 | task | unassigned | ISS-329, ISS-342 | ISS-330 | Prove atmosphere water and volumetric fog coexist in one frame |
 | [ISS-344](ISS-344.md) | open | 1 | task | unassigned | ISS-229 | ISS-331, ISS-345 | Capture atmosphere Bevy baseline artifact |
 | [ISS-345](ISS-345.md) | open | 1 | task | unassigned | ISS-330, ISS-344 | ISS-331 | Capture atmosphere mgstudio visual delta packet |
-| [ISS-402](ISS-402.md) | blocked | 1 | bug | unassigned | none | none | Unblock meshlet example on MoonBit new native backend |
 | [ISS-403](ISS-403.md) | open | 1 | bug | unassigned | ISS-019 | none | Split deferred opaque main-phase exclusion behind real deferred phase consumption |
 | [ISS-404](ISS-404.md) | blocked | 1 | bug | unassigned | none | none | Unblock official Bevy native transparency screenshot capture on macOS |
 | [ISS-406](ISS-406.md) | blocked | 1 | bug | unassigned | none | none | Capture pinned Bevy wireframe window for visual parity |
 | [ISS-407](ISS-407.md) | blocked | 1 | bug | unassigned | none | ISS-114 | Capture pinned Bevy contact_shadows window for visual parity |
-| [ISS-426](ISS-426.md) | blocked | 1 | bug | unassigned | none | none | Fix Moon test generated-driver ambiguous-braces warnings |
 | [ISS-427](ISS-427.md) | blocked | 1 | bug | unassigned | none | none | Unblock ASan and LSan startup on macOS |
 | [ISS-428](ISS-428.md) | blocked | 1 | feature | unassigned | none | none | Add cancellable wgpu map-read futures |
+| [ISS-443](ISS-443.md) | open | 1 | task | unassigned | none | none | Clear new-toolchain type-parameter method warnings |
 | [ISS-047](ISS-047.md) | open | 2 | epic | unassigned | none | none | Triage failed example screenshot captures |
+| [ISS-441](ISS-441.md) | open | 2 | bug | unassigned | none | none | Make many_foxes profiling survive long native compilation |
 | [ISS-011](ISS-011.md) | open | 4 | task | unassigned | ISS-004 | none | Recheck cluster assignment after top CPU costs are fixed |
 
 ## Dependency Graph
@@ -531,6 +532,51 @@ graph TD
   ISS_426["ISS-426: Fix Moon test generated-driver ambiguous-braces warnings"]
   ISS_427["ISS-427: Unblock ASan and LSan startup on macOS"]
   ISS_428["ISS-428: Add cancellable wgpu map-read futures"]
+  ISS_429["ISS-429: Design the unified dual-category ECS architecture"]
+  ISS_430["ISS-430: Establish MoonBit valtype and MutArrayView enforcement capabilities"]
+  ISS_431["ISS-431: Choose the ECS-B component definition and registration surface"]
+  ISS_432["ISS-432: Define the mixed-query iteration and result model"]
+  ISS_433["ISS-433: Define ECS-B write and change-detection semantics"]
+  ISS_434["ISS-434: Define mixed-query scheduling and alias-safety rules"]
+  ISS_435["ISS-435: Define ECS-B lifecycle hook and observer semantics"]
+  ISS_436["ISS-436: Choose the ECS-B storage and archetype integration model"]
+  ISS_437["ISS-437: Define ECS-B compatibility and migration boundaries"]
+  ISS_438["ISS-438: Set ECS-B correctness and performance acceptance gates"]
+  ISS_439["ISS-439: Decide whether to adopt ECS-B and hand off implementation planning"]
+  ISS_440["ISS-440: Add compiler-known value-component constraints to MoonBit"]
+  ISS_441["ISS-441: Make many_foxes profiling survive long native compilation"]
+  ISS_442["ISS-442: Replace holey ECS table columns with dense storage"]
+  ISS_443["ISS-443: Clear new-toolchain type-parameter method warnings"]
+  ISS_444["ISS-444: Systematically remove ECS hot-path overhead"]
+  ISS_445["ISS-445: Persist hot query state with registered systems"]
+  ISS_446["ISS-446: Separate value-only and change-aware component reads"]
+  ISS_447["ISS-447: Split query specification from fetch state and row items"]
+  ISS_448["ISS-448: Bind typed component columns once per table"]
+  ISS_449["ISS-449: Remove per-row query wrapper allocation"]
+  ISS_450["ISS-450: Make changed messages and caller metadata demand-driven"]
+  ISS_451["ISS-451: Replace hot dense-ID maps with indexed arrays"]
+  ISS_452["ISS-452: Remove redundant per-entity component membership indexes"]
+  ISS_453["ISS-453: Move query lease checks out of row items"]
+  ISS_454["ISS-454: Unify typed payload and raw table structural moves"]
+  ISS_455["ISS-455: Unblock generic value-type query row wrappers"]
+  ISS_456["ISS-456: Migrate trace-proven dense query hotspots to table batches"]
+  ISS_457["ISS-457: Restore delayed-frame visibility in many animated sprites"]
+  ISS_458["ISS-458: Restore sprite_slice texture rendering"]
+  ISS_459["ISS-459: Reject query cursors invalidated by World lifecycle changes"]
+  ISS_460["ISS-460: Preserve render-world cluster buffer ownership"]
+  ISS_461["ISS-461: Grow bindless material allocations across slabs"]
+  ISS_462["ISS-462: Align many_animated_sprites with pinned Bevy source"]
+  ISS_463["ISS-463: Diagnose the many_animated_sprites severe performance gap"]
+  ISS_464["ISS-464: Make ViewVisibility value updates migration-safe"]
+  ISS_465["ISS-465: Preserve exact affine transforms in sprite picking"]
+  ISS_466["ISS-466: Restore standard Camera2d sprite picking"]
+  ISS_467["ISS-467: Restore component membership updates on despawn"]
+  ISS_468["ISS-468: Prevent same-reference bypass replacement destruction"]
+  ISS_469["ISS-469: Retain zero-column table entity rows"]
+  ISS_470["ISS-470: Revoke escaped table-batch mutable views"]
+  ISS_471["ISS-471: Optimize revocable table-batch value access"]
+  ISS_472["ISS-472: Restrict filtered table batches to matching rows"]
+  ISS_473["ISS-473: Align Camera2d frustum with uniform render scale"]
   ISS_002 --> ISS_003
   ISS_002 --> ISS_004
   ISS_043 --> ISS_004
@@ -1052,6 +1098,39 @@ graph TD
   ISS_411 --> ISS_425
   ISS_412 --> ISS_425
   ISS_414 --> ISS_425
+  ISS_430 --> ISS_431
+  ISS_430 --> ISS_432
+  ISS_431 --> ISS_432
+  ISS_430 --> ISS_433
+  ISS_432 --> ISS_434
+  ISS_433 --> ISS_434
+  ISS_433 --> ISS_435
+  ISS_431 --> ISS_436
+  ISS_432 --> ISS_436
+  ISS_433 --> ISS_436
+  ISS_431 --> ISS_437
+  ISS_432 --> ISS_437
+  ISS_433 --> ISS_437
+  ISS_435 --> ISS_437
+  ISS_436 --> ISS_437
+  ISS_434 --> ISS_439
+  ISS_435 --> ISS_439
+  ISS_437 --> ISS_439
+  ISS_438 --> ISS_439
+  ISS_442 --> ISS_445
+  ISS_445 --> ISS_446
+  ISS_446 --> ISS_447
+  ISS_447 --> ISS_448
+  ISS_448 --> ISS_449
+  ISS_449 --> ISS_450
+  ISS_450 --> ISS_451
+  ISS_451 --> ISS_452
+  ISS_452 --> ISS_453
+  ISS_453 --> ISS_454
+  ISS_449 --> ISS_456
+  ISS_470 --> ISS_471
+  ISS_456 --> ISS_472
+  ISS_457 --> ISS_473
 ```
 
 ## Warnings
diff --git a/docs/issues/WAYFINDING.md b/docs/issues/WAYFINDING.md
new file mode 100644
index 000000000..66764d259
--- /dev/null
+++ b/docs/issues/WAYFINDING.md
@@ -0,0 +1,25 @@
+# Wayfinding operations
+
+This repository represents Wayfinder maps and decision tickets in the existing
+Markdown tracker under `docs/issues`.
+
+- A map is an open epic whose labels include `wayfinder:map`.
+- A decision ticket is a child of the map through its `Parent` relationship and
+  carries exactly one `wayfinder:research`, `wayfinder:prototype`,
+  `wayfinder:grilling`, or `wayfinder:task` label.
+- Hard ordering is represented with `Depends on`; the derived reverse edge is
+  `Blocks`.
+- The frontier is the map's open, unassigned child tickets whose dependencies
+  are all closed. Regenerate `README.md`, then filter its ready queue by the
+  map's child relationship.
+- Claim a ticket before working it by setting `Assignee` and changing `Status`
+  to `in_progress`.
+- Resolve a ticket by recording the answer in `Close Notes`, changing `Status`
+  to `closed`, and adding a one-line named link under the map's
+  `Decisions so far` section.
+- Add newly visible decisions as child tickets in one pass, then add dependency
+  edges in a second pass. Keep questions that cannot yet be stated precisely in
+  the map's `Not yet specified` section.
+- Regenerate `docs/issues/README.md` after every tracker mutation.
+
+Use ticket titles, not bare `ISS` identifiers, in developer-facing narration.
diff --git a/docs/research/ecs-b-valtype-mutarrayview.md b/docs/research/ecs-b-valtype-mutarrayview.md
new file mode 100644
index 000000000..d704cff77
--- /dev/null
+++ b/docs/research/ecs-b-valtype-mutarrayview.md
@@ -0,0 +1,160 @@
+# MoonBit `#valtype` and `MutArrayView` enforcement capabilities
+
+Date: 2026-07-15
+
+## Executive conclusion
+
+The current MoonBit toolchain can enforce that a concrete declaration is a valid `#valtype`, and `ArrayView[T]` / `MutArrayView[T]` return elements as `T` while `MutArrayView[T]` replaces an element with another `T`. It cannot express “`T` must be a `#valtype`” as a generic API bound, cannot infer deep immutability from `#valtype`, cannot keep a mutable view inside a query scope, and cannot let mgstudio intercept writes made through a raw `MutArrayView[T]`.
+
+Therefore the proposed ECS-B contract is only partially implementable with the raw standard-library types:
+
+- A scalar-only `#valtype` component can be read as a value and replaced in storage.
+- A raw `MutArrayView[T]` is unsuitable as the public tracked-write query API if ECS-B requires per-component change ticks or runtime rejection of writes after the query scope ends.
+- Preserving the desired `positions[i] = { ..positions[i], x: new_x }` syntax is possible with an mgstudio-owned view type that overloads `_[_]` and `_[_]=_`; the official language guide explicitly supports these overloads. It would not be a `MutArrayView[T]` at the API boundary.
+- Hard rejection of non-value or shallowly mutable component types needs source generation/linting backed by a restricted schema, or a MoonBit language/toolchain capability. A user-implemented marker trait is only a convention.
+
+## Baseline and evidence method
+
+The behavior below was checked with:
+
+```text
+moon 0.1.20260714 (4620153 2026-07-14)
+moonc v0.10.4+4f2e8f7dc-nightly (2026-07-13)
+moonrun 0.1.20260714 (4620153 2026-07-14)
+MOONBIT_NEW_NATIVE=1
+```
+
+The standard-library source bundled with this toolchain was compared with official `moonbitlang/core` commit [`4df746e8c4e47261bb843b3201d7c4656c45384c`](https://github.com/moonbitlang/core/commit/4df746e8c4e47261bb843b3201d7c4656c45384c). The installed `builtin/mutarrayview.mbt` and `builtin/arrayview.mbt` matched that commit byte-for-byte. Small native projects under `/tmp` were used to test accepted declarations, diagnostics, copying, aliasing, and escaped views.
+
+## What `#valtype` actually guarantees
+
+`#valtype` is a declaration attribute that asks the compiler for value representation. The compiler rejects unsupported layouts, including mutable fields, a direct type-parameter field, nested value-type fields, and extensible enums; these are documented under diagnostic [E4173](https://docs.moonbitlang.com/en/latest/language/error_codes/E4173.html) and were reproduced on the baseline toolchain.
+
+The exact boundary is representation-based rather than “the declaration is non-generic”:
+
+- `#valtype struct GenericBox[T] { value : T }` is rejected because the field layout depends directly on `T`.
+- A generic `#valtype` whose stored layout is fixed can compile. The official immutable map is `#valtype struct HashMap[K, V] { data : Node[K, V]? }`, where the field is a reference-shaped optional regardless of `K` and `V` ([official source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/immut/hashmap/types.mbt#L15-L28)).
+- An extensible enum annotated with `#valtype` is rejected with “Value type is not allowed for extensible enum.”
+
+Consequently, “value types do not support generics” is too strong. A direct generic payload is rejected, but generic value wrappers with a fixed physical representation exist in the official standard library.
+
+### `#valtype` is not deep immutability
+
+A `#valtype` struct cannot declare a `mut` field, but an immutable field may hold a mutable reference value. MoonBit explicitly distinguishes immutability of a binding or field from mutability of the value it contains; arrays, refs, and structs with mutable fields can still be mutated through an immutable binding ([E4087](https://docs.moonbitlang.com/en/latest/language/error_codes/E4087.html)). The official `BigInt` is a `#valtype` containing `FixedArray[UInt]` ([official source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/bigint/bigint_nonjs.mbt#L27-L38)). Its encapsulation prevents public mutation, not `#valtype` alone.
+
+The baseline compiler accepted:
+
+```moonbit
+#valtype
+struct ArrayBox {
+  value : Array[Int]
+}
+```
+
+A test copied an `ArrayBox` out of an array, mutated `read_copy.value[0]`, and observed the mutation through the component still in storage. The outer value is copied, but the inner array reference aliases the same mutable object.
+
+For ECS-B, the property required to guarantee read-only query semantics is therefore stronger than `#valtype`: every user-observable path reachable from a component must be immutable, or mutable references must be fully encapsulated behind an observationally immutable API. Current generic constraints cannot state that property.
+
+## Valtype-only generic APIs
+
+MoonBit constrained generics are trait constraints such as `[T : Eq]` ([official trait documentation](https://docs.moonbitlang.com/en/latest/language/methods.html#using-traits)). There is no exposed builtin `Valtype`/`ValueType` trait or kind constraint. Compiling `[T : Valtype]` on the baseline reports E4023, “The trait Valtype is not found.”
+
+The apparent marker-trait alternatives do not provide the desired guarantee:
+
+- An empty marker trait cannot discriminate because the current language automatically implements empty traits for all types ([official trait documentation](https://docs.moonbitlang.com/en/latest/language/methods.html#implementing-traits)).
+- A non-empty `pub(open)` marker trait can be implemented by downstream component authors for a non-`#valtype` type, so it is an explicit promise rather than enforcement.
+- A sealed `pub trait` can only be implemented by the package defining the trait ([official access-control documentation](https://docs.moonbitlang.com/en/latest/language/packages.html#access-control)). That prevents downstream authors from lying, but also prevents their packages from registering arbitrary user-defined component types through an implementation.
+- MoonBit cannot automatically derive a user-defined marker trait; custom derives are rejected ([E4077](https://docs.moonbitlang.com/en/latest/language/error_codes/E4077.html)).
+
+An opaque registration witness does not remove this limitation by itself. If downstream generated code can publicly construct the witness, handwritten code can do the same. If its constructor or trait is sealed, downstream generated code cannot construct or implement it unless generation writes into a package controlled by mgstudio.
+
+### Enforcement classification
+
+| Requirement | Current language/library | Code generation or convention | Toolchain change |
+| --- | --- | --- | --- |
+| Reject an invalid concrete `#valtype` declaration | Compiler-enforced | Not needed | Not needed |
+| Require generic `T` to have `#valtype` representation | Not expressible | Generator/linter can inspect declarations; an open marker remains forgeable | Compiler-known `ValueType` kind/trait or reflection predicate |
+| Require deep immutability | Not implied by `#valtype` | Restricted schema plus recursive field validation; otherwise convention | Compiler-known deep-immutable/sendable-style property |
+| Allow downstream arbitrary component types with a sealed witness | Not directly possible across package boundary | Aggregate generated registrations inside an mgstudio-owned package, or accept a forgeable public hook | Compiler-supported custom derive or compiler-issued witness |
+
+## Copy-returning reads
+
+`ArrayView[T]::at` returns `T`, and its public API has no element setter ([official source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/builtin/arrayview.mbt#L112-L173)). For a value component with no reachable mutable reference, this gives the intended local behavior:
+
+1. `let old = positions[i]` obtains the old value.
+2. `{ ..old, x: new_x }` creates a replacement value.
+3. The stored component is unchanged until the write API receives that replacement.
+
+This is not a complete query-level read guarantee:
+
+- `ArrayView` is a borrowed view, not a snapshot. Official documentation notes that the underlying `Array` or `FixedArray` may still be modified ([ArrayView documentation](https://docs.moonbitlang.com/en/latest/language/fundamentals.html#arrayview)).
+- A shallowly mutable `#valtype`, such as the accepted `ArrayBox`, can mutate storage-visible state through the copied field.
+- MoonBit has no ownership/lifetime rule that makes a view non-escaping or uniquely borrowed. The baseline toolchain accepted a closure that captured `MutArrayView[Point]` and mutated the backing array after the function that created the closure had returned. It also accepted two overlapping mutable views of the same array.
+
+Thus the ECS scheduler can prevent known systems from being scheduled concurrently, but the raw view type cannot prevent a system from retaining an alias and writing outside its declared access window.
+
+## Replacement writes and interception
+
+`MutArrayView[T]` is itself a builtin value-shaped view over an `UninitializedArray[T]` buffer, start, and length ([official source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/builtin/mutarrayview.mbt#L16-L46)). Its getter returns `T` ([source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/builtin/mutarrayview.mbt#L92-L150)); its `_[_]=_` operator is the builtin `set` intrinsic, which writes the supplied `T` directly into the backing buffer ([source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/builtin/mutarrayview.mbt#L152-L186)). `unsafe_set` is another direct write path ([source](https://github.com/moonbitlang/core/blob/4df746e8c4e47261bb843b3201d7c4656c45384c/builtin/mutarrayview.mbt#L188-L216)).
+
+This does implement physical replacement, but there is no callback, trait hook, or metadata parameter for mgstudio. Methods and operators for a foreign type cannot be overridden by the ECS package; MoonBit only permits the type-owning package to define its methods, and `_[_]=_` resolves to the annotated method ([operator-overloading documentation](https://docs.moonbitlang.com/en/latest/language/methods.html#operator-overloading), [access-control documentation](https://docs.moonbitlang.com/en/latest/language/packages.html#access-control)).
+
+Therefore a raw `MutArrayView[T]` cannot provide exact ECS change detection:
+
+- Marking the entire returned range changed when the view is granted is safe but creates false positives, including when no assignment occurs.
+- Comparing a snapshot after the system returns adds an O(n) copy/compare path and still cannot account for a retained view that writes later.
+- Returning the raw view alongside a tracker does not force callers to notify the tracker.
+- Wrapping elements in a tracked value does not help because assigning through `MutArrayView` still replaces the element without invoking an mgstudio hook.
+
+## Recommended boundary for the ECS-B design map
+
+If ECS-B requires API-enforced read/write semantics and Bevy-like per-component change ticks, its tracked query API should be an mgstudio-owned abstraction:
+
+```moonbit
+let old = positions[i]
+positions[i] = { ..old, x: new_x }
+```
+
+The syntax remains available because MoonBit lets user-defined types overload `_[_]` and `_[_]=_`. The wrapper setter can perform, in one operation:
+
+1. bounds and entity-row validation;
+2. replacement of the backing `T`;
+3. update of that row's changed tick;
+4. an active-lease/epoch check that rejects writes after the query scope is closed.
+
+The backing storage may internally use an array and `MutArrayView[T]`, but the raw mutable view must not escape the ECS package. A separately named bulk/untracked API could expose raw `MutArrayView[T]` only if its contract intentionally marks the entire range changed and accepts non-escaping as a convention.
+
+For component eligibility, choose explicitly between these contracts before implementation:
+
+1. **Representation-only ECS-B:** require `#valtype` by generator/lint convention. Copying is shallow; read-only semantics exclude interior mutation only by user promise.
+2. **Deeply immutable ECS-B:** restrict component schemas to compiler scalar types and an audited whitelist/recursive set of immutable types. This is stronger than current `#valtype` and needs generator/linter ownership of registration.
+3. **Toolchain-gated ECS-B:** wait for or request a compiler-known generic value-layout constraint and, if deep read isolation is required, a separate deep-immutability property. Compile-time non-escaping mutable query borrows would require an ownership/lifetime capability; otherwise use the runtime lease wrapper above.
+
+The original stated goal—read/write semantics guaranteed by the API—matches option 2 plus a custom tracked view today. Raw `MutArrayView[T]` plus `#valtype` alone does not meet it.
+
+## Reproduction record
+
+Commands were run one at a time, with the required native-backend environment variable:
+
+```sh
+MOONBIT_NEW_NATIVE=1 moon version --all
+MOONBIT_NEW_NATIVE=1 moon check --target native
+MOONBIT_NEW_NATIVE=1 moon test --target native
+```
+
+Observed compile-time results:
+
+- direct generic field in `#valtype`: rejected with E4173;
+- mutable field in `#valtype`: rejected with E4173;
+- nested `#valtype` field: rejected with E4173;
+- `#valtype` extensible enum: rejected with E4173;
+- generic value wrapper containing `Node[T]?`: accepted;
+- `#valtype` containing `Array[Int]`: accepted;
+- `[T : Valtype]`: rejected because no such trait exists.
+
+Observed native runtime results (`4` tests passed):
+
+- scalar value read followed by record update did not change storage until assignment;
+- copying a `#valtype` containing `Array[Int]` preserved an alias to the inner array;
+- assigning through `MutArrayView` changed the backing array;
+- overlapping `MutArrayView`s and a closure-captured escaping view were accepted and observed each other's writes.
diff --git a/mgstudio-engine/animation/animation_event.mbt b/mgstudio-engine/animation/animation_event.mbt
index ba6a83bce..641110f6b 100644
--- a/mgstudio-engine/animation/animation_event.mbt
+++ b/mgstudio-engine/animation/animation_event.mbt
@@ -54,14 +54,14 @@ pub fn[T : AnimationEvent + @ecs.TriggerEvent] AnimationClipEvent::new_typed(
   time : Float,
   event : T,
 ) -> AnimationClipEvent {
-  event.animation_event_marker()
+  AnimationEvent::animation_event_marker(event)
   let trigger : AnimationEventTriggerFn = fn(
     world : @ecs.World,
     entity : @core.Entity,
     _time : Float,
     _weight : Float,
   ) {
-    let event_value = T::set_observer_entity(event, entity)
+    let event_value = @ecs.TriggerEvent::set_observer_entity(event, entity)
     world.trigger(event_value, caller=Some("mgstudio.animation.trigger_events"))
   }
   AnimationClipEvent::{ time, label: "", payload: "", trigger: Some(trigger) }
diff --git a/mgstudio-engine/anti_alias/smaa/SMAAAreaLUT.ktx2 b/mgstudio-engine/anti_alias/smaa/SMAAAreaLUT.ktx2
index e7d160f62..90bf16490 100644
Binary files a/mgstudio-engine/anti_alias/smaa/SMAAAreaLUT.ktx2 and b/mgstudio-engine/anti_alias/smaa/SMAAAreaLUT.ktx2 differ
diff --git a/mgstudio-engine/anti_alias/smaa/SMAASearchLUT.ktx2 b/mgstudio-engine/anti_alias/smaa/SMAASearchLUT.ktx2
index 29089f1e9..1d6d92df6 100644
Binary files a/mgstudio-engine/anti_alias/smaa/SMAASearchLUT.ktx2 and b/mgstudio-engine/anti_alias/smaa/SMAASearchLUT.ktx2 differ
diff --git a/mgstudio-engine/app/message_support.mbt b/mgstudio-engine/app/message_support.mbt
index 88cdb7225..b56371f71 100644
--- a/mgstudio-engine/app/message_support.mbt
+++ b/mgstudio-engine/app/message_support.mbt
@@ -136,7 +136,7 @@ pub fn[T : @ecs.Message + Default] ResMut::write_default(
   self : ResMut[@ecs.Messages[T]],
 ) -> Int {
   let key : @ecs.MessageKey[T] = @ecs.Message::message()
-  res_mut_world_or_abort(self).send_message(key, T::default())
+  res_mut_world_or_abort(self).send_message(key, Default::default())
 }
 
 ///|
diff --git a/mgstudio-engine/app/query_params.mbt b/mgstudio-engine/app/query_params.mbt
index 2685a3660..8f165cbaa 100644
--- a/mgstudio-engine/app/query_params.mbt
+++ b/mgstudio-engine/app/query_params.mbt
@@ -196,7 +196,7 @@ fn[D, F : FromWorld] query_param_query_from_state(
 ) -> @ecs.Query[D, F] {
   let world = system_param_abort_missing_world()
   let scope = current_system_param_scope_or_abort()
-  let filter = F::from_world(world)
+  let filter : F = FromWorld::from_world(world)
   @ecs.query_filtered_with_cache_and_lease(
     scope.world_lease(),
     filter,
@@ -247,7 +247,7 @@ pub impl[D : @ecs.QueryData, F : FromWorld + @ecs.QueryFilter] SystemParam for @
   F,
 ] with fn access(world) {
   let access = SystemAccess::new()
-  let filter = F::from_world(world)
+  let filter : F = FromWorld::from_world(world)
   let (data_access, filter_access) = @ecs.query_access_descriptor(
     filter,
     fn(data_access : @ecs.QueryDataAccess) { D::collect_access(data_access) },
@@ -321,7 +321,7 @@ pub impl[D : @ecs.QueryData, F : FromWorld + @ecs.QueryFilter] SystemParam for S
   F,
 ] with fn access(world) {
   let access = SystemAccess::new()
-  let filter = F::from_world(world)
+  let filter : F = FromWorld::from_world(world)
   let (data_access, filter_access) = @ecs.query_access_descriptor(
     filter,
     fn(data_access : @ecs.QueryDataAccess) { D::collect_access(data_access) },
@@ -376,7 +376,7 @@ pub impl[D : @ecs.QueryData, F : FromWorld + @ecs.QueryFilter] SystemParam for P
   F,
 ] with fn access(world) {
   let access = SystemAccess::new()
-  let filter = F::from_world(world)
+  let filter : F = FromWorld::from_world(world)
   let (data_access, filter_access) = @ecs.query_access_descriptor(
     filter,
     fn(data_access : @ecs.QueryDataAccess) { D::collect_access(data_access) },
diff --git a/mgstudio-engine/app/resource_param_test.mbt b/mgstudio-engine/app/resource_param_test.mbt
index a222cc4a2..810ce036b 100644
--- a/mgstudio-engine/app/resource_param_test.mbt
+++ b/mgstudio-engine/app/resource_param_test.mbt
@@ -261,6 +261,10 @@ test "app: any_with_component gates system execution on component presence" {
 
   debug_inspect(log.length(), content="1")
   debug_inspect(log[0], content="0")
+
+  try! app.world().despawn(entity)
+  app.run_once() |> ignore
+  debug_inspect(log.length(), content="1")
 }
 
 ///|
diff --git a/mgstudio-engine/asset/assets.mbt b/mgstudio-engine/asset/assets.mbt
index b10250ad7..a357b7f0a 100644
--- a/mgstudio-engine/asset/assets.mbt
+++ b/mgstudio-engine/asset/assets.mbt
@@ -164,7 +164,11 @@ pub fn[T] Assets::reserve_handle(self : Assets[T]) -> Handle[T] {
 
 ///|
 pub fn[T] Assets::get(self : Assets[T], handle : Handle[T]) -> T? {
-  let id = handle.id()
+  self.get_by_id(handle.id())
+}
+
+///|
+fn[T] Assets::get_by_id(self : Assets[T], id : Int) -> T? {
   if id < 0 || id >= self.items.length() {
     None
   } else {
diff --git a/mgstudio-engine/asset/pkg.generated.mbti b/mgstudio-engine/asset/pkg.generated.mbti
index d6f81ee21..059239d0b 100644
--- a/mgstudio-engine/asset/pkg.generated.mbti
+++ b/mgstudio-engine/asset/pkg.generated.mbti
@@ -661,11 +661,12 @@ pub fn[T] SavedAssetBuilder::build(Self, T) -> SavedAsset[T]
 pub fn SavedAssetBuilder::new(AssetServer, AssetPath) -> Self
 
 pub struct TextureAtlas {
-  layout : Handle[TextureAtlasLayout]
   index : Int
+  // private fields
 }
 pub fn TextureAtlas::index(Self) -> Int
 pub fn TextureAtlas::layout(Self) -> Handle[TextureAtlasLayout]
+pub fn TextureAtlas::layout_asset(Self, Assets[TextureAtlasLayout]) -> TextureAtlasLayout?
 pub fn TextureAtlas::new(Handle[TextureAtlasLayout], Int) -> Self
 pub fn TextureAtlas::texture_rect(Self, Assets[TextureAtlasLayout]) -> @math.URect?
 pub fn TextureAtlas::with_index(Self, Int) -> Self
diff --git a/mgstudio-engine/asset/texture_atlas.mbt b/mgstudio-engine/asset/texture_atlas.mbt
index 87cf0c754..9b0f4a24c 100644
--- a/mgstudio-engine/asset/texture_atlas.mbt
+++ b/mgstudio-engine/asset/texture_atlas.mbt
@@ -131,23 +131,25 @@ pub fn TextureAtlasLayout::texture(
 }
 
 ///|
+// Bevy source: `bevy/crates/bevy_image/src/texture_atlas.rs::TextureAtlas`.
+// Bevy stores this as an inline component field. MoonBit value types cannot
+// contain the current generic reference-typed Handle, so preserve the same
+// value semantics by storing its scalar asset id.
+#valtype
 pub struct TextureAtlas {
-  layout : Handle[TextureAtlasLayout]
+  priv layout_id : Int
   index : Int
 }
 
 ///|
 pub impl ToJson for TextureAtlas with fn to_json(self) {
-  (self.layout, self.index).to_json()
+  (self.layout_id, self.index).to_json()
 }
 
 ///|
 pub impl @json.FromJson for TextureAtlas with fn from_json(json, path) {
-  let (layout, index) : (Handle[TextureAtlasLayout], Int) = @json.from_json(
-    json,
-    path~,
-  )
-  TextureAtlas::{ layout, index }
+  let (layout_id, index) : (Int, Int) = @json.from_json(json, path~)
+  TextureAtlas::{ layout_id, index }
 }
 
 ///|
@@ -155,7 +157,7 @@ pub fn TextureAtlas::new(
   layout : Handle[TextureAtlasLayout],
   index : Int,
 ) -> TextureAtlas {
-  TextureAtlas::{ layout, index }
+  TextureAtlas::{ layout_id: layout.id(), index }
 }
 
 ///|
@@ -171,12 +173,12 @@ pub fn TextureAtlas::with_layout(
   self : TextureAtlas,
   layout : Handle[TextureAtlasLayout],
 ) -> TextureAtlas {
-  TextureAtlas::{ ..self, layout, }
+  TextureAtlas::{ ..self, layout_id: layout.id() }
 }
 
 ///|
 pub fn TextureAtlas::layout(self : TextureAtlas) -> Handle[TextureAtlasLayout] {
-  self.layout
+  Handle::new(self.layout_id)
 }
 
 ///|
@@ -184,12 +186,20 @@ pub fn TextureAtlas::index(self : TextureAtlas) -> Int {
   self.index
 }
 
+///|
+pub fn TextureAtlas::layout_asset(
+  self : TextureAtlas,
+  layouts : Assets[TextureAtlasLayout],
+) -> TextureAtlasLayout? {
+  layouts.get_by_id(self.layout_id)
+}
+
 ///|
 pub fn TextureAtlas::texture_rect(
   self : TextureAtlas,
   layouts : Assets[TextureAtlasLayout],
 ) -> @math.URect? {
-  if layouts.get(self.layout) is Some(layout_value) {
+  if self.layout_asset(layouts) is Some(layout_value) {
     if self.index >= 0 && self.index < layout_value.textures.length() {
       return Some(layout_value.textures[self.index])
     }
@@ -224,7 +234,7 @@ pub fn TextureAtlasSources::handle(
   texture : Handle[Image],
 ) -> TextureAtlas? {
   if self.texture_index(texture) is Some(index) {
-    Some(TextureAtlas::{ layout, index })
+    Some(TextureAtlas::new(layout, index))
   } else {
     None
   }
diff --git a/mgstudio-engine/asset/texture_atlas_test.mbt b/mgstudio-engine/asset/texture_atlas_test.mbt
index 611892588..54f2f9cd7 100644
--- a/mgstudio-engine/asset/texture_atlas_test.mbt
+++ b/mgstudio-engine/asset/texture_atlas_test.mbt
@@ -20,6 +20,16 @@ fn rects_overlap(a : @math.URect, b : @math.URect) -> Bool {
   a.max.y > b.min.y
 }
 
+///|
+test "texture atlas: with_index preserves inline value semantics" {
+  let atlas = TextureAtlas::new(Handle::new(9), 3)
+  let next = atlas.with_index(4)
+  debug_inspect(atlas.layout().id(), content="9")
+  debug_inspect(atlas.index(), content="3")
+  debug_inspect(next.layout().id(), content="9")
+  debug_inspect(next.index(), content="4")
+}
+
 ///|
 test "dynamic texture atlas: packs non-overlapping rects" {
   let atlas_size = @math.UVec2::new(8, 8)
diff --git a/mgstudio-engine/assets/environment_maps/cubes_reflection_probe_specular_rgb9e5_zstd.ktx2 b/mgstudio-engine/assets/environment_maps/cubes_reflection_probe_specular_rgb9e5_zstd.ktx2
index 9c2f2a85a..a4ffc2ba8 100644
Binary files a/mgstudio-engine/assets/environment_maps/cubes_reflection_probe_specular_rgb9e5_zstd.ktx2 and b/mgstudio-engine/assets/environment_maps/cubes_reflection_probe_specular_rgb9e5_zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/lightmaps/CornellBox-Box.zstd.ktx2 b/mgstudio-engine/assets/lightmaps/CornellBox-Box.zstd.ktx2
index 0a31dd485..52f3fd1dd 100644
Binary files a/mgstudio-engine/assets/lightmaps/CornellBox-Box.zstd.ktx2 and b/mgstudio-engine/assets/lightmaps/CornellBox-Box.zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/lightmaps/CornellBox-Large.zstd.ktx2 b/mgstudio-engine/assets/lightmaps/CornellBox-Large.zstd.ktx2
index c41ef9b03..71a7b3427 100644
Binary files a/mgstudio-engine/assets/lightmaps/CornellBox-Large.zstd.ktx2 and b/mgstudio-engine/assets/lightmaps/CornellBox-Large.zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/lightmaps/CornellBox-Small.zstd.ktx2 b/mgstudio-engine/assets/lightmaps/CornellBox-Small.zstd.ktx2
index 9b1b72cd1..c59b2c6b8 100644
Binary files a/mgstudio-engine/assets/lightmaps/CornellBox-Small.zstd.ktx2 and b/mgstudio-engine/assets/lightmaps/CornellBox-Small.zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/lightmaps/MixedLightingExample-Baked.zstd.ktx2 b/mgstudio-engine/assets/lightmaps/MixedLightingExample-Baked.zstd.ktx2
index 6f699f561..f41b3da97 100644
Binary files a/mgstudio-engine/assets/lightmaps/MixedLightingExample-Baked.zstd.ktx2 and b/mgstudio-engine/assets/lightmaps/MixedLightingExample-Baked.zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedDirect.zstd.ktx2 b/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedDirect.zstd.ktx2
index 1977d638e..2b3476ee6 100644
Binary files a/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedDirect.zstd.ktx2 and b/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedDirect.zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedIndirect.zstd.ktx2 b/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedIndirect.zstd.ktx2
index 070d8ac61..e68566f7b 100644
Binary files a/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedIndirect.zstd.ktx2 and b/mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedIndirect.zstd.ktx2 differ
diff --git a/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_anisotropy.ktx2 b/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_anisotropy.ktx2
index 32ef2d17d..e51e77c48 100644
Binary files a/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_anisotropy.ktx2 and b/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_anisotropy.ktx2 differ
diff --git a/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_normalbump.ktx2 b/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_normalbump.ktx2
index 8099744a8..f3f375a14 100644
Binary files a/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_normalbump.ktx2 and b/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_normalbump.ktx2 differ
diff --git a/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_occlusionroughnessmetal.ktx2 b/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_occlusionroughnessmetal.ktx2
index af0ae73cd..281bbb5c1 100644
Binary files a/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_occlusionroughnessmetal.ktx2 and b/mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_occlusionroughnessmetal.ktx2 differ
diff --git a/mgstudio-engine/assets/shaders/custom_material.wesl b/mgstudio-engine/assets/shaders/custom_material.wesl
index ca9466878..2d4ba6917 100644
--- a/mgstudio-engine/assets/shaders/custom_material.wesl
+++ b/mgstudio-engine/assets/shaders/custom_material.wesl
@@ -6,7 +6,7 @@ struct VertexOutput {
 }
 
 struct CustomMaterial {
-    // Needed for 16-bit alignment on WebGL2
+    // Needed for 16 byte alignment on WebGL2
     time: vec4<f32>,
 }
 
diff --git a/mgstudio-engine/assets/textures/Ryfjallet_cubemap_astc4x4.ktx2 b/mgstudio-engine/assets/textures/Ryfjallet_cubemap_astc4x4.ktx2
index 78696cadc..d30a21c15 100644
Binary files a/mgstudio-engine/assets/textures/Ryfjallet_cubemap_astc4x4.ktx2 and b/mgstudio-engine/assets/textures/Ryfjallet_cubemap_astc4x4.ktx2 differ
diff --git a/mgstudio-engine/assets/textures/Ryfjallet_cubemap_bc7.ktx2 b/mgstudio-engine/assets/textures/Ryfjallet_cubemap_bc7.ktx2
index 17e67c7c9..569782a13 100644
Binary files a/mgstudio-engine/assets/textures/Ryfjallet_cubemap_bc7.ktx2 and b/mgstudio-engine/assets/textures/Ryfjallet_cubemap_bc7.ktx2 differ
diff --git a/mgstudio-engine/assets/textures/Ryfjallet_cubemap_etc2.ktx2 b/mgstudio-engine/assets/textures/Ryfjallet_cubemap_etc2.ktx2
index 22a389cfd..fd40f8ba3 100644
Binary files a/mgstudio-engine/assets/textures/Ryfjallet_cubemap_etc2.ktx2 and b/mgstudio-engine/assets/textures/Ryfjallet_cubemap_etc2.ktx2 differ
diff --git a/mgstudio-engine/audio/audio_source.mbt b/mgstudio-engine/audio/audio_source.mbt
index fea3a8d32..7036220c0 100644
--- a/mgstudio-engine/audio/audio_source.mbt
+++ b/mgstudio-engine/audio/audio_source.mbt
@@ -177,7 +177,7 @@ pub fn audio_source_load(
   let canonical_path = @asset.asset_canonical_path(path)
   let paths = audio_resource_ensure_mut(
     world,
-    AudioSourceAssetPaths::resource(),
+    (@app.Resource::resource() : @ecs.ResourceKey[AudioSourceAssetPaths]),
     fn() { AudioSourceAssetPaths::new() },
   )
   match paths.peek().find_path_handle(canonical_path) {
diff --git a/mgstudio-engine/camera/lib.mbt b/mgstudio-engine/camera/lib.mbt
index dc7ce5704..87d191718 100644
--- a/mgstudio-engine/camera/lib.mbt
+++ b/mgstudio-engine/camera/lib.mbt
@@ -26,6 +26,81 @@ pub let camera_update_systems : @app.SystemSet = @app.system_set(
   "mgstudio.camera.update",
 )
 
+///|
+pub let camera_update_frusta_systems : @app.SystemSet = @app.system_set(
+  "mgstudio.camera.update_frusta",
+)
+
+///|
+fn camera2d_frustum_render_transform(
+  global_transform : @transform.GlobalTransform,
+) -> @transform.Transform {
+  let camera_transform = global_transform.to_transform_approx()
+  let scale_x = if camera_transform.scale.x < 0.0F {
+    -camera_transform.scale.x
+  } else if camera_transform.scale.x == 0.0F {
+    1.0F
+  } else {
+    camera_transform.scale.x
+  }
+  camera_transform.with_scale(
+    @math.Vec3::new(scale_x, scale_x, camera_transform.scale.z),
+  )
+}
+
+///|
+// Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::update_frusta`.
+// The current 2D projection surface is the WindowSize orthographic subset, so
+// reuse the source-aligned orthographic implementation with the 2D defaults.
+// Bevy feeds rendering and frustum extraction the same camera affine. The
+// current native 2D backend uses absolute non-zero scale.x for both view axes,
+// so the 2D frustum must apply that same transform convention before entering
+// the shared 3D projection code.
+pub fn update_frusta_2d_system(world : @ecs.World) -> Unit {
+  let updates : Array[(@core.Entity, @camera_primitives.Frustum)] = []
+  world.for_each_component(@camera_projection2d.ecs_key_projection, fn(
+    entity,
+    projection,
+  ) {
+    guard (try! world.get_by_key(entity, @camera_camera.ecs_key_camera))
+      is Some(camera) else {
+      return
+    }
+    guard camera.logical_viewport_size() is Some(logical_size) else { return }
+    if logical_size.x <= 0.0F || logical_size.y <= 0.0F {
+      return
+    }
+    guard (try! world.get_by_key(entity, @transform.ecs_key_global_transform))
+      is Some(global_transform) else {
+      return
+    }
+    let orthographic = match projection {
+      @camera_projection2d.Projection::Orthographic(value) => value
+    }
+    let projection_3d = @camera_projection3d.OrthographicProjection3d::default_2d()
+      .with_scale(orthographic.scale)
+      .update(logical_size.x, logical_size.y)
+    let next = @camera_projection3d.render3d_orthographic_projection_compute_frustum(
+      projection_3d,
+      camera2d_frustum_render_transform(global_transform),
+    )
+    match (try! world.get_by_key(entity, @camera_primitives.ecs_key_frustum)) {
+      Some(current) => if current != next { updates.push((entity, next)) }
+      None => updates.push((entity, next))
+    }
+  })
+  for update in updates {
+    let (entity, frustum) = update
+    if (try! world.get_by_key(entity, @camera_primitives.ecs_key_frustum))
+      is Some(_) {
+      try! (world.replace(entity, @camera_primitives.ecs_key_frustum, frustum)
+      |> ignore)
+    } else {
+      try! world.set_by_key(entity, @camera_primitives.ecs_key_frustum, frustum)
+    }
+  }
+}
+
 ///|
 pub struct CameraProjectionPlugin {}
 
@@ -67,6 +142,12 @@ pub fn camera_projection_plugin(
   app : @app.App[@ecs.World],
 ) -> @app.App[@ecs.World] {
   app
+  .configure_set(@app.PostUpdate, camera_update_systems, after=[
+    @transform.transform_set_propagate,
+  ])
+  .configure_set(@app.PostUpdate, camera_update_frusta_systems, after=[
+    camera_update_systems, @transform.transform_set_propagate,
+  ])
   .add_post_update_system_config(
     @app.system(@pbr.render3d_camera_system)
     .named("mgstudio.pbr.render3d_camera_system")
@@ -76,9 +157,12 @@ pub fn camera_projection_plugin(
   .add_post_update_system_config(
     @app.system(@pbr.render3d_update_frusta_system)
     .named("mgstudio.pbr.render3d_update_frusta")
-    .in_set(camera_update_systems)
-    .after("mgstudio.pbr.render3d_camera_system")
-    .after(@transform.transform_set_propagate),
+    .in_set(camera_update_frusta_systems),
+  )
+  .add_post_update_system_config(
+    @app.system(update_frusta_2d_system)
+    .named("mgstudio.camera.update_frusta_2d")
+    .in_set(camera_update_frusta_systems),
   )
 }
 
diff --git a/mgstudio-engine/camera/moon.pkg b/mgstudio-engine/camera/moon.pkg
index 89d669b79..78aef91db 100644
--- a/mgstudio-engine/camera/moon.pkg
+++ b/mgstudio-engine/camera/moon.pkg
@@ -10,6 +10,7 @@ import {
   "Milky2018/mgstudio/camera/projection3d" @camera_projection3d,
   "Milky2018/mgstudio/camera/viewport" @camera_viewport,
   "Milky2018/mgstudio/app",
+  "Milky2018/mgstudio/core",
   "Milky2018/mgstudio/transform",
   "Milky2018/mgstudio/ecs",
   "Milky2018/mgstudio/camera/primitives" @camera_primitives,
diff --git a/mgstudio-engine/camera/pkg.generated.mbti b/mgstudio-engine/camera/pkg.generated.mbti
index 322193da9..d736ac1d6 100644
--- a/mgstudio-engine/camera/pkg.generated.mbti
+++ b/mgstudio-engine/camera/pkg.generated.mbti
@@ -26,6 +26,8 @@ pub fn camera_plugin(@app.App[@ecs.World]) -> @app.App[@ecs.World]
 
 pub fn camera_projection_plugin(@app.App[@ecs.World]) -> @app.App[@ecs.World]
 
+pub let camera_update_frusta_systems : String
+
 pub let camera_update_systems : String
 
 pub fn camera_viewport_clamp_to_size(@viewport.Viewport, @math.IVec2) -> @viewport.Viewport
@@ -66,6 +68,8 @@ pub fn perspective_projection_3d_update(@projection3d.PerspectiveProjection3d, F
 
 pub fn perspective_projection_3d_with_aspect_ratio(@projection3d.PerspectiveProjection3d, Float) -> @projection3d.PerspectiveProjection3d
 
+pub fn update_frusta_2d_system(@ecs.World) -> Unit
+
 // Errors
 
 // Types and methods
diff --git a/mgstudio-engine/camera/plugin_test.mbt b/mgstudio-engine/camera/plugin_test.mbt
index a9e28bdbb..e65cd337a 100644
--- a/mgstudio-engine/camera/plugin_test.mbt
+++ b/mgstudio-engine/camera/plugin_test.mbt
@@ -165,7 +165,7 @@ test "camera plugin: owns Camera required components" {
 }
 
 ///|
-test "camera projection plugin: updates frustum when transform changes" {
+test "camera projection plugin: updates frustum when transform or projection changes" {
   let lifecycle_world_159_0 = @ecs.World::new()
   defer lifecycle_world_159_0.close()
   let mut app = @app.App::new(lifecycle_world_159_0).add_plugins(
@@ -196,4 +196,165 @@ test "camera projection plugin: updates frustum when transform changes" {
     None => false
   }
   debug_inspect(frustum_after_transform_ok, content="true")
+
+  let updated_projection = @pbr.Projection::Perspective(
+    @pbr.PerspectiveProjection3d::PerspectiveProjection3d().with_far(250.0F),
+  )
+  try! (app
+  .world()
+  .replace(entity, @pbr.ecs_key_projection, updated_projection)
+  |> ignore)
+  app = app.update()
+
+  let frustum_after_projection : @camera_primitives.Frustum? = try! app
+    .world()
+    .get_by_key(entity, @camera_primitives.ecs_key_frustum)
+  let expected_after_projection = updated_projection.compute_frustum(
+    moved_transform,
+  )
+  debug_inspect(
+    frustum_after_projection == Some(expected_after_projection),
+    content="true",
+  )
+}
+
+///|
+test "camera projection plugin: updates Camera2d frustum from logical viewport" {
+  let lifecycle_world_199_0 = @ecs.World::new()
+  defer lifecycle_world_199_0.close()
+  let mut app = @app.App::new(lifecycle_world_199_0).add_plugins(
+    CameraPlugin::CameraPlugin(),
+  )
+  let world = app.world()
+  let entity = world.spawn()
+  try! world.set_by_key(
+    entity,
+    @camera_components2d.ecs_key_camera2d,
+    @camera_components2d.Camera2d::Camera2d(),
+  )
+  try! world.set_by_key(
+    entity,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  let camera = (try! world.get_by_key(entity, @camera_camera.ecs_key_camera)).unwrap()
+  let computed = @camera_computed.ComputedCameraValues::new(
+    @math.Mat4::identity(),
+    Some(
+      @camera_computed.RenderTargetInfo::new(@math.IVec2::new(1280, 720), 2.0F),
+    ),
+    None,
+    None,
+  )
+  try! (world.replace(
+    entity,
+    @camera_camera.ecs_key_camera,
+    camera.with_computed(computed),
+  )
+  |> ignore)
+
+  app = app.update()
+
+  let frustum = (try! app
+  .world()
+  .get_by_key(entity, @camera_primitives.ecs_key_frustum)).unwrap()
+  let inside = @camera_primitives.Sphere::new(
+    @math.Vec3::new(300.0F, 0.0F, 0.0F),
+    1.0F,
+  )
+  let outside = @camera_primitives.Sphere::new(
+    @math.Vec3::new(400.0F, 0.0F, 0.0F),
+    1.0F,
+  )
+  debug_inspect(frustum.intersects_sphere(inside, false), content="true")
+  debug_inspect(frustum.intersects_sphere(outside, false), content="false")
+}
+
+///|
+test "camera projection plugin: Camera2d frustum matches uniform X render scale" {
+  let lifecycle_world = @ecs.World::new()
+  defer lifecycle_world.close()
+  let mut app = @app.App::new(lifecycle_world).add_plugins(
+    CameraPlugin::CameraPlugin(),
+  )
+  let world = app.world()
+  let entity = world.spawn()
+  try! world.set_by_key(
+    entity,
+    @camera_components2d.ecs_key_camera2d,
+    @camera_components2d.Camera2d::Camera2d(),
+  )
+  let camera_transform = @transform.Transform::identity().with_scale(
+    @math.Vec3::new(2.0F, 1.0F, 1.0F),
+  )
+  try! world.set_by_key(
+    entity,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::from_transform(camera_transform),
+  )
+  let camera = (try! world.get_by_key(entity, @camera_camera.ecs_key_camera)).unwrap()
+  let computed = @camera_computed.ComputedCameraValues::new(
+    @math.Mat4::identity(),
+    Some(
+      @camera_computed.RenderTargetInfo::new(@math.IVec2::new(100, 100), 1.0F),
+    ),
+    None,
+    None,
+  )
+  try! (world.replace(
+    entity,
+    @camera_camera.ecs_key_camera,
+    camera.with_computed(computed),
+  )
+  |> ignore)
+  let projection = match
+    (try! world.get_by_key(entity, @camera_projection2d.ecs_key_projection)).unwrap() {
+    @camera_projection2d.Projection::Orthographic(value) => value
+  }
+  let vertically_visible = @math.Vec2::new(0.0F, 75.0F)
+  let vertically_hidden = @math.Vec2::new(0.0F, 125.0F)
+  debug_inspect(
+    camera.world_to_viewport_2d(
+      camera_transform,
+      vertically_visible,
+      projection,
+      @math.IVec2::new(100, 100),
+      1.0F,
+    )
+    is Some(_),
+    content="true",
+  )
+  debug_inspect(
+    camera.world_to_viewport_2d(
+      camera_transform,
+      vertically_hidden,
+      projection,
+      @math.IVec2::new(100, 100),
+      1.0F,
+    )
+    is Some(_),
+    content="false",
+  )
+
+  app = app.update()
+
+  let frustum = (try! app
+  .world()
+  .get_by_key(entity, @camera_primitives.ecs_key_frustum)).unwrap()
+  let visible_sphere = @camera_primitives.Sphere::new(
+    @math.Vec3::new(vertically_visible.x, vertically_visible.y, 0.0F),
+    1.0F,
+  )
+  let hidden_sphere = @camera_primitives.Sphere::new(
+    @math.Vec3::new(vertically_hidden.x, vertically_hidden.y, 0.0F),
+    1.0F,
+  )
+  debug_inspect(
+    frustum.intersects_sphere(visible_sphere, false),
+    content="true",
+  )
+  debug_inspect(
+    frustum.intersects_sphere(hidden_sphere, false),
+    content="false",
+  )
 }
diff --git a/mgstudio-engine/camera/primitives/aabb_bench_test.mbt b/mgstudio-engine/camera/primitives/aabb_bench_test.mbt
new file mode 100644
index 000000000..d3a6952dd
--- /dev/null
+++ b/mgstudio-engine/camera/primitives/aabb_bench_test.mbt
@@ -0,0 +1,65 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "bench camera primitives: rebuild and compare Aabbs" (b : @bench.T) {
+  let aabb_count = 20_000
+  let aabbs = Array::make(
+    aabb_count,
+    Aabb::from_min_max(@math.Vec3::zero(), @math.Vec3::zero()),
+  )
+  b.bench(name="rebuild and compare Aabbs x20000", count=100U, () => {
+    let mut changed = 0
+    for index in 0..<aabbs.length() {
+      let x = Float::from_int(index)
+      let next = Aabb::from_min_max(
+        @math.Vec3::new(x - 1.0F, -2.0F, 0.0F),
+        @math.Vec3::new(x + 1.0F, 2.0F, 0.0F),
+      )
+      if !aabbs[index].equals(next) {
+        aabbs[index] = next
+        changed = changed + 1
+      }
+    }
+    b.keep(changed)
+  })
+}
+
+///|
+test "bench camera primitives: rebuild and compare scalar Aabbs" (b : @bench.T) {
+  let aabb_count = 20_000
+  let aabbs = Array::make(
+    aabb_count,
+    Aabb::from_min_max_xyz(0.0F, 0.0F, 0.0F, 0.0F, 0.0F, 0.0F),
+  )
+  b.bench(name="rebuild and compare scalar Aabbs x20000", count=100U, () => {
+    let mut changed = 0
+    for index in 0..<aabbs.length() {
+      let x = Float::from_int(index)
+      let next = Aabb::from_min_max_xyz(
+        x - 1.0F,
+        -2.0F,
+        0.0F,
+        x + 1.0F,
+        2.0F,
+        0.0F,
+      )
+      if !aabbs[index].equals(next) {
+        aabbs[index] = next
+        changed = changed + 1
+      }
+    }
+    b.keep(changed)
+  })
+}
diff --git a/mgstudio-engine/camera/primitives/moon.pkg b/mgstudio-engine/camera/primitives/moon.pkg
index 7631ddb38..165fa5b45 100644
--- a/mgstudio-engine/camera/primitives/moon.pkg
+++ b/mgstudio-engine/camera/primitives/moon.pkg
@@ -11,4 +11,8 @@ import {
   "moonbitlang/core/json",
 }
 
+import {
+  "moonbitlang/core/bench",
+} for "test"
+
 supported_targets = "native"
diff --git a/mgstudio-engine/camera/primitives/pkg.generated.mbti b/mgstudio-engine/camera/primitives/pkg.generated.mbti
index ef77647c3..d71d8e78e 100644
--- a/mgstudio-engine/camera/primitives/pkg.generated.mbti
+++ b/mgstudio-engine/camera/primitives/pkg.generated.mbti
@@ -6,6 +6,7 @@ import {
   "Milky2018/mgstudio/ecs",
   "Milky2018/mgstudio/math",
   "Milky2018/mgstudio/mesh",
+  "moonbitlang/core/debug",
   "moonbitlang/core/hashmap",
   "moonbitlang/core/json",
 }
@@ -41,11 +42,24 @@ pub fn update_skinned_mesh_bounds_system(@ecs.World) -> Unit
 
 // Types and methods
 pub struct Aabb {
-  inner : @math.Aabb3d
-}
+  center_x : Float
+  center_y : Float
+  center_z : Float
+  half_extents_x : Float
+  half_extents_y : Float
+  half_extents_z : Float
+} derive(Eq, @debug.Debug)
 pub fn Aabb::center(Self) -> @math.Vec3
+pub fn Aabb::center_x(Self) -> Float
+pub fn Aabb::center_y(Self) -> Float
+pub fn Aabb::center_z(Self) -> Float
+pub fn Aabb::equals(Self, Self) -> Bool
 pub fn Aabb::from_math(@math.Aabb3d) -> Self
 pub fn Aabb::from_min_max(@math.Vec3, @math.Vec3) -> Self
+pub fn Aabb::from_min_max_xyz(Float, Float, Float, Float, Float, Float) -> Self
+pub fn Aabb::half_extents_x(Self) -> Float
+pub fn Aabb::half_extents_y(Self) -> Float
+pub fn Aabb::half_extents_z(Self) -> Float
 pub fn Aabb::half_size(Self) -> @math.Vec3
 pub fn Aabb::to_math(Self) -> @math.Aabb3d
 pub impl @ecs.Component for Aabb
@@ -56,6 +70,7 @@ pub struct CascadesFrusta {
 pub fn CascadesFrusta::CascadesFrusta() -> Self
 pub fn CascadesFrusta::clear(Self) -> Unit
 pub fn CascadesFrusta::get(Self, @core.Entity) -> Array[Frustum]
+pub fn CascadesFrusta::iter(Self) -> Array[(@core.Entity, Array[Frustum])]
 pub fn CascadesFrusta::set(Self, @core.Entity, Array[Frustum]) -> Unit
 pub impl @ecs.Component for CascadesFrusta
 
@@ -89,11 +104,15 @@ pub fn Frustum::view_frustum(Self) -> ViewFrustum
 pub impl @ecs.Component for Frustum
 
 pub struct Sphere {
-  center : @math.Vec3
+  center_x : Float
+  center_y : Float
+  center_z : Float
   radius : Float
 }
 pub fn Sphere::Sphere() -> Self
 pub fn Sphere::center(Self) -> @math.Vec3
+pub fn Sphere::from_xyz(Float, Float, Float, Float) -> Self
+pub fn Sphere::intersects_obb(Self, Aabb, @math.Affine3) -> Bool
 pub fn Sphere::new(@math.Vec3, Float) -> Self
 pub fn Sphere::radius(Self) -> Float
 pub impl @ecs.Component for Sphere
diff --git a/mgstudio-engine/camera/primitives/top.mbt b/mgstudio-engine/camera/primitives/top.mbt
index f432b7bfb..55714f7a4 100644
--- a/mgstudio-engine/camera/primitives/top.mbt
+++ b/mgstudio-engine/camera/primitives/top.mbt
@@ -14,16 +14,27 @@
 
 ///|
 // Bevy source: `bevy/crates/bevy_camera/src/primitives.rs`.
+// Bevy stores two inline Vec3A values. MoonBit value types cannot contain the
+// current reference-typed Vec3, so the same six scalars are flattened here.
 
 ///|
+#valtype
 pub struct Aabb {
-  inner : @math.Aabb3d
-}
+  center_x : Float
+  center_y : Float
+  center_z : Float
+  half_extents_x : Float
+  half_extents_y : Float
+  half_extents_z : Float
+} derive(Eq, Debug)
 
 ///|
 // Bevy source: `bevy/crates/bevy_camera/src/primitives.rs::Sphere`.
+#valtype
 pub struct Sphere {
-  center : @math.Vec3
+  center_x : Float
+  center_y : Float
+  center_z : Float
   radius : Float
 }
 
@@ -71,17 +82,27 @@ pub fn SubCameraView3d::with_offset(
 
 ///|
 pub fn Sphere::Sphere() -> Sphere {
-  Sphere::{ center: @math.Vec3::zero(), radius: 0.0F }
+  Sphere::{ center_x: 0.0F, center_y: 0.0F, center_z: 0.0F, radius: 0.0F }
 }
 
 ///|
 pub fn Sphere::new(center : @math.Vec3, radius : Float) -> Sphere {
-  Sphere::{ center, radius }
+  Sphere::from_xyz(center.x, center.y, center.z, radius)
+}
+
+///|
+pub fn Sphere::from_xyz(
+  center_x : Float,
+  center_y : Float,
+  center_z : Float,
+  radius : Float,
+) -> Sphere {
+  Sphere::{ center_x, center_y, center_z, radius }
 }
 
 ///|
 pub fn Sphere::center(self : Sphere) -> @math.Vec3 {
-  self.center
+  @math.Vec3::new(self.center_x, self.center_y, self.center_z)
 }
 
 ///|
@@ -89,6 +110,38 @@ pub fn Sphere::radius(self : Sphere) -> Float {
   self.radius
 }
 
+///|
+// Bevy source: `bevy/crates/bevy_camera/src/primitives.rs::Sphere::intersects_obb`.
+pub fn Sphere::intersects_obb(
+  self : Sphere,
+  aabb : Aabb,
+  world_from_local : @math.Affine3,
+) -> Bool {
+  let center_x = world_from_local.matrix3.x_axis.x * aabb.center_x +
+    world_from_local.matrix3.y_axis.x * aabb.center_y +
+    world_from_local.matrix3.z_axis.x * aabb.center_z +
+    world_from_local.translation.x
+  let center_y = world_from_local.matrix3.x_axis.y * aabb.center_x +
+    world_from_local.matrix3.y_axis.y * aabb.center_y +
+    world_from_local.matrix3.z_axis.y * aabb.center_z +
+    world_from_local.translation.y
+  let center_z = world_from_local.matrix3.x_axis.z * aabb.center_x +
+    world_from_local.matrix3.y_axis.z * aabb.center_y +
+    world_from_local.matrix3.z_axis.z * aabb.center_z +
+    world_from_local.translation.z
+  let offset_x = center_x - self.center_x
+  let offset_y = center_y - self.center_y
+  let offset_z = center_z - self.center_z
+  let distance_squared = offset_x * offset_x +
+    offset_y * offset_y +
+    offset_z * offset_z
+  let distance = @math.sqrt(distance_squared)
+  let relative_radius = camera_primitives_relative_radius_xyz(
+    aabb, offset_x, offset_y, offset_z, world_from_local,
+  )
+  distance_squared <= self.radius * distance + relative_radius
+}
+
 ///|
 pub type HalfSpace = @math.HalfSpace
 
@@ -321,6 +374,17 @@ pub fn CascadesFrusta::get(
   self.frusta.get(view).unwrap_or([])
 }
 
+///|
+pub fn CascadesFrusta::iter(
+  self : CascadesFrusta,
+) -> Array[(@core.Entity, Array[Frustum])] {
+  let entries : Array[(@core.Entity, Array[Frustum])] = []
+  for view, frusta in self.frusta {
+    entries.push((view, frusta))
+  }
+  entries
+}
+
 ///|
 pub fn CascadesFrusta::set(
   self : CascadesFrusta,
@@ -345,28 +409,39 @@ fn camera_primitives_abs(value : Float) -> Float {
 }
 
 ///|
-fn camera_primitives_relative_radius(
+fn camera_primitives_relative_radius_xyz(
   aabb : Aabb,
-  plane_normal : @math.Vec3,
+  normal_x : Float,
+  normal_y : Float,
+  normal_z : Float,
   world_from_local : @math.Affine3,
 ) -> Float {
-  let half_extents = aabb.half_size()
-  let transformed = @math.Vec3::new(
-    plane_normal.dot(world_from_local.matrix3.x_axis),
-    plane_normal.dot(world_from_local.matrix3.y_axis),
-    plane_normal.dot(world_from_local.matrix3.z_axis),
-  )
-  camera_primitives_abs(transformed.x) * half_extents.x +
-  camera_primitives_abs(transformed.y) * half_extents.y +
-  camera_primitives_abs(transformed.z) * half_extents.z
-}
-
-///|
-fn camera_primitives_signed_distance(
+  let transformed_x = normal_x * world_from_local.matrix3.x_axis.x +
+    normal_y * world_from_local.matrix3.x_axis.y +
+    normal_z * world_from_local.matrix3.x_axis.z
+  let transformed_y = normal_x * world_from_local.matrix3.y_axis.x +
+    normal_y * world_from_local.matrix3.y_axis.y +
+    normal_z * world_from_local.matrix3.y_axis.z
+  let transformed_z = normal_x * world_from_local.matrix3.z_axis.x +
+    normal_y * world_from_local.matrix3.z_axis.y +
+    normal_z * world_from_local.matrix3.z_axis.z
+  camera_primitives_abs(transformed_x) * aabb.half_extents_x +
+  camera_primitives_abs(transformed_y) * aabb.half_extents_y +
+  camera_primitives_abs(transformed_z) * aabb.half_extents_z
+}
+
+///|
+fn camera_primitives_signed_distance_xyz(
   half_space : HalfSpace,
-  point : @math.Vec3,
+  point_x : Float,
+  point_y : Float,
+  point_z : Float,
 ) -> Float {
-  half_space.normal().dot(point) + half_space.d()
+  let normal_d = half_space.normal_d()
+  normal_d.x * point_x +
+  normal_d.y * point_y +
+  normal_d.z * point_z +
+  normal_d.w
 }
 
 ///|
@@ -391,7 +466,12 @@ pub fn Frustum::intersects_sphere(
   }
   for index in 0..<=last {
     let half_space = self.half_spaces[index]
-    if camera_primitives_signed_distance(half_space, sphere.center()) +
+    if camera_primitives_signed_distance_xyz(
+        half_space,
+        sphere.center_x,
+        sphere.center_y,
+        sphere.center_z,
+      ) +
       sphere.radius() <=
       0.0F {
       return false
@@ -409,18 +489,35 @@ pub fn Frustum::intersects_obb(
   intersect_near : Bool,
   intersect_far : Bool,
 ) -> Bool {
-  let center_world = world_from_local.transform_point3(aabb.center())
+  let center_x = world_from_local.matrix3.x_axis.x * aabb.center_x +
+    world_from_local.matrix3.y_axis.x * aabb.center_y +
+    world_from_local.matrix3.z_axis.x * aabb.center_z +
+    world_from_local.translation.x
+  let center_y = world_from_local.matrix3.x_axis.y * aabb.center_x +
+    world_from_local.matrix3.y_axis.y * aabb.center_y +
+    world_from_local.matrix3.z_axis.y * aabb.center_z +
+    world_from_local.translation.y
+  let center_z = world_from_local.matrix3.x_axis.z * aabb.center_x +
+    world_from_local.matrix3.y_axis.z * aabb.center_y +
+    world_from_local.matrix3.z_axis.z * aabb.center_z +
+    world_from_local.translation.z
   for index in 0..<self.half_spaces.length() {
     if (index == VIEW_FRUSTUM_NEAR_PLANE_IDX && !intersect_near) ||
       (index == VIEW_FRUSTUM_FAR_PLANE_IDX && !intersect_far) {
       continue
     }
     let half_space = self.half_spaces[index]
-    let plane_normal = half_space.normal()
-    let relative_radius = camera_primitives_relative_radius(
-      aabb, plane_normal, world_from_local,
+    let normal_d = half_space.normal_d()
+    let relative_radius = camera_primitives_relative_radius_xyz(
+      aabb,
+      normal_d.x,
+      normal_d.y,
+      normal_d.z,
+      world_from_local,
     )
-    if camera_primitives_signed_distance(half_space, center_world) +
+    if camera_primitives_signed_distance_xyz(
+        half_space, center_x, center_y, center_z,
+      ) +
       relative_radius <=
       0.0F {
       return false
@@ -481,27 +578,91 @@ pub impl @ecs.Component for CascadesFrusta with fn component() {
 
 ///|
 pub fn Aabb::from_math(inner : @math.Aabb3d) -> Aabb {
-  Aabb::{ inner, }
+  let center = inner.center()
+  let half_extents = inner.half_size()
+  Aabb::{
+    center_x: center.x,
+    center_y: center.y,
+    center_z: center.z,
+    half_extents_x: half_extents.x,
+    half_extents_y: half_extents.y,
+    half_extents_z: half_extents.z,
+  }
 }
 
 ///|
 pub fn Aabb::to_math(self : Aabb) -> @math.Aabb3d {
-  self.inner
+  @math.Aabb3d::new(self.center(), self.half_size())
+}
+
+///|
+/// Scalar form of Bevy's `Aabb::from_min_max` for allocation-free value paths.
+pub fn Aabb::from_min_max_xyz(
+  min_x : Float,
+  min_y : Float,
+  min_z : Float,
+  max_x : Float,
+  max_y : Float,
+  max_z : Float,
+) -> Aabb {
+  Aabb::{
+    center_x: (max_x + min_x) * 0.5F,
+    center_y: (max_y + min_y) * 0.5F,
+    center_z: (max_z + min_z) * 0.5F,
+    half_extents_x: (max_x - min_x) * 0.5F,
+    half_extents_y: (max_y - min_y) * 0.5F,
+    half_extents_z: (max_z - min_z) * 0.5F,
+  }
 }
 
 ///|
 pub fn Aabb::from_min_max(min : @math.Vec3, max : @math.Vec3) -> Aabb {
-  Aabb::from_math(@math.Aabb3d::from_min_max(min, max))
+  Aabb::from_min_max_xyz(min.x, min.y, min.z, max.x, max.y, max.z)
 }
 
 ///|
 pub fn Aabb::center(self : Aabb) -> @math.Vec3 {
-  self.inner.center()
+  @math.Vec3::new(self.center_x, self.center_y, self.center_z)
+}
+
+///|
+pub fn Aabb::center_x(self : Aabb) -> Float {
+  self.center_x
+}
+
+///|
+pub fn Aabb::center_y(self : Aabb) -> Float {
+  self.center_y
+}
+
+///|
+pub fn Aabb::center_z(self : Aabb) -> Float {
+  self.center_z
 }
 
 ///|
 pub fn Aabb::half_size(self : Aabb) -> @math.Vec3 {
-  self.inner.half_size()
+  @math.Vec3::new(self.half_extents_x, self.half_extents_y, self.half_extents_z)
+}
+
+///|
+pub fn Aabb::half_extents_x(self : Aabb) -> Float {
+  self.half_extents_x
+}
+
+///|
+pub fn Aabb::half_extents_y(self : Aabb) -> Float {
+  self.half_extents_y
+}
+
+///|
+pub fn Aabb::half_extents_z(self : Aabb) -> Float {
+  self.half_extents_z
+}
+
+///|
+pub fn Aabb::equals(self : Aabb, other : Aabb) -> Bool {
+  self == other
 }
 
 ///|
@@ -539,12 +700,7 @@ fn mesh2d_geometry_compute_aabb(geometry : @mesh.Mesh2dGeometry) -> Aabb? {
     }
     index = index + 2
   }
-  Some(
-    Aabb::from_min_max(
-      @math.Vec3::new(min_x, min_y, 0.0F),
-      @math.Vec3::new(max_x, max_y, 0.0F),
-    ),
-  )
+  Some(Aabb::from_min_max_xyz(min_x, min_y, 0.0F, max_x, max_y, 0.0F))
 }
 
 ///|
@@ -581,12 +737,7 @@ fn mesh3d_geometry_compute_aabb(geometry : @mesh.Mesh3dGeometry) -> Aabb? {
       max_z = position.z
     }
   }
-  Some(
-    Aabb::from_min_max(
-      @math.Vec3::new(min_x, min_y, min_z),
-      @math.Vec3::new(max_x, max_y, max_z),
-    ),
-  )
+  Some(Aabb::from_min_max_xyz(min_x, min_y, min_z, max_x, max_y, max_z))
 }
 
 ///|
@@ -636,15 +787,9 @@ fn visibility_write_aabb(
   }
 }
 
-///|
-fn visibility_vec3_eq(lhs : @math.Vec3, rhs : @math.Vec3) -> Bool {
-  lhs.x == rhs.x && lhs.y == rhs.y && lhs.z == rhs.z
-}
-
 ///|
 fn visibility_aabb_eq(lhs : Aabb, rhs : Aabb) -> Bool {
-  visibility_vec3_eq(lhs.center(), rhs.center()) &&
-  visibility_vec3_eq(lhs.half_size(), rhs.half_size())
+  lhs.equals(rhs)
 }
 
 ///|
diff --git a/mgstudio-engine/camera/primitives/visibility_bounds_wbtest.mbt b/mgstudio-engine/camera/primitives/visibility_bounds_wbtest.mbt
index 4ae6b6934..fbd5507e7 100644
--- a/mgstudio-engine/camera/primitives/visibility_bounds_wbtest.mbt
+++ b/mgstudio-engine/camera/primitives/visibility_bounds_wbtest.mbt
@@ -156,3 +156,30 @@ test "camera/primitives: light frusta containers default to Bevy empty shape" {
   cascades.clear()
   debug_inspect(cascades.get(view).length(), content="0")
 }
+
+///|
+test "camera/primitives: Sphere intersects transformed Aabb" {
+  let aabb = Aabb::from_min_max_xyz(
+    -1.0F,
+    -1.0F,
+    -1.0F,
+    1.0F,
+    1.0F,
+    1.0F,
+  )
+  let world_from_local = @math.Affine3::from_translation(
+    @math.Vec3::new(2.0F, 0.0F, 0.0F),
+  )
+  debug_inspect(
+    Sphere::from_xyz(4.0F, 0.0F, 0.0F, 1.0F).intersects_obb(
+      aabb, world_from_local,
+    ),
+    content="true",
+  )
+  debug_inspect(
+    Sphere::from_xyz(7.0F, 0.0F, 0.0F, 1.0F).intersects_obb(
+      aabb, world_from_local,
+    ),
+    content="false",
+  )
+}
diff --git a/mgstudio-engine/camera/visibility/culling_bench_wbtest.mbt b/mgstudio-engine/camera/visibility/culling_bench_wbtest.mbt
new file mode 100644
index 000000000..d108993fc
--- /dev/null
+++ b/mgstudio-engine/camera/visibility/culling_bench_wbtest.mbt
@@ -0,0 +1,50 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "bench camera visibility: cull Aabb grid" (b : @bench.T) {
+  let side = 320
+  let transforms : Array[@transform.GlobalTransform] = []
+  for y in 0..<side {
+    for x in 0..<side {
+      transforms.push(
+        @transform.GlobalTransform::from_transform(
+          @transform.Transform::from_xyz(
+            Float::from_int(x - side / 2) * 64.0F,
+            Float::from_int(y - side / 2) * 64.0F,
+            0.0F,
+          ),
+        ),
+      )
+    }
+  }
+  let frustum = @camera_primitives.Frustum::default_2d()
+  let aabb = @camera_primitives.Aabb::from_min_max_xyz(
+    -32.0F,
+    -32.0F,
+    0.0F,
+    32.0F,
+    32.0F,
+    0.0F,
+  )
+  b.bench(name="cull Aabb grid x102400", count=50U, () => {
+    let mut culled = 0
+    for transform in transforms {
+      if visibility_cull_aabb(frustum, aabb, transform) {
+        culled = culled + 1
+      }
+    }
+    b.keep(culled)
+  })
+}
diff --git a/mgstudio-engine/camera/visibility/moon.pkg b/mgstudio-engine/camera/visibility/moon.pkg
index bdd7d8fb7..5bc6991f3 100644
--- a/mgstudio-engine/camera/visibility/moon.pkg
+++ b/mgstudio-engine/camera/visibility/moon.pkg
@@ -12,4 +12,8 @@ import {
   "moonbitlang/core/hashmap",
 }
 
+import {
+  "moonbitlang/core/bench",
+} for "wbtest"
+
 supported_targets = "native"
diff --git a/mgstudio-engine/camera/visibility/top.mbt b/mgstudio-engine/camera/visibility/top.mbt
index 023e1c534..70da9dc67 100644
--- a/mgstudio-engine/camera/visibility/top.mbt
+++ b/mgstudio-engine/camera/visibility/top.mbt
@@ -23,6 +23,11 @@ let visibility_set_update_skinned_mesh_bounds : @app.SystemSet = @app.system_set
   "mgstudio.camera.visibility.update_skinned_mesh_bounds",
 )
 
+///|
+let camera_update_frusta_systems : @app.SystemSet = @app.system_set(
+  "mgstudio.camera.update_frusta",
+)
+
 ///|
 // Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::VisibleMeshEntities`.
 pub struct VisibleMeshEntities {
@@ -180,11 +185,27 @@ pub impl @ecs.Component for CascadesVisibleEntities with fn component() {
 }
 
 ///|
-fn visibility_radius_vec3(
+fn visibility_radius_aabb(
   world_from_local : @math.Affine3,
-  extents : @math.Vec3,
+  aabb : @camera_primitives.Aabb,
 ) -> Float {
-  world_from_local.matrix3.mul_vec3(extents).length()
+  let half_x = aabb.half_extents_x()
+  let half_y = aabb.half_extents_y()
+  let half_z = aabb.half_extents_z()
+  let transformed_x = world_from_local.matrix3.x_axis.x * half_x +
+    world_from_local.matrix3.y_axis.x * half_y +
+    world_from_local.matrix3.z_axis.x * half_z
+  let transformed_y = world_from_local.matrix3.x_axis.y * half_x +
+    world_from_local.matrix3.y_axis.y * half_y +
+    world_from_local.matrix3.z_axis.y * half_z
+  let transformed_z = world_from_local.matrix3.x_axis.z * half_x +
+    world_from_local.matrix3.y_axis.z * half_y +
+    world_from_local.matrix3.z_axis.z * half_z
+  @math.sqrt(
+    transformed_x * transformed_x +
+    transformed_y * transformed_y +
+    transformed_z * transformed_z,
+  )
 }
 
 ///|
@@ -194,9 +215,23 @@ fn visibility_cull_aabb(
   global_transform : @transform.GlobalTransform,
 ) -> Bool {
   let world_from_local = global_transform.affine()
-  let model_sphere = @camera_primitives.Sphere::new(
-    world_from_local.transform_point3(aabb.center()),
-    visibility_radius_vec3(world_from_local, aabb.half_size()),
+  let center_x = world_from_local.matrix3.x_axis.x * aabb.center_x() +
+    world_from_local.matrix3.y_axis.x * aabb.center_y() +
+    world_from_local.matrix3.z_axis.x * aabb.center_z() +
+    world_from_local.translation.x
+  let center_y = world_from_local.matrix3.x_axis.y * aabb.center_x() +
+    world_from_local.matrix3.y_axis.y * aabb.center_y() +
+    world_from_local.matrix3.z_axis.y * aabb.center_z() +
+    world_from_local.translation.y
+  let center_z = world_from_local.matrix3.x_axis.z * aabb.center_x() +
+    world_from_local.matrix3.y_axis.z * aabb.center_y() +
+    world_from_local.matrix3.z_axis.z * aabb.center_z() +
+    world_from_local.translation.z
+  let model_sphere = @camera_primitives.Sphere::from_xyz(
+    center_x,
+    center_y,
+    center_z,
+    visibility_radius_aabb(world_from_local, aabb),
   )
   !frustum.intersects_sphere(model_sphere, false) ||
   !frustum.intersects_obb(aabb, world_from_local, true, false)
@@ -210,74 +245,41 @@ fn visibility_cull_sphere(
   !frustum.intersects_sphere(sphere, false)
 }
 
+///|
+fn[T] with_optional_table_values(
+  column : @ecs.TableBatchRead[T]?,
+  read : (ArrayView[T]?) -> Unit,
+) -> Unit {
+  match column {
+    Some(column) => column.with_values(fn(values) { read(Some(values)) })
+    None => read(None)
+  }
+}
+
 ///|
 fn check_visibility_visible_entities_system(world : @ecs.World) -> Unit {
-  let visible_rows : Array[
-    (
-      @core.Entity,
-      @root_visibility.InheritedVisibility,
-      @camera_render_layers.RenderLayers,
-      @root_visibility.VisibilityClass?,
-      @camera_primitives.Aabb?,
-      @camera_primitives.Sphere?,
-      @transform.GlobalTransform,
-      Bool,
-      Bool,
-    ),
-  ] = []
   let visible_query : @ecs.Query[
     (
       @core.Entity,
       (
-        @ecs.Read[@root_visibility.InheritedVisibility],
+        @ecs.ReadValue[@root_visibility.InheritedVisibility],
         @ecs.Write[@root_visibility.ViewVisibility],
         @ecs.Optional[@root_visibility.VisibilityClass],
         @ecs.Optional[@camera_render_layers.RenderLayers],
         @ecs.Optional[@camera_primitives.Aabb],
         @ecs.Optional[@camera_primitives.Sphere],
-        @ecs.Read[@transform.GlobalTransform],
+        @ecs.ReadValue[@transform.GlobalTransform],
       ),
       (
         @ecs.Has[@root_visibility.NoFrustumCulling],
-        @ecs.Has[@root_visibility.NoCpuCulling],
         @ecs.Has[@root_visibility.VisibilityRange],
       ),
     ),
-    @ecs.All,
-  ] = @ecs.query(world)
-  try! visible_query.view(fn(_query_entity, data) {
-    let (
-      entity,
-      (
-        inherited_visibility,
-        _view_visibility,
-        visibility_class,
-        render_layers,
-        aabb,
-        sphere,
-        global_transform,
-      ),
-      (no_frustum_culling, no_cpu_culling, has_visibility_range),
-    ) = data
-    if no_cpu_culling.present() {
-      return
-    }
-    visible_rows.push(
-      (
-        entity,
-        inherited_visibility.value(),
-        render_layers
-        .value()
-        .unwrap_or(@camera_render_layers.RenderLayers::RenderLayers()),
-        visibility_class.value(),
-        aabb.value(),
-        sphere.value(),
-        global_transform.value(),
-        no_frustum_culling.present(),
-        has_visibility_range.present(),
-      ),
-    )
-  })
+    @ecs.Without[@root_visibility.NoCpuCulling],
+  ] = @ecs.query_filtered(
+    world,
+    @ecs.Without::new(@root_visibility.ecs_key_no_cpu_culling),
+  )
   let visible_entity_ranges = world.get_resource(ecs_key_visible_entity_ranges)
   let view_query : @ecs.Query[
     (
@@ -285,8 +287,8 @@ fn check_visibility_visible_entities_system(world : @ecs.World) -> Unit {
       (
         @ecs.Write[@camera_camera.VisibleEntities],
         @ecs.Optional[@camera_render_layers.RenderLayers],
-        @ecs.Read[@camera_camera.Camera],
-        @ecs.Read[@camera_primitives.Frustum],
+        @ecs.ReadValue[@camera_camera.Camera],
+        @ecs.ReadValue[@camera_primitives.Frustum],
         @ecs.Has[@root_visibility.NoCpuCulling],
       ),
     ),
@@ -302,82 +304,120 @@ fn check_visibility_visible_entities_system(world : @ecs.World) -> Unit {
     }
     let view_mask = view_layers
       .value()
-      .unwrap_or(@camera_render_layers.RenderLayers::RenderLayers())
-    let accepted : Array[(@core.Entity, Int)] = []
-    for row in visible_rows {
-      let (
-        entity,
-        inherited_visibility,
-        entity_layers,
-        visibility_class,
-        aabb,
-        sphere,
-        global_transform,
-        no_frustum_culling,
-        has_visibility_range,
-      ) = row
-      if !inherited_visibility.get() {
-        continue
-      }
-      if !view_mask.intersects(entity_layers) {
-        continue
-      }
-      if has_visibility_range {
-        match visible_entity_ranges {
-          Some(ranges) =>
-            if !ranges.entity_is_in_range_of_view(entity, view_entity) {
-              continue
-            }
-          None => continue
-        }
-      }
-      if !no_frustum_culling && !no_cpu_culling_camera.present() {
-        match aabb {
-          Some(model_aabb) =>
-            if visibility_cull_aabb(
-                frustum.value(),
-                model_aabb,
-                global_transform,
-              ) {
-              continue
-            }
-          None =>
-            match sphere {
-              Some(model_sphere) =>
-                if visibility_cull_sphere(frustum.value(), model_sphere) {
-                  continue
-                }
-              None => ()
-            }
-        }
-      }
-      match visibility_class {
-        Some(classes) =>
-          for class_id in classes.iter() {
-            accepted.push((entity, class_id))
-          }
-        None => ()
-      }
-    }
+      .unwrap_or(@camera_render_layers.default_layers)
     visible_entities.modify(fn(value) {
       value.clear_all()
-      for item in accepted {
-        let (entity, class_id) = item
-        value.push(entity, class_id)
-      }
+      try! visible_query.for_each_table(fn(batch) {
+        let inherited_visibility = batch
+          .read(@root_visibility.ecs_key_inherited_visibility)
+          .unwrap()
+        let view_visibility = batch
+          .write(@root_visibility.ecs_key_view_visibility)
+          .unwrap()
+        let visibility_class = batch.read(
+          @root_visibility.ecs_key_visibility_class,
+        )
+        let render_layers = batch.read(
+          @camera_render_layers.ecs_key_render_layers,
+        )
+        let aabb = batch.read(@camera_primitives.ecs_key_aabb)
+        let sphere = batch.read(@camera_primitives.ecs_key_sphere)
+        let global_transform = batch
+          .read(@transform.ecs_key_global_transform)
+          .unwrap()
+        let no_frustum_culling = batch.has(
+          @root_visibility.ecs_key_no_frustum_culling,
+        )
+        let has_visibility_range = batch.has(
+          @root_visibility.ecs_key_visibility_range,
+        )
+        batch.with_entities(fn(entities) {
+          with_optional_table_values(visibility_class, fn(visibility_classes) {
+            with_optional_table_values(render_layers, fn(render_layer_values) {
+              with_optional_table_values(aabb, fn(aabbs) {
+                with_optional_table_values(sphere, fn(spheres) {
+                  inherited_visibility.with_values(fn(inherited_values) {
+                    global_transform.with_values(fn(global_transforms) {
+                      for row_index in 0..<inherited_values.length() {
+                        if !inherited_values[row_index].get() {
+                          continue
+                        }
+                        let entity_layers = match render_layer_values {
+                          Some(values) => values[row_index]
+                          None => @camera_render_layers.default_layers
+                        }
+                        if !view_mask.intersects(entity_layers) {
+                          continue
+                        }
+                        let entity = entities[row_index]
+                        if has_visibility_range {
+                          match visible_entity_ranges {
+                            Some(ranges) =>
+                              if !ranges.entity_is_in_range_of_view(
+                                  entity, view_entity,
+                                ) {
+                                continue
+                              }
+                            None => ()
+                          }
+                        }
+                        if !no_frustum_culling &&
+                          !no_cpu_culling_camera.present() {
+                          match aabbs {
+                            Some(values) =>
+                              if visibility_cull_aabb(
+                                  frustum.value(),
+                                  values[row_index],
+                                  global_transforms[row_index],
+                                ) {
+                                continue
+                              }
+                            None =>
+                              match spheres {
+                                Some(values) =>
+                                  if visibility_cull_sphere(
+                                      frustum.value(),
+                                      values[row_index],
+                                    ) {
+                                    continue
+                                  }
+                                None => ()
+                              }
+                          }
+                        }
+                        let current_visibility = view_visibility.peek(row_index)
+                        if !current_visibility.get() {
+                          if current_visibility.was_visible_now_hidden() {
+                            view_visibility.bypass_change_detection(row_index, fn(
+                              _value,
+                            ) {
+                              @root_visibility.ViewVisibility::visible()
+                            })
+                          } else {
+                            view_visibility.set(
+                              row_index,
+                              @root_visibility.ViewVisibility::new(true),
+                            )
+                          }
+                        }
+                        match visibility_classes {
+                          Some(values) =>
+                            for class_id in values[row_index].iter() {
+                              value.push(entity, class_id)
+                            }
+                          None => ()
+                        }
+                      }
+                    })
+                  })
+                })
+              })
+            })
+          })
+        })
+      })
       value.sort_all()
     })
-    for item in accepted {
-      let (entity, _class_id) = item
-      let view_visibility = (try! world.get_by_key(
-        entity, @root_visibility.ecs_key_view_visibility,
-      )).unwrap()
-      view_visibility.set_visible()
-      try! (world.replace(
-        entity, @root_visibility.ecs_key_view_visibility, view_visibility,
-      )
-      |> ignore)
-    }
   })
 }
 
@@ -401,6 +441,11 @@ pub fn visibility_plugin_with(
 ) -> @app.App[@ecs.World] {
   ignore(plugin)
   @root_visibility.visibility_plugin(app)
+  .configure_set(
+    @app.PostUpdate,
+    @root_visibility.visibility_set_check_visibility,
+    after=[camera_update_frusta_systems],
+  )
   .configure_set(
     @app.PostUpdate,
     @root_visibility.visibility_set_calculate_bounds,
diff --git a/mgstudio-engine/camera/visibility/visible_entities_wbtest.mbt b/mgstudio-engine/camera/visibility/visible_entities_wbtest.mbt
index 4f3ccabf2..030fa74e5 100644
--- a/mgstudio-engine/camera/visibility/visible_entities_wbtest.mbt
+++ b/mgstudio-engine/camera/visibility/visible_entities_wbtest.mbt
@@ -19,6 +19,7 @@ test "camera visibility: check visibility fills camera VisibleEntities by visibi
   let camera = world.spawn()
   let visible_mesh = world.spawn()
   let hidden_layer_mesh = world.spawn()
+  let newly_visible_mesh = world.spawn()
   let mesh3d_class = 123456
   try! world.set_by_key(
     camera,
@@ -30,17 +31,12 @@ test "camera visibility: check visibility fills camera VisibleEntities by visibi
     @camera_camera.ecs_key_visible_entities,
     @camera_camera.VisibleEntities::VisibleEntities(),
   )
-  try! world.set_by_key(
-    camera,
-    @camera_render_layers.ecs_key_render_layers,
-    @camera_render_layers.RenderLayers::layer(0),
-  )
   try! world.set_by_key(
     camera,
     @camera_primitives.ecs_key_frustum,
     @camera_primitives.Frustum::default_2d(),
   )
-  for entity in [visible_mesh, hidden_layer_mesh] {
+  for entity in [visible_mesh, hidden_layer_mesh, newly_visible_mesh] {
     try! world.set_by_key(
       entity,
       @root_visibility.ecs_key_inherited_visibility,
@@ -71,23 +67,38 @@ test "camera visibility: check visibility fills camera VisibleEntities by visibi
     )
   }
   try! world.set_by_key(
-    visible_mesh,
+    hidden_layer_mesh,
     @camera_render_layers.ecs_key_render_layers,
-    @camera_render_layers.RenderLayers::layer(0),
+    @camera_render_layers.RenderLayers::layer(1),
   )
   try! world.set_by_key(
-    hidden_layer_mesh,
+    newly_visible_mesh,
     @camera_render_layers.ecs_key_render_layers,
-    @camera_render_layers.RenderLayers::layer(1),
+    @camera_render_layers.RenderLayers::layer(0),
   )
+  try! (world.replace(
+    visible_mesh,
+    @root_visibility.ecs_key_view_visibility,
+    @root_visibility.ViewVisibility::visible(),
+  ) |> ignore)
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+  let view_visibility = (try! world.get_mut(
+    visible_mesh, key=@root_visibility.ecs_key_view_visibility,
+  )).unwrap()
+  view_visibility.bypass_change_detection(fn(value) { value.advance_frame() })
 
   check_visibility_visible_entities_system(world)
 
   let visible_entities = (try! world.get_by_key(
     camera, @camera_camera.ecs_key_visible_entities,
   )).unwrap()
-  debug_inspect(visible_entities.len(mesh3d_class), content="1")
+  debug_inspect(visible_entities.len(mesh3d_class), content="2")
   debug_inspect(visible_entities.get(mesh3d_class)[0].id, content="1")
+  debug_inspect(visible_entities.get(mesh3d_class)[1].id, content="3")
   debug_inspect(
     (try! world.get_by_key(
       visible_mesh, @root_visibility.ecs_key_view_visibility,
@@ -96,6 +107,14 @@ test "camera visibility: check visibility fills camera VisibleEntities by visibi
     .is_visible(),
     content="true",
   )
+  let changed = world
+    .changed_components(
+      @root_visibility.ecs_key_view_visibility,
+      @core.SystemTicks::new(1, 2),
+    )
+    .read()
+  debug_inspect(changed.contains(visible_mesh), content="false")
+  debug_inspect(changed.contains(newly_visible_mesh), content="true")
 }
 
 ///|
diff --git a/mgstudio-engine/core/duration.mbt b/mgstudio-engine/core/duration.mbt
index dc8c8d54a..17a714261 100644
--- a/mgstudio-engine/core/duration.mbt
+++ b/mgstudio-engine/core/duration.mbt
@@ -25,6 +25,7 @@ const NANOS_PER_SEC : Int64 = 1_000_000_000L
 const DURATION_MAX_NANOS : Int64 = 9_223_372_036_854_775_807L
 
 ///|
+#valtype
 pub struct Duration {
   nanos : Int64
 } derive(Eq, Debug, ToJson, FromJson)
diff --git a/mgstudio-engine/core_pipeline/mip_generation/moon.pkg b/mgstudio-engine/core_pipeline/mip_generation/moon.pkg
index b103dad83..8519f0416 100644
--- a/mgstudio-engine/core_pipeline/mip_generation/moon.pkg
+++ b/mgstudio-engine/core_pipeline/mip_generation/moon.pkg
@@ -12,7 +12,7 @@ import {
   "Milky2018/mgstudio/shader",
   "Milky2018/mgstudio/shader/compile" @shader_compile,
   "Milky2018/mgstudio/shader/source" @shader_source,
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
   "Milky2018/wgpu_mbt" @wgpu,
 }
 
diff --git a/mgstudio-engine/core_pipeline/skybox/top.mbt b/mgstudio-engine/core_pipeline/skybox/top.mbt
index 0132db855..5609dd5ff 100644
--- a/mgstudio-engine/core_pipeline/skybox/top.mbt
+++ b/mgstudio-engine/core_pipeline/skybox/top.mbt
@@ -616,13 +616,19 @@ fn skybox_pipeline_state_mut_or_init(
 fn extracted_skyboxes_mut_or_init(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[ExtractedSkyboxes] {
-  if world.get_resource(ExtractedSkyboxes::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]),
+    )
+    is None {
     world.insert_resource(
-      ExtractedSkyboxes::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]),
       ExtractedSkyboxes::ExtractedSkyboxes(),
     )
   }
-  match world.get_resource_mut(ExtractedSkyboxes::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]),
+    ) {
     Some(value) => value
     None => abort("Missing ExtractedSkyboxes resource")
   }
@@ -753,9 +759,11 @@ fn configure_skybox_render_sub_app(
       SkyboxPipelineState::SkyboxPipelineState(),
     )
   }
-  if !world.resource(ExtractedSkyboxes::resource()).is_present() {
+  if !world
+    .resource((@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]))
+    .is_present() {
     world.insert_resource(
-      ExtractedSkyboxes::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]),
       ExtractedSkyboxes::ExtractedSkyboxes(),
     )
   }
@@ -806,7 +814,7 @@ fn extract_skybox(world : @ecs.World) -> Unit {
       )
       try! world.set_by_key(
         render_entity_ref.value().id(),
-        SkyboxUniforms::component(),
+        (@ecs.Component::component() : @ecs.ComponentKey[SkyboxUniforms]),
         uniforms,
       )
       extracted.push(
@@ -837,7 +845,10 @@ fn prepare_skybox_pipelines(world : @ecs.World) -> Unit {
     })
     return
   }
-  match world.get_resource(ExtractedSkyboxes::resource()) {
+  match
+    world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]),
+    ) {
     Some(extracted) => {
       remove_stale_skybox_pipeline_components(world, extracted)
       for entry in extracted.entries {
@@ -879,7 +890,10 @@ fn prepare_skybox_pipelines(world : @ecs.World) -> Unit {
 ///|
 fn prepare_skybox_bind_groups(world : @ecs.World) -> Unit {
   let mut bind_group_count = 0
-  match world.get_resource(ExtractedSkyboxes::resource()) {
+  match
+    world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ExtractedSkyboxes]),
+    ) {
     Some(extracted) => {
       remove_stale_skybox_bind_group_components(world, extracted)
       for entry in extracted.entries {
diff --git a/mgstudio-engine/ecs/README.md b/mgstudio-engine/ecs/README.md
index b058e99c2..a0eca0553 100644
--- a/mgstudio-engine/ecs/README.md
+++ b/mgstudio-engine/ecs/README.md
@@ -224,6 +224,10 @@ mutable fields, so mgstudio treats read access as an API contract:
   component messages, or changed resource ticks must go through `Write[T]`,
   `ResourceMut[T]`, `EntityMut` write methods, or explicit world set/update
   APIs.
+- `Write::bypass_change_detection` replaces a component without updating its
+  change tick or sending changed-component messages. It is reserved for
+  source-owned internal bookkeeping whose mutation is not a semantic component
+  change; ordinary component writes must not use it.
 - Fetching a mutable-capable handle does not mark a value changed by itself.
   The change tick advances only when the caller invokes a write method such as
   `Write::set`, `Write::modify`, `ResourceMut::set`, `ResourceMut::modify`,
diff --git a/mgstudio-engine/ecs/archetype.mbt b/mgstudio-engine/ecs/archetype.mbt
index 9c37c8561..dd7dc2fdf 100644
--- a/mgstudio-engine/ecs/archetype.mbt
+++ b/mgstudio-engine/ecs/archetype.mbt
@@ -166,59 +166,6 @@ fn archetype_insert_sorted_unique_by_binary_search(
   true
 }
 
-///|
-fn archetype_check_single_add(
-  current_component_local_ids : Array[Int],
-  previous_component_local_ids : Array[Int],
-  previous_presence : @utils.IntBitSet,
-) -> Int? {
-  let mut added_component_local_id : Int? = None
-  for component_local_id in current_component_local_ids {
-    if !previous_presence.contains(component_local_id) {
-      match added_component_local_id {
-        Some(_) => return None
-        None => added_component_local_id = Some(component_local_id)
-      }
-    }
-  }
-  guard added_component_local_id is Some(component_local_id) else {
-    return None
-  }
-  if current_component_local_ids.length() !=
-    previous_component_local_ids.length() + 1 {
-    return None
-  }
-  Some(component_local_id)
-}
-
-///|
-fn archetype_check_single_remove(
-  current_component_local_ids : Array[Int],
-  previous_component_local_ids : Array[Int],
-  previous_presence : @utils.IntBitSet,
-  current_presence : @utils.IntBitSet,
-) -> Int? {
-  if previous_component_local_ids.length() !=
-    current_component_local_ids.length() + 1 {
-    return None
-  }
-  for component_local_id in current_component_local_ids {
-    if !previous_presence.contains(component_local_id) {
-      return None
-    }
-  }
-  let mut removed_component_local_id : Int? = None
-  for component_local_id in previous_component_local_ids {
-    if !current_presence.contains(component_local_id) {
-      match removed_component_local_id {
-        Some(_) => return None
-        None => removed_component_local_id = Some(component_local_id)
-      }
-    }
-  }
-  removed_component_local_id
-}
-
 ///|
 fn archetype_insert_sorted_unique(ids : Array[Int], archetype_id : Int) -> Bool {
   if ids.length() == 0 || ids[ids.length() - 1] < archetype_id {
@@ -433,15 +380,6 @@ fn World::ensure_entity_archetype_capacity(
   while self.entity_storage.entity_archetype_ids.length() <= entity_id {
     self.entity_storage.entity_archetype_ids.push(-1)
   }
-  while self.entity_storage.entity_component_local_ids.length() <= entity_id {
-    self.entity_storage.entity_component_local_ids.push([])
-  }
-  while self.entity_storage.entity_component_local_id_presence.length() <=
-        entity_id {
-    self.entity_storage.entity_component_local_id_presence.push(
-      @utils.IntBitSet::new(),
-    )
-  }
   while self.entity_storage.entity_table_ids.length() <= entity_id {
     self.entity_storage.entity_table_ids.push(-1)
   }
@@ -982,6 +920,7 @@ fn World::swap_remove_entity_from_table(
   self : World,
   entity : @core.Entity,
   table_id : Int,
+  target_component_local_ids : Array[Int],
 ) -> Unit {
   guard self.entity_table_row(entity) is Some(row) else {
     if entity.id >= 0 &&
@@ -996,7 +935,7 @@ fn World::swap_remove_entity_from_table(
     self.entity_storage.entity_table_rows[entity.id] = -1
     return
   }
-  match table_ref.swap_remove_row(self, row) {
+  match table_ref.swap_remove_row(self, row, target_component_local_ids) {
     Some(result) => {
       if result.swapped_entity is Some(swapped_entity) &&
         result.swapped_row is Some(swapped_row) {
@@ -1047,8 +986,7 @@ fn World::bundle_migrate_new_archetype_new_table(
   } else {
     []
   }
-  let target_row = if to_table_id >= 0 &&
-    target_component_local_ids.length() > 0 {
+  let target_row = if to_table_id >= 0 {
     let appended_row = match
       self
       .ensure_table_storage(to_table_id)
@@ -1066,7 +1004,9 @@ fn World::bundle_migrate_new_archetype_new_table(
     None
   }
   if from_table_id >= 0 {
-    self.swap_remove_entity_from_table(entity, from_table_id)
+    self.swap_remove_entity_from_table(
+      entity, from_table_id, target_component_local_ids,
+    )
   } else if entity.id >= 0 &&
     entity.id < self.entity_storage.entity_table_rows.length() {
     self.entity_storage.entity_table_ids[entity.id] = -1
@@ -1081,8 +1021,7 @@ fn World::bundle_migrate_new_archetype_new_table(
   } else {
     self.entity_storage.entity_archetype_rows[entity.id] = -1
   }
-  self.entity_storage.entity_table_ids[entity.id] = if to_table_id >= 0 &&
-    target_component_local_ids.length() > 0 {
+  self.entity_storage.entity_table_ids[entity.id] = if to_table_id >= 0 {
     to_table_id
   } else {
     -1
@@ -1189,23 +1128,10 @@ fn World::entity_local_components(
   self : World,
   entity : @core.Entity,
 ) -> Array[Int] {
-  if entity.id < 0 ||
-    entity.id >= self.entity_storage.entity_component_local_ids.length() {
+  guard self.entity_archetype_id(entity) is Some(archetype_id) else {
     return []
   }
-  self.entity_storage.entity_component_local_ids[entity.id]
-}
-
-///|
-fn World::entity_component_local_presence(
-  self : World,
-  entity : @core.Entity,
-) -> @utils.IntBitSet? {
-  if entity.id < 0 ||
-    entity.id >= self.entity_storage.entity_component_local_id_presence.length() {
-    return None
-  }
-  Some(self.entity_storage.entity_component_local_id_presence[entity.id])
+  self.archetype_component_local_ids.get(archetype_id).unwrap_or([])
 }
 
 ///|
@@ -1214,27 +1140,15 @@ fn World::entity_has_component_local_id(
   entity : @core.Entity,
   component_local_id : Int,
 ) -> Bool {
-  match self.entity_component_local_presence(entity) {
+  guard self.entity_archetype_id(entity) is Some(archetype_id) else {
+    return false
+  }
+  match self.archetype_component_local_id_presence.get(archetype_id) {
     Some(presence) => presence.contains(component_local_id)
     None => false
   }
 }
 
-///|
-fn World::entity_replace_component_local_ids_without_membership_update(
-  self : World,
-  entity : @core.Entity,
-  component_local_ids : Array[Int],
-) -> Unit {
-  self.ensure_entity_archetype_capacity(entity.id)
-  self.entity_storage.entity_component_local_ids[entity.id] = component_local_ids.copy()
-  let presence = self.entity_storage.entity_component_local_id_presence[entity.id]
-  presence.clear()
-  for component_local_id in component_local_ids {
-    presence.insert(component_local_id)
-  }
-}
-
 ///|
 fn World::initialize_entity_archetype_tracking(
   self : World,
@@ -1242,7 +1156,6 @@ fn World::initialize_entity_archetype_tracking(
 ) -> Unit {
   self.ensure_entity_archetype_capacity(entity.id)
   let previous_archetype_id = self.entity_storage.entity_archetype_ids[entity.id]
-  self.entity_replace_component_local_ids_without_membership_update(entity, [])
   ignore(
     self.migrate_entity_bundle(
       entity,
@@ -1263,7 +1176,7 @@ fn World::clear_entity_archetype_tracking(
     return
   }
   let previous_archetype_id = self.entity_storage.entity_archetype_ids[entity.id]
-  let component_local_ids = self.entity_storage.entity_component_local_ids[entity.id]
+  let component_local_ids = self.entity_local_components(entity)
   for component_local_id in component_local_ids {
     self.decrement_component_membership_count_local(component_local_id)
     self.bump_component_membership_generation_local(component_local_id)
@@ -1276,56 +1189,22 @@ fn World::clear_entity_archetype_tracking(
       component_write_set_new(),
     ),
   )
-  self.entity_replace_component_local_ids_without_membership_update(entity, [])
 }
 
 ///|
-fn World::entity_add_component_local_id(
+fn World::record_entity_component_added_local_id(
   self : World,
-  entity : @core.Entity,
   component_local_id : Int,
 ) -> Unit {
-  self.ensure_entity_archetype_capacity(entity.id)
-  let component_local_ids = self.entity_storage.entity_component_local_ids[entity.id]
-  if !self.entity_storage.entity_component_local_id_presence[entity.id].contains(
-      component_local_id,
-    ) {
-    component_local_ids.push(component_local_id)
-    self.entity_storage.entity_component_local_id_presence[entity.id].insert(
-      component_local_id,
-    )
-    self.increment_component_membership_count_local(component_local_id)
-    self.bump_component_membership_generation_local(component_local_id)
-  }
+  self.increment_component_membership_count_local(component_local_id)
+  self.bump_component_membership_generation_local(component_local_id)
 }
 
 ///|
-fn World::entity_remove_component_local_id(
+fn World::record_entity_component_removed_local_id(
   self : World,
-  entity : @core.Entity,
   component_local_id : Int,
 ) -> Unit {
-  if entity.id < 0 ||
-    entity.id >= self.entity_storage.entity_component_local_ids.length() {
-    return
-  }
-  let component_local_ids = self.entity_storage.entity_component_local_ids[entity.id]
-  let mut remove_index : Int? = None
-  for index in 0..<component_local_ids.length() {
-    if component_local_ids[index] == component_local_id {
-      remove_index = Some(index)
-      break
-    }
-  }
-  guard remove_index is Some(index) else { return }
-  let last_index = component_local_ids.length() - 1
-  if index != last_index {
-    component_local_ids[index] = component_local_ids[last_index]
-  }
-  ignore(component_local_ids.pop())
-  self.entity_storage.entity_component_local_id_presence[entity.id].remove(
-    component_local_id,
-  )
   self.decrement_component_membership_count_local(component_local_id)
   self.bump_component_membership_generation_local(component_local_id)
 }
@@ -1342,9 +1221,7 @@ fn World::refresh_entity_archetype_with_bundle_info(
   }
   self.ensure_entity_archetype_capacity(entity.id)
   let previous_archetype_id = self.entity_storage.entity_archetype_ids[entity.id]
-  let current_component_local_ids = self.entity_local_components(entity)
   let mut next_archetype_id : Int? = None
-  let mut normalized_components : Array[Int]? = None
   match bundle_info {
     Some(bundle_info) if previous_archetype_id >= 0 =>
       if archetype_bundle_info_covers_component_writes(
@@ -1360,63 +1237,33 @@ fn World::refresh_entity_archetype_with_bundle_info(
   }
   if next_archetype_id is None &&
     previous_archetype_id >= 0 &&
-    self.archetype_component_local_ids.get(previous_archetype_id)
-    is Some(previous_component_local_ids) {
-    let previous_len = previous_component_local_ids.length()
-    let current_len = current_component_local_ids.length()
+    component_writes.entries.length() == 1 {
+    next_archetype_id = Some(
+      self.ensure_archetype_add_edge_target(
+        previous_archetype_id,
+        component_writes.entries[0].local_component_id,
+      ),
+    )
+  }
+  if next_archetype_id is None {
+    let previous_component_local_ids = self.archetype_component_local_ids
+      .get(previous_archetype_id)
+      .unwrap_or([])
     let previous_presence = self.archetype_component_local_id_presence
       .get(previous_archetype_id)
       .unwrap_or(@utils.IntBitSet::new())
-    let current_presence = self.entity_storage.entity_component_local_id_presence[entity.id]
-    if current_len == previous_len + 1 {
-      match
-        archetype_check_single_add(
-          current_component_local_ids, previous_component_local_ids, previous_presence,
-        ) {
-        Some(component_local_id) =>
-          next_archetype_id = Some(
-            self.ensure_archetype_add_edge_target(
-              previous_archetype_id, component_local_id,
-            ),
-          )
-        None => ()
-      }
-    } else if previous_len == current_len + 1 {
-      match
-        archetype_check_single_remove(
-          current_component_local_ids, previous_component_local_ids, previous_presence,
-          current_presence,
-        ) {
-        Some(component_local_id) =>
-          next_archetype_id = Some(
-            self.ensure_archetype_remove_edge_target(
-              previous_archetype_id, component_local_id,
-            ),
-          )
-        None => ()
-      }
+    let added_component_local_ids : Array[Int] = []
+    for entry in component_writes.entries {
+      added_component_local_ids.push(entry.local_component_id)
     }
-  }
-  if next_archetype_id is None {
-    let normalized = archetype_sorted_unique_local_component_ids(
-      current_component_local_ids,
+    let target_component_local_ids = archetype_union_sorted_unique_local_component_ids_with_presence(
+      previous_component_local_ids, previous_presence, added_component_local_ids,
     )
-    normalized_components = Some(normalized)
     next_archetype_id = Some(
-      self.ensure_archetype_for_local_components(normalized),
+      self.ensure_archetype_for_local_components(target_component_local_ids),
     )
   }
   guard next_archetype_id is Some(next_archetype_id) else { return }
-  if self.archetype_component_local_ids.get(next_archetype_id)
-    is Some(next_component_local_ids) {
-    self.entity_replace_component_local_ids_without_membership_update(
-      entity, next_component_local_ids,
-    )
-  } else if normalized_components is Some(normalized) {
-    self.entity_replace_component_local_ids_without_membership_update(
-      entity, normalized,
-    )
-  }
   ignore(
     self.migrate_entity_bundle(
       entity, previous_archetype_id, next_archetype_id, component_writes,
@@ -1459,19 +1306,6 @@ fn World::refresh_entity_archetype_after_component_remove(
   let next_archetype_id = self.ensure_archetype_remove_edge_target(
     previous_archetype_id, removed_component_local_id,
   )
-  if self.archetype_component_local_ids.get(next_archetype_id)
-    is Some(next_component_local_ids) {
-    self.entity_replace_component_local_ids_without_membership_update(
-      entity, next_component_local_ids,
-    )
-  } else {
-    self.entity_replace_component_local_ids_without_membership_update(
-      entity,
-      archetype_sorted_unique_local_component_ids(
-        self.entity_local_components(entity),
-      ),
-    )
-  }
   ignore(
     self.migrate_entity_bundle(
       entity,
diff --git a/mgstudio-engine/ecs/change_location_wbtest.mbt b/mgstudio-engine/ecs/change_location_wbtest.mbt
new file mode 100644
index 000000000..5c6b90e2f
--- /dev/null
+++ b/mgstudio-engine/ecs/change_location_wbtest.mbt
@@ -0,0 +1,89 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+enum ChangeLocationMarker {
+  Marker
+}
+
+///|
+let change_location_marker_key : ComponentKey[ChangeLocationMarker] = register_component(
+  debug_name="change_location_marker",
+)
+
+///|
+pub impl Component for ChangeLocationMarker with fn component() {
+  change_location_marker_key
+}
+
+///|
+fn change_location_marker_column(
+  world : World,
+  entity : @core.Entity,
+) -> RawTableColumn {
+  let local_component_id = world
+    .local_component_id(change_location_marker_key.id())
+    .unwrap()
+  let (table_id, _row_index) = world.entity_table_location(entity).unwrap()
+  world.table_storage(table_id).unwrap().column(local_component_id).unwrap()
+}
+
+///|
+test "ecs change locations: default omits storage and opt-in records caller" {
+  let default_world = World::new()
+  defer default_world.close()
+  let default_entity = default_world.spawn()
+  try! default_world.set_by_key(
+    default_entity,
+    change_location_marker_key,
+    ChangeLocationMarker::Marker,
+  )
+  debug_inspect(
+    change_location_marker_column(default_world, default_entity).storage.changed_caller_ids
+    is None,
+    content="true",
+  )
+  debug_inspect(
+    try! (default_world
+    .get_mut(default_entity, key=change_location_marker_key)
+    .unwrap()
+    .changed_by()
+    is None),
+    content="true",
+  )
+
+  let tracked_world = World::new(track_change_locations=true)
+  defer tracked_world.close()
+  let tracked_entity = tracked_world.spawn()
+  try! tracked_world.set_by_key(
+    tracked_entity,
+    change_location_marker_key,
+    ChangeLocationMarker::Marker,
+  )
+  debug_inspect(
+    change_location_marker_column(tracked_world, tracked_entity).storage.changed_caller_ids
+    .unwrap()
+    .length(),
+    content="1",
+  )
+  debug_inspect(
+    try! tracked_world
+    .get_mut(tracked_entity, key=change_location_marker_key)
+    .unwrap()
+    .changed_by()
+    .unwrap()
+    .contains("change_location_wbtest.mbt"),
+    content="true",
+  )
+}
diff --git a/mgstudio-engine/ecs/changed_components.mbt b/mgstudio-engine/ecs/changed_components.mbt
index 715a61e73..2de2d108d 100644
--- a/mgstudio-engine/ecs/changed_components.mbt
+++ b/mgstudio-engine/ecs/changed_components.mbt
@@ -14,29 +14,31 @@
 
 ///|
 pub struct ChangedComponents[_] {
-  priv reader : @core.MessageReader[@core.Entity]
+  priv entities : Array[@core.Entity]
 }
 
 ///|
 pub fn[T] ChangedComponents::read(
   self : ChangedComponents[T],
 ) -> Array[@core.Entity] {
-  self.reader.read()
+  let entities = self.entities.copy()
+  self.entities.clear()
+  entities
 }
 
 ///|
 pub fn[T] ChangedComponents::len(self : ChangedComponents[T]) -> Int {
-  self.reader.len()
+  self.entities.length()
 }
 
 ///|
 pub fn[T] ChangedComponents::is_empty(self : ChangedComponents[T]) -> Bool {
-  self.reader.is_empty()
+  self.entities.is_empty()
 }
 
 ///|
 pub fn[T] ChangedComponents::clear(self : ChangedComponents[T]) -> Unit {
-  self.reader.clear()
+  self.entities.clear()
 }
 
 ///|
@@ -45,11 +47,16 @@ pub fn[T] World::changed_components(
   key : ComponentKey[T],
   system : @core.SystemTicks,
 ) -> ChangedComponents[T] {
-  let reader = match self.changed_component_messages(key.id()) {
-    Some(messages) => messages.reader(system)
-    None => @core.Messages::new().reader(system)
+  let entities : Array[@core.Entity] = []
+  guard self.local_component_id(key.id()) is Some(local_component_id) else {
+    return ChangedComponents::{ entities, }
   }
-  ChangedComponents::{ reader, }
+  key.component_for_each(self, fn(entity, _value) {
+    if self.is_changed_by_local_id(entity, local_component_id, system) {
+      entities.push(entity)
+    }
+  })
+  ChangedComponents::{ entities, }
 }
 
 ///|
diff --git a/mgstudio-engine/ecs/changed_components_test.mbt b/mgstudio-engine/ecs/changed_components_test.mbt
index 7afb6b484..1b5f373d5 100644
--- a/mgstudio-engine/ecs/changed_components_test.mbt
+++ b/mgstudio-engine/ecs/changed_components_test.mbt
@@ -112,6 +112,36 @@ test "ecs changed components: Write::modify marks changed on explicit mutation"
   debug_inspect(changed.contains(entity), content="true")
 }
 
+///|
+test "ecs changed components: Write::bypass_change_detection preserves tick" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+
+  try! world.set_by_key(entity, changed_marker_key, ChangedMarker::{ value: 1 })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let maybe_mut = try! world.get_mut(entity, key=changed_marker_key)
+  let item = match maybe_mut {
+    Some(item) => item
+    None => abort("expected mutable component")
+  }
+  item.bypass_change_detection(fn(value) {
+    value.value = 11
+    value
+  })
+
+  debug_inspect(item.last_changed(), content="1")
+  debug_inspect(
+    try! world.get_by_key(entity, changed_marker_key),
+    content="Some({ value: 11 })",
+  )
+  let changed = world
+    .changed_components(changed_marker_key, @core.SystemTicks::new(1, 2))
+    .read()
+  debug_inspect(changed.contains(entity), content="false")
+}
+
 ///|
 test "ecs changed components: Write::value does not mark changed by itself" {
   let world = World::new()
diff --git a/mgstudio-engine/ecs/changed_components_wbtest.mbt b/mgstudio-engine/ecs/changed_components_wbtest.mbt
new file mode 100644
index 000000000..d2c62cb5d
--- /dev/null
+++ b/mgstudio-engine/ecs/changed_components_wbtest.mbt
@@ -0,0 +1,69 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+enum DemandDrivenChangedMarker {
+  Marker
+}
+
+///|
+let demand_driven_changed_marker_key : ComponentKey[DemandDrivenChangedMarker] = register_component(
+  debug_name="demand_driven_changed_marker",
+)
+
+///|
+test "ecs changed components: tick scan preserves first and repeated reads" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+
+  try! world.set_by_key(
+    entity,
+    demand_driven_changed_marker_key,
+    DemandDrivenChangedMarker::Marker,
+  )
+
+  let first = world
+    .changed_components(
+      demand_driven_changed_marker_key,
+      @core.SystemTicks::new(0, 1),
+    )
+    .read()
+  debug_inspect(first, content="[{ id: 0, generation: 1 }]")
+  let repeated = world
+    .changed_components(
+      demand_driven_changed_marker_key,
+      @core.SystemTicks::new(0, 1),
+    )
+    .read()
+  debug_inspect(repeated, content="[{ id: 0, generation: 1 }]")
+
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  debug_inspect(
+    try! world.replace(
+      entity,
+      demand_driven_changed_marker_key,
+      DemandDrivenChangedMarker::Marker,
+    ),
+    content="true",
+  )
+  let second = world
+    .changed_components(
+      demand_driven_changed_marker_key,
+      @core.SystemTicks::new(1, 2),
+    )
+    .read()
+  debug_inspect(second, content="[{ id: 0, generation: 1 }]")
+}
diff --git a/mgstudio-engine/ecs/component_column.mbt b/mgstudio-engine/ecs/component_column.mbt
index ed83fba6c..2a1f07b18 100644
--- a/mgstudio-engine/ecs/component_column.mbt
+++ b/mgstudio-engine/ecs/component_column.mbt
@@ -665,8 +665,8 @@ pub fn[T] ComponentColumn::for_each_changed_table_entity(
   visit : (@core.Entity, Int, Int) -> Bool,
 ) -> Bool {
   guard self.storage_type == Table else { return true }
-  for entry in self.world.tables.iter() {
-    let (table_id, table_ref) = entry
+  for table_id in 0..<self.world.tables.length() {
+    guard self.world.tables[table_id] is Some(table_ref) else { continue }
     guard self.cached_table_column(table_id) is Some(column_ref) else {
       continue
     }
@@ -1433,9 +1433,6 @@ pub fn[T] ComponentColumn::set(
   if !self.set_tick_only(entity, value) {
     return false
   }
-  self.world
-  .ensure_changed_component_messages(self.key.id())
-  .send(component_write_tick(self.world), entity)
   true
 }
 
diff --git a/mgstudio-engine/ecs/component_column_wbtest.mbt b/mgstudio-engine/ecs/component_column_wbtest.mbt
index 003ef9b6d..1f4390305 100644
--- a/mgstudio-engine/ecs/component_column_wbtest.mbt
+++ b/mgstudio-engine/ecs/component_column_wbtest.mbt
@@ -42,6 +42,22 @@ pub impl Component for ComponentColumnMigrationMarker with fn component() {
   component_column_migration_marker_key
 }
 
+///|
+fn assert_component_table_storage_invariants(world : World) -> Unit raise {
+  for table_id in 0..<world.tables.length() {
+    guard world.tables[table_id] is Some(table_ref) else { continue }
+    let row_count = table_ref.row_count()
+    assert_eq(table_ref.table_id, table_id)
+    for column_ref in table_ref.columns {
+      assert_eq(raw_table_column_kernel_len(column_ref.storage), row_count)
+      assert_eq(
+        (column_ref.component_ops.table_row_count)(world, table_id),
+        row_count,
+      )
+    }
+  }
+}
+
 ///|
 test "ecs component column: cached table values write through typed storage" {
   let world = World::new()
@@ -188,6 +204,41 @@ test "ecs component column: table migration moves canonical typed rows" {
   )
 }
 
+///|
+test "ecs component column: structural changes preserve table column lengths" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, component_column_cache_value_key, ComponentColumnCacheValue::{
+    x: 1,
+  })
+  try! world.set_by_key(second, component_column_cache_value_key, ComponentColumnCacheValue::{
+    x: 2,
+  })
+  assert_component_table_storage_invariants(world)
+
+  try! world.set_by_key(first, component_column_migration_marker_key, ComponentColumnMigrationMarker::{
+    y: 3,
+  })
+  assert_component_table_storage_invariants(world)
+
+  try! world.set_by_key(first, component_column_cache_value_key, ComponentColumnCacheValue::{
+    x: 4,
+  })
+  assert_component_table_storage_invariants(world)
+
+  ignore(try! world.remove_by_key(first, component_column_migration_marker_key))
+  assert_component_table_storage_invariants(world)
+
+  try! world.despawn(second)
+  assert_component_table_storage_invariants(world)
+  debug_inspect(
+    try! world.get_by_key(first, component_column_cache_value_key),
+    content="Some({ x: 4 })",
+  )
+}
+
 ///|
 test "ecs component column: table storage iteration does not retain staged duplicates" {
   let world = World::new()
diff --git a/mgstudio-engine/ecs/component_hooks.mbt b/mgstudio-engine/ecs/component_hooks.mbt
index e82c91717..63bdf99aa 100644
--- a/mgstudio-engine/ecs/component_hooks.mbt
+++ b/mgstudio-engine/ecs/component_hooks.mbt
@@ -355,8 +355,21 @@ fn World::component_hooks(self : World, component_id : Int) -> ComponentHooks? {
 }
 
 ///|
-fn hook_caller_from_loc(loc : SourceLoc) -> String? {
-  Some(loc.to_string())
+fn hook_caller_from_loc(world : World, loc : SourceLoc) -> String? {
+  if world.tracks_change_locations() {
+    Some(loc.to_string())
+  } else {
+    None
+  }
+}
+
+///|
+fn World::tracked_change_caller(self : World, caller : String?) -> String? {
+  if self.tracks_change_locations() {
+    caller
+  } else {
+    None
+  }
 }
 
 ///|
diff --git a/mgstudio-engine/ecs/component_hooks_test.mbt b/mgstudio-engine/ecs/component_hooks_test.mbt
index a61e4be37..4228b5b14 100644
--- a/mgstudio-engine/ecs/component_hooks_test.mbt
+++ b/mgstudio-engine/ecs/component_hooks_test.mbt
@@ -221,7 +221,7 @@ fn hook_remove_commands_test_install_hooks(world : World) -> Unit {
 ///|
 test "ecs component hooks: first insert fires add then insert with readable payload" {
   hook_test_reset()
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   hook_test_install_hooks(world)
   let entity = world.spawn()
@@ -240,7 +240,7 @@ test "ecs component hooks: first insert fires add then insert with readable payl
 ///|
 test "ecs component hooks: replace fires replace then insert around the new payload" {
   hook_test_reset()
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   hook_test_install_hooks(world)
   let entity = world.spawn()
@@ -264,7 +264,7 @@ test "ecs component hooks: replace fires replace then insert around the new payl
 ///|
 test "ecs component hooks: remove keeps the old payload visible through replace and remove" {
   hook_test_reset()
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   hook_test_install_hooks(world)
   let entity = world.spawn()
@@ -292,7 +292,7 @@ test "ecs component hooks: remove keeps the old payload visible through replace
 ///|
 test "ecs component hooks: despawn fires despawn replace remove before entity teardown" {
   hook_test_reset()
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   hook_test_install_hooks(world)
   let entity = world.spawn()
@@ -318,7 +318,7 @@ test "ecs component hooks: despawn fires despawn replace remove before entity te
 ///|
 test "ecs component hooks: component access mutation paths preserve caller provenance" {
   hook_test_reset()
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   hook_test_install_hooks(world)
   let entity = world.spawn()
diff --git a/mgstudio-engine/ecs/component_membership_wbtest.mbt b/mgstudio-engine/ecs/component_membership_wbtest.mbt
new file mode 100644
index 000000000..345fdde97
--- /dev/null
+++ b/mgstudio-engine/ecs/component_membership_wbtest.mbt
@@ -0,0 +1,48 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+struct DespawnMembershipMarker {}
+
+///|
+let despawn_membership_marker_key : ComponentKey[DespawnMembershipMarker] = register_component(
+  debug_name="tests.ecs.despawn_membership_marker",
+)
+
+///|
+test "despawn updates component membership count and generation" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, despawn_membership_marker_key, DespawnMembershipMarker::{
+
+  })
+  let generation_before = world.component_membership_generation_for_definition(
+    despawn_membership_marker_key.id(),
+  )
+  assert_eq(world.component_count(despawn_membership_marker_key), 1)
+
+  try! world.despawn(entity)
+
+  let generation_after = world.component_membership_generation_for_definition(
+    despawn_membership_marker_key.id(),
+  )
+  debug_inspect(
+    (
+      world.component_count(despawn_membership_marker_key),
+      generation_after - generation_before,
+    ),
+    content="(0, 1)",
+  )
+}
diff --git a/mgstudio-engine/ecs/component_ops.mbt b/mgstudio-engine/ecs/component_ops.mbt
index 1f5f3ce5a..3ee08b7a3 100644
--- a/mgstudio-engine/ecs/component_ops.mbt
+++ b/mgstudio-engine/ecs/component_ops.mbt
@@ -19,9 +19,10 @@ struct ComponentOps {
   contains : (World, @core.Entity) -> Bool
   for_each_entity : (World, (@core.Entity) -> Unit) -> Unit
   remove : (World, @core.Entity) -> Bool
-  move_table_row : (World, @core.Entity, Int, Int, Int, Int) -> Bool
+  move_table_row_and_swap_remove : (World, @core.Entity, Int, Int, Int, Int) -> Bool
   move_staged_to_table_row : (World, @core.Entity, Int, Int) -> Bool
   swap_remove_table_row : (World, Int, Int) -> Unit
+  table_row_count : (World, Int) -> Int
 }
 
 ///|
@@ -39,8 +40,8 @@ fn[T] component_ops_for_key(key : ComponentKey[T]) -> ComponentOps {
     for_each_entity: fn(world, visit) {
       key.component_for_each(world, fn(entity, _value) { visit(entity) })
     },
-    remove: fn(world, entity) { key.component_remove(world, entity) is Some(_) },
-    move_table_row: fn(
+    remove: fn(world, entity) { key.component_remove(world, entity) },
+    move_table_row_and_swap_remove: fn(
       world,
       entity,
       source_table_id,
@@ -48,7 +49,7 @@ fn[T] component_ops_for_key(key : ComponentKey[T]) -> ComponentOps {
       target_table_id,
       target_row_index,
     ) {
-      key.component_move_table_row(
+      key.component_move_table_row_and_swap_remove(
         world, entity, source_table_id, source_row_index, target_table_id, target_row_index,
       )
     },
@@ -58,6 +59,9 @@ fn[T] component_ops_for_key(key : ComponentKey[T]) -> ComponentOps {
     swap_remove_table_row: fn(world, table_id, row_index) {
       key.component_swap_remove_table_row(world, table_id, row_index)
     },
+    table_row_count: fn(world, table_id) {
+      key.component_table_row_count(world, table_id)
+    },
   }
 }
 
diff --git a/mgstudio-engine/ecs/component_remove_transaction.mbt b/mgstudio-engine/ecs/component_remove_transaction.mbt
index c07395c70..d5c15c0a1 100644
--- a/mgstudio-engine/ecs/component_remove_transaction.mbt
+++ b/mgstudio-engine/ecs/component_remove_transaction.mbt
@@ -164,7 +164,16 @@ fn World::commit_component_remove_transaction(
       removal.local_id,
     ),
   )
-  self.entity_remove_component_local_id(transaction.entity, removal.local_id)
+  self.finish_component_remove_transaction(transaction, removal)
+}
+
+///|
+fn World::finish_component_remove_transaction(
+  self : World,
+  transaction : ComponentRemoveTransaction,
+  removal : ComponentRemoval,
+) -> Unit {
+  self.record_entity_component_removed_local_id(removal.local_id)
   self.refresh_entity_archetype_after_component_remove(
     transaction.entity,
     removal.local_id,
@@ -176,6 +185,30 @@ fn World::commit_component_remove_transaction(
   self.clear_component_tick_records(transaction.entity, removal.definition_id)
 }
 
+///|
+fn[T] World::commit_component_take_transaction(
+  self : World,
+  transaction : ComponentRemoveTransaction,
+  key : ComponentKey[T],
+) -> T? {
+  if transaction.is_empty() {
+    return None
+  }
+  let removal = transaction.removals[0]
+  if removal.definition_id != key.id() {
+    abort("Component take transaction key does not match its removal")
+  }
+  self.run_component_remove_transaction_replace_remove_phase(transaction)
+  self.run_component_remove_transaction_remove_observer_phase(transaction)
+  let taken = key.component_take(self, transaction.entity)
+  self.clear_sparse_component_metadata_by_local_id(
+    transaction.entity,
+    removal.local_id,
+  )
+  self.finish_component_remove_transaction(transaction, removal)
+  taken
+}
+
 ///|
 fn World::commit_component_despawn_transaction(
   self : World,
@@ -185,11 +218,11 @@ fn World::commit_component_despawn_transaction(
   self.run_component_remove_transaction_replace_remove_phase(transaction)
   self.run_component_remove_transaction_remove_observer_phase(transaction)
   self.commit_removed_component_effects(transaction)
+  self.clear_entity_archetype_tracking(transaction.entity)
   let freed = self.entities.despawn(transaction.entity) catch {
     err => raise EntityStateError(err)
   }
   self.free_spawned_entity(freed)
-  self.clear_entity_archetype_tracking(transaction.entity)
   self.mark_entity_lifecycle_changed()
   self.mark_structure_changed()
 }
diff --git a/mgstudio-engine/ecs/component_writer.mbt b/mgstudio-engine/ecs/component_writer.mbt
index 38999fd64..5231e56f8 100644
--- a/mgstudio-engine/ecs/component_writer.mbt
+++ b/mgstudio-engine/ecs/component_writer.mbt
@@ -18,6 +18,8 @@ pub struct ComponentWriter {
   priv component_debug_name : String
   priv value_type_name : String
   priv apply_fn : (World, @core.Entity) -> Unit
+  priv consumed : Ref[Bool]
+  priv drop_unconsumed_fn : () -> Unit
 }
 
 ///|
@@ -28,6 +30,7 @@ fn[T] component_writer_for_key(
   ensure_component_ops_for_key(key)
   let component_definition_id = key.id()
   let component_debug_name = key.debug_name()
+  let consumed = Ref(false)
   {
     component_definition_id,
     component_debug_name,
@@ -37,6 +40,8 @@ fn[T] component_writer_for_key(
       "component#\{component_definition_id.to_string()}"
     },
     apply_fn: fn(world, entity) { key.component_set(world, entity, value) },
+    consumed,
+    drop_unconsumed_fn: fn() { key.component_finalize_value(value) },
   }
 }
 
@@ -51,9 +56,24 @@ fn ComponentWriter::apply(
   world : World,
   entity : @core.Entity,
 ) -> Unit {
+  if self.consumed.val {
+    abort(
+      "ComponentWriter for {self.value_type_name} was consumed more than once",
+    )
+  }
+  self.consumed.val = true
   (self.apply_fn)(world, entity)
 }
 
+///|
+fn ComponentWriter::drop_unconsumed(self : ComponentWriter) -> Unit {
+  if self.consumed.val {
+    return
+  }
+  self.consumed.val = true
+  (self.drop_unconsumed_fn)()
+}
+
 ///|
 pub fn ComponentWriter::component_definition_id(self : ComponentWriter) -> Int {
   self.component_definition_id
diff --git a/mgstudio-engine/ecs/ecs.mbt b/mgstudio-engine/ecs/ecs.mbt
index c3bf0a1b2..92bedc395 100644
--- a/mgstudio-engine/ecs/ecs.mbt
+++ b/mgstudio-engine/ecs/ecs.mbt
@@ -117,15 +117,19 @@ let ecs_id_allocator_state : EcsIdAllocatorState = {
 ///|
 pub fn[T] register_component(
   debug_name? : String = "",
-  finalizer? : (T) -> Unit = fn(_value : T) { () },
+  finalizer? : (T) -> Unit,
 ) -> ComponentKey[T] {
   let id = ecs_id_allocator_state.next_component_id
   ecs_id_allocator_state.next_component_id = id + 1
   ignore(component_metadata_ensure(id, debug_name~))
+  let (finalize_value, has_custom_finalizer) = match finalizer {
+    Some(finalize_value) => (finalize_value, true)
+    None => (fn(_value : T) { () }, false)
+  }
   let key = ComponentKey::{
     id,
     debug_name,
-    access: component_access_new(id, finalizer~),
+    access: component_access_new(id, finalize_value, has_custom_finalizer),
   }
   key
 }
@@ -171,6 +175,7 @@ pub(all) suberror EcsError {
   EventTypeMismatch(Int, String, Int, String)
   MessageTypeMismatch(Int, String, Int, String)
   WorldClosed(Int)
+  TableBatchUnavailable(String)
   ForeignEntityReservation(@core.Entity, Int, Int)
   StaleEntityReservation(@core.Entity)
 }
@@ -197,6 +202,7 @@ priv struct ArchetypeSignatureIndex {
 pub struct World {
   priv lifecycle : WorldLifecycle
   priv cleanup_registry : WorldCleanupRegistry
+  priv track_change_locations : Bool
   priv mut structural_generation : Int
   priv mut entity_lifecycle_generation : Int
   priv mut component_registration_generation : Int
@@ -217,7 +223,7 @@ pub struct World {
   priv mut system_tick_context : @core.SystemTickContext
   priv component_write_transactions : ComponentWriteTransactionState
   priv query_iterations : WorldQueryIterationState
-  priv tables : Map[Int, RawTable]
+  priv tables : Array[RawTable?]
   priv sparse_component_metadata : Map[
     Int,
     @core.ComponentStore[ComponentTickMetadata],
@@ -252,7 +258,6 @@ pub struct World {
   priv required_components : Map[Int, RequiredComponentsState]
   priv used_components : @utils.IntBitSet
   priv added_components : Map[Int, @core.Messages[@core.Entity]]
-  priv changed_components : Map[Int, @core.Messages[@core.Entity]]
   priv removed_components : Map[Int, @core.Messages[@core.Entity]]
   priv component_hooks_registry : Map[Int, ComponentHooks]
   priv resource_tick_registry : WorldResourceTickRegistry
@@ -266,12 +271,13 @@ pub struct World {
 /// Creates a World with an explicit lifecycle.
 ///
 /// The owner must call `World::close`. Prefer `with_world` for lexical scopes.
-pub fn World::new() -> World {
+pub fn World::new(track_change_locations? : Bool = false) -> World {
   let world_id = ecs_id_allocator_state.next_world_id
   ecs_id_allocator_state.next_world_id = world_id + 1
   let world = World::{
     lifecycle: WorldLifecycle::new(world_id),
     cleanup_registry: world_cleanup_registry_new(),
+    track_change_locations,
     structural_generation: 0,
     entity_lifecycle_generation: 0,
     component_registration_generation: 0,
@@ -289,7 +295,7 @@ pub fn World::new() -> World {
     system_tick_context: @core.SystemTickContext::new(),
     component_write_transactions: component_write_transaction_state_new(),
     query_iterations: world_query_iteration_state_new(),
-    tables: Map([]),
+    tables: [],
     sparse_component_metadata: Map([]),
     next_archetype_id: 1,
     next_table_id: 1,
@@ -321,7 +327,6 @@ pub fn World::new() -> World {
     required_components: Map([]),
     used_components: @utils.IntBitSet::new(),
     added_components: Map([]),
-    changed_components: Map([]),
     removed_components: Map([]),
     component_hooks_registry: Map([]),
     resource_tick_registry: world_resource_tick_registry_new(),
@@ -332,6 +337,7 @@ pub fn World::new() -> World {
   }
   world.archetype_ids_by_signature.insert([], 0)
   world.table_ids_by_signature.insert([], 0)
+  ignore(world.ensure_table_storage(0))
   world.bootstrap_component_registrations()
   world.insert_resource(
     ecs_key_default_query_filters,
@@ -340,6 +346,17 @@ pub fn World::new() -> World {
   world
 }
 
+///|
+/// Returns whether this world records component and resource change locations.
+///
+/// This is disabled by default, matching Bevy without its non-default
+/// `track_location` feature. Enable it at construction time with
+/// `World::new(track_change_locations=true)` when change-location diagnostics
+/// are required.
+pub fn World::tracks_change_locations(self : World) -> Bool {
+  self.track_change_locations
+}
+
 ///|
 pub fn World::world_id(self : World) -> Int {
   self.lifecycle.world_id
@@ -362,6 +379,7 @@ pub fn World::is_active(self : World) -> Bool {
 
 ///|
 pub fn World::close(self : World) -> Unit {
+  self.abort_if_query_iteration_would_be_invalidated("close world")
   guard self.lifecycle.begin_close() else { return }
   self.allocator_connection.close()
   let pre_close_hooks = self.pre_close_hooks
@@ -485,7 +503,7 @@ pub fn World::despawn(
   self.ensure_entity_alive(entity)
   self.ensure_query_iteration_can_change_structure("despawn entity")
   let outermost = self.begin_deferred_hook_command_scope()
-  let caller = hook_caller_from_loc(loc)
+  let caller = hook_caller_from_loc(self, loc)
   let transaction = self.component_remove_transaction_for_despawn(
     entity, caller,
   )
@@ -506,7 +524,7 @@ pub fn[T] World::set_by_key(
     entity,
     key.id(),
     component_writer_for_key(key, value),
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(self, loc),
   )
 }
 
@@ -514,8 +532,8 @@ pub fn[T] World::set_by_key(
 /// Returns the component value for read-only use.
 ///
 /// MoonBit cannot enforce that the returned value is not mutated through an
-/// alias. Code that wants ECS change detection, changed-component messages, or
-/// replacement hooks must use `World::get_mut`, `World::update_by_key`,
+/// alias. Code that wants ECS change detection or replacement hooks must use
+/// `World::get_mut`, `World::update_by_key`,
 /// `Write::modify` or `Write::set` instead of mutating the value
 /// returned here.
 pub fn[T] World::get_by_key(
@@ -548,7 +566,7 @@ pub fn[T] World::update_by_key(
     return false
   }
   let new_value = update(old_value)
-  let caller = hook_caller_from_loc(loc)
+  let caller = hook_caller_from_loc(self, loc)
   self.run_component_replace_hooks(entity, key.id(), caller~)
   self.run_replace_observers(entity, key.id())
   ignore(self.replace_component_value_by_key(entity, key, new_value))
@@ -569,7 +587,7 @@ pub fn[T] World::remove_by_key(
 ) -> Bool raise EcsError {
   self.ensure_entity_alive(entity)
   let outermost = self.begin_deferred_hook_command_scope()
-  let caller = hook_caller_from_loc(loc)
+  let caller = hook_caller_from_loc(self, loc)
   guard self.component_remove_transaction_for_key(entity, key.id(), caller)
     is Some(transaction) else {
     self.end_deferred_hook_command_scope(outermost)
@@ -708,30 +726,6 @@ fn World::ensure_added_component_messages(
   }
 }
 
-///|
-fn World::ensure_changed_component_messages(
-  self : World,
-  key_id : Int,
-) -> @core.Messages[@core.Entity] {
-  let local_id = self.ensure_component_registered(key_id)
-  self.ensure_changed_component_messages_by_local_id(local_id)
-}
-
-///|
-fn World::ensure_changed_component_messages_by_local_id(
-  self : World,
-  local_id : Int,
-) -> @core.Messages[@core.Entity] {
-  match self.changed_components.get(local_id) {
-    Some(messages) => messages
-    None => {
-      let messages = @core.Messages::new()
-      self.changed_components.set(local_id, messages)
-      messages
-    }
-  }
-}
-
 ///|
 fn World::ensure_sparse_component_metadata_store_for_local_id(
   self : World,
@@ -769,6 +763,7 @@ fn World::record_component_added_with_caller(
   key_id : Int,
   caller : String?,
 ) -> Unit {
+  let caller = self.tracked_change_caller(caller)
   let tick = component_write_tick(self)
   let local_id = self.ensure_component_registered(key_id)
   let recorded = match self.local_component_storage_type(local_id) {
@@ -798,14 +793,12 @@ fn World::record_component_changed_with_caller(
   key_id : Int,
   caller : String?,
 ) -> Unit {
+  let caller = self.tracked_change_caller(caller)
   let tick = component_write_tick(self)
   let local_id = self.ensure_component_registered(key_id)
   self.record_component_changed_by_local_id_with_tick(
     entity, local_id, tick, caller,
   )
-  self
-  .ensure_changed_component_messages_by_local_id(local_id)
-  .send(tick, entity)
 }
 
 ///|
@@ -914,17 +907,6 @@ fn World::added_component_tick_by_local_id(
   }
 }
 
-///|
-fn World::changed_component_messages(
-  self : World,
-  key_id : Int,
-) -> @core.Messages[@core.Entity]? {
-  match self.local_component_id(key_id) {
-    Some(local_id) => self.changed_components.get(local_id)
-    None => None
-  }
-}
-
 ///|
 fn World::changed_component_tick(
   self : World,
@@ -1011,8 +993,10 @@ pub fn World::set_tick_context(
 pub fn World::check_change_ticks(self : World) -> Unit {
   let present_tick = self.read_change_tick()
   self.resource_tick_registry.check_change_ticks(present_tick)
-  for entry in self.tables.iter() {
-    entry.1.check_change_ticks(present_tick)
+  for table in self.tables {
+    if table is Some(table_ref) {
+      table_ref.check_change_ticks(present_tick)
+    }
   }
   for entry in self.sparse_component_metadata.iter() {
     let metadata_store = entry.1
diff --git a/mgstudio-engine/ecs/ecs_perf_bench_test.mbt b/mgstudio-engine/ecs/ecs_perf_bench_test.mbt
index defa7f9be..2321999ea 100644
--- a/mgstudio-engine/ecs/ecs_perf_bench_test.mbt
+++ b/mgstudio-engine/ecs/ecs_perf_bench_test.mbt
@@ -210,6 +210,34 @@ fn ecs_bench_dense_query_sum(
   total.val
 }
 
+///|
+fn ecs_bench_dense_value_query_sum(
+  world : World,
+  cache : QueryCache,
+) -> Int raise EcsError {
+  let query : Query[
+    (
+      ReadValue[BenchPosition],
+      ReadValue[BenchVelocity],
+      ReadValue[BenchHealth],
+      ReadValue[BenchMass],
+    ),
+    All,
+  ] = query_filtered_with_cache(world, All::new(), cache)
+  let total = Ref(0)
+  query.for_each(fn(_entity, data) {
+    let (position, velocity, health, mass) = data
+    total.val = total.val +
+      position.value().x +
+      position.value().y +
+      velocity.value().dx +
+      velocity.value().dy +
+      health.value().hp +
+      mass.value().value
+  })
+  total.val
+}
+
 ///|
 fn ecs_bench_dense_query_state_iter_sum(
   world : World,
@@ -278,6 +306,57 @@ fn ecs_bench_mut_query_apply(
   total.val
 }
 
+///|
+fn ecs_bench_mut_query_for_each_apply(
+  world : World,
+  cache : QueryCache,
+) -> Int raise EcsError {
+  let query : Query[(Write[BenchPosition], Read[BenchVelocity]), All] = query_filtered_with_cache(
+    world,
+    All::new(),
+    cache,
+  )
+  let total = Ref(0)
+  query.for_each(fn(_entity, data) {
+    let (position, velocity) = data
+    let v = velocity.value()
+    position.modify(fn(p) {
+      p.x = p.x + v.dx
+      p.y = p.y + v.dy
+    })
+    let p = position.value()
+    total.val = total.val + p.x + p.y
+  })
+  total.val
+}
+
+///|
+fn ecs_bench_mut_query_table_batch_apply(
+  world : World,
+  cache : QueryCache,
+) -> Int raise EcsError {
+  let query : Query[(Write[BenchPosition], Read[BenchVelocity]), All] = query_filtered_with_cache(
+    world,
+    All::new(),
+    cache,
+  )
+  let total = Ref(0)
+  query.for_each_table(fn(batch) {
+    let positions = batch.write(bench_position_key).unwrap()
+    let velocities = batch.read(bench_velocity_key).unwrap()
+    for row_index in 0..<batch.length() {
+      let v = velocities.value(row_index)
+      positions.modify(row_index, fn(p) {
+        p.x = p.x + v.dx
+        p.y = p.y + v.dy
+      })
+      let p = positions.peek(row_index)
+      total.val = total.val + p.x + p.y
+    }
+  })
+  total.val
+}
+
 ///|
 test "bench ecs: spawn dense bundle" (b : @bench.T) {
   let entity_count = 5_000
@@ -315,6 +394,16 @@ test "bench ecs: query dense cached" (b : @bench.T) {
   })
 }
 
+///|
+test "bench ecs: query dense value-only cached" (b : @bench.T) {
+  let world = try! ecs_bench_seed_dense_world(20_000)
+  defer world.close()
+  let cache = QueryCache::new()
+  b.bench(name="query dense value-only cached x20000", count=100U, () => {
+    b.keep(try! ecs_bench_dense_value_query_sum(world, cache))
+  })
+}
+
 ///|
 test "bench ecs: query dense state iter cached" (b : @bench.T) {
   let world = try! ecs_bench_seed_dense_world(20_000)
@@ -352,3 +441,57 @@ test "bench ecs: mut query modify cached" (b : @bench.T) {
     b.keep(ecs_bench_mut_query_apply(world, state))
   })
 }
+
+///|
+test "bench ecs: mut query for_each cached" (b : @bench.T) {
+  let world = try! ecs_bench_seed_dense_world(20_000)
+  defer world.close()
+  let cache = QueryCache::new()
+  b.bench(name="query mut for_each cached x20000", count=100U, () => {
+    b.keep(try! ecs_bench_mut_query_for_each_apply(world, cache))
+  })
+}
+
+///|
+test "bench ecs: mut query table batch cached" (b : @bench.T) {
+  let world = try! ecs_bench_seed_dense_world(20_000)
+  defer world.close()
+  let cache = QueryCache::new()
+  b.bench(name="query mut table batch cached x20000", count=100U, () => {
+    b.keep(try! ecs_bench_mut_query_table_batch_apply(world, cache))
+  })
+}
+
+///|
+test "bench ecs: table batch read view cached" (b : @bench.T) {
+  let world = try! ecs_bench_seed_dense_world(102_400)
+  defer world.close()
+  let cache = QueryCache::new()
+  b.bench(name="table batch value accessor x102400", count=50U, () => {
+    let query : Query[ReadValue[BenchPosition], All] = query_filtered_with_cache(
+      world, All::new(), cache,
+    )
+    let total = Ref(0)
+    try! query.for_each_table(fn(batch) {
+      let positions = batch.read(bench_position_key).unwrap()
+      for row_index in 0..<batch.length() {
+        total.val = total.val + positions.value(row_index).x
+      }
+    })
+    b.keep(total.val)
+  })
+  b.bench(name="table batch read view x102400", count=50U, () => {
+    let query : Query[ReadValue[BenchPosition], All] = query_filtered_with_cache(
+      world, All::new(), cache,
+    )
+    let total = Ref(0)
+    try! query.for_each_table(fn(batch) {
+      batch.read(bench_position_key).unwrap().with_values(fn(positions) {
+        for position in positions {
+          total.val = total.val + position.x
+        }
+      })
+    })
+    b.keep(total.val)
+  })
+}
diff --git a/mgstudio-engine/ecs/entity_access.mbt b/mgstudio-engine/ecs/entity_access.mbt
index b1ed05468..3417a618c 100644
--- a/mgstudio-engine/ecs/entity_access.mbt
+++ b/mgstudio-engine/ecs/entity_access.mbt
@@ -32,6 +32,7 @@ pub struct Write[T] {
   priv table_id : Int
   priv row_index : Int
   priv local_component_id : Int
+  priv bound_table_values : Array[T]?
 }
 
 ///|
@@ -46,19 +47,24 @@ pub(open) trait Bundle {
 
 ///|
 fn[T] mut_value_or_abort(item : Write[T]) -> T {
+  match item.bound_table_values {
+    Some(values) if item.table_id >= 0 && item.row_index >= 0 => {
+      if item.row_index >= values.length() {
+        abort("Write expected bound table component row")
+      }
+      return values[item.row_index]
+    }
+    _ => ()
+  }
   match item.world.local_component_storage_type(item.local_component_id) {
     Some(Table) => {
       if item.table_id >= 0 && item.row_index >= 0 {
-        match
-          item.world.component_value_by_table_row_fast(
-            item.key,
-            item.local_component_id,
-            item.table_id,
-            item.row_index,
-          ) {
-          Some(value) => return value
-          None => abort("Write expected table component value at fetched row")
-        }
+        return item.world.component_value_by_table_row_unchecked(
+          item.key,
+          item.local_component_id,
+          item.table_id,
+          item.row_index,
+        )
       }
       guard item.world.component_write_transaction_contains(
         item.entity,
@@ -149,9 +155,6 @@ fn[T] mut_mark_changed(item : Write[T], caller? : String? = None) -> Unit {
       caller,
     )
   }
-  item.world
-  .ensure_changed_component_messages_by_local_id(item.local_component_id)
-  .send(tick, item.entity)
 }
 
 ///|
@@ -238,7 +241,7 @@ pub fn[T : Component] Write::set_changed(
   loc~ : SourceLoc,
 ) -> Unit {
   ignore(T::component())
-  mut_mark_changed(self, caller=hook_caller_from_loc(loc))
+  mut_mark_changed(self, caller=hook_caller_from_loc(self.world, loc))
 }
 
 ///|
@@ -251,7 +254,7 @@ pub fn[T : Component] Write::set_added(
   let world = self.world
   let entity = self.entity
   let key_id = self.key.id()
-  let caller = hook_caller_from_loc(loc)
+  let caller = hook_caller_from_loc(world, loc)
   world.record_component_added_with_caller(entity, key_id, caller)
   world
   .ensure_added_component_messages(key_id)
@@ -274,10 +277,29 @@ pub fn[T, R] Write::modify(
 ) -> R {
   let value = self.peek(loc~)
   let result = f(value)
-  mut_mark_changed(self, caller=hook_caller_from_loc(loc))
+  mut_mark_changed(self, caller=hook_caller_from_loc(self.world, loc))
   result
 }
 
+///|
+/// Updates the component through a closure without marking it changed.
+///
+/// This is the MoonBit equivalent of Bevy's
+/// `DetectChangesMut::bypass_change_detection`. Use it only for internal state
+/// changes that must not be observed as a semantic component change. Returning
+/// the same reference preserves its ownership; returning a different value
+/// replaces and finalizes the displaced component normally.
+pub fn[T] Write::bypass_change_detection(
+  self : Write[T],
+  update : (T) -> T,
+) -> Unit {
+  let value = mut_value_or_abort(self)
+  let replacement = update(value)
+  if !physical_equal(value, replacement) {
+    mut_assign_value_or_abort(self, replacement)
+  }
+}
+
 ///|
 #callsite(autofill(loc))
 pub fn[T : Eq] Write::set_if_neq(
@@ -298,11 +320,10 @@ pub fn[T : Eq] Write::set_if_neq(
 /// Replaces the component and marks it changed.
 ///
 /// Prefer `Write::set` over mutating values returned by read-only APIs. This
-/// keeps change ticks and changed-component messages in sync with the stored
-/// value.
+/// keeps change ticks in sync with the stored value.
 #callsite(autofill(loc))
 pub fn[T] Write::set(self : Write[T], value : T, loc~ : SourceLoc) -> Unit {
-  mut_mark_changed(self, caller=hook_caller_from_loc(loc))
+  mut_mark_changed(self, caller=hook_caller_from_loc(self.world, loc))
   mut_assign_value_or_abort(self, value)
 }
 
@@ -314,8 +335,17 @@ fn[T] mut_from_component_location(
   local_component_id : Int,
   table_id : Int,
   row_index : Int,
+  bound_table_values? : Array[T]? = None,
 ) -> Write[T] {
-  { world, entity, key, table_id, row_index, local_component_id }
+  {
+    world,
+    entity,
+    key,
+    table_id,
+    row_index,
+    local_component_id,
+    bound_table_values,
+  }
 }
 
 ///|
@@ -482,7 +512,7 @@ pub impl[A : Component, B : Component] Bundle for (A, B) with fn insert_into(
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -502,7 +532,7 @@ pub impl[A : Component, B : Component, C : Component] Bundle for (A, B, C) with
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -523,7 +553,7 @@ pub impl[A : Component, B : Component, C : Component, D : Component] Bundle for
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -546,7 +576,7 @@ pub impl[
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -571,7 +601,7 @@ pub impl[
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -603,7 +633,7 @@ pub impl[
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -637,7 +667,7 @@ pub impl[
   try! world.insert_component_writes_with_requirements(
     entity,
     writes,
-    caller=hook_caller_from_loc(loc),
+    caller=hook_caller_from_loc(world, loc),
   )
 }
 
@@ -681,11 +711,7 @@ pub fn[T : Component] EntityMut::remove_component(
   self : EntityMut,
   loc~ : SourceLoc,
 ) -> T? raise EcsError {
-  let previous = self.world.get_by_key(self.entity, T::component())
-  if previous is Some(_) {
-    self.world.remove_by_key(self.entity, T::component(), loc~) |> ignore
-  }
-  previous
+  self.world.take(self.entity, T::component(), loc~)
 }
 
 ///|
diff --git a/mgstudio-engine/ecs/entity_disabling.mbt b/mgstudio-engine/ecs/entity_disabling.mbt
index 390fe62ef..cb78c8412 100644
--- a/mgstudio-engine/ecs/entity_disabling.mbt
+++ b/mgstudio-engine/ecs/entity_disabling.mbt
@@ -111,7 +111,7 @@ fn entity_has_component_id(
   }
   match world.local_component_id(component_id) {
     Some(local_component_id) =>
-      world.entity_local_components(entity).contains(local_component_id)
+      world.entity_has_component_local_id(entity, local_component_id)
     None => false
   }
 }
diff --git a/mgstudio-engine/ecs/entity_storage.mbt b/mgstudio-engine/ecs/entity_storage.mbt
index 1f5455b6f..ffa2c7a29 100644
--- a/mgstudio-engine/ecs/entity_storage.mbt
+++ b/mgstudio-engine/ecs/entity_storage.mbt
@@ -19,8 +19,6 @@ priv struct WorldEntityStorageState {
   entity_table_ids : Array[Int]
   entity_table_rows : Array[Int]
   entity_archetype_rows : Array[Int]
-  entity_component_local_ids : Array[Array[Int]]
-  entity_component_local_id_presence : Array[@utils.IntBitSet]
 }
 
 ///|
@@ -31,7 +29,5 @@ fn world_entity_storage_state_new() -> WorldEntityStorageState {
     entity_table_ids: [],
     entity_table_rows: [],
     entity_archetype_rows: [],
-    entity_component_local_ids: [],
-    entity_component_local_id_presence: [],
   }
 }
diff --git a/mgstudio-engine/ecs/filter.mbt b/mgstudio-engine/ecs/filter.mbt
index d45a58406..730da5ae9 100644
--- a/mgstudio-engine/ecs/filter.mbt
+++ b/mgstudio-engine/ecs/filter.mbt
@@ -22,6 +22,10 @@ pub(open) trait QueryFilter {
     table_id : Int,
     row_index : Int,
   ) -> Bool = _
+  fn bind_table_row_matcher(self : Self, world : World, table_id : Int) -> (
+    @core.Entity,
+    Int,
+  ) -> Bool = _
   fn mentions_component(self : Self, component_id : Int) -> Bool
   fn matches_component_set(self : Self, set_contains_id : (Int) -> Bool) -> Bool
   fn collect_access(self : Self, access : QueryFilterAccess) -> Unit = _
@@ -43,6 +47,10 @@ pub(open) trait QueryFilterDisjunction {
     table_id : Int,
     row_index : Int,
   ) -> Bool = _
+  fn bind_table_row_matcher_any(self : Self, world : World, table_id : Int) -> (
+    @core.Entity,
+    Int,
+  ) -> Bool = _
   fn mentions_component_any(self : Self, component_id : Int) -> Bool
   fn matches_component_set_any(self : Self, set_contains_id : (Int) -> Bool) -> Bool
   fn collect_access_any(self : Self, access : QueryFilterAccess) -> Unit = _
@@ -63,6 +71,13 @@ impl QueryFilter with fn matches_table_row(
   QueryFilter::matches(self, world, entity)
 }
 
+///|
+impl QueryFilter with fn bind_table_row_matcher(self, world, table_id) {
+  fn(entity, row_index) {
+    QueryFilter::matches_table_row(self, world, entity, table_id, row_index)
+  }
+}
+
 ///|
 impl QueryFilter with fn collect_access(_self, _access) {
   ()
@@ -97,6 +112,19 @@ impl QueryFilterDisjunction with fn matches_table_row_any(
   QueryFilterDisjunction::matches_any(self, world, entity)
 }
 
+///|
+impl QueryFilterDisjunction with fn bind_table_row_matcher_any(
+  self,
+  world,
+  table_id,
+) {
+  fn(entity, row_index) {
+    QueryFilterDisjunction::matches_table_row_any(
+      self, world, entity, table_id, row_index,
+    )
+  }
+}
+
 ///|
 impl QueryFilterDisjunction with fn collect_access_any(_self, _access) {
   ()
@@ -260,6 +288,50 @@ fn query_filter_table_changed_matches(
   }
 }
 
+///|
+fn query_filter_bind_table_added_matcher(
+  world : World,
+  component_id : Int,
+  table_id : Int,
+) -> (@core.Entity, Int) -> Bool {
+  let ticks = world.get_tick_context().ticks()
+  guard world.local_component_id(component_id) is Some(local_component_id) else {
+    return fn(_entity, _row_index) { false }
+  }
+  guard world.local_component_storage_type(local_component_id) == Some(Table) else {
+    return fn(_entity, _row_index) { false }
+  }
+  guard world.table_storage(table_id) is Some(table_ref) else {
+    return fn(_entity, _row_index) { false }
+  }
+  guard table_ref.column(local_component_id) is Some(column) else {
+    return fn(_entity, _row_index) { false }
+  }
+  fn(_entity, row_index) { column.added_tick_is_in(row_index, ticks) }
+}
+
+///|
+fn query_filter_bind_table_changed_matcher(
+  world : World,
+  component_id : Int,
+  table_id : Int,
+) -> (@core.Entity, Int) -> Bool {
+  let ticks = world.get_tick_context().ticks()
+  guard world.local_component_id(component_id) is Some(local_component_id) else {
+    return fn(_entity, _row_index) { false }
+  }
+  guard world.local_component_storage_type(local_component_id) == Some(Table) else {
+    return fn(_entity, _row_index) { false }
+  }
+  guard world.table_storage(table_id) is Some(table_ref) else {
+    return fn(_entity, _row_index) { false }
+  }
+  guard table_ref.column(local_component_id) is Some(column) else {
+    return fn(_entity, _row_index) { false }
+  }
+  fn(_entity, row_index) { column.changed_tick_is_in(row_index, ticks) }
+}
+
 ///|
 fn query_filter_append_unique_anchor_components(
   out : Array[Int],
@@ -286,6 +358,16 @@ pub impl QueryFilter for All with fn matches(self, _world, _entity) {
   true
 }
 
+///|
+pub impl QueryFilter for All with fn bind_table_row_matcher(
+  self,
+  _world,
+  _table_id,
+) {
+  ignore(self)
+  fn(_entity, _row_index) { true }
+}
+
 ///|
 pub impl QueryFilter for All with fn mentions_component(self, _component_id) {
   ignore(self)
@@ -345,6 +427,20 @@ pub impl[T] QueryFilter for With[T] with fn matches(self, world, entity) {
   entity_has_component_id(world, self.key.id(), entity)
 }
 
+///|
+pub impl[T] QueryFilter for With[T] with fn bind_table_row_matcher(
+  self,
+  world,
+  table_id,
+) {
+  let matches = match world.local_component_id(self.key.id()) {
+    Some(local_component_id) =>
+      world.table_has_component_local_id(table_id, local_component_id)
+    None => false
+  }
+  fn(_entity, _row_index) { matches }
+}
+
 ///|
 pub impl[T] QueryFilter for With[T] with fn mentions_component(
   self,
@@ -403,6 +499,20 @@ pub impl[T] QueryFilter for Without[T] with fn matches(self, world, entity) {
   !entity_has_component_id(world, self.key.id(), entity)
 }
 
+///|
+pub impl[T] QueryFilter for Without[T] with fn bind_table_row_matcher(
+  self,
+  world,
+  table_id,
+) {
+  let matches = match world.local_component_id(self.key.id()) {
+    Some(local_component_id) =>
+      !world.table_has_component_local_id(table_id, local_component_id)
+    None => true
+  }
+  fn(_entity, _row_index) { matches }
+}
+
 ///|
 pub impl[T] QueryFilter for Without[T] with fn mentions_component(
   self,
@@ -463,6 +573,16 @@ pub impl[T] QueryFilter for Allow[T] with fn matches(self, _world, _entity) {
   true
 }
 
+///|
+pub impl[T] QueryFilter for Allow[T] with fn bind_table_row_matcher(
+  self,
+  _world,
+  _table_id,
+) {
+  ignore(self)
+  fn(_entity, _row_index) { true }
+}
+
 ///|
 pub impl[T] QueryFilter for Allow[T] with fn mentions_component(
   self,
@@ -571,6 +691,15 @@ pub impl[T] QueryFilter for Added[T] with fn matches_table_row(
   query_filter_table_added_matches(world, self.key.id(), table_id, row_index)
 }
 
+///|
+pub impl[T] QueryFilter for Added[T] with fn bind_table_row_matcher(
+  self,
+  world,
+  table_id,
+) {
+  query_filter_bind_table_added_matcher(world, self.key.id(), table_id)
+}
+
 ///|
 pub impl[T] QueryFilter for Added[T] with fn is_dense(self, world) {
   query_filter_component_is_dense(world, self.key.id())
@@ -649,6 +778,15 @@ pub impl[T] QueryFilter for Changed[T] with fn matches_table_row(
   query_filter_table_changed_matches(world, self.key.id(), table_id, row_index)
 }
 
+///|
+pub impl[T] QueryFilter for Changed[T] with fn bind_table_row_matcher(
+  self,
+  world,
+  table_id,
+) {
+  query_filter_bind_table_changed_matcher(world, self.key.id(), table_id)
+}
+
 ///|
 pub impl[T] QueryFilter for Changed[T] with fn is_dense(self, world) {
   query_filter_component_is_dense(world, self.key.id())
@@ -701,6 +839,19 @@ pub impl[F : QueryFilterDisjunction] QueryFilter for Or[F] with fn matches_table
   )
 }
 
+///|
+pub impl[F : QueryFilterDisjunction] QueryFilter for Or[F] with fn bind_table_row_matcher(
+  self,
+  world,
+  table_id,
+) {
+  QueryFilterDisjunction::bind_table_row_matcher_any(
+    self.filters,
+    world,
+    table_id,
+  )
+}
+
 ///|
 pub impl[F : QueryFilterDisjunction] QueryFilter for Or[F] with fn mentions_component(
   self,
@@ -791,6 +942,19 @@ pub impl[A : QueryFilter, B : QueryFilter] QueryFilter for (A, B) with fn matche
   QueryFilter::matches_table_row(self.1, world, entity, table_id, row_index)
 }
 
+///|
+pub impl[A : QueryFilter, B : QueryFilter] QueryFilter for (A, B) with fn bind_table_row_matcher(
+  self,
+  world,
+  table_id,
+) {
+  let matches_a = QueryFilter::bind_table_row_matcher(self.0, world, table_id)
+  let matches_b = QueryFilter::bind_table_row_matcher(self.1, world, table_id)
+  fn(entity, row_index) {
+    matches_a(entity, row_index) && matches_b(entity, row_index)
+  }
+}
+
 ///|
 pub impl[A : QueryFilter, B : QueryFilter] QueryFilter for (A, B) with fn mentions_component(
   self,
@@ -898,6 +1062,22 @@ pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter] QueryFilter for (
   QueryFilter::matches_table_row(self.2, world, entity, table_id, row_index)
 }
 
+///|
+pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter] QueryFilter for (
+  A,
+  B,
+  C,
+) with fn bind_table_row_matcher(self, world, table_id) {
+  let matches_a = QueryFilter::bind_table_row_matcher(self.0, world, table_id)
+  let matches_b = QueryFilter::bind_table_row_matcher(self.1, world, table_id)
+  let matches_c = QueryFilter::bind_table_row_matcher(self.2, world, table_id)
+  fn(entity, row_index) {
+    matches_a(entity, row_index) &&
+    matches_b(entity, row_index) &&
+    matches_c(entity, row_index)
+  }
+}
+
 ///|
 pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter] QueryFilter for (
   A,
@@ -1970,6 +2150,19 @@ pub impl[A : QueryFilter, B : QueryFilter] QueryFilterDisjunction for (A, B) wit
   QueryFilter::matches_table_row(self.1, world, entity, table_id, row_index)
 }
 
+///|
+pub impl[A : QueryFilter, B : QueryFilter] QueryFilterDisjunction for (A, B) with fn bind_table_row_matcher_any(
+  self,
+  world,
+  table_id,
+) {
+  let matches_a = QueryFilter::bind_table_row_matcher(self.0, world, table_id)
+  let matches_b = QueryFilter::bind_table_row_matcher(self.1, world, table_id)
+  fn(entity, row_index) {
+    matches_a(entity, row_index) || matches_b(entity, row_index)
+  }
+}
+
 ///|
 pub impl[A : QueryFilter, B : QueryFilter] QueryFilterDisjunction for (A, B) with fn mentions_component_any(
   self,
@@ -2051,6 +2244,22 @@ pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter] QueryFilterDisjuncti
   QueryFilter::matches_table_row(self.2, world, entity, table_id, row_index)
 }
 
+///|
+pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter] QueryFilterDisjunction for (
+  A,
+  B,
+  C,
+) with fn bind_table_row_matcher_any(self, world, table_id) {
+  let matches_a = QueryFilter::bind_table_row_matcher(self.0, world, table_id)
+  let matches_b = QueryFilter::bind_table_row_matcher(self.1, world, table_id)
+  let matches_c = QueryFilter::bind_table_row_matcher(self.2, world, table_id)
+  fn(entity, row_index) {
+    matches_a(entity, row_index) ||
+    matches_b(entity, row_index) ||
+    matches_c(entity, row_index)
+  }
+}
+
 ///|
 pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter] QueryFilterDisjunction for (
   A,
@@ -2154,6 +2363,25 @@ pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter, D : QueryFilter] Que
   QueryFilter::matches_table_row(self.3, world, entity, table_id, row_index)
 }
 
+///|
+pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter, D : QueryFilter] QueryFilterDisjunction for (
+  A,
+  B,
+  C,
+  D,
+) with fn bind_table_row_matcher_any(self, world, table_id) {
+  let matches_a = QueryFilter::bind_table_row_matcher(self.0, world, table_id)
+  let matches_b = QueryFilter::bind_table_row_matcher(self.1, world, table_id)
+  let matches_c = QueryFilter::bind_table_row_matcher(self.2, world, table_id)
+  let matches_d = QueryFilter::bind_table_row_matcher(self.3, world, table_id)
+  fn(entity, row_index) {
+    matches_a(entity, row_index) ||
+    matches_b(entity, row_index) ||
+    matches_c(entity, row_index) ||
+    matches_d(entity, row_index)
+  }
+}
+
 ///|
 pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter, D : QueryFilter] QueryFilterDisjunction for (
   A,
diff --git a/mgstudio-engine/ecs/finalizer_test.mbt b/mgstudio-engine/ecs/finalizer_test.mbt
index 430e6247f..fd8ade294 100644
--- a/mgstudio-engine/ecs/finalizer_test.mbt
+++ b/mgstudio-engine/ecs/finalizer_test.mbt
@@ -17,6 +17,63 @@ struct FinalizerProbe {
   id : Int
 }
 
+///|
+struct BypassFinalizerProbe {
+  id : Int
+}
+
+///|
+let bypass_finalized_values : Array[Int] = []
+
+///|
+let bypass_finalizer_probe_key : ComponentKey[BypassFinalizerProbe] = register_component(
+  debug_name="tests.ecs.bypass_finalizer_component",
+  finalizer=fn(value) { bypass_finalized_values.push(value.id) },
+)
+
+///|
+pub impl Component for BypassFinalizerProbe with fn component() {
+  bypass_finalizer_probe_key
+}
+
+///|
+test "ecs: bypass change detection preserves same-reference ownership" {
+  bypass_finalized_values.clear()
+  let world = World::new()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, bypass_finalizer_probe_key, { id: 1 })
+  let component = (try! world.get_mut(entity, key=bypass_finalizer_probe_key)).unwrap()
+
+  component.bypass_change_detection(fn(value) { value })
+  let finalized_before_close = bypass_finalized_values.length()
+  world.close()
+
+  debug_inspect(
+    (finalized_before_close, bypass_finalized_values),
+    content="(0, [1])",
+  )
+}
+
+///|
+test "ecs: bypass change detection finalizes a distinct replacement" {
+  bypass_finalized_values.clear()
+  let world = World::new()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, bypass_finalizer_probe_key, { id: 1 })
+  let component = (try! world.get_mut(entity, key=bypass_finalizer_probe_key)).unwrap()
+
+  component.bypass_change_detection(fn(_value) {
+    BypassFinalizerProbe::{ id: 2 }
+  })
+  let finalized_before_close = bypass_finalized_values.copy()
+  world.close()
+
+  debug_inspect(
+    (finalized_before_close, bypass_finalized_values),
+    content="([1], [1, 2])",
+  )
+}
+
 ///|
 test "ecs: finalizers distinguish value transfer from destruction" {
   let resource_finalized : Array[Int] = []
@@ -40,8 +97,16 @@ test "ecs: finalizers distinguish value transfer from destruction" {
   try! world.set_by_key(first, component_key, { id: 3 })
   try! world.set_by_key(first, component_key, { id: 4 })
   try! world.despawn(first)
+  let rejected = world.spawn_empty()
+  try! world.despawn(rejected)
+  try world.set_by_key(rejected, component_key, { id: 8 }) catch {
+    EntityNotAlive(_) => ()
+    _ => fail("expected stale entity insertion to be rejected")
+  } noraise {
+    _ => fail("expected stale entity insertion to fail")
+  }
   debug_inspect(resource_finalized, content="[1]")
-  debug_inspect(component_finalized, content="[3, 4]")
+  debug_inspect(component_finalized, content="[3, 4, 8]")
 
   world.insert_resource(resource_key, { id: 5 })
   debug_inspect(world.drop_resource(resource_key), content="true")
@@ -49,8 +114,15 @@ test "ecs: finalizers distinguish value transfer from destruction" {
   world.insert_resource(resource_key, { id: 7 })
   let second = world.spawn_empty()
   try! world.set_by_key(second, component_key, { id: 6 })
+  let transferred = world.spawn_empty()
+  try! world.set_by_key(transferred, component_key, { id: 9 })
+  debug_inspect(
+    (try! world.take(transferred, component_key)).map(fn(value) { value.id }),
+    content="Some(9)",
+  )
+  debug_inspect(component_finalized, content="[3, 4, 8]")
   world.close()
   world.close()
   debug_inspect(resource_finalized, content="[1, 5, 7]")
-  debug_inspect(component_finalized, content="[3, 4, 6]")
+  debug_inspect(component_finalized, content="[3, 4, 8, 6]")
 }
diff --git a/mgstudio-engine/ecs/pkg.generated.mbti b/mgstudio-engine/ecs/pkg.generated.mbti
index 79c31600d..3136c18a3 100644
--- a/mgstudio-engine/ecs/pkg.generated.mbti
+++ b/mgstudio-engine/ecs/pkg.generated.mbti
@@ -82,6 +82,7 @@ pub(all) suberror EcsError {
   EventTypeMismatch(Int, String, Int, String)
   MessageTypeMismatch(Int, String, Int, String)
   WorldClosed(Int)
+  TableBatchUnavailable(String)
   ForeignEntityReservation(@core.Entity, Int, Int)
   StaleEntityReservation(@core.Entity)
 }
@@ -561,6 +562,7 @@ pub fn[D, F] Query::cache_state(Self[D, F]) -> QueryCache
 pub fn[D : QueryData, F : QueryFilter] Query::contiguous_iter(Self[D, F]) -> QueryContiguousIter[D, F]?
 pub fn[D : QueryData, F : QueryFilter] Query::count(Self[D, F]) -> Int
 pub fn[D : QueryData, F : QueryFilter] Query::for_each(Self[D, F], (@core.Entity, D) -> Unit) -> Unit raise EcsError
+pub fn[D : QueryData, F : QueryFilter] Query::for_each_table(Self[D, F], (QueryTableBatch) -> Unit raise EcsError) -> Unit raise EcsError
 pub fn[D : QueryData, F : QueryFilter] Query::get(Self[D, F], @core.Entity) -> D? raise EcsError
 pub fn[D, F] Query::is_active(Self[D, F]) -> Bool
 pub fn[D : QueryData, F : QueryFilter] Query::iter(Self[D, F]) -> QueryMany[D, F]
@@ -571,6 +573,7 @@ pub fn[D : QueryData, F : QueryFilter] Query::iter_many_unique_unsafe(Self[D, F]
 pub fn[D, F] Query::par_iter(Self[D, F]) -> QueryParallel[D, F]
 pub fn[D : QueryData, F : QueryFilter] Query::require_single(Self[D, F]) -> D raise
 pub fn[D : QueryData, F : QueryFilter] Query::single(Self[D, F]) -> D? raise EcsError
+pub fn[D : QueryData, F : QueryFilter] Query::try_for_each_filtered_table(Self[D, F], (QueryTableBatch, QueryTableRows) -> Unit raise EcsError) -> Bool raise EcsError
 pub fn[D : QueryData, F : QueryFilter] Query::view(Self[D, F], (@core.Entity, D) -> Unit) -> Unit raise EcsError
 
 pub struct QueryCache {
@@ -631,6 +634,10 @@ pub(all) struct QueryDataSparseAnchorFetch {
   // private fields
 }
 
+pub(all) struct QueryDataTableBinding {
+  // private fields
+}
+
 pub(all) struct QueryDataTableRowFetch {
   // private fields
 }
@@ -670,6 +677,23 @@ pub fn[D : QueryData, F : QueryFilter] QueryState::iter_many(Self[D, F], World,
 pub fn[D : QueryData, F : QueryFilter] QueryState::require_single(Self[D, F], World) -> D raise
 pub fn[D : QueryData, F : QueryFilter] QueryState::single(Self[D, F], World) -> D? raise EcsError
 
+pub struct QueryTableBatch {
+  // private fields
+}
+pub fn QueryTableBatch::entity(Self, Int) -> @core.Entity
+pub fn[T] QueryTableBatch::has(Self, ComponentKey[T]) -> Bool
+pub fn QueryTableBatch::length(Self) -> Int
+pub fn[T] QueryTableBatch::read(Self, ComponentKey[T]) -> TableBatchRead[T]?
+pub fn QueryTableBatch::with_entities(Self, (ArrayView[@core.Entity]) -> Unit) -> Unit
+pub fn[T] QueryTableBatch::write(Self, ComponentKey[T]) -> TableBatchWrite[T]?
+
+pub struct QueryTableRows {
+  // private fields
+}
+pub fn QueryTableRows::for_each(Self, (Int) -> Unit raise EcsError) -> Unit raise EcsError
+pub fn[T] QueryTableRows::with_read_values(Self, TableBatchRead[T], (ArrayView[T]) -> Unit) -> Unit
+pub fn[T] QueryTableRows::with_write_values(Self, TableBatchWrite[T], (ArrayView[T]) -> Unit) -> Unit
+
 type RawTable
 
 pub(all) struct RawTableColumn {
@@ -680,7 +704,7 @@ pub(all) struct RawTableColumn {
 pub(all) struct RawTableColumnKernel {
   mut added_ticks : Array[Int64]
   mut changed_ticks : Array[Int64]
-  mut changed_caller_ids : Array[Int]
+  changed_caller_ids : Array[Int]?
 }
 
 pub struct Read[T] {
@@ -695,6 +719,13 @@ pub fn[T] Read::last_changed(Self[T]) -> Int64
 pub fn[T] Read::value(Self[T]) -> T
 pub impl[T : Component] QueryData for Read[T]
 
+pub struct ReadValue[T] {
+  // private fields
+}
+pub fn[T] ReadValue::key(Self[T]) -> ComponentKey[T]
+pub fn[T] ReadValue::value(Self[T]) -> T
+pub impl[T : Component] QueryData for ReadValue[T]
+
 pub struct Remove {
 }
 pub impl ComponentObserverEvent for Remove
@@ -764,6 +795,58 @@ pub fn[T : Eq] ResourceMut::set_if_neq(Self[T], T, loc~ : SourceLoc) -> Bool
 #callsite(autofill(loc))
 pub fn[T] ResourceMut::update(Self[T], (T) -> T, loc~ : SourceLoc) -> Unit
 
+pub struct TableBatchChangeWriter {
+  // private fields
+}
+pub fn TableBatchChangeWriter::set_changed(Self, Int) -> Unit
+
+pub struct TableBatchMutValues[T] {
+  // private fields
+}
+pub fn[T] TableBatchMutValues::length(Self[T]) -> Int
+pub fn[T] TableBatchMutValues::op_get(Self[T], Int) -> T
+pub fn[T] TableBatchMutValues::op_set(Self[T], Int, T) -> Unit
+
+pub struct TableBatchRead[T] {
+  // private fields
+}
+pub fn[T] TableBatchRead::added(Self[T], Int) -> Int64
+pub fn[T] TableBatchRead::changed_by(Self[T], Int) -> String?
+pub fn[T] TableBatchRead::is_added(Self[T], Int) -> Bool
+pub fn[T] TableBatchRead::is_changed(Self[T], Int) -> Bool
+pub fn[T] TableBatchRead::key(Self[T]) -> ComponentKey[T]
+pub fn[T] TableBatchRead::last_changed(Self[T], Int) -> Int64
+pub fn[T] TableBatchRead::value(Self[T], Int) -> T
+pub fn[T] TableBatchRead::with_values(Self[T], (ArrayView[T]) -> Unit) -> Unit
+
+pub struct TableBatchWrite[T] {
+  // private fields
+}
+pub fn[T] TableBatchWrite::added(Self[T], Int) -> Int64
+pub fn[T] TableBatchWrite::bypass_change_detection(Self[T], Int, (T) -> T) -> Unit
+pub fn[T] TableBatchWrite::changed_by(Self[T], Int) -> String?
+pub fn[T] TableBatchWrite::is_added(Self[T], Int) -> Bool
+pub fn[T] TableBatchWrite::is_changed(Self[T], Int) -> Bool
+pub fn[T] TableBatchWrite::key(Self[T]) -> ComponentKey[T]
+pub fn[T] TableBatchWrite::last_changed(Self[T], Int) -> Int64
+#callsite(autofill(loc))
+pub fn[T, R] TableBatchWrite::modify(Self[T], Int, (T) -> R, loc~ : SourceLoc) -> R
+pub fn[T] TableBatchWrite::peek(Self[T], Int) -> T
+#callsite(autofill(loc))
+pub fn[T] TableBatchWrite::set(Self[T], Int, T, loc~ : SourceLoc) -> Unit
+#callsite(autofill(loc))
+pub fn[T : Component] TableBatchWrite::set_added(Self[T], Int, loc~ : SourceLoc) -> Unit
+#callsite(autofill(loc))
+pub fn[T : Component] TableBatchWrite::set_changed(Self[T], Int, loc~ : SourceLoc) -> Unit
+#callsite(autofill(loc))
+pub fn[T : Eq] TableBatchWrite::set_if_neq(Self[T], Int, T, loc~ : SourceLoc) -> Bool
+#callsite(autofill(loc))
+pub fn[T] TableBatchWrite::update_inplace(Self[T], (TableBatchMutValues[T]) -> Unit, loc~ : SourceLoc) -> Unit
+pub fn[T] TableBatchWrite::update_inplace_bypass_change_detection(Self[T], (TableBatchMutValues[T]) -> Unit) -> Unit
+pub fn[T] TableBatchWrite::value(Self[T], Int) -> T
+#callsite(autofill(loc))
+pub fn[T : Component] TableBatchWrite::with_change_writer(Self[T], (TableBatchChangeWriter) -> Unit, loc~ : SourceLoc) -> Unit
+
 type TriggerObserverContext
 
 pub struct With[T] {
@@ -864,7 +947,7 @@ pub fn[T] World::mark_resource_changed(Self, ResourceKey[T], caller? : String?)
 pub fn[T] World::message_mutator(Self, MessageKey[T], cursor? : MessageCursor[T]) -> MessageMutator[T]
 pub fn[T] World::message_reader(Self, MessageKey[T], cursor? : MessageCursor[T]) -> MessageReader[T]
 pub fn[T] World::message_writer(Self, MessageKey[T]) -> MessageWriter[T]
-pub fn World::new() -> Self
+pub fn World::new(track_change_locations? : Bool) -> Self
 pub fn World::pending_entity_reservation_count(Self) -> Int
 pub fn[D] World::query(Self) -> QueryState[D, All]
 pub fn[F] World::query_entities_filtered(Self, F) -> Query[@core.Entity, F]
@@ -912,6 +995,7 @@ pub fn World::spawn_reserved(Self, EntityReservation) -> @core.Entity raise EcsE
 pub fn World::structural_generation(Self) -> Int
 #callsite(autofill(loc))
 pub fn[T] World::take(Self, @core.Entity, ComponentKey[T], loc~ : SourceLoc) -> T? raise EcsError
+pub fn World::tracks_change_locations(Self) -> Bool
 pub fn[E : TriggerEvent] World::trigger(Self, E, caller? : String?) -> Unit
 pub fn[T, R : Default] World::try_register_required_components(Self, ComponentKey[T], ComponentKey[R]) -> Unit raise RequiredComponentsError
 pub fn[T, R] World::try_register_required_components_with(Self, ComponentKey[T], ComponentKey[R], () -> R) -> Unit raise RequiredComponentsError
@@ -958,6 +1042,7 @@ pub struct Write[T] {
   // private fields
 }
 pub fn[T] Write::added(Self[T]) -> Int64
+pub fn[T] Write::bypass_change_detection(Self[T], (T) -> T) -> Unit
 pub fn[T] Write::changed_by(Self[T]) -> String?
 pub fn[T] Write::is_added(Self[T]) -> Bool
 pub fn[T] Write::is_changed(Self[T]) -> Bool
@@ -1020,6 +1105,7 @@ pub(open) trait QueryData {
   fn fetch_table_row(QueryDataTableRowFetch) -> Self raise EcsError = _
   fn fetch_table_row_with_plan_offset(QueryDataPlannedFetch) -> Self raise EcsError = _
   fn fetch_sparse_anchor_with_plan_offset(QueryDataSparseAnchorFetch) -> Self raise EcsError = _
+  fn bind_table_fetch(QueryDataTableBinding) -> (@core.Entity, Int) -> Self raise EcsError = _
   fn mentions_component(Int) -> Bool
   fn matches_component_set((Int) -> Bool) -> Bool
   fn collect_access(QueryDataAccess) -> Unit = _
@@ -1044,6 +1130,7 @@ pub impl[A : QueryData, B : QueryData, C : QueryData, D : QueryData, E : QueryDa
 pub(open) trait QueryFilter {
   fn matches(Self, World, @core.Entity) -> Bool
   fn matches_table_row(Self, World, @core.Entity, Int, Int) -> Bool = _
+  fn bind_table_row_matcher(Self, World, Int) -> (@core.Entity, Int) -> Bool = _
   fn mentions_component(Self, Int) -> Bool
   fn matches_component_set(Self, (Int) -> Bool) -> Bool
   fn collect_access(Self, QueryFilterAccess) -> Unit = _
@@ -1065,6 +1152,7 @@ pub impl[A : QueryFilter, B : QueryFilter, C : QueryFilter, D : QueryFilter, E :
 pub(open) trait QueryFilterDisjunction {
   fn matches_any(Self, World, @core.Entity) -> Bool
   fn matches_table_row_any(Self, World, @core.Entity, Int, Int) -> Bool = _
+  fn bind_table_row_matcher_any(Self, World, Int) -> (@core.Entity, Int) -> Bool = _
   fn mentions_component_any(Self, Int) -> Bool
   fn matches_component_set_any(Self, (Int) -> Bool) -> Bool
   fn collect_access_any(Self, QueryFilterAccess) -> Unit = _
diff --git a/mgstudio-engine/ecs/query.mbt b/mgstudio-engine/ecs/query.mbt
index da657e541..a79234a36 100644
--- a/mgstudio-engine/ecs/query.mbt
+++ b/mgstudio-engine/ecs/query.mbt
@@ -239,6 +239,7 @@ priv struct QueryIterationPlan {
 ///|
 pub struct QueryMany[D, F] {
   priv query : Query[D, F]
+  priv structural_generation : Int
   priv data_fetch_plan : QueryDataFetchPlan
   priv default_filter_component_ids : Array[Int]
   priv entities_pre_matched : Bool
@@ -255,6 +256,7 @@ pub struct QueryMany[D, F] {
   priv mut dense_table_entities : Array[@core.Entity]
   priv mut dense_table_row_count : Int
   priv mut dense_table_row_index : Int
+  priv mut dense_table_fetch : ((@core.Entity, Int) -> D raise EcsError)?
   priv sparse_anchor_info : QuerySparseAnchorInfo?
   priv sparse_anchor_entities : Array[@core.Entity]
   priv mut sparse_anchor_index : Int
@@ -544,6 +546,7 @@ fn[D, F] query_many_from_plan(
 ) -> QueryMany[D, F] {
   {
     query,
+    structural_generation: query.world_or_abort().structural_generation(),
     data_fetch_plan: plan.data_fetch_plan,
     default_filter_component_ids: plan.default_filter_component_ids,
     entities_pre_matched: plan.entities_pre_matched,
@@ -560,6 +563,7 @@ fn[D, F] query_many_from_plan(
     dense_table_entities: [],
     dense_table_row_count: 0,
     dense_table_row_index: 0,
+    dense_table_fetch: None,
     sparse_anchor_info: plan.sparse_anchor_info,
     sparse_anchor_entities: match plan.sparse_anchor_info {
       Some(anchor_info) =>
@@ -982,9 +986,7 @@ pub fn[D : QueryData, F : QueryFilter] Query::view(
   self.world_or_abort().begin_query_iteration()
   try {
     let iter = self.iter()
-    while iter.fetch_next() is Some((entity, item)) {
-      f(entity, item)
-    }
+    iter.for_each_remaining(f)
     self.world_or_abort().end_query_iteration()
   } catch {
     err => {
@@ -1199,6 +1201,7 @@ pub fn[D : QueryData, F : QueryFilter] Query::iter_many(
 ) -> QueryMany[D, F] {
   {
     query: self,
+    structural_generation: self.world_or_abort().structural_generation(),
     data_fetch_plan: D::prepare_fetch_plan(self.world_or_abort()),
     default_filter_component_ids: self.default_filter_component_ids(),
     entities_pre_matched: false,
@@ -1215,6 +1218,7 @@ pub fn[D : QueryData, F : QueryFilter] Query::iter_many(
     dense_table_entities: [],
     dense_table_row_count: 0,
     dense_table_row_index: 0,
+    dense_table_fetch: None,
     sparse_anchor_info: None,
     sparse_anchor_entities: [],
     sparse_anchor_index: 0,
@@ -2071,6 +2075,7 @@ pub fn[D : QueryData, F : QueryFilter] QueryState::iter_many(
   let query : Query[D, F] = query_filtered(world, self.filter)
   {
     query,
+    structural_generation: world.structural_generation(),
     data_fetch_plan: self.data_fetch_plan(world),
     default_filter_component_ids: self.default_filter_component_ids(world),
     entities_pre_matched: false,
@@ -2087,6 +2092,7 @@ pub fn[D : QueryData, F : QueryFilter] QueryState::iter_many(
     dense_table_entities: [],
     dense_table_row_count: 0,
     dense_table_row_index: 0,
+    dense_table_fetch: None,
     sparse_anchor_info: None,
     sparse_anchor_entities: [],
     sparse_anchor_index: 0,
@@ -2572,53 +2578,91 @@ fn[D : QueryData, F : QueryFilter] QueryState::query_matching_tables(
   }
 }
 
+///|
+fn[D : QueryData, F : QueryFilter] QueryMany::dense_next_entity(
+  self : QueryMany[D, F],
+) -> @core.Entity? {
+  while true {
+    if self.current_table_id >= 0 {
+      while self.dense_table_row_index < self.dense_table_row_count {
+        let row_index = self.dense_table_row_index
+        self.dense_table_row_index = self.dense_table_row_index + 1
+        let entity = self.dense_table_entities[row_index]
+        if query_filter_matches_table_row_if_needed(
+            self.query.world_or_abort(),
+            self.query.filter,
+            self.table_row_filter_required,
+            entity,
+            self.current_table_id,
+            row_index,
+          ) {
+          return Some(entity)
+        }
+      }
+    }
+    if self.dense_table_index >= self.dense_tables.length() {
+      return None
+    }
+    self.current_table_id = self.dense_tables[self.dense_table_index]
+    self.dense_table_index = self.dense_table_index + 1
+    self.dense_table_entities = match
+      self.query.world_or_abort().table_entities_view(self.current_table_id) {
+      Some(entities) => entities
+      None => []
+    }
+    self.dense_table_row_count = self.dense_table_entities.length()
+    self.dense_table_row_index = 0
+    self.dense_table_fetch = Some(
+      D::bind_table_fetch({
+        world: self.query.world_or_abort(),
+        table_id: self.current_table_id,
+        plan: self.data_fetch_plan,
+        offset: 0,
+      }),
+    )
+  }
+  abort("Dense query cursor unexpectedly terminated")
+}
+
+///|
+fn[D, F] QueryMany::fetch_dense_current(
+  self : QueryMany[D, F],
+  entity : @core.Entity,
+) -> D raise EcsError {
+  guard self.dense_table_fetch is Some(fetch_row) else {
+    abort("Dense query table fetch was not bound")
+  }
+  fetch_row(entity, self.dense_table_row_index - 1)
+}
+
+///|
+fn[D : QueryData, F : QueryFilter] QueryMany::for_each_remaining(
+  self : QueryMany[D, F],
+  f : (@core.Entity, D) -> Unit,
+) -> Unit raise EcsError {
+  if self.dense_driven {
+    while self.dense_next_entity() is Some(entity) {
+      f(entity, self.fetch_dense_current(entity))
+    }
+    return
+  }
+  while self.fetch_next() is Some((entity, item)) {
+    f(entity, item)
+  }
+}
+
 ///|
 pub fn[D : QueryData, F : QueryFilter] QueryMany::fetch_next(
   self : QueryMany[D, F],
 ) -> (@core.Entity, D)? raise EcsError {
+  let world = self.query.world_or_abort()
+  if world.structural_generation() != self.structural_generation {
+    abort("QueryMany used after a structural World change")
+  }
   if self.dense_driven {
-    while true {
-      if self.current_table_id >= 0 {
-        while self.dense_table_row_index < self.dense_table_row_count {
-          let row_index = self.dense_table_row_index
-          self.dense_table_row_index = self.dense_table_row_index + 1
-          let entity = self.dense_table_entities[row_index]
-          if query_filter_matches_table_row_if_needed(
-              self.query.world_or_abort(),
-              self.query.filter,
-              self.table_row_filter_required,
-              entity,
-              self.current_table_id,
-              row_index,
-            ) {
-            return Some(
-              (
-                entity,
-                D::fetch_table_row_with_plan_offset(
-                  query_data_table_row_fetch(
-                    self.query.world_or_abort(),
-                    entity,
-                    self.current_table_id,
-                    row_index,
-                  ).planned(self.data_fetch_plan, 0),
-                ),
-              ),
-            )
-          }
-        }
-      }
-      if self.dense_table_index >= self.dense_tables.length() {
-        return None
-      }
-      self.current_table_id = self.dense_tables[self.dense_table_index]
-      self.dense_table_index = self.dense_table_index + 1
-      self.dense_table_entities = match
-        self.query.world_or_abort().table_entities_view(self.current_table_id) {
-        Some(entities) => entities
-        None => []
-      }
-      self.dense_table_row_count = self.dense_table_entities.length()
-      self.dense_table_row_index = 0
+    return match self.dense_next_entity() {
+      Some(entity) => Some((entity, self.fetch_dense_current(entity)))
+      None => None
     }
   }
   match self.sparse_anchor_info {
diff --git a/mgstudio-engine/ecs/query_data.mbt b/mgstudio-engine/ecs/query_data.mbt
index 4fa794400..a3d70c29d 100644
--- a/mgstudio-engine/ecs/query_data.mbt
+++ b/mgstudio-engine/ecs/query_data.mbt
@@ -43,6 +43,14 @@ pub(all) struct QueryDataSparseAnchorFetch {
   priv offset : Int
 }
 
+///|
+pub(all) struct QueryDataTableBinding {
+  priv world : World
+  priv table_id : Int
+  priv plan : QueryDataFetchPlan
+  priv offset : Int
+}
+
 ///|
 fn query_data_table_row_fetch(
   world : World,
@@ -93,6 +101,14 @@ fn QueryDataSparseAnchorFetch::with_offset(
   }
 }
 
+///|
+fn QueryDataTableBinding::with_offset(
+  self : QueryDataTableBinding,
+  offset : Int,
+) -> QueryDataTableBinding {
+  { world: self.world, table_id: self.table_id, plan: self.plan, offset }
+}
+
 ///|
 fn QueryDataFetchPlan::new() -> QueryDataFetchPlan {
   {
@@ -211,6 +227,25 @@ fn[T] QueryDataFetchPlan::value_at_table_row(
   }
 }
 
+///|
+fn[T] QueryDataFetchPlan::value_at_table_row_unchecked(
+  self : QueryDataFetchPlan,
+  world : World,
+  key : ComponentKey[T],
+  offset : Int,
+  table_id : Int,
+  row_index : Int,
+) -> T {
+  guard self.cached_table_column(world, offset, table_id) is Some(column_ref) else {
+    abort("Required planned fetch used a missing table column")
+  }
+  if row_index < 0 ||
+    row_index >= raw_table_column_kernel_len(column_ref.storage) {
+    abort("Required planned fetch row is out of bounds")
+  }
+  key.component_get_table_row_unchecked(world, table_id, row_index)
+}
+
 ///|
 pub(open) trait QueryData {
   fn matches(World, @core.Entity) -> Bool
@@ -221,6 +256,7 @@ pub(open) trait QueryData {
   fn fetch_table_row(QueryDataTableRowFetch) -> Self raise EcsError = _
   fn fetch_table_row_with_plan_offset(QueryDataPlannedFetch) -> Self raise EcsError = _
   fn fetch_sparse_anchor_with_plan_offset(QueryDataSparseAnchorFetch) -> Self raise EcsError = _
+  fn bind_table_fetch(QueryDataTableBinding) -> (@core.Entity, Int) -> Self raise EcsError = _
   fn mentions_component(Int) -> Bool
   fn matches_component_set((Int) -> Bool) -> Bool
   fn collect_access(QueryDataAccess) -> Unit = _
@@ -283,6 +319,20 @@ impl QueryData with fn fetch_sparse_anchor_with_plan_offset(fetch) {
   })
 }
 
+///|
+impl QueryData with fn bind_table_fetch(binding) {
+  fn(entity, row_index) raise EcsError {
+    Self::fetch_table_row_with_plan_offset(
+      query_data_table_row_fetch(
+        binding.world,
+        entity,
+        binding.table_id,
+        row_index,
+      ).planned(binding.plan, binding.offset),
+    )
+  }
+}
+
 ///|
 impl QueryData with fn iteration_anchor_components() {
   []
@@ -299,6 +349,12 @@ pub struct Read[T] {
   priv is_changed : Bool
 }
 
+///|
+pub struct ReadValue[T] {
+  priv key : ComponentKey[T]
+  priv value : T
+}
+
 ///|
 priv struct QueryComponentTickSnapshot {
   added_tick : @core.Tick
@@ -375,6 +431,21 @@ pub fn[T] Read::changed_by(self : Read[T]) -> String? {
   self.changed_by
 }
 
+///|
+pub fn[T] ReadValue::key(self : ReadValue[T]) -> ComponentKey[T] {
+  self.key
+}
+
+///|
+/// Returns a queried component value without loading change metadata.
+///
+/// `ReadValue[T]` corresponds to Bevy's ordinary `&T` query item. Use
+/// `Read[T]` when the system also needs added ticks, changed ticks, or the
+/// changed caller.
+pub fn[T] ReadValue::value(self : ReadValue[T]) -> T {
+  self.value
+}
+
 ///|
 pub fn QueryDataAccess::add_read_component(
   self : QueryDataAccess,
@@ -621,19 +692,12 @@ fn[T] query_data_component_value_at_fetch_location(
   match
     query_data_component_storage_type_or_abort(fetch.world, local_component_id) {
     Table =>
-      match
-        fetch.world.component_value_by_table_row_fast(
-          key,
-          local_component_id,
-          fetch.table_id,
-          fetch.row_index,
-        ) {
-        Some(value) => value
-        None =>
-          abort(
-            "QueryData::fetch expected table component value at query table row",
-          )
-      }
+      fetch.world.component_value_by_table_row_unchecked(
+        key,
+        local_component_id,
+        fetch.table_id,
+        fetch.row_index,
+      )
     SparseSet => query_data_require_component(fetch.world, fetch.entity, key)
   }
 }
@@ -650,25 +714,41 @@ fn[T] query_data_component_value_at_planned_fetch_location(
       local_component_id,
     ) {
     Table =>
-      match
-        fetch.plan.value_at_table_row(
-          fetch.row.world,
-          key,
-          fetch.offset,
-          fetch.row.table_id,
-          fetch.row.row_index,
-        ) {
-        Some(value) => value
-        None =>
-          abort(
-            "QueryData::fetch expected planned table component value at query table row",
-          )
-      }
+      fetch.plan.value_at_table_row_unchecked(
+        fetch.row.world,
+        key,
+        fetch.offset,
+        fetch.row.table_id,
+        fetch.row.row_index,
+      )
     SparseSet =>
       query_data_require_component(fetch.row.world, fetch.row.entity, key)
   }
 }
 
+///|
+fn[T] query_data_bind_required_table_values(
+  binding : QueryDataTableBinding,
+  key : ComponentKey[T],
+) -> (Int, Array[T], RawTableColumn) {
+  let local_component_id = query_data_component_local_id_or_abort(
+    query_data_local_component_id_from_plan(binding.plan, binding.offset),
+  )
+  guard binding.plan.cached_table_column(
+      binding.world,
+      binding.offset,
+      binding.table_id,
+    )
+    is Some(column) else {
+    abort("Required query table binding used a missing raw column")
+  }
+  guard key.component_bind_table_values(binding.world, binding.table_id)
+    is Some(values) else {
+    abort("Required query table binding used a missing typed column")
+  }
+  (local_component_id, values, column)
+}
+
 ///|
 fn[T] query_data_optional_component_value_by_entity(
   world : World,
@@ -906,6 +986,38 @@ pub impl[T : Component] QueryData for Read[T] with fn fetch_plan_size() {
   1
 }
 
+///|
+pub impl[T : Component] QueryData for Read[T] with fn bind_table_fetch(binding) {
+  let key = T::component()
+  let (local_component_id, values, column) = query_data_bind_required_table_values(
+    binding, key,
+  )
+  ignore(local_component_id)
+  let system_ticks = binding.world.get_tick_context().ticks()
+  fn(_entity, row_index) {
+    if row_index < 0 || row_index >= values.length() {
+      abort("Read query bound table row is out of bounds")
+    }
+    let added_tick = query_data_tick_or_abort(
+      column.added_tick_at_row(row_index),
+      "added",
+    )
+    let changed_tick = query_data_tick_or_abort(
+      column.changed_tick_at_row(row_index),
+      "changed",
+    )
+    {
+      key,
+      value: values[row_index],
+      added_tick,
+      changed_tick,
+      changed_by: column.changed_caller_at_row(row_index),
+      is_added: system_ticks.contains(added_tick),
+      is_changed: system_ticks.contains(changed_tick),
+    }
+  }
+}
+
 ///|
 pub impl[T : Component] QueryData for Read[T] with fn fetch_table_row(fetch) {
   let key = T::component()
@@ -1007,6 +1119,159 @@ pub impl[T : Component] QueryData for Read[T] with fn contiguous_compatible() {
   true
 }
 
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn matches(
+  world,
+  entity,
+) {
+  query_data_component_matches(world, entity, T::component())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn fetch(world, entity) {
+  let key = T::component()
+  ReadValue::{ key, value: query_data_require_component(world, entity, key) }
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn append_fetch_plan(
+  world,
+  plan,
+) {
+  plan.push_component_id(world, T::component().id())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn fetch_plan_size() {
+  1
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn bind_table_fetch(
+  binding,
+) {
+  let key = T::component()
+  let (_local_component_id, values, _column) = query_data_bind_required_table_values(
+    binding, key,
+  )
+  fn(_entity, row_index) {
+    if row_index < 0 || row_index >= values.length() {
+      abort("ReadValue query bound table row is out of bounds")
+    }
+    ReadValue::{ key, value: values[row_index] }
+  }
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn fetch_table_row(
+  fetch,
+) {
+  let key = T::component()
+  let local_component_id = query_data_component_local_id_or_abort(
+    fetch.world.local_component_id(key.id()),
+  )
+  ReadValue::{
+    key,
+    value: query_data_component_value_at_fetch_location(
+      fetch, key, local_component_id,
+    ),
+  }
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn fetch_table_row_with_plan_offset(
+  fetch,
+) {
+  let key = T::component()
+  let local_component_id = query_data_component_local_id_or_abort(
+    query_data_local_component_id_from_plan(fetch.plan, fetch.offset),
+  )
+  ReadValue::{
+    key,
+    value: query_data_component_value_at_planned_fetch_location(
+      fetch, key, local_component_id,
+    ),
+  }
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn fetch_sparse_anchor_with_plan_offset(
+  fetch,
+) {
+  let key = T::component()
+  match query_data_local_component_id_from_plan(fetch.plan, fetch.offset) {
+    Some(local_component_id) if local_component_id ==
+      fetch.anchor_local_component_id =>
+      ReadValue::{
+        key,
+        value: query_data_require_component(
+          fetch.row.world,
+          fetch.row.entity,
+          key,
+        ),
+      }
+    _ =>
+      ReadValue::fetch_table_row_with_plan_offset({
+        row: fetch.row,
+        plan: fetch.plan,
+        offset: fetch.offset,
+      })
+  }
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn mentions_component(
+  component_id,
+) {
+  component_id == T::component().id()
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn matches_component_set(
+  set_contains_id,
+) {
+  set_contains_id(T::component().id())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn collect_access(
+  access,
+) {
+  access.add_read_component(T::component().id())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn collect_required_components(
+  access,
+) {
+  access.add_required_component(T::component().id())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn requires_entity_check() {
+  false
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn is_dense(world) {
+  query_data_component_is_dense(world, T::component().id())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn iteration_anchor_component() {
+  Some(T::component().id())
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn iteration_anchor_components() {
+  [T::component().id()]
+}
+
+///|
+pub impl[T : Component] QueryData for ReadValue[T] with fn contiguous_compatible() {
+  true
+}
+
 ///|
 pub impl[T : Component] QueryData for Write[T] with fn matches(world, entity) {
   query_data_component_matches(world, entity, T::component())
@@ -1030,6 +1295,28 @@ pub impl[T : Component] QueryData for Write[T] with fn fetch_plan_size() {
   1
 }
 
+///|
+pub impl[T : Component] QueryData for Write[T] with fn bind_table_fetch(binding) {
+  let key = T::component()
+  let (local_component_id, values, _column) = query_data_bind_required_table_values(
+    binding, key,
+  )
+  fn(entity, row_index) {
+    if row_index < 0 || row_index >= values.length() {
+      abort("Write query bound table row is out of bounds")
+    }
+    mut_from_component_location(
+      binding.world,
+      entity,
+      key,
+      local_component_id,
+      binding.table_id,
+      row_index,
+      bound_table_values=Some(values),
+    )
+  }
+}
+
 ///|
 pub impl[T : Component] QueryData for Write[T] with fn fetch_table_row(fetch) {
   let key = T::component()
@@ -1646,6 +1933,18 @@ pub impl[A : QueryData, B : QueryData] QueryData for (A, B) with fn fetch_plan_s
   A::fetch_plan_size() + B::fetch_plan_size()
 }
 
+///|
+pub impl[A : QueryData, B : QueryData] QueryData for (A, B) with fn bind_table_fetch(
+  binding,
+) {
+  let b_offset = binding.offset + A::fetch_plan_size()
+  let fetch_a = A::bind_table_fetch(binding)
+  let fetch_b = B::bind_table_fetch(binding.with_offset(b_offset))
+  fn(entity, row_index) raise EcsError {
+    (fetch_a(entity, row_index), fetch_b(entity, row_index))
+  }
+}
+
 ///|
 pub impl[A : QueryData, B : QueryData] QueryData for (A, B) with fn fetch_table_row(
   fetch,
@@ -1778,6 +2077,24 @@ pub impl[A : QueryData, B : QueryData, C : QueryData] QueryData for (A, B, C) wi
   A::fetch_plan_size() + B::fetch_plan_size() + C::fetch_plan_size()
 }
 
+///|
+pub impl[A : QueryData, B : QueryData, C : QueryData] QueryData for (A, B, C) with fn bind_table_fetch(
+  binding,
+) {
+  let b_offset = binding.offset + A::fetch_plan_size()
+  let c_offset = b_offset + B::fetch_plan_size()
+  let fetch_a = A::bind_table_fetch(binding)
+  let fetch_b = B::bind_table_fetch(binding.with_offset(b_offset))
+  let fetch_c = C::bind_table_fetch(binding.with_offset(c_offset))
+  fn(entity, row_index) raise EcsError {
+    (
+      fetch_a(entity, row_index),
+      fetch_b(entity, row_index),
+      fetch_c(entity, row_index),
+    )
+  }
+}
+
 ///|
 pub impl[A : QueryData, B : QueryData, C : QueryData] QueryData for (A, B, C) with fn fetch_table_row(
   fetch,
@@ -1956,6 +2273,30 @@ pub impl[A : QueryData, B : QueryData, C : QueryData, D : QueryData] QueryData f
   D::fetch_plan_size()
 }
 
+///|
+pub impl[A : QueryData, B : QueryData, C : QueryData, D : QueryData] QueryData for (
+  A,
+  B,
+  C,
+  D,
+) with fn bind_table_fetch(binding) {
+  let b_offset = binding.offset + A::fetch_plan_size()
+  let c_offset = b_offset + B::fetch_plan_size()
+  let d_offset = c_offset + C::fetch_plan_size()
+  let fetch_a = A::bind_table_fetch(binding)
+  let fetch_b = B::bind_table_fetch(binding.with_offset(b_offset))
+  let fetch_c = C::bind_table_fetch(binding.with_offset(c_offset))
+  let fetch_d = D::bind_table_fetch(binding.with_offset(d_offset))
+  fn(entity, row_index) raise EcsError {
+    (
+      fetch_a(entity, row_index),
+      fetch_b(entity, row_index),
+      fetch_c(entity, row_index),
+      fetch_d(entity, row_index),
+    )
+  }
+}
+
 ///|
 pub impl[A : QueryData, B : QueryData, C : QueryData, D : QueryData] QueryData for (
   A,
diff --git a/mgstudio-engine/ecs/query_mut_test.mbt b/mgstudio-engine/ecs/query_mut_test.mbt
index ac2d2143f..2b5c08be4 100644
--- a/mgstudio-engine/ecs/query_mut_test.mbt
+++ b/mgstudio-engine/ecs/query_mut_test.mbt
@@ -244,10 +244,89 @@ test "ecs query: view rejects structural removal" {
 }
 
 ///|
-test "ecs mut query: detect changes helpers support explicit mutation and marking" {
+test "panic ecs query: escaped iterator rejects an invalidated World lease" {
   let world = World::new()
   defer world.close()
   let entity = world.spawn()
+  try! world.set_by_key(entity, mut_query_position_key, MutQueryPosition::{
+    x: 1,
+    y: 2,
+  })
+  let lease = WorldLease::new(world)
+  let query : Query[ReadValue[MutQueryPosition], All] = query_filtered_with_cache_and_lease(
+    lease,
+    All::new(),
+    QueryCache::new(),
+  )
+  let iter = query.iter()
+  lease.invalidate()
+  ignore(try! iter.fetch_next())
+}
+
+///|
+test "panic ecs query: active view rejects World close" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, mut_query_position_key, MutQueryPosition::{
+    x: 1,
+    y: 2,
+  })
+  let query : Query[ReadValue[MutQueryPosition], All] = query(world)
+  try! query.view(fn(_entity, _position) { world.close() })
+}
+
+///|
+test "panic ecs query: escaped iterator rejects structural invalidation" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  try! world.set_by_key(first, mut_query_position_key, MutQueryPosition::{
+    x: 1,
+    y: 2,
+  })
+  let second = world.spawn()
+  try! world.set_by_key(second, mut_query_position_key, MutQueryPosition::{
+    x: 3,
+    y: 4,
+  })
+  let query : Query[ReadValue[MutQueryPosition], All] = query(world)
+  let iter = query.iter()
+  ignore(try! iter.fetch_next())
+  ignore(world.spawn())
+  ignore(try! iter.fetch_next())
+}
+
+///|
+test "ecs query: nested read-only views keep the outer scope active" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  try! world.set_by_key(first, mut_query_position_key, MutQueryPosition::{
+    x: 1,
+    y: 2,
+  })
+  let second = world.spawn()
+  try! world.set_by_key(second, mut_query_position_key, MutQueryPosition::{
+    x: 3,
+    y: 4,
+  })
+  let outer : Query[ReadValue[MutQueryPosition], All] = query(world)
+  let inner : Query[ReadValue[MutQueryPosition], All] = query(world)
+  let visits = Ref(0)
+  try! outer.view(fn(_outer_entity, _outer_position) {
+    try! inner.view(fn(_inner_entity, _inner_position) {
+      visits.val = visits.val + 1
+    })
+  })
+  debug_inspect(visits.val, content="4")
+}
+
+///|
+test "ecs mut query: detect changes helpers support explicit mutation and marking" {
+  let world = World::new(track_change_locations=true)
+  defer world.close()
+  let entity = world.spawn()
 
   try! world.set_by_key(entity, mut_query_position_key, MutQueryPosition::{
     x: 2,
@@ -307,6 +386,46 @@ test "ecs mut query: Write::modify persists method-style mutations" {
   )
 }
 
+///|
+test "ecs mut query: table-bound Write set replaces values and marks changes" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, mut_query_position_key, MutQueryPosition::{
+    x: 1,
+    y: 2,
+  })
+  try! world.set_by_key(second, mut_query_position_key, MutQueryPosition::{
+    x: 3,
+    y: 4,
+  })
+  world.increment_change_tick() |> ignore
+  set_test_tick(world, 0, 1)
+
+  let query : Query[Write[MutQueryPosition], All] = query(world)
+  try! query.for_each(fn(entity, position) {
+    position.set(MutQueryPosition::{ x: entity.id + 10, y: entity.id + 20 })
+  })
+
+  debug_inspect(
+    try! world.get_by_key(first, mut_query_position_key),
+    content="Some({ x: 10, y: 20 })",
+  )
+  debug_inspect(
+    try! world.get_by_key(second, mut_query_position_key),
+    content="Some({ x: 11, y: 21 })",
+  )
+  debug_inspect(
+    world.is_changed_by_key(
+      first,
+      mut_query_position_key,
+      @core.SystemTicks::new(0, 1),
+    ),
+    content="true",
+  )
+}
+
 ///|
 test "ecs mut query: QueryState supports get, require_single, iter_many_unique and mixed data" {
   let world = World::new()
diff --git a/mgstudio-engine/ecs/query_table_batch.mbt b/mgstudio-engine/ecs/query_table_batch.mbt
new file mode 100644
index 000000000..5694909a4
--- /dev/null
+++ b/mgstudio-engine/ecs/query_table_batch.mbt
@@ -0,0 +1,988 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+priv struct QueryTableBatchScope {
+  lease : WorldLease
+  table_id : Int
+  mut entities : Array[@core.Entity]?
+  whole_table : Bool
+  mut authorized_row : Int
+}
+
+///|
+priv struct QueryTableBatchColumnBinding[T] {
+  mut values : Array[T]?
+  mut column : RawTableColumn?
+}
+
+///|
+/// One matching dense ECS table.
+///
+/// The query data and filter used to create this batch remain the authority for
+/// component access and table selection. Bind only columns declared by the
+/// query. A batch is valid only for the duration of its `Query::for_each_table`
+/// callback.
+pub struct QueryTableBatch {
+  priv scope : QueryTableBatchScope
+  priv data_access : QueryDataAccess
+  priv data_mentions_component : (Int) -> Bool
+  priv filter_mentions_component : (Int) -> Bool
+  priv cleanups : Array[() -> Unit]
+}
+
+///|
+/// Exact matching rows for one dense query table.
+///
+/// The row matcher is bound once for the table and retains the query's full
+/// per-row filter semantics, including `Changed`, `Added`, and `Or`. Row
+/// indices are physical indices into the accompanying `QueryTableBatch`.
+pub struct QueryTableRows {
+  priv scope : QueryTableBatchScope
+  priv matches : (@core.Entity, Int) -> Bool
+}
+
+///|
+/// A read-only typed column bound once for a query table.
+pub struct TableBatchRead[T] {
+  priv scope : QueryTableBatchScope
+  priv binding : QueryTableBatchColumnBinding[T]
+  priv key : ComponentKey[T]
+}
+
+///|
+/// A writable typed column bound once for a query table.
+///
+/// Use the mutation methods on this type so component change ticks and changed
+/// messages remain synchronized. Direct mutable array access is intentionally
+/// not exposed.
+pub struct TableBatchWrite[T] {
+  priv scope : QueryTableBatchScope
+  priv binding : QueryTableBatchColumnBinding[T]
+  priv key : ComponentKey[T]
+  priv local_component_id : Int
+}
+
+///|
+/// A revocable mutable view of one complete table component column.
+///
+/// Values can be read and replaced with indexed syntax during the callback
+/// that receives this view. Every operation aborts after that callback returns;
+/// retaining the view never retains usable write access to the ECS column.
+pub struct TableBatchMutValues[T] {
+  priv mut active : Bool
+  priv values : MutArrayView[T]
+}
+
+///|
+fn[T] TableBatchMutValues::invalidate(self : TableBatchMutValues[T]) -> Unit {
+  self.active = false
+}
+
+///|
+fn[T] TableBatchMutValues::ensure_active(self : TableBatchMutValues[T]) -> Unit {
+  if !self.active {
+    abort("table batch mutable values used outside its callback")
+  }
+}
+
+///|
+pub fn[T] TableBatchMutValues::length(self : TableBatchMutValues[T]) -> Int {
+  self.ensure_active()
+  self.values.length()
+}
+
+///|
+pub fn[T] TableBatchMutValues::op_get(
+  self : TableBatchMutValues[T],
+  row_index : Int,
+) -> T {
+  self.ensure_active()
+  self.values[row_index]
+}
+
+///|
+pub fn[T] TableBatchMutValues::op_set(
+  self : TableBatchMutValues[T],
+  row_index : Int,
+  value : T,
+) -> Unit {
+  self.ensure_active()
+  self.values[row_index] = value
+}
+
+///|
+/// Callback-scoped change metadata writer for one bound table column.
+///
+/// The table column, change tick, and optional caller location are resolved
+/// once when the writer is created. Use this when reference-typed component
+/// values are mutated in place and only selected rows should be marked changed.
+/// The writer becomes invalid when its callback returns.
+pub struct TableBatchChangeWriter {
+  priv mut active : Bool
+  priv row_count : Int
+  priv scope : QueryTableBatchScope
+  priv column : RawTableColumn
+  priv tick : @core.Tick
+  priv caller_id : Int
+}
+
+///|
+fn TableBatchChangeWriter::invalidate(self : TableBatchChangeWriter) -> Unit {
+  self.active = false
+}
+
+///|
+pub fn TableBatchChangeWriter::set_changed(
+  self : TableBatchChangeWriter,
+  row_index : Int,
+) -> Unit {
+  if !self.active {
+    abort("table batch change writer used outside its callback")
+  }
+  if row_index < 0 || row_index >= self.row_count {
+    abort("table batch change writer row is out of bounds")
+  }
+  ignore(self.scope.entity_or_abort(row_index))
+  if !self.column.record_changed_id_at_row(row_index, self.tick, self.caller_id) {
+    abort("table batch change writer expected change tick metadata")
+  }
+}
+
+///|
+fn QueryTableBatchScope::world_or_abort(self : QueryTableBatchScope) -> World {
+  self.lease.world_or_abort()
+}
+
+///|
+fn QueryTableBatchScope::entities_or_abort(
+  self : QueryTableBatchScope,
+) -> Array[@core.Entity] {
+  ignore(self.world_or_abort())
+  match self.entities {
+    Some(entities) => entities
+    None => abort("table batch used outside its callback")
+  }
+}
+
+///|
+fn QueryTableBatchScope::entity_or_abort(
+  self : QueryTableBatchScope,
+  row_index : Int,
+) -> @core.Entity {
+  let entities = self.entities_or_abort()
+  if row_index < 0 || row_index >= entities.length() {
+    abort("table batch row is out of bounds")
+  }
+  if !self.whole_table && self.authorized_row != row_index {
+    abort(
+      "filtered table row access requires the matching QueryTableRows::for_each callback",
+    )
+  }
+  entities[row_index]
+}
+
+///|
+fn QueryTableBatchScope::with_authorized_row(
+  self : QueryTableBatchScope,
+  row_index : Int,
+  visit : (Int) -> Unit raise EcsError,
+) -> Unit raise EcsError {
+  let previous_row = self.authorized_row
+  self.authorized_row = row_index
+  defer {
+    self.authorized_row = previous_row
+  }
+  visit(row_index)
+}
+
+///|
+fn[T] QueryTableBatchColumnBinding::values_or_abort(
+  self : QueryTableBatchColumnBinding[T],
+) -> Array[T] {
+  match self.values {
+    Some(values) => values
+    None => abort("table batch column used outside its callback")
+  }
+}
+
+///|
+fn[T] QueryTableBatchColumnBinding::column_or_abort(
+  self : QueryTableBatchColumnBinding[T],
+) -> RawTableColumn {
+  match self.column {
+    Some(column) => column
+    None => abort("table batch column used outside its callback")
+  }
+}
+
+///|
+fn[T] QueryTableBatchColumnBinding::invalidate(
+  self : QueryTableBatchColumnBinding[T],
+) -> Unit {
+  self.values = None
+  self.column = None
+}
+
+///|
+fn QueryTableBatch::invalidate(self : QueryTableBatch) -> Unit {
+  for cleanup in self.cleanups {
+    cleanup()
+  }
+  self.cleanups.clear()
+  self.scope.entities = None
+  self.scope.lease.invalidate()
+}
+
+///|
+fn QueryTableBatch::allows_read(
+  self : QueryTableBatch,
+  component_id : Int,
+) -> Bool {
+  self.data_access.read_component_set.contains(component_id) ||
+  self.data_access.write_component_set.contains(component_id)
+}
+
+///|
+fn QueryTableBatch::allows_write(
+  self : QueryTableBatch,
+  component_id : Int,
+) -> Bool {
+  self.data_access.write_component_set.contains(component_id)
+}
+
+///|
+fn QueryTableBatch::mentions_component(
+  self : QueryTableBatch,
+  component_id : Int,
+) -> Bool {
+  (self.data_mentions_component)(component_id) ||
+  (self.filter_mentions_component)(component_id)
+}
+
+///|
+pub fn QueryTableBatch::length(self : QueryTableBatch) -> Int {
+  self.scope.entities_or_abort().length()
+}
+
+///|
+pub fn QueryTableBatch::entity(
+  self : QueryTableBatch,
+  row_index : Int,
+) -> @core.Entity {
+  self.scope.entity_or_abort(row_index)
+}
+
+///|
+/// Provides one callback-scoped view of this complete table's entity column.
+///
+/// The view covers only live entity rows and is valid only during `read`.
+/// Retaining it after the callback is invalid. This operation is available
+/// only from `Query::for_each_table`; filtered row batches must preserve their
+/// exact row matcher and use `QueryTableBatch::entity`.
+pub fn QueryTableBatch::with_entities(
+  self : QueryTableBatch,
+  read : (ArrayView[@core.Entity]) -> Unit,
+) -> Unit {
+  if !self.scope.whole_table {
+    abort("QueryTableBatch::with_entities requires Query::for_each_table")
+  }
+  let entities = self.scope.entities_or_abort()
+  read(entities[:])
+}
+
+///|
+/// Visits the physical table rows that satisfy the query filter.
+///
+/// This row set is valid only for the duration of its
+/// `Query::try_for_each_filtered_table` callback.
+pub fn QueryTableRows::for_each(
+  self : QueryTableRows,
+  visit : (Int) -> Unit raise EcsError,
+) -> Unit raise EcsError {
+  let entities = self.scope.entities_or_abort()
+  for row_index in 0..<entities.length() {
+    if (self.matches)(entities[row_index], row_index) {
+      self.scope.with_authorized_row(row_index, visit)
+    }
+  }
+}
+
+///|
+/// Provides a callback-scoped read view bound to this filtered row set.
+///
+/// The callback still must iterate with `QueryTableRows::for_each`; the view is
+/// the complete physical table column so matching row indices can be resolved
+/// without repeating batch lease and entity validation. The column and rows
+/// must originate from the same batch callback.
+pub fn[T] QueryTableRows::with_read_values(
+  self : QueryTableRows,
+  column : TableBatchRead[T],
+  read : (ArrayView[T]) -> Unit,
+) -> Unit {
+  if !physical_equal(self.scope, column.scope) {
+    abort("filtered table rows and read column must belong to the same batch")
+  }
+  let row_count = self.scope.entities_or_abort().length()
+  read(column.binding.values_or_abort()[:row_count])
+}
+
+///|
+/// Provides a callback-scoped read view of a writable column bound to this
+/// filtered row set.
+///
+/// The returned `ArrayView` cannot replace values. Mutations must still use
+/// `TableBatchWrite` so change ticks, callers, messages, and finalizers remain
+/// synchronized. The callback must iterate with `QueryTableRows::for_each`.
+pub fn[T] QueryTableRows::with_write_values(
+  self : QueryTableRows,
+  column : TableBatchWrite[T],
+  read : (ArrayView[T]) -> Unit,
+) -> Unit {
+  if !physical_equal(self.scope, column.scope) {
+    abort("filtered table rows and write column must belong to the same batch")
+  }
+  let row_count = self.scope.entities_or_abort().length()
+  read(column.binding.values_or_abort()[:row_count])
+}
+
+///|
+pub fn[T] QueryTableBatch::read(
+  self : QueryTableBatch,
+  key : ComponentKey[T],
+) -> TableBatchRead[T]? {
+  let component_id = key.id()
+  if !self.allows_read(component_id) {
+    abort(
+      "table batch read requires the component to be declared as Read or Write in the Query data",
+    )
+  }
+  let world = self.scope.world_or_abort()
+  guard world.local_component_id(component_id) is Some(local_component_id) else {
+    return None
+  }
+  if world.local_component_storage_type(local_component_id) != Some(Table) {
+    abort("table batch read requires table component storage")
+  }
+  guard world.table_storage(self.scope.table_id) is Some(table_ref) else {
+    abort("table batch expected a live table")
+  }
+  guard table_ref.column(local_component_id) is Some(column) else {
+    return None
+  }
+  guard key.component_bind_table_values(world, self.scope.table_id)
+    is Some(values) else {
+    abort("table batch expected a typed table column")
+  }
+  if values.length() < self.length() {
+    abort("table batch typed read column is shorter than its entity column")
+  }
+  let binding = QueryTableBatchColumnBinding::{
+    values: Some(values),
+    column: Some(column),
+  }
+  self.cleanups.push(fn() { binding.invalidate() })
+  Some(TableBatchRead::{ scope: self.scope, binding, key })
+}
+
+///|
+pub fn[T] QueryTableBatch::write(
+  self : QueryTableBatch,
+  key : ComponentKey[T],
+) -> TableBatchWrite[T]? {
+  let component_id = key.id()
+  if !self.allows_write(component_id) {
+    abort(
+      "table batch write requires the component to be declared as Write in the Query data",
+    )
+  }
+  let world = self.scope.world_or_abort()
+  guard world.local_component_id(component_id) is Some(local_component_id) else {
+    return None
+  }
+  if world.local_component_storage_type(local_component_id) != Some(Table) {
+    abort("table batch write requires table component storage")
+  }
+  guard world.table_storage(self.scope.table_id) is Some(table_ref) else {
+    abort("table batch expected a live table")
+  }
+  guard table_ref.column(local_component_id) is Some(column) else {
+    return None
+  }
+  guard key.component_bind_table_values(world, self.scope.table_id)
+    is Some(values) else {
+    abort("table batch expected a typed table column")
+  }
+  if values.length() < self.length() {
+    abort("table batch typed write column is shorter than its entity column")
+  }
+  let binding = QueryTableBatchColumnBinding::{
+    values: Some(values),
+    column: Some(column),
+  }
+  self.cleanups.push(fn() { binding.invalidate() })
+  Some(TableBatchWrite::{ scope: self.scope, binding, key, local_component_id })
+}
+
+///|
+pub fn[T] QueryTableBatch::has(
+  self : QueryTableBatch,
+  key : ComponentKey[T],
+) -> Bool {
+  let component_id = key.id()
+  if !self.mentions_component(component_id) {
+    abort(
+      "table batch presence access requires the component to be declared by the Query data or filter",
+    )
+  }
+  let world = self.scope.world_or_abort()
+  guard world.local_component_id(component_id) is Some(local_component_id) else {
+    return false
+  }
+  if world.local_component_storage_type(local_component_id) != Some(Table) {
+    abort("table batch presence access requires table component storage")
+  }
+  world.table_has_component_local_id(self.scope.table_id, local_component_id)
+}
+
+///|
+pub fn[T] TableBatchRead::value(self : TableBatchRead[T], row_index : Int) -> T {
+  ignore(self.scope.entity_or_abort(row_index))
+  self.binding.values_or_abort()[row_index]
+}
+
+///|
+/// Provides one callback-scoped read-only view of this complete table column.
+///
+/// The view covers only live entity rows and is valid only during `read`.
+/// Retaining it after the callback is invalid. This operation is available
+/// only from `Query::for_each_table`; filtered row batches must preserve their
+/// exact row matcher and use `TableBatchRead::value`.
+pub fn[T] TableBatchRead::with_values(
+  self : TableBatchRead[T],
+  read : (ArrayView[T]) -> Unit,
+) -> Unit {
+  if !self.scope.whole_table {
+    abort("TableBatchRead::with_values requires Query::for_each_table")
+  }
+  let row_count = self.scope.entities_or_abort().length()
+  read(self.binding.values_or_abort()[:row_count])
+}
+
+///|
+pub fn[T] TableBatchRead::key(self : TableBatchRead[T]) -> ComponentKey[T] {
+  self.key
+}
+
+///|
+pub fn[T] TableBatchRead::is_added(
+  self : TableBatchRead[T],
+  row_index : Int,
+) -> Bool {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().added_tick_at_row(row_index) {
+    Some(tick) =>
+      self.scope.world_or_abort().get_tick_context().ticks().contains(tick)
+    None => abort("table batch read expected added tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchRead::is_changed(
+  self : TableBatchRead[T],
+  row_index : Int,
+) -> Bool {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().changed_tick_at_row(row_index) {
+    Some(tick) =>
+      self.scope.world_or_abort().get_tick_context().ticks().contains(tick)
+    None => abort("table batch read expected changed tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchRead::added(
+  self : TableBatchRead[T],
+  row_index : Int,
+) -> @core.Tick {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().added_tick_at_row(row_index) {
+    Some(tick) => tick
+    None => abort("table batch read expected added tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchRead::last_changed(
+  self : TableBatchRead[T],
+  row_index : Int,
+) -> @core.Tick {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().changed_tick_at_row(row_index) {
+    Some(tick) => tick
+    None => abort("table batch read expected changed tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchRead::changed_by(
+  self : TableBatchRead[T],
+  row_index : Int,
+) -> String? {
+  ignore(self.scope.entity_or_abort(row_index))
+  self.binding.column_or_abort().changed_caller_at_row(row_index)
+}
+
+///|
+pub fn[T] TableBatchWrite::peek(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> T {
+  ignore(self.scope.entity_or_abort(row_index))
+  self.binding.values_or_abort()[row_index]
+}
+
+///|
+pub fn[T] TableBatchWrite::key(self : TableBatchWrite[T]) -> ComponentKey[T] {
+  self.key
+}
+
+///|
+pub fn[T] TableBatchWrite::value(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> T {
+  self.peek(row_index)
+}
+
+///|
+pub fn[T] TableBatchWrite::is_added(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> Bool {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().added_tick_at_row(row_index) {
+    Some(tick) =>
+      self.scope.world_or_abort().get_tick_context().ticks().contains(tick)
+    None => abort("table batch write expected added tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchWrite::is_changed(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> Bool {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().changed_tick_at_row(row_index) {
+    Some(tick) =>
+      self.scope.world_or_abort().get_tick_context().ticks().contains(tick)
+    None => abort("table batch write expected changed tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchWrite::added(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> @core.Tick {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().added_tick_at_row(row_index) {
+    Some(tick) => tick
+    None => abort("table batch write expected added tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchWrite::last_changed(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> @core.Tick {
+  ignore(self.scope.entity_or_abort(row_index))
+  match self.binding.column_or_abort().changed_tick_at_row(row_index) {
+    Some(tick) => tick
+    None => abort("table batch write expected changed tick metadata")
+  }
+}
+
+///|
+pub fn[T] TableBatchWrite::changed_by(
+  self : TableBatchWrite[T],
+  row_index : Int,
+) -> String? {
+  ignore(self.scope.entity_or_abort(row_index))
+  self.binding.column_or_abort().changed_caller_at_row(row_index)
+}
+
+///|
+fn[T] TableBatchWrite::mark_changed(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  caller : String?,
+) -> Unit {
+  ignore(self.scope.entity_or_abort(row_index))
+  let world = self.scope.world_or_abort()
+  let tick = component_write_tick(world)
+  if !self.binding
+    .column_or_abort()
+    .record_changed_at_row(row_index, tick, caller) {
+    abort("table batch write expected change tick metadata")
+  }
+}
+
+///|
+fn[T] TableBatchWrite::assign(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  value : T,
+) -> Unit {
+  ignore(self.scope.entity_or_abort(row_index))
+  let world = self.scope.world_or_abort()
+  if !world.replace_component_value_at_table_row(
+      self.key,
+      self.local_component_id,
+      self.scope.table_id,
+      row_index,
+      value,
+    ) {
+    abort("table batch write expected a writable table component row")
+  }
+}
+
+///|
+#callsite(autofill(loc))
+pub fn[T : Component] TableBatchWrite::set_changed(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  loc~ : SourceLoc,
+) -> Unit {
+  ignore(T::component())
+  self.mark_changed(
+    row_index,
+    hook_caller_from_loc(self.scope.world_or_abort(), loc),
+  )
+}
+
+///|
+/// Binds change metadata once for selected in-place row mutations.
+///
+/// This preserves ordinary component change detection. It only removes the
+/// repeated table, world-tick, and call-site resolution otherwise performed by
+/// one `set_changed` call per row.
+#callsite(autofill(loc))
+pub fn[T : Component] TableBatchWrite::with_change_writer(
+  self : TableBatchWrite[T],
+  write : (TableBatchChangeWriter) -> Unit,
+  loc~ : SourceLoc,
+) -> Unit {
+  ignore(T::component())
+  let row_count = self.scope.entities_or_abort().length()
+  let world = self.scope.world_or_abort()
+  let writer = TableBatchChangeWriter::{
+    active: true,
+    row_count,
+    scope: self.scope,
+    column: self.binding.column_or_abort(),
+    tick: component_write_tick(world),
+    caller_id: raw_table_store_changed_caller(hook_caller_from_loc(world, loc)),
+  }
+  defer writer.invalidate()
+  write(writer)
+}
+
+///|
+#callsite(autofill(loc))
+pub fn[T : Component] TableBatchWrite::set_added(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  loc~ : SourceLoc,
+) -> Unit {
+  ignore(T::component())
+  let entity = self.scope.entity_or_abort(row_index)
+  let world = self.scope.world_or_abort()
+  let caller = hook_caller_from_loc(world, loc)
+  world.record_component_added_with_caller(entity, self.key.id(), caller)
+  world
+  .ensure_added_component_messages(self.key.id())
+  .send(component_write_tick(world), entity)
+  world.record_component_changed_with_caller(entity, self.key.id(), caller)
+}
+
+///|
+#callsite(autofill(loc))
+pub fn[T, R] TableBatchWrite::modify(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  f : (T) -> R,
+  loc~ : SourceLoc,
+) -> R {
+  let result = f(self.peek(row_index))
+  self.mark_changed(
+    row_index,
+    hook_caller_from_loc(self.scope.world_or_abort(), loc),
+  )
+  result
+}
+
+///|
+/// Updates every row in this writable table column through one mutable view.
+///
+/// The view covers only the live entity rows and is valid only during
+/// `update`. Retaining it after the callback does not retain access: all
+/// subsequent operations abort. Every row is marked changed after the callback
+/// returns. This operation is available only from `Query::for_each_table`; a
+/// filtered row batch cannot safely update its whole physical column.
+/// Components with custom finalizers must use `set` so replaced values are
+/// finalized.
+#callsite(autofill(loc))
+pub fn[T] TableBatchWrite::update_inplace(
+  self : TableBatchWrite[T],
+  update : (TableBatchMutValues[T]) -> Unit,
+  loc~ : SourceLoc,
+) -> Unit {
+  if !self.scope.whole_table {
+    abort("TableBatchWrite::update_inplace requires Query::for_each_table")
+  }
+  if self.key.component_has_custom_finalizer() {
+    abort(
+      "TableBatchWrite::update_inplace does not support components with custom finalizers",
+    )
+  }
+  let row_count = self.scope.entities_or_abort().length()
+  let values = self.binding.values_or_abort()
+  let mut_values = TableBatchMutValues::{
+    active: true,
+    values: values.mut_view(end=row_count),
+  }
+  defer mut_values.invalidate()
+  update(mut_values)
+  let world = self.scope.world_or_abort()
+  let tick = component_write_tick(world)
+  let caller = hook_caller_from_loc(world, loc)
+  let column = self.binding.column_or_abort()
+  for row_index in 0..<row_count {
+    if !column.record_changed_at_row(row_index, tick, caller) {
+      abort("table batch write expected change tick metadata")
+    }
+  }
+}
+
+///|
+/// Updates every row in this writable table column without recording change
+/// ticks, matching Bevy's `bypass_change_detection` semantics for bulk state.
+///
+/// Like `update_inplace`, this is valid only for a complete table column and
+/// rejects components with custom finalizers.
+pub fn[T] TableBatchWrite::update_inplace_bypass_change_detection(
+  self : TableBatchWrite[T],
+  update : (TableBatchMutValues[T]) -> Unit,
+) -> Unit {
+  if !self.scope.whole_table {
+    abort(
+      "TableBatchWrite::update_inplace_bypass_change_detection requires Query::for_each_table",
+    )
+  }
+  if self.key.component_has_custom_finalizer() {
+    abort(
+      "TableBatchWrite::update_inplace_bypass_change_detection does not support components with custom finalizers",
+    )
+  }
+  let row_count = self.scope.entities_or_abort().length()
+  let mut_values = TableBatchMutValues::{
+    active: true,
+    values: self.binding.values_or_abort().mut_view(end=row_count),
+  }
+  defer mut_values.invalidate()
+  update(mut_values)
+}
+
+///|
+/// Updates one row without marking it changed.
+///
+/// Returning the same reference preserves its ownership; returning a different
+/// value replaces and finalizes the displaced component normally.
+pub fn[T] TableBatchWrite::bypass_change_detection(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  update : (T) -> T,
+) -> Unit {
+  let value = self.peek(row_index)
+  let replacement = update(value)
+  if !physical_equal(value, replacement) {
+    self.assign(row_index, replacement)
+  }
+}
+
+///|
+#callsite(autofill(loc))
+pub fn[T : Eq] TableBatchWrite::set_if_neq(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  value : T,
+  loc~ : SourceLoc,
+) -> Bool {
+  if self.peek(row_index) != value {
+    self.set(row_index, value, loc~)
+    true
+  } else {
+    false
+  }
+}
+
+///|
+#callsite(autofill(loc))
+pub fn[T] TableBatchWrite::set(
+  self : TableBatchWrite[T],
+  row_index : Int,
+  value : T,
+  loc~ : SourceLoc,
+) -> Unit {
+  self.mark_changed(
+    row_index,
+    hook_caller_from_loc(self.scope.world_or_abort(), loc),
+  )
+  self.assign(row_index, value)
+}
+
+///|
+fn query_visit_table_batch(
+  batch : QueryTableBatch,
+  visit : (QueryTableBatch) -> Unit raise EcsError,
+) -> Unit raise EcsError {
+  defer batch.invalidate()
+  visit(batch)
+}
+
+///|
+fn query_visit_filtered_table_batch(
+  batch : QueryTableBatch,
+  rows : QueryTableRows,
+  visit : (QueryTableBatch, QueryTableRows) -> Unit raise EcsError,
+) -> Unit raise EcsError {
+  defer batch.invalidate()
+  visit(batch, rows)
+}
+
+///|
+/// Visits each matching dense table once.
+///
+/// This is the MoonBit batch counterpart of Bevy's table-bound contiguous
+/// query fetch. It preserves the original query's component access and
+/// archetypal filter semantics, but rejects sparse data and filters that need
+/// per-row evaluation.
+pub fn[D : QueryData, F : QueryFilter] Query::for_each_table(
+  self : Query[D, F],
+  visit : (QueryTableBatch) -> Unit raise EcsError,
+) -> Unit raise EcsError {
+  let world = self.world_or_abort()
+  let plan = self.iteration_plan(self.default_filter_component_ids())
+  if !plan.dense_driven {
+    raise TableBatchUnavailable(
+      "Query::for_each_table requires conflict-free dense query data and an archetypal dense filter",
+    )
+  }
+  if plan.table_row_filter_required {
+    raise TableBatchUnavailable(
+      "Query::for_each_table does not support filters that require per-row evaluation",
+    )
+  }
+  let data_access = QueryDataAccess::new()
+  D::collect_access(data_access)
+  D::collect_required_components(data_access)
+  world.begin_query_iteration()
+  defer world.end_query_iteration()
+  for table_id in plan.dense_tables {
+    guard world.table_entities_view(table_id) is Some(entities) else {
+      continue
+    }
+    if entities.length() == 0 {
+      continue
+    }
+    let filter = self.filter
+    let batch = QueryTableBatch::{
+      scope: {
+        lease: WorldLease::new(world),
+        table_id,
+        entities: Some(entities),
+        whole_table: true,
+        authorized_row: -1,
+      },
+      data_access,
+      data_mentions_component: fn(component_id) {
+        D::mentions_component(component_id)
+      },
+      filter_mentions_component: fn(component_id) {
+        QueryFilter::mentions_component(filter, component_id)
+      },
+      cleanups: [],
+    }
+    query_visit_table_batch(batch, visit)
+  }
+}
+
+///|
+/// Visits each matching dense table once with an exact per-row filter view.
+///
+/// Unlike `Query::for_each_table`, this API accepts dense filters that require
+/// row evaluation. The filter binds its table-local state once, and callers
+/// must traverse `QueryTableRows` to preserve `Changed`, `Added`, `Or`, and
+/// custom row-filter semantics.
+pub fn[D : QueryData, F : QueryFilter] Query::try_for_each_filtered_table(
+  self : Query[D, F],
+  visit : (QueryTableBatch, QueryTableRows) -> Unit raise EcsError,
+) -> Bool raise EcsError {
+  let world = self.world_or_abort()
+  let plan = self.iteration_plan(self.default_filter_component_ids())
+  if !plan.dense_driven {
+    return false
+  }
+  let data_access = QueryDataAccess::new()
+  D::collect_access(data_access)
+  D::collect_required_components(data_access)
+  world.begin_query_iteration()
+  defer world.end_query_iteration()
+  for table_id in plan.dense_tables {
+    guard world.table_entities_view(table_id) is Some(entities) else {
+      continue
+    }
+    if entities.length() == 0 {
+      continue
+    }
+    let filter = self.filter
+    let scope = QueryTableBatchScope::{
+      lease: WorldLease::new(world),
+      table_id,
+      entities: Some(entities),
+      whole_table: false,
+      authorized_row: -1,
+    }
+    let batch = QueryTableBatch::{
+      scope,
+      data_access,
+      data_mentions_component: fn(component_id) {
+        D::mentions_component(component_id)
+      },
+      filter_mentions_component: fn(component_id) {
+        QueryFilter::mentions_component(filter, component_id)
+      },
+      cleanups: [],
+    }
+    let rows = QueryTableRows::{
+      scope,
+      matches: QueryFilter::bind_table_row_matcher(filter, world, table_id),
+    }
+    query_visit_filtered_table_batch(batch, rows, visit)
+  }
+  true
+}
diff --git a/mgstudio-engine/ecs/query_table_batch_test.mbt b/mgstudio-engine/ecs/query_table_batch_test.mbt
new file mode 100644
index 000000000..3b9bfb55f
--- /dev/null
+++ b/mgstudio-engine/ecs/query_table_batch_test.mbt
@@ -0,0 +1,980 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+struct TableBatchPosition {
+  mut value : Int
+} derive(Eq, Debug)
+
+///|
+struct TableBatchVelocity {
+  value : Int
+} derive(Eq, Debug)
+
+///|
+#valtype
+struct TableBatchValuePosition {
+  value : Int
+} derive(Eq, Debug)
+
+///|
+struct TableBatchExcluded {}
+
+///|
+struct TableBatchFinalized {
+  id : Int
+} derive(Eq, Debug)
+
+///|
+let table_batch_finalized_values : Array[Int] = []
+
+///|
+let table_batch_position_key : ComponentKey[TableBatchPosition] = register_component(
+  debug_name="ecs.test.TableBatchPosition",
+)
+
+///|
+let table_batch_velocity_key : ComponentKey[TableBatchVelocity] = register_component(
+  debug_name="ecs.test.TableBatchVelocity",
+)
+
+///|
+let table_batch_value_position_key : ComponentKey[TableBatchValuePosition] = register_component(
+  debug_name="ecs.test.TableBatchValuePosition",
+)
+
+///|
+let table_batch_excluded_key : ComponentKey[TableBatchExcluded] = register_component(
+  debug_name="ecs.test.TableBatchExcluded",
+)
+
+///|
+let table_batch_finalized_key : ComponentKey[TableBatchFinalized] = register_component(
+  debug_name="ecs.test.TableBatchFinalized",
+  finalizer=fn(value) { table_batch_finalized_values.push(value.id) },
+)
+
+///|
+pub impl Component for TableBatchPosition with fn component() {
+  table_batch_position_key
+}
+
+///|
+pub impl Component for TableBatchVelocity with fn component() {
+  table_batch_velocity_key
+}
+
+///|
+pub impl Component for TableBatchValuePosition with fn component() {
+  table_batch_value_position_key
+}
+
+///|
+pub impl Component for TableBatchExcluded with fn component() {
+  table_batch_excluded_key
+}
+
+///|
+pub impl Component for TableBatchFinalized with fn component() {
+  table_batch_finalized_key
+}
+
+///|
+test "ecs table batch: Entity visits empty table entities" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn_empty()
+  let second = world.spawn_empty()
+  let query : Query[@core.Entity, All] = query(world)
+  let seen : Array[@core.Entity] = []
+
+  try! query.for_each_table(fn(batch) {
+    for row_index in 0..<batch.length() {
+      seen.push(batch.entity(row_index))
+    }
+  })
+
+  debug_inspect(
+    (seen.contains(first), seen.contains(second), seen.length()),
+    content="(true, true, 2)",
+  )
+}
+
+///|
+test "ecs table batch: Has visits absent and present table rows" {
+  let world = World::new()
+  defer world.close()
+  let absent = world.spawn_empty()
+  let present = world.spawn()
+  try! world.set_by_key(present, table_batch_position_key, { value: 1 })
+  let query : Query[Has[TableBatchPosition], All] = query(world)
+  let mut absent_value : Bool? = None
+  let mut present_value : Bool? = None
+  let mut seen_count = 0
+
+  try! query.for_each_table(fn(batch) {
+    let has_position = batch.has(table_batch_position_key)
+    for row_index in 0..<batch.length() {
+      let entity = batch.entity(row_index)
+      if entity == absent {
+        absent_value = Some(has_position)
+      }
+      if entity == present {
+        present_value = Some(has_position)
+      }
+      seen_count = seen_count + 1
+    }
+  })
+
+  debug_inspect(
+    (absent_value, present_value, seen_count),
+    content="(Some(false), Some(true), 2)",
+  )
+}
+
+///|
+test "ecs table batch: filtered traversal visits empty table entities" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn_empty()
+  let query : Query[@core.Entity, All] = query(world)
+  let seen : Array[@core.Entity] = []
+
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    try! rows.for_each(fn(row_index) { seen.push(batch.entity(row_index)) })
+  })
+
+  debug_inspect(
+    (used_batch, seen.contains(entity), seen.length()),
+    content="(true, true, 1)",
+  )
+}
+
+///|
+test "ecs table batch: empty table rows survive component table migration" {
+  let world = World::new()
+  defer world.close()
+  let migrating = world.spawn_empty()
+  let stable = world.spawn_empty()
+  try! world.set_by_key(migrating, table_batch_position_key, { value: 1 })
+  debug_inspect(
+    try! world.remove_by_key(migrating, table_batch_position_key),
+    content="true",
+  )
+  let query : Query[Has[TableBatchPosition], All] = query(world)
+  let seen : Array[@core.Entity] = []
+  let values : Array[Bool] = []
+
+  try! query.for_each_table(fn(batch) {
+    let has_position = batch.has(table_batch_position_key)
+    for row_index in 0..<batch.length() {
+      seen.push(batch.entity(row_index))
+      values.push(has_position)
+    }
+  })
+
+  debug_inspect(
+    (seen.contains(migrating), seen.contains(stable), seen.length(), values),
+    content="(true, true, 2, [false, false])",
+  )
+}
+
+///|
+test "ecs table batch: empty table despawn preserves swapped row" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn_empty()
+  let removed = world.spawn_empty()
+  let last = world.spawn_empty()
+  try! world.despawn(removed)
+  let query : Query[@core.Entity, All] = query(world)
+  let seen : Array[@core.Entity] = []
+
+  try! query.for_each_table(fn(batch) {
+    for row_index in 0..<batch.length() {
+      seen.push(batch.entity(row_index))
+    }
+  })
+
+  debug_inspect(
+    (
+      seen.contains(first),
+      seen.contains(removed),
+      seen.contains(last),
+      seen.length(),
+    ),
+    content="(true, false, true, 2)",
+  )
+}
+
+///|
+test "ecs table batch: dense write preserves filters and change detection" {
+  let world = World::new()
+  defer world.close()
+  let changed_entity = try! world.spawn_bundle(
+    (TableBatchPosition::{ value: 1 }, TableBatchVelocity::{ value: 10 }),
+  )
+  let bypassed_entity = try! world.spawn_bundle(
+    (TableBatchPosition::{ value: 2 }, TableBatchVelocity::{ value: 20 }),
+  )
+  let excluded_entity = try! world.spawn_bundle(
+    (
+      TableBatchPosition::{ value: 3 },
+      TableBatchVelocity::{ value: 30 },
+      TableBatchExcluded::{  },
+    ),
+  )
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let query : Query[
+    (Write[TableBatchPosition], ReadValue[TableBatchVelocity]),
+    Without[TableBatchExcluded],
+  ] = query_filtered(world, Without::new(table_batch_excluded_key))
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_position_key).unwrap()
+    let velocities = batch.read(table_batch_velocity_key).unwrap()
+    for row_index in 0..<batch.length() {
+      let velocity = velocities.value(row_index).value
+      if batch.entity(row_index) == changed_entity {
+        positions.modify(row_index, fn(position) { position.value += velocity })
+      } else {
+        positions.bypass_change_detection(row_index, fn(position) {
+          position.value += velocity
+          position
+        })
+      }
+    }
+  })
+
+  debug_inspect(
+    try! world.get_by_key(changed_entity, table_batch_position_key),
+    content="Some({ value: 11 })",
+  )
+  debug_inspect(
+    try! world.get_by_key(bypassed_entity, table_batch_position_key),
+    content="Some({ value: 22 })",
+  )
+  debug_inspect(
+    try! world.get_by_key(excluded_entity, table_batch_position_key),
+    content="Some({ value: 3 })",
+  )
+  let changed = world
+    .changed_components(table_batch_position_key, @core.SystemTicks::new(1, 2))
+    .read()
+  debug_inspect(changed.contains(changed_entity), content="true")
+  debug_inspect(changed.contains(bypassed_entity), content="false")
+  debug_inspect(changed.contains(excluded_entity), content="false")
+}
+
+///|
+test "ecs table batch: bound change writer marks only selected rows" {
+  let world = World::new(track_change_locations=true)
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, table_batch_position_key, TableBatchPosition::{
+    value: 1,
+  })
+  try! world.set_by_key(second, table_batch_position_key, TableBatchPosition::{
+    value: 2,
+  })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let write_query : Query[Write[TableBatchPosition], All] = query(world)
+
+  try! write_query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_position_key).unwrap()
+    positions.with_change_writer(fn(changes) {
+      for row_index in 0..<batch.length() {
+        if batch.entity(row_index) == first {
+          positions.peek(row_index).value += 10
+          changes.set_changed(row_index)
+        }
+      }
+    })
+  })
+
+  let changed = world
+    .changed_components(table_batch_position_key, @core.SystemTicks::new(1, 2))
+    .read()
+  debug_inspect(changed.contains(first), content="true")
+  debug_inspect(changed.contains(second), content="false")
+  let read_query : Query[Read[TableBatchPosition], All] = query(world)
+  let first_value = (try! read_query.get(first)).unwrap()
+  debug_inspect(first_value.value(), content="{ value: 11 }")
+  debug_inspect(first_value.changed_by() is Some(_), content="true")
+}
+
+///|
+test "panic ecs table batch: escaped change writer is invalid" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_position_key, TableBatchPosition::{
+    value: 1,
+  })
+  let query : Query[Write[TableBatchPosition], All] = query(world)
+  let mut escaped : TableBatchChangeWriter? = None
+
+  try! query.for_each_table(fn(batch) {
+    batch
+    .write(table_batch_position_key)
+    .unwrap()
+    .with_change_writer(fn(changes) { escaped = Some(changes) })
+  })
+  escaped.unwrap().set_changed(0)
+}
+
+///|
+test "ecs table batch: read view exposes complete live column" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, table_batch_velocity_key, TableBatchVelocity::{
+    value: 10,
+  })
+  try! world.set_by_key(second, table_batch_velocity_key, TableBatchVelocity::{
+    value: 20,
+  })
+  let query : Query[ReadValue[TableBatchVelocity], All] = query(world)
+  let seen : Array[Int] = []
+
+  try! query.for_each_table(fn(batch) {
+    batch.read(table_batch_velocity_key).unwrap().with_values(fn(values) {
+      for value in values {
+        seen.push(value.value)
+      }
+    })
+  })
+
+  debug_inspect(seen, content="[10, 20]")
+}
+
+///|
+test "ecs table batch: entity view exposes complete live table" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, table_batch_velocity_key, TableBatchVelocity::{
+    value: 10,
+  })
+  try! world.set_by_key(second, table_batch_velocity_key, TableBatchVelocity::{
+    value: 20,
+  })
+  let query : Query[ReadValue[TableBatchVelocity], All] = query(world)
+  let seen : Array[Int] = []
+
+  try! query.for_each_table(fn(batch) {
+    batch.with_entities(fn(entities) {
+      for entity in entities {
+        seen.push(entity.id)
+      }
+    })
+  })
+
+  debug_inspect(seen, content="[0, 1]")
+}
+
+///|
+test "ecs table batch: update_inplace replaces value components and marks changed" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, table_batch_value_position_key, TableBatchValuePosition::{
+    value: 1,
+  })
+  try! world.set_by_key(second, table_batch_value_position_key, TableBatchValuePosition::{
+    value: 2,
+  })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace(fn(values) {
+      for row_index in 0..<values.length() {
+        values[row_index] = TableBatchValuePosition::{
+          value: values[row_index].value + 10,
+        }
+      }
+    })
+  })
+
+  debug_inspect(
+    try! world.get_by_key(first, table_batch_value_position_key),
+    content="Some({ value: 11 })",
+  )
+  debug_inspect(
+    try! world.get_by_key(second, table_batch_value_position_key),
+    content="Some({ value: 12 })",
+  )
+  let changed = world
+    .changed_components(
+      table_batch_value_position_key,
+      @core.SystemTicks::new(1, 2),
+    )
+    .read()
+  debug_inspect(changed.contains(first), content="true")
+  debug_inspect(changed.contains(second), content="true")
+}
+
+///|
+test "ecs table batch: update_inplace bypass preserves change ticks" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, table_batch_value_position_key, TableBatchValuePosition::{
+    value: 1,
+  })
+  try! world.set_by_key(second, table_batch_value_position_key, TableBatchValuePosition::{
+    value: 2,
+  })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace_bypass_change_detection(fn(values) {
+      for row_index in 0..<values.length() {
+        values[row_index] = TableBatchValuePosition::{
+          value: values[row_index].value + 10,
+        }
+      }
+    })
+  })
+
+  debug_inspect(
+    try! world.get_by_key(first, table_batch_value_position_key),
+    content="Some({ value: 11 })",
+  )
+  debug_inspect(
+    try! world.get_by_key(second, table_batch_value_position_key),
+    content="Some({ value: 12 })",
+  )
+  let changed = world
+    .changed_components(
+      table_batch_value_position_key,
+      @core.SystemTicks::new(1, 2),
+    )
+    .read()
+  debug_inspect(changed.contains(first), content="false")
+  debug_inspect(changed.contains(second), content="false")
+}
+
+///|
+test "panic ecs table batch: escaped update view cannot write after callback" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_value_position_key, { value: 1 })
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+  let mut escaped : TableBatchMutValues[TableBatchValuePosition]? = None
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace(fn(values) { escaped = Some(values) })
+    escaped.unwrap()[0] = { value: 99 }
+  })
+}
+
+///|
+test "panic ecs table batch: escaped update view cannot write a reused row" {
+  let world = World::new()
+  defer world.close()
+  let original = world.spawn()
+  try! world.set_by_key(original, table_batch_value_position_key, { value: 1 })
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+  let mut escaped : TableBatchMutValues[TableBatchValuePosition]? = None
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace(fn(values) { escaped = Some(values) })
+  })
+  debug_inspect(
+    try! world.remove_by_key(original, table_batch_value_position_key),
+    content="true",
+  )
+  let replacement = world.spawn()
+  try! world.set_by_key(replacement, table_batch_value_position_key, {
+    value: 2,
+  })
+  escaped.unwrap()[0] = { value: 99 }
+}
+
+///|
+test "panic ecs table batch: escaped update view cannot read after callback" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_value_position_key, { value: 1 })
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+  let mut escaped : TableBatchMutValues[TableBatchValuePosition]? = None
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace(fn(values) { escaped = Some(values) })
+  })
+  ignore(escaped.unwrap()[0])
+}
+
+///|
+test "panic ecs table batch: escaped bypass update view is invalid" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_value_position_key, { value: 1 })
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+  let mut escaped : TableBatchMutValues[TableBatchValuePosition]? = None
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace_bypass_change_detection(fn(values) {
+      escaped = Some(values)
+    })
+  })
+  escaped.unwrap()[0] = { value: 99 }
+}
+
+///|
+test "panic ecs table batch: mutable values reject rows beyond live column" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_value_position_key, { value: 1 })
+  let query : Query[Write[TableBatchValuePosition], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let positions = batch.write(table_batch_value_position_key).unwrap()
+    positions.update_inplace_bypass_change_detection(fn(values) {
+      values[values.length()] = { value: 99 }
+    })
+  })
+}
+
+///|
+test "ecs table batch: writes preserve component replacement finalizers" {
+  table_batch_finalized_values.clear()
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_finalized_key, TableBatchFinalized::{
+    id: 1,
+  })
+  let query : Query[Write[TableBatchFinalized], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let values = batch.write(table_batch_finalized_key).unwrap()
+    values.set(0, { id: 2 })
+    values.bypass_change_detection(0, fn(_value) {
+      TableBatchFinalized::{ id: 3 }
+    })
+  })
+
+  debug_inspect(
+    try! world.get_by_key(entity, table_batch_finalized_key),
+    content="Some({ id: 3 })",
+  )
+  debug_inspect(table_batch_finalized_values, content="[1, 2]")
+}
+
+///|
+test "ecs table batch: bypass preserves same-reference ownership" {
+  table_batch_finalized_values.clear()
+  let world = World::new()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_finalized_key, TableBatchFinalized::{
+    id: 1,
+  })
+  let query : Query[Write[TableBatchFinalized], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let values = batch.write(table_batch_finalized_key).unwrap()
+    values.bypass_change_detection(0, fn(value) { value })
+  })
+  let finalized_before_close = table_batch_finalized_values.length()
+  world.close()
+
+  debug_inspect(
+    (finalized_before_close, table_batch_finalized_values),
+    content="(0, [1])",
+  )
+}
+
+///|
+test "panic ecs table batch: update_inplace rejects custom finalizers" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_finalized_key, TableBatchFinalized::{
+    id: 1,
+  })
+  let query : Query[Write[TableBatchFinalized], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let values = batch.write(table_batch_finalized_key).unwrap()
+    values.update_inplace(fn(_items) { () })
+  })
+}
+
+///|
+test "panic ecs table batch: update_inplace rejects filtered row batches" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_position_key, TableBatchPosition::{
+    value: 1,
+  })
+  let query : Query[Write[TableBatchPosition], Changed[TableBatchPosition]] = query_filtered(
+    world,
+    Changed::new(table_batch_position_key),
+  )
+
+  ignore(
+    try! query.try_for_each_filtered_table(fn(batch, _rows) {
+      let values = batch.write(table_batch_position_key).unwrap()
+      values.update_inplace(fn(_items) { () })
+    }),
+  )
+}
+
+///|
+test "panic ecs table batch: read view rejects filtered row batches" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_velocity_key, TableBatchVelocity::{
+    value: 10,
+  })
+  let query : Query[ReadValue[TableBatchVelocity], Changed[TableBatchVelocity]] = query_filtered(
+    world,
+    Changed::new(table_batch_velocity_key),
+  )
+
+  ignore(
+    try! query.try_for_each_filtered_table(fn(batch, _rows) {
+      batch.read(table_batch_velocity_key).unwrap().with_values(fn(_values) {
+        ()
+      })
+    }),
+  )
+}
+
+///|
+test "panic ecs table batch: entity view rejects filtered row batches" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_velocity_key, TableBatchVelocity::{
+    value: 10,
+  })
+  let query : Query[ReadValue[TableBatchVelocity], Changed[TableBatchVelocity]] = query_filtered(
+    world,
+    Changed::new(table_batch_velocity_key),
+  )
+
+  ignore(
+    try! query.try_for_each_filtered_table(fn(batch, _rows) {
+      batch.with_entities(fn(_entities) { () })
+    }),
+  )
+}
+
+///|
+test "panic ecs table batch: update_inplace bypass rejects custom finalizers" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_finalized_key, TableBatchFinalized::{
+    id: 1,
+  })
+  let query : Query[Write[TableBatchFinalized], All] = query(world)
+
+  try! query.for_each_table(fn(batch) {
+    let values = batch.write(table_batch_finalized_key).unwrap()
+    values.update_inplace_bypass_change_detection(fn(_items) { () })
+  })
+}
+
+///|
+test "panic ecs table batch: update_inplace bypass rejects filtered row batches" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_position_key, TableBatchPosition::{
+    value: 1,
+  })
+  let query : Query[Write[TableBatchPosition], Changed[TableBatchPosition]] = query_filtered(
+    world,
+    Changed::new(table_batch_position_key),
+  )
+
+  ignore(
+    try! query.try_for_each_filtered_table(fn(batch, _rows) {
+      let values = batch.write(table_batch_position_key).unwrap()
+      values.update_inplace_bypass_change_detection(fn(_items) { () })
+    }),
+  )
+}
+
+///|
+test "panic ecs table batch: filtered write rejects an unmatched physical row" {
+  let world = World::new()
+  defer world.close()
+  let changed_entity = world.spawn()
+  let unchanged_entity = world.spawn()
+  try! world.set_by_key(changed_entity, table_batch_position_key, { value: 1 })
+  try! world.set_by_key(unchanged_entity, table_batch_position_key, { value: 2 })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  try! world.set_by_key(changed_entity, table_batch_position_key, { value: 11 })
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+  let query : Query[Write[TableBatchPosition], Changed[TableBatchPosition]] = query_filtered(
+    world,
+    Changed::new(table_batch_position_key),
+  )
+  ignore(
+    try! query.try_for_each_filtered_table(fn(batch, rows) {
+      let positions = batch.write(table_batch_position_key).unwrap()
+      try! rows.for_each(fn(row_index) {
+        let unmatched_row = if row_index == 0 { 1 } else { 0 }
+        positions.set(unmatched_row, { value: 99 })
+      })
+    }),
+  )
+}
+
+///|
+test "ecs table batch: filtered write permits the matching physical row" {
+  let world = World::new()
+  defer world.close()
+  let changed_entity = world.spawn()
+  let unchanged_entity = world.spawn()
+  try! world.set_by_key(changed_entity, table_batch_position_key, { value: 1 })
+  try! world.set_by_key(unchanged_entity, table_batch_position_key, { value: 2 })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  try! world.set_by_key(changed_entity, table_batch_position_key, { value: 11 })
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+  let query : Query[Write[TableBatchPosition], Changed[TableBatchPosition]] = query_filtered(
+    world,
+    Changed::new(table_batch_position_key),
+  )
+  let visited = Ref(0)
+
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let positions = batch.write(table_batch_position_key).unwrap()
+    try! rows.for_each(fn(row_index) {
+      visited.val = visited.val + 1
+      positions.set(row_index, { value: 21 })
+    })
+  })
+
+  debug_inspect(used_batch, content="true")
+  debug_inspect(visited.val, content="1")
+  debug_inspect(
+    try! world.get_by_key(changed_entity, table_batch_position_key),
+    content="Some({ value: 21 })",
+  )
+  debug_inspect(
+    try! world.get_by_key(unchanged_entity, table_batch_position_key),
+    content="Some({ value: 2 })",
+  )
+}
+
+///|
+test "panic ecs table batch: filtered change writer rejects an unmatched row" {
+  let world = World::new()
+  defer world.close()
+  let changed_entity = world.spawn()
+  let unchanged_entity = world.spawn()
+  try! world.set_by_key(changed_entity, table_batch_position_key, { value: 1 })
+  try! world.set_by_key(unchanged_entity, table_batch_position_key, { value: 2 })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  try! world.set_by_key(changed_entity, table_batch_position_key, { value: 11 })
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+  let query : Query[Write[TableBatchPosition], Changed[TableBatchPosition]] = query_filtered(
+    world,
+    Changed::new(table_batch_position_key),
+  )
+
+  ignore(
+    try! query.try_for_each_filtered_table(fn(batch, rows) {
+      let positions = batch.write(table_batch_position_key).unwrap()
+      positions.with_change_writer(fn(writer) {
+        try! rows.for_each(fn(row_index) {
+          let unmatched_row = if row_index == 0 { 1 } else { 0 }
+          writer.set_changed(unmatched_row)
+        })
+      })
+    }),
+  )
+}
+
+///|
+test "ecs table batch: filtered row authorization restores after nested exit" {
+  let world = World::new()
+  defer world.close()
+  let first = world.spawn()
+  let second = world.spawn()
+  try! world.set_by_key(first, table_batch_position_key, { value: 1 })
+  try! world.set_by_key(second, table_batch_position_key, { value: 2 })
+  let query : Query[Write[TableBatchPosition], All] = query(world)
+  let outer_visits = Ref(0)
+  let nested_visits = Ref(0)
+
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let positions = batch.write(table_batch_position_key).unwrap()
+    try! rows.for_each(outer_row => {
+      ignore(positions.peek(outer_row))
+      try! rows.for_each(fn(inner_row) {
+        ignore(positions.peek(inner_row))
+        nested_visits.val = nested_visits.val + 1
+      })
+      ignore(positions.peek(outer_row))
+      try
+        rows.for_each(_inner_row => {
+          raise TableBatchUnavailable("nested authorization test")
+        })
+      catch {
+        TableBatchUnavailable(_) => ()
+        _ => abort("nested filtered traversal raised an unexpected ECS error")
+      } noraise {
+        _ => abort("nested filtered traversal should raise")
+      }
+      ignore(positions.peek(outer_row))
+      outer_visits.val = outer_visits.val + 1
+    })
+  })
+
+  debug_inspect(used_batch, content="true")
+  debug_inspect(outer_visits.val, content="2")
+  debug_inspect(nested_visits.val, content="4")
+}
+
+///|
+test "ecs table batch: filtered rows preserve Changed Added Or semantics" {
+  let world = World::new()
+  defer world.close()
+  let changed_entity = try! world.spawn_bundle(
+    (TableBatchPosition::{ value: 1 }, TableBatchVelocity::{ value: 10 }),
+  )
+  let added_entity = world.spawn()
+  try! world.set_by_key(added_entity, table_batch_position_key, TableBatchPosition::{
+    value: 2,
+  })
+  let unchanged_entity = try! world.spawn_bundle(
+    (TableBatchPosition::{ value: 3 }, TableBatchVelocity::{ value: 30 }),
+  )
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  try! world.set_by_key(changed_entity, table_batch_position_key, TableBatchPosition::{
+    value: 11,
+  })
+  try! world.set_by_key(added_entity, table_batch_velocity_key, TableBatchVelocity::{
+    value: 20,
+  })
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+  let query : Query[
+    (Write[TableBatchPosition], ReadValue[TableBatchVelocity]),
+    Or[(Changed[TableBatchPosition], Added[TableBatchVelocity])],
+  ] = query_filtered(
+    world,
+    Or::new(
+      (
+        Changed::new(table_batch_position_key),
+        Added::new(table_batch_velocity_key),
+      ),
+    ),
+  )
+  let seen : Array[@core.Entity] = []
+
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let positions = batch.write(table_batch_position_key).unwrap()
+    let velocities = batch.read(table_batch_velocity_key).unwrap()
+    rows.with_write_values(positions, fn(position_values) {
+      rows.with_read_values(velocities, fn(velocity_values) {
+        try! rows.for_each(fn(row_index) {
+          ignore(position_values[row_index])
+          ignore(velocity_values[row_index])
+          seen.push(batch.entity(row_index))
+        })
+      })
+    })
+  })
+
+  debug_inspect(used_batch, content="true")
+  debug_inspect(seen.contains(changed_entity), content="true")
+  debug_inspect(seen.contains(added_entity), content="true")
+  debug_inspect(seen.contains(unchanged_entity), content="false")
+  debug_inspect(seen.length(), content="2")
+}
+
+///|
+test "ecs table batch: unavailable dense filter preserves row fallback" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, table_batch_position_key, TableBatchPosition::{
+    value: 1,
+  })
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  try! world.set_by_key(entity, table_batch_position_key, TableBatchPosition::{
+    value: 2,
+  })
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+  let query : Query[
+    @core.Entity,
+    Or[(Changed[TableBatchPosition], Changed[TableBatchExcluded])],
+  ] = query_filtered(
+    world,
+    Or::new(
+      (
+        Changed::new(table_batch_position_key),
+        Changed::new(table_batch_excluded_key),
+      ),
+    ),
+  )
+  let seen : Array[@core.Entity] = []
+  let mut callback_invoked = false
+
+  let used_batch = try! query.try_for_each_filtered_table(fn(_batch, _rows) {
+    callback_invoked = true
+  })
+  if !used_batch {
+    try! query.for_each(fn(_entity, value) { seen.push(value) })
+  }
+
+  debug_inspect(used_batch, content="false")
+  debug_inspect(callback_invoked, content="false")
+  debug_inspect(seen, content="[{ id: 0, generation: 1 }]")
+}
diff --git a/mgstudio-engine/ecs/query_test.mbt b/mgstudio-engine/ecs/query_test.mbt
index 955c8c2b8..485ffdd64 100644
--- a/mgstudio-engine/ecs/query_test.mbt
+++ b/mgstudio-engine/ecs/query_test.mbt
@@ -806,7 +806,7 @@ test "ecs query: added filter only matches entities inserted in the current tick
 
 ///|
 test "ecs query: Read exposes change detection metadata" {
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   let entity = world.spawn()
 
@@ -851,6 +851,19 @@ test "ecs query: Read exposes change detection metadata" {
   debug_inspect(second_position.value(), content="{ x: 6, y: 7 }")
 }
 
+///|
+test "ecs query: ReadValue returns the value without change metadata" {
+  let world = World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(entity, position_key, Position::{ x: 3, y: 5 })
+
+  let query : Query[ReadValue[Position], All] = query(world)
+  let position = try! query.require_single()
+  debug_inspect(position.key().id() == position_key.id(), content="true")
+  debug_inspect(position.value(), content="{ x: 3, y: 5 }")
+}
+
 ///|
 test "ecs query_state: default query filter cache invalidates on resource updates" {
   let world = World::new()
diff --git a/mgstudio-engine/ecs/raw_table.mbt b/mgstudio-engine/ecs/raw_table.mbt
index b8e93df61..3dbb57e6e 100644
--- a/mgstudio-engine/ecs/raw_table.mbt
+++ b/mgstudio-engine/ecs/raw_table.mbt
@@ -92,8 +92,14 @@ priv struct RawTableSwapRemoveResult {
 }
 
 ///|
-fn raw_table_column_new(component_ops : ComponentOps) -> RawTableColumn {
-  { component_ops, storage: raw_table_column_kernel_new() }
+fn raw_table_column_new(
+  component_ops : ComponentOps,
+  track_change_locations : Bool,
+) -> RawTableColumn {
+  {
+    component_ops,
+    storage: raw_table_column_kernel_new(track_change_locations),
+  }
 }
 
 ///|
@@ -160,6 +166,26 @@ fn RawTableColumn::changed_tick_at_row(
   raw_table_load_tick(raw_table_column_kernel_changed(self.storage, row_index))
 }
 
+///|
+fn RawTableColumn::added_tick_is_in(
+  self : RawTableColumn,
+  row_index : Int,
+  ticks : @core.SystemTicks,
+) -> Bool {
+  let tick = raw_table_column_kernel_added(self.storage, row_index)
+  tick >= 0 && ticks.contains(tick)
+}
+
+///|
+fn RawTableColumn::changed_tick_is_in(
+  self : RawTableColumn,
+  row_index : Int,
+  ticks : @core.SystemTicks,
+) -> Bool {
+  let tick = raw_table_column_kernel_changed(self.storage, row_index)
+  tick >= 0 && ticks.contains(tick)
+}
+
 ///|
 fn RawTableColumn::changed_caller_at_row(
   self : RawTableColumn,
@@ -197,12 +223,26 @@ fn RawTableColumn::record_changed_at_row(
   row_index : Int,
   tick : @core.Tick,
   caller : String?,
+) -> Bool {
+  self.record_changed_id_at_row(
+    row_index,
+    tick,
+    raw_table_store_changed_caller(caller),
+  )
+}
+
+///|
+fn RawTableColumn::record_changed_id_at_row(
+  self : RawTableColumn,
+  row_index : Int,
+  tick : @core.Tick,
+  caller_id : Int,
 ) -> Bool {
   raw_table_column_kernel_set_changed(
     self.storage,
     row_index,
     raw_table_store_tick(Some(tick)),
-    raw_table_store_changed_caller(caller),
+    caller_id,
   )
 }
 
@@ -243,6 +283,14 @@ fn raw_table_column_swap_remove(
   raw_table_column_kernel_swap_remove(column_ref.storage, row_index)
 }
 
+///|
+fn raw_table_column_metadata_swap_remove(
+  column_ref : RawTableColumn,
+  row_index : Int,
+) -> Bool {
+  raw_table_column_kernel_swap_remove(column_ref.storage, row_index)
+}
+
 ///|
 fn raw_table_new(
   world : World,
@@ -263,7 +311,7 @@ fn raw_table_new(
         )
     }
     let ops = component_ops(definition_id)
-    columns.push(raw_table_column_new(ops))
+    columns.push(raw_table_column_new(ops, world.tracks_change_locations()))
   }
   {
     table_id,
@@ -393,48 +441,54 @@ fn RawTable::append_row_from_source_table(
 ) -> TableRow? {
   let row = raw_table_row_kernel_push(self.rows, entity)
   let row_index = row
+  // Table component ids inherit the sorted, unique archetype signature, so
+  // source and target columns can be merged without a lookup or allocation.
+  let mut source_column_index = 0
   for column_index in 0..<self.columns.length() {
     let component_local_id = self.component_local_ids[column_index]
     let column = self.columns[column_index]
     let mut added_tick : @core.Tick? = None
     let mut changed_tick : @core.Tick? = None
     let mut changed_caller : String? = None
-    let mut source_table_id : Int? = None
-    let mut source_row_index : Int? = None
     let appended = match source_table {
       Some(source_table_ref) =>
         match source_row {
-          Some(source_row) =>
-            match source_table_ref.column(component_local_id) {
-              Some(source_column_ref) => {
-                source_table_id = Some(source_table_ref.table_id)
-                source_row_index = Some(source_row.index())
-                added_tick = source_column_ref.added_tick_at_row(
-                  source_row.index(),
-                )
-                changed_tick = source_column_ref.changed_tick_at_row(
-                  source_row.index(),
-                )
-                changed_caller = source_column_ref.changed_caller_at_row(
-                  source_row.index(),
-                )
-                column.append_from_row(source_column_ref, source_row.index())
-              }
-              None =>
-                if component_writes.contains(component_local_id) {
-                  match component_writes.metadata(component_local_id) {
-                    Some(metadata) => {
-                      added_tick = metadata.added_tick
-                      changed_tick = metadata.changed_tick
-                      changed_caller = metadata.changed_caller
-                    }
-                    None => ()
-                  }
-                  column.append_row()
-                } else {
-                  false
+          Some(source_row) => {
+            while source_column_index <
+                  source_table_ref.component_local_ids.length() &&
+                  source_table_ref.component_local_ids[source_column_index] <
+                  component_local_id {
+              source_column_index = source_column_index + 1
+            }
+            if source_column_index <
+              source_table_ref.component_local_ids.length() &&
+              source_table_ref.component_local_ids[source_column_index] ==
+              component_local_id {
+              let source_column_ref = source_table_ref.columns[source_column_index]
+              added_tick = source_column_ref.added_tick_at_row(
+                source_row.index(),
+              )
+              changed_tick = source_column_ref.changed_tick_at_row(
+                source_row.index(),
+              )
+              changed_caller = source_column_ref.changed_caller_at_row(
+                source_row.index(),
+              )
+              column.append_from_row(source_column_ref, source_row.index())
+            } else if component_writes.contains(component_local_id) {
+              match component_writes.metadata(component_local_id) {
+                Some(metadata) => {
+                  added_tick = metadata.added_tick
+                  changed_tick = metadata.changed_tick
+                  changed_caller = metadata.changed_caller
                 }
+                None => ()
+              }
+              column.append_row()
+            } else {
+              false
             }
+          }
           None =>
             if component_writes.contains(component_local_id) {
               match component_writes.metadata(component_local_id) {
@@ -495,16 +549,41 @@ fn RawTable::append_row_from_source_table(
       ignore(raw_table_row_kernel_swap_remove(self.rows, row_index))
       return None
     }
-    let moved_value = match (source_table_id, source_row_index) {
-      (Some(source_table_id), Some(source_row_index)) =>
-        (column.component_ops.move_table_row)(
-          world,
-          entity,
-          source_table_id,
-          source_row_index,
-          self.table_id,
-          row_index,
-        )
+  }
+  // Raw target rows are fully prepared before typed ownership changes. No
+  // callbacks or public world access occur until the source row is finalized.
+  source_column_index = 0
+  for column_index in 0..<self.columns.length() {
+    let component_local_id = self.component_local_ids[column_index]
+    let column = self.columns[column_index]
+    let moved_value = match (source_table, source_row) {
+      (Some(source_table_ref), Some(source_row)) => {
+        while source_column_index <
+              source_table_ref.component_local_ids.length() &&
+              source_table_ref.component_local_ids[source_column_index] <
+              component_local_id {
+          source_column_index = source_column_index + 1
+        }
+        if source_column_index < source_table_ref.component_local_ids.length() &&
+          source_table_ref.component_local_ids[source_column_index] ==
+          component_local_id {
+          (column.component_ops.move_table_row_and_swap_remove)(
+            world,
+            entity,
+            source_table_ref.table_id,
+            source_row.index(),
+            self.table_id,
+            row_index,
+          )
+        } else {
+          (column.component_ops.move_staged_to_table_row)(
+            world,
+            entity,
+            self.table_id,
+            row_index,
+          )
+        }
+      }
       _ =>
         (column.component_ops.move_staged_to_table_row)(
           world,
@@ -527,6 +606,7 @@ fn RawTable::swap_remove_row(
   self : RawTable,
   world : World,
   row : TableRow,
+  target_component_local_ids : Array[Int],
 ) -> RawTableSwapRemoveResult? {
   let row_index = row.index()
   let len = self.row_count()
@@ -543,10 +623,27 @@ fn RawTable::swap_remove_row(
   } else {
     raw_table_row_kernel_entity_at(self.rows, last_row_index)
   }
-  for column_ref in self.columns {
-    ignore(
-      raw_table_column_swap_remove(world, self.table_id, column_ref, row_index),
-    )
+  let mut target_column_index = 0
+  for column_index in 0..<self.columns.length() {
+    let component_local_id = self.component_local_ids[column_index]
+    while target_column_index < target_component_local_ids.length() &&
+          target_component_local_ids[target_column_index] < component_local_id {
+      target_column_index = target_column_index + 1
+    }
+    let column_ref = self.columns[column_index]
+    if target_column_index < target_component_local_ids.length() &&
+      target_component_local_ids[target_column_index] == component_local_id {
+      ignore(raw_table_column_metadata_swap_remove(column_ref, row_index))
+    } else {
+      ignore(
+        raw_table_column_swap_remove(
+          world,
+          self.table_id,
+          column_ref,
+          row_index,
+        ),
+      )
+    }
   }
   guard raw_table_row_kernel_swap_remove(self.rows, row_index) else {
     return None
@@ -564,17 +661,31 @@ fn RawTable::swap_remove_row(
 
 ///|
 fn World::ensure_table_storage(self : World, table_id : Int) -> RawTable {
+  if table_id < 0 {
+    abort("Cannot ensure table storage for negative table id")
+  }
   let component_local_ids = self.table_component_local_ids
     .get(table_id)
     .unwrap_or([])
-  self.tables.get_or_init(table_id, fn() {
-    raw_table_new(self, table_id, component_local_ids)
-  })
+  while self.tables.length() <= table_id {
+    self.tables.push(None)
+  }
+  match self.tables[table_id] {
+    Some(table_ref) => table_ref
+    None => {
+      let table_ref = raw_table_new(self, table_id, component_local_ids)
+      self.tables[table_id] = Some(table_ref)
+      table_ref
+    }
+  }
 }
 
 ///|
 fn World::table_storage(self : World, table_id : Int) -> RawTable? {
-  self.tables.get(table_id)
+  if table_id < 0 || table_id >= self.tables.length() {
+    return None
+  }
+  self.tables[table_id]
 }
 
 ///|
@@ -842,6 +953,29 @@ fn[T] World::component_value_by_table_row_fast(
   key.component_get_table_row(self, table_id, row_index)
 }
 
+///|
+fn[T] World::component_value_by_table_row_unchecked(
+  self : World,
+  key : ComponentKey[T],
+  local_component_id : Int,
+  table_id : Int,
+  row_index : Int,
+) -> T {
+  if self.local_component_storage_type(local_component_id) != Some(Table) {
+    abort("Required table fetch used a non-table component")
+  }
+  guard self.table_storage(table_id) is Some(table_ref) else {
+    abort("Required table fetch used a missing table")
+  }
+  guard table_ref.column(local_component_id) is Some(_) else {
+    abort("Required table fetch used a table without the component")
+  }
+  if row_index < 0 || row_index >= table_ref.row_count() {
+    abort("Required table fetch row is out of bounds")
+  }
+  key.component_get_table_row_unchecked(self, table_id, row_index)
+}
+
 ///|
 fn World::record_table_component_added_by_local_id(
   self : World,
diff --git a/mgstudio-engine/ecs/raw_table_kernel_portable.mbt b/mgstudio-engine/ecs/raw_table_kernel_portable.mbt
index 6d71d4563..5c651ca2e 100644
--- a/mgstudio-engine/ecs/raw_table_kernel_portable.mbt
+++ b/mgstudio-engine/ecs/raw_table_kernel_portable.mbt
@@ -68,12 +68,22 @@ fn raw_table_row_kernel_swap_remove(
 pub(all) struct RawTableColumnKernel {
   mut added_ticks : Array[@core.Tick]
   mut changed_ticks : Array[@core.Tick]
-  mut changed_caller_ids : Array[Int]
+  changed_caller_ids : Array[Int]?
 }
 
 ///|
-fn raw_table_column_kernel_new() -> RawTableColumnKernel {
-  { added_ticks: [], changed_ticks: [], changed_caller_ids: [] }
+fn raw_table_column_kernel_new(
+  track_change_locations : Bool,
+) -> RawTableColumnKernel {
+  {
+    added_ticks: [],
+    changed_ticks: [],
+    changed_caller_ids: if track_change_locations {
+      Some([])
+    } else {
+      None
+    },
+  }
 }
 
 ///|
@@ -90,7 +100,9 @@ fn raw_table_column_kernel_push(
 ) -> Bool {
   kernel.added_ticks.push(added_tick)
   kernel.changed_ticks.push(changed_tick)
-  kernel.changed_caller_ids.push(changed_caller_id)
+  if kernel.changed_caller_ids is Some(changed_caller_ids) {
+    changed_caller_ids.push(changed_caller_id)
+  }
   true
 }
 
@@ -107,7 +119,9 @@ fn raw_table_column_kernel_set_metadata(
   }
   kernel.added_ticks[row] = added_tick
   kernel.changed_ticks[row] = changed_tick
-  kernel.changed_caller_ids[row] = changed_caller_id
+  if kernel.changed_caller_ids is Some(changed_caller_ids) {
+    changed_caller_ids[row] = changed_caller_id
+  }
   true
 }
 
@@ -122,7 +136,9 @@ fn raw_table_column_kernel_set_changed(
     return false
   }
   kernel.changed_ticks[row] = changed_tick
-  kernel.changed_caller_ids[row] = changed_caller_id
+  if kernel.changed_caller_ids is Some(changed_caller_ids) {
+    changed_caller_ids[row] = changed_caller_id
+  }
   true
 }
 
@@ -153,10 +169,15 @@ fn raw_table_column_kernel_changed_caller_id(
   kernel : RawTableColumnKernel,
   row : Int,
 ) -> Int {
-  if row < 0 || row >= kernel.changed_caller_ids.length() {
-    return 0
+  match kernel.changed_caller_ids {
+    Some(changed_caller_ids) => {
+      if row < 0 || row >= changed_caller_ids.length() {
+        return 0
+      }
+      changed_caller_ids[row]
+    }
+    None => 0
   }
-  kernel.changed_caller_ids[row]
 }
 
 ///|
@@ -171,10 +192,14 @@ fn raw_table_column_kernel_swap_remove(
   if row != last_index {
     kernel.added_ticks[row] = kernel.added_ticks[last_index]
     kernel.changed_ticks[row] = kernel.changed_ticks[last_index]
-    kernel.changed_caller_ids[row] = kernel.changed_caller_ids[last_index]
+    if kernel.changed_caller_ids is Some(changed_caller_ids) {
+      changed_caller_ids[row] = changed_caller_ids[last_index]
+    }
   }
   ignore(kernel.added_ticks.pop())
   ignore(kernel.changed_ticks.pop())
-  ignore(kernel.changed_caller_ids.pop())
+  if kernel.changed_caller_ids is Some(changed_caller_ids) {
+    ignore(changed_caller_ids.pop())
+  }
   true
 }
diff --git a/mgstudio-engine/ecs/required_components.mbt b/mgstudio-engine/ecs/required_components.mbt
index ff88e8893..7230db808 100644
--- a/mgstudio-engine/ecs/required_components.mbt
+++ b/mgstudio-engine/ecs/required_components.mbt
@@ -442,6 +442,9 @@ fn World::insert_component_writes_with_requirements(
   writes : Array[(Int, ComponentWriter)],
   caller? : String? = None,
 ) -> Unit raise EcsError {
+  defer (for write in writes {
+    write.1.drop_unconsumed()
+  })
   self.ensure_entity_alive(entity)
   if self.has_active_query_iteration() {
     for write in writes {
@@ -451,6 +454,7 @@ fn World::insert_component_writes_with_requirements(
     }
   }
   let outermost = self.begin_deferred_hook_command_scope()
+  defer self.end_deferred_hook_command_scope(outermost)
   let bundle_info = self.ensure_bundle_info_for_writes(writes)
   let has_existing_transaction = self.has_active_component_write_transaction_for_entity(
     entity,
@@ -458,15 +462,14 @@ fn World::insert_component_writes_with_requirements(
   let assume_no_existing_components = !has_existing_transaction &&
     entity.id >= 0 &&
     entity.id < self.entity_storage.entity_archetype_ids.length() &&
-    self.entity_storage.entity_archetype_ids[entity.id] == 0 &&
-    entity.id < self.entity_storage.entity_component_local_ids.length() &&
-    self.entity_storage.entity_component_local_ids[entity.id].length() == 0
+    self.entity_storage.entity_archetype_ids[entity.id] == 0
   let component_writes = self
     .active_component_write_set_for_entity(entity)
     .unwrap_or(component_write_set_new())
   let previous_transaction = self.begin_component_write_transaction(
     entity, component_writes,
   )
+  defer self.restore_component_write_transaction(previous_transaction)
   let transaction = ComponentInsertTransaction(
     entity, component_writes, assume_no_existing_components, caller,
   )
@@ -485,8 +488,6 @@ fn World::insert_component_writes_with_requirements(
     )
     self.mark_structure_changed()
   }
-  self.restore_component_write_transaction(previous_transaction)
-  self.end_deferred_hook_command_scope(outermost)
 }
 
 ///|
@@ -539,7 +540,7 @@ fn World::insert_component_with_requirements_unchecked(
   )
 
   if !replacing {
-    self.entity_add_component_local_id(entity, component_local_id)
+    self.record_entity_component_added_local_id(component_local_id)
     transaction.mark_structural_changed()
     self.record_component_added_with_caller(
       entity, component_definition_id, caller,
diff --git a/mgstudio-engine/ecs/resource.mbt b/mgstudio-engine/ecs/resource.mbt
index 44617cdfe..275e1afcb 100644
--- a/mgstudio-engine/ecs/resource.mbt
+++ b/mgstudio-engine/ecs/resource.mbt
@@ -168,7 +168,11 @@ pub fn[T] World::mark_resource_changed(
   key : ResourceKey[T],
   caller? : String? = None,
 ) -> Unit {
-  key.resource_record_changed(self, resource_write_tick(self), caller)
+  key.resource_record_changed(
+    self,
+    resource_write_tick(self),
+    self.tracked_change_caller(caller),
+  )
 }
 
 ///|
@@ -178,6 +182,7 @@ pub fn[T] World::mark_resource_added(
   caller? : String? = None,
 ) -> Unit {
   let tick = resource_write_tick(self)
+  let caller = self.tracked_change_caller(caller)
   key.resource_record_added(self, tick, caller)
   key.resource_record_changed(self, tick, caller)
 }
diff --git a/mgstudio-engine/ecs/resource_access.mbt b/mgstudio-engine/ecs/resource_access.mbt
index 36322d0f3..56b1ee9cb 100644
--- a/mgstudio-engine/ecs/resource_access.mbt
+++ b/mgstudio-engine/ecs/resource_access.mbt
@@ -173,7 +173,10 @@ pub fn[T] ResourceMut::set_changed(
   self : ResourceMut[T],
   loc~ : SourceLoc,
 ) -> Unit {
-  self.world.mark_resource_changed(self.key, caller=Some(loc.to_string()))
+  self.world.mark_resource_changed(
+    self.key,
+    caller=hook_caller_from_loc(self.world, loc),
+  )
 }
 
 ///|
@@ -182,7 +185,10 @@ pub fn[T] ResourceMut::set_added(
   self : ResourceMut[T],
   loc~ : SourceLoc,
 ) -> Unit {
-  self.world.mark_resource_added(self.key, caller=Some(loc.to_string()))
+  self.world.mark_resource_added(
+    self.key,
+    caller=hook_caller_from_loc(self.world, loc),
+  )
 }
 
 ///|
diff --git a/mgstudio-engine/ecs/resource_test.mbt b/mgstudio-engine/ecs/resource_test.mbt
index 239ffed1a..121afee2f 100644
--- a/mgstudio-engine/ecs/resource_test.mbt
+++ b/mgstudio-engine/ecs/resource_test.mbt
@@ -91,7 +91,7 @@ test "ecs resource: ResourceMut updates live world storage" {
 
 ///|
 test "ecs resource: ResourceMut exposes detect changes metadata" {
-  let world = World::new()
+  let world = World::new(track_change_locations=true)
   defer world.close()
   let res_config : ResourceKey[RuntimeConfig] = register_resource(
     debug_name="resource_mut_detect_runtime_config",
diff --git a/mgstudio-engine/ecs/typed_storage.mbt b/mgstudio-engine/ecs/typed_storage.mbt
index a68409ded..6d50ef2aa 100644
--- a/mgstudio-engine/ecs/typed_storage.mbt
+++ b/mgstudio-engine/ecs/typed_storage.mbt
@@ -17,13 +17,19 @@ struct ComponentAccess[T] {
   contains : (World, @core.Entity) -> Bool
   get : (World, @core.Entity) -> T?
   set : (World, @core.Entity, T) -> Unit
-  remove : (World, @core.Entity) -> T?
+  remove : (World, @core.Entity) -> Bool
+  take : (World, @core.Entity) -> T?
   for_each : (World, (@core.Entity, T) -> Unit) -> Unit
   get_table_row : (World, Int, Int) -> T?
+  get_table_row_unchecked : (World, Int, Int) -> T
+  bind_table_values : (World, Int) -> Array[T]?
   set_table_row : (World, Int, Int, T) -> Unit
-  move_table_row : (World, @core.Entity, Int, Int, Int, Int) -> Bool
+  move_table_row_and_swap_remove : (World, @core.Entity, Int, Int, Int, Int) -> Bool
   move_staged_to_table_row : (World, @core.Entity, Int, Int) -> Bool
   swap_remove_table_row : (World, Int, Int) -> Unit
+  table_row_count : (World, Int) -> Int
+  finalize_value : (T) -> Unit
+  has_custom_finalizer : Bool
 }
 
 ///|
@@ -49,31 +55,31 @@ priv struct TypedResourceSlot[T] {
   mut changed_caller : String?
 }
 
+///|
+priv struct DenseComponentColumn[T] {
+  values : Array[T]
+}
+
 ///|
 priv struct TypedComponentStorage[T] {
   staged_by_entity : @core.ComponentStore[T]
-  table_rows_by_table : Map[Int, Array[T?]]
+  dense_columns_by_table : Map[Int, DenseComponentColumn[T]]
 }
 
 ///|
 fn[T] typed_component_storage_new() -> TypedComponentStorage[T] {
   {
     staged_by_entity: @core.ComponentStore::new(),
-    table_rows_by_table: Map([]),
+    dense_columns_by_table: Map([]),
   }
 }
 
 ///|
-fn[T] TypedComponentStorage::ensure_table_rows(
+fn[T] TypedComponentStorage::ensure_dense_column(
   self : TypedComponentStorage[T],
   table_id : Int,
-  row_index : Int,
-) -> Array[T?] {
-  let rows = self.table_rows_by_table.get_or_init(table_id, fn() { [] })
-  while rows.length() <= row_index {
-    rows.push(None)
-  }
-  rows
+) -> DenseComponentColumn[T] {
+  self.dense_columns_by_table.get_or_init(table_id, fn() { { values: [] } })
 }
 
 ///|
@@ -83,39 +89,48 @@ fn[T] TypedComponentStorage::get_table_row(
   row_index : Int,
 ) -> T? {
   guard row_index >= 0 else { return None }
-  guard self.table_rows_by_table.get(table_id) is Some(rows) else {
+  guard self.dense_columns_by_table.get(table_id) is Some(column) else {
     return None
   }
-  guard row_index < rows.length() else { return None }
-  rows[row_index]
+  guard row_index < column.values.length() else { return None }
+  Some(column.values[row_index])
 }
 
 ///|
-fn[T] TypedComponentStorage::set_table_row(
+fn[T] TypedComponentStorage::get_table_row_unchecked(
   self : TypedComponentStorage[T],
   table_id : Int,
   row_index : Int,
-  value : T,
-) -> Unit {
-  guard row_index >= 0 else { return }
-  let rows = self.ensure_table_rows(table_id, row_index)
-  rows[row_index] = Some(value)
+) -> T {
+  guard self.dense_columns_by_table.get(table_id) is Some(column) else {
+    abort("Missing dense component column for a matched table")
+  }
+  if row_index < 0 || row_index >= column.values.length() {
+    abort("Dense component row is out of bounds for a matched table")
+  }
+  column.values[row_index]
 }
 
 ///|
-fn[T] TypedComponentStorage::take_table_row(
+fn[T] TypedComponentStorage::set_table_row(
   self : TypedComponentStorage[T],
   table_id : Int,
   row_index : Int,
-) -> T? {
-  guard row_index >= 0 else { return None }
-  guard self.table_rows_by_table.get(table_id) is Some(rows) else {
-    return None
+  value : T,
+) -> Unit {
+  if row_index < 0 {
+    abort("Dense component column row index must be non-negative")
+  }
+  let column = self.ensure_dense_column(table_id)
+  if row_index == column.values.length() {
+    column.values.push(value)
+  } else if row_index < column.values.length() {
+    column.values[row_index] = value
+  } else {
+    abort(
+      "Dense component column cannot initialize row \{row_index.to_string()} after length \{column.values.length().to_string()}",
+    )
   }
-  guard row_index < rows.length() else { return None }
-  let value = rows[row_index]
-  rows[row_index] = None
-  value
 }
 
 ///|
@@ -124,31 +139,31 @@ fn[T] TypedComponentStorage::swap_remove_table_row(
   table_id : Int,
   row_index : Int,
 ) -> Unit {
-  guard self.table_rows_by_table.get(table_id) is Some(rows) else { return }
-  guard row_index >= 0 && row_index < rows.length() else { return }
-  let last_index = rows.length() - 1
+  guard self.dense_columns_by_table.get(table_id) is Some(column) else {
+    return
+  }
+  guard row_index >= 0 && row_index < column.values.length() else { return }
+  let last_index = column.values.length() - 1
   if row_index != last_index {
-    rows[row_index] = rows[last_index]
+    column.values[row_index] = column.values[last_index]
   }
-  ignore(rows.pop())
+  ignore(column.values.pop())
 }
 
 ///|
 fn[T] component_access_new(
   component_id : Int,
-  finalizer? : (T) -> Unit = fn(_value : T) { () },
+  finalizer : (T) -> Unit,
+  has_custom_finalizer : Bool,
 ) -> ComponentAccess[T] {
   let stores_by_world : Map[Int, TypedComponentStorage[T]] = Map([])
   let finalize_world_id = fn(world_id : Int) {
     guard stores_by_world.get(world_id) is Some(store) else { return }
     stores_by_world.remove(world_id)
     store.staged_by_entity.for_each(fn(_entity, value) { finalizer(value) })
-    for entry in store.table_rows_by_table.iter() {
-      for value in entry.1 {
-        match value {
-          Some(value) => finalizer(value)
-          None => ()
-        }
+    for entry in store.dense_columns_by_table.iter() {
+      for value in entry.1.values {
+        finalizer(value)
       }
     }
   }
@@ -230,36 +245,53 @@ fn[T] component_access_new(
             Some(value) => finalizer(value)
             None => ()
           }
-          match store.take_table_row(table_id, row_index) {
+          match store.get_table_row(table_id, row_index) {
             Some(value) => {
+              // The structural transaction swap-removes this dense row after
+              // running removal hooks. Only finalize the discarded value here.
               finalizer(value)
-              Some(value)
+              true
             }
-            None => None
+            None => false
           }
         }
         None =>
           match staged {
             Some(value) => {
               finalizer(value)
-              Some(value)
+              true
             }
-            None => None
+            None => false
           }
       }
     },
+    take: fn(world, entity) {
+      let store = get_store(world)
+      let staged = store.staged_by_entity.remove(entity)
+      match table_location(world, entity) {
+        Some((table_id, row_index)) => {
+          match staged {
+            Some(value) => finalizer(value)
+            None => ()
+          }
+          // The caller receives ownership. The structural transaction only
+          // forgets the source row and must not run the component finalizer.
+          store.get_table_row(table_id, row_index)
+        }
+        None => staged
+      }
+    },
     for_each: fn(world, visit) {
       let store = get_store(world)
-      for table_entry in store.table_rows_by_table.iter() {
+      for table_entry in store.dense_columns_by_table.iter() {
         let table_id = table_entry.0
-        let rows = table_entry.1
+        let values = table_entry.1.values
         guard world.table_entities_view(table_id) is Some(entities) else {
           continue
         }
-        for row_index in 0..<rows.length() {
-          guard rows[row_index] is Some(value) else { continue }
+        for row_index in 0..<values.length() {
           guard row_index < entities.length() else { continue }
-          visit(entities[row_index], value)
+          visit(entities[row_index], values[row_index])
         }
       }
       store.staged_by_entity.for_each(visit)
@@ -267,6 +299,15 @@ fn[T] component_access_new(
     get_table_row: fn(world, table_id, row_index) {
       get_store(world).get_table_row(table_id, row_index)
     },
+    get_table_row_unchecked: fn(world, table_id, row_index) {
+      get_store(world).get_table_row_unchecked(table_id, row_index)
+    },
+    bind_table_values: fn(world, table_id) {
+      match get_store(world).dense_columns_by_table.get(table_id) {
+        Some(column) => Some(column.values)
+        None => None
+      }
+    },
     set_table_row: fn(world, table_id, row_index, value) {
       let store = get_store(world)
       match store.get_table_row(table_id, row_index) {
@@ -275,7 +316,7 @@ fn[T] component_access_new(
       }
       store.set_table_row(table_id, row_index, value)
     },
-    move_table_row: fn(
+    move_table_row_and_swap_remove: fn(
       world,
       entity,
       source_table_id,
@@ -285,9 +326,13 @@ fn[T] component_access_new(
     ) {
       let store = get_store(world)
       ignore(store.staged_by_entity.remove(entity))
-      match store.take_table_row(source_table_id, source_row_index) {
+      match store.get_table_row(source_table_id, source_row_index) {
         Some(value) => {
+          // This is the GC-language equivalent of Bevy's owning row move. The
+          // source row is swap-removed in the same typed storage operation, so
+          // ownership is transferred exactly once.
           store.set_table_row(target_table_id, target_row_index, value)
+          store.swap_remove_table_row(source_table_id, source_row_index)
           true
         }
         None => false
@@ -306,6 +351,14 @@ fn[T] component_access_new(
     swap_remove_table_row: fn(world, table_id, row_index) {
       get_store(world).swap_remove_table_row(table_id, row_index)
     },
+    table_row_count: fn(world, table_id) {
+      match get_store(world).dense_columns_by_table.get(table_id) {
+        Some(column) => column.values.length()
+        None => 0
+      }
+    },
+    finalize_value: finalizer,
+    has_custom_finalizer,
   }
 }
 
@@ -342,10 +395,19 @@ fn[T] ComponentKey::component_remove(
   self : ComponentKey[T],
   world : World,
   entity : @core.Entity,
-) -> T? {
+) -> Bool {
   (self.access.remove)(world, entity)
 }
 
+///|
+fn[T] ComponentKey::component_take(
+  self : ComponentKey[T],
+  world : World,
+  entity : @core.Entity,
+) -> T? {
+  (self.access.take)(world, entity)
+}
+
 ///|
 fn[T] ComponentKey::component_for_each(
   self : ComponentKey[T],
@@ -365,6 +427,25 @@ fn[T] ComponentKey::component_get_table_row(
   (self.access.get_table_row)(world, table_id, row_index)
 }
 
+///|
+fn[T] ComponentKey::component_get_table_row_unchecked(
+  self : ComponentKey[T],
+  world : World,
+  table_id : Int,
+  row_index : Int,
+) -> T {
+  (self.access.get_table_row_unchecked)(world, table_id, row_index)
+}
+
+///|
+fn[T] ComponentKey::component_bind_table_values(
+  self : ComponentKey[T],
+  world : World,
+  table_id : Int,
+) -> Array[T]? {
+  (self.access.bind_table_values)(world, table_id)
+}
+
 ///|
 fn[T] ComponentKey::component_set_table_row(
   self : ComponentKey[T],
@@ -377,7 +458,7 @@ fn[T] ComponentKey::component_set_table_row(
 }
 
 ///|
-fn[T] ComponentKey::component_move_table_row(
+fn[T] ComponentKey::component_move_table_row_and_swap_remove(
   self : ComponentKey[T],
   world : World,
   entity : @core.Entity,
@@ -386,7 +467,7 @@ fn[T] ComponentKey::component_move_table_row(
   target_table_id : Int,
   target_row_index : Int,
 ) -> Bool {
-  (self.access.move_table_row)(
+  (self.access.move_table_row_and_swap_remove)(
     world, entity, source_table_id, source_row_index, target_table_id, target_row_index,
   )
 }
@@ -412,6 +493,30 @@ fn[T] ComponentKey::component_swap_remove_table_row(
   (self.access.swap_remove_table_row)(world, table_id, row_index)
 }
 
+///|
+fn[T] ComponentKey::component_table_row_count(
+  self : ComponentKey[T],
+  world : World,
+  table_id : Int,
+) -> Int {
+  (self.access.table_row_count)(world, table_id)
+}
+
+///|
+fn[T] ComponentKey::component_finalize_value(
+  self : ComponentKey[T],
+  value : T,
+) -> Unit {
+  (self.access.finalize_value)(value)
+}
+
+///|
+fn[T] ComponentKey::component_has_custom_finalizer(
+  self : ComponentKey[T],
+) -> Bool {
+  self.access.has_custom_finalizer
+}
+
 ///|
 fn[T] resource_access_ops_new(
   resource_id : Int,
diff --git a/mgstudio-engine/ecs/world_component_ops.mbt b/mgstudio-engine/ecs/world_component_ops.mbt
index 37b587a1b..249cfb636 100644
--- a/mgstudio-engine/ecs/world_component_ops.mbt
+++ b/mgstudio-engine/ecs/world_component_ops.mbt
@@ -27,7 +27,7 @@ pub fn[T] World::replace(
     return false
   }
   let outermost = self.begin_deferred_hook_command_scope()
-  let caller = hook_caller_from_loc(loc)
+  let caller = hook_caller_from_loc(self, loc)
   self.run_component_replace_hooks(entity, key.id(), caller~)
   ignore(
     self.replace_component_value_by_local_id(
@@ -48,11 +48,16 @@ pub fn[T] World::take(
   key : ComponentKey[T],
   loc~ : SourceLoc,
 ) -> T? raise EcsError {
-  let previous = self.get_by_key(entity, key)
-  if previous is Some(_) {
-    self.remove_by_key(entity, key, loc~) |> ignore
+  self.ensure_entity_alive(entity)
+  let outermost = self.begin_deferred_hook_command_scope()
+  defer self.end_deferred_hook_command_scope(outermost)
+  let caller = hook_caller_from_loc(self, loc)
+  guard self.component_remove_transaction_for_key(entity, key.id(), caller)
+    is Some(transaction) else {
+    return None
   }
-  previous
+  self.ensure_query_iteration_can_change_structure("take component")
+  self.commit_component_take_transaction(transaction, key)
 }
 
 ///|
diff --git a/mgstudio-engine/examples/3d/contact_shadows/reference.png b/mgstudio-engine/examples/3d/contact_shadows/reference.png
index b4f20d408..77c4a8d54 100644
Binary files a/mgstudio-engine/examples/3d/contact_shadows/reference.png and b/mgstudio-engine/examples/3d/contact_shadows/reference.png differ
diff --git a/mgstudio-engine/examples/3d/lighting/reference.png b/mgstudio-engine/examples/3d/lighting/reference.png
index 987f35351..b85d7f959 100644
Binary files a/mgstudio-engine/examples/3d/lighting/reference.png and b/mgstudio-engine/examples/3d/lighting/reference.png differ
diff --git a/mgstudio-engine/examples/3d/mixed_lighting/reference.png b/mgstudio-engine/examples/3d/mixed_lighting/reference.png
index 06543d412..b3bd673d8 100644
Binary files a/mgstudio-engine/examples/3d/mixed_lighting/reference.png and b/mgstudio-engine/examples/3d/mixed_lighting/reference.png differ
diff --git a/mgstudio-engine/examples/3d/skybox/reference.png b/mgstudio-engine/examples/3d/skybox/reference.png
index ddb52220f..266f70259 100644
Binary files a/mgstudio-engine/examples/3d/skybox/reference.png and b/mgstudio-engine/examples/3d/skybox/reference.png differ
diff --git a/mgstudio-engine/examples/3d/volumetric_fog/main_wbtest.mbt b/mgstudio-engine/examples/3d/volumetric_fog/main_wbtest.mbt
index 198df76e8..06e10bddf 100644
--- a/mgstudio-engine/examples/3d/volumetric_fog/main_wbtest.mbt
+++ b/mgstudio-engine/examples/3d/volumetric_fog/main_wbtest.mbt
@@ -2380,7 +2380,6 @@ test "volumetric_fog: GLB Cube reaches PBR render mesh extraction" {
       @scene.scene_spawn_roots_system(world)
       @transform.propagate_transforms_system(world)
       @visibility.visibility_propagate_system(world)
-      @visibility.check_visibility_system(world)
 
       let mesh_query : @ecs.Query[
         (
diff --git a/mgstudio-engine/examples/app/externally_driven_headless_renderer/main.mbt b/mgstudio-engine/examples/app/externally_driven_headless_renderer/main.mbt
index c46d8a70f..49db80df9 100644
--- a/mgstudio-engine/examples/app/externally_driven_headless_renderer/main.mbt
+++ b/mgstudio-engine/examples/app/externally_driven_headless_renderer/main.mbt
@@ -89,6 +89,22 @@ fn capture_system(
   }
 }
 
+///|
+fn raw_handle_for_host(
+  world : @ecs.World,
+  host_window : @window.HostWindow,
+) -> @window.RawHandleWrapper? {
+  for entry in @window.window_host_entries(world) {
+    if entry.host_window == host_window {
+      return try! world.get_by_key(
+        entry.entity,
+        @window.ecs_key_raw_handle_wrapper,
+      )
+    }
+  }
+  None
+}
+
 ///|
 fn externally_driven_runner_builder(
   app : @app.App[@ecs.World],
@@ -98,7 +114,11 @@ fn externally_driven_runner_builder(
       return
     }
     let device = @render.host_gpu_request_device()
-    let surface = @render.host_gpu_create_surface(window)
+    let raw_handle = match raw_handle_for_host(app.world(), window) {
+      Some(handle) => handle
+      None => return
+    }
+    let surface = @render.host_gpu_create_surface(raw_handle)
     let width = @window.host_window_get_width(window)
     let height = @window.host_window_get_height(window)
     @render.host_gpu_configure_surface(device~, surface~, width~, height~)
diff --git a/mgstudio-engine/examples/picking/sprite_picking/main.mbt b/mgstudio-engine/examples/picking/sprite_picking/main.mbt
index d7004688f..1e52c93b2 100644
--- a/mgstudio-engine/examples/picking/sprite_picking/main.mbt
+++ b/mgstudio-engine/examples/picking/sprite_picking/main.mbt
@@ -58,6 +58,7 @@ fn setup(commands : @app.Commands) -> Unit {
               colors.normal,
             ),
             @transform.Transform::from_xyz(x, y, 0.0F),
+            @picking.Pickable::Pickable(),
             PickableSpriteColors::{ ..colors },
           ),
         ),
diff --git a/mgstudio-engine/examples/picking/sprite_picking/moon.pkg b/mgstudio-engine/examples/picking/sprite_picking/moon.pkg
index 0bb41a427..675a8211b 100644
--- a/mgstudio-engine/examples/picking/sprite_picking/moon.pkg
+++ b/mgstudio-engine/examples/picking/sprite_picking/moon.pkg
@@ -7,6 +7,7 @@ import {
   "Milky2018/mgstudio/core",
   "Milky2018/mgstudio/ecs",
   "Milky2018/mgstudio/math",
+  "Milky2018/mgstudio/picking",
   "Milky2018/mgstudio/sprite",
   "Milky2018/mgstudio/transform",
 }
diff --git a/mgstudio-engine/examples/stress_tests/many_animated_sprites/main.mbt b/mgstudio-engine/examples/stress_tests/many_animated_sprites/main.mbt
index f8cadc787..895050948 100644
--- a/mgstudio-engine/examples/stress_tests/many_animated_sprites/main.mbt
+++ b/mgstudio-engine/examples/stress_tests/many_animated_sprites/main.mbt
@@ -12,15 +12,6 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-///|
-const GRID_HALF_X : Int = 160
-
-///|
-const GRID_HALF_Y : Int = 160
-
-///|
-const TILE_SIZE : Float = 64.0F
-
 ///|
 const CAMERA_SPEED : Float = 1000.0F
 
@@ -40,28 +31,50 @@ pub impl @ecs.Component for AnimationTimer with fn component() {
 }
 
 ///|
-struct PrintTimer {
-  mut seconds : Float
+struct PrintingTimer {
+  timer : @time.Timer
 }
 
 ///|
-let print_timer_key : @ecs.ResourceKey[PrintTimer] = @ecs.register_resource(
-  debug_name="examples.stress_tests.many_animated_sprites.PrintTimer",
-)
+fn PrintingTimer::PrintingTimer() -> PrintingTimer {
+  PrintingTimer::{
+    timer: @time.Timer::from_seconds(1.0F, @time.TimerMode::Repeating),
+  }
+}
+
+///|
+impl @app.FromWorld for PrintingTimer with fn from_world(_world) {
+  PrintingTimer::PrintingTimer()
+}
 
 ///|
-impl @app.Resource for PrintTimer with fn resource() {
-  print_timer_key
+fn configured_window() -> @window.Window {
+  let window = @window.Window::Window()
+  window.present_mode = @window.PresentMode::AutoNoVsync
+  window.resolution = @window.WindowResolution::new(1920, 1080).with_scale_factor_override(
+    1.0F,
+  )
+  window
 }
 
 ///|
-fn PrintTimer::PrintTimer() -> PrintTimer {
-  { seconds: 0.0F }
+fn animation_timer(elapsed_seconds : Float) -> AnimationTimer {
+  AnimationTimer::{
+    timer: @time.Timer::from_seconds(0.1F, @time.TimerMode::Repeating).set_elapsed(
+      @core.Duration::from_secs_f32(elapsed_seconds),
+    ),
+  }
 }
 
 ///|
-fn float_from_int(value : Int) -> Float {
-  Float::from_double(value.to_double())
+fn advance_camera_transform(
+  transform : @transform.Transform,
+  delta_seconds : Float,
+) -> Unit {
+  transform.rotate(@math.Quat::from_rotation_z(delta_seconds * 0.5F))
+  transform.translation = transform.transform_point(
+    @math.Vec3::new(CAMERA_SPEED * delta_seconds, 0.0F, 0.0F),
+  )
 }
 
 ///|
@@ -70,6 +83,16 @@ fn setup(
   asset_server : @app.Res[@asset.AssetServer],
   texture_atlas_layouts : @app.ResMut[@asset.Assets[@asset.TextureAtlasLayout]],
 ) -> Unit {
+  @app.log_record(
+    @app.Warn,
+    message="This is a stress test used to push Mgstudio to its limit and debug performance issues. It is not representative of an actual game. It must be run in release mode using --release or it will be very slow.",
+    target="many_animated_sprites",
+  )
+  let rng = @random.Rand::new()
+  let tile_size = @math.Vec2::splat(64.0F)
+  let map_size = @math.Vec2::splat(320.0F)
+  let half_x = (map_size.x / 2.0F).to_int()
+  let half_y = (map_size.y / 2.0F).to_int()
   let texture = asset_server
     .get()
     .load("textures/rpg/chars/gabe/gabe-idle-run.png")
@@ -78,34 +101,26 @@ fn setup(
     .add(@asset.TextureAtlasLayout::from_grid(@math.UVec2::new(24, 24), 7, 1))
   ignore(commands.spawn_component(@camera_components2d.Camera2d::Camera2d()))
 
-  for y in -GRID_HALF_Y..<GRID_HALF_Y {
-    for x in -GRID_HALF_X..<GRID_HALF_X {
-      let idx = (y + GRID_HALF_Y) * (GRID_HALF_X * 2) + (x + GRID_HALF_X)
-      let rotation = @math.Quat::from_rotation_z(
-        float_from_int(idx % 360) * 0.017453292519943295F,
+  for y in -half_y..<half_y {
+    for x in -half_x..<half_x {
+      let translation = @math.Vec3::new(
+        Float::from_int(x) * tile_size.x,
+        Float::from_int(y) * tile_size.y,
+        rng.float(),
       )
-      let scale = 0.6F + float_from_int(idx % 5) * 0.3F
-      let fps = 10.0F + float_from_int(idx % 11)
+      let rotation = @math.Quat::from_rotation_z(rng.float())
+      let scale = @math.Vec3::splat(rng.float() * 2.0F)
       ignore(
         commands.spawn(
           (
             @sprite.Sprite::from_atlas_image(
               texture,
-              @asset.TextureAtlas::new(atlas_layout, idx % 7),
-            ).with_custom_size(Some(@math.Vec2::new(28.0F, 28.0F))),
-            @transform.Transform::from_xyz(
-              float_from_int(x) * TILE_SIZE,
-              float_from_int(y) * TILE_SIZE,
-              float_from_int(idx % 100) / 100.0F,
-            )
+              @asset.TextureAtlas::new(atlas_layout, 0),
+            ).with_custom_size(Some(tile_size)),
+            @transform.Transform::from_translation(translation)
             .with_rotation(rotation)
-            .with_scale(@math.Vec3::splat(scale)),
-            AnimationTimer::{
-              timer: @time.Timer::from_seconds(
-                1.0F / fps,
-                @time.TimerMode::Repeating,
-              ),
-            },
+            .with_scale(scale),
+            animation_timer(rng.float()),
           ),
         ),
       )
@@ -116,23 +131,38 @@ fn setup(
 ///|
 fn animate_sprites(
   time : @app.Res[@time.Time[Unit]],
+  texture_atlas_layouts : @app.Res[@asset.Assets[@asset.TextureAtlasLayout]],
   sprites : @ecs.Query[
     (@ecs.Write[AnimationTimer], @ecs.Write[@sprite.Sprite]),
     @ecs.All,
   ],
 ) -> Unit {
-  try! sprites.for_each(fn(_entity, data) {
-    let (timer, sprite) = data
-    let next_timer = timer.modify(fn(value) {
-      value.timer = value.timer.tick(time.get().delta())
-      value.timer
-    })
-    if !next_timer.just_finished() {
-      return
-    }
-    sprite.modify(fn(value) {
-      guard value.texture_atlas is Some(atlas) else { return }
-      value.texture_atlas = Some(atlas.with_index((atlas.index + 1) % 7))
+  let delta = time.get().delta()
+  let layouts = texture_atlas_layouts.get()
+  try! sprites.for_each_table(fn(batch) {
+    let timers = batch.write(animation_timer_key).unwrap()
+    let sprite_values = batch.write(@sprite.ecs_key_sprite).unwrap()
+    sprite_values.with_change_writer(fn(sprite_changes) {
+      timers.update_inplace(fn(timer_values) {
+        for row_index in 0..<timer_values.length() {
+          let next_timer = timer_values[row_index].timer.tick(delta)
+          timer_values[row_index].timer = next_timer
+          if !next_timer.just_finished() {
+            continue
+          }
+          let sprite = sprite_values.peek(row_index)
+          guard sprite.texture_atlas is Some(atlas) else { continue }
+          guard atlas.layout_asset(layouts) is Some(layout) else {
+            abort(
+              "many_animated_sprites texture atlas layout must remain loaded",
+            )
+          }
+          sprite.texture_atlas = Some(
+            atlas.with_index((atlas.index + 1) % layout.len()),
+          )
+          sprite_changes.set_changed(row_index)
+        }
+      })
     })
   })
 }
@@ -142,17 +172,12 @@ fn move_camera(
   time : @app.Res[@time.Time[Unit]],
   camera : @ecs.Query[
     @ecs.Write[@transform.Transform],
-    @ecs.With[@camera_components2d.Camera2d],
+    @ecs.With[@camera_camera.Camera],
   ],
 ) -> Unit {
   try! camera.for_each(fn(_entity, transform) {
     transform.modify(fn(value) {
-      value.rotation = @math.Quat::from_rotation_z(
-        time.get().elapsed_secs() * 0.5F,
-      )
-      value.translation = value.translation.add(
-        @math.Vec3::new(CAMERA_SPEED * time.get().delta_secs(), 0.0F, 0.0F),
-      )
+      advance_camera_transform(value, time.get().delta_secs())
     })
   })
 }
@@ -160,34 +185,48 @@ fn move_camera(
 ///|
 fn print_sprite_count(
   time : @app.Res[@time.Time[Unit]],
-  timer : @app.ResMut[PrintTimer],
-  sprites : @ecs.Query[@ecs.Read[AnimationTimer], @ecs.All],
+  timer : @app.Local[PrintingTimer],
+  sprites : @ecs.Query[@ecs.Read[@sprite.Sprite], @ecs.All],
 ) -> Unit {
-  let should_print = timer.modify(fn(value) {
-    value.seconds += time.get().delta_secs()
-    if value.seconds < 1.0F {
-      false
-    } else {
-      value.seconds -= 1.0F
-      true
-    }
-  })
-  if !should_print {
+  let next_timer = timer.get().timer.tick(time.get().delta())
+  timer.set(PrintingTimer::{ timer: next_timer })
+  if !next_timer.just_finished() {
     return
   }
-  println("Animated sprites: \{sprites.count()}")
+  println("Sprites: \{sprites.count()}")
 }
 
 ///|
 fn main {
   @app.App::new(@ecs.World::new())
-  .insert_resource(PrintTimer::PrintTimer())
+  .add_plugins(@diagnostic.LogDiagnosticsPlugin::LogDiagnosticsPlugin())
+  .add_plugins(
+    @diagnostic.FrameTimeDiagnosticsPlugin::FrameTimeDiagnosticsPlugin(),
+  )
+  .add_plugins(
+    @mgstudio.DefaultPlugins::set(@window.WindowPlugin::{
+      primary_window: Some(configured_window()),
+      primary_cursor_options: Some(@window.CursorOptions::CursorOptions()),
+      exit_condition: @window.ExitCondition::OnAllClosed,
+      close_when_requested: true,
+    }),
+  )
   .insert_resource(@winit.WinitSettings::continuous())
-  .add_plugins(@mgstudio.DefaultPlugins::DefaultPlugins())
-  .add_plugins(@diagnostic.StressDiagnosticsPlugin::StressDiagnosticsPlugin())
   .add_systems_param3(@app.Startup, setup)
-  .add_systems_param2(@app.Update, animate_sprites)
-  .add_systems_param2(@app.Update, move_camera)
-  .add_systems_param3(@app.Update, print_sprite_count)
+  .add_systems_param3(@app.Update, animate_sprites)
+  .add_systems(
+    @app.Update,
+    @app.system_config_param3(print_sprite_count).named(
+      "examples.stress_tests.many_animated_sprites.print_sprite_count",
+    ),
+  )
+  .add_systems(
+    @app.Update,
+    @app.system_config_param2(move_camera).after(
+      @app.system_set(
+        "examples.stress_tests.many_animated_sprites.print_sprite_count",
+      ),
+    ),
+  )
   .run()
 }
diff --git a/mgstudio-engine/examples/stress_tests/many_animated_sprites/main_wbtest.mbt b/mgstudio-engine/examples/stress_tests/many_animated_sprites/main_wbtest.mbt
new file mode 100644
index 000000000..3536046c9
--- /dev/null
+++ b/mgstudio-engine/examples/stress_tests/many_animated_sprites/main_wbtest.mbt
@@ -0,0 +1,53 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+fn approx_equal(left : Float, right : Float) -> Bool {
+  (left - right).abs() <= 1.0e-4F
+}
+
+///|
+test "many animated sprites: benchmark configuration matches pinned Bevy" {
+  let window = configured_window()
+  debug_inspect(window.physical_width(), content="1920")
+  debug_inspect(window.physical_height(), content="1080")
+  debug_inspect(window.resolution.scale_factor_override(), content="Some(1)")
+  debug_inspect(window.present_mode, content="AutoNoVsync")
+
+  let timer = animation_timer(0.75F).timer
+  debug_inspect(approx_equal(timer.duration_seconds(), 0.1F), content="true")
+  debug_inspect(approx_equal(timer.elapsed_secs(), 0.75F), content="true")
+}
+
+///|
+test "many animated sprites: camera translates along its rotated local x axis" {
+  let transform = @transform.Transform::identity()
+  advance_camera_transform(transform, 1.0F)
+  let expected = @math.Quat::from_rotation_z(0.5F).mul_vec3(
+    @math.Vec3::new(CAMERA_SPEED, 0.0F, 0.0F),
+  )
+  debug_inspect(
+    approx_equal(transform.translation.x, expected.x),
+    content="true",
+  )
+  debug_inspect(
+    approx_equal(transform.translation.y, expected.y),
+    content="true",
+  )
+  debug_inspect(approx_equal(transform.translation.z, 0.0F), content="true")
+  let right = transform.right()
+  let expected_right = expected.normalize_or_zero()
+  debug_inspect(approx_equal(right.x, expected_right.x), content="true")
+  debug_inspect(approx_equal(right.y, expected_right.y), content="true")
+}
diff --git a/mgstudio-engine/examples/stress_tests/many_animated_sprites/moon.pkg b/mgstudio-engine/examples/stress_tests/many_animated_sprites/moon.pkg
index f37ee0714..b036f2cf1 100644
--- a/mgstudio-engine/examples/stress_tests/many_animated_sprites/moon.pkg
+++ b/mgstudio-engine/examples/stress_tests/many_animated_sprites/moon.pkg
@@ -1,15 +1,19 @@
 import {
+  "Milky2018/mgstudio/camera/camera" @camera_camera,
   "Milky2018/mgstudio/camera/components2d" @camera_components2d,
   "Milky2018/mgstudio",
   "Milky2018/mgstudio/app",
   "Milky2018/mgstudio/asset",
+  "Milky2018/mgstudio/core",
   "Milky2018/mgstudio/diagnostic",
   "Milky2018/mgstudio/ecs",
   "Milky2018/mgstudio/math",
   "Milky2018/mgstudio/sprite",
   "Milky2018/mgstudio/time",
   "Milky2018/mgstudio/transform",
+  "Milky2018/mgstudio/window",
   "Milky2018/mgstudio/winit",
+  "moonbitlang/core/random",
 }
 
 supported_targets = "native"
diff --git a/mgstudio-engine/examples/stress_tests/many_animated_sprites/pkg.generated.mbti b/mgstudio-engine/examples/stress_tests/many_animated_sprites/pkg.generated.mbti
index 75d256c28..893773551 100644
--- a/mgstudio-engine/examples/stress_tests/many_animated_sprites/pkg.generated.mbti
+++ b/mgstudio-engine/examples/stress_tests/many_animated_sprites/pkg.generated.mbti
@@ -13,7 +13,7 @@ import {
 type AnimationTimer
 pub impl @ecs.Component for AnimationTimer
 
-type PrintTimer
+type PrintingTimer
 
 // Type aliases
 
diff --git a/mgstudio-engine/examples/stress_tests/many_animated_sprites/reference.png b/mgstudio-engine/examples/stress_tests/many_animated_sprites/reference.png
index 66458c378..a53ee3e86 100644
Binary files a/mgstudio-engine/examples/stress_tests/many_animated_sprites/reference.png and b/mgstudio-engine/examples/stress_tests/many_animated_sprites/reference.png differ
diff --git a/mgstudio-engine/input/common_conditions.mbt b/mgstudio-engine/input/common_conditions.mbt
index fdf12a93d..c4bdb871e 100644
--- a/mgstudio-engine/input/common_conditions.mbt
+++ b/mgstudio-engine/input/common_conditions.mbt
@@ -20,14 +20,18 @@
 pub fn[T : ButtonInputButton + ButtonInputSnapshotProvider] input_pressed(
   input : T,
 ) -> @app.RunConditionFn[@ecs.World] {
-  fn(_world : @ecs.World) -> Bool { T::read_button_input().pressed(input) }
+  fn(_world : @ecs.World) -> Bool {
+    ButtonInputSnapshotProvider::read_button_input().pressed(input)
+  }
 }
 
 ///|
 pub fn[T : ButtonInputButton + ButtonInputSnapshotProvider] input_just_pressed(
   input : T,
 ) -> @app.RunConditionFn[@ecs.World] {
-  fn(_world : @ecs.World) -> Bool { T::read_button_input().just_pressed(input) }
+  fn(_world : @ecs.World) -> Bool {
+    ButtonInputSnapshotProvider::read_button_input().just_pressed(input)
+  }
 }
 
 ///|
@@ -35,7 +39,7 @@ pub fn[T : ButtonInputButton + ButtonInputSnapshotProvider] input_just_released(
   input : T,
 ) -> @app.RunConditionFn[@ecs.World] {
   fn(_world : @ecs.World) -> Bool {
-    T::read_button_input().just_released(input)
+    ButtonInputSnapshotProvider::read_button_input().just_released(input)
   }
 }
 
@@ -46,7 +50,7 @@ pub fn[T : ButtonInputButton + ButtonInputSnapshotProvider] input_toggle_active(
 ) -> @app.RunConditionFn[@ecs.World] {
   let mut active = initial_active
   fn(_world : @ecs.World) -> Bool {
-    let button_input = T::read_button_input()
+    let button_input = ButtonInputSnapshotProvider::read_button_input()
     if button_input.just_pressed(input) {
       active = !active
     }
diff --git a/mgstudio-engine/input/lib.mbt b/mgstudio-engine/input/lib.mbt
index 9074c9ed9..f21137691 100644
--- a/mgstudio-engine/input/lib.mbt
+++ b/mgstudio-engine/input/lib.mbt
@@ -1832,11 +1832,17 @@ fn ensure_input_resources(world : @ecs.World) -> Unit {
 
 ///|
 fn input_event_cursors(world : @ecs.World) -> InputEventCursors {
-  match world.get_resource(InputEventCursors::resource()) {
+  match
+    world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[InputEventCursors]),
+    ) {
     Some(cursors) => cursors
     None => {
       let cursors = InputEventCursors::InputEventCursors()
-      world.insert_resource(InputEventCursors::resource(), cursors)
+      world.insert_resource(
+        (@app.Resource::resource() : @ecs.ResourceKey[InputEventCursors]),
+        cursors,
+      )
       cursors
     }
   }
diff --git a/mgstudio-engine/light/moon.pkg b/mgstudio-engine/light/moon.pkg
index 5f99fe46a..7b525f859 100644
--- a/mgstudio-engine/light/moon.pkg
+++ b/mgstudio-engine/light/moon.pkg
@@ -4,6 +4,7 @@ import {
   "Milky2018/mgstudio/camera/primitives" @camera_primitives,
   "Milky2018/mgstudio/camera/projection3d" @camera_projection3d,
   "Milky2018/mgstudio/camera/visibility" @camera_visibility,
+  "Milky2018/mgstudio/camera/visibility/render_layers" @camera_render_layers,
   "Milky2018/mgstudio/app",
   "moonbitlang/core/float",
   "moonbitlang/core/json",
@@ -12,6 +13,7 @@ import {
   "Milky2018/mgstudio/ecs",
   "Milky2018/mgstudio/log",
   "Milky2018/mgstudio/math",
+  "Milky2018/mgstudio/mesh",
   "Milky2018/mgstudio/sprite",
   "Milky2018/mgstudio/transform",
   "Milky2018/mgstudio/visibility",
diff --git a/mgstudio-engine/light/pkg.generated.mbti b/mgstudio-engine/light/pkg.generated.mbti
index b49e68925..b5190692a 100644
--- a/mgstudio-engine/light/pkg.generated.mbti
+++ b/mgstudio-engine/light/pkg.generated.mbti
@@ -26,6 +26,10 @@ pub fn build_directional_light_cascades(@ecs.World) -> Unit
 
 pub fn calculate_directional_light_cascade(Array[@math.Vec3], Float, @math.Mat4, @math.Mat4) -> Cascade
 
+pub fn check_dir_light_mesh_visibility(@ecs.World) -> Unit
+
+pub fn check_point_light_mesh_visibility(@ecs.World) -> Unit
+
 pub fn cluster_visibility_class_id() -> Int
 
 pub fn directional_light_validated_shadow_map_size(Int) -> Int
diff --git a/mgstudio-engine/light/plugin.mbt b/mgstudio-engine/light/plugin.mbt
index 28a1c048f..9b72941f4 100644
--- a/mgstudio-engine/light/plugin.mbt
+++ b/mgstudio-engine/light/plugin.mbt
@@ -368,4 +368,22 @@ pub fn light_plugin(app : @app.App[@ecs.World]) -> @app.App[@ecs.World] {
     .after(simulation_light_set_assign_lights_to_clusters)
     .in_set(simulation_light_set_update_light_frusta),
   )
+  .add_post_update_system_config(
+    @app.system(check_dir_light_mesh_visibility)
+    .after(@visibility.visibility_set_calculate_bounds)
+    .after(@transform.transform_set_propagate)
+    .after(simulation_light_set_update_light_frusta)
+    .after(@visibility.visibility_set_check_visibility)
+    .before(@visibility.visibility_set_mark_newly_hidden_entities_invisible)
+    .in_set(simulation_light_set_check_light_visibility),
+  )
+  .add_post_update_system_config(
+    @app.system(check_point_light_mesh_visibility)
+    .after(@visibility.visibility_set_calculate_bounds)
+    .after(@transform.transform_set_propagate)
+    .after(simulation_light_set_update_light_frusta)
+    .after(@visibility.visibility_set_check_visibility)
+    .before(@visibility.visibility_set_mark_newly_hidden_entities_invisible)
+    .in_set(simulation_light_set_check_light_visibility),
+  )
 }
diff --git a/mgstudio-engine/light/visibility.mbt b/mgstudio-engine/light/visibility.mbt
new file mode 100644
index 000000000..faad29eb6
--- /dev/null
+++ b/mgstudio-engine/light/visibility.mbt
@@ -0,0 +1,424 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+// Bevy source: `bevy/crates/bevy_light/src/lib.rs`.
+
+///|
+type DirectionalLightVisibilityQuery = @ecs.Query[
+  (
+    @ecs.ReadValue[DirectionalLight],
+    @ecs.ReadValue[@camera_primitives.CascadesFrusta],
+    @ecs.Write[@camera_visibility.CascadesVisibleEntities],
+    @ecs.Optional[@camera_render_layers.RenderLayers],
+    @ecs.ReadValue[@visibility.ViewVisibility],
+  ),
+  @ecs.Without[SpotLight],
+]
+
+///|
+type ShadowCasterVisibilityQuery = @ecs.Query[
+  (
+    @core.Entity,
+    @ecs.ReadValue[@visibility.InheritedVisibility],
+    @ecs.Write[@visibility.ViewVisibility],
+    @ecs.Optional[@camera_render_layers.RenderLayers],
+    @ecs.Optional[@camera_primitives.Aabb],
+    @ecs.Optional[@transform.GlobalTransform],
+    @ecs.Has[@visibility.VisibilityRange],
+    @ecs.Has[@visibility.NoFrustumCulling],
+  ),
+  (
+    @ecs.Without[NotShadowCaster],
+    @ecs.Without[DirectionalLight],
+    @ecs.Without[@visibility.NoCpuCulling],
+    @ecs.With[@mesh.Mesh3d],
+  ),
+]
+
+///|
+type PointLightVisibilityQuery = @ecs.Query[
+  (
+    @ecs.ReadValue[PointLight],
+    @ecs.ReadValue[@transform.GlobalTransform],
+    @ecs.ReadValue[@camera_primitives.CubemapFrusta],
+    @ecs.Write[@camera_visibility.CubemapVisibleEntities],
+    @ecs.Optional[@camera_render_layers.RenderLayers],
+  ),
+  @ecs.All,
+]
+
+///|
+type SpotLightVisibilityQuery = @ecs.Query[
+  (
+    @ecs.ReadValue[SpotLight],
+    @ecs.ReadValue[@transform.GlobalTransform],
+    @ecs.ReadValue[@camera_primitives.Frustum],
+    @ecs.Write[@camera_visibility.VisibleMeshEntities],
+    @ecs.Optional[@camera_render_layers.RenderLayers],
+  ),
+  @ecs.All,
+]
+
+///|
+fn shadow_caster_visibility_query(
+  world : @ecs.World,
+) -> ShadowCasterVisibilityQuery {
+  @ecs.query_filtered(
+    world,
+    (
+      @ecs.Without::new(ecs_key_not_shadow_caster),
+      @ecs.Without::new(ecs_key_directional_light),
+      @ecs.Without::new(@visibility.ecs_key_no_cpu_culling),
+      @ecs.With::new(@mesh.ecs_key_mesh3d),
+    ),
+  )
+}
+
+///|
+fn shadow_visibility_layers(
+  layers : @ecs.Optional[@camera_render_layers.RenderLayers],
+) -> @camera_render_layers.RenderLayers {
+  layers.value().unwrap_or(@camera_render_layers.RenderLayers::RenderLayers())
+}
+
+///|
+fn shadow_visibility_range_culls(
+  ranges : @camera_visibility.VisibleEntityRanges?,
+  entity : @core.Entity,
+  view : @core.Entity,
+) -> Bool {
+  match ranges {
+    Some(visible_entity_ranges) =>
+      !visible_entity_ranges.entity_is_in_range_of_view(entity, view)
+    None => false
+  }
+}
+
+///|
+fn shadow_visible_entities_sort(
+  visible_entities : @camera_visibility.VisibleMeshEntities,
+) -> Unit {
+  visible_entities.iter().sort_by(fn(left, right) { left.id.compare(right.id) })
+}
+
+///|
+// Bevy source: `bevy/crates/bevy_light/src/lib.rs::check_dir_light_mesh_visibility`.
+pub fn check_dir_light_mesh_visibility(world : @ecs.World) -> Unit {
+  let directional_lights : DirectionalLightVisibilityQuery = @ecs.query_filtered(
+    world,
+    @ecs.Without::new(ecs_key_spot_light),
+  )
+  let visible_entity_query = shadow_caster_visibility_query(world)
+  let visible_entity_ranges = world.get_resource(
+    @camera_visibility.ecs_key_visible_entity_ranges,
+  )
+  try! directional_lights.view(fn(_light_entity, item) {
+    let (
+      directional_light,
+      cascades_frusta,
+      cascades_visible_entities,
+      light_layers,
+      light_view_visibility,
+    ) = item
+    cascades_visible_entities.modify(fn(visible_entities) {
+      visible_entities.clear()
+      if !directional_light.value().shadow_maps_enabled ||
+        !light_view_visibility.value().get() {
+        return
+      }
+      let view_mask = shadow_visibility_layers(light_layers)
+      for entry in cascades_frusta.value().iter() {
+        let (view, view_frusta) = entry
+        let cascade_visible_entities : Array[
+          @camera_visibility.VisibleMeshEntities,
+        ] = []
+        for _ in view_frusta {
+          cascade_visible_entities.push(
+            @camera_visibility.VisibleMeshEntities::VisibleMeshEntities(),
+          )
+        }
+        try! visible_entity_query.view(fn(_candidate_entity, candidate) {
+          let (
+            entity,
+            inherited_visibility,
+            view_visibility,
+            entity_layers,
+            aabb,
+            transform,
+            has_visibility_range,
+            has_no_frustum_culling,
+          ) = candidate
+          if !inherited_visibility.value().get() ||
+            !view_mask.intersects(shadow_visibility_layers(entity_layers)) {
+            return
+          }
+          if has_visibility_range.present() &&
+            shadow_visibility_range_culls(visible_entity_ranges, entity, view) {
+            return
+          }
+          let mut visible = false
+          match (aabb.value(), transform.value()) {
+            (Some(model_aabb), Some(global_transform)) =>
+              for index = 0; index < view_frusta.length(); index = index + 1 {
+                if has_no_frustum_culling.present() ||
+                  view_frusta[index].intersects_obb(
+                    model_aabb,
+                    global_transform.affine(),
+                    false,
+                    true,
+                  ) {
+                  visible = true
+                  cascade_visible_entities[index].push(entity)
+                }
+              }
+            _ => {
+              visible = true
+              for entities in cascade_visible_entities {
+                entities.push(entity)
+              }
+            }
+          }
+          if visible {
+            @visibility.SetViewVisibility::set_visible(view_visibility)
+          }
+        })
+        for entities in cascade_visible_entities {
+          shadow_visible_entities_sort(entities)
+        }
+        visible_entities.set(view, cascade_visible_entities)
+      }
+    })
+  })
+}
+
+///|
+fn shadow_visible_light_entities(world : @ecs.World) -> Array[@core.Entity] {
+  let entities : Array[@core.Entity] = []
+  let checked : Map[UInt64, Bool] = Map([])
+  let visible_lights : @ecs.Query[
+    @ecs.ReadValue[@camera_camera.VisibleEntities],
+    @ecs.All,
+  ] = @ecs.query(world)
+  try! visible_lights.view(fn(_view, visible_entities) {
+    for entity in visible_entities.value().get(cluster_visibility_class_id()) {
+      let key = entity.to_bits()
+      if !checked.contains(key) {
+        checked.set(key, true)
+        entities.push(entity)
+      }
+    }
+  })
+  entities
+}
+
+///|
+fn shadow_lod_range_culls(
+  ranges : @camera_visibility.VisibleEntityRanges?,
+  shadow_lod_origin : @core.Entity?,
+  entity : @core.Entity,
+) -> Bool {
+  match ranges {
+    Some(visible_entity_ranges) =>
+      match shadow_lod_origin {
+        Some(origin) =>
+          !visible_entity_ranges.entity_is_in_range_of_view(entity, origin)
+        None => true
+      }
+    None => false
+  }
+}
+
+///|
+fn check_point_light_visibility(
+  visible_entity_query : ShadowCasterVisibilityQuery,
+  visible_entity_ranges : @camera_visibility.VisibleEntityRanges?,
+  shadow_lod_origin : @core.Entity?,
+  item : (
+    @ecs.ReadValue[PointLight],
+    @ecs.ReadValue[@transform.GlobalTransform],
+    @ecs.ReadValue[@camera_primitives.CubemapFrusta],
+    @ecs.Write[@camera_visibility.CubemapVisibleEntities],
+    @ecs.Optional[@camera_render_layers.RenderLayers],
+  ),
+) -> Unit {
+  let (
+    point_light,
+    light_transform,
+    cubemap_frusta,
+    cubemap_visible_entities,
+    light_layers,
+  ) = item
+  if !point_light.value().shadow_maps_enabled {
+    return
+  }
+  let view_mask = shadow_visibility_layers(light_layers)
+  let light_sphere = @camera_primitives.Sphere::new(
+    light_transform.value().translation(),
+    point_light.value().range,
+  )
+  cubemap_visible_entities.modify(fn(visible_entities) {
+    for entities in visible_entities.iter() {
+      entities.clear()
+    }
+    try! visible_entity_query.view(fn(_candidate_entity, candidate) {
+      let (
+        entity,
+        inherited_visibility,
+        view_visibility,
+        entity_layers,
+        aabb,
+        transform,
+        has_visibility_range,
+        has_no_frustum_culling,
+      ) = candidate
+      if !inherited_visibility.value().get() ||
+        !view_mask.intersects(shadow_visibility_layers(entity_layers)) {
+        return
+      }
+      if has_visibility_range.present() &&
+        shadow_lod_range_culls(visible_entity_ranges, shadow_lod_origin, entity) {
+        return
+      }
+      match (aabb.value(), transform.value()) {
+        (Some(model_aabb), Some(global_transform)) => {
+          if !has_no_frustum_culling.present() &&
+            !light_sphere.intersects_obb(model_aabb, global_transform.affine()) {
+            return
+          }
+          for index = 0
+              index < cubemap_frusta.value().iter().length()
+              index = index + 1 {
+            if has_no_frustum_culling.present() ||
+              cubemap_frusta.value().iter()[index].intersects_obb(
+                model_aabb,
+                global_transform.affine(),
+                true,
+                true,
+              ) {
+              @visibility.SetViewVisibility::set_visible(view_visibility)
+              visible_entities.iter()[index].push(entity)
+            }
+          }
+        }
+        _ => {
+          @visibility.SetViewVisibility::set_visible(view_visibility)
+          for entities in visible_entities.iter() {
+            entities.push(entity)
+          }
+        }
+      }
+    })
+    for entities in visible_entities.iter() {
+      shadow_visible_entities_sort(entities)
+    }
+  })
+}
+
+///|
+fn check_spot_light_visibility(
+  visible_entity_query : ShadowCasterVisibilityQuery,
+  visible_entity_ranges : @camera_visibility.VisibleEntityRanges?,
+  shadow_lod_origin : @core.Entity?,
+  item : (
+    @ecs.ReadValue[SpotLight],
+    @ecs.ReadValue[@transform.GlobalTransform],
+    @ecs.ReadValue[@camera_primitives.Frustum],
+    @ecs.Write[@camera_visibility.VisibleMeshEntities],
+    @ecs.Optional[@camera_render_layers.RenderLayers],
+  ),
+) -> Unit {
+  let (spot_light, light_transform, frustum, visible_entities, light_layers) = item
+  if !spot_light.value().shadow_maps_enabled {
+    return
+  }
+  let view_mask = shadow_visibility_layers(light_layers)
+  let light_sphere = @camera_primitives.Sphere::new(
+    light_transform.value().translation(),
+    spot_light.value().range,
+  )
+  visible_entities.modify(fn(entities) {
+    entities.clear()
+    try! visible_entity_query.view(fn(_candidate_entity, candidate) {
+      let (
+        entity,
+        inherited_visibility,
+        view_visibility,
+        entity_layers,
+        aabb,
+        transform,
+        has_visibility_range,
+        has_no_frustum_culling,
+      ) = candidate
+      if !inherited_visibility.value().get() ||
+        !view_mask.intersects(shadow_visibility_layers(entity_layers)) {
+        return
+      }
+      if has_visibility_range.present() &&
+        shadow_lod_range_culls(visible_entity_ranges, shadow_lod_origin, entity) {
+        return
+      }
+      match (aabb.value(), transform.value()) {
+        (Some(model_aabb), Some(global_transform)) => {
+          if !has_no_frustum_culling.present() &&
+            !light_sphere.intersects_obb(model_aabb, global_transform.affine()) {
+            return
+          }
+          if has_no_frustum_culling.present() ||
+            frustum
+            .value()
+            .intersects_obb(model_aabb, global_transform.affine(), true, true) {
+            @visibility.SetViewVisibility::set_visible(view_visibility)
+            entities.push(entity)
+          }
+        }
+        _ => {
+          @visibility.SetViewVisibility::set_visible(view_visibility)
+          entities.push(entity)
+        }
+      }
+    })
+    shadow_visible_entities_sort(entities)
+  })
+}
+
+///|
+// Bevy source: `bevy/crates/bevy_light/src/lib.rs::check_point_light_mesh_visibility`.
+pub fn check_point_light_mesh_visibility(world : @ecs.World) -> Unit {
+  let visible_entity_query = shadow_caster_visibility_query(world)
+  let point_lights : PointLightVisibilityQuery = @ecs.query(world)
+  let spot_lights : SpotLightVisibilityQuery = @ecs.query(world)
+  let visible_entity_ranges = world.get_resource(
+    @camera_visibility.ecs_key_visible_entity_ranges,
+  )
+  let shadow_lod_origin = get_shadow_lod_origin(world)
+  for light_entity in shadow_visible_light_entities(world) {
+    match (try! point_lights.get(light_entity)) {
+      Some(point_light) => {
+        check_point_light_visibility(
+          visible_entity_query, visible_entity_ranges, shadow_lod_origin, point_light,
+        )
+        continue
+      }
+      None => ()
+    }
+    match (try! spot_lights.get(light_entity)) {
+      Some(spot_light) =>
+        check_spot_light_visibility(
+          visible_entity_query, visible_entity_ranges, shadow_lod_origin, spot_light,
+        )
+      None => ()
+    }
+  }
+}
diff --git a/mgstudio-engine/light/visibility_wbtest.mbt b/mgstudio-engine/light/visibility_wbtest.mbt
new file mode 100644
index 000000000..684dceea8
--- /dev/null
+++ b/mgstudio-engine/light/visibility_wbtest.mbt
@@ -0,0 +1,233 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "light visibility: point shadow caster becomes view visible" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let camera = world.spawn()
+  let point = world.spawn()
+  let mesh = world.spawn()
+  let visible_lights = @camera_camera.VisibleEntities::VisibleEntities()
+  visible_lights.push(point, cluster_visibility_class_id())
+  try! world.set_by_key(
+    camera, @camera_camera.ecs_key_visible_entities, visible_lights,
+  )
+  try! world.set_by_key(
+    point,
+    ecs_key_point_light,
+    PointLight::PointLight().with_shadow_maps_enabled(true).with_range(10.0F),
+  )
+  try! world.set_by_key(
+    point,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(
+    point,
+    @camera_primitives.ecs_key_cubemap_frusta,
+    @camera_primitives.CubemapFrusta::CubemapFrusta(),
+  )
+  try! world.set_by_key(
+    point,
+    @camera_visibility.ecs_key_cubemap_visible_entities,
+    @camera_visibility.CubemapVisibleEntities::CubemapVisibleEntities(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @mesh.ecs_key_mesh3d,
+    @mesh.Mesh3d::new(@asset.Handle::new(1)),
+  )
+  try! world.set_by_key(
+    mesh,
+    @visibility.ecs_key_inherited_visibility,
+    @visibility.InheritedVisibility::visible(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::hidden(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @camera_primitives.ecs_key_aabb,
+    @camera_primitives.Aabb::from_min_max(
+      @math.Vec3::new(-0.5F, -0.5F, -0.5F),
+      @math.Vec3::new(0.5F, 0.5F, 0.5F),
+    ),
+  )
+
+  check_point_light_mesh_visibility(world)
+
+  let visible = (try! world.get_by_key(
+    point, @camera_visibility.ecs_key_cubemap_visible_entities,
+  )).unwrap()
+  debug_inspect(visible.get(0).unwrap().len(), content="1")
+  debug_inspect(
+    (try! world.get_by_key(mesh, @visibility.ecs_key_view_visibility))
+    .unwrap()
+    .get(),
+    content="true",
+  )
+}
+
+///|
+test "light visibility: spot shadow caster becomes view visible" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let camera = world.spawn()
+  let spot = world.spawn()
+  let mesh = world.spawn()
+  let visible_lights = @camera_camera.VisibleEntities::VisibleEntities()
+  visible_lights.push(spot, cluster_visibility_class_id())
+  try! world.set_by_key(
+    camera, @camera_camera.ecs_key_visible_entities, visible_lights,
+  )
+  try! world.set_by_key(
+    spot,
+    ecs_key_spot_light,
+    SpotLight::SpotLight().with_shadow_maps_enabled(true),
+  )
+  try! world.set_by_key(
+    spot,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(
+    spot,
+    @camera_primitives.ecs_key_frustum,
+    @camera_primitives.Frustum::Frustum(),
+  )
+  try! world.set_by_key(
+    spot,
+    @camera_visibility.ecs_key_visible_mesh_entities,
+    @camera_visibility.VisibleMeshEntities::VisibleMeshEntities(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @mesh.ecs_key_mesh3d,
+    @mesh.Mesh3d::new(@asset.Handle::new(2)),
+  )
+  try! world.set_by_key(
+    mesh,
+    @visibility.ecs_key_inherited_visibility,
+    @visibility.InheritedVisibility::visible(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::hidden(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @camera_primitives.ecs_key_aabb,
+    @camera_primitives.Aabb::from_min_max(
+      @math.Vec3::new(-0.5F, -0.5F, -0.5F),
+      @math.Vec3::new(0.5F, 0.5F, 0.5F),
+    ),
+  )
+
+  check_point_light_mesh_visibility(world)
+
+  let visible = (try! world.get_by_key(
+    spot, @camera_visibility.ecs_key_visible_mesh_entities,
+  )).unwrap()
+  debug_inspect(visible.len(), content="1")
+  debug_inspect(
+    (try! world.get_by_key(mesh, @visibility.ecs_key_view_visibility))
+    .unwrap()
+    .get(),
+    content="true",
+  )
+}
+
+///|
+test "light visibility: directional shadow caster becomes view visible" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let view = world.spawn()
+  let light = world.spawn()
+  let mesh = world.spawn()
+  let frusta = @camera_primitives.CascadesFrusta::CascadesFrusta()
+  frusta.set(view, [@camera_primitives.Frustum::Frustum()])
+  try! world.set_by_key(
+    light,
+    ecs_key_directional_light,
+    DirectionalLight::DirectionalLight().with_shadow_maps_enabled(true),
+  )
+  try! world.set_by_key(
+    light, @camera_primitives.ecs_key_cascades_frusta, frusta,
+  )
+  try! world.set_by_key(
+    light,
+    @camera_visibility.ecs_key_cascades_visible_entities,
+    @camera_visibility.CascadesVisibleEntities::CascadesVisibleEntities(),
+  )
+  try! world.set_by_key(
+    light,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::visible(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @mesh.ecs_key_mesh3d,
+    @mesh.Mesh3d::new(@asset.Handle::new(3)),
+  )
+  try! world.set_by_key(
+    mesh,
+    @visibility.ecs_key_inherited_visibility,
+    @visibility.InheritedVisibility::visible(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::hidden(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(
+    mesh,
+    @camera_primitives.ecs_key_aabb,
+    @camera_primitives.Aabb::from_min_max(
+      @math.Vec3::new(-0.5F, -0.5F, -0.5F),
+      @math.Vec3::new(0.5F, 0.5F, 0.5F),
+    ),
+  )
+
+  check_dir_light_mesh_visibility(world)
+
+  let visible = (try! world.get_by_key(
+    light, @camera_visibility.ecs_key_cascades_visible_entities,
+  )).unwrap()
+  debug_inspect(visible.get(view)[0].len(), content="1")
+  debug_inspect(
+    (try! world.get_by_key(mesh, @visibility.ecs_key_view_visibility))
+    .unwrap()
+    .get(),
+    content="true",
+  )
+}
diff --git a/mgstudio-engine/math/affine3.mbt b/mgstudio-engine/math/affine3.mbt
index d88b977ed..8b4e08e6e 100644
--- a/mgstudio-engine/math/affine3.mbt
+++ b/mgstudio-engine/math/affine3.mbt
@@ -23,6 +23,22 @@ pub fn Affine3::identity() -> Affine3 {
   Affine3::{ matrix3: Mat3::identity(), translation: Vec3::zero() }
 }
 
+///|
+pub fn Affine3::is_nan(self : Affine3) -> Bool {
+  self.matrix3.x_axis.x.is_nan() ||
+  self.matrix3.x_axis.y.is_nan() ||
+  self.matrix3.x_axis.z.is_nan() ||
+  self.matrix3.y_axis.x.is_nan() ||
+  self.matrix3.y_axis.y.is_nan() ||
+  self.matrix3.y_axis.z.is_nan() ||
+  self.matrix3.z_axis.x.is_nan() ||
+  self.matrix3.z_axis.y.is_nan() ||
+  self.matrix3.z_axis.z.is_nan() ||
+  self.translation.x.is_nan() ||
+  self.translation.y.is_nan() ||
+  self.translation.z.is_nan()
+}
+
 ///|
 pub fn Affine3::from_mat3_translation(
   matrix3 : Mat3,
diff --git a/mgstudio-engine/math/affine3_test.mbt b/mgstudio-engine/math/affine3_test.mbt
index 216d79d71..1c8ce52c2 100644
--- a/mgstudio-engine/math/affine3_test.mbt
+++ b/mgstudio-engine/math/affine3_test.mbt
@@ -40,3 +40,23 @@ test "math: affine decomposition matches glam negative determinant scale" {
     content="true",
   )
 }
+
+///|
+test "math: affine is_nan checks matrix and translation" {
+  let nan = 0.0F / 0.0F
+  let matrix_nan = Affine3::from_mat3_translation(
+    Mat3::from_cols(
+      Vec3::new(1.0F, 0.0F, 0.0F),
+      Vec3::new(0.0F, nan, 0.0F),
+      Vec3::new(0.0F, 0.0F, 1.0F),
+    ),
+    Vec3::zero(),
+  )
+  let translation_nan = Affine3::from_translation(Vec3::new(0.0F, 0.0F, nan))
+  inspect(
+    !Affine3::identity().is_nan() &&
+    matrix_nan.is_nan() &&
+    translation_nan.is_nan(),
+    content="true",
+  )
+}
diff --git a/mgstudio-engine/math/math_test.mbt b/mgstudio-engine/math/math_test.mbt
index 8b23d8e50..c1f4d54e8 100644
--- a/mgstudio-engine/math/math_test.mbt
+++ b/mgstudio-engine/math/math_test.mbt
@@ -53,6 +53,13 @@ fn vec3_within_half_size(value : Vec3, half_size : Vec3) -> Bool {
   abs_float(value.z) <= half_size.z
 }
 
+///|
+test "math: sqrt preserves Float square-root semantics" {
+  debug_inspect(sqrt(0.0F) == 0.0F, content="true")
+  debug_inspect(sqrt(4.0F) == 2.0F, content="true")
+  debug_inspect(sqrt(-1.0F).is_nan(), content="true")
+}
+
 ///|
 test "math: cuboid constructors preserve Bevy full-size semantics" {
   let cuboid = Cuboid::new(3.0F, 7.0F, 2.0F)
diff --git a/mgstudio-engine/math/ops.mbt b/mgstudio-engine/math/ops.mbt
index b08d98ab2..9f640b2cf 100644
--- a/mgstudio-engine/math/ops.mbt
+++ b/mgstudio-engine/math/ops.mbt
@@ -43,7 +43,7 @@ pub fn sin(value : Float) -> Float {
 
 ///|
 pub fn sqrt(value : Float) -> Float {
-  @coremath.powf(value, 0.5F)
+  value.sqrt()
 }
 
 ///|
diff --git a/mgstudio-engine/math/pkg.generated.mbti b/mgstudio-engine/math/pkg.generated.mbti
index aa545af8a..e389cbec9 100644
--- a/mgstudio-engine/math/pkg.generated.mbti
+++ b/mgstudio-engine/math/pkg.generated.mbti
@@ -180,6 +180,7 @@ pub fn Affine3::from_scale_rotation_translation(Vec3, Quat, Vec3) -> Self
 pub fn Affine3::from_translation(Vec3) -> Self
 pub fn Affine3::identity() -> Self
 pub fn Affine3::inverse(Self) -> Self
+pub fn Affine3::is_nan(Self) -> Bool
 pub fn Affine3::mul(Self, Self) -> Self
 pub fn Affine3::mul_rotation_translation(Self, Quat, Vec3) -> Self
 pub fn Affine3::mul_transform(Self, Vec3, Quat, Vec3) -> Self
diff --git a/mgstudio-engine/mesh/primitives/dim2.mbt b/mgstudio-engine/mesh/primitives/dim2.mbt
index 9d085e3aa..fd9cd45df 100644
--- a/mgstudio-engine/mesh/primitives/dim2.mbt
+++ b/mgstudio-engine/mesh/primitives/dim2.mbt
@@ -1393,7 +1393,7 @@ pub impl Extrudable for RingMeshBuilder with fn perimeter(self) {
 
 ///|
 pub impl[P : ExtrudablePrimitive] Meshable for @math.Ring[P] with fn mesh(self) {
-  ring_mesh(self.outer_shape.mesh(), self.inner_shape.mesh())
+  ring_mesh(Meshable::mesh(self.outer_shape), Meshable::mesh(self.inner_shape))
 }
 
 ///|
@@ -1403,7 +1403,7 @@ pub impl[P : ExtrudablePrimitive] ExtrudablePrimitive for @math.Ring[P] with fn
   ring_perimeter(
     self.outer_shape.mesh_perimeter(),
     self.inner_shape.mesh_perimeter(),
-    self.outer_shape.mesh().vertex_count(),
+    Meshable::mesh(self.outer_shape).vertex_count(),
   )
 }
 
diff --git a/mgstudio-engine/mesh/primitives/extrusion.mbt b/mgstudio-engine/mesh/primitives/extrusion.mbt
index 7a9c03af5..99345ee97 100644
--- a/mgstudio-engine/mesh/primitives/extrusion.mbt
+++ b/mgstudio-engine/mesh/primitives/extrusion.mbt
@@ -96,7 +96,7 @@ pub fn[P : ExtrudablePrimitive] extrusion_mesh(
 ) -> @mesh.Mesh3dGeometry {
   let shape = extrusion.base_shape
   ExtrusionBuilder::new(
-    shape.mesh(),
+    Meshable::mesh(shape),
     shape.mesh_perimeter(),
     extrusion.half_depth * 2.0F,
   ).build()
diff --git a/mgstudio-engine/moon.mod b/mgstudio-engine/moon.mod
index fc65417c4..26210976f 100644
--- a/mgstudio-engine/moon.mod
+++ b/mgstudio-engine/moon.mod
@@ -7,17 +7,16 @@ import {
   "Milky2018/moon_rapier@0.5.1",
   "Milky2018/moon_swash@0.1.10",
   "Milky2018/moon_zeno@0.1.3",
-  "Milky2018/moon_taffy@0.5.2",
   "Milky2018/moon_accesskit@0.3.0",
   "Milky2018/moon_skrifa@0.1.8",
   "Milky2018/gamepad@0.4.6",
   "Milky2018/moon_cpal@0.11.7",
   "Milky2018/moon_rodio@0.3.3",
-  "Milky2018/moon_wesl@0.1.2",
-  "Milky2018/moon_wgsl@0.15.3",
-  "Milky2018/wgpu_mbt@0.14.8",
+  "Milky2018/moon_wesl@0.17.0",
+  "Milky2018/moon_wgsl@0.17.0",
+  "Milky2018/wgpu_mbt@0.15.0",
   "moonbitlang/x@0.4.45",
-  "Milky2018/window@0.5.2",
+  "Milky2018/window@0.6.0",
   "gmlewis/image@0.17.9",
   "gmlewis/io@0.23.12",
   "Milky2018/sysinfo@0.1.2",
@@ -26,9 +25,11 @@ import {
   "gmlewis/flate@0.36.9",
   "Milky2018/metis@0.1.1",
   "Milky2018/meshopt_mbt@0.1.1",
-  "Milky2018/wgsl@0.15.3",
-  "Milky2018/moon_wgsl_naga@0.15.3",
-  "Milky2018/moon_wgsl_naga_oil@0.15.3",
+  "Milky2018/wgsl@0.17.0",
+  "Milky2018/moon_wgsl_naga@0.17.0",
+  "Milky2018/moon_wgsl_naga_oil@0.17.0",
+  "Milky2018/windowing@0.1.0",
+  "Milky2018/chicle@0.6.0",
 }
 
 readme = "README.mbt.md"
diff --git a/mgstudio-engine/pbr/decal/forward.mbt b/mgstudio-engine/pbr/decal/forward.mbt
index 843b242a9..54eccb84b 100644
--- a/mgstudio-engine/pbr/decal/forward.mbt
+++ b/mgstudio-engine/pbr/decal/forward.mbt
@@ -220,7 +220,9 @@ fn forward_decal_set_mesh(
   world : @ecs.DeferredWorld,
   context : @ecs.HookContext,
 ) -> Unit {
-  guard world.resource(ForwardDecalMesh::resource()).get()
+  guard world
+    .resource((@app.Resource::resource() : @ecs.ResourceKey[ForwardDecalMesh]))
+    .get()
     is Some(forward_decal_mesh) else {
     return
   }
@@ -285,7 +287,7 @@ pub impl @app.Plugin for ForwardDecalPlugin with fn build(self, app) {
   app
   .world()
   .insert_resource(
-    ForwardDecalMesh::resource(),
+    (@app.Resource::resource() : @ecs.ResourceKey[ForwardDecalMesh]),
     ForwardDecalMesh::new(decal_mesh),
   )
   ensure_forward_decal_required_components_registered()
@@ -391,7 +393,11 @@ test "pbr decal forward: component hook assigns plugin decal mesh" {
     ForwardDecalPlugin::ForwardDecalPlugin(),
   )
   let world = app.world()
-  let decal_mesh = world.get_resource(ForwardDecalMesh::resource()).unwrap()
+  let decal_mesh = world
+    .get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ForwardDecalMesh]),
+    )
+    .unwrap()
   let entity = world.spawn_empty()
   try! world.set_by_key(
     entity,
diff --git a/mgstudio-engine/pbr/extended_material.mbt b/mgstudio-engine/pbr/extended_material.mbt
index 6277138a2..a31f03ea2 100644
--- a/mgstudio-engine/pbr/extended_material.mbt
+++ b/mgstudio-engine/pbr/extended_material.mbt
@@ -188,6 +188,97 @@ pub fn standard_material_extension_default_specialize_ref() -> @material.UserSpe
   None
 }
 
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_asset_debug_name(
+  _witness : E?,
+) -> String {
+  E::extended_material_asset_debug_name()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_vertex_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::vertex_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_fragment_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::fragment_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_prepass_vertex_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::prepass_vertex_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_prepass_fragment_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::prepass_fragment_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_deferred_vertex_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::deferred_vertex_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_deferred_fragment_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::deferred_fragment_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_meshlet_fragment_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::meshlet_fragment_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_meshlet_prepass_fragment_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::meshlet_prepass_fragment_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_meshlet_deferred_fragment_shader_ref(
+  _witness : E?,
+) -> String? {
+  E::meshlet_deferred_fragment_shader_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_enable_prepass(
+  _witness : E?,
+) -> Bool {
+  E::enable_prepass_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_enable_shadows(
+  _witness : E?,
+) -> Bool {
+  E::enable_shadows_ref()
+}
+
+///|
+fn[E : StandardMaterialExtension] standard_material_extension_specialize(
+  _witness : E?,
+) -> @material.UserSpecializeFn? {
+  E::specialize_ref()
+}
+
 ///|
 pub fn[T : MaterialExtension] material_extension_metadata_from_extension(
   extension : T,
@@ -406,7 +497,8 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn material_debug_name() {
-  E::extended_material_asset_debug_name()
+  let witness : E? = None
+  standard_material_extension_asset_debug_name(witness)
 }
 
 ///|
@@ -414,7 +506,7 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn material_keys() {
-  E::extended_material_keys()
+  StandardMaterialExtension::extended_material_keys()
 }
 
 ///|
@@ -422,8 +514,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn vertex_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::vertex_shader_ref(),
+    standard_material_extension_vertex_shader_ref(witness),
     extended_material_standard_vertex_shader(),
   )
 }
@@ -433,8 +526,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn fragment_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::fragment_shader_ref(),
+    standard_material_extension_fragment_shader_ref(witness),
     extended_material_standard_fragment_shader(),
   )
 }
@@ -444,8 +538,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn prepass_vertex_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::prepass_vertex_shader_ref(),
+    standard_material_extension_prepass_vertex_shader_ref(witness),
     extended_material_standard_prepass_vertex_shader(),
   )
 }
@@ -455,8 +550,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn prepass_fragment_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::prepass_fragment_shader_ref(),
+    standard_material_extension_prepass_fragment_shader_ref(witness),
     extended_material_standard_prepass_fragment_shader(),
   )
 }
@@ -466,8 +562,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn deferred_vertex_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::deferred_vertex_shader_ref(),
+    standard_material_extension_deferred_vertex_shader_ref(witness),
     extended_material_standard_deferred_vertex_shader(),
   )
 }
@@ -477,8 +574,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn deferred_fragment_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::deferred_fragment_shader_ref(),
+    standard_material_extension_deferred_fragment_shader_ref(witness),
     extended_material_standard_deferred_fragment_shader(),
   )
 }
@@ -488,8 +586,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn meshlet_fragment_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::meshlet_fragment_shader_ref(),
+    standard_material_extension_meshlet_fragment_shader_ref(witness),
     extended_material_standard_meshlet_fragment_shader(),
   )
 }
@@ -499,8 +598,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn meshlet_prepass_fragment_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::meshlet_prepass_fragment_shader_ref(),
+    standard_material_extension_meshlet_prepass_fragment_shader_ref(witness),
     extended_material_standard_meshlet_prepass_fragment_shader(),
   )
 }
@@ -510,8 +610,9 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn meshlet_deferred_fragment_shader() {
+  let witness : E? = None
   extended_material_shader_override(
-    E::meshlet_deferred_fragment_shader_ref(),
+    standard_material_extension_meshlet_deferred_fragment_shader_ref(witness),
     extended_material_standard_meshlet_deferred_fragment_shader(),
   )
 }
@@ -529,7 +630,7 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn alpha_mode(self) {
-  match self.extension.alpha_mode() {
+  match MaterialExtension::alpha_mode(self.extension) {
     Some(value) => value
     None => self.base.alpha_mode
   }
@@ -580,7 +681,8 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn enable_prepass() {
-  E::enable_prepass_ref()
+  let witness : E? = None
+  standard_material_extension_enable_prepass(witness)
 }
 
 ///|
@@ -588,7 +690,8 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn enable_shadows() {
-  E::enable_shadows_ref()
+  let witness : E? = None
+  standard_material_extension_enable_shadows(witness)
 }
 
 ///|
@@ -623,11 +726,14 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   let base = standard_material_bind_group_layout_descriptor(
     features=context.standard_material_texture_features(),
   )
-  let extension_entries = self.extension.bind_group_layout_entries()
+  let extension_entries = MaterialExtension::bind_group_layout_entries(
+    self.extension,
+  )
+  let witness : E? = None
   extended_material_bind_group_layout_descriptor(
     base,
     extension_entries,
-    E::extended_material_asset_debug_name(),
+    standard_material_extension_asset_debug_name(witness),
   )
 }
 
@@ -648,7 +754,7 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   E,
 ] with fn renderer_extra_bind_group_data(self, _context) {
   let entries : Array[@render_resource.MaterialBindGroupResolvedEntry] = []
-  for binding in self.extension.bind_group_bindings() {
+  for binding in MaterialExtension::bind_group_bindings(self.extension) {
     let material_binding = extended_material_binding_from_extension_binding(
       binding,
     )
@@ -662,9 +768,10 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
   StandardMaterial,
   E,
 ] with fn material_key(self) {
+  let witness : E? = None
   @material.ErasedMaterialKey::new(
     self.bind_group_data().hash64(),
-    "MaterialExtensionBindGroupData<\{E::extended_material_asset_debug_name()}>",
+    "MaterialExtensionBindGroupData<\{standard_material_extension_asset_debug_name(witness)}>",
   )
 }
 
@@ -688,16 +795,17 @@ pub impl[E : MaterialExtension + StandardMaterialExtension] Material for Extende
       "StandardMaterial",
     ),
   )
-  match E::specialize_ref() {
+  let witness : E? = None
+  match standard_material_extension_specialize(witness) {
     Some(user_specialize) =>
       user_specialize(
-        E::extended_material_asset_debug_name(),
+        standard_material_extension_asset_debug_name(witness),
         base_descriptor,
         layout,
         @material.ErasedMaterialPipelineKey::new(
           key.mesh_key(),
           key.material_key(),
-          E::extended_material_asset_debug_name(),
+          standard_material_extension_asset_debug_name(witness),
         ),
       )
     None => base_descriptor
diff --git a/mgstudio-engine/pbr/free_camera.mbt b/mgstudio-engine/pbr/free_camera.mbt
index f46981d11..d05b66ad8 100644
--- a/mgstudio-engine/pbr/free_camera.mbt
+++ b/mgstudio-engine/pbr/free_camera.mbt
@@ -98,14 +98,23 @@ impl @app.Resource for FreeCameraSystemState with fn resource() {
 fn free_camera_system_state_mut_or_init(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[FreeCameraSystemState] {
-  if world.get_resource(FreeCameraSystemState::resource()) is None {
-    world.insert_resource(FreeCameraSystemState::resource(), FreeCameraSystemState::{
-      toggle_cursor_grab: false,
-      mouse_cursor_grab: false,
-      last_mouse_position: None,
-    })
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[FreeCameraSystemState]),
+    )
+    is None {
+    world.insert_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[FreeCameraSystemState]),
+      FreeCameraSystemState::{
+        toggle_cursor_grab: false,
+        mouse_cursor_grab: false,
+        last_mouse_position: None,
+      },
+    )
   }
-  match world.get_resource_mut(FreeCameraSystemState::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[FreeCameraSystemState]),
+    ) {
     Some(state) => state
     None => abort("Missing FreeCameraSystemState resource")
   }
diff --git a/mgstudio-engine/pbr/material_bind_groups.mbt b/mgstudio-engine/pbr/material_bind_groups.mbt
index d1b432a55..d8f57f8c3 100644
--- a/mgstudio-engine/pbr/material_bind_groups.mbt
+++ b/mgstudio-engine/pbr/material_bind_groups.mbt
@@ -406,10 +406,12 @@ pub fn material_bind_group_allocator_for_support(
   bindless_supported : Bool,
   bindless_slot_count : Int?,
 ) -> MaterialBindGroupAllocator {
-  if material_uses_bindless_resources(bindless_supported, bindless_slot_count) {
-    MaterialBindGroupAllocator::default_bindless()
-  } else {
-    MaterialBindGroupAllocator::default_non_bindless()
+  match bindless_slot_count {
+    Some(slot_count) if bindless_supported && slot_count > 1 =>
+      MaterialBindGroupAllocator::Bindless(
+        MaterialBindGroupBindlessAllocator::with_slab_capacity(slot_count),
+      )
+    _ => MaterialBindGroupAllocator::default_non_bindless()
   }
 }
 
@@ -757,31 +759,22 @@ pub fn MaterialBindGroupBindlessAllocator::with_slab_capacity(
 pub fn MaterialBindGroupBindlessAllocator::allocate(
   self : MaterialBindGroupBindlessAllocator,
   material_id : Int,
-) -> MaterialBindingId? {
-  match self.free_slots.pop() {
+) -> MaterialBindingId {
+  let index = match self.free_slots.pop() {
     Some(slot) => {
       self.slots[slot] = Some(material_id)
-      Some(
-        MaterialBindingId::new(
-          MaterialBindGroupIndex::new(0),
-          MaterialBindGroupSlot::new(slot),
-        ),
-      )
+      slot
+    }
+    None => {
+      let slot = self.slots.length()
+      self.slots.push(Some(material_id))
+      slot
     }
-    None =>
-      if self.slots.length() >= self.slab_capacity {
-        None
-      } else {
-        let slot = self.slots.length()
-        self.slots.push(Some(material_id))
-        Some(
-          MaterialBindingId::new(
-            MaterialBindGroupIndex::new(0),
-            MaterialBindGroupSlot::new(slot),
-          ),
-        )
-      }
   }
+  MaterialBindingId::new(
+    MaterialBindGroupIndex::new(index / self.slab_capacity),
+    MaterialBindGroupSlot::new(index % self.slab_capacity),
+  )
 }
 
 ///|
@@ -789,13 +782,18 @@ pub fn MaterialBindGroupBindlessAllocator::free(
   self : MaterialBindGroupBindlessAllocator,
   binding_id : MaterialBindingId,
 ) -> Unit {
+  let group = binding_id.group().to_int()
   let slot = binding_id.slot().to_int()
-  if slot < 0 || slot >= self.slots.length() {
+  if group < 0 || slot < 0 || slot >= self.slab_capacity {
+    return
+  }
+  let index = group * self.slab_capacity + slot
+  if index < 0 || index >= self.slots.length() {
     return
   }
-  if self.slots[slot] is Some(_) {
-    self.slots[slot] = None
-    self.free_slots.push(slot)
+  if self.slots[index] is Some(_) {
+    self.slots[index] = None
+    self.free_slots.push(index)
   }
 }
 
@@ -893,7 +891,7 @@ pub fn MaterialBindGroupAllocator::allocate_bindless_material(
   material_id : Int,
 ) -> MaterialBindingId? {
   match self {
-    Bindless(allocator) => allocator.allocate(material_id)
+    Bindless(allocator) => Some(allocator.allocate(material_id))
     NonBindless(_) => None
   }
 }
@@ -972,11 +970,9 @@ pub fn MaterialBindGroupAllocators::install_standard_material(
   )
   self.insert(
     plan.material_label(),
-    if plan.uses_bindless_resources() {
-      MaterialBindGroupAllocator::default_bindless()
-    } else {
-      MaterialBindGroupAllocator::default_non_bindless()
-    },
+    material_bind_group_allocator_for_support(
+      bindless_supported, bindless_slot_count,
+    ),
   )
   plan
 }
diff --git a/mgstudio-engine/pbr/material_bind_groups_test.mbt b/mgstudio-engine/pbr/material_bind_groups_test.mbt
index 60749a124..33f0f78ce 100644
--- a/mgstudio-engine/pbr/material_bind_groups_test.mbt
+++ b/mgstudio-engine/pbr/material_bind_groups_test.mbt
@@ -30,23 +30,26 @@ test "render3d: non-bindless allocator reuses freed indices" {
 }
 
 ///|
-test "render3d: bindless allocator respects slab capacity" {
+test "render3d: bindless allocator grows across slabs" {
   let allocator = MaterialBindGroupBindlessAllocator::with_slab_capacity(2)
   let first = allocator.allocate(1001)
   let second = allocator.allocate(1002)
   let third = allocator.allocate(1003)
 
-  debug_inspect(first is Some(_), content="true")
-  debug_inspect(second is Some(_), content="true")
-  debug_inspect(third is None, content="true")
-  debug_inspect(allocator.len(), content="2")
+  debug_inspect(first.group().to_int(), content="0")
+  debug_inspect(second.slot().to_int(), content="1")
+  debug_inspect(third.group().to_int(), content="1")
+  debug_inspect(third.slot().to_int(), content="0")
+  debug_inspect(allocator.len(), content="3")
+  debug_inspect(allocator.slab_count(), content="2")
 
-  match first {
-    Some(binding) => allocator.free(binding)
-    None => ()
-  }
-  debug_inspect(allocator.len(), content="1")
-  debug_inspect(allocator.allocate(1004) is Some(_), content="true")
+  allocator.free(first)
+  debug_inspect(allocator.len(), content="2")
+  let reused = allocator.allocate(1004)
+  debug_inspect(
+    (reused.group().to_int(), reused.slot().to_int()),
+    content="(0, 0)",
+  )
 }
 
 ///|
@@ -97,7 +100,13 @@ test "render3d: material allocator allocates bindless material bindings only" {
     Some(binding) => debug_inspect(binding.slot().to_int(), content="1")
     None => abort("expected second bindless material binding")
   }
-  debug_inspect(bindless.allocate_bindless_material(12) is None, content="true")
+  match bindless.allocate_bindless_material(12) {
+    Some(binding) => {
+      debug_inspect(binding.group().to_int(), content="1")
+      debug_inspect(binding.slot().to_int(), content="0")
+    }
+    None => abort("expected allocation in a second bindless slab")
+  }
 
   let non_bindless = MaterialBindGroupAllocator::default_non_bindless()
   debug_inspect(
@@ -169,8 +178,17 @@ test "render3d: standard material allocator install chooses bindless mode from b
   debug_inspect(bindless_plan.uses_bindless_resources(), content="true")
   debug_inspect(bindless_allocators.len(), content="1")
   match bindless_allocators.get("StandardMaterial") {
-    Some(MaterialBindGroupAllocator::Bindless(_)) =>
+    Some(MaterialBindGroupAllocator::Bindless(allocator)) => {
       debug_inspect(true, content="true")
+      for material_id in 0..<8 {
+        ignore(allocator.allocate(material_id))
+      }
+      let ninth = allocator.allocate(8)
+      debug_inspect(
+        (ninth.group().to_int(), ninth.slot().to_int()),
+        content="(1, 0)",
+      )
+    }
     _ => debug_inspect(false, content="true")
   }
 
diff --git a/mgstudio-engine/pbr/material_plugin.mbt b/mgstudio-engine/pbr/material_plugin.mbt
index e931e9542..ec28e89b3 100644
--- a/mgstudio-engine/pbr/material_plugin.mbt
+++ b/mgstudio-engine/pbr/material_plugin.mbt
@@ -1369,11 +1369,18 @@ pub impl[M : Material + @asset.Asset] @app.Plugin for MaterialPlugin[M] with fn
   material_plugin_build(app, self)
 }
 
+///|
+fn[M : @asset.Asset] material_plugin_asset_debug_name(
+  _plugin : MaterialPlugin[M],
+) -> String {
+  M::asset_debug_name()
+}
+
 ///|
 pub impl[M : Material + @asset.Asset] @app.Plugin for MaterialPlugin[M] with fn name(
-  _self,
+  self,
 ) {
-  "mgstudio.pbr.MaterialPlugin<\{M::asset_debug_name()}>"
+  "mgstudio.pbr.MaterialPlugin<\{material_plugin_asset_debug_name(self)}>"
 }
 
 ///|
@@ -1394,6 +1401,20 @@ fn[M : Material] material_pipeline_from_material_hooks(
   )
 }
 
+///|
+fn[M : Material] material_register_shader_sources_for_handle(
+  _probe : @asset.Handle[M],
+) -> Bool {
+  M::register_shader_sources()
+}
+
+///|
+fn[M : Material] material_debug_name_for_handle(
+  _probe : @asset.Handle[M],
+) -> String {
+  M::material_debug_name()
+}
+
 ///|
 fn[M : Material] ensure_prepared_material_assets_resource_in_world(
   world : @ecs.World,
@@ -1602,26 +1623,6 @@ fn[M : Material] check_typed_entities_needing_specialization_system(
   })
 }
 
-///|
-fn[M] collect_changed_typed_mesh_material_entities(
-  source_world : @ecs.World,
-  material_key : @ecs.ComponentKey[MeshMaterial3dTyped[M]],
-  system_ticks : @core.SystemTicks,
-) -> Map[UInt64, @core.Entity] {
-  let changed_entities : Map[UInt64, @core.Entity] = Map([])
-  for
-    entity in source_world
-    .changed_components(@visibility.ecs_key_view_visibility, system_ticks)
-    .read() {
-    changed_entities.set(entity.to_bits(), entity)
-  }
-  for
-    entity in source_world.changed_components(material_key, system_ticks).read() {
-    changed_entities.set(entity.to_bits(), entity)
-  }
-  changed_entities
-}
-
 ///|
 fn[M] collect_removed_typed_mesh_material_entities(
   source_world : @ecs.World,
@@ -1759,7 +1760,7 @@ fn[M : Material + @asset.Asset] material_plugin_build(
   plugin : MaterialPlugin[M],
 ) -> @app.App[@ecs.World] {
   let probe : @asset.Handle[M] = @asset.Handle::new(0)
-  let shader_paths = if M::register_shader_sources() {
+  let shader_paths = if material_register_shader_sources_for_handle(probe) {
     material_shader_asset_paths(probe)
   } else {
     []
@@ -1797,7 +1798,7 @@ fn[M : Material + @asset.Asset] material_plugin_build(
       @app.system(fn(world : @ecs.World) {
         add_material_bind_group_allocator_system(world, probe)
       }).named(
-        "mgstudio_pbr::add_material_bind_group_allocator<\{M::material_debug_name()}>",
+        "mgstudio_pbr::add_material_bind_group_allocator<\{material_debug_name_for_handle(probe)}>",
       ),
     )
     .add_systems(
@@ -1886,61 +1887,94 @@ fn[M : Material] extract_mesh_materials_system(
   }
   instances.modify(fn(value) {
     material_shader_paths.modify(fn(paths) {
-      let changed_entities = collect_changed_typed_mesh_material_entities(
-        source_world, material_key, system_ticks,
-      )
-      for _, entity in changed_entities {
-        if !source_world.is_alive(entity) {
-          continue
-        }
-        guard (try! source_world.get_by_key(entity, material_key))
-          is Some(material) else {
-          continue
-        }
-        let view_visible = match
-          (try! source_world.get_by_key(
-            entity, @visibility.ecs_key_view_visibility,
-          )) {
-          Some(view_visibility) => view_visibility.is_visible()
-          None => false
-        }
-        value.set(entity, material.handle())
-        match
-          world.get_resource_mut(RenderMaterial3dResolvedSlots::resource()) {
-          Some(resolved_slots) =>
-            resolved_slots.modify(fn(slots) {
-              if view_visible {
-                let prepared_handle = PreparedMaterial::prepared_handle(
-                  material.handle(),
-                )
-                match prepared_material_get(prepared_assets, prepared_handle) {
-                  Some(prepared) =>
-                    slots.set_resolved(entity, prepared.resolved_material())
-                  None => slots.set_pending(entity)
+      with_source_world_system_ticks(source_world, system_ticks, fn() {
+        let query : @ecs.Query[
+          (
+            @ecs.ReadValue[@visibility.ViewVisibility],
+            @ecs.ReadValue[MeshMaterial3dTyped[M]],
+          ),
+          @ecs.Or[
+            (
+              @ecs.Changed[@visibility.ViewVisibility],
+              @ecs.Changed[MeshMaterial3dTyped[M]],
+            ),
+          ],
+        ] = @ecs.query_filtered(
+          source_world,
+          @ecs.Or::new(
+            (
+              @ecs.Changed::new(@visibility.ecs_key_view_visibility),
+              @ecs.Changed::new(material_key),
+            ),
+          ),
+        )
+        fn extract_entity(
+          entity : @core.Entity,
+          view_visibility : @visibility.ViewVisibility,
+          material : MeshMaterial3dTyped[M],
+        ) -> Unit {
+          let view_visible = view_visibility.is_visible()
+          value.set(entity, material.handle())
+          match
+            world.get_resource_mut(RenderMaterial3dResolvedSlots::resource()) {
+            Some(resolved_slots) =>
+              resolved_slots.modify(fn(slots) {
+                if view_visible {
+                  let prepared_handle = PreparedMaterial::prepared_handle(
+                    material.handle(),
+                  )
+                  match
+                    prepared_material_get(prepared_assets, prepared_handle) {
+                    Some(prepared) =>
+                      slots.set_resolved(entity, prepared.resolved_material())
+                    None => slots.set_pending(entity)
+                  }
+                } else {
+                  slots.remove(entity)
                 }
-              } else {
-                slots.remove(entity)
-              }
-            })
-          None => ()
-        }
-        if view_visible {
-          for path in shader_paths {
-            paths.insert(Some(path))
+              })
+            None => ()
+          }
+          if view_visible {
+            for path in shader_paths {
+              paths.insert(Some(path))
+            }
+          }
+          match global_instances {
+            Some(global) =>
+              global.modify(fn(global_value) {
+                global_value.extract_mesh_material_id(
+                  entity,
+                  view_visible,
+                  material.handle().id(),
+                )
+              })
+            None => ()
           }
         }
-        match global_instances {
-          Some(global) =>
-            global.modify(fn(global_value) {
-              global_value.extract_mesh_material_id(
-                entity,
-                view_visible,
-                material.handle().id(),
-              )
-            })
-          None => ()
+        let used_batch = try! query.try_for_each_filtered_table(fn(
+          batch,
+          rows,
+        ) {
+          let view_visibilities = batch
+            .read(@visibility.ecs_key_view_visibility)
+            .unwrap()
+          let materials = batch.read(material_key).unwrap()
+          try! rows.for_each(fn(row_index) {
+            extract_entity(
+              batch.entity(row_index),
+              view_visibilities.value(row_index),
+              materials.value(row_index),
+            )
+          })
+        })
+        if !used_batch {
+          try! query.for_each(fn(entity, data) {
+            let (view_visibility, material) = data
+            extract_entity(entity, view_visibility.value(), material.value())
+          })
         }
-      }
+      })
     })
   })
 }
@@ -2143,7 +2177,7 @@ fn[M : Material + @asset.Asset] material_asset_changed_ids_since_last_prepare(
     return changed_ids
   }
   ensure_material_asset_event_cursor_resource_in_world(render_world, _probe)
-  let cursor_key = M::material_keys().material_asset_event_cursor
+  let cursor_key = Material::material_keys().material_asset_event_cursor
   guard render_world.get_resource_mut(cursor_key) is Some(cursor_resource) else {
     return changed_ids
   }
diff --git a/mgstudio-engine/pbr/materials_plugin_wbtest.mbt b/mgstudio-engine/pbr/materials_plugin_wbtest.mbt
index 364c2282a..7d507206a 100644
--- a/mgstudio-engine/pbr/materials_plugin_wbtest.mbt
+++ b/mgstudio-engine/pbr/materials_plugin_wbtest.mbt
@@ -218,17 +218,15 @@ test "render3d: batchable shadow phase merges contiguous Bevy batch ranges" {
     phase.input_uniform_index(second_main),
     content="Some(InputUniformIndex(15))",
   )
-  let render_mesh_instances = RenderMeshInstances::new(
-    use_gpu_instance_buffer_builder=true,
-  )
-  render_mesh_instances.insert(
-    first_main,
-    RenderMeshQueueData::new(77, 14U, true),
+  let phase_instances : @render_batching.PhaseBatchedInstanceBuffers[Unit] = @render_batching.PhaseBatchedInstanceBuffers::new()
+  let phase_indirect = @render_batching.PhaseIndirectParametersBuffers::new(
+    false,
   )
-  render_mesh_instances.insert(
-    second_main,
-    RenderMeshQueueData::new(77, 15U, true),
+  phase.prepare_batchable_phase_buffers(
+    "shadow-resolve-view", true, false, phase_instances, phase_indirect,
   )
+  inspect(phase.items()[0].batch_range().start(), content="0")
+  inspect(phase.items()[0].batch_range().end(), content="2")
   let meshes = [
     ExtractedMesh3d::{
       entity: phase_entity_ref3d_for_main(first_main.id()),
@@ -245,17 +243,14 @@ test "render3d: batchable shadow phase merges contiguous Bevy batch ranges" {
       ),
     },
   ]
-  let resolved = render3d_shadow_resolve_phase_items(
-    meshes,
-    render_mesh_instances,
-    phase.items(),
-  )
-  debug_inspect(resolved.length(), content="1")
+  let resolved = render3d_shadow_resolve_phase_items(meshes, phase)
+  debug_inspect(resolved.length(), content="2")
   debug_inspect(
     render3d_resolved_shadow_phase_draw_count(resolved),
     content="2",
   )
-  debug_inspect(resolved[0].extracted_indices.length(), content="2")
+  debug_inspect(resolved[0].extracted_indices.length(), content="1")
+  debug_inspect(resolved[1].extracted_indices.length(), content="1")
 }
 
 ///|
@@ -268,24 +263,15 @@ test "render3d: shadow phase resolve keeps Bevy mesh bins isolated" {
   )
   let first_main = @render.MainEntity::new(@core.Entity::new(51, 1))
   let second_main = @render.MainEntity::new(@core.Entity::new(52, 1))
-  let item = Render3dShadowPhaseItemData::new(
+  let phase = Render3dShadowViewPhaseData::new(
+    @render_batching.GpuPreprocessingMode::None,
+  )
+  phase.add(
     key,
     Render3dShadowBinKeyData::new(77),
-    @core.Entity::new(61, 1),
-    first_main,
-    Render3dShadowBatchRange::new(14, 16),
-    Render3dShadowPhaseItemExtraIndex::none(),
-  )
-  let render_mesh_instances = RenderMeshInstances::new(
-    use_gpu_instance_buffer_builder=true,
-  )
-  render_mesh_instances.insert(
-    first_main,
-    RenderMeshQueueData::new(77, 14U, true),
-  )
-  render_mesh_instances.insert(
-    second_main,
-    RenderMeshQueueData::new(78, 15U, true),
+    (@core.Entity::new(61, 1), first_main),
+    14U,
+    Render3dShadowBinnedRenderPhaseType::BatchableMesh,
   )
   let meshes = [
     ExtractedMesh3d::{
@@ -303,11 +289,7 @@ test "render3d: shadow phase resolve keeps Bevy mesh bins isolated" {
       ),
     },
   ]
-  let resolved = render3d_shadow_resolve_phase_items(
-    meshes,
-    render_mesh_instances,
-    [item],
-  )
+  let resolved = render3d_shadow_resolve_phase_items(meshes, phase)
   debug_inspect(resolved.length(), content="1")
   debug_inspect(
     render3d_resolved_shadow_phase_draw_count(resolved),
diff --git a/mgstudio-engine/pbr/moon.pkg b/mgstudio-engine/pbr/moon.pkg
index 5b02307a1..08da5d463 100644
--- a/mgstudio-engine/pbr/moon.pkg
+++ b/mgstudio-engine/pbr/moon.pkg
@@ -70,7 +70,7 @@ import {
   "Milky2018/mgstudio/core_pipeline/fullscreen_vertex_shader/source" @fullscreen_vertex_shader_source,
   "Milky2018/mgstudio/mesh/primitives" @mesh_primitives,
   "Milky2018/mgstudio/shader/compile" @shader_compile,
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
 } for "test"
 
 import {
diff --git a/mgstudio-engine/pbr/pkg.generated.mbti b/mgstudio-engine/pbr/pkg.generated.mbti
index f50b14a60..a23d85216 100644
--- a/mgstudio-engine/pbr/pkg.generated.mbti
+++ b/mgstudio-engine/pbr/pkg.generated.mbti
@@ -1750,7 +1750,7 @@ pub struct MaterialBindGroupBindlessAllocator {
   free_slots : Array[Int]
 }
 pub fn MaterialBindGroupBindlessAllocator::MaterialBindGroupBindlessAllocator() -> Self
-pub fn MaterialBindGroupBindlessAllocator::allocate(Self, Int) -> MaterialBindingId?
+pub fn MaterialBindGroupBindlessAllocator::allocate(Self, Int) -> MaterialBindingId
 pub fn MaterialBindGroupBindlessAllocator::allocations(Self) -> UInt
 pub fn MaterialBindGroupBindlessAllocator::free(Self, MaterialBindingId) -> Unit
 pub fn MaterialBindGroupBindlessAllocator::len(Self) -> Int
@@ -3733,4 +3733,3 @@ pub(open) trait StandardMaterialExtension {
   fn enable_shadows_ref() -> Bool
   fn specialize_ref() -> ((String, @render_resource.RenderPipelineDescriptor, @Milky2018/mgstudio/mesh.MeshVertexBufferLayoutRef, @material.ErasedMaterialPipelineKey) -> @render_resource.RenderPipelineDescriptor raise @material.SpecializedMeshPipelineError)?
 }
-
diff --git a/mgstudio-engine/pbr/render/diagnostic.mbt b/mgstudio-engine/pbr/render/diagnostic.mbt
index 0449d8a8f..e9c36a175 100644
--- a/mgstudio-engine/pbr/render/diagnostic.mbt
+++ b/mgstudio-engine/pbr/render/diagnostic.mbt
@@ -46,13 +46,19 @@ impl @app.Resource for Render3dDiagnosticsState with fn resource() {
 fn render3d_diagnostics_state_mut_or_init(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dDiagnosticsState] {
-  if world.get_resource(Render3dDiagnosticsState::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dDiagnosticsState]),
+    )
+    is None {
     world.insert_resource(
-      Render3dDiagnosticsState::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dDiagnosticsState]),
       render3d_diagnostics_state_default(),
     )
   }
-  match world.get_resource_mut(Render3dDiagnosticsState::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dDiagnosticsState]),
+    ) {
     Some(state) => state
     None => abort("Missing Render3dDiagnosticsState resource")
   }
diff --git a/mgstudio-engine/pbr/render/moon.pkg b/mgstudio-engine/pbr/render/moon.pkg
index d91cc1f4b..5e76b7f66 100644
--- a/mgstudio-engine/pbr/render/moon.pkg
+++ b/mgstudio-engine/pbr/render/moon.pkg
@@ -33,7 +33,7 @@ import {
   "Milky2018/mgstudio/transform",
   "Milky2018/mgstudio/visibility",
   "Milky2018/mgstudio/window",
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
   "Milky2018/moon_wgsl_naga_oil/compose" @wgsl_compose,
   "Milky2018/mgstudio/shader/source" @shader_source,
   "Milky2018/wgpu_mbt" @wgpu,
diff --git a/mgstudio-engine/pbr/render/pkg.generated.mbti b/mgstudio-engine/pbr/render/pkg.generated.mbti
index 52f6cee4a..5820c0216 100644
--- a/mgstudio-engine/pbr/render/pkg.generated.mbti
+++ b/mgstudio-engine/pbr/render/pkg.generated.mbti
@@ -27,8 +27,8 @@ import {
   "Milky2018/mgstudio/time",
   "Milky2018/mgstudio/transform",
   "Milky2018/moon_wgsl_naga_oil/compose",
+  "Milky2018/moon_wgsl_naga_oil/contract",
   "Milky2018/wgpu_mbt",
-  "Milky2018/wgsl/common",
   "moonbitlang/core/debug",
   "moonbitlang/core/hashmap",
   "moonbitlang/core/hashset",
@@ -556,7 +556,7 @@ pub fn render3d_transform_local_normal(@transform.Transform, @math.Vec3) -> @mat
 
 pub fn render3d_transform_point(@transform.Transform, @math.Vec3) -> @math.Vec3
 
-pub fn[T] render3d_update_frusta_system_by_projection_key(@ecs.World, @ecs.ComponentKey[T], (T, @transform.Transform) -> @primitives.Frustum) -> Unit
+pub fn[T : @ecs.Component] render3d_update_frusta_system_by_projection_key(@ecs.World, @ecs.ComponentKey[T], (T, @transform.Transform) -> @primitives.Frustum) -> Unit
 
 pub fn render3d_upload_mesh_handle_cached(Render3dMeshRuntimeState, @asset.Handle[@mesh.Mesh]) -> Int
 
@@ -1369,7 +1369,7 @@ pub using @projection3d {type OrthographicProjection3d}
 
 pub using @projection3d {type OrthographicScalingMode3d}
 
-pub using @common {type WgslComposeOptions as PbrRenderWgslComposeOptions}
+pub using @contract {type WgslComposeOptions as PbrRenderWgslComposeOptions}
 
 pub using @compose {type Composer as PbrRenderWgslComposer}
 
@@ -1388,4 +1388,3 @@ pub using @primitives {type SubCameraView3d}
 pub using @projection3d {type ViewFrustum}
 
 // Traits
-
diff --git a/mgstudio-engine/pbr/render/systems.mbt b/mgstudio-engine/pbr/render/systems.mbt
index b4aba547a..ea272e4b5 100644
--- a/mgstudio-engine/pbr/render/systems.mbt
+++ b/mgstudio-engine/pbr/render/systems.mbt
@@ -35,58 +35,47 @@ pub fn render3d_system_labels() -> Array[String] {
 }
 
 ///|
-pub fn[T] render3d_update_frusta_system_by_projection_key(
+pub fn[T : @ecs.Component] render3d_update_frusta_system_by_projection_key(
   world : @ecs.World,
   projection_key : @ecs.ComponentKey[T],
   compute_frustum : (T, @transform.Transform) -> Frustum,
 ) -> Unit {
-  let tick = world.get_tick_context().ticks()
-  let processed = @hashset.HashSet([])
-  fn entity_key(entity : @core.Entity) -> UInt64 {
-    let hi = entity.id.reinterpret_as_uint().to_uint64()
-    let lo = entity.generation.reinterpret_as_uint().to_uint64() & 0xFFFF_FFFFUL
-    (hi << 32) | lo
-  }
-  fn update_entity(
-    world : @ecs.World,
-    entity : @core.Entity,
-    projection_key : @ecs.ComponentKey[T],
-    compute_frustum : (T, @transform.Transform) -> Frustum,
-  ) -> Unit {
-    guard world.is_alive(entity) else { return }
-    guard (try! world.get_by_key(entity, @transform.ecs_key_transform))
-      is Some(transform) else {
-      return
-    }
-    guard (try! world.get_by_key(entity, projection_key)) is Some(projection) else {
-      return
-    }
-    let next = compute_frustum(projection, transform)
-    if (try! world.get_by_key(entity, ecs_key_frustum)) is Some(current) {
-      if current != next {
-        try! (world.replace(entity, ecs_key_frustum, next) |> ignore)
+  let query : @ecs.Query[
+    (
+      @ecs.ReadValue[@transform.Transform],
+      @ecs.ReadValue[T],
+      @ecs.Write[Frustum],
+    ),
+    @ecs.Or[(@ecs.Changed[@transform.Transform], @ecs.Changed[T])],
+  ] = @ecs.query_filtered(
+    world,
+    @ecs.Or::new(
+      (
+        @ecs.Changed::new(@transform.ecs_key_transform),
+        @ecs.Changed::new(projection_key),
+      ),
+    ),
+  )
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let transforms = batch.read(@transform.ecs_key_transform).unwrap()
+    let projections = batch.read(projection_key).unwrap()
+    let frusta = batch.write(ecs_key_frustum).unwrap()
+    try! rows.for_each(fn(row_index) {
+      let next = compute_frustum(
+        projections.value(row_index), transforms.value(row_index),
+      )
+      if frusta.peek(row_index) != next {
+        frusta.set(row_index, next)
       }
-    } else {
-      try! world.set_by_key(entity, ecs_key_frustum, next)
-    }
-  }
-  for
-    entity in world
-    .changed_components(@transform.ecs_key_transform, tick)
-    .read() {
-    let key = entity_key(entity)
-    if processed.contains(key) {
-      continue
-    }
-    processed.add(key)
-    update_entity(world, entity, projection_key, compute_frustum)
-  }
-  for entity in world.changed_components(projection_key, tick).read() {
-    let key = entity_key(entity)
-    if processed.contains(key) {
-      continue
-    }
-    processed.add(key)
-    update_entity(world, entity, projection_key, compute_frustum)
+    })
+  })
+  if !used_batch {
+    try! query.for_each(fn(_entity, data) {
+      let (transform, projection, frustum) = data
+      let next = compute_frustum(projection.value(), transform.value())
+      if frustum.peek() != next {
+        frustum.set(next)
+      }
+    })
   }
 }
diff --git a/mgstudio-engine/pbr/render/wgsl_entrypoint_wbtest.mbt b/mgstudio-engine/pbr/render/wgsl_entrypoint_wbtest.mbt
index b2c5c0cae..78caadc2d 100644
--- a/mgstudio-engine/pbr/render/wgsl_entrypoint_wbtest.mbt
+++ b/mgstudio-engine/pbr/render/wgsl_entrypoint_wbtest.mbt
@@ -30,9 +30,10 @@ test "pbr render: item-imported entrypoints are tree-shaken when unused" {
   )
   let source = composer.compose_wgsl("entry.wgsl", @wgsl_common.WgslComposeOptions::{
     defines: Map([]),
-    value_defines: @wgsl_common.default_wgsl_value_defines(),
+    value_defines: @wgsl_common.bevy_wgsl_value_defines(),
     redirects: [],
     additional_imports: [],
+    immediate_specializations: [],
   }) catch {
     err =>
       abort(
@@ -67,9 +68,10 @@ test "pbr render: module alias global binding access composes" {
   )
   let source = composer.compose_wgsl("view_transformations.wgsl", @wgsl_common.WgslComposeOptions::{
     defines: Map([]),
-    value_defines: @wgsl_common.default_wgsl_value_defines(),
+    value_defines: @wgsl_common.bevy_wgsl_value_defines(),
     redirects: [],
     additional_imports: [],
+    immediate_specializations: [],
   }) catch {
     err =>
       abort(
diff --git a/mgstudio-engine/pbr/render/world_transform_cache.mbt b/mgstudio-engine/pbr/render/world_transform_cache.mbt
index 20a8105ff..5870ba9f8 100644
--- a/mgstudio-engine/pbr/render/world_transform_cache.mbt
+++ b/mgstudio-engine/pbr/render/world_transform_cache.mbt
@@ -129,13 +129,19 @@ impl @app.Resource for Render3dWorldTransformCache with fn resource() {
 pub fn render3d_world_transform_cache_mut(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dWorldTransformCache] {
-  if world.get_resource(Render3dWorldTransformCache::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dWorldTransformCache]),
+    )
+    is None {
     world.insert_resource(
-      Render3dWorldTransformCache::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dWorldTransformCache]),
       render3d_world_transform_cache_new(),
     )
   }
-  match world.get_resource_mut(Render3dWorldTransformCache::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dWorldTransformCache]),
+    ) {
     Some(cache) => cache
     None => abort("Missing Render3dWorldTransformCache resource")
   }
diff --git a/mgstudio-engine/pbr/render_execute.mbt b/mgstudio-engine/pbr/render_execute.mbt
index de4cc4e8d..1d1803f2d 100644
--- a/mgstudio-engine/pbr/render_execute.mbt
+++ b/mgstudio-engine/pbr/render_execute.mbt
@@ -2693,6 +2693,20 @@ pub fn Render3dShadowViewPhaseData::input_uniform_index(
   self.input_uniform_indices.get(main_entity.id().to_bits())
 }
 
+///|
+fn Render3dShadowViewPhaseData::cached_bin_key(
+  self : Render3dShadowViewPhaseData,
+  main_entity : @render.MainEntity,
+) -> @render_phase.CachedBinKey[
+  Render3dShadowBatchSetKeyData,
+  Render3dShadowBinKeyData,
+]? {
+  match self.cached_entity_bin_keys.get(main_entity) {
+    Some(cached_entity) => cached_entity.cached_bin_key()
+    None => None
+  }
+}
+
 ///|
 pub fn Render3dShadowViewPhaseData::phase_type(
   self : Render3dShadowViewPhaseData,
diff --git a/mgstudio-engine/pbr/render_execute_camera_directional_shadow.mbt b/mgstudio-engine/pbr/render_execute_camera_directional_shadow.mbt
index b49def264..fc248111a 100644
--- a/mgstudio-engine/pbr/render_execute_camera_directional_shadow.mbt
+++ b/mgstudio-engine/pbr/render_execute_camera_directional_shadow.mbt
@@ -535,14 +535,25 @@ impl @app.Resource for Render3dDirectionalLightShadowTargets with fn resource()
 fn render3d_directional_light_shadow_targets_mut_or_init(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dDirectionalLightShadowTargets] {
-  if world.get_resource(Render3dDirectionalLightShadowTargets::resource())
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dDirectionalLightShadowTargets]),
+    )
     is None {
-    world.insert_resource(Render3dDirectionalLightShadowTargets::resource(), {
-      entries: [],
-    })
+    world.insert_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dDirectionalLightShadowTargets]),
+      { entries: [] },
+    )
   }
   match
-    world.get_resource_mut(Render3dDirectionalLightShadowTargets::resource()) {
+    world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dDirectionalLightShadowTargets]),
+    ) {
     Some(state) => state
     None => abort("Missing Render3dDirectionalLightShadowTargets resource")
   }
diff --git a/mgstudio-engine/pbr/render_execute_camera_point_shadow.mbt b/mgstudio-engine/pbr/render_execute_camera_point_shadow.mbt
index bcc95271c..d0f4dd640 100644
--- a/mgstudio-engine/pbr/render_execute_camera_point_shadow.mbt
+++ b/mgstudio-engine/pbr/render_execute_camera_point_shadow.mbt
@@ -183,12 +183,25 @@ impl @app.Resource for Render3dPointLightShadowTargets with fn resource() {
 fn render3d_point_light_shadow_targets_mut_or_init(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dPointLightShadowTargets] {
-  if world.get_resource(Render3dPointLightShadowTargets::resource()) is None {
-    world.insert_resource(Render3dPointLightShadowTargets::resource(), {
-      entries: [],
-    })
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dPointLightShadowTargets]),
+    )
+    is None {
+    world.insert_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dPointLightShadowTargets]),
+      { entries: [] },
+    )
   }
-  match world.get_resource_mut(Render3dPointLightShadowTargets::resource()) {
+  match
+    world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dPointLightShadowTargets]),
+    ) {
     Some(state) => state
     None => abort("Missing Render3dPointLightShadowTargets resource")
   }
diff --git a/mgstudio-engine/pbr/render_execute_queue_state.mbt b/mgstudio-engine/pbr/render_execute_queue_state.mbt
index e59f24db1..f99a38903 100644
--- a/mgstudio-engine/pbr/render_execute_queue_state.mbt
+++ b/mgstudio-engine/pbr/render_execute_queue_state.mbt
@@ -112,9 +112,12 @@ impl @app.Resource for Render3dExecuteQueueState with fn resource() {
 
 ///|
 fn ensure_render3d_execute_queue_state(world : @ecs.World) -> Unit {
-  if world.get_resource(Render3dExecuteQueueState::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dExecuteQueueState]),
+    )
+    is None {
     world.insert_resource(
-      Render3dExecuteQueueState::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dExecuteQueueState]),
       render3d_execute_queue_state_default(),
     )
   }
@@ -125,7 +128,10 @@ fn render3d_execute_queue_state_mut_or_abort(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dExecuteQueueState] {
   ensure_render3d_execute_queue_state(world)
-  match world.get_resource_mut(Render3dExecuteQueueState::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dExecuteQueueState]),
+    ) {
     Some(state) => state
     None => abort("Missing Render3dExecuteQueueState resource in render world")
   }
diff --git a/mgstudio-engine/pbr/render_extract.mbt b/mgstudio-engine/pbr/render_extract.mbt
index 8410bfe1e..0398cfa6a 100644
--- a/mgstudio-engine/pbr/render_extract.mbt
+++ b/mgstudio-engine/pbr/render_extract.mbt
@@ -144,24 +144,21 @@ let late_sweep_material_instances_set : @app.SystemSet = @app.system_set(
 )
 
 ///|
-fn collect_changed_mesh_material_entities(
+fn[R] with_source_world_system_ticks(
   source_world : @ecs.World,
   system_ticks : @core.SystemTicks,
-) -> Map[UInt64, @core.Entity] {
-  let changed_entities : Map[UInt64, @core.Entity] = Map([])
-  for
-    entity in source_world
-    .changed_components(@visibility.ecs_key_view_visibility, system_ticks)
-    .read() {
-    changed_entities.set(entity.to_bits(), entity)
-  }
-  for
-    entity in source_world
-    .changed_components(ecs_key_mesh_material3d, system_ticks)
-    .read() {
-    changed_entities.set(entity.to_bits(), entity)
-  }
-  changed_entities
+  run : () -> R,
+) -> R {
+  let previous_ticks = source_world.get_tick_context().ticks()
+  let query_context = @core.SystemTickContext::new()
+  query_context.set(system_ticks)
+  source_world.set_tick_context(query_context)
+  defer {
+    let previous_context = @core.SystemTickContext::new()
+    previous_context.set(previous_ticks)
+    source_world.set_tick_context(previous_context)
+  }
+  run()
 }
 
 ///|
@@ -506,9 +503,6 @@ fn extract_mesh_materials(render_world : @ecs.World) -> Unit {
     Some(instances) => instances.source_system_ticks(source_world)
     None => @core.SystemTicks::new(0, source_world.read_change_tick())
   }
-  let changed_entities = collect_changed_mesh_material_entities(
-    source_world, system_ticks,
-  )
   let material_instances = match
     render_world.get_resource_mut(ecs_key_render_material_instances) {
     Some(value) => value
@@ -527,30 +521,64 @@ fn extract_mesh_materials(render_world : @ecs.World) -> Unit {
   }
   material_instances.modify(fn(instances) {
     material_shader_paths.modify(fn(shader_paths) {
-      for _, entity in changed_entities {
-        if !source_world.is_alive(entity) {
-          continue
-        }
-        match
+      with_source_world_system_ticks(source_world, system_ticks, fn() {
+        let query : @ecs.Query[
           (
-            try! source_world.get_by_key(
-              entity, @visibility.ecs_key_view_visibility,
+            @ecs.ReadValue[@visibility.ViewVisibility],
+            @ecs.ReadValue[MeshMaterial3d],
+          ),
+          @ecs.Or[
+            (
+              @ecs.Changed[@visibility.ViewVisibility],
+              @ecs.Changed[MeshMaterial3d],
             ),
-            try! source_world.get_by_key(entity, ecs_key_mesh_material3d),
-          ) {
-          (Some(view_visibility), Some(material)) => {
-            instances.extract_mesh_material(
-              entity,
-              view_visibility.is_visible(),
-              material,
-            )
-            if view_visibility.is_visible() {
-              shader_paths.extract_mesh_material(material)
-            }
+          ],
+        ] = @ecs.query_filtered(
+          source_world,
+          @ecs.Or::new(
+            (
+              @ecs.Changed::new(@visibility.ecs_key_view_visibility),
+              @ecs.Changed::new(ecs_key_mesh_material3d),
+            ),
+          ),
+        )
+        fn extract_entity(
+          entity : @core.Entity,
+          view_visibility : @visibility.ViewVisibility,
+          material : MeshMaterial3d,
+        ) -> Unit {
+          instances.extract_mesh_material(
+            entity,
+            view_visibility.is_visible(),
+            material,
+          )
+          if view_visibility.is_visible() {
+            shader_paths.extract_mesh_material(material)
           }
-          _ => ()
         }
-      }
+        let used_batch = try! query.try_for_each_filtered_table(fn(
+          batch,
+          rows,
+        ) {
+          let view_visibilities = batch
+            .read(@visibility.ecs_key_view_visibility)
+            .unwrap()
+          let materials = batch.read(ecs_key_mesh_material3d).unwrap()
+          try! rows.for_each(fn(row_index) {
+            extract_entity(
+              batch.entity(row_index),
+              view_visibilities.value(row_index),
+              materials.value(row_index),
+            )
+          })
+        })
+        if !used_batch {
+          try! query.for_each(fn(entity, data) {
+            let (view_visibility, material) = data
+            extract_entity(entity, view_visibility.value(), material.value())
+          })
+        }
+      })
     })
   })
 }
diff --git a/mgstudio-engine/pbr/render_phase_items.mbt b/mgstudio-engine/pbr/render_phase_items.mbt
index d7eafcdf9..d903b7e90 100644
--- a/mgstudio-engine/pbr/render_phase_items.mbt
+++ b/mgstudio-engine/pbr/render_phase_items.mbt
@@ -501,33 +501,64 @@ impl @app.Resource for Render3dTransparentMainViewPhases with fn resource() {
 
 ///|
 fn ensure_render3d_main_view_phase_resources(world : @ecs.World) -> Unit {
-  if world.get_resource(Render3dMainViewDrawItems::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
+    )
+    is None {
     world.insert_resource(
-      Render3dMainViewDrawItems::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
       Render3dMainViewDrawItems::Render3dMainViewDrawItems(),
     )
   }
-  if world.get_resource(Render3dOpaqueMainViewPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueMainViewPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dOpaqueMainViewPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueMainViewPhases]),
       Render3dOpaqueMainViewPhases::Render3dOpaqueMainViewPhases(),
     )
   }
-  if world.get_resource(Render3dAlphaMaskMainViewPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskMainViewPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dAlphaMaskMainViewPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskMainViewPhases]),
       Render3dAlphaMaskMainViewPhases::Render3dAlphaMaskMainViewPhases(),
     )
   }
-  if world.get_resource(Render3dTransmissiveMainViewPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransmissiveMainViewPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dTransmissiveMainViewPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransmissiveMainViewPhases]),
       Render3dTransmissiveMainViewPhases::Render3dTransmissiveMainViewPhases(),
     )
   }
-  if world.get_resource(Render3dTransparentMainViewPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransparentMainViewPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dTransparentMainViewPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransparentMainViewPhases]),
       Render3dTransparentMainViewPhases::Render3dTransparentMainViewPhases(),
     )
   }
@@ -538,7 +569,10 @@ fn render3d_main_view_draw_items_mut_or_abort(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dMainViewDrawItems] {
   ensure_render3d_main_view_phase_resources(world)
-  match world.get_resource_mut(Render3dMainViewDrawItems::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
+    ) {
     Some(draw_items) => draw_items
     None => abort("Missing Render3dMainViewDrawItems resource in render world")
   }
@@ -587,21 +621,33 @@ fn render3d_prepare_main_view_phase(
   draw_items_resource.modify(fn(value) {
     value.set_draw_items(retained_view_entity, draw_items)
   })
-  guard world.get_resource_mut(Render3dOpaqueMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueMainViewPhases]),
+    )
     is Some(opaque_phases) else {
     abort("Missing Render3dOpaqueMainViewPhases resource in render world")
   }
   opaque_phases.modify(fn(value) {
     value.store.set_indices(retained_view_entity, opaque_draw_item_indices)
   })
-  guard world.get_resource_mut(Render3dAlphaMaskMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskMainViewPhases]),
+    )
     is Some(alpha_mask_phases) else {
     abort("Missing Render3dAlphaMaskMainViewPhases resource in render world")
   }
   alpha_mask_phases.modify(fn(value) {
     value.store.set_indices(retained_view_entity, alpha_mask_draw_item_indices)
   })
-  guard world.get_resource_mut(Render3dTransmissiveMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransmissiveMainViewPhases]),
+    )
     is Some(transmissive_phases) else {
     abort("Missing Render3dTransmissiveMainViewPhases resource in render world")
   }
@@ -610,7 +656,11 @@ fn render3d_prepare_main_view_phase(
       retained_view_entity, transmissive_draw_item_indices,
     )
   })
-  guard world.get_resource_mut(Render3dTransparentMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransparentMainViewPhases]),
+    )
     is Some(transparent_phases) else {
     abort("Missing Render3dTransparentMainViewPhases resource in render world")
   }
@@ -629,7 +679,9 @@ fn render3d_apply_main_view_phase_queue(
 ) -> Array[MeshPhaseItem3d] {
   ensure_render3d_main_view_phase_resources(world)
   let existing = match
-    world.get_resource(Render3dMainViewDrawItems::resource()) {
+    world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
+    ) {
     Some(draw_items) =>
       match draw_items.items(retained_view_entity) {
         Some(items) => items.copy()
@@ -656,26 +708,42 @@ fn render3d_retain_live_main_view_phases(
   ensure_render3d_main_view_phase_resources(world)
   let draw_items = render3d_main_view_draw_items_mut_or_abort(world)
   draw_items.modify(fn(value) { value.retain_live_views(live_views) })
-  guard world.get_resource_mut(Render3dOpaqueMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueMainViewPhases]),
+    )
     is Some(opaque_phases) else {
     abort("Missing Render3dOpaqueMainViewPhases resource in render world")
   }
   opaque_phases.modify(fn(value) { value.store.retain_live_views(live_views) })
-  guard world.get_resource_mut(Render3dAlphaMaskMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskMainViewPhases]),
+    )
     is Some(alpha_mask_phases) else {
     abort("Missing Render3dAlphaMaskMainViewPhases resource in render world")
   }
   alpha_mask_phases.modify(fn(value) {
     value.store.retain_live_views(live_views)
   })
-  guard world.get_resource_mut(Render3dTransmissiveMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransmissiveMainViewPhases]),
+    )
     is Some(transmissive_phases) else {
     abort("Missing Render3dTransmissiveMainViewPhases resource in render world")
   }
   transmissive_phases.modify(fn(value) {
     value.store.retain_live_views(live_views)
   })
-  guard world.get_resource_mut(Render3dTransparentMainViewPhases::resource())
+  guard world.get_resource_mut(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransparentMainViewPhases]),
+    )
     is Some(transparent_phases) else {
     abort("Missing Render3dTransparentMainViewPhases resource in render world")
   }
@@ -689,7 +757,9 @@ fn render3d_main_view_phase_items_or_abort(
   world : @ecs.World,
   retained_view_entity : @core.Entity,
 ) -> Array[MeshPhaseItem3d] {
-  guard world.get_resource(Render3dMainViewDrawItems::resource())
+  guard world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
+    )
     is Some(draw_items) else {
     abort("Missing Render3dMainViewDrawItems resource during pbr main pass")
   }
@@ -704,23 +774,39 @@ fn render3d_main_view_phase_draw_item_indices_or_abort(
   world : @ecs.World,
   retained_view_entity : @core.Entity,
 ) -> Array[Int] {
-  guard world.get_resource(Render3dOpaqueMainViewPhases::resource())
+  guard world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueMainViewPhases]),
+    )
     is Some(opaque_phases) else {
     abort("Missing Render3dOpaqueMainViewPhases resource during pbr main pass")
   }
-  guard world.get_resource(Render3dAlphaMaskMainViewPhases::resource())
+  guard world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskMainViewPhases]),
+    )
     is Some(alpha_mask_phases) else {
     abort(
       "Missing Render3dAlphaMaskMainViewPhases resource during pbr main pass",
     )
   }
-  guard world.get_resource(Render3dTransmissiveMainViewPhases::resource())
+  guard world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransmissiveMainViewPhases]),
+    )
     is Some(transmissive_phases) else {
     abort(
       "Missing Render3dTransmissiveMainViewPhases resource during pbr main pass",
     )
   }
-  guard world.get_resource(Render3dTransparentMainViewPhases::resource())
+  guard world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dTransparentMainViewPhases]),
+    )
     is Some(transparent_phases) else {
     abort(
       "Missing Render3dTransparentMainViewPhases resource during pbr main pass",
@@ -763,7 +849,9 @@ fn render3d_main_view_phase_item_count_or_abort(
   world : @ecs.World,
   retained_view_entity : @core.Entity,
 ) -> Int {
-  guard world.get_resource(Render3dMainViewDrawItems::resource())
+  guard world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
+    )
     is Some(draw_items) else {
     abort(
       "Missing Render3dMainViewDrawItems resource during pbr draw storage reservation",
diff --git a/mgstudio-engine/pbr/render_prepass_phases.mbt b/mgstudio-engine/pbr/render_prepass_phases.mbt
index fe4a57c3e..c15b46aec 100644
--- a/mgstudio-engine/pbr/render_prepass_phases.mbt
+++ b/mgstudio-engine/pbr/render_prepass_phases.mbt
@@ -174,16 +174,30 @@ fn render3d_retained_prepass_phase_items(
   let prepass_items : Array[MeshPhaseItem3d] = []
   let deferred_items : Array[MeshPhaseItem3d] = []
   let opaque_prepass = world
-    .get_resource(Render3dOpaquePrepassPhases::resource())
+    .get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+    )
     .unwrap()
   let alpha_mask_prepass = world
-    .get_resource(Render3dAlphaMaskPrepassPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+    )
     .unwrap()
   let opaque_deferred = world
-    .get_resource(Render3dOpaqueDeferredPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+    )
     .unwrap()
   let alpha_mask_deferred = world
-    .get_resource(Render3dAlphaMaskDeferredPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+    )
     .unwrap()
   render3d_append_retained_prepass_phase_items(
     prepass_items,
@@ -302,27 +316,51 @@ impl @app.Resource for Render3dAlphaMaskDeferredPhases with fn resource() {
 
 ///|
 fn ensure_render3d_prepass_phase_resources(world : @ecs.World) -> Unit {
-  if world.get_resource(Render3dOpaquePrepassPhases::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dOpaquePrepassPhases::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
       Render3dOpaquePrepassPhases::Render3dOpaquePrepassPhases(),
     )
   }
-  if world.get_resource(Render3dAlphaMaskPrepassPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dAlphaMaskPrepassPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
       Render3dAlphaMaskPrepassPhases::Render3dAlphaMaskPrepassPhases(),
     )
   }
-  if world.get_resource(Render3dOpaqueDeferredPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dOpaqueDeferredPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
       Render3dOpaqueDeferredPhases::Render3dOpaqueDeferredPhases(),
     )
   }
-  if world.get_resource(Render3dAlphaMaskDeferredPhases::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+    )
+    is None {
     world.insert_resource(
-      Render3dAlphaMaskDeferredPhases::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
       Render3dAlphaMaskDeferredPhases::Render3dAlphaMaskDeferredPhases(),
     )
   }
@@ -363,14 +401,24 @@ fn render3d_extract_camera_prepass_phases(
       camera.payload.normal_prepass_enabled ||
       camera.payload.motion_vector_prepass_enabled
     if has_prepass {
-      match world.get_resource(Render3dOpaquePrepassPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+        ) {
         Some(phases) =>
           phases.phases.prepare_for_new_frame(
             retained_view_entity, gpu_preprocessing_mode,
           )
         None => abort("Missing Opaque3dPrepass phases during extraction")
       }
-      match world.get_resource(Render3dAlphaMaskPrepassPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+        ) {
         Some(phases) =>
           phases.phases.prepare_for_new_frame(
             retained_view_entity, gpu_preprocessing_mode,
@@ -378,24 +426,44 @@ fn render3d_extract_camera_prepass_phases(
         None => abort("Missing AlphaMask3dPrepass phases during extraction")
       }
     } else {
-      match world.get_resource(Render3dOpaquePrepassPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+        ) {
         Some(phases) => phases.phases.remove(retained_view_entity)
         None => abort("Missing Opaque3dPrepass phases during extraction")
       }
-      match world.get_resource(Render3dAlphaMaskPrepassPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+        ) {
         Some(phases) => phases.phases.remove(retained_view_entity)
         None => abort("Missing AlphaMask3dPrepass phases during extraction")
       }
     }
     if camera.payload.deferred_prepass_enabled {
-      match world.get_resource(Render3dOpaqueDeferredPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+        ) {
         Some(phases) =>
           phases.phases.prepare_for_new_frame(
             retained_view_entity, gpu_preprocessing_mode,
           )
         None => abort("Missing Opaque3dDeferred phases during extraction")
       }
-      match world.get_resource(Render3dAlphaMaskDeferredPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+        ) {
         Some(phases) =>
           phases.phases.prepare_for_new_frame(
             retained_view_entity, gpu_preprocessing_mode,
@@ -403,30 +471,58 @@ fn render3d_extract_camera_prepass_phases(
         None => abort("Missing AlphaMask3dDeferred phases during extraction")
       }
     } else {
-      match world.get_resource(Render3dOpaqueDeferredPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+        ) {
         Some(phases) => phases.phases.remove(retained_view_entity)
         None => abort("Missing Opaque3dDeferred phases during extraction")
       }
-      match world.get_resource(Render3dAlphaMaskDeferredPhases::resource()) {
+      match
+        world.get_resource(
+          (
+            @app.Resource::resource() :
+            @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+        ) {
         Some(phases) => phases.phases.remove(retained_view_entity)
         None => abort("Missing AlphaMask3dDeferred phases during extraction")
       }
     }
     live_views.add(retained_view_entity)
   }
-  match world.get_resource(Render3dOpaquePrepassPhases::resource()) {
+  match
+    world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+    ) {
     Some(phases) => phases.phases.retain_live_views(live_views)
     None => abort("Missing Opaque3dPrepass phases during extraction")
   }
-  match world.get_resource(Render3dAlphaMaskPrepassPhases::resource()) {
+  match
+    world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+    ) {
     Some(phases) => phases.phases.retain_live_views(live_views)
     None => abort("Missing AlphaMask3dPrepass phases during extraction")
   }
-  match world.get_resource(Render3dOpaqueDeferredPhases::resource()) {
+  match
+    world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+    ) {
     Some(phases) => phases.phases.retain_live_views(live_views)
     None => abort("Missing Opaque3dDeferred phases during extraction")
   }
-  match world.get_resource(Render3dAlphaMaskDeferredPhases::resource()) {
+  match
+    world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+    ) {
     Some(phases) => phases.phases.retain_live_views(live_views)
     None => abort("Missing AlphaMask3dDeferred phases during extraction")
   }
diff --git a/mgstudio-engine/pbr/render_prepass_queue.mbt b/mgstudio-engine/pbr/render_prepass_queue.mbt
index 9c60b87b4..d88fcf409 100644
--- a/mgstudio-engine/pbr/render_prepass_queue.mbt
+++ b/mgstudio-engine/pbr/render_prepass_queue.mbt
@@ -76,25 +76,47 @@ fn render3d_queue_prepass_material_meshes(
     .get_resource(@render_batching.GpuPreprocessingSupport::resource())
     .unwrap()
   let specialized_cache = world
-    .get_resource(SpecializedPrepassMaterialPipelineCache::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[SpecializedPrepassMaterialPipelineCache]),
+    )
     .unwrap()
   let pending_queues = world
-    .get_resource(PendingPrepassMeshMaterialQueues::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[PendingPrepassMeshMaterialQueues]),
+    )
     .unwrap()
   let dirty_specializations = world
     .get_resource(@render_visibility.DirtySpecializations::resource())
     .unwrap()
   let opaque_prepass_phases = world
-    .get_resource(Render3dOpaquePrepassPhases::resource())
+    .get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+    )
     .unwrap()
   let alpha_mask_prepass_phases = world
-    .get_resource(Render3dAlphaMaskPrepassPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+    )
     .unwrap()
   let opaque_deferred_phases = world
-    .get_resource(Render3dOpaqueDeferredPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+    )
     .unwrap()
   let alpha_mask_deferred_phases = world
-    .get_resource(Render3dAlphaMaskDeferredPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+    )
     .unwrap()
   let extracted_indices = render3d_prepass_extracted_index_by_entity(meshes)
   for camera in cameras {
diff --git a/mgstudio-engine/pbr/render_prepass_specialization.mbt b/mgstudio-engine/pbr/render_prepass_specialization.mbt
index 318e119aa..f2a8f2630 100644
--- a/mgstudio-engine/pbr/render_prepass_specialization.mbt
+++ b/mgstudio-engine/pbr/render_prepass_specialization.mbt
@@ -202,22 +202,38 @@ impl @app.Resource for PendingPrepassMeshMaterialQueues with fn resource() {
 
 ///|
 fn ensure_render3d_prepass_specialization_resources(world : @ecs.World) -> Unit {
-  if world.get_resource(SpecializedPrepassMaterialPipelineCache::resource())
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[SpecializedPrepassMaterialPipelineCache]),
+    )
     is None {
     world.insert_resource(
-      SpecializedPrepassMaterialPipelineCache::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[SpecializedPrepassMaterialPipelineCache]),
       SpecializedPrepassMaterialPipelineCache::new(),
     )
   }
-  if world.get_resource(ViewKeyPrepassCache::resource()) is None {
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ViewKeyPrepassCache]),
+    )
+    is None {
     world.insert_resource(
-      ViewKeyPrepassCache::resource(),
+      (@app.Resource::resource() : @ecs.ResourceKey[ViewKeyPrepassCache]),
       ViewKeyPrepassCache::new(),
     )
   }
-  if world.get_resource(PendingPrepassMeshMaterialQueues::resource()) is None {
+  if world.get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[PendingPrepassMeshMaterialQueues]),
+    )
+    is None {
     world.insert_resource(
-      PendingPrepassMeshMaterialQueues::resource(),
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[PendingPrepassMeshMaterialQueues]),
       PendingPrepassMeshMaterialQueues::new(),
     )
   }
@@ -255,7 +271,9 @@ fn render3d_check_prepass_views_need_specialization(
       )
   }
   let view_key_cache = world
-    .get_resource(ViewKeyPrepassCache::resource())
+    .get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ViewKeyPrepassCache]),
+    )
     .unwrap()
   for camera in cameras {
     if !camera.payload.camera.is_active {
@@ -302,16 +320,30 @@ fn render3d_prepass_phases_contain_view(
   retained_view_entity : @render_view.RetainedViewEntity,
 ) -> Bool {
   let opaque_prepass = world
-    .get_resource(Render3dOpaquePrepassPhases::resource())
+    .get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaquePrepassPhases]),
+    )
     .unwrap()
   let alpha_mask_prepass = world
-    .get_resource(Render3dAlphaMaskPrepassPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskPrepassPhases]),
+    )
     .unwrap()
   let opaque_deferred = world
-    .get_resource(Render3dOpaqueDeferredPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dOpaqueDeferredPhases]),
+    )
     .unwrap()
   let alpha_mask_deferred = world
-    .get_resource(Render3dAlphaMaskDeferredPhases::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[Render3dAlphaMaskDeferredPhases]),
+    )
     .unwrap()
   opaque_prepass.phases.contains(retained_view_entity) ||
   alpha_mask_prepass.phases.contains(retained_view_entity) ||
@@ -460,7 +492,11 @@ fn render3d_specialize_prepass_work_item(
     }
   }
   let cache = world
-    .get_resource(SpecializedPrepassMaterialPipelineCache::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[SpecializedPrepassMaterialPipelineCache]),
+    )
     .unwrap()
   cache
   .view_or_insert(item.retained_view_entity)
@@ -486,13 +522,23 @@ fn render3d_specialize_prepass_material_meshes(
     .get_resource(@render_visibility.DirtySpecializations::resource())
     .unwrap()
   let view_key_cache = world
-    .get_resource(ViewKeyPrepassCache::resource())
+    .get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[ViewKeyPrepassCache]),
+    )
     .unwrap()
   let specialized_cache = world
-    .get_resource(SpecializedPrepassMaterialPipelineCache::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[SpecializedPrepassMaterialPipelineCache]),
+    )
     .unwrap()
   let pending_queues = world
-    .get_resource(PendingPrepassMeshMaterialQueues::resource())
+    .get_resource(
+      (
+        @app.Resource::resource() :
+        @ecs.ResourceKey[PendingPrepassMeshMaterialQueues]),
+    )
     .unwrap()
   for camera in cameras {
     let retained_view_entity = @render_view.RetainedViewEntity::new(
diff --git a/mgstudio-engine/pbr/render_scene_resources.mbt b/mgstudio-engine/pbr/render_scene_resources.mbt
index c1b2bd72b..9a5df531c 100644
--- a/mgstudio-engine/pbr/render_scene_resources.mbt
+++ b/mgstudio-engine/pbr/render_scene_resources.mbt
@@ -86,15 +86,24 @@ impl @app.Resource for Render3dSceneTargetsState with fn resource() {
 fn render3d_scene_targets_state_mut_or_init(
   world : @ecs.World,
 ) -> @ecs.ResourceMut[Render3dSceneTargetsState] {
-  if world.get_resource(Render3dSceneTargetsState::resource()) is None {
-    world.insert_resource(Render3dSceneTargetsState::resource(), {
-      motion_blur_targets: [],
-      prepass_targets: [],
-      transmission_source_targets: [],
-      postprocess_ping_targets: [],
-    })
+  if world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dSceneTargetsState]),
+    )
+    is None {
+    world.insert_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dSceneTargetsState]),
+      {
+        motion_blur_targets: [],
+        prepass_targets: [],
+        transmission_source_targets: [],
+        postprocess_ping_targets: [],
+      },
+    )
   }
-  match world.get_resource_mut(Render3dSceneTargetsState::resource()) {
+  match
+    world.get_resource_mut(
+      (@app.Resource::resource() : @ecs.ResourceKey[Render3dSceneTargetsState]),
+    ) {
     Some(state) => state
     None => abort("Missing Render3dSceneTargetsState resource")
   }
diff --git a/mgstudio-engine/pbr/render_shadow_phase.mbt b/mgstudio-engine/pbr/render_shadow_phase.mbt
index b12b4da1d..4adcb6121 100644
--- a/mgstudio-engine/pbr/render_shadow_phase.mbt
+++ b/mgstudio-engine/pbr/render_shadow_phase.mbt
@@ -266,21 +266,6 @@ fn render3d_queue_shadow_phase_views(
   queued_count
 }
 
-///|
-fn render3d_shadow_phase_items_for_view(
-  world : @ecs.World,
-  retained_view_entity : @render_view.RetainedViewEntity,
-) -> Array[Render3dShadowPhaseItemData] {
-  match world.get_resource(Render3dShadowPhasesData::resource()) {
-    Some(phases) =>
-      match phases.get(retained_view_entity) {
-        Some(phase) => phase.render_items(false)
-        None => []
-      }
-    None => []
-  }
-}
-
 ///|
 fn render3d_extracted_shadow_mesh_matches_bin(
   mesh : ExtractedMesh3d,
@@ -292,55 +277,41 @@ fn render3d_extracted_shadow_mesh_matches_bin(
 ///|
 fn render3d_shadow_resolve_phase_items(
   meshes : Array[ExtractedMesh3d],
-  render_mesh_instances : RenderMeshInstances,
-  items : Array[Render3dShadowPhaseItemData],
+  phase : Render3dShadowViewPhaseData,
 ) -> Array[Render3dResolvedShadowPhaseItem] {
-  let mesh_indices_by_main_entity : Map[UInt64, Int] = Map([])
-  let mesh_indices_by_uniform_index : Map[Int, Int] = Map([])
+  // Bevy phase preparation rewrites `batch_range` from input-uniform indices
+  // to GPU output/indirect-buffer indices. Those ranges cannot identify the
+  // source entities here; the retained binned-phase cache remains the exact
+  // source of entity membership for the backend's per-entity draw bridge.
+  let resolved : Array[Render3dResolvedShadowPhaseItem] = []
   for index in 0..<meshes.length() {
     let main_entity = @render.MainEntity::new(meshes[index].entity.main_entity)
-    let main_bits = main_entity.id().to_bits()
-    mesh_indices_by_main_entity.set(main_bits, index)
-    match render_mesh_instances.render_mesh_queue_data(main_entity) {
-      Some(queue_data) =>
-        mesh_indices_by_uniform_index.set(
-          queue_data.current_uniform_index().to_int(),
-          index,
-        )
-      None => ()
-    }
-  }
-  let resolved : Array[Render3dResolvedShadowPhaseItem] = []
-  for item in items {
-    let extracted_indices : Array[Int] = []
-    let batch_range = item.batch_range()
-    for uniform_index in batch_range.start()..<batch_range.end() {
-      match mesh_indices_by_uniform_index.get(uniform_index) {
-        Some(extracted_index) =>
-          if render3d_extracted_shadow_mesh_matches_bin(
-              meshes[extracted_index],
-              item.bin_key(),
-            ) {
-            extracted_indices.push(extracted_index)
-          }
-        None => ()
-      }
+    guard phase.cached_bin_key(main_entity) is Some(cached_bin_key) else {
+      continue
     }
-    if extracted_indices.length() == 0 {
-      match mesh_indices_by_main_entity.get(item.main_entity().id().to_bits()) {
-        Some(extracted_index) =>
-          if render3d_extracted_shadow_mesh_matches_bin(
-              meshes[extracted_index],
-              item.bin_key(),
-            ) {
-            extracted_indices.push(extracted_index)
-          }
-        None => ()
-      }
+    guard render3d_extracted_shadow_mesh_matches_bin(
+        meshes[index],
+        cached_bin_key.bin_key(),
+      ) else {
+      continue
     }
-    if extracted_indices.length() > 0 {
-      resolved.push(Render3dResolvedShadowPhaseItem::{ item, extracted_indices })
+    guard phase.input_uniform_index(main_entity) is Some(input_uniform_index) else {
+      continue
     }
+    let item = Render3dShadowPhaseItemData::new(
+      cached_bin_key.batch_set_key(),
+      cached_bin_key.bin_key(),
+      meshes[index].entity.render_entity,
+      main_entity,
+      Render3dShadowBatchRange::new(
+        input_uniform_index.to_int(),
+        input_uniform_index.to_int() + 1,
+      ),
+      Render3dShadowPhaseItemExtraIndex::none(),
+    )
+    resolved.push(
+      Render3dResolvedShadowPhaseItem::{ item, extracted_indices: [index] },
+    )
   }
   resolved
 }
@@ -514,16 +485,17 @@ fn render3d_execute_shadow_phase_view(
   let retained_view_entity = phase_view.shadow_view.light_entity.shadow_phase_retained_view(
     @render_view.RetainedViewEntity::new(camera_entity),
   )
-  let phase_items = render3d_shadow_phase_items_for_view(
-    world, retained_view_entity,
-  )
-  let render_mesh_instances = match
-    world.get_resource(RenderMeshInstances::resource()) {
-    Some(value) => value
+  let shadow_phase = match
+    world.get_resource(Render3dShadowPhasesData::resource()) {
+    Some(phases) =>
+      match phases.get(retained_view_entity) {
+        Some(phase) => phase
+        None => return
+      }
     None => return
   }
   let resolved_phase_items = render3d_shadow_resolve_phase_items(
-    meshes, render_mesh_instances, phase_items,
+    meshes, shadow_phase,
   )
   @app.timeline_trace_emit_counter_int(
     "render_3d_shadow_phase_items",
diff --git a/mgstudio-engine/pbr/render_startup.mbt b/mgstudio-engine/pbr/render_startup.mbt
index 8e2dbb54f..5bad7f683 100644
--- a/mgstudio-engine/pbr/render_startup.mbt
+++ b/mgstudio-engine/pbr/render_startup.mbt
@@ -280,29 +280,35 @@ fn configure_pbr_render_world_resources(
   )
   pbr_init_render_resource_if_missing(
     world,
-    Render3dMainViewDrawItems::resource(),
+    (@app.Resource::resource() : @ecs.ResourceKey[Render3dMainViewDrawItems]),
     fn() { Render3dMainViewDrawItems::Render3dMainViewDrawItems() },
   )
   pbr_init_render_resource_if_missing(
     world,
-    Render3dOpaqueMainViewPhases::resource(),
+    (@app.Resource::resource() : @ecs.ResourceKey[Render3dOpaqueMainViewPhases]),
     fn() { Render3dOpaqueMainViewPhases::Render3dOpaqueMainViewPhases() },
   )
   pbr_init_render_resource_if_missing(
     world,
-    Render3dAlphaMaskMainViewPhases::resource(),
+    (
+      @app.Resource::resource() :
+      @ecs.ResourceKey[Render3dAlphaMaskMainViewPhases]),
     fn() { Render3dAlphaMaskMainViewPhases::Render3dAlphaMaskMainViewPhases() },
   )
   pbr_init_render_resource_if_missing(
     world,
-    Render3dTransmissiveMainViewPhases::resource(),
+    (
+      @app.Resource::resource() :
+      @ecs.ResourceKey[Render3dTransmissiveMainViewPhases]),
     fn() {
       Render3dTransmissiveMainViewPhases::Render3dTransmissiveMainViewPhases()
     },
   )
   pbr_init_render_resource_if_missing(
     world,
-    Render3dTransparentMainViewPhases::resource(),
+    (
+      @app.Resource::resource() :
+      @ecs.ResourceKey[Render3dTransparentMainViewPhases]),
     fn() {
       Render3dTransparentMainViewPhases::Render3dTransparentMainViewPhases()
     },
diff --git a/mgstudio-engine/pbr/wireframe.mbt b/mgstudio-engine/pbr/wireframe.mbt
index e351d6678..a3cb13078 100644
--- a/mgstudio-engine/pbr/wireframe.mbt
+++ b/mgstudio-engine/pbr/wireframe.mbt
@@ -453,7 +453,10 @@ fn wireframe_material_assets_mut_or_abort(
 fn global_wireframe_material_or_abort(
   world : @ecs.World,
 ) -> GlobalWireframeMaterial {
-  match world.get_resource(GlobalWireframeMaterial::resource()) {
+  match
+    world.get_resource(
+      (@app.Resource::resource() : @ecs.ResourceKey[GlobalWireframeMaterial]),
+    ) {
     Some(material) => material
     None =>
       abort(
@@ -477,9 +480,10 @@ fn setup_global_wireframe_material(world : @ecs.World) -> Unit {
       ),
     )
   })
-  world.insert_resource(GlobalWireframeMaterial::resource(), GlobalWireframeMaterial::{
-    handle,
-  })
+  world.insert_resource(
+    (@app.Resource::resource() : @ecs.ResourceKey[GlobalWireframeMaterial]),
+    GlobalWireframeMaterial::{ handle, },
+  )
 }
 
 ///|
diff --git a/mgstudio-engine/picking/backend.mbt b/mgstudio-engine/picking/backend.mbt
index 07ab397a5..e4ac03524 100644
--- a/mgstudio-engine/picking/backend.mbt
+++ b/mgstudio-engine/picking/backend.mbt
@@ -77,63 +77,58 @@ fn picking_write_pointer_hits(
 }
 
 ///|
-fn sprite_region_size(sprite : @sprite.Sprite) -> @math.Vec2 {
-  let texture_id = sprite.image.id()
-  let mut image_width = @asset.host_asset_texture_width(texture_id)
-  let mut image_height = @asset.host_asset_texture_height(texture_id)
-  if image_width <= 0 || image_height <= 0 {
-    // Avoid division by zero for not-yet-loaded textures.
-    image_width = 1
-    image_height = 1
-  }
-  let image_rect = @math.Rect::new(
-    @math.Vec2::new(0.0F, 0.0F),
-    @math.Vec2::new(
-      Float::from_double(image_width.to_double()),
-      Float::from_double(image_height.to_double()),
-    ),
-  )
-  let atlas_rect = match sprite.texture_atlas {
-    Some(atlas) =>
-      match @asset.asset_get_texture_atlas_layout(atlas.layout) {
-        Some(layout_value) =>
-          if atlas.index >= 0 && atlas.index < layout_value.textures.length() {
-            Some(layout_value.textures[atlas.index].as_rect())
-          } else {
-            None
-          }
-        None => None
+fn picking_mesh_camera_transform(
+  world : @ecs.World,
+  entity : @core.Entity,
+) -> @transform.Transform {
+  match (try! world.get_by_key(entity, @transform.ecs_key_global_transform)) {
+    Some(gt) => gt.to_transform_approx()
+    None =>
+      match (try! world.get_by_key(entity, @transform.ecs_key_transform)) {
+        Some(value) => value
+        None => @transform.Transform::identity()
       }
-    None => None
   }
-  let texture_rect = match (atlas_rect, sprite.rect) {
-    (None, None) => image_rect
-    (None, Some(r)) => r
-    (Some(ar), None) => ar
-    (Some(ar), Some(r)) => {
-      let min = @math.Vec2::new(r.min.x + ar.min.x, r.min.y + ar.min.y)
-      let max = @math.Vec2::new(r.max.x + ar.min.x, r.max.y + ar.min.y)
-      @math.Rect::new(min, max)
-    }
-  }
-  texture_rect.size()
 }
 
 ///|
-fn picking_camera_transform(
+fn picking_camera_affine(
   world : @ecs.World,
   entity : @core.Entity,
-) -> @transform.Transform {
+) -> @math.Affine3 {
   match (try! world.get_by_key(entity, @transform.ecs_key_global_transform)) {
-    Some(gt) => gt.to_transform_approx()
+    Some(global_transform) => global_transform.affine()
     None =>
       match (try! world.get_by_key(entity, @transform.ecs_key_transform)) {
-        Some(value) => value
-        None => @transform.Transform::identity()
+        Some(transform) =>
+          @transform.GlobalTransform::from_transform(transform).affine()
+        None => @math.Affine3::identity()
       }
   }
 }
 
+///|
+fn picking_affine_inverse(affine : @math.Affine3) -> @math.Affine3? {
+  let cofactor_x = affine.matrix3.y_axis.cross(affine.matrix3.z_axis)
+  let cofactor_y = affine.matrix3.z_axis.cross(affine.matrix3.x_axis)
+  let cofactor_z = affine.matrix3.x_axis.cross(affine.matrix3.y_axis)
+  let determinant = affine.matrix3.z_axis.dot(cofactor_z)
+  if determinant == 0.0F {
+    return None
+  }
+  let inverse_matrix3 = @math.Mat3::from_cols(
+      cofactor_x, cofactor_y, cofactor_z,
+    )
+    .transpose()
+    .mul_scalar(1.0F / determinant)
+  Some(
+    @math.Affine3::from_mat3_translation(
+      inverse_matrix3,
+      inverse_matrix3.mul_vec3(affine.translation).neg(),
+    ),
+  )
+}
+
 ///|
 fn picking_insert_camera_sorted(
   cameras : Array[(@core.Entity, @camera_camera.Camera, @camera.Projection)],
@@ -156,16 +151,18 @@ fn picking_insert_sprite_camera_sorted(
       @core.Entity,
       @camera_camera.Camera,
       @camera.Projection,
-      @transform.Transform,
+      @math.Affine3,
       Bool,
+      @camera_render_layers.RenderLayers,
     ),
   ],
   camera : (
     @core.Entity,
     @camera_camera.Camera,
     @camera.Projection,
-    @transform.Transform,
+    @math.Affine3,
     Bool,
+    @camera_render_layers.RenderLayers,
   ),
 ) -> Unit {
   let mut insert_at = cameras.length()
@@ -264,8 +261,9 @@ fn picking_sprite_cameras(
     @core.Entity,
     @camera_camera.Camera,
     @camera.Projection,
-    @transform.Transform,
+    @math.Affine3,
     Bool,
+    @camera_render_layers.RenderLayers,
   ),
 ] {
   let cameras : Array[
@@ -273,8 +271,9 @@ fn picking_sprite_cameras(
       @core.Entity,
       @camera_camera.Camera,
       @camera.Projection,
-      @transform.Transform,
+      @math.Affine3,
       Bool,
+      @camera_render_layers.RenderLayers,
     ),
   ] = []
   world.for_each_component(@camera_components2d.ecs_key_camera2d, fn(
@@ -294,15 +293,27 @@ fn picking_sprite_cameras(
     if settings.require_markers && !has_marker {
       return
     }
-    let projection = match
-      (try! world.get_by_key(entity, @camera.ecs_key_projection)) {
-      Some(value) => value
-      None => @camera.Projection::default()
+    guard (try! world.get_by_key(
+        entity, @camera_projection2d.ecs_key_projection,
+      ))
+      is Some(@camera_projection2d.Projection::Orthographic(projection_2d)) else {
+      return
     }
-    let transform = picking_camera_transform(world, entity)
+    // Mgstudio stores the implemented 2D authoring subset separately from the
+    // full runtime projection. Reconstruct Bevy's Camera2d-required
+    // `OrthographicProjection::default_2d()` before the viewport update below.
+    let projection = @camera.Projection::Orthographic(
+      @camera.OrthographicProjection3d::default_2d().with_scale(
+        projection_2d.scale,
+      ),
+    )
+    let affine = picking_camera_affine(world, entity)
+    let render_layers = (try! world.get_by_key(
+      entity, @camera_render_layers.ecs_key_render_layers,
+    )).unwrap_or(@camera_render_layers.RenderLayers::RenderLayers())
     picking_insert_sprite_camera_sorted(
       cameras,
-      (entity, camera, projection, transform, has_marker),
+      (entity, camera, projection, affine, has_marker, render_layers),
     )
   })
   cameras
@@ -312,79 +323,206 @@ fn picking_sprite_cameras(
 fn picking_sprite_ray_local_hit(
   origin : @math.Vec3,
   direction : @math.Vec3,
-  transform : @transform.Transform,
+  affine : @math.Affine3,
   max_distance : Float,
 ) -> (@math.Vec2, Float)? {
-  guard @pbr_render.render3d_inverse_transform_point(transform, origin)
-    is Some(local_origin) else {
+  guard picking_affine_inverse(affine) is Some(world_to_sprite) else {
+    return None
+  }
+  let cursor_start_sprite = world_to_sprite.transform_point3(origin)
+  let cursor_end_sprite = world_to_sprite.transform_point3(
+    origin.add(direction.mul_scalar(max_distance)),
+  )
+  if cursor_start_sprite.z == cursor_end_sprite.z {
     return None
   }
-  guard @pbr_render.render3d_inverse_transform_direction(transform, direction)
-    is Some(local_direction) else {
+  let lerp_factor = -cursor_start_sprite.z /
+    (cursor_end_sprite.z - cursor_start_sprite.z)
+  if !(lerp_factor >= 0.0F && lerp_factor <= 1.0F) {
     return None
   }
-  if @pbr_render.absf(local_direction.z) <= 1.0e-9F {
+  let local_hit = cursor_start_sprite.add(
+    cursor_end_sprite.sub(cursor_start_sprite).mul_scalar(lerp_factor),
+  )
+  Some((@math.Vec2::new(local_hit.x, local_hit.y), lerp_factor * max_distance))
+}
+
+///|
+fn picking_sprite_camera_viewport_to_world_ray(
+  screen : @math.Vec2,
+  camera : @camera_camera.Camera,
+  projection : @camera.Projection,
+  camera_affine : @math.Affine3,
+  target_size : @math.IVec2,
+  scale_factor : Float,
+) -> (@math.Vec3, @math.Vec3)? {
+  guard @pbr_render.render3d_camera_viewport_rect_logical(
+      camera, target_size, scale_factor,
+    )
+    is Some((viewport_x, viewport_y, viewport_width, viewport_height)) else {
+    return None
+  }
+  if screen.x < viewport_x ||
+    screen.y < viewport_y ||
+    screen.x > viewport_x + viewport_width ||
+    screen.y > viewport_y + viewport_height {
+    return None
+  }
+  let ndc_x = (screen.x - viewport_x) / viewport_width * 2.0F - 1.0F
+  let ndc_y = 1.0F - (screen.y - viewport_y) / viewport_height * 2.0F
+  let clip_from_view = projection
+    .update(viewport_width, viewport_height)
+    .get_clip_from_view()
+  guard @pbr_render.render3d_projection_matrix_inverse(clip_from_view)
+    is Some(view_from_clip) else {
+    return None
+  }
+  let near_view_h = view_from_clip.mul_vec4(
+    @math.Vec4::new(ndc_x, ndc_y, 1.0F, 1.0F),
+  )
+  let far_view_h = view_from_clip.mul_vec4(
+    @math.Vec4::new(ndc_x, ndc_y, 1.1920929e-7F, 1.0F),
+  )
+  if near_view_h.w == 0.0F || far_view_h.w == 0.0F {
     return None
   }
-  let distance = -local_origin.z / local_direction.z
-  if distance < 0.0F || distance > max_distance {
+  let near_view = @math.Vec3::new(
+    near_view_h.x / near_view_h.w,
+    near_view_h.y / near_view_h.w,
+    near_view_h.z / near_view_h.w,
+  )
+  let far_view = @math.Vec3::new(
+    far_view_h.x / far_view_h.w,
+    far_view_h.y / far_view_h.w,
+    far_view_h.z / far_view_h.w,
+  )
+  let direction = camera_affine.matrix3
+    .mul_vec3(far_view.sub(near_view))
+    .normalize_or_zero()
+  if direction.length_squared() <= 1.0e-12F ||
+    direction.x.is_nan() ||
+    direction.y.is_nan() ||
+    direction.z.is_nan() {
     return None
   }
-  let local_hit = local_origin.add(local_direction.mul_scalar(distance))
-  Some((@math.Vec2::new(local_hit.x, local_hit.y), distance))
+  Some((camera_affine.transform_point3(near_view), direction))
 }
 
 ///|
-fn picking_sprite_collect_sorted(
-  world : @ecs.World,
-) -> Array[
-  (@core.Entity, @sprite.Sprite, @transform.Transform, @sprite.Anchor, Pickable),
-] {
-  let sorted_sprites : Array[
-    (
-      @core.Entity,
-      @sprite.Sprite,
-      @transform.Transform,
-      @sprite.Anchor,
-      Pickable,
-    ),
-  ] = []
-  world.for_each_component(@sprite.ecs_key_sprite, fn(entity, sprite) {
-    if (try! world.get_by_key(entity, @visibility.ecs_key_view_visibility))
-      is Some(vv) &&
-      !vv.is_visible() {
-      return
+type SpritePickingEntry = (
+  @core.Entity,
+  @sprite.Sprite,
+  @math.Affine3,
+  @sprite.Anchor,
+  Pickable,
+  @camera_render_layers.RenderLayers,
+)
+
+///|
+fn picking_sprite_depth_radix_key(entry : SpritePickingEntry) -> UInt {
+  let bits = (-entry.2.translation.z).reinterpret_as_uint()
+  let flip_negative_mask = if (bits & 0x8000_0000U) != 0U {
+    0xffff_ffffU
+  } else {
+    0U
+  }
+  bits ^ (flip_negative_mask | 0x8000_0000U)
+}
+
+///|
+// Bevy source: `radsort::sort_by_key(..., |(_, _, transform, ..)|
+// -transform.translation().z)` in `bevy_sprite::picking_backend::sprite_picking`.
+fn picking_sprite_stable_radix_sort(
+  entries : Array[SpritePickingEntry],
+) -> Array[SpritePickingEntry] {
+  if entries.length() < 2 {
+    return entries
+  }
+  let mut current = entries
+  for digit in 0..<4 {
+    let offsets = FixedArray::make(256, 0)
+    let shift = digit * 8
+    for entry in current {
+      let bucket = ((picking_sprite_depth_radix_key(entry) >> shift) & 0xffU).reinterpret_as_int()
+      offsets[bucket] = offsets[bucket] + 1
     }
-    let transform = match
-      (try! world.get_by_key(entity, @transform.ecs_key_global_transform)) {
-      Some(gt) => gt.to_transform_approx()
-      None =>
-        match (try! world.get_by_key(entity, @transform.ecs_key_transform)) {
-          Some(t) => t
-          None => @transform.Transform::identity()
-        }
+    let mut non_empty_buckets = 0
+    for bucket in 0..<256 {
+      if offsets[bucket] != 0 {
+        non_empty_buckets = non_empty_buckets + 1
+      }
     }
-    let anchor = match (try! world.get_by_key(entity, @sprite.ecs_key_anchor)) {
-      Some(a) => a
-      None => @sprite.Anchor::Anchor()
+    if non_empty_buckets <= 1 {
+      continue
     }
-    let pickable = match (try! world.get_by_key(entity, ecs_key_pickable)) {
-      Some(value) => value
-      None => Pickable::Pickable()
+    let mut offset = 0
+    for bucket in 0..<256 {
+      let count = offsets[bucket]
+      offsets[bucket] = offset
+      offset = offset + count
     }
-    let mut insert_at = sorted_sprites.length()
-    for i in 0..<sorted_sprites.length() {
-      if transform.translation.z > sorted_sprites[i].2.translation.z {
-        insert_at = i
-        break
+    let next = Array::make(current.length(), current[0])
+    for entry in current {
+      let bucket = ((picking_sprite_depth_radix_key(entry) >> shift) & 0xffU).reinterpret_as_int()
+      let index = offsets[bucket]
+      next[index] = entry
+      offsets[bucket] = index + 1
+    }
+    current = next
+  }
+  current
+}
+
+///|
+fn picking_sprite_collect_sorted(
+  world : @ecs.World,
+) -> Array[SpritePickingEntry] {
+  let sprites : Array[SpritePickingEntry] = []
+  let query : @ecs.Query[
+    (
+      (
+        @ecs.Read[@sprite.Sprite],
+        @ecs.Read[@transform.GlobalTransform],
+        @ecs.Read[@sprite.Anchor],
+        @ecs.Read[Pickable],
+      ),
+      (
+        @ecs.Read[@visibility.ViewVisibility],
+        @ecs.Optional[@camera_render_layers.RenderLayers],
+      ),
+    ),
+    @ecs.All,
+  ] = @ecs.query(world)
+  try! query.for_each_table(fn(batch) {
+    let sprite = batch.read(@sprite.ecs_key_sprite).unwrap()
+    let global_transform = batch
+      .read(@transform.ecs_key_global_transform)
+      .unwrap()
+    let anchor = batch.read(@sprite.ecs_key_anchor).unwrap()
+    let pickable = batch.read(ecs_key_pickable).unwrap()
+    let visibility = batch.read(@visibility.ecs_key_view_visibility).unwrap()
+    let layers = batch.read(@camera_render_layers.ecs_key_render_layers)
+    for row_index in 0..<batch.length() {
+      if global_transform.value(row_index).affine().is_nan() ||
+        !visibility.value(row_index).is_visible() {
+        continue
       }
+      sprites.push(
+        (
+          batch.entity(row_index),
+          sprite.value(row_index),
+          global_transform.value(row_index).affine(),
+          anchor.value(row_index),
+          pickable.value(row_index),
+          match layers {
+            Some(column) => column.value(row_index)
+            None => @camera_render_layers.RenderLayers::RenderLayers()
+          },
+        ),
+      )
     }
-    sorted_sprites.insert(
-      insert_at,
-      (entity, sprite, transform, anchor, pickable),
-    )
   })
-  sorted_sprites
+  picking_sprite_stable_radix_sort(sprites)
 }
 
 ///|
@@ -393,55 +531,45 @@ fn picking_sprite_hit_from_local_pos(
   entry : (
     @core.Entity,
     @sprite.Sprite,
-    @transform.Transform,
+    @math.Affine3,
     @sprite.Anchor,
     Pickable,
+    @camera_render_layers.RenderLayers,
   ),
   local_pos : @math.Vec2,
   settings : SpritePickingSettings,
-  depth : Float,
+  camera_entity : @core.Entity,
+  camera_affine : @math.Affine3,
+  camera_near : Float,
 ) -> (@core.Entity, HitData)? {
   let entity = entry.0
   let sprite = entry.1
-  let transform = entry.2
+  let affine = entry.2
   let anchor = entry.3
-  let region = sprite_region_size(sprite)
-  let denom_x = if region.x == 0.0F { 1.0F } else { region.x }
-  let denom_y = if region.y == 0.0F { 1.0F } else { region.y }
-  let mut scale = @math.Vec2::new(transform.scale.x, transform.scale.y)
-  match sprite.custom_size {
-    Some(custom) =>
-      scale = @math.Vec2::new(
-        scale.x * (custom.x / denom_x),
-        scale.y * (custom.y / denom_y),
-      )
-    None => ()
-  }
-  let half = @math.Vec2::new(
-    scale.x * region.x / 2.0F,
-    scale.y * region.y / 2.0F,
-  )
-  if half.x <= 0.0F || half.y <= 0.0F {
-    return None
-  }
-  let abs_x = if local_pos.x < 0.0F { -local_pos.x } else { local_pos.x }
-  let abs_y = if local_pos.y < 0.0F { -local_pos.y } else { local_pos.y }
-  if abs_x <= half.x &&
-    abs_y <= half.y &&
-    picking_sprite_pixel_is_valid(
+  if picking_sprite_pixel_is_valid(
       world,
       sprite,
       anchor,
       local_pos,
       settings.picking_mode,
     ) {
-    let position = transform.transform_point(
+    let position = affine.transform_point3(
       @math.Vec3::new(local_pos.x, local_pos.y, 0.0F),
     )
+    guard picking_affine_inverse(camera_affine) is Some(world_to_camera) else {
+      return None
+    }
+    let camera_position = world_to_camera.transform_point3(position)
+    let depth = -camera_near - camera_position.z
     Some(
       (
         entity,
-        HitData::new(entity, depth, Some(position), Some(transform.back())),
+        HitData::new(
+          camera_entity,
+          depth,
+          Some(position),
+          Some(affine.matrix3.z_axis.normalize()),
+        ),
       ),
     )
   } else {
@@ -484,7 +612,9 @@ pub fn picking_mesh3d_hit_test_system(world : @ecs.World) -> Unit {
         let camera_entity = entry.0
         let camera = entry.1
         let projection = entry.2
-        let camera_transform = picking_camera_transform(world, camera_entity)
+        let camera_transform = picking_mesh_camera_transform(
+          world, camera_entity,
+        )
         let target_size = picking_camera_target_size(
           camera, window_width, window_height,
         )
@@ -548,34 +678,46 @@ pub fn picking_sprite2d_hit_test_system(world : @ecs.World) -> Unit {
       for camera_entry in cameras {
         let camera = camera_entry.1
         let projection = camera_entry.2
-        let camera_transform = camera_entry.3
+        let camera_affine = camera_entry.3
+        let camera_layers = camera_entry.5
+        guard projection is @camera.Projection::Orthographic(orthographic) else {
+          continue
+        }
         let target_size = picking_camera_target_size(
           camera, window_width, window_height,
         )
-        guard @camera.camera_viewport_to_world_ray(
-            pointer_window_pos, camera, projection, camera_transform, target_size,
-            scale_factor,
+        guard picking_sprite_camera_viewport_to_world_ray(
+            pointer_window_pos, camera, projection, camera_affine, target_size, scale_factor,
           )
           is Some((origin, direction)) else {
           continue
         }
-        let max_distance = projection.far().max(1.0F)
+        let max_distance = orthographic.far() - orthographic.near()
         let picks : Array[(@core.Entity, HitData)] = []
         let mut blocked = false
         for entry in sorted_sprites {
           if blocked {
             break
           }
-          let transform = entry.2
+          let affine = entry.2
           let pickable = entry.4
+          if !camera_layers.intersects(entry.5) {
+            continue
+          }
           guard picking_sprite_ray_local_hit(
-              origin, direction, transform, max_distance,
+              origin, direction, affine, max_distance,
             )
-            is Some((local_pos, depth)) else {
+            is Some((local_pos, _depth)) else {
             continue
           }
           guard picking_sprite_hit_from_local_pos(
-              world, entry, local_pos, settings, depth,
+              world,
+              entry,
+              local_pos,
+              settings,
+              camera_entry.0,
+              camera_affine,
+              orthographic.near(),
             )
             is Some(payload) else {
             continue
diff --git a/mgstudio-engine/picking/moon.pkg b/mgstudio-engine/picking/moon.pkg
index 954b2ccb0..b6bf7e10b 100644
--- a/mgstudio-engine/picking/moon.pkg
+++ b/mgstudio-engine/picking/moon.pkg
@@ -5,6 +5,8 @@ import {
   "Milky2018/mgstudio/camera",
   "Milky2018/mgstudio/camera/camera" @camera_camera,
   "Milky2018/mgstudio/camera/components2d" @camera_components2d,
+  "Milky2018/mgstudio/camera/projection2d" @camera_projection2d,
+  "Milky2018/mgstudio/camera/visibility/render_layers" @camera_render_layers,
   "Milky2018/moon_accesskit",
   "Milky2018/mgstudio/core",
   "Milky2018/mgstudio/input",
diff --git a/mgstudio-engine/picking/sprite_picking_wbtest.mbt b/mgstudio-engine/picking/sprite_picking_wbtest.mbt
index 65a9662fe..c04e3aa11 100644
--- a/mgstudio-engine/picking/sprite_picking_wbtest.mbt
+++ b/mgstudio-engine/picking/sprite_picking_wbtest.mbt
@@ -98,9 +98,150 @@ test "sprite picking bounding box ignores transparent pixels" {
 }
 
 ///|
-test "sprite picking camera marker requirement filters cameras" {
+test "sprite picking collection matches bevy required query and stable depth sort" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let entities : Array[@core.Entity] = []
+  let nan = 0.0F / 0.0F
+  for
+    candidate in [
+      (1.0F, true, true, None),
+      (1.0F, true, true, Some(3)),
+      (3.0F, true, true, None),
+      (4.0F, false, true, None),
+      (5.0F, true, false, None),
+      (nan, true, true, None),
+    ] {
+    let entity = world.spawn_empty()
+    entities.push(entity)
+    try! world.set_by_key(
+      entity,
+      @sprite.ecs_key_sprite,
+      @sprite.Sprite::sized(@math.Vec2::new(8.0F, 8.0F)),
+    )
+    try! world.set_by_key(
+      entity,
+      @transform.ecs_key_global_transform,
+      @transform.GlobalTransform::from_transform(
+        @transform.Transform::from_xyz(0.0F, 0.0F, candidate.0),
+      ),
+    )
+    try! world.set_by_key(
+      entity,
+      @sprite.ecs_key_anchor,
+      @sprite.Anchor::center(),
+    )
+    try! world.set_by_key(
+      entity,
+      @visibility.ecs_key_view_visibility,
+      @visibility.ViewVisibility::new(candidate.1),
+    )
+    if candidate.2 {
+      try! world.set_by_key(entity, ecs_key_pickable, Pickable::Pickable())
+    }
+    match candidate.3 {
+      Some(layer) =>
+        try! world.set_by_key(
+          entity,
+          @camera_render_layers.ecs_key_render_layers,
+          @camera_render_layers.RenderLayers::layer(layer),
+        )
+      None => ()
+    }
+  }
+
+  let sorted = picking_sprite_collect_sorted(world)
+  let ok = sorted.length() == 3 &&
+    sorted[0].0 == entities[2] &&
+    sorted[1].0 == entities[0] &&
+    sorted[2].0 == entities[1] &&
+    sorted[0].5.mask() == 1 &&
+    sorted[1].5.mask() == 1 &&
+    sorted[2].5.mask() == 8
+  debug_inspect(ok, content="true")
+}
+
+///|
+test "sprite picking hit data uses camera entity and camera-space depth" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let entity = @core.Entity::new(7, 0)
+  let camera_entity = @core.Entity::new(11, 0)
+  let sprite_transform = @transform.GlobalTransform::from_transform(
+    @transform.Transform::from_xyz(0.0F, 0.0F, 2.0F),
+  ).affine()
+  let camera_transform = @transform.GlobalTransform::from_transform(
+    @transform.Transform::from_xyz(0.0F, 0.0F, 10.0F),
+  ).affine()
+  let entry : SpritePickingEntry = (
+    entity,
+    @sprite.Sprite::sized(@math.Vec2::new(2.0F, 2.0F)),
+    sprite_transform,
+    @sprite.Anchor::center(),
+    Pickable::Pickable(),
+    @camera_render_layers.RenderLayers::RenderLayers(),
+  )
+  let hit = picking_sprite_hit_from_local_pos(
+    world,
+    entry,
+    @math.Vec2::zero(),
+    SpritePickingSettings::new(false, BoundingBox),
+    camera_entity,
+    camera_transform,
+    -1.0F,
+  )
+  guard hit is Some((hit_entity, hit_data)) else {
+    debug_inspect(false, content="true")
+    return
+  }
+  let position_ok = match hit_data.position {
+    Some(position) =>
+      position.x == 0.0F && position.y == 0.0F && position.z == 2.0F
+    None => false
+  }
+  let ok = hit_entity == entity &&
+    hit_data.camera == camera_entity &&
+    hit_data.depth == 9.0F &&
+    position_ok
+  debug_inspect(ok, content="true")
+}
+
+///|
+test "sprite picking preserves sheared global transform affine semantics" {
   let world = @ecs.World::new()
   defer world.close()
+  @camera_components2d.ensure_camera2d_required_components(world)
+  let parent = @transform.GlobalTransform::from_transform(
+    @transform.Transform::identity()
+    .with_translation(@math.Vec3::new(3.0F, -2.0F, 5.0F))
+    .with_scale(@math.Vec3::new(0.5F, 1.0F, 0.25F)),
+  )
+  let child = @transform.GlobalTransform::from_transform(
+    @transform.Transform::identity().with_rotation(
+      @math.Quat::from_rotation_y(0.6F),
+    ),
+  )
+  let global_transform = parent.mul(child)
+  let entity = world.spawn_empty()
+  try! world.set_by_key(
+    entity,
+    @sprite.ecs_key_sprite,
+    @sprite.Sprite::sized(@math.Vec2::new(2.0F, 2.0F)),
+  )
+  try! world.set_by_key(
+    entity, @transform.ecs_key_global_transform, global_transform,
+  )
+  try! world.set_by_key(
+    entity,
+    @sprite.ecs_key_anchor,
+    @sprite.Anchor::center(),
+  )
+  try! world.set_by_key(entity, ecs_key_pickable, Pickable::Pickable())
+  try! world.set_by_key(
+    entity,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::new(true),
+  )
   let camera_entity = world.spawn_empty()
   try! world.set_by_key(
     camera_entity,
@@ -109,18 +250,69 @@ test "sprite picking camera marker requirement filters cameras" {
   )
   try! world.set_by_key(
     camera_entity,
-    @camera_camera.ecs_key_camera,
-    @camera_camera.Camera::Camera(),
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
   )
-  try! world.set_by_key(
-    camera_entity,
-    @camera.ecs_key_projection,
-    @camera.Projection::default(),
+  let entries = picking_sprite_collect_sorted(world)
+  let cameras = picking_sprite_cameras(
+    world,
+    SpritePickingSettings::new(false, BoundingBox),
+  )
+  assert_eq(entries.length(), 1)
+  assert_eq(cameras.length(), 1)
+  let affine = global_transform.affine()
+  let local_start = @math.Vec3::new(0.75F, 0.0F, 1.0F)
+  let local_end = @math.Vec3::new(0.75F, 0.0F, -1.0F)
+  let ray_origin = affine.transform_point3(local_start)
+  let ray_end = affine.transform_point3(local_end)
+  let ray_delta = ray_end.sub(ray_origin)
+  guard picking_sprite_ray_local_hit(
+      ray_origin,
+      ray_delta.normalize(),
+      entries[0].2,
+      ray_delta.length(),
+    )
+    is Some((local_hit, _)) else {
+    fail("expected sheared sprite ray hit")
+  }
+  guard picking_sprite_hit_from_local_pos(
+      world,
+      entries[0],
+      local_hit,
+      SpritePickingSettings::new(false, BoundingBox),
+      camera_entity,
+      cameras[0].3,
+      -1.0F,
+    )
+    is Some((_, hit_data)) else {
+    fail("expected sheared sprite hit data")
+  }
+  let expected_position = affine.transform_point3(
+    @math.Vec3::new(0.75F, 0.0F, 0.0F),
   )
+  let expected_normal = affine.matrix3.z_axis.normalize()
+  guard hit_data.position is Some(position) else {
+    fail("expected world hit position")
+  }
+  guard hit_data.normal is Some(normal) else {
+    fail("expected world hit normal")
+  }
+  assert_eq(@pbr_render.absf(local_hit.x - 0.75F) <= 1.0e-5F, true)
+  assert_eq(@pbr_render.absf(local_hit.y) <= 1.0e-5F, true)
+  assert_eq(position.distance(expected_position) <= 1.0e-5F, true)
+  assert_eq(normal.distance(expected_normal) <= 1.0e-5F, true)
+}
+
+///|
+test "sprite picking camera marker requirement filters cameras" {
+  let world = @ecs.World::new()
+  defer world.close()
+  @camera_components2d.ensure_camera2d_required_components(world)
+  let camera_entity = world.spawn_empty()
   try! world.set_by_key(
     camera_entity,
-    @transform.ecs_key_transform,
-    @transform.Transform::identity(),
+    @camera_components2d.ecs_key_camera2d,
+    @camera_components2d.Camera2d::Camera2d(),
   )
   debug_inspect(
     picking_sprite_cameras(world, SpritePickingSettings::new(true, BoundingBox)).length(),
@@ -134,3 +326,60 @@ test "sprite picking camera marker requirement filters cameras" {
     content="1",
   )
 }
+
+///|
+test "sprite picking collects standard Camera2d orthographic projection" {
+  let world = @ecs.World::new()
+  defer world.close()
+  @camera_components2d.ensure_camera2d_required_components(world)
+  let camera_entity = world.spawn_empty()
+  try! world.set_by_key(
+    camera_entity,
+    @camera_components2d.ecs_key_camera2d,
+    @camera_components2d.Camera2d::Camera2d(),
+  )
+  ignore(
+    try! world.replace(
+      camera_entity,
+      @camera_projection2d.ecs_key_projection,
+      @camera_projection2d.Projection::Orthographic(
+        @camera_projection2d.OrthographicProjection::new(2.0F),
+      ),
+    ),
+  )
+  let cameras = picking_sprite_cameras(
+    world,
+    SpritePickingSettings::new(false, BoundingBox),
+  )
+  assert_eq(cameras.length(), 1)
+  let projection_matches_camera2d = match cameras[0].2 {
+    @camera.Projection::Orthographic(orthographic) =>
+      orthographic.scale() == 2.0F &&
+      orthographic.near() == -1000.0F &&
+      orthographic.far() == 1000.0F
+    _ => false
+  }
+  assert_eq(projection_matches_camera2d, true)
+  guard picking_sprite_camera_viewport_to_world_ray(
+      @math.Vec2::new(50.0F, 50.0F),
+      cameras[0].1,
+      cameras[0].2,
+      cameras[0].3,
+      @math.IVec2::new(100, 100),
+      1.0F,
+    )
+    is Some((origin, direction)) else {
+    fail("expected standard Camera2d viewport ray")
+  }
+  guard picking_sprite_ray_local_hit(
+      origin,
+      direction,
+      @math.Affine3::identity(),
+      2000.0F,
+    )
+    is Some((local_hit, _)) else {
+    fail("expected standard Camera2d ray to intersect the sprite plane")
+  }
+  assert_eq(@pbr_render.absf(local_hit.x) <= 1.0e-5F, true)
+  assert_eq(@pbr_render.absf(local_hit.y) <= 1.0e-5F, true)
+}
diff --git a/mgstudio-engine/render/camera.mbt b/mgstudio-engine/render/camera.mbt
index 5d3cdbc9d..ac0882915 100644
--- a/mgstudio-engine/render/camera.mbt
+++ b/mgstudio-engine/render/camera.mbt
@@ -74,8 +74,10 @@ fn host_gpu_composite_alpha_mode_kind(mode : HostGpuCompositeAlphaMode) -> Int {
 }
 
 ///|
-pub fn host_gpu_create_surface(window : Int) -> HostGpuSurface {
-  @renderer.create_surface(window)
+pub fn host_gpu_create_surface(
+  handle : @window.RawHandleWrapper,
+) -> HostGpuSurface {
+  @renderer.create_surface(handle)
 }
 
 ///|
@@ -88,6 +90,11 @@ pub fn host_gpu_surface_target_id_for_window(window : Int) -> Int {
   @renderer.surface_target_id_for_window(window)
 }
 
+///|
+pub fn host_gpu_release_surface(surface : HostGpuSurface) -> Unit {
+  @renderer.release_surface(surface)
+}
+
 ///|
 pub fn host_gpu_configure_surface(
   device~ : HostGpuDevice,
diff --git a/mgstudio-engine/render/pkg.generated.mbti b/mgstudio-engine/render/pkg.generated.mbti
index 85168be2e..eeedfe9f1 100644
--- a/mgstudio-engine/render/pkg.generated.mbti
+++ b/mgstudio-engine/render/pkg.generated.mbti
@@ -229,7 +229,7 @@ pub fn host_gpu_create_render_target_rg16f(width~ : Int, height~ : Int, nearest~
 
 pub fn host_gpu_create_render_target_rgba16f(width~ : Int, height~ : Int, nearest~ : Bool, sample_count? : Int) -> Int
 
-pub fn host_gpu_create_surface(Int) -> Int
+pub fn host_gpu_create_surface(@window.RawHandleWrapper) -> Int
 
 pub fn host_gpu_create_transmission_source_texture_rgba16f(width~ : Int, height~ : Int) -> Int
 
@@ -385,6 +385,8 @@ pub fn host_gpu_register_mesh3d_material_pipeline_descriptor(material_pipeline_i
 
 pub fn host_gpu_release_skybox_bind_group(bind_group_id~ : Int) -> Bool
 
+pub fn host_gpu_release_surface(Int) -> Unit
+
 pub fn host_gpu_request_device() -> Int
 
 pub fn host_gpu_reserve_mesh3d_draw_storage(count~ : Int) -> Int
diff --git a/mgstudio-engine/render/renderer/backend_init.mbt b/mgstudio-engine/render/renderer/backend_init.mbt
index 697382b19..1955a7b9a 100644
--- a/mgstudio-engine/render/renderer/backend_init.mbt
+++ b/mgstudio-engine/render/renderer/backend_init.mbt
@@ -317,6 +317,7 @@ fn gpu_backend_new_from_instance(
     mesh3d_clusterable_object_index_lists_size: 0UL,
     mesh3d_cluster_offsets_and_counts_buf: None,
     mesh3d_cluster_offsets_and_counts_size: 0UL,
+    mesh3d_cluster_buffers_source_owned: false,
     mesh3d_clustered_decals_buf: None,
     mesh3d_clustered_decals_capacity: 0UL,
     mesh3d_clustered_decals_revision: 0,
diff --git a/mgstudio-engine/render/renderer/backend_state.mbt b/mgstudio-engine/render/renderer/backend_state.mbt
index b52c96ffb..b759e499f 100644
--- a/mgstudio-engine/render/renderer/backend_state.mbt
+++ b/mgstudio-engine/render/renderer/backend_state.mbt
@@ -189,6 +189,7 @@ pub struct GpuBackend {
   mut mesh3d_clusterable_object_index_lists_size : UInt64
   mut mesh3d_cluster_offsets_and_counts_buf : @wgpu.Buffer?
   mut mesh3d_cluster_offsets_and_counts_size : UInt64
+  mut mesh3d_cluster_buffers_source_owned : Bool
   mut mesh3d_clustered_decals_buf : @wgpu.Buffer?
   mut mesh3d_clustered_decals_capacity : UInt64
   mut mesh3d_clustered_decals_revision : Int
diff --git a/mgstudio-engine/render/renderer/gpu_wbtest.mbt b/mgstudio-engine/render/renderer/gpu_wbtest.mbt
index 5c547b77b..b9ef05f10 100644
--- a/mgstudio-engine/render/renderer/gpu_wbtest.mbt
+++ b/mgstudio-engine/render/renderer/gpu_wbtest.mbt
@@ -2539,6 +2539,40 @@ test "renderer: replacing mesh3d cluster buffers keeps handles bounded" {
   debug_inspect(bounded, content="true")
 }
 
+///|
+test "renderer: source-owned mesh3d cluster buffers reject legacy uploads" {
+  let backend = GpuBackend::new()
+  ensure_mesh3d_pipeline_layout_resources(backend)
+  let usage = bu(
+    @wgpu.BUFFER_USAGE_STORAGE | @wgpu.BUFFER_USAGE_COPY_DST,
+  )
+  let clustered_lights = backend.device.create_buffer(size=16UL, usage~)
+  let object_indices = backend.device.create_buffer(size=16UL, usage~)
+  let offsets_and_counts = backend.device.create_buffer(size=16UL, usage~)
+  backend.use_mesh3d_cluster_buffers(
+    clustered_lights,
+    16UL,
+    object_indices,
+    16UL,
+    offsets_and_counts,
+    16UL,
+  )
+  clustered_lights.release()
+  object_indices.release()
+  offsets_and_counts.release()
+
+  backend.device.push_error_scope(@wgpu.ERROR_FILTER_VALIDATION)
+  backend.prepare_mesh3d_cluster_buffers(
+    Bytes::make(32, (0).to_byte()),
+    Bytes::make(32, (0).to_byte()),
+    Bytes::make(32, (0).to_byte()),
+  )
+  let result = backend.device.pop_error_scope_sync_result(backend.instance)
+  let no_legacy_overwrite = result.error_type == @wgpu.ERROR_TYPE_NO_ERROR
+  backend.shutdown()
+  debug_inspect(no_legacy_overwrite, content="true")
+}
+
 ///|
 test "renderer: mesh3d runtime flags infer two-component normal map format" {
   let backend = GpuBackend::new()
diff --git a/mgstudio-engine/render/renderer/mesh3d_runtime_api.mbt b/mgstudio-engine/render/renderer/mesh3d_runtime_api.mbt
index 9c04eacac..8cda63d75 100644
--- a/mgstudio-engine/render/renderer/mesh3d_runtime_api.mbt
+++ b/mgstudio-engine/render/renderer/mesh3d_runtime_api.mbt
@@ -109,6 +109,9 @@ pub fn GpuBackend::prepare_mesh3d_cluster_buffers(
   clusterable_object_index_lists_bytes : Bytes,
   cluster_offsets_and_counts_bytes : Bytes,
 ) -> Unit {
+  if self.mesh3d_cluster_buffers_source_owned {
+    return
+  }
   ensure_mesh3d_view_binding_buffers(self)
   guard self.mesh3d_clustered_lights_buf is Some(clustered_lights_buf) else {
     return
@@ -163,6 +166,7 @@ pub fn GpuBackend::use_mesh3d_cluster_buffers(
     cluster_offsets_and_counts_buffer,
   )
   self.mesh3d_cluster_offsets_and_counts_size = cluster_offsets_and_counts_size
+  self.mesh3d_cluster_buffers_source_owned = true
 }
 
 ///|
diff --git a/mgstudio-engine/render/renderer/moon.pkg b/mgstudio-engine/render/renderer/moon.pkg
index f4b8526f0..f05294092 100644
--- a/mgstudio-engine/render/renderer/moon.pkg
+++ b/mgstudio-engine/render/renderer/moon.pkg
@@ -10,10 +10,10 @@ import {
   "Milky2018/mgstudio/render/render_resource",
   "Milky2018/mgstudio/shader/compile" @shader_compile,
   "Milky2018/mgstudio/time",
-  "Milky2018/mgstudio/window/windowing_native" @windowing,
+  "Milky2018/mgstudio/window" @window_pkg,
   "Milky2018/wgpu_mbt" @wgpu,
   "Milky2018/wgpu_mbt/c" @wgpu_c,
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
   "moonbitlang/core/ref",
   "moonbitlang/core/math" @coremath,
   "moonbitlang/core/string",
diff --git a/mgstudio-engine/render/renderer/pkg.generated.mbti b/mgstudio-engine/render/renderer/pkg.generated.mbti
index 6c9d11d0a..745661058 100644
--- a/mgstudio-engine/render/renderer/pkg.generated.mbti
+++ b/mgstudio-engine/render/renderer/pkg.generated.mbti
@@ -3,6 +3,7 @@ package "Milky2018/mgstudio/render/renderer"
 
 import {
   "Milky2018/mgstudio/render/render_resource",
+  "Milky2018/mgstudio/window",
   "Milky2018/wgpu_mbt",
   "moonbitlang/core/debug",
   "moonbitlang/core/hashmap",
@@ -149,7 +150,7 @@ pub fn create_render_target_rgba16f(width~ : Int, height~ : Int, nearest~ : Bool
 
 pub fn create_render_target_with_formats(width~ : Int, height~ : Int, nearest~ : Bool, format~ : @wgpu_mbt.TextureFormat, sample_format~ : @wgpu_mbt.TextureFormat?, sample_count? : Int) -> Int
 
-pub fn create_surface(Int) -> Int
+pub fn create_surface(@window.RawHandleWrapper) -> Int
 
 pub fn create_transmission_source_texture_rgba16f(width~ : Int, height~ : Int) -> Int
 
@@ -459,6 +460,8 @@ pub fn release_frame_retired_resources() -> Unit
 
 pub fn release_skybox_prepared_bind_group(bind_group_id~ : Int) -> Bool
 
+pub fn release_surface(Int) -> Unit
+
 pub fn render_context_backend_for_test() -> GpuBackend?
 
 pub fn render_context_set_backend_for_test(GpuBackend?) -> Unit
@@ -1116,8 +1119,8 @@ pub fn GpuBackend::create_render_target(Self, Int, Int, Bool) -> Int raise GpuBa
 pub fn GpuBackend::create_render_target_rg16f(Self, Int, Int, Bool, sample_count? : Int) -> Int raise GpuBackendError
 pub fn GpuBackend::create_render_target_rgba16f(Self, Int, Int, Bool, sample_count? : Int) -> Int raise GpuBackendError
 pub fn GpuBackend::create_render_target_with_formats(Self, Int, Int, Bool, @wgpu_mbt.TextureFormat, @wgpu_mbt.TextureFormat?, sample_count? : Int) -> Int raise GpuBackendError
-pub fn GpuBackend::create_surface(Self, Int) -> Unit
-pub fn GpuBackend::create_surface_binding(Self, Int, Int, Int) -> Unit
+pub fn GpuBackend::create_surface(Self, @window.RawHandleWrapper) -> Unit
+pub fn GpuBackend::create_surface_binding(Self, Int, Int, @window.RawHandleWrapper) -> Unit
 pub fn GpuBackend::create_texture_3d_with_format(Self, Int, Int, Int, @wgpu_mbt.TextureFormat, Array[Bytes], label? : String?) -> Int raise GpuBackendError
 pub fn GpuBackend::create_texture_cube_with_format(Self, Int, Int, @wgpu_mbt.TextureFormat, Array[Bytes], Bool, usage_bits? : Int, label? : String?, replace_texture_id? : Int) -> Int raise GpuBackendError
 pub fn GpuBackend::create_texture_mip_view(Self, Int, Int) -> Int raise GpuBackendError
@@ -2124,4 +2127,3 @@ pub type NativeGpuSurface = Int
 pub type PendingMapReadCallback = (UInt, Bytes, @wgpu_mbt.Buffer) -> Unit
 
 // Traits
-
diff --git a/mgstudio-engine/render/renderer/window_surface.mbt b/mgstudio-engine/render/renderer/window_surface.mbt
index a929ef1ce..b65b73a6c 100644
--- a/mgstudio-engine/render/renderer/window_surface.mbt
+++ b/mgstudio-engine/render/renderer/window_surface.mbt
@@ -21,6 +21,7 @@
 priv struct SurfaceBinding {
   surface_id : NativeGpuSurface
   window : Int
+  handle : @window_pkg.RawHandleWrapper
   target_id : Int
   mut needs_initial_present : Bool
 }
@@ -71,6 +72,31 @@ fn find_surface_binding(surface_id : NativeGpuSurface) -> SurfaceBinding? {
   None
 }
 
+///|
+fn remove_surface_runtime_bindings(surface_id : NativeGpuSurface) -> Unit {
+  let state = window_surface_runtime_state
+  let next_surfaces : Array[SurfaceBinding] = []
+  for binding in state.surfaces {
+    if binding.surface_id != surface_id {
+      next_surfaces.push(binding)
+    }
+  }
+  state.surfaces.clear()
+  for binding in next_surfaces {
+    state.surfaces.push(binding)
+  }
+  let next_frames : Array[FrameBinding] = []
+  for binding in state.frames {
+    if binding.surface_id != surface_id {
+      next_frames.push(binding)
+    }
+  }
+  state.frames.clear()
+  for binding in next_frames {
+    state.frames.push(binding)
+  }
+}
+
 ///|
 fn find_surface_binding_by_window(window : Int) -> SurfaceBinding? {
   let state = window_surface_runtime_state
@@ -573,18 +599,13 @@ pub fn GpuBackend::create_surface_binding(
   self : GpuBackend,
   surface_id : Int,
   target_id : Int,
-  window : Int,
+  handle : @window_pkg.RawHandleWrapper,
 ) -> Unit {
   if surface_state_index_by_surface_id(self, surface_id) is Some(_) {
     return
   }
-  let ns_view = match @windowing.content_view_handle(window) {
-    Some(handle) => handle
-    None => abort("wgpu: failed to get macOS window content view handle")
-  }
-  let surface = self.instance.create_surface_macos_ns_view_u64(ns_view) catch {
-    err =>
-      abort("wgpu: failed to create macOS window surface: \{err.message()}")
+  let surface = self.instance.create_surface_from_window(handle) catch {
+    err => abort("wgpu: failed to create window surface: \{err.message()}")
   }
   self.surfaces.push(GpuSurfaceState::{
     surface_id,
@@ -606,8 +627,34 @@ pub fn GpuBackend::create_surface_binding(
 }
 
 ///|
-pub fn GpuBackend::create_surface(self : GpuBackend, window : Int) -> Unit {
-  self.create_surface_binding(1, -1, window)
+pub fn GpuBackend::create_surface(
+  self : GpuBackend,
+  handle : @window_pkg.RawHandleWrapper,
+) -> Unit {
+  self.create_surface_binding(1, -1, handle)
+}
+
+///|
+fn GpuBackend::release_surface_binding(
+  self : GpuBackend,
+  surface_id : Int,
+) -> Unit {
+  guard surface_state_index_by_surface_id(self, surface_id) is Some(index) else {
+    return
+  }
+  let target_id = self.surfaces[index].target_id
+  self.release_frame_binding(surface_id)
+  let removed = self.surfaces.remove(index)
+  removed.release()
+  if self.active_surface_target_id == target_id {
+    self.active_surface_target_id = match default_surface_target_id(self) {
+      Some(next_target_id) => next_target_id
+      None => -1
+    }
+    self.frame = None
+    self.pass_state = None
+  }
+  sync_active_surface_state(self)
 }
 
 ///|
@@ -624,6 +671,16 @@ pub fn GpuBackend::configure_surface_binding(
     return
   }
   let state = self.surfaces[index]
+  let window_handle = match find_surface_binding(surface_id) {
+    Some(binding) => binding.handle.window_handle()
+    None => abort("wgpu: missing window handle for surface \{surface_id}")
+  }
+  state.surface.sync_macos_window_handle(window_handle) catch {
+    err =>
+      abort(
+        "wgpu: failed to synchronize macOS window surface: \{err.message()}",
+      )
+  }
   let present_mode_u32 = surface_present_mode_resolve(
     state.surface,
     self.adapter,
@@ -717,13 +774,7 @@ pub fn GpuBackend::ensure_surface_configured(
 }
 
 ///|
-pub fn GpuBackend::begin_frame_binding(
-  self : GpuBackend,
-  surface_id : Int,
-) -> Bool {
-  guard surface_state_index_by_surface_id(self, surface_id) is Some(index) else {
-    return false
-  }
+fn GpuBackend::prepare_render_frame(self : GpuBackend) -> Unit {
   mesh3d_pass_uniform_states_clear(self)
   mesh3d_frame_view_bind_group_cache_clear(self)
   self.mesh3d_motion_vector_view_bg_cache.clear()
@@ -733,11 +784,6 @@ pub fn GpuBackend::begin_frame_binding(
   } else {
     self.frame_count = self.frame_count + 1U
   }
-  let target_id = self.surfaces[index].target_id
-  self.set_active_surface_target(target_id)
-  self.surfaces[index].cleared_this_frame = false
-  sync_active_surface_state(self)
-
   self.mesh2d_instance_used = 0
   self.sprite_flush_count_this_frame = 0
   mesh2d_reset_pending_batch(self)
@@ -749,6 +795,21 @@ pub fn GpuBackend::begin_frame_binding(
   self.mesh3d_prepared_draw_count = 0
   self.mesh3d_motion_vector_mesh_slot_used = 0
   self.mesh3d_motion_vector_instance_mesh_used = 0
+}
+
+///|
+pub fn GpuBackend::begin_frame_binding(
+  self : GpuBackend,
+  surface_id : Int,
+) -> Bool {
+  guard surface_state_index_by_surface_id(self, surface_id) is Some(index) else {
+    return false
+  }
+  let target_id = self.surfaces[index].target_id
+  self.set_active_surface_target(target_id)
+  self.surfaces[index].cleared_this_frame = false
+  sync_active_surface_state(self)
+
   let acquired = match self.acquire_surface_texture_once(index) {
     SurfaceAcquired(st, tex) => Some((st, tex))
     SurfaceOutdated => {
@@ -1017,22 +1078,36 @@ pub fn release_frame_retired_resources() -> Unit {
 }
 
 ///|
-pub fn create_surface(window : Int) -> NativeGpuSurface {
+pub fn create_surface(
+  handle : @window_pkg.RawHandleWrapper,
+) -> NativeGpuSurface {
   let surface_id = next_surface_id()
   let target_id = surface_target_id_from_surface_id(surface_id)
   let state = window_surface_runtime_state
   state.surfaces.push(SurfaceBinding::{
     surface_id,
-    window,
+    window: handle.window(),
+    handle,
     target_id,
     needs_initial_present: true,
   })
   if ensure_backend() is Some(backend) {
-    backend.create_surface_binding(surface_id, target_id, window)
+    backend.create_surface_binding(surface_id, target_id, handle)
   }
   surface_id
 }
 
+///|
+pub fn release_surface(surface : NativeGpuSurface) -> Unit {
+  if surface <= 0 {
+    return
+  }
+  if render_context_runtime_state.backend is Some(backend) {
+    backend.release_surface_binding(surface)
+  }
+  remove_surface_runtime_bindings(surface)
+}
+
 ///|
 pub fn surface_target_id(surface : NativeGpuSurface) -> Int {
   match find_surface_binding(surface) {
@@ -1082,7 +1157,7 @@ pub fn begin_frame(surface : NativeGpuSurface) -> Bool {
   if surface <= 0 {
     return false
   }
-  render_diagnostics_begin_frame()
+  prepare_render_frame()
   if ensure_backend() is Some(backend) {
     guard backend.begin_frame_binding(surface) else { return false }
     record_active_frame(surface, surface_target_id_from_surface_id(surface))
@@ -1091,8 +1166,20 @@ pub fn begin_frame(surface : NativeGpuSurface) -> Bool {
   false
 }
 
+///|
+fn prepare_render_frame() -> Unit {
+  render_diagnostics_begin_frame()
+  if ensure_backend() is Some(backend) {
+    backend.prepare_render_frame()
+  }
+}
+
 ///|
 pub fn prepare_initial_surface_frames() -> Unit {
+  // Bevy's `prepare_windows` starts the logical render frame before the render
+  // graph runs. Host surface acquisition can remain lazy after the initial
+  // present, but frame-local GPU allocators must still reset at this boundary.
+  prepare_render_frame()
   if ensure_backend() is Some(backend) {
     backend.prepare_initial_surface_frames()
   }
diff --git a/mgstudio-engine/render/uniform.mbt b/mgstudio-engine/render/uniform.mbt
index 612abfa20..182617d09 100644
--- a/mgstudio-engine/render/uniform.mbt
+++ b/mgstudio-engine/render/uniform.mbt
@@ -180,6 +180,13 @@ pub impl[C : @ecs.Component + UniformComponent] @app.Plugin for UniformComponent
   uniform_component_plugin_with(app, self)
 }
 
+///|
+fn[C : UniformComponent] uniform_component_debug_name_for_key(
+  _key : @ecs.ComponentKey[C],
+) -> String {
+  C::uniform_component_debug_name()
+}
+
 ///|
 pub fn[C : @ecs.Component + UniformComponent] uniform_component_plugin_with(
   app : @app.App[@ecs.World],
@@ -187,7 +194,7 @@ pub fn[C : @ecs.Component + UniformComponent] uniform_component_plugin_with(
 ) -> @app.App[@ecs.World] {
   ignore(plugin)
   let uniform_key : @ecs.ResourceKey[ComponentUniforms[C]] = ComponentUniforms::resource()
-  let component_key : @ecs.ComponentKey[C] = C::component()
+  let component_key : @ecs.ComponentKey[C] = @ecs.Component::component()
   let index_key : @ecs.ComponentKey[DynamicUniformIndex[C]] = DynamicUniformIndex::component()
   try_with_render_app(app, fn(render_app : @app.SubApp[@ecs.World]) {
     if render_app.world().get_resource(uniform_key) is None {
@@ -201,7 +208,7 @@ pub fn[C : @ecs.Component + UniformComponent] uniform_component_plugin_with(
         prepare_uniform_components(world, component_key, index_key, uniform_key)
       })
       .named(
-        "mgstudio_render::uniform::prepare_uniform_components<\{C::uniform_component_debug_name()}>",
+        "mgstudio_render::uniform::prepare_uniform_components<\{uniform_component_debug_name_for_key(component_key)}>",
       )
       .in_set(render_system_set_prepare_resources),
     )
diff --git a/mgstudio-engine/render/view/window/moon.pkg b/mgstudio-engine/render/view/window/moon.pkg
index 3eea3229e..5096de0c7 100644
--- a/mgstudio-engine/render/view/window/moon.pkg
+++ b/mgstudio-engine/render/view/window/moon.pkg
@@ -13,6 +13,10 @@ import {
   "Milky2018/wgpu_mbt" @wgpu,
 }
 
+import {
+  "Milky2018/windowing",
+} for "wbtest"
+
 supported_targets = "native"
 
 options(
diff --git a/mgstudio-engine/render/view/window/pkg.generated.mbti b/mgstudio-engine/render/view/window/pkg.generated.mbti
index 79e91dc1e..a739e51ee 100644
--- a/mgstudio-engine/render/view/window/pkg.generated.mbti
+++ b/mgstudio-engine/render/view/window/pkg.generated.mbti
@@ -85,7 +85,6 @@ pub let window_surfaces_resource_key : @ecs.ResourceKey[WindowSurfaces]
 
 // Errors
 pub suberror WindowSurfaceCreateError {
-  MissingContentViewHandle(@core.Entity, Int)
   NativeSurfaceCreateFailed(@core.Entity, String)
   NativeSurfaceConfigureFailed(@core.Entity, String)
 }
diff --git a/mgstudio-engine/render/view/window/top.mbt b/mgstudio-engine/render/view/window/top.mbt
index f41bf0051..433f3a326 100644
--- a/mgstudio-engine/render/view/window/top.mbt
+++ b/mgstudio-engine/render/view/window/top.mbt
@@ -20,7 +20,6 @@ pub struct WindowRenderPlugin {}
 
 ///|
 pub suberror WindowSurfaceCreateError {
-  MissingContentViewHandle(@core.Entity, Int)
   NativeSurfaceCreateFailed(@core.Entity, String)
   NativeSurfaceConfigureFailed(@core.Entity, String)
 }
@@ -30,8 +29,6 @@ pub fn WindowSurfaceCreateError::message(
   self : WindowSurfaceCreateError,
 ) -> String {
   match self {
-    MissingContentViewHandle(entity, window) =>
-      "missing content view handle for window entity \{entity.to_bits()} host window \{window}"
     NativeSurfaceCreateFailed(entity, message) =>
       "failed to create surface for window entity \{entity.to_bits()}: \{message}"
     NativeSurfaceConfigureFailed(entity, message) =>
@@ -251,6 +248,9 @@ pub fn WindowSurfaces::remove(
   self : WindowSurfaces,
   entity : @core.Entity,
 ) -> Unit {
+  if self.surfaces.get(entity) is Some(data) {
+    data.surface.release()
+  }
   self.surfaces.remove(entity)
   self.configured_windows.remove(entity)
 }
@@ -398,7 +398,7 @@ pub fn prepare_windows(
     } else if status == @wgpu.SURFACE_GET_CURRENT_TEXTURE_STATUS_OUTDATED {
       frame.release()
       configure_surface_for_window(
-        window.entity,
+        window,
         surface_data.surface,
         surface_data.configuration,
         render_adapter,
@@ -669,12 +669,19 @@ fn surface_configuration_from_surface(
 
 ///|
 fn configure_surface_for_window(
-  entity : @core.Entity,
+  window : ExtractedWindow,
   surface : @wgpu.Surface,
   configuration : @wgpu.SurfaceConfiguration,
   render_adapter : @renderer.RenderAdapter,
   render_device : @renderer.RenderDevice,
 ) -> Unit raise WindowSurfaceCreateError {
+  surface.sync_macos_window_handle(window.handle.window_handle()) catch {
+    err =>
+      raise WindowSurfaceCreateError::NativeSurfaceConfigureFailed(
+        window.entity,
+        err.message(),
+      )
+  }
   surface.configure_with_or_raise(
     render_adapter.wgpu_adapter(),
     render_device.wgpu_device(),
@@ -682,7 +689,7 @@ fn configure_surface_for_window(
   ) catch {
     err =>
       raise WindowSurfaceCreateError::NativeSurfaceConfigureFailed(
-        entity,
+        window.entity,
         err.message(),
       )
   }
@@ -693,15 +700,7 @@ pub fn create_surface_for_window(
   window : ExtractedWindow,
   render_instance : @renderer.RenderInstance,
 ) -> @wgpu.Surface raise WindowSurfaceCreateError {
-  let ns_view = match window.handle.content_view_handle() {
-    Some(handle) => handle
-    None =>
-      raise WindowSurfaceCreateError::MissingContentViewHandle(
-        window.entity,
-        window.handle.window(),
-      )
-  }
-  render_instance.wgpu_instance().create_surface_macos_ns_view_u64(ns_view) catch {
+  render_instance.wgpu_instance().create_surface_from_window(window.handle) catch {
     err =>
       raise WindowSurfaceCreateError::NativeSurfaceCreateFailed(
         window.entity,
@@ -722,11 +721,7 @@ fn surface_data_for_window(
     window, surface, render_adapter,
   )
   configure_surface_for_window(
-    window.entity,
-    surface,
-    configuration,
-    render_adapter,
-    render_device,
+    window, surface, configuration, render_adapter, render_device,
   )
   SurfaceData::{
     surface,
@@ -748,7 +743,7 @@ fn reconfigured_surface_data_for_window(
     render_adapter,
   )
   configure_surface_for_window(
-    window.entity,
+    window,
     data.surface,
     configuration,
     render_adapter,
diff --git a/mgstudio-engine/render/view/window/top_wbtest.mbt b/mgstudio-engine/render/view/window/top_wbtest.mbt
index 77b4ca151..304f5c39d 100644
--- a/mgstudio-engine/render/view/window/top_wbtest.mbt
+++ b/mgstudio-engine/render/view/window/top_wbtest.mbt
@@ -12,6 +12,37 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+///|
+priv struct UnavailableHandleProvider {}
+
+///|
+impl @windowing.WindowHandleProvider for UnavailableHandleProvider with fn raw_window_handle(
+  _self,
+) {
+  raise @windowing.HandleError::Unavailable
+}
+
+///|
+impl @windowing.DisplayHandleProvider for UnavailableHandleProvider with fn raw_display_handle(
+  _self,
+) {
+  raise @windowing.HandleError::Unavailable
+}
+
+///|
+fn test_raw_handle(window : Int) -> @window_pkg.RawHandleWrapper {
+  let provider = UnavailableHandleProvider::{  }
+  @window_pkg.RawHandleWrapper::new(
+    window,
+    @windowing.WindowHandle::from_provider(
+      provider as &@windowing.WindowHandleProvider,
+    ),
+    @windowing.DisplayHandle::from_provider(
+      provider as &@windowing.DisplayHandleProvider,
+    ),
+  )
+}
+
 ///|
 test "render view window: WindowRenderPlugin initializes render-world window resources" {
   let lifecycle_world_15_0 = @ecs.World::new()
@@ -49,9 +80,7 @@ test "render view window: ExtractedWindows tracks primary and removes it with en
   let world = @ecs.World::new()
   defer world.close()
   let entity = world.spawn()
-  let handle = @window_pkg.RawHandleWrapper::new(
-    @window_pkg.WindowWrapper::new(11),
-  )
+  let handle = test_raw_handle(11)
   let extracted = ExtractedWindow::new(
     entity,
     handle,
@@ -98,12 +127,7 @@ fn spawn_extractable_window(
 ) -> @core.Entity {
   let entity = world.spawn()
   try! (world.entity_mut(entity).insert_component(window) |> ignore)
-  try! (world
-  .entity_mut(entity)
-  .insert_component(
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(17)),
-  )
-  |> ignore)
+  try! (world.entity_mut(entity).insert_component(test_raw_handle(17)) |> ignore)
   if primary {
     try! (world
     .entity_mut(entity)
@@ -232,7 +256,7 @@ test "render view window: need_surface_configuration follows configured and chan
   let entity = world.spawn()
   let extracted = ExtractedWindow::new(
     entity,
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(17)),
+    test_raw_handle(17),
     640,
     360,
     @window_pkg.PresentMode::Fifo,
@@ -258,7 +282,7 @@ test "render view window: camera target gating follows Bevy prepare_windows cond
   let secondary_entity = world.spawn()
   let primary = ExtractedWindow::new(
     primary_entity,
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(17)),
+    test_raw_handle(17),
     640,
     360,
     @window_pkg.PresentMode::Fifo,
@@ -267,7 +291,7 @@ test "render view window: camera target gating follows Bevy prepare_windows cond
   )
   let secondary = ExtractedWindow::new(
     secondary_entity,
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(18)),
+    test_raw_handle(18),
     640,
     360,
     @window_pkg.PresentMode::Fifo,
@@ -388,7 +412,7 @@ test "render view window: present_mode_raw chooses first supported fallback" {
   let entity = world.spawn()
   let window = ExtractedWindow::new(
     entity,
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(17)),
+    test_raw_handle(17),
     640,
     360,
     @window_pkg.PresentMode::AutoNoVsync,
@@ -455,7 +479,7 @@ test "render view window: surface configuration uses Bevy window fields" {
   let entity = world.spawn()
   let window = ExtractedWindow::new(
     entity,
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(17)),
+    test_raw_handle(17),
     640,
     360,
     @window_pkg.PresentMode::AutoNoVsync,
@@ -495,13 +519,13 @@ test "render view window: surface configuration uses Bevy window fields" {
 }
 
 ///|
-test "render view window: create_surface_for_window reports missing content view" {
+test "render view window: create_surface_for_window reports unavailable typed handle" {
   let world = @ecs.World::new()
   defer world.close()
   let entity = world.spawn()
   let window = ExtractedWindow::new(
     entity,
-    @window_pkg.RawHandleWrapper::new(@window_pkg.WindowWrapper::new(-1)),
+    test_raw_handle(-1),
     640,
     360,
     @window_pkg.PresentMode::Fifo,
@@ -515,8 +539,8 @@ test "render view window: create_surface_for_window reports missing content view
     create_surface_for_window(window, render_instance) |> ignore
     debug_inspect(false, content="true")
   } catch {
-    WindowSurfaceCreateError::MissingContentViewHandle(_, host_window) =>
-      debug_inspect(host_window, content="-1")
+    WindowSurfaceCreateError::NativeSurfaceCreateFailed(_, message) =>
+      debug_inspect(message, content="\"window handle is unavailable\"")
     _ => debug_inspect(false, content="true")
   }
 }
diff --git a/mgstudio-engine/scene/scene_loader.mbt b/mgstudio-engine/scene/scene_loader.mbt
index 6f987e602..f03122480 100644
--- a/mgstudio-engine/scene/scene_loader.mbt
+++ b/mgstudio-engine/scene/scene_loader.mbt
@@ -62,7 +62,8 @@ fn scene_init_gltf_assets(app : @app.App[@ecs.World]) -> @app.App[@ecs.World] {
 
 ///|
 fn scene_registry_from_world(world : @ecs.World) -> SceneAssetRegistryState? {
-  let key : @ecs.ResourceKey[SceneAssetRegistryState] = SceneAssetRegistryState::resource()
+  let key : @ecs.ResourceKey[SceneAssetRegistryState] = (
+    @app.Resource::resource() : @ecs.ResourceKey[SceneAssetRegistryState])
   world.get_resource(key)
 }
 
diff --git a/mgstudio-engine/scripts/gate_bevy_asset_mirror.sh b/mgstudio-engine/scripts/gate_bevy_asset_mirror.sh
new file mode 100755
index 000000000..07108a468
--- /dev/null
+++ b/mgstudio-engine/scripts/gate_bevy_asset_mirror.sh
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Copyright 2026 International Digital Economy Academy
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+REPO_DIR="$(cd "${SCRIPT_DIR}/../.." && pwd)"
+
+python3 "${REPO_DIR}/scripts/sync_bevy_assets.py" --check-manifest
diff --git a/mgstudio-engine/scripts/parity_hard_gates.sh b/mgstudio-engine/scripts/parity_hard_gates.sh
index 52edf586c..67ff8304a 100755
--- a/mgstudio-engine/scripts/parity_hard_gates.sh
+++ b/mgstudio-engine/scripts/parity_hard_gates.sh
@@ -18,6 +18,7 @@ set -euo pipefail
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
 
 "${SCRIPT_DIR}/gate_no_mgstudio_shader.sh"
+"${SCRIPT_DIR}/gate_bevy_asset_mirror.sh"
 "${SCRIPT_DIR}/gate_asset_provenance.sh"
 "${SCRIPT_DIR}/gate_visual_runtime.sh"
 if [[ "${MGSTUDIO_PARITY_INCLUDE_STRESS:-0}" == "1" ]]; then
diff --git a/mgstudio-engine/shader/compile/lib.mbt b/mgstudio-engine/shader/compile/lib.mbt
index 140239479..c974e2ef9 100644
--- a/mgstudio-engine/shader/compile/lib.mbt
+++ b/mgstudio-engine/shader/compile/lib.mbt
@@ -125,7 +125,7 @@ let shader_compile_runtime_state : ShaderCompileRuntimeState = {
 
 ///|
 pub fn normalize_shader_rel_path(rel : String) -> String {
-  @wgsl_resolver.normalize_shader_rel_path(rel)
+  @wgsl_common.normalize_shader_rel_path(rel)
 }
 
 ///|
@@ -326,7 +326,7 @@ pub fn default_shader_value_defines() -> @hashmap.HashMap[
   String,
   @wgsl_common.ShaderDefValue,
 ] {
-  shader_def_map_to_hashmap(@wgsl_common.default_wgsl_value_defines())
+  shader_def_map_to_hashmap(@wgsl_common.bevy_wgsl_value_defines())
 }
 
 ///|
@@ -341,6 +341,7 @@ fn compose_options(
     value_defines: shader_def_hashmap_to_map(value_defines),
     redirects: [],
     additional_imports: [],
+    immediate_specializations: [],
   }
 }
 
@@ -386,8 +387,8 @@ pub fn load_preprocessed_wgsl(
     return cached
   }
   let options = compose_options(assets_base, defines, value_defines)
-  let composer = shader_compile_composer(Some(rel))
-  let composed = composer.compose_wgsl(rel, options) catch {
+  let composer = shader_compile_composer(None)
+  let composed = composer.compose_wgsl_runtime_valid(rel, options) catch {
     err => raise shader_compile_error_from_composer(err)
   }
   shader_compile_cache_insert(key, composed)
diff --git a/mgstudio-engine/shader/compile/moon.pkg b/mgstudio-engine/shader/compile/moon.pkg
index 309576d31..8c98f3b64 100644
--- a/mgstudio-engine/shader/compile/moon.pkg
+++ b/mgstudio-engine/shader/compile/moon.pkg
@@ -1,8 +1,7 @@
 import {
   "Milky2018/mgstudio/shader/source" @shader_source,
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
   "Milky2018/moon_wgsl_naga_oil/compose" @wgsl_compose,
-  "Milky2018/moon_wgsl_naga_oil/resolver" @wgsl_resolver,
   "moonbitlang/core/hashmap",
   "moonbitlang/core/ref",
 }
diff --git a/mgstudio-engine/shader/compile/namespace_function_external_blocker_test.mbt b/mgstudio-engine/shader/compile/namespace_function_external_blocker_test.mbt
index fa3bac48b..449d98db0 100644
--- a/mgstudio-engine/shader/compile/namespace_function_external_blocker_test.mbt
+++ b/mgstudio-engine/shader/compile/namespace_function_external_blocker_test.mbt
@@ -13,28 +13,86 @@
 // limitations under the License.
 
 ///|
-test "compile external blocker: fully qualified module function call fails IR lowering" {
+test "compile: transitive fully qualified module function call is flattened" {
   clear_registered_shader_sources()
   register_shader_source(
-    "shader/compile/fog_blocker.wgsl", "#define_import_path test::fog\nfn linear_fog(value: f32) -> f32 { return value; }\n",
+    "shader/compile/types_blocker.wgsl",
+    (
+      #|#define_import_path test::types
+      #|struct Fog { mode: u32 }
+      #|
+    ),
   )
   register_shader_source(
-    "shader/compile/fog_blocker_root.wgsl", "#define_import_path test::root\nfn fragment() -> f32 { return test::fog::linear_fog(1.0); }\n",
+    "shader/compile/fog_blocker.wgsl",
+    (
+      #|#define_import_path test::fog
+      #|#import test::types::Fog
+      #|fn linear_fog(
+      #|  fog_params: Fog,
+      #|  input_color: vec4<f32>,
+      #|  distance: f32,
+      #|  scattering: vec3<f32>,
+      #|) -> vec4<f32> {
+      #|  return input_color;
+      #|}
+      #|
+    ),
   )
-  let message = try
+  register_shader_source(
+    "shader/compile/pbr_functions_blocker.wgsl",
+    (
+      #|#define_import_path test::pbr_functions
+      #|#import test::types
+      #|#ifdef DISTANCE_FOG
+      #|fn apply_fog(
+      #|  fog_params: types::Fog,
+      #|  input_color: vec4<f32>,
+      #|  distance: f32,
+      #|  scattering: vec3<f32>,
+      #|) -> vec4<f32> {
+      #|  return test::fog::linear_fog(
+      #|    fog_params, input_color, distance, scattering,
+      #|  );
+      #|}
+      #|#endif
+      #|
+    ),
+  )
+  register_shader_source(
+    "shader/compile/fog_blocker_root.wgsl",
+    (
+      #|#define_import_path test::root
+      #|#import test::pbr_functions
+      #|#import test::types
+      #|fn fragment(
+      #|  fog_params: types::Fog,
+      #|  input_color: vec4<f32>,
+      #|  distance: f32,
+      #|  scattering: vec3<f32>,
+      #|) -> vec4<f32> {
+      #|  return pbr_functions::apply_fog(
+      #|    fog_params, input_color, distance, scattering,
+      #|  );
+      #|}
+      #|
+    ),
+  )
+  let source = try
     load_preprocessed_wgsl(
       "",
       "shader/compile/fog_blocker_root.wgsl",
-      @hashmap.HashMap([]),
+      @hashmap.HashMap([("DISTANCE_FOG", true)]),
       default_shader_value_defines(),
     )
   catch {
-    err => err.message()
+    err =>
+      fail(
+        "expected qualified module function compose success: \{err.message()}",
+      )
   } noraise {
-    _ => ""
+    source => source
   }
-  debug_inspect(
-    message,
-    content="\"invalid WGSL IR pipeline: IR lowering failed: unsupported WGSL type: test::fog::linear_fog\"",
-  )
+  assert_true(source.contains("fn fragment"))
+  assert_false(source.contains("test::fog::linear_fog"))
 }
diff --git a/mgstudio-engine/shader/compile/pkg.generated.mbti b/mgstudio-engine/shader/compile/pkg.generated.mbti
index ba9ed66a3..c15b268ab 100644
--- a/mgstudio-engine/shader/compile/pkg.generated.mbti
+++ b/mgstudio-engine/shader/compile/pkg.generated.mbti
@@ -2,7 +2,7 @@
 package "Milky2018/mgstudio/shader/compile"
 
 import {
-  "Milky2018/wgsl/common",
+  "Milky2018/moon_wgsl_naga_oil/contract",
   "moonbitlang/core/hashmap",
 }
 
@@ -13,17 +13,17 @@ pub fn clear_registered_shader_sources() -> Unit
 
 pub fn copy_registered_shader_import_module_paths() -> @hashmap.HashMap[String, String]
 
-pub fn default_shader_value_defines() -> @hashmap.HashMap[String, @common.ShaderDefValue]
+pub fn default_shader_value_defines() -> @hashmap.HashMap[String, @contract.ShaderDefValue]
 
 pub fn ensure_startup_shader_sources_once(() -> Unit) -> Unit
 
-pub fn load_preprocessed_wgsl(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @common.ShaderDefValue]) -> String raise ShaderCompileError
+pub fn load_preprocessed_wgsl(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @contract.ShaderDefValue]) -> String raise ShaderCompileError
 
 pub fn load_wgsl_from_sources_required(String, String) -> String raise ShaderCompileError
 
 pub fn normalize_shader_rel_path(String) -> String
 
-pub fn preprocess_shader_source(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @common.ShaderDefValue]) -> String raise ShaderCompileError
+pub fn preprocess_shader_source(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @contract.ShaderDefValue]) -> String raise ShaderCompileError
 
 pub fn register_shader_source(String, String) -> Unit
 
@@ -44,11 +44,11 @@ pub(all) struct ShaderCompileRequest {
   assets_base : String
   target : ShaderCompileTarget
   defines : @hashmap.HashMap[String, Bool]
-  value_defines : @hashmap.HashMap[String, @common.ShaderDefValue]
+  value_defines : @hashmap.HashMap[String, @contract.ShaderDefValue]
 }
 pub fn ShaderCompileRequest::compile(Self) -> String raise ShaderCompileError
-pub fn ShaderCompileRequest::for_path(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @common.ShaderDefValue]) -> Self
-pub fn ShaderCompileRequest::for_source(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @common.ShaderDefValue]) -> Self
+pub fn ShaderCompileRequest::for_path(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @contract.ShaderDefValue]) -> Self
+pub fn ShaderCompileRequest::for_source(String, String, @hashmap.HashMap[String, Bool], @hashmap.HashMap[String, @contract.ShaderDefValue]) -> Self
 
 pub(all) enum ShaderCompileTarget {
   Path(String)
diff --git a/mgstudio-engine/shader/lib.mbt b/mgstudio-engine/shader/lib.mbt
index 1f145b862..c3ab82c64 100644
--- a/mgstudio-engine/shader/lib.mbt
+++ b/mgstudio-engine/shader/lib.mbt
@@ -83,7 +83,7 @@ fn preprocess_shader_imports(
   source : String,
   path : String,
 ) -> (ShaderImport, Array[ShaderImport]) {
-  let metadata = @wgsl_metadata.get_preprocessor_metadata(source) catch {
+  let metadata = @wgsl_common.get_preprocessor_metadata(source) catch {
     _ =>
       @wgsl_common.PreprocessorMetaData::PreprocessorMetaData(
         None,
diff --git a/mgstudio-engine/shader/moon.pkg b/mgstudio-engine/shader/moon.pkg
index e8fe900e0..e11ee6d91 100644
--- a/mgstudio-engine/shader/moon.pkg
+++ b/mgstudio-engine/shader/moon.pkg
@@ -5,9 +5,8 @@ import {
   "moonbitlang/core/encoding/utf8",
   "moonbitlang/core/hashmap",
   "moonbitlang/core/hashset",
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
   "Milky2018/moon_wgsl_naga_oil/compose" @wgsl_compose,
-  "Milky2018/moon_wgsl_naga_oil/metadata" @wgsl_metadata,
   "Milky2018/moon_wesl" @wesl,
 }
 
diff --git a/mgstudio-engine/shader/pkg.generated.mbti b/mgstudio-engine/shader/pkg.generated.mbti
index 9108496f3..09a63e4c3 100644
--- a/mgstudio-engine/shader/pkg.generated.mbti
+++ b/mgstudio-engine/shader/pkg.generated.mbti
@@ -8,7 +8,7 @@ import {
   "Milky2018/mgstudio/image",
   "Milky2018/moon_wesl",
   "Milky2018/moon_wgsl_naga_oil/compose",
-  "Milky2018/wgsl/common",
+  "Milky2018/moon_wgsl_naga_oil/contract",
   "moonbitlang/core/debug",
   "moonbitlang/core/hashmap",
 }
@@ -53,16 +53,16 @@ pub(all) struct ComposableModuleDescriptor {
   file_path : String
   language : ShaderLanguage
   as_name : String?
-  additional_imports : Array[@common.ImportDefinition]
-  shader_defs : @hashmap.HashMap[String, @common.ShaderDefValue]
+  additional_imports : Array[@contract.ImportDefinition]
+  shader_defs : @hashmap.HashMap[String, @contract.ShaderDefValue]
 } derive(Eq)
 
 pub(all) struct NagaModuleDescriptor {
   source : String
   file_path : String
   shader_type : ShaderType
-  shader_defs : @hashmap.HashMap[String, @common.ShaderDefValue]
-  additional_imports : Array[@common.ImportDefinition]
+  shader_defs : @hashmap.HashMap[String, @contract.ShaderDefValue]
+  additional_imports : Array[@contract.ImportDefinition]
 } derive(Eq)
 
 pub(all) struct Shader {
@@ -70,7 +70,7 @@ pub(all) struct Shader {
   source : Source
   import_path : ShaderImport
   imports : Array[ShaderImport]
-  additional_imports : Array[@common.ImportDefinition]
+  additional_imports : Array[@contract.ImportDefinition]
   shader_defs : Array[ShaderDefVal]
   file_dependencies : Array[@asset.Handle[Shader]]
   validate_shader : ValidateShader
diff --git a/mgstudio-engine/shader/shader_cache.mbt b/mgstudio-engine/shader/shader_cache.mbt
index 920af3c51..5864fd9cc 100644
--- a/mgstudio-engine/shader/shader_cache.mbt
+++ b/mgstudio-engine/shader/shader_cache.mbt
@@ -239,18 +239,20 @@ fn[ShaderModule, RenderDevice] shader_cache_compiled_source(
             cache.module_path_to_asset_id,
             cache.shaders,
           )
-          let mut compiler_options = @wesl.CompileOptions::default()
-            .with_imports(true)
-            .with_condcomp(true)
-            .with_lower(true)
+          let features = @wesl.Features::default()
           for shader_def in shader_defs {
             match shader_def {
               Bool(key, value) =>
-                compiler_options = compiler_options.with_feature(key, value)
+                features.set_feature(key, @wesl.Feature::from_bool(value))
               Int(_, _) => ()
               UInt(_, _) => ()
             }
           }
+          let compiler_options = {
+            ..@wesl.CompileOptions::default(),
+            lower: true,
+            features,
+          }
           let compiled = @wesl.compile(
             module_path,
             resolver,
diff --git a/mgstudio-engine/shader/source/lib.mbt b/mgstudio-engine/shader/source/lib.mbt
index 69ced9e40..ac6231776 100644
--- a/mgstudio-engine/shader/source/lib.mbt
+++ b/mgstudio-engine/shader/source/lib.mbt
@@ -15,54 +15,25 @@
 ///|
 pub type ShaderSourceFile = @wgsl_common.WgslSourceFile
 
-///|
-pub type ShaderSourceScanOptions = @wgsl_common.WgslSourceScanOptions
-
 ///|
 let embedded_shader_source_paths : Array[String] = []
 
 ///|
 fn shader_source_collect_import_targets(
   source : String,
-  out : Array[@wgsl_common.WgslImportTarget],
+  out : Array[String],
 ) -> Unit {
-  for
-    item in @wgsl_directive.parse_wgsl_directive_scan_items(
-      source,
-      include_glsl_version=false,
-    ) {
-    match item.kind() {
-      @wgsl_directive.WgslDirectiveScanItemKind::Directive(directive) =>
-        if @wgsl_directive.wgsl_effective_directive_kind(directive) ==
-          @wgsl_ast.WgslDirectiveKind::Import {
-          @wgsl_resolver.collect_wgsl_import_targets(
-            @wgsl_directive.wgsl_effective_directive_tail(directive),
-            "",
-            out,
-          )
-        }
-      _ => ()
-    }
+  let metadata = @wgsl_common.get_preprocessor_metadata(source) catch {
+    _ => return
+  }
+  for import_binding in metadata.imports {
+    out.push(import_binding.definition.import_path)
   }
 }
 
 ///|
 fn shader_source_has_define_import_path(source : String) -> Bool {
-  for
-    item in @wgsl_directive.parse_wgsl_directive_scan_items(
-      source,
-      include_glsl_version=false,
-    ) {
-    match item.kind() {
-      @wgsl_directive.WgslDirectiveScanItemKind::Directive(directive) =>
-        if @wgsl_directive.wgsl_effective_directive_kind(directive) ==
-          @wgsl_ast.WgslDirectiveKind::DefineImportPath {
-          return true
-        }
-      _ => ()
-    }
-  }
-  false
+  @wgsl_common.wgsl_source_define_import_path(source) is Some(_)
 }
 
 ///|
@@ -83,7 +54,7 @@ pub fn clear_embedded_shader_sources() -> Unit {
 
 ///|
 pub fn load_embedded_shader_source(rel_path : String, source : String) -> Unit {
-  let normalized = @wgsl_resolver.normalize_shader_rel_path(rel_path)
+  let normalized = @wgsl_common.normalize_shader_rel_path(rel_path)
   upsert_embedded_shader_source_path(normalized)
   @embedded_asset.register_embedded_asset_virtual_bytes(
     normalized,
@@ -135,9 +106,9 @@ fn shader_source_file_by_rel_path(
   files : Array[ShaderSourceFile],
   rel_path : String,
 ) -> ShaderSourceFile? {
-  let normalized = @wgsl_resolver.normalize_shader_rel_path(rel_path)
+  let normalized = @wgsl_common.normalize_shader_rel_path(rel_path)
   for file in files {
-    if @wgsl_resolver.normalize_shader_rel_path(file.rel_path) == normalized {
+    if @wgsl_common.normalize_shader_rel_path(file.rel_path) == normalized {
       return Some(file)
     }
   }
@@ -168,19 +139,17 @@ fn shader_source_extract_quoted_target_path(raw_path : String) -> String? {
 
 ///|
 fn shader_source_resolve_file_import_target(
-  registry : @wgsl_resolver.WgslSourceRegistry,
+  registry : @wgsl_common.WgslSourceRegistry,
   importer_rel_path : String,
-  target : @wgsl_common.WgslImportTarget,
+  target : String,
 ) -> String? {
   match
     @wgsl_resolver.resolve_wgsl_import_file_path_from_registry(
-      registry,
-      importer_rel_path,
-      target.raw_path,
+      registry, importer_rel_path, target,
     ) {
     Some(path) => Some(path)
     None =>
-      match shader_source_extract_quoted_target_path(target.raw_path) {
+      match shader_source_extract_quoted_target_path(target) {
         Some(path) =>
           @wgsl_resolver.resolve_wgsl_import_file_path_from_registry(
             registry,
@@ -198,7 +167,7 @@ fn shader_source_push_dependency_path(
   pending_paths : Array[String],
   rel_path : String,
 ) -> Unit {
-  let normalized = @wgsl_resolver.normalize_shader_rel_path(rel_path)
+  let normalized = @wgsl_common.normalize_shader_rel_path(rel_path)
   if normalized == "" || included_paths.contains(normalized) {
     return
   }
@@ -209,14 +178,14 @@ fn shader_source_push_dependency_path(
 
 ///|
 fn shader_source_collect_dependency_paths(
-  registry : @wgsl_resolver.WgslSourceRegistry,
+  registry : @wgsl_common.WgslSourceRegistry,
   modules : Map[String, String],
   importer_rel_path : String,
   importer_source : String,
   included_paths : Array[String],
   pending_paths : Array[String],
 ) -> Unit {
-  let targets : Array[@wgsl_common.WgslImportTarget] = []
+  let targets : Array[String] = []
   shader_source_collect_import_targets(importer_source, targets)
   for target in targets {
     match
@@ -230,9 +199,7 @@ fn shader_source_collect_dependency_paths(
       None =>
         match
           @wgsl_resolver.resolve_wgsl_import_module_in_registry(
-            registry,
-            target.raw_path,
-            modules,
+            registry, target, modules,
           ) {
           Some(resolved) =>
             shader_source_push_dependency_path(
@@ -250,9 +217,9 @@ fn shader_source_collect_dependency_paths(
 fn embedded_shader_composer_source_files_for_root(
   root_rel_path : String,
 ) -> Array[ShaderSourceFile] {
-  let root = @wgsl_resolver.normalize_shader_rel_path(root_rel_path)
+  let root = @wgsl_common.normalize_shader_rel_path(root_rel_path)
   let files = embedded_shader_source_files()
-  let registry = @wgsl_resolver.WgslSourceRegistry::default()
+  let registry = @wgsl_common.WgslSourceRegistry::default()
   registry.register_source_files(files)
   let modules = registry.copy_import_module_paths()
   let included_paths : Array[String] = []
@@ -284,7 +251,7 @@ fn embedded_shader_composer_source_files_for_root(
   let composer_files : Array[ShaderSourceFile] = []
   for file in files {
     if included_paths.contains(
-        @wgsl_resolver.normalize_shader_rel_path(file.rel_path),
+        @wgsl_common.normalize_shader_rel_path(file.rel_path),
       ) {
       composer_files.push(file)
     }
@@ -304,10 +271,10 @@ pub fn embedded_shader_composer_source_files(
 
 ///|
 fn upsert_embedded_shader_source_path(rel_path : String) -> Unit {
-  let normalized = @wgsl_resolver.normalize_shader_rel_path(rel_path)
+  let normalized = @wgsl_common.normalize_shader_rel_path(rel_path)
   let paths = embedded_shader_source_paths
   for i in 0..<paths.length() {
-    if @wgsl_resolver.normalize_shader_rel_path(paths[i]) == normalized {
+    if @wgsl_common.normalize_shader_rel_path(paths[i]) == normalized {
       paths[i] = normalized
       return
     }
@@ -320,17 +287,9 @@ pub fn copy_embedded_shader_import_module_paths() -> @hashmap.HashMap[
   String,
   String,
 ] {
-  let registry = @wgsl_resolver.WgslSourceRegistry::default()
+  let registry = @wgsl_common.WgslSourceRegistry::default()
   registry.register_source_files(
     embedded_shader_source_files_with_import_path(),
   )
   @hashmap.HashMap(registry.copy_import_module_paths().to_array())
 }
-
-///|
-pub fn scan_shader_source_files(
-  root : String,
-  options : ShaderSourceScanOptions,
-) -> Array[ShaderSourceFile] raise @fs.IOError {
-  @wgsl_resolver.scan_wgsl_source_files(root, options)
-}
diff --git a/mgstudio-engine/shader/source/moon.pkg b/mgstudio-engine/shader/source/moon.pkg
index 488b4e45b..9606b0081 100644
--- a/mgstudio-engine/shader/source/moon.pkg
+++ b/mgstudio-engine/shader/source/moon.pkg
@@ -1,9 +1,7 @@
 import {
   "Milky2018/mgstudio/embedded_asset",
-  "Milky2018/wgsl/ast" @wgsl_ast,
-  "Milky2018/wgsl/common" @wgsl_common,
+  "Milky2018/moon_wgsl" @wgsl_common,
   "Milky2018/moon_wgsl_naga_oil/compose" @wgsl_compose,
-  "Milky2018/moon_wgsl_naga_oil/directive" @wgsl_directive,
   "Milky2018/moon_wgsl_naga_oil/resolver" @wgsl_resolver,
   "moonbitlang/core/encoding/utf8",
   "moonbitlang/core/hashmap",
diff --git a/mgstudio-engine/shader/source/pkg.generated.mbti b/mgstudio-engine/shader/source/pkg.generated.mbti
index 2fc0d537f..689764151 100644
--- a/mgstudio-engine/shader/source/pkg.generated.mbti
+++ b/mgstudio-engine/shader/source/pkg.generated.mbti
@@ -3,7 +3,8 @@ package "Milky2018/mgstudio/shader/source"
 
 import {
   "Milky2018/moon_wgsl_naga_oil/compose",
-  "Milky2018/wgsl/common",
+  "Milky2018/moon_wgsl_naga_oil/contract",
+  "moonbitlang/core/debug",
   "moonbitlang/core/hashmap",
   "moonbitlang/x/fs",
 }
@@ -13,28 +14,32 @@ pub fn clear_embedded_shader_sources() -> Unit
 
 pub fn copy_embedded_shader_import_module_paths() -> @hashmap.HashMap[String, String]
 
-pub fn embedded_shader_composer_source_files(String?) -> Array[@common.WgslSourceFile]
+pub fn embedded_shader_composer_source_files(String?) -> Array[@contract.WgslSourceFile]
 
 pub fn embedded_shader_source(String) -> String?
 
-pub fn embedded_shader_source_files() -> Array[@common.WgslSourceFile]
+pub fn embedded_shader_source_files() -> Array[@contract.WgslSourceFile]
 
 pub fn embedded_shader_source_required(String) -> String raise @compose.ComposerError
 
 pub fn load_embedded_shader_source(String, String) -> Unit
 
-pub fn load_embedded_shader_source_files(Array[@common.WgslSourceFile]) -> Unit
+pub fn load_embedded_shader_source_files(Array[@contract.WgslSourceFile]) -> Unit
 
-pub fn scan_shader_source_files(String, @common.WgslSourceScanOptions) -> Array[@common.WgslSourceFile] raise @fs.IOError
+pub fn scan_shader_source_files(String, ShaderSourceScanOptions) -> Array[@contract.WgslSourceFile] raise @fs.IOError
 
 // Errors
 
 // Types and methods
+pub(all) struct ShaderSourceScanOptions {
+  recursive : Bool
+  extensions : Array[String]
+  exclude_prefixes : Array[String]
+} derive(Eq, @debug.Debug)
+pub fn ShaderSourceScanOptions::default() -> Self
 
 // Type aliases
-pub using @common {type WgslSourceFile as ShaderSourceFile}
-
-pub using @common {type WgslSourceScanOptions as ShaderSourceScanOptions}
+pub using @contract {type WgslSourceFile as ShaderSourceFile}
 
 // Traits
 
diff --git a/mgstudio-engine/shader/source/scan.mbt b/mgstudio-engine/shader/source/scan.mbt
new file mode 100644
index 000000000..8ad12ebde
--- /dev/null
+++ b/mgstudio-engine/shader/source/scan.mbt
@@ -0,0 +1,172 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+pub(all) struct ShaderSourceScanOptions {
+  recursive : Bool
+  extensions : Array[String]
+  exclude_prefixes : Array[String]
+} derive(Eq, Debug)
+
+///|
+pub fn ShaderSourceScanOptions::default() -> ShaderSourceScanOptions {
+  { recursive: true, extensions: [".wgsl"], exclude_prefixes: [] }
+}
+
+///|
+fn normalize_scan_path(path : String) -> String {
+  let trimmed = path.trim().to_owned()
+  if trimmed == "" {
+    return ""
+  }
+  let parts : Array[String] = []
+  let mut start = 0
+  for i in 0..<trimmed.length() {
+    if trimmed.code_unit_at(i).to_int() == 92 {
+      parts.push(trimmed[start:i].to_owned())
+      start = i + 1
+    }
+  }
+  parts.push(trimmed[start:trimmed.length()].to_owned())
+  parts.join("/")
+}
+
+///|
+fn join_scan_path(prefix : String, path : String) -> String {
+  let lhs = normalize_scan_path(prefix)
+  let rhs = normalize_scan_path(path)
+  if lhs == "" {
+    return rhs
+  }
+  if rhs == "" {
+    return lhs
+  }
+  "\{lhs}/\{rhs}"
+}
+
+///|
+fn normalize_scan_extensions(extensions : Array[String]) -> Array[String] {
+  let normalized : Array[String] = []
+  for extension in extensions {
+    let trimmed = extension.trim().to_owned()
+    if trimmed == "" {
+      continue
+    }
+    normalized.push(
+      if trimmed.has_prefix(".") {
+        trimmed
+      } else {
+        ".\{trimmed}"
+      },
+    )
+  }
+  normalized
+}
+
+///|
+fn scan_path_is_excluded(
+  rel_path : String,
+  exclude_prefixes : Array[String],
+) -> Bool {
+  let normalized_rel_path = @wgsl_resolver.normalize_shader_rel_path(rel_path)
+  for prefix in exclude_prefixes {
+    let normalized_prefix = @wgsl_resolver.normalize_shader_rel_path(
+      normalize_scan_path(prefix),
+    )
+    if normalized_prefix != "" &&
+      (
+        normalized_rel_path == normalized_prefix ||
+        normalized_rel_path.has_prefix("\{normalized_prefix}/")
+      ) {
+      return true
+    }
+  }
+  false
+}
+
+///|
+fn scan_path_matches_extension(
+  rel_path : String,
+  extensions : Array[String],
+) -> Bool {
+  if extensions.length() == 0 {
+    return true
+  }
+  for extension in extensions {
+    if rel_path.has_suffix(extension) {
+      return true
+    }
+  }
+  false
+}
+
+///|
+fn collect_source_files(
+  fs_path : String,
+  rel_prefix : String,
+  options : ShaderSourceScanOptions,
+  normalized_extensions : Array[String],
+  out : Array[ShaderSourceFile],
+) -> Unit raise @fs.IOError {
+  let entries = @fs.read_dir(fs_path)
+  entries.sort()
+  for entry_name in entries {
+    let entry_rel_path = if rel_prefix == "" {
+      normalize_scan_path(entry_name)
+    } else {
+      join_scan_path(rel_prefix, entry_name)
+    }
+    if scan_path_is_excluded(entry_rel_path, options.exclude_prefixes) {
+      continue
+    }
+    let entry_fs_path = join_scan_path(fs_path, entry_name)
+    if @fs.is_dir(entry_fs_path) {
+      if options.recursive {
+        collect_source_files(
+          entry_fs_path, entry_rel_path, options, normalized_extensions, out,
+        )
+      }
+      continue
+    }
+    if !@fs.is_file(entry_fs_path) ||
+      !scan_path_matches_extension(
+        @wgsl_resolver.normalize_shader_rel_path(entry_rel_path),
+        normalized_extensions,
+      ) {
+      continue
+    }
+    out.push({
+      rel_path: @wgsl_resolver.normalize_shader_rel_path(entry_rel_path),
+      source: @fs.read_file_to_string(entry_fs_path),
+    })
+  }
+}
+
+///|
+pub fn scan_shader_source_files(
+  root : String,
+  options : ShaderSourceScanOptions,
+) -> Array[ShaderSourceFile] raise @fs.IOError {
+  let normalized_root = normalize_scan_path(root)
+  let scan_root = if normalized_root == "" { "." } else { normalized_root }
+  let files : Array[ShaderSourceFile] = []
+  collect_source_files(
+    scan_root,
+    "",
+    options,
+    normalize_scan_extensions(options.extensions),
+    files,
+  )
+  files
+}
diff --git a/mgstudio-engine/shader/source/scan_test.mbt b/mgstudio-engine/shader/source/scan_test.mbt
new file mode 100644
index 000000000..7c46132c0
--- /dev/null
+++ b/mgstudio-engine/shader/source/scan_test.mbt
@@ -0,0 +1,25 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "shader source: 0.17 filesystem adapter preserves scan behavior" {
+  let files = try! scan_shader_source_files("shader/source", {
+    ..ShaderSourceScanOptions::default(),
+    recursive: false,
+    extensions: ["mbt"],
+  })
+  let paths = files.map(fn(file) { file.rel_path })
+  assert_true(paths.contains("lib.mbt"))
+  assert_true(paths.contains("scan.mbt"))
+}
diff --git a/mgstudio-engine/sprite/bounds_wbtest.mbt b/mgstudio-engine/sprite/bounds_wbtest.mbt
new file mode 100644
index 000000000..d6e9c3c36
--- /dev/null
+++ b/mgstudio-engine/sprite/bounds_wbtest.mbt
@@ -0,0 +1,101 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "sprite bounds: new Sprite with Mesh2d still receives the sprite Aabb" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let mut app = @app.App::new(world).add_plugins(SpritePlugin::SpritePlugin())
+  let atlases : @asset.Assets[@asset.TextureAtlasLayout] = @asset.Assets::new()
+  world.insert_resource(@asset.assets_resource_key(), atlases)
+  let meshes : @asset.Assets[@mesh.Mesh] = @asset.Assets::new()
+  world.insert_resource(@asset.assets_resource_key(), meshes)
+  let entity = world.spawn()
+  try! world.set_by_key(
+    entity,
+    ecs_key_sprite,
+    Sprite::sized(@math.Vec2::new(10.0F, 6.0F)),
+  )
+  try! world.set_by_key(entity, ecs_key_anchor, Anchor::center())
+  try! world.set_by_key(
+    entity,
+    @mesh.ecs_key_mesh2d,
+    @mesh.Mesh2d::new(@asset.Handle::new(999)),
+  )
+
+  app = app.update()
+
+  guard (try! world.get_by_key(entity, @camera_primitives.ecs_key_aabb))
+    is Some(aabb) else {
+    debug_inspect(false, content="true")
+    return
+  }
+  let center = aabb.center()
+  let half_size = aabb.half_size()
+  debug_inspect(
+    center.x == 0.0F &&
+    center.y == 0.0F &&
+    center.z == 0.0F &&
+    half_size.x == 5.0F &&
+    half_size.y == 3.0F &&
+    half_size.z == 0.0F,
+    content="true",
+  )
+}
+
+///|
+test "sprite bounds: equal Aabb replacement preserves change ticks" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let mut app = @app.App::new(world).add_plugins(SpritePlugin::SpritePlugin())
+  let atlases : @asset.Assets[@asset.TextureAtlasLayout] = @asset.Assets::new()
+  world.insert_resource(@asset.assets_resource_key(), atlases)
+  let meshes : @asset.Assets[@mesh.Mesh] = @asset.Assets::new()
+  world.insert_resource(@asset.assets_resource_key(), meshes)
+  let entity = world.spawn()
+  try! world.set_by_key(
+    entity,
+    ecs_key_sprite,
+    Sprite::sized(@math.Vec2::new(4.0F, 6.0F)),
+  )
+  try! world.set_by_key(entity, ecs_key_anchor, Anchor::center())
+  let replace_with_equal_sprite = Ref(false)
+  app = app.add_systems(
+    @app.Update,
+    @app.system(fn(world : @ecs.World) {
+      if replace_with_equal_sprite.val {
+        try! (world.replace(
+          entity,
+          ecs_key_sprite,
+          Sprite::sized(@math.Vec2::new(4.0F, 6.0F)),
+        )
+        |> ignore)
+        replace_with_equal_sprite.val = false
+      }
+    }),
+  )
+
+  app = app.update()
+  let before = world.read_change_tick()
+  replace_with_equal_sprite.val = true
+  app = app.update()
+  let after = world.read_change_tick()
+  let changed = world
+    .changed_components(
+      @camera_primitives.ecs_key_aabb,
+      @core.SystemTicks::new(before, after),
+    )
+    .read()
+  debug_inspect(changed.contains(entity), content="false")
+}
diff --git a/mgstudio-engine/sprite/computed_slices.mbt b/mgstudio-engine/sprite/computed_slices.mbt
index 09fe7e3f4..dc5afc384 100644
--- a/mgstudio-engine/sprite/computed_slices.mbt
+++ b/mgstudio-engine/sprite/computed_slices.mbt
@@ -238,7 +238,7 @@ pub let ecs_key_computed_texture_slices : @ecs.ComponentKey[
 )
 
 ///|
-impl @ecs.Component for ComputedTextureSlices with fn component() {
+pub impl @ecs.Component for ComputedTextureSlices with fn component() {
   ecs_key_computed_texture_slices
 }
 
@@ -294,7 +294,7 @@ fn compute_sprite_slices(
 ) -> ComputedTextureSlices? {
   let (image_size, texture_rect) = match sprite.texture_atlas {
     Some(atlas) =>
-      match texture_atlas_layouts.get(atlas.layout()) {
+      match atlas.layout_asset(texture_atlas_layouts) {
         Some(layout) =>
           match atlas.texture_rect(texture_atlas_layouts) {
             Some(rect) => (layout.size().to_vec2(), rect.as_rect())
@@ -379,12 +379,15 @@ pub type ComputedSlicesAssetParams = @app.ParamSet2[
 
 ///|
 pub type ComputedSlicesChangedSpritesQuery = @ecs.Query[
-  @ecs.Read[Sprite],
+  @ecs.ReadValue[Sprite],
   @ecs.Changed[Sprite],
 ]
 
 ///|
-pub type ComputedSlicesAllSpritesQuery = @ecs.Query[@ecs.Read[Sprite], @ecs.All]
+pub type ComputedSlicesAllSpritesQuery = @ecs.Query[
+  @ecs.ReadValue[Sprite],
+  @ecs.All,
+]
 
 ///|
 pub type ComputedSlicesAssetEventParams = @app.ParamSet2[
@@ -400,15 +403,36 @@ pub fn compute_slices_on_sprite_change_system(
 ) -> Unit {
   let images = assets.p0().get()
   let texture_atlas_layouts = assets.p1().get()
-  try! changed_sprites.view(fn(entity, sprite_comp) {
-    let sprite = sprite_comp.value()
-    if !sprite.image_mode.uses_slices() {
-      return
-    }
-    insert_computed_texture_slices_for_sprite(
-      commands, entity, sprite, images, texture_atlas_layouts,
-    )
+  let used_batch = try! changed_sprites.try_for_each_filtered_table(fn(
+    batch,
+    rows,
+  ) {
+    let sprites = batch.read(ecs_key_sprite).unwrap()
+    try! rows.for_each(fn(row_index) {
+      let sprite = sprites.value(row_index)
+      if !sprite.image_mode.uses_slices() {
+        return
+      }
+      insert_computed_texture_slices_for_sprite(
+        commands,
+        batch.entity(row_index),
+        sprite,
+        images,
+        texture_atlas_layouts,
+      )
+    })
   })
+  if !used_batch {
+    try! changed_sprites.view(fn(entity, sprite_comp) {
+      let sprite = sprite_comp.value()
+      if !sprite.image_mode.uses_slices() {
+        return
+      }
+      insert_computed_texture_slices_for_sprite(
+        commands, entity, sprite, images, texture_atlas_layouts,
+      )
+    })
+  }
 }
 
 ///|
diff --git a/mgstudio-engine/sprite/ecs_keys.mbt b/mgstudio-engine/sprite/ecs_keys.mbt
index 5eebcfe51..0dbe196f2 100644
--- a/mgstudio-engine/sprite/ecs_keys.mbt
+++ b/mgstudio-engine/sprite/ecs_keys.mbt
@@ -126,7 +126,7 @@ fn encode_image_handle(handle : @asset.Handle[@asset.Image]) -> Json {
 
 ///|
 fn encode_texture_atlas(texture_atlas : @asset.TextureAtlas) -> Json {
-  (texture_atlas.layout.id(), texture_atlas.index).to_json()
+  (texture_atlas.layout().id(), texture_atlas.index).to_json()
 }
 
 ///|
diff --git a/mgstudio-engine/sprite/gizmo.mbt b/mgstudio-engine/sprite/gizmo.mbt
index f48679892..d084c89db 100644
--- a/mgstudio-engine/sprite/gizmo.mbt
+++ b/mgstudio-engine/sprite/gizmo.mbt
@@ -125,7 +125,7 @@ fn[Config : GizmoConfigGroup + Default] gizmos_from_world(
   let store : GizmoConfigStore? = world.get_resource(
     GizmoConfigStore::resource(),
   )
-  let group = Config::default()
+  let group : Config = Default::default()
   let store = match store {
     Some(store) => store
     None => raise @ecs.Invalid("Missing resource for system parameter")
diff --git a/mgstudio-engine/sprite/lib.mbt b/mgstudio-engine/sprite/lib.mbt
index c059f2e00..5294c8e4b 100644
--- a/mgstudio-engine/sprite/lib.mbt
+++ b/mgstudio-engine/sprite/lib.mbt
@@ -28,25 +28,6 @@ let ecs_res_key_sprite_plugin_marker : @ecs.ResourceKey[SpritePluginMarker] = @e
   debug_name="mgstudio.sprite.SpritePluginMarker",
 )
 
-///|
-let sprite_bounds_initialized_worlds : @hashset.HashSet[Int] = @hashset.HashSet([],
-)
-
-///|
-fn sprite_entity_key(entity : @core.Entity) -> UInt64 {
-  let hi = entity.id.reinterpret_as_uint().to_uint64()
-  let lo = entity.generation.reinterpret_as_uint().to_uint64() & 0xFFFF_FFFFUL
-  (hi << 32) | lo
-}
-
-///|
-fn sprite_insert_entity_key(
-  set : @hashset.HashSet[UInt64],
-  entity : @core.Entity,
-) -> Unit {
-  set.add(sprite_entity_key(entity))
-}
-
 ///|
 fn sprite_mesh2d_aabb(mesh2d : Mesh2d) -> @camera_primitives.Aabb? {
   guard render_mesh_asset_get(mesh2d.mesh()) is Some(mesh_asset) else {
@@ -123,9 +104,13 @@ fn sprite_sprite_aabb(
   let half_x = size.x * 0.5F
   let half_y = size.y * 0.5F
   Some(
-    @camera_primitives.Aabb::from_min_max(
-      @math.Vec3::new(center_x - half_x, center_y - half_y, 0.0F),
-      @math.Vec3::new(center_x + half_x, center_y + half_y, 0.0F),
+    @camera_primitives.Aabb::from_min_max_xyz(
+      center_x - half_x,
+      center_y - half_y,
+      0.0F,
+      center_x + half_x,
+      center_y + half_y,
+      0.0F,
     ),
   )
 }
@@ -145,15 +130,27 @@ fn sprite_mesh_aabb(
   let half_x = size.x * 0.5F
   let half_y = size.y * 0.5F
   Some(
-    @camera_primitives.Aabb::from_min_max(
-      @math.Vec3::new(center_x - half_x, center_y - half_y, 0.0F),
-      @math.Vec3::new(center_x + half_x, center_y + half_y, 0.0F),
+    @camera_primitives.Aabb::from_min_max_xyz(
+      center_x - half_x,
+      center_y - half_y,
+      0.0F,
+      center_x + half_x,
+      center_y + half_y,
+      0.0F,
     ),
   )
 }
 
 ///|
-fn sprite_set_or_replace_aabb(
+fn sprite_aabbs_equal(
+  current : @camera_primitives.Aabb,
+  next : @camera_primitives.Aabb,
+) -> Bool {
+  current.equals(next)
+}
+
+///|
+fn sprite_insert_or_replace_new_aabb(
   world : @ecs.World,
   entity : @core.Entity,
   aabb : @camera_primitives.Aabb,
@@ -166,157 +163,420 @@ fn sprite_set_or_replace_aabb(
 }
 
 ///|
-fn sprite_calculate_bounds_2d(world : @ecs.World) -> Unit {
-  let has_mesh2d = world.component_count(@mesh.ecs_key_mesh2d) > 0
-  let has_sprite = world.component_count(ecs_key_sprite) > 0
-  let has_sprite_mesh = world.component_count(ecs_key_sprite_mesh) > 0
-  if !has_mesh2d && !has_sprite && !has_sprite_mesh {
-    return
-  }
-  let world_id = world.world_id()
-  let first_run = !sprite_bounds_initialized_worlds.contains(world_id)
-  if first_run {
-    sprite_bounds_initialized_worlds.add(world_id)
-  }
-  let pending_aabbs : Array[(@core.Entity, @camera_primitives.Aabb)] = []
-  let changed_mesh2d_entities : @hashset.HashSet[UInt64] = @hashset.HashSet([])
-  let changed_sprite_or_anchor_entities : @hashset.HashSet[UInt64] = @hashset.HashSet([],
-  )
-  let changed_sprite_mesh_or_anchor_entities : @hashset.HashSet[UInt64] = @hashset.HashSet([],
+type SpriteNewMeshAabbQuery = @ecs.Query[
+  @ecs.Read[Mesh2d],
+  (
+    (
+      (
+        @ecs.Without[@camera_primitives.Aabb],
+        @ecs.Without[@visibility.NoFrustumCulling],
+      ),
+      @ecs.Without[@visibility.NoAutoAabb],
+    ),
+    @ecs.Without[SpriteMesh],
+  ),
+]
+
+///|
+type SpriteUpdateMeshAabbQuery = @ecs.Query[
+  (@ecs.Read[Mesh2d], @ecs.Write[@camera_primitives.Aabb]),
+  (
+    (
+      (@ecs.Changed[Mesh2d], @ecs.Without[@visibility.NoFrustumCulling]),
+      @ecs.Without[@visibility.NoAutoAabb],
+    ),
+    (@ecs.Without[SpriteMesh], @ecs.Without[Sprite]),
+  ),
+]
+
+///|
+type SpriteNewAabbQuery = @ecs.Query[
+  (@ecs.Read[Sprite], @ecs.Read[Anchor]),
+  (
+    (
+      @ecs.Without[@camera_primitives.Aabb],
+      @ecs.Without[@visibility.NoFrustumCulling],
+    ),
+    @ecs.Without[@visibility.NoAutoAabb],
+  ),
+]
+
+///|
+type SpriteUpdateAabbQuery = @ecs.Query[
+  ((@ecs.Read[Sprite], @ecs.Write[@camera_primitives.Aabb]), @ecs.Read[Anchor]),
+  (
+    (
+      @ecs.Or[(@ecs.Changed[Sprite], @ecs.Changed[Anchor])],
+      @ecs.Without[@visibility.NoFrustumCulling],
+    ),
+    (@ecs.Without[@visibility.NoAutoAabb], @ecs.Without[Mesh2d]),
+  ),
+]
+
+///|
+type SpriteMeshNewAabbQuery = @ecs.Query[
+  (@ecs.Read[SpriteMesh], @ecs.Read[Anchor]),
+  (
+    (
+      @ecs.Without[@camera_primitives.Aabb],
+      @ecs.Without[@visibility.NoFrustumCulling],
+    ),
+    @ecs.Without[@visibility.NoAutoAabb],
+  ),
+]
+
+///|
+type SpriteMeshUpdateAabbQuery = @ecs.Query[
+  (
+    (@ecs.Read[SpriteMesh], @ecs.Write[@camera_primitives.Aabb]),
+    @ecs.Read[Anchor],
+  ),
+  (
+    (
+      @ecs.Or[(@ecs.Changed[SpriteMesh], @ecs.Changed[Anchor])],
+      @ecs.Without[@visibility.NoFrustumCulling],
+    ),
+    @ecs.Without[@visibility.NoAutoAabb],
+  ),
+]
+
+///|
+fn sprite_collect_new_mesh_aabbs(
+  world : @ecs.World,
+  pending_aabbs : Array[(@core.Entity, @camera_primitives.Aabb)],
+) -> Unit {
+  let query : SpriteNewMeshAabbQuery = @ecs.query_filtered(
+    world,
+    (
+      (
+        (
+          @ecs.Without::new(@camera_primitives.ecs_key_aabb),
+          @ecs.Without::new(@visibility.ecs_key_no_frustum_culling),
+        ),
+        @ecs.Without::new(@visibility.ecs_key_no_auto_aabb),
+      ),
+      @ecs.Without::new(ecs_key_sprite_mesh),
+    ),
   )
-  if !first_run {
-    let tick = world.get_tick_context().ticks()
-    for entity in world.added_components(@mesh.ecs_key_mesh2d, tick).read() {
-      sprite_insert_entity_key(changed_mesh2d_entities, entity)
-    }
-    for entity in world.changed_components(@mesh.ecs_key_mesh2d, tick).read() {
-      sprite_insert_entity_key(changed_mesh2d_entities, entity)
-    }
-    for entity in world.added_components(ecs_key_sprite, tick).read() {
-      sprite_insert_entity_key(changed_sprite_or_anchor_entities, entity)
-    }
-    for entity in world.changed_components(ecs_key_sprite, tick).read() {
-      sprite_insert_entity_key(changed_sprite_or_anchor_entities, entity)
-    }
-    for entity in world.added_components(ecs_key_anchor, tick).read() {
-      sprite_insert_entity_key(changed_sprite_or_anchor_entities, entity)
-      sprite_insert_entity_key(changed_sprite_mesh_or_anchor_entities, entity)
-    }
-    for entity in world.changed_components(ecs_key_anchor, tick).read() {
-      sprite_insert_entity_key(changed_sprite_or_anchor_entities, entity)
-      sprite_insert_entity_key(changed_sprite_mesh_or_anchor_entities, entity)
-    }
-    for entity in world.added_components(ecs_key_sprite_mesh, tick).read() {
-      sprite_insert_entity_key(changed_sprite_mesh_or_anchor_entities, entity)
-    }
-    for entity in world.changed_components(ecs_key_sprite_mesh, tick).read() {
-      sprite_insert_entity_key(changed_sprite_mesh_or_anchor_entities, entity)
+  try! query.for_each_table(fn(batch) {
+    let mesh2d = batch.read(@mesh.ecs_key_mesh2d).unwrap()
+    for row_index in 0..<batch.length() {
+      if sprite_mesh2d_aabb(mesh2d.value(row_index)) is Some(aabb) {
+        pending_aabbs.push((batch.entity(row_index), aabb))
+      }
     }
-  }
+  })
+}
 
-  if has_mesh2d {
-    let mesh2d_query : @ecs.Query[@ecs.Read[Mesh2d], @ecs.All] = @ecs.query(
-      world,
-    )
-    try! mesh2d_query.view(fn(entity, mesh2d_comp) {
-      if (try! world.contains_by_key(
-          entity, @visibility.ecs_key_no_frustum_culling,
-        )) {
-        return
-      }
-      if (try! world.contains_by_key(entity, @visibility.ecs_key_no_auto_aabb)) {
-        return
-      }
-      let has_aabb = try! world.contains_by_key(
-        entity, @camera_primitives.ecs_key_aabb,
-      )
-      if !first_run &&
-        has_aabb &&
-        !changed_mesh2d_entities.contains(sprite_entity_key(entity)) {
-        return
+///|
+fn sprite_update_mesh_aabbs(world : @ecs.World) -> Int {
+  let query : SpriteUpdateMeshAabbQuery = @ecs.query_filtered(
+    world,
+    (
+      (
+        (
+          @ecs.Changed::new(@mesh.ecs_key_mesh2d),
+          @ecs.Without::new(@visibility.ecs_key_no_frustum_culling),
+        ),
+        @ecs.Without::new(@visibility.ecs_key_no_auto_aabb),
+      ),
+      (
+        @ecs.Without::new(ecs_key_sprite_mesh),
+        @ecs.Without::new(ecs_key_sprite),
+      ),
+    ),
+  )
+  let changed_count = Ref(0)
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let mesh2d = batch.read(@mesh.ecs_key_mesh2d).unwrap()
+    let aabbs = batch.write(@camera_primitives.ecs_key_aabb).unwrap()
+    try! rows.for_each(fn(row_index) {
+      changed_count.val = changed_count.val + 1
+      if sprite_mesh2d_aabb(mesh2d.value(row_index)) is Some(next) &&
+        !sprite_aabbs_equal(aabbs.peek(row_index), next) {
+        aabbs.set(row_index, next)
       }
-      if sprite_mesh2d_aabb(mesh2d_comp.value()) is Some(aabb) {
-        pending_aabbs.push((entity, aabb))
+    })
+  })
+  if !used_batch {
+    try! query.for_each(fn(_entity, data) {
+      changed_count.val = changed_count.val + 1
+      let (mesh2d, aabb) = data
+      if sprite_mesh2d_aabb(mesh2d.value()) is Some(next) &&
+        !sprite_aabbs_equal(aabb.peek(), next) {
+        aabb.set(next)
       }
     })
   }
+  changed_count.val
+}
 
-  if has_sprite {
-    let atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout] = @asset.asset_assets_or_abort()
-    let sprite_query : @ecs.Query[
-      (@ecs.Read[Sprite], @ecs.Read[Anchor]),
-      @ecs.All,
-    ] = @ecs.query(world)
-    try! sprite_query.view(fn(entity, data) {
-      if (try! world.contains_by_key(entity, @mesh.ecs_key_mesh2d)) {
-        return
-      }
-      if (try! world.contains_by_key(
-          entity, @visibility.ecs_key_no_frustum_culling,
-        )) {
-        return
-      }
-      if (try! world.contains_by_key(entity, @visibility.ecs_key_no_auto_aabb)) {
-        return
-      }
-      let has_aabb = try! world.contains_by_key(
-        entity, @camera_primitives.ecs_key_aabb,
-      )
-      if !first_run &&
-        has_aabb &&
-        !changed_sprite_or_anchor_entities.contains(sprite_entity_key(entity)) {
-        return
-      }
-      let (sprite_comp, anchor_comp) = data
+///|
+fn sprite_collect_new_sprite_aabbs(
+  world : @ecs.World,
+  atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout],
+  pending_aabbs : Array[(@core.Entity, @camera_primitives.Aabb)],
+) -> Unit {
+  let query : SpriteNewAabbQuery = @ecs.query_filtered(
+    world,
+    (
+      (
+        @ecs.Without::new(@camera_primitives.ecs_key_aabb),
+        @ecs.Without::new(@visibility.ecs_key_no_frustum_culling),
+      ),
+      @ecs.Without::new(@visibility.ecs_key_no_auto_aabb),
+    ),
+  )
+  try! query.for_each_table(fn(batch) {
+    let sprites = batch.read(ecs_key_sprite).unwrap()
+    let anchors = batch.read(ecs_key_anchor).unwrap()
+    for row_index in 0..<batch.length() {
       if sprite_sprite_aabb(
-          sprite_comp.value(),
-          anchor_comp.value(),
+          sprites.value(row_index),
+          anchors.value(row_index),
           atlas_layout_assets,
         )
         is Some(aabb) {
-        pending_aabbs.push((entity, aabb))
+        pending_aabbs.push((batch.entity(row_index), aabb))
+      }
+    }
+  })
+}
+
+///|
+fn sprite_update_sprite_aabbs(
+  world : @ecs.World,
+  atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout],
+) -> Int {
+  let query : SpriteUpdateAabbQuery = @ecs.query_filtered(
+    world,
+    (
+      (
+        @ecs.Or::new(
+          (@ecs.Changed::new(ecs_key_sprite), @ecs.Changed::new(ecs_key_anchor)),
+        ),
+        @ecs.Without::new(@visibility.ecs_key_no_frustum_culling),
+      ),
+      (
+        @ecs.Without::new(@visibility.ecs_key_no_auto_aabb),
+        @ecs.Without::new(@mesh.ecs_key_mesh2d),
+      ),
+    ),
+  )
+  let changed_count = Ref(0)
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let sprites = batch.read(ecs_key_sprite).unwrap()
+    let aabbs = batch.write(@camera_primitives.ecs_key_aabb).unwrap()
+    let anchors = batch.read(ecs_key_anchor).unwrap()
+    rows.with_read_values(sprites, fn(sprite_values) {
+      rows.with_read_values(anchors, fn(anchor_values) {
+        rows.with_write_values(aabbs, fn(aabb_values) {
+          try! rows.for_each(fn(row_index) {
+            changed_count.val = changed_count.val + 1
+            if sprite_sprite_aabb(
+                sprite_values[row_index],
+                anchor_values[row_index],
+                atlas_layout_assets,
+              )
+              is Some(next) &&
+              !sprite_aabbs_equal(aabb_values[row_index], next) {
+              aabbs.set(row_index, next)
+            }
+          })
+        })
+      })
+    })
+  })
+  if !used_batch {
+    try! query.for_each(fn(_entity, data) {
+      changed_count.val = changed_count.val + 1
+      let ((sprite, aabb), anchor) = data
+      if sprite_sprite_aabb(sprite.value(), anchor.value(), atlas_layout_assets)
+        is Some(next) &&
+        !sprite_aabbs_equal(aabb.peek(), next) {
+        aabb.set(next)
       }
     })
   }
-  if has_sprite_mesh {
-    let atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout] = @asset.asset_assets_or_abort()
-    let sprite_mesh_query : @ecs.Query[
-      (@ecs.Read[SpriteMesh], @ecs.Read[Anchor]),
-      @ecs.All,
-    ] = @ecs.query(world)
-    try! sprite_mesh_query.view(fn(entity, data) {
-      if (try! world.contains_by_key(
-          entity, @visibility.ecs_key_no_frustum_culling,
-        )) {
-        return
-      }
-      if (try! world.contains_by_key(entity, @visibility.ecs_key_no_auto_aabb)) {
-        return
+  changed_count.val
+}
+
+///|
+fn sprite_collect_new_sprite_mesh_aabbs(
+  world : @ecs.World,
+  atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout],
+  pending_aabbs : Array[(@core.Entity, @camera_primitives.Aabb)],
+) -> Unit {
+  let query : SpriteMeshNewAabbQuery = @ecs.query_filtered(
+    world,
+    (
+      (
+        @ecs.Without::new(@camera_primitives.ecs_key_aabb),
+        @ecs.Without::new(@visibility.ecs_key_no_frustum_culling),
+      ),
+      @ecs.Without::new(@visibility.ecs_key_no_auto_aabb),
+    ),
+  )
+  try! query.for_each_table(fn(batch) {
+    let sprite_meshes = batch.read(ecs_key_sprite_mesh).unwrap()
+    let anchors = batch.read(ecs_key_anchor).unwrap()
+    for row_index in 0..<batch.length() {
+      if sprite_mesh_aabb(
+          sprite_meshes.value(row_index),
+          anchors.value(row_index),
+          atlas_layout_assets,
+        )
+        is Some(aabb) {
+        pending_aabbs.push((batch.entity(row_index), aabb))
       }
-      let has_aabb = try! world.contains_by_key(
-        entity, @camera_primitives.ecs_key_aabb,
-      )
-      if !first_run &&
-        has_aabb &&
-        !changed_sprite_mesh_or_anchor_entities.contains(
-          sprite_entity_key(entity),
-        ) {
-        return
+    }
+  })
+}
+
+///|
+fn sprite_update_sprite_mesh_aabbs(
+  world : @ecs.World,
+  atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout],
+) -> Int {
+  let query : SpriteMeshUpdateAabbQuery = @ecs.query_filtered(
+    world,
+    (
+      (
+        @ecs.Or::new(
+          (
+            @ecs.Changed::new(ecs_key_sprite_mesh),
+            @ecs.Changed::new(ecs_key_anchor),
+          ),
+        ),
+        @ecs.Without::new(@visibility.ecs_key_no_frustum_culling),
+      ),
+      @ecs.Without::new(@visibility.ecs_key_no_auto_aabb),
+    ),
+  )
+  let changed_count = Ref(0)
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let sprite_meshes = batch.read(ecs_key_sprite_mesh).unwrap()
+    let aabbs = batch.write(@camera_primitives.ecs_key_aabb).unwrap()
+    let anchors = batch.read(ecs_key_anchor).unwrap()
+    try! rows.for_each(fn(row_index) {
+      changed_count.val = changed_count.val + 1
+      if sprite_mesh_aabb(
+          sprite_meshes.value(row_index),
+          anchors.value(row_index),
+          atlas_layout_assets,
+        )
+        is Some(next) &&
+        !sprite_aabbs_equal(aabbs.peek(row_index), next) {
+        aabbs.set(row_index, next)
       }
-      let (sprite_mesh_comp, anchor_comp) = data
+    })
+  })
+  if !used_batch {
+    try! query.for_each(fn(_entity, data) {
+      changed_count.val = changed_count.val + 1
+      let ((sprite_mesh, aabb), anchor) = data
       if sprite_mesh_aabb(
-          sprite_mesh_comp.value(),
-          anchor_comp.value(),
+          sprite_mesh.value(),
+          anchor.value(),
           atlas_layout_assets,
         )
-        is Some(aabb) {
-        pending_aabbs.push((entity, aabb))
+        is Some(next) &&
+        !sprite_aabbs_equal(aabb.peek(), next) {
+        aabb.set(next)
       }
     })
   }
+  changed_count.val
+}
+
+///|
+fn sprite_calculate_bounds_2d(world : @ecs.World) -> Unit {
+  let has_mesh2d = world.component_count(@mesh.ecs_key_mesh2d) > 0
+  let has_sprite = world.component_count(ecs_key_sprite) > 0
+  let has_sprite_mesh = world.component_count(ecs_key_sprite_mesh) > 0
+  if !has_mesh2d && !has_sprite && !has_sprite_mesh {
+    return
+  }
+  let pending_aabbs : Array[(@core.Entity, @camera_primitives.Aabb)] = []
+  let mut changed_mesh2d_count = 0
+  let mut changed_sprite_count = 0
+  let mut changed_sprite_mesh_count = 0
+
+  let scan_mesh2d_trace_start_us = @app.timeline_trace_begin_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.scan_mesh2d",
+  )
+  if has_mesh2d {
+    sprite_collect_new_mesh_aabbs(world, pending_aabbs)
+    changed_mesh2d_count = sprite_update_mesh_aabbs(world)
+  }
+  @app.timeline_trace_end_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.scan_mesh2d",
+    scan_mesh2d_trace_start_us,
+  )
+
+  let scan_sprites_trace_start_us = @app.timeline_trace_begin_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.scan_sprites",
+  )
+  if has_sprite {
+    let atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout] = @asset.asset_assets_or_abort()
+    sprite_collect_new_sprite_aabbs(world, atlas_layout_assets, pending_aabbs)
+    changed_sprite_count = sprite_update_sprite_aabbs(
+      world, atlas_layout_assets,
+    )
+  }
+  @app.timeline_trace_end_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.scan_sprites",
+    scan_sprites_trace_start_us,
+  )
+
+  let scan_sprite_mesh_trace_start_us = @app.timeline_trace_begin_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.scan_sprite_mesh",
+  )
+  if has_sprite_mesh {
+    let atlas_layout_assets : @asset.Assets[@asset.TextureAtlasLayout] = @asset.asset_assets_or_abort()
+    sprite_collect_new_sprite_mesh_aabbs(
+      world, atlas_layout_assets, pending_aabbs,
+    )
+    changed_sprite_mesh_count = sprite_update_sprite_mesh_aabbs(
+      world, atlas_layout_assets,
+    )
+  }
+  @app.timeline_trace_end_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.scan_sprite_mesh",
+    scan_sprite_mesh_trace_start_us,
+  )
+
+  let apply_aabbs_trace_start_us = @app.timeline_trace_begin_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.apply_aabbs",
+  )
   for entry in pending_aabbs {
-    sprite_set_or_replace_aabb(world, entry.0, entry.1)
+    sprite_insert_or_replace_new_aabb(world, entry.0, entry.1)
   }
+  @app.timeline_trace_end_span(
+    @app.TimelineTraceCategory::System,
+    "sprite_bounds.apply_aabbs",
+    apply_aabbs_trace_start_us,
+  )
+  @app.timeline_trace_emit_counter_int(
+    "sprite_bounds.changed_mesh2d_entities", changed_mesh2d_count,
+  )
+  @app.timeline_trace_emit_counter_int(
+    "sprite_bounds.changed_sprite_or_anchor_entities", changed_sprite_count,
+  )
+  @app.timeline_trace_emit_counter_int(
+    "sprite_bounds.changed_sprite_mesh_or_anchor_entities", changed_sprite_mesh_count,
+  )
+  @app.timeline_trace_emit_counter_int(
+    "sprite_bounds.pending_aabbs",
+    pending_aabbs.length(),
+  )
 }
 
 ///|
diff --git a/mgstudio-engine/sprite/pkg.generated.mbti b/mgstudio-engine/sprite/pkg.generated.mbti
index 576d2618e..e1b259016 100644
--- a/mgstudio-engine/sprite/pkg.generated.mbti
+++ b/mgstudio-engine/sprite/pkg.generated.mbti
@@ -24,9 +24,9 @@ pub fn apply_scale_sprite_image_mode(@math.Vec2, @math.Vec2, @math.Vec2, @math.V
 
 pub fn apply_sprite_image_mode(@math.Vec2, @math.Vec2, @math.Vec2, @math.Vec2, SpriteImageMode, Bool) -> (@math.Vec2, @math.Vec2, @math.Vec2, @math.Vec2, Bool)
 
-pub fn compute_slices_on_asset_event_system(@app.Commands, @app.ParamSet2[@app.Res[@asset.Assets[@image.Image]], @app.Res[@asset.Assets[@asset.TextureAtlasLayout]]], @app.ParamSet2[@ecs.MessageReader[@asset.AssetEvent[@image.Image]], @ecs.Query[@ecs.Read[Sprite], @ecs.All]]) -> Unit
+pub fn compute_slices_on_asset_event_system(@app.Commands, @app.ParamSet2[@app.Res[@asset.Assets[@image.Image]], @app.Res[@asset.Assets[@asset.TextureAtlasLayout]]], @app.ParamSet2[@ecs.MessageReader[@asset.AssetEvent[@image.Image]], @ecs.Query[@ecs.ReadValue[Sprite], @ecs.All]]) -> Unit
 
-pub fn compute_slices_on_sprite_change_system(@app.Commands, @app.ParamSet2[@app.Res[@asset.Assets[@image.Image]], @app.Res[@asset.Assets[@asset.TextureAtlasLayout]]], @ecs.Query[@ecs.Read[Sprite], @ecs.Changed[Sprite]]) -> Unit
+pub fn compute_slices_on_sprite_change_system(@app.Commands, @app.ParamSet2[@app.Res[@asset.Assets[@image.Image]], @app.Res[@asset.Assets[@asset.TextureAtlasLayout]]], @ecs.Query[@ecs.ReadValue[Sprite], @ecs.Changed[Sprite]]) -> Unit
 
 pub fn compute_sprite_slices_from_rect(Sprite, @math.Vec2, @math.Rect) -> ComputedTextureSlices?
 
@@ -154,6 +154,7 @@ pub struct ComputedTextureSlices {
   slices : Array[TextureSlice]
 }
 pub fn ComputedTextureSlices::extract_slices(Self, Sprite, Anchor) -> Array[TextureSlice]
+pub impl @ecs.Component for ComputedTextureSlices
 
 pub struct DefaultGizmoConfigGroup {
 }
@@ -513,13 +514,13 @@ pub fn TextureSlicer::with_max_corner_scale(Self, Float) -> Self
 pub fn TextureSlicer::with_sides_scale_mode(Self, SliceScaleMode) -> Self
 
 // Type aliases
-pub type ComputedSlicesAllSpritesQuery = @ecs.Query[@ecs.Read[Sprite], @ecs.All]
+pub type ComputedSlicesAllSpritesQuery = @ecs.Query[@ecs.ReadValue[Sprite], @ecs.All]
 
-pub type ComputedSlicesAssetEventParams = @app.ParamSet2[@ecs.MessageReader[@asset.AssetEvent[@image.Image]], @ecs.Query[@ecs.Read[Sprite], @ecs.All]]
+pub type ComputedSlicesAssetEventParams = @app.ParamSet2[@ecs.MessageReader[@asset.AssetEvent[@image.Image]], @ecs.Query[@ecs.ReadValue[Sprite], @ecs.All]]
 
 pub type ComputedSlicesAssetParams = @app.ParamSet2[@app.Res[@asset.Assets[@image.Image]], @app.Res[@asset.Assets[@asset.TextureAtlasLayout]]]
 
-pub type ComputedSlicesChangedSpritesQuery = @ecs.Query[@ecs.Read[Sprite], @ecs.Changed[Sprite]]
+pub type ComputedSlicesChangedSpritesQuery = @ecs.Query[@ecs.ReadValue[Sprite], @ecs.Changed[Sprite]]
 
 // Traits
 pub(open) trait GizmoConfigGroup {
diff --git a/mgstudio-engine/sprite_render/mesh2d/material/top.mbt b/mgstudio-engine/sprite_render/mesh2d/material/top.mbt
index 4a3aecaf1..caf405303 100644
--- a/mgstudio-engine/sprite_render/mesh2d/material/top.mbt
+++ b/mgstudio-engine/sprite_render/mesh2d/material/top.mbt
@@ -1059,11 +1059,18 @@ pub impl[M : Material2d + @asset.Asset] @app.Plugin for Material2dPlugin[M] with
   material2d_plugin_build(app, self)
 }
 
+///|
+fn[M : @asset.Asset] material2d_plugin_asset_debug_name(
+  _plugin : Material2dPlugin[M],
+) -> String {
+  M::asset_debug_name()
+}
+
 ///|
 pub impl[M : Material2d + @asset.Asset] @app.Plugin for Material2dPlugin[M] with fn name(
-  _self,
+  self,
 ) {
-  "mgstudio.sprite_render.Material2dPlugin<\{M::asset_debug_name()}>"
+  "mgstudio.sprite_render.Material2dPlugin<\{material2d_plugin_asset_debug_name(self)}>"
 }
 
 ///|
diff --git a/mgstudio-engine/sprite_render/render/ecs_runtime_wbtest.mbt b/mgstudio-engine/sprite_render/render/ecs_runtime_wbtest.mbt
index ca6f34cb0..5c7d19cda 100644
--- a/mgstudio-engine/sprite_render/render/ecs_runtime_wbtest.mbt
+++ b/mgstudio-engine/sprite_render/render/ecs_runtime_wbtest.mbt
@@ -631,6 +631,37 @@ test "render2d: Camera2d tuple stores window render target" {
   )
 }
 
+///|
+test "render2d: camera system updates screen target without RenderState" {
+  let world = @ecs.World::new()
+  defer world.close()
+  ensure_camera2d_authoring_required_components(world)
+  let window = @window.Window::Window()
+  window.resolution = @window.WindowResolution::new(1280, 720).with_scale_factor_override(
+    2.0F,
+  )
+  ignore(try! world.spawn_bundle((window, @window.PrimaryWindow::{  })))
+  let camera_entity = world.spawn_empty()
+  try! (world.set_by_key(
+    camera_entity,
+    @camera_components2d.ecs_key_camera2d,
+    @camera_components2d.Camera2d::Camera2d(),
+  )
+  |> ignore)
+
+  render2d_camera_system_ecs(world)
+
+  let camera = (try! world.get_by_key(
+    camera_entity, @camera_camera.ecs_key_camera,
+  )).unwrap()
+  let target_info = camera.computed.target_info.unwrap()
+  debug_inspect(target_info.physical_size.x, content="1280")
+  debug_inspect(target_info.physical_size.y, content="720")
+  debug_inspect(target_info.scale_factor, content="2")
+  debug_inspect(camera.logical_viewport_size().unwrap().x, content="640")
+  debug_inspect(camera.logical_viewport_size().unwrap().y, content="360")
+}
+
 ///|
 test "render2d: Mesh2d tuple spawn inserts expected components" {
   let world = @ecs.World::new()
@@ -938,6 +969,53 @@ test "sprite: SpritePlugin calculate_bounds_2d inserts Aabb for Sprite" {
   }
 }
 
+///|
+test "sprite: SpritePlugin calculate_bounds_2d updates changed Sprite Aabb" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let mut app = @app.App::new(world)
+    .add_plugins(@asset.AssetPlugin::AssetPlugin())
+    .add_plugins(@mesh.MeshPlugin::MeshPlugin())
+    .add_plugins(@sprite.SpritePlugin::SpritePlugin())
+  let entity = world.spawn()
+  try! world.set_by_key(
+    entity,
+    @sprite.ecs_key_sprite,
+    Sprite::from_color(@color.Color::white(), @math.Vec2::new(40.0F, 20.0F)),
+  )
+  let should_resize = Ref(false)
+  app = app.add_systems(
+    @app.Update,
+    @app.system(fn(world : @ecs.World) {
+      if should_resize.val {
+        let replaced = world.replace(
+          entity,
+          @sprite.ecs_key_sprite,
+          Sprite::from_color(
+            @color.Color::white(),
+            @math.Vec2::new(60.0F, 30.0F),
+          ),
+        ) catch {
+          _ => false
+        }
+        if !replaced {
+          abort("test Sprite must remain replaceable")
+        }
+        should_resize.val = false
+      }
+    }),
+  )
+
+  app = app.update()
+  should_resize.val = true
+  app = app.update()
+
+  let aabb = (try! world.get_by_key(entity, @camera_primitives.ecs_key_aabb)).unwrap()
+  let half_size = aabb.half_size()
+  debug_inspect(half_size.x.to_double(), content="30")
+  debug_inspect(half_size.y.to_double(), content="15")
+}
+
 ///|
 test "sprite: Sprite and @sprite.SpriteMesh install Bevy required components" {
   let lifecycle_world_927_0 = @ecs.World::new()
diff --git a/mgstudio-engine/sprite_render/render/runtime.mbt b/mgstudio-engine/sprite_render/render/runtime.mbt
index e2607ffba..bb2e4d0af 100644
--- a/mgstudio-engine/sprite_render/render/runtime.mbt
+++ b/mgstudio-engine/sprite_render/render/runtime.mbt
@@ -892,13 +892,6 @@ priv struct QueuedCameraDrawItems {
   ui_overlay_items : Array[DrawItem]
 }
 
-///|
-priv struct RuntimeRenderTargetInfo {
-  id : Int
-  width : Int
-  height : Int
-}
-
 ///|
 priv struct PostProcessIntermediateTargetInfo {
   camera : @core.Entity
@@ -918,7 +911,6 @@ struct RenderState {
   extra_sprite_slice_batches : Array[ExtractedSpriteSliceBatch]
   cameras : Array[ExtractedCamera2d]
   meshes : Array[ExtractedMesh2d]
-  render_targets : Array[RuntimeRenderTargetInfo]
   postprocess_intermediate_targets : Array[PostProcessIntermediateTargetInfo]
   // Prepare stage output: stable camera iteration order for the frame.
   mut prepared_camera_indices : Array[Int]
@@ -957,7 +949,6 @@ fn RenderState::new() -> RenderState {
     extra_sprite_slice_batches: [],
     cameras: [],
     meshes: [],
-    render_targets: [],
     postprocess_intermediate_targets: [],
     prepared_camera_indices: [],
     queued_draw_item_counts: [],
@@ -1231,14 +1222,8 @@ pub fn render2d_create_render_target(
   height : Int,
   nearest : Bool,
 ) -> @asset.Handle[@asset.Image] {
+  world |> ignore
   let id = @renderer.host_gpu_create_render_target(width~, height~, nearest~)
-  ensure_render_state_resource(world)
-  let res = get_render_state_resource(world)
-  if res.get() is Some(state_value) {
-    let rs = state_value
-    rs.render_targets.push(RuntimeRenderTargetInfo::{ id, width, height })
-    res.insert(rs)
-  }
   @asset.Handle::new(id)
 }
 
@@ -1448,19 +1433,6 @@ pub fn render2d_clear_overlay_ui_sprites(world : @ecs.World) -> Unit {
   @ui_render_runtime.clear_extracted_ui_sprites(world)
 }
 
-///|
-fn render2d_find_render_target_size(
-  state : RenderState,
-  id : Int,
-) -> RuntimeRenderTargetInfo? {
-  for target in state.render_targets {
-    if target.id == id {
-      return Some(target)
-    }
-  }
-  None
-}
-
 ///|
 priv struct RenderTargetComputed {
   size : @math.IVec2
@@ -1499,22 +1471,22 @@ fn render2d_window_target_info(
 ///|
 fn render2d_target_info(
   world : @ecs.World,
-  state : RenderState,
   target : @camera_camera.RenderTarget,
 ) -> RenderTargetComputed? {
   match target {
     Screen => render2d_window_target_info(world, @window.WindowRef::Primary)
     Window(window_ref) => render2d_window_target_info(world, window_ref)
     Image(handle) => {
-      let target_id = handle.id()
-      if render2d_find_render_target_size(state, target_id) is Some(info) {
+      let images_key : @ecs.ResourceKey[@asset.Assets[@asset.Image]] = @asset.assets_resource_key()
+      if world.get_resource(images_key) is Some(images) &&
+        images.get(handle) is Some(image) {
         Some(RenderTargetComputed::{
-          size: @math.IVec2::new(info.width, info.height),
+          size: @math.IVec2::new(image.width(), image.height()),
           scale_factor: 1.0F,
         })
       } else {
-        let width = @renderer.asset_texture_width(texture_id=target_id)
-        let height = @renderer.asset_texture_height(texture_id=target_id)
+        let width = @asset.asset_texture_width(handle)
+        let height = @asset.asset_texture_height(handle)
         if width > 0 && height > 0 {
           Some(RenderTargetComputed::{
             size: @math.IVec2::new(width, height),
@@ -1586,11 +1558,6 @@ fn render2d_get_or_create_postprocess_intermediate_target(
     nearest=false,
   )
   let handle : @asset.Handle[@asset.Image] = @asset.Handle::new(id)
-  state.render_targets.push(RuntimeRenderTargetInfo::{
-    id,
-    width: safe_width,
-    height: safe_height,
-  })
   for i in 0..<state.postprocess_intermediate_targets.length() {
     let entry = state.postprocess_intermediate_targets[i]
     if render2d_same_entity(entry.camera, camera) && entry.slot == slot {
@@ -1875,9 +1842,7 @@ fn camera_color_grading(
 
 ///|
 pub fn render2d_camera_system(world : @ecs.World) -> Unit {
-  guard render_state_ref(world) is Some(render_state_ref_value) else { return }
   let ecs_world = world
-  let render_state = render_state_ref_value
   ecs_world.for_each_component(@camera_components2d.ecs_key_camera2d, fn(
     entity,
     _marker,
@@ -1897,7 +1862,7 @@ pub fn render2d_camera_system(world : @ecs.World) -> Unit {
     .unwrap_or(@camera_projection2d.Projection::orthographic_2d())
     |> ignore)
 
-    let target_info = render2d_target_info(world, render_state, target)
+    let target_info = render2d_target_info(world, target)
     let next_target_info = render2d_camera_target_info_from_render_target(
       target_info,
     )
@@ -1999,8 +1964,6 @@ fn render2d_entity_visible_ecs(
 
 ///|
 pub fn render2d_camera_system_ecs(world : @ecs.World) -> Unit {
-  guard render_state_ref(world) is Some(render_state_ref_value) else { return }
-  let render_state = render_state_ref_value
   let cameras : Array[@core.Entity] = []
   let camera2d_query : @ecs.Query[
     @ecs.Read[@camera_components2d.Camera2d],
@@ -2018,7 +1981,7 @@ pub fn render2d_camera_system_ecs(world : @ecs.World) -> Unit {
       @camera_projection2d.Projection::orthographic_2d(),
     )
     |> ignore
-    let target_info = render2d_target_info(world, render_state, target)
+    let target_info = render2d_target_info(world, target)
     let next_target_info = render2d_camera_target_info_from_render_target(
       target_info,
     )
@@ -2125,7 +2088,7 @@ fn render2d_extract_camera_entity_ecs(
       target_size: target_info.physical_size,
       scale_factor,
     }
-  } else if render2d_target_info(world, rs, target) is Some(info) {
+  } else if render2d_target_info(world, target) is Some(info) {
     let scale_factor = if info.scale_factor <= 0.0F {
       1.0F
     } else {
@@ -2183,7 +2146,7 @@ fn render2d_extract_ui_only_cameras_ecs(
 
 ///|
 pub let camera_update_systems : @app.SystemSet = @app.system_set(
-  "mgstudio.camera.update_systems",
+  "mgstudio.camera.update",
 )
 
 ///|
@@ -2256,101 +2219,129 @@ pub fn render_extract_system_ecs(world : @ecs.World) -> Unit {
     let texture_atlas_layouts = source_world.get_resource(
       texture_atlas_layouts_key,
     )
-    let sprite_query : @ecs.Query[@ecs.Read[Sprite], @ecs.All] = @ecs.query(
-      source_world,
-    )
-    try! sprite_query.view(fn(entity, sprite) {
-      if !render2d_entity_visible_ecs(source_world, entity) {
-        return
-      }
-      let sprite = sprite.value()
-      let anchor = (try! source_world.get_by_key(entity, ecs_key_anchor)).unwrap_or(
-        Anchor::Anchor(),
-      )
-      let layers = (try! source_world.get_by_key(entity, ecs_key_render_layers)).unwrap_or(
-        RenderLayers::RenderLayers(),
-      )
-      let transform = render2d_resolve_transform_ecs(source_world, entity)
-      let mut uv_min = default_uv_min()
-      let mut uv_max = default_uv_max()
-      let mut region_size = @math.Vec2::new(1.0F, 1.0F)
-      let mut image_size = @math.Vec2::new(1.0F, 1.0F)
-      if sprite_uv_from_sprite(sprite, texture_atlas_layouts) is Some(info) {
-        uv_min = info.uv_min
-        uv_max = info.uv_max
-        image_size = info.image_size
-        region_size = info.region_size
-      }
-      let draw_scale = sprite_draw_scale(
-        sprite,
-        @math.Vec2::new(transform.scale.x, transform.scale.y),
-        region_size,
-      )
-      let scissor = match
-        (try! source_world.get_by_key(entity, @ui_clip.ecs_key_scissor_rect)) {
-        Some(v) => Some(v.rect)
-        None => None
-      }
-      let has_custom_size = match sprite.custom_size {
-        Some(_) => true
-        None => false
-      }
-      let (
-        uv_draw_min,
-        uv_draw_max,
-        draw_scale_for_host,
-        local_offset,
-        needs_repeat_sampler,
-      ) = apply_sprite_image_mode(
-        uv_min,
-        uv_max,
-        draw_scale,
-        region_size,
-        sprite.image_mode,
-        has_custom_size,
-      )
-      let anchor_offset = sprite_anchor_offset(
-        anchor,
-        transform.rotation_z(),
-        draw_scale_for_host,
-        region_size,
-        local_offset,
-      )
-      if needs_repeat_sampler {
-        @asset.asset_set_texture_sampler(
-          sprite.image,
-          @asset.ImageSampler::Descriptor(
-            @asset.ImageSamplerDescriptor::linear().set_address_mode(
-              @asset.ImageAddressMode::Repeat,
-            ),
-          ),
-        )
-      }
-      if !append_computed_sprite_slices(
-          rs.sprite_slice_batches,
-          entity,
+    let sprite_query : @ecs.Query[
+      (
+        (
+          @ecs.Read[Sprite],
+          @ecs.Read[@visibility.ViewVisibility],
+          @ecs.Read[@transform.GlobalTransform],
+          @ecs.Read[Anchor],
+        ),
+        (
+          @ecs.Optional[ComputedTextureSlices],
+          @ecs.Optional[RenderLayers],
+          @ecs.Optional[@ui_clip.ScissorRect],
+        ),
+      ),
+      @ecs.All,
+    ] = @ecs.query(source_world)
+    try! sprite_query.for_each_table(fn(batch) {
+      let sprites = batch.read(@sprite.ecs_key_sprite).unwrap()
+      let view_visibilities = batch
+        .read(@visibility.ecs_key_view_visibility)
+        .unwrap()
+      let global_transforms = batch
+        .read(@transform.ecs_key_global_transform)
+        .unwrap()
+      let anchors = batch.read(ecs_key_anchor).unwrap()
+      let computed_slices = batch.read(ecs_key_computed_texture_slices)
+      let render_layers = batch.read(ecs_key_render_layers)
+      let scissors = batch.read(@ui_clip.ecs_key_scissor_rect)
+      for row_index in 0..<batch.length() {
+        if !view_visibilities.value(row_index).is_visible() {
+          continue
+        }
+        let entity = batch.entity(row_index)
+        let sprite = sprites.value(row_index)
+        let anchor = anchors.value(row_index)
+        let layers = match render_layers {
+          Some(column) => column.value(row_index)
+          None => RenderLayers::RenderLayers()
+        }
+        let transform = global_transforms.value(row_index).to_transform_approx()
+        let mut uv_min = default_uv_min()
+        let mut uv_max = default_uv_max()
+        let mut region_size = @math.Vec2::new(1.0F, 1.0F)
+        let mut image_size = @math.Vec2::new(1.0F, 1.0F)
+        if sprite_uv_from_sprite(sprite, texture_atlas_layouts) is Some(info) {
+          uv_min = info.uv_min
+          uv_max = info.uv_max
+          image_size = info.image_size
+          region_size = info.region_size
+        }
+        let draw_scale = sprite_draw_scale(
           sprite,
-          try! source_world.get_by_key(entity, ecs_key_computed_texture_slices),
+          @math.Vec2::new(transform.scale.x, transform.scale.y),
+          region_size,
+        )
+        let scissor = match scissors {
+          Some(column) => Some(column.value(row_index).rect)
+          None => None
+        }
+        let has_custom_size = match sprite.custom_size {
+          Some(_) => true
+          None => false
+        }
+        let (
+          uv_draw_min,
+          uv_draw_max,
+          draw_scale_for_host,
+          local_offset,
+          needs_repeat_sampler,
+        ) = apply_sprite_image_mode(
+          uv_min,
+          uv_max,
+          draw_scale,
+          region_size,
+          sprite.image_mode,
+          has_custom_size,
+        )
+        let anchor_offset = sprite_anchor_offset(
           anchor,
-          transform,
-          layers,
-          scissor,
-          image_size,
-        ) {
-        rs.sprites.push(ExtractedSprite::{
-          entity: phase_entity_ref_for_main(entity),
-          payload: SpriteDrawPayload::{
+          transform.rotation_z(),
+          draw_scale_for_host,
+          region_size,
+          local_offset,
+        )
+        if needs_repeat_sampler {
+          @asset.asset_set_texture_sampler(
+            sprite.image,
+            @asset.ImageSampler::Descriptor(
+              @asset.ImageSamplerDescriptor::linear().set_address_mode(
+                @asset.ImageAddressMode::Repeat,
+              ),
+            ),
+          )
+        }
+        if !append_computed_sprite_slices(
+            rs.sprite_slice_batches,
+            entity,
+            sprite,
+            match computed_slices {
+              Some(column) => Some(column.value(row_index))
+              None => None
+            },
+            anchor,
             transform,
-            anchor_offset,
-            draw_scale: draw_scale_for_host,
-            color: sprite.color,
-            texture: sprite.image,
             layers,
-            uv_min: uv_draw_min,
-            uv_max: uv_draw_max,
             scissor,
-          },
-        })
+            image_size,
+          ) {
+          rs.sprites.push(ExtractedSprite::{
+            entity: phase_entity_ref_for_main(entity),
+            payload: SpriteDrawPayload::{
+              transform,
+              anchor_offset,
+              draw_scale: draw_scale_for_host,
+              color: sprite.color,
+              texture: sprite.image,
+              layers,
+              uv_min: uv_draw_min,
+              uv_max: uv_draw_max,
+              scissor,
+            },
+          })
+        }
       }
     })
     // ECS mesh components.
@@ -4669,6 +4660,127 @@ test "render2d: sliced sprite extraction follows computed slices instead of ui s
   debug_inspect(ok, content="true")
 }
 
+///|
+test "render2d: ecs sprite extraction preserves required and optional columns" {
+  let world = @ecs.World::new()
+  defer world.close()
+  ensure_render_state_resource(world)
+
+  let plain_entity = world.spawn_empty()
+  let plain_transform = @transform.Transform::from_xyz(2.0F, 3.0F, 4.0F)
+  try! world.set_by_key(
+    plain_entity,
+    @sprite.ecs_key_sprite,
+    Sprite::from_color(@color.Color::white(), @math.Vec2::new(8.0F, 4.0F)),
+  )
+  try! world.set_by_key(
+    plain_entity,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::visible(),
+  )
+  try! world.set_by_key(
+    plain_entity,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::from_transform(plain_transform),
+  )
+  try! world.set_by_key(plain_entity, ecs_key_anchor, Anchor::center())
+
+  let sliced_entity = world.spawn_empty()
+  let sliced_sprite = Sprite::from_image(@asset.Handle::new(7))
+    .with_image_mode(
+      SpriteImageMode::Sliced(TextureSlicer::new(BorderRect::square(8.0F))),
+    )
+    .with_custom_size(Some(@math.Vec2::new(96.0F, 64.0F)))
+  guard compute_sprite_slices_from_rect(
+      sliced_sprite,
+      @math.Vec2::new(32.0F, 32.0F),
+      @math.Rect::new(@math.Vec2::zero(), @math.Vec2::new(32.0F, 32.0F)),
+    )
+    is Some(computed_slices) else {
+    debug_inspect(false, content="true")
+    return
+  }
+  try! world.set_by_key(sliced_entity, @sprite.ecs_key_sprite, sliced_sprite)
+  try! world.set_by_key(
+    sliced_entity,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::visible(),
+  )
+  try! world.set_by_key(
+    sliced_entity,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(sliced_entity, ecs_key_anchor, Anchor::center())
+  try! world.set_by_key(
+    sliced_entity, ecs_key_computed_texture_slices, computed_slices,
+  )
+  try! world.set_by_key(
+    sliced_entity,
+    ecs_key_render_layers,
+    RenderLayers::layer(3),
+  )
+  try! world.set_by_key(
+    sliced_entity,
+    @ui_clip.ecs_key_scissor_rect,
+    @ui_clip.ScissorRect::new(
+      @math.Rect::new(@math.Vec2::new(1.0F, 2.0F), @math.Vec2::new(9.0F, 10.0F)),
+    ),
+  )
+
+  let hidden_entity = world.spawn_empty()
+  try! world.set_by_key(
+    hidden_entity,
+    @sprite.ecs_key_sprite,
+    Sprite::from_color(@color.Color::white(), @math.Vec2::new(16.0F, 16.0F)),
+  )
+  try! world.set_by_key(
+    hidden_entity,
+    @visibility.ecs_key_view_visibility,
+    @visibility.ViewVisibility::hidden(),
+  )
+  try! world.set_by_key(
+    hidden_entity,
+    @transform.ecs_key_global_transform,
+    @transform.GlobalTransform::identity(),
+  )
+  try! world.set_by_key(hidden_entity, ecs_key_anchor, Anchor::center())
+
+  render_extract_system_ecs(world)
+
+  let rs = render_state_ref(world).unwrap()
+  let plain_ok = rs.sprites.length() == 1 &&
+    phase_entity_ref_cmp(
+      rs.sprites[0].entity,
+      phase_entity_ref_for_main(plain_entity),
+    ) ==
+    0 &&
+    rs.sprites[0].payload.transform.translation.x == 2.0F &&
+    rs.sprites[0].payload.transform.translation.y == 3.0F &&
+    rs.sprites[0].payload.transform.translation.z == 4.0F &&
+    rs.sprites[0].payload.layers.mask() == 1 &&
+    rs.sprites[0].payload.scissor is None
+  let sliced_scissor_ok = match rs.sprite_slice_batches[0].payload.scissor {
+    Some(rect) =>
+      rect.min.x == 1.0F &&
+      rect.min.y == 2.0F &&
+      rect.max.x == 9.0F &&
+      rect.max.y == 10.0F
+    None => false
+  }
+  let sliced_ok = rs.sprite_slice_batches.length() == 1 &&
+    phase_entity_ref_cmp(
+      rs.sprite_slice_batches[0].entity,
+      phase_entity_ref_for_main(sliced_entity),
+    ) ==
+    0 &&
+    rs.sprite_slice_batches[0].payload.texture.id() == 7 &&
+    rs.sprite_slice_batches[0].payload.layers.mask() == 8 &&
+    rs.sprite_slice_batches[0].payload.slices.length() == 9 &&
+    sliced_scissor_ok
+  debug_inspect(plain_ok && sliced_ok, content="true")
+}
+
 ///|
 test "render2d: camera viewport clamp matches bevy edge behavior" {
   let viewport = Viewport::new(
diff --git a/mgstudio-engine/sprite_render/sprite_mesh/top.mbt b/mgstudio-engine/sprite_render/sprite_mesh/top.mbt
index 93b2fbc72..4e5df353c 100644
--- a/mgstudio-engine/sprite_render/sprite_mesh/top.mbt
+++ b/mgstudio-engine/sprite_render/sprite_mesh/top.mbt
@@ -768,7 +768,7 @@ fn sprite_material_with_atlas_layout(
 ) -> SpriteMaterial {
   match texture_atlas {
     Some(atlas) =>
-      match texture_atlas_layouts.get(atlas.layout()) {
+      match atlas.layout_asset(texture_atlas_layouts) {
         Some(layout) =>
           material.with_texture_atlas_layout(Some(layout), atlas.index())
         None => material
diff --git a/mgstudio-engine/time/moon.pkg b/mgstudio-engine/time/moon.pkg
index 4293aba0d..8687b7c5b 100644
--- a/mgstudio-engine/time/moon.pkg
+++ b/mgstudio-engine/time/moon.pkg
@@ -5,3 +5,7 @@ import {
   "moonbitlang/core/hashmap",
   "moonbitlang/core/ref",
 }
+
+import {
+  "moonbitlang/core/bench",
+} for "test"
diff --git a/mgstudio-engine/time/pkg.generated.mbti b/mgstudio-engine/time/pkg.generated.mbti
index fd0a9d509..7c50ab97a 100644
--- a/mgstudio-engine/time/pkg.generated.mbti
+++ b/mgstudio-engine/time/pkg.generated.mbti
@@ -119,7 +119,7 @@ pub impl TimeContext for Real
 pub impl Default for Real
 
 pub struct Stopwatch {
-  elapsed : @core.Duration
+  elapsed_nanos : Int64
   paused : Bool
 } derive(Eq, @debug.Debug)
 pub fn Stopwatch::elapsed(Self) -> @core.Duration
@@ -249,9 +249,10 @@ pub fn TimeUpdateStrategy::default() -> Self
 pub impl @app.Resource for TimeUpdateStrategy
 
 pub struct Timer {
-  stopwatch : Stopwatch
-  duration : @core.Duration
-  mode : TimerMode
+  stopwatch_elapsed_nanos : Int64
+  stopwatch_paused : Bool
+  duration_nanos : Int64
+  mode_repeating : Bool
   finished : Bool
   times_finished_this_tick : Int
 } derive(Eq, @debug.Debug)
diff --git a/mgstudio-engine/time/stopwatch.mbt b/mgstudio-engine/time/stopwatch.mbt
index abba10df2..948252503 100644
--- a/mgstudio-engine/time/stopwatch.mbt
+++ b/mgstudio-engine/time/stopwatch.mbt
@@ -17,29 +17,30 @@
 // Licensed under Apache-2.0 or MIT.
 
 ///|
+#valtype
 pub struct Stopwatch {
-  elapsed : @core.Duration
+  elapsed_nanos : Int64
   paused : Bool
 } derive(Eq, Debug)
 
 ///|
 pub fn Stopwatch::new() -> Stopwatch {
-  Stopwatch::{ elapsed: @core.Duration::zero(), paused: false }
+  Stopwatch::{ elapsed_nanos: 0L, paused: false }
 }
 
 ///|
 pub fn Stopwatch::elapsed(self : Stopwatch) -> @core.Duration {
-  self.elapsed
+  @core.Duration::from_nanos(self.elapsed_nanos)
 }
 
 ///|
 pub fn Stopwatch::elapsed_secs(self : Stopwatch) -> Float {
-  self.elapsed.as_secs_f32()
+  self.elapsed().as_secs_f32()
 }
 
 ///|
 pub fn Stopwatch::elapsed_secs_f64(self : Stopwatch) -> Double {
-  self.elapsed.as_secs_f64()
+  self.elapsed().as_secs_f64()
 }
 
 ///|
@@ -52,7 +53,7 @@ pub fn Stopwatch::set_elapsed(
   self : Stopwatch,
   elapsed : @core.Duration,
 ) -> Stopwatch {
-  Stopwatch::{ ..self, elapsed, }
+  Stopwatch::{ ..self, elapsed_nanos: elapsed.as_nanos() }
 }
 
 ///|
@@ -68,7 +69,10 @@ pub fn Stopwatch::tick(self : Stopwatch, delta : @core.Duration) -> Stopwatch {
   if self.paused || delta.is_zero() {
     self
   } else {
-    Stopwatch::{ ..self, elapsed: self.elapsed.saturating_add(delta) }
+    Stopwatch::{
+      ..self,
+      elapsed_nanos: self.elapsed().saturating_add(delta).as_nanos(),
+    }
   }
 }
 
@@ -89,5 +93,5 @@ pub fn Stopwatch::is_paused(self : Stopwatch) -> Bool {
 
 ///|
 pub fn Stopwatch::reset(self : Stopwatch) -> Stopwatch {
-  Stopwatch::{ ..self, elapsed: @core.Duration::zero() }
+  Stopwatch::{ ..self, elapsed_nanos: 0L }
 }
diff --git a/mgstudio-engine/time/timer.mbt b/mgstudio-engine/time/timer.mbt
index e9a743332..3c570a197 100644
--- a/mgstudio-engine/time/timer.mbt
+++ b/mgstudio-engine/time/timer.mbt
@@ -17,16 +17,19 @@
 // Licensed under Apache-2.0 or MIT.
 
 ///|
+#valtype
 pub(all) enum TimerMode {
   Once
   Repeating
 } derive(Eq, Debug)
 
 ///|
+#valtype
 pub struct Timer {
-  stopwatch : Stopwatch
-  duration : @core.Duration
-  mode : TimerMode
+  stopwatch_elapsed_nanos : Int64
+  stopwatch_paused : Bool
+  duration_nanos : Int64
+  mode_repeating : Bool
   finished : Bool
   times_finished_this_tick : Int
 } derive(Eq, Debug)
@@ -59,9 +62,10 @@ fn timer_is_elapsed(
 ///|
 pub fn Timer::new(duration : @core.Duration, mode : TimerMode) -> Timer {
   Timer::{
-    stopwatch: Stopwatch::new(),
-    duration,
-    mode,
+    stopwatch_elapsed_nanos: 0L,
+    stopwatch_paused: false,
+    duration_nanos: duration.as_nanos(),
+    mode_repeating: mode == Repeating,
     finished: false,
     times_finished_this_tick: 0,
   }
@@ -74,11 +78,11 @@ pub fn Timer::from_seconds(seconds : Float, mode : TimerMode) -> Timer {
 
 ///|
 pub fn Timer::tick(self : Timer, delta : @core.Duration) -> Timer {
-  if self.stopwatch.is_paused() {
+  if self.stopwatch_paused {
     return Timer::{
       ..self,
       times_finished_this_tick: 0,
-      finished: if self.mode == Repeating {
+      finished: if self.mode_repeating {
         false
       } else {
         self.finished
@@ -86,67 +90,64 @@ pub fn Timer::tick(self : Timer, delta : @core.Duration) -> Timer {
     }
   }
 
-  if self.mode != Repeating && self.finished {
+  if !self.mode_repeating && self.finished {
     return Timer::{ ..self, times_finished_this_tick: 0 }
   }
 
-  let stopwatch = self.stopwatch.tick(delta)
+  let stopwatch = Stopwatch::{
+    elapsed_nanos: self.stopwatch_elapsed_nanos,
+    paused: self.stopwatch_paused,
+  }.tick(delta)
   let elapsed = stopwatch.elapsed()
-  let duration = self.duration
+  let duration = self.duration()
   let finished = timer_is_elapsed(elapsed, duration)
 
   if !finished {
     return Timer::{
       ..self,
-      stopwatch,
+      stopwatch_elapsed_nanos: elapsed.as_nanos(),
       finished: false,
       times_finished_this_tick: 0,
     }
   }
 
-  match self.mode {
-    Repeating => {
-      let duration_nanos = duration.as_nanos()
-      let elapsed_nanos = elapsed.as_nanos()
-      let times_finished = if duration_nanos <= 0L {
-        2_147_483_647
-      } else {
-        (elapsed_nanos / duration_nanos).to_int()
-      }
-      let wrapped = if duration_nanos <= 0L {
-        @core.Duration::zero()
-      } else {
-        @core.Duration::from_nanos(elapsed_nanos % duration_nanos)
-      }
-      Timer::{
-        ..self,
-        stopwatch: stopwatch.set_elapsed(wrapped),
-        finished: times_finished > 0,
-        times_finished_this_tick: times_finished,
-      }
+  if self.mode_repeating {
+    let duration_nanos = duration.as_nanos()
+    let elapsed_nanos = elapsed.as_nanos()
+    let times_finished = if duration_nanos <= 0L {
+      2_147_483_647
+    } else {
+      (elapsed_nanos / duration_nanos).to_int()
+    }
+    let wrapped = if duration_nanos <= 0L {
+      @core.Duration::zero()
+    } else {
+      @core.Duration::from_nanos(elapsed_nanos % duration_nanos)
+    }
+    Timer::{
+      ..self,
+      stopwatch_elapsed_nanos: wrapped.as_nanos(),
+      finished: times_finished > 0,
+      times_finished_this_tick: times_finished,
+    }
+  } else {
+    Timer::{
+      ..self,
+      stopwatch_elapsed_nanos: duration.as_nanos(),
+      finished: true,
+      times_finished_this_tick: 1,
     }
-    Once =>
-      Timer::{
-        ..self,
-        stopwatch: stopwatch.set_elapsed(duration),
-        finished: true,
-        times_finished_this_tick: 1,
-      }
   }
 }
 
 ///|
 pub fn Timer::pause(self : Timer) -> Timer {
-  Timer::{
-    ..self,
-    stopwatch: self.stopwatch.pause(),
-    times_finished_this_tick: 0,
-  }
+  Timer::{ ..self, stopwatch_paused: true, times_finished_this_tick: 0 }
 }
 
 ///|
 pub fn Timer::unpause(self : Timer) -> Timer {
-  Timer::{ ..self, stopwatch: self.stopwatch.unpause() }
+  Timer::{ ..self, stopwatch_paused: false }
 }
 
 ///|
@@ -162,7 +163,7 @@ pub fn Timer::toggle(self : Timer) -> Timer {
 pub fn Timer::reset(self : Timer) -> Timer {
   Timer::{
     ..self,
-    stopwatch: self.stopwatch.reset(),
+    stopwatch_elapsed_nanos: 0L,
     finished: false,
     times_finished_this_tick: 0,
   }
@@ -170,27 +171,32 @@ pub fn Timer::reset(self : Timer) -> Timer {
 
 ///|
 pub fn Timer::mode(self : Timer) -> TimerMode {
-  self.mode
+  if self.mode_repeating {
+    Repeating
+  } else {
+    Once
+  }
 }
 
 ///|
 pub fn Timer::set_mode(self : Timer, mode : TimerMode) -> Timer {
-  if self.mode != Repeating && mode == Repeating && self.finished {
+  let mode_repeating = mode == Repeating
+  if !self.mode_repeating && mode_repeating && self.finished {
     Timer::{
       ..self,
-      mode,
-      stopwatch: self.stopwatch.reset(),
+      mode_repeating,
+      stopwatch_elapsed_nanos: 0L,
       finished: false,
       times_finished_this_tick: 0,
     }
   } else {
-    Timer::{ ..self, mode, }
+    Timer::{ ..self, mode_repeating, }
   }
 }
 
 ///|
 pub fn Timer::is_paused(self : Timer) -> Bool {
-  self.stopwatch.is_paused()
+  self.stopwatch_paused
 }
 
 ///|
@@ -205,17 +211,17 @@ pub fn Timer::is_finished(self : Timer) -> Bool {
 
 ///|
 pub fn Timer::elapsed(self : Timer) -> @core.Duration {
-  self.stopwatch.elapsed()
+  @core.Duration::from_nanos(self.stopwatch_elapsed_nanos)
 }
 
 ///|
 pub fn Timer::elapsed_secs(self : Timer) -> Float {
-  self.stopwatch.elapsed_secs()
+  self.elapsed().as_secs_f32()
 }
 
 ///|
 pub fn Timer::elapsed_secs_f64(self : Timer) -> Double {
-  self.stopwatch.elapsed_secs_f64()
+  self.elapsed().as_secs_f64()
 }
 
 ///|
@@ -225,22 +231,22 @@ pub fn Timer::elapsed_seconds(self : Timer) -> Float {
 
 ///|
 pub fn Timer::set_elapsed(self : Timer, elapsed : @core.Duration) -> Timer {
-  Timer::{ ..self, stopwatch: self.stopwatch.set_elapsed(elapsed) }
+  Timer::{ ..self, stopwatch_elapsed_nanos: elapsed.as_nanos() }
 }
 
 ///|
 pub fn Timer::duration(self : Timer) -> @core.Duration {
-  self.duration
+  @core.Duration::from_nanos(self.duration_nanos)
 }
 
 ///|
 pub fn Timer::duration_seconds(self : Timer) -> Float {
-  self.duration.as_secs_f32()
+  self.duration().as_secs_f32()
 }
 
 ///|
 pub fn Timer::set_duration(self : Timer, duration : @core.Duration) -> Timer {
-  Timer::{ ..self, duration, }
+  Timer::{ ..self, duration_nanos: duration.as_nanos() }
 }
 
 ///|
@@ -268,7 +274,7 @@ pub fn Timer::almost_finish(self : Timer) -> Timer {
 
 ///|
 pub fn Timer::remaining(self : Timer) -> @core.Duration {
-  self.duration.saturating_sub(self.elapsed())
+  self.duration().saturating_sub(self.elapsed())
 }
 
 ///|
@@ -288,7 +294,7 @@ pub fn Timer::times_finished_this_tick(self : Timer) -> Int {
 
 ///|
 pub fn Timer::fraction(self : Timer) -> Float {
-  timer_fraction(self.elapsed(), self.duration)
+  timer_fraction(self.elapsed(), self.duration())
 }
 
 ///|
diff --git a/mgstudio-engine/time/timer_bench_test.mbt b/mgstudio-engine/time/timer_bench_test.mbt
new file mode 100644
index 000000000..f138ff225
--- /dev/null
+++ b/mgstudio-engine/time/timer_bench_test.mbt
@@ -0,0 +1,29 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "bench time: tick repeating timers" (b : @bench.T) {
+  let timer_count = 20_000
+  let timers = Array::make(
+    timer_count,
+    Timer::from_seconds(1.0F, TimerMode::Repeating),
+  )
+  let delta = @core.Duration::from_millis(16L)
+  b.bench(name="tick repeating timers x20000", count=100U, () => {
+    for index in 0..<timers.length() {
+      timers[index] = timers[index].tick(delta)
+    }
+    b.keep(timers[0].elapsed().as_nanos())
+  })
+}
diff --git a/mgstudio-engine/transform/components.mbt b/mgstudio-engine/transform/components.mbt
index 27e959d5e..0c164050e 100644
--- a/mgstudio-engine/transform/components.mbt
+++ b/mgstudio-engine/transform/components.mbt
@@ -555,31 +555,31 @@ pub impl Default for TransformTreeChanged with fn default() {
 }
 
 ///|
-pub struct StaticTransformOptimizations {
-  threshold : Float
-  mut enabled : Bool
+pub enum StaticTransformOptimizations {
+  Enabled
+  Disabled
 } derive(Eq, Debug, ToJson, FromJson)
 
-///|
-pub fn StaticTransformOptimizations::from_threshold(
-  threshold : Float,
-) -> StaticTransformOptimizations {
-  { threshold, enabled: true }
-}
-
 ///|
 pub fn StaticTransformOptimizations::disabled() -> StaticTransformOptimizations {
-  { threshold: 0.0F, enabled: false }
+  StaticTransformOptimizations::Disabled
 }
 
 ///|
 pub fn StaticTransformOptimizations::enabled() -> StaticTransformOptimizations {
-  { threshold: 1.0F, enabled: true }
+  StaticTransformOptimizations::Enabled
 }
 
 ///|
 pub fn StaticTransformOptimizations::StaticTransformOptimizations() -> StaticTransformOptimizations {
-  { threshold: 0.3F, enabled: true }
+  StaticTransformOptimizations::Enabled
+}
+
+///|
+pub fn StaticTransformOptimizations::is_enabled(
+  self : StaticTransformOptimizations,
+) -> Bool {
+  self == StaticTransformOptimizations::Enabled
 }
 
 ///|
diff --git a/mgstudio-engine/transform/pkg.generated.mbti b/mgstudio-engine/transform/pkg.generated.mbti
index 049c1e258..789d94635 100644
--- a/mgstudio-engine/transform/pkg.generated.mbti
+++ b/mgstudio-engine/transform/pkg.generated.mbti
@@ -26,7 +26,7 @@ pub fn mark_dirty_trees(@ecs.World) -> Unit
 
 pub fn mark_dirty_trees_ecs(@ecs.World) -> Unit
 
-pub fn mark_dirty_trees_system(@ecs.Query[@core.Entity, @ecs.Or[(@ecs.Changed[Transform], @ecs.Changed[@hierarchy.Parent], @ecs.Added[GlobalTransform])]], @ecs.RemovedComponents[@hierarchy.Parent], @app.ParamSet2[@ecs.Query[@ecs.Write[TransformTreeChanged], @ecs.All], @ecs.Query[@ecs.Read[@hierarchy.Parent], @ecs.All]], @app.ResMut[StaticTransformOptimizations]) -> Unit
+pub fn mark_dirty_trees_system(@ecs.Query[@core.Entity, @ecs.Or[(@ecs.Changed[Transform], @ecs.Changed[@hierarchy.Parent], @ecs.Added[GlobalTransform])]], @ecs.RemovedComponents[@hierarchy.Parent], @app.ParamSet2[@ecs.Query[@ecs.Write[TransformTreeChanged], @ecs.All], @ecs.Query[@ecs.Read[@hierarchy.Parent], @ecs.All]], @app.Res[StaticTransformOptimizations]) -> Unit
 
 pub fn propagate_parent_transforms(@ecs.World) -> Unit
 
@@ -48,7 +48,7 @@ pub fn set_parent_in_place(@ecs.World, @core.Entity, @core.Entity) -> Unit
 
 pub let static_transform_optimizations_resource_key : @ecs.ResourceKey[StaticTransformOptimizations]
 
-pub fn sync_simple_transforms(@app.ParamSet2[@ecs.Query[(@ecs.Read[Transform], @ecs.Write[GlobalTransform]), (@ecs.Without[@hierarchy.Parent], @ecs.Without[@hierarchy.Children], @ecs.Or[(@ecs.Changed[Transform], @ecs.Added[GlobalTransform])])], @ecs.Query[(@ecs.Read[Transform], @ecs.Write[GlobalTransform]), (@ecs.Without[@hierarchy.Parent], @ecs.Without[@hierarchy.Children])]], @ecs.RemovedComponents[@hierarchy.Parent]) -> Unit
+pub fn sync_simple_transforms(@app.ParamSet2[@ecs.Query[(@ecs.ReadValue[Transform], @ecs.Write[GlobalTransform]), (@ecs.Without[@hierarchy.Parent], @ecs.Without[@hierarchy.Children], @ecs.Or[(@ecs.Changed[Transform], @ecs.Added[GlobalTransform])])], @ecs.Query[(@ecs.Read[Transform], @ecs.Write[GlobalTransform]), (@ecs.Without[@hierarchy.Parent], @ecs.Without[@hierarchy.Children])]], @ecs.RemovedComponents[@hierarchy.Parent]) -> Unit
 
 pub fn sync_simple_transforms_world(@ecs.World) -> Unit
 
@@ -107,14 +107,14 @@ pub impl Default for GlobalTransform
 pub impl ToJson for GlobalTransform
 pub impl @json.FromJson for GlobalTransform
 
-pub struct StaticTransformOptimizations {
-  threshold : Float
-  mut enabled : Bool
+pub enum StaticTransformOptimizations {
+  Enabled
+  Disabled
 } derive(Eq, ToJson, @debug.Debug, @json.FromJson)
 pub fn StaticTransformOptimizations::StaticTransformOptimizations() -> Self
 pub fn StaticTransformOptimizations::disabled() -> Self
 pub fn StaticTransformOptimizations::enabled() -> Self
-pub fn StaticTransformOptimizations::from_threshold(Float) -> Self
+pub fn StaticTransformOptimizations::is_enabled(Self) -> Bool
 pub impl @app.Resource for StaticTransformOptimizations
 pub impl Default for StaticTransformOptimizations
 
diff --git a/mgstudio-engine/transform/systems.mbt b/mgstudio-engine/transform/systems.mbt
index d90030d36..e98da89da 100644
--- a/mgstudio-engine/transform/systems.mbt
+++ b/mgstudio-engine/transform/systems.mbt
@@ -14,7 +14,7 @@
 
 ///|
 type SimpleTransformChangedQuery = @ecs.Query[
-  (@ecs.Read[Transform], @ecs.Write[GlobalTransform]),
+  (@ecs.ReadValue[Transform], @ecs.Write[GlobalTransform]),
   (
     @ecs.Without[@hierarchy.Parent],
     @ecs.Without[@hierarchy.Children],
@@ -192,20 +192,24 @@ fn read_static_transform_optimizations(
   .unwrap_or(StaticTransformOptimizations::StaticTransformOptimizations())
 }
 
-///|
-fn write_static_transform_optimizations(
-  world : @ecs.World,
-  value : StaticTransformOptimizations,
-) -> Unit {
-  world.insert_resource(static_transform_optimizations_resource_key, value)
-}
-
 ///|
 fn sync_simple_transforms_changed(query : SimpleTransformChangedQuery) -> Unit {
-  try! query.for_each(fn(_entity, data) {
-    let (transform, global_transform) = data
-    global_transform.set(GlobalTransform::from_transform(transform.value()))
+  let used_batch = try! query.try_for_each_filtered_table(fn(batch, rows) {
+    let transforms = batch.read(ecs_key_transform).unwrap()
+    let global_transforms = batch.write(ecs_key_global_transform).unwrap()
+    try! rows.for_each(fn(row_index) {
+      global_transforms.set(
+        row_index,
+        GlobalTransform::from_transform(transforms.value(row_index)),
+      )
+    })
   })
+  if !used_batch {
+    try! query.for_each(fn(_entity, data) {
+      let (transform, global_transform) = data
+      global_transform.set(GlobalTransform::from_transform(transform.value()))
+    })
+  }
 }
 
 ///|
@@ -277,17 +281,6 @@ pub fn sync_simple_transforms_world(world : @ecs.World) -> Unit {
   sync_simple_transforms_apply(world)
 }
 
-///|
-fn clamp_static_transform_threshold(threshold : Float) -> Float {
-  if threshold < 0.0F {
-    0.0F
-  } else if threshold > 1.0F {
-    1.0F
-  } else {
-    threshold
-  }
-}
-
 ///|
 fn mark_dirty_tree_chain(
   transforms : TransformTreeChangedMutQuery,
@@ -308,54 +301,32 @@ fn mark_dirty_tree_chain(
   }
 }
 
-///|
-fn mark_dirty_trees_enabled_state(
-  static_optimizations : StaticTransformOptimizations,
-  dynamic_count : () -> Int,
-  total : () -> Int,
-) -> StaticTransformOptimizations {
-  let threshold = clamp_static_transform_threshold(
-    static_optimizations.threshold,
-  )
-  if threshold == 0.0F {
-    static_optimizations.enabled = false
-  } else if threshold == 1.0F {
-    static_optimizations.enabled = true
-  } else {
-    static_optimizations.enabled = true
-    let total_count = total()
-    if total_count > 0 {
-      if Float::from_int(dynamic_count()) / Float::from_int(total_count) >
-        threshold {
-        static_optimizations.enabled = false
-      }
-    }
-  }
-  static_optimizations
-}
-
 ///|
 pub fn mark_dirty_trees_system(
   changed_transforms : TransformDirtyTriggerQuery,
   orphaned : @ecs.RemovedComponents[@hierarchy.Parent],
   query_set : @app.ParamSet2[TransformTreeChangedMutQuery, TransformParentQuery],
-  static_optimizations_ref : @app.ResMut[StaticTransformOptimizations],
+  static_optimizations : @app.Res[StaticTransformOptimizations],
 ) -> Unit {
-  let transforms = query_set.p0()
-  let parents = query_set.p1()
-  let static_optimizations = mark_dirty_trees_enabled_state(
-    static_optimizations_ref.peek(),
-    fn() { changed_transforms.count() },
-    fn() { transforms.count() },
-  )
-  ignore(static_optimizations_ref.set_if_neq(static_optimizations))
-  if !static_optimizations.enabled {
+  if !static_optimizations.get().is_enabled() {
     return
   }
+  let transforms = query_set.p0()
+  let parents = query_set.p1()
 
-  try! changed_transforms.for_each(fn(_entity, changed_entity) {
-    mark_dirty_tree_chain(transforms, parents, changed_entity)
+  let used_batch = try! changed_transforms.try_for_each_filtered_table(fn(
+    batch,
+    rows,
+  ) {
+    try! rows.for_each(fn(row_index) {
+      mark_dirty_tree_chain(transforms, parents, batch.entity(row_index))
+    })
   })
+  if !used_batch {
+    try! changed_transforms.for_each(fn(_entity, changed_entity) {
+      mark_dirty_tree_chain(transforms, parents, changed_entity)
+    })
+  }
   for entity in orphaned.read() {
     mark_dirty_tree_chain(transforms, parents, entity)
   }
@@ -363,6 +334,9 @@ pub fn mark_dirty_trees_system(
 
 ///|
 pub fn mark_dirty_trees(world : @ecs.World) -> Unit {
+  if !read_static_transform_optimizations(world).is_enabled() {
+    return
+  }
   let changed_transforms : TransformDirtyTriggerQuery = @ecs.query_filtered(
     world,
     @ecs.Or::new(
@@ -382,19 +356,19 @@ pub fn mark_dirty_trees(world : @ecs.World) -> Unit {
   let transforms : TransformTreeChangedMutQuery = @ecs.query(world)
   let parents : TransformParentQuery = @ecs.query(world)
 
-  let static_optimizations = mark_dirty_trees_enabled_state(
-    read_static_transform_optimizations(world),
-    fn() { changed_transforms.count() },
-    fn() { transforms.count() },
-  )
-  write_static_transform_optimizations(world, static_optimizations)
-  if !static_optimizations.enabled {
-    return
-  }
-
-  try! changed_transforms.for_each(fn(_entity, changed_entity) {
-    mark_dirty_tree_chain(transforms, parents, changed_entity)
+  let used_batch = try! changed_transforms.try_for_each_filtered_table(fn(
+    batch,
+    rows,
+  ) {
+    try! rows.for_each(fn(row_index) {
+      mark_dirty_tree_chain(transforms, parents, batch.entity(row_index))
+    })
   })
+  if !used_batch {
+    try! changed_transforms.for_each(fn(_entity, changed_entity) {
+      mark_dirty_tree_chain(transforms, parents, changed_entity)
+    })
+  }
   for entity in orphaned_entities {
     mark_dirty_tree_chain(transforms, parents, entity)
   }
@@ -715,7 +689,7 @@ pub fn propagate_parent_transforms(world : @ecs.World) -> Unit {
   propagate_parent_transforms_dense(
     world,
     columns,
-    static_optimizations.enabled,
+    static_optimizations.is_enabled(),
   )
 }
 
diff --git a/mgstudio-engine/transform/transform_test.mbt b/mgstudio-engine/transform/transform_test.mbt
index 6388b0bc7..6fdf4b765 100644
--- a/mgstudio-engine/transform/transform_test.mbt
+++ b/mgstudio-engine/transform/transform_test.mbt
@@ -497,43 +497,15 @@ test "transform ecs: mark_dirty_trees marks ancestor chain" {
 }
 
 ///|
-test "transform ecs: mark_dirty_trees disables static optimization above threshold" {
-  let world = @ecs.World::new()
-  defer world.close()
-  let entity_a = world.spawn_empty()
-  let entity_b = world.spawn_empty()
-
-  prepare_transform_world(world)
-  world.insert_resource(
-    static_transform_optimizations_resource_key,
-    StaticTransformOptimizations::from_threshold(0.3F),
-  )
-  next_system_ticks(world) |> ignore
-  try! world.set_by_key(
-    entity_a,
-    ecs_key_transform,
-    Transform::from_xy_rotation_scale(
-      @math.Vec2::new(1.0F, 0.0F),
-      0.0F,
-      @math.Vec2::new(1.0F, 1.0F),
-    ),
+test "transform ecs: static optimization mode is explicit" {
+  debug_inspect(
+    StaticTransformOptimizations::StaticTransformOptimizations().is_enabled(),
+    content="true",
   )
-  try! world.set_by_key(
-    entity_b,
-    ecs_key_transform,
-    Transform::from_xy_rotation_scale(
-      @math.Vec2::new(2.0F, 0.0F),
-      0.0F,
-      @math.Vec2::new(1.0F, 1.0F),
-    ),
+  debug_inspect(
+    StaticTransformOptimizations::disabled().is_enabled(),
+    content="false",
   )
-
-  mark_dirty_trees(world)
-
-  let state = world
-    .get_resource(static_transform_optimizations_resource_key)
-    .unwrap()
-  debug_inspect(state.enabled, content="false")
 }
 
 ///|
@@ -621,7 +593,7 @@ test "transform plugin: keeps preinserted static optimization resource" {
     .world()
     .get_resource(static_transform_optimizations_resource_key)
     .unwrap()
-  debug_inspect(value.threshold == 0.0F && !value.enabled, content="true")
+  debug_inspect(value.is_enabled(), content="false")
 }
 
 ///|
diff --git a/mgstudio-engine/ui/builder_api_test.mbt b/mgstudio-engine/ui/builder_api_test.mbt
index 637b5377b..c8422ab45 100644
--- a/mgstudio-engine/ui/builder_api_test.mbt
+++ b/mgstudio-engine/ui/builder_api_test.mbt
@@ -63,7 +63,7 @@ test "ui: atlas image builder keeps image and atlas together" {
   let image_node = ImageNode::from_atlas_image(image, texture_atlas)
   debug_inspect(image_node.image.id() == image.id(), content="true")
   let has_matching_atlas = match image_node.texture_atlas {
-    Some(atlas) => atlas.index == 3 && atlas.layout.id() == 9
+    Some(atlas) => atlas.index == 3 && atlas.layout().id() == 9
     None => false
   }
   debug_inspect(has_matching_atlas, content="true")
diff --git a/mgstudio-engine/ui/moon.pkg b/mgstudio-engine/ui/moon.pkg
index 652f0f9f1..d76cb26e7 100644
--- a/mgstudio-engine/ui/moon.pkg
+++ b/mgstudio-engine/ui/moon.pkg
@@ -20,10 +20,10 @@ import {
   "Milky2018/mgstudio/window",
   "Milky2018/mgstudio/ecs",
   "Milky2018/moon_accesskit",
-  "Milky2018/moon_taffy/geometry" @taffy_geometry,
-  "Milky2018/moon_taffy/style" @taffy_style,
-  "Milky2018/moon_taffy/style_helpers" @taffy_helpers,
-  "Milky2018/moon_taffy/tree" @taffy_tree,
+  "Milky2018/chicle/geometry" @chicle_geometry,
+  "Milky2018/chicle/style" @chicle_style,
+  "Milky2018/chicle/style_helpers" @chicle_helpers,
+  "Milky2018/chicle/tree" @chicle_tree,
   "moonbitlang/core/hashmap",
   "moonbitlang/core/json",
   "moonbitlang/core/ref",
diff --git a/mgstudio-engine/ui/ui.mbt b/mgstudio-engine/ui/ui.mbt
index 7ad5afea9..3fb458264 100644
--- a/mgstudio-engine/ui/ui.mbt
+++ b/mgstudio-engine/ui/ui.mbt
@@ -1615,7 +1615,7 @@ pub fn ui_image_content_size_system(world : @ecs.World) -> Unit {
   }
 
   fn atlas_rect_for(atlas : @asset.TextureAtlas) -> @math.Rect? {
-    match @asset.asset_get_texture_atlas_layout(atlas.layout) {
+    match @asset.asset_get_texture_atlas_layout(atlas.layout()) {
       Some(layout_value) =>
         if atlas.index >= 0 && atlas.index < layout_value.textures.length() {
           Some(layout_value.textures[atlas.index].as_rect())
@@ -1754,20 +1754,20 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
 
   let mut root_viewport_size = @math.Vec2::new(0.0F, 0.0F)
 
-  fn dim_for_val(val : Val) -> @taffy_style.Dimension {
+  fn dim_for_val(val : Val) -> @chicle_style.Dimension {
     match val {
-      Auto => @taffy_helpers.auto()
-      Px(px) => @taffy_helpers.length(f2d(px))
-      Percent(p) => @taffy_helpers.percent(f2d(p / 100.0F))
-      Vw(p) => @taffy_helpers.length(f2d(root_viewport_size.x * (p / 100.0F)))
-      Vh(p) => @taffy_helpers.length(f2d(root_viewport_size.y * (p / 100.0F)))
+      Auto => @chicle_helpers.auto()
+      Px(px) => @chicle_helpers.length(f2d(px))
+      Percent(p) => @chicle_helpers.percent(f2d(p / 100.0F))
+      Vw(p) => @chicle_helpers.length(f2d(root_viewport_size.x * (p / 100.0F)))
+      Vh(p) => @chicle_helpers.length(f2d(root_viewport_size.y * (p / 100.0F)))
       VMin(p) => {
         let m = if root_viewport_size.x < root_viewport_size.y {
           root_viewport_size.x
         } else {
           root_viewport_size.y
         }
-        @taffy_helpers.length(f2d(m * (p / 100.0F)))
+        @chicle_helpers.length(f2d(m * (p / 100.0F)))
       }
       VMax(p) => {
         let m = if root_viewport_size.x > root_viewport_size.y {
@@ -1775,7 +1775,7 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
         } else {
           root_viewport_size.y
         }
-        @taffy_helpers.length(f2d(m * (p / 100.0F)))
+        @chicle_helpers.length(f2d(m * (p / 100.0F)))
       }
     }
   }
@@ -1820,8 +1820,8 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
 
   fn rect_for_uirect(
     r : UiRect,
-  ) -> @taffy_geometry.Rect[@taffy_style.Dimension] {
-    @taffy_geometry.Rect(
+  ) -> @chicle_geometry.Rect[@chicle_style.Dimension] {
+    @chicle_geometry.Rect(
       left=dim_for_val(r.left),
       right=dim_for_val(r.right),
       top=dim_for_val(r.top),
@@ -1832,259 +1832,265 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
   fn size_for_vals(
     w : Val,
     h : Val,
-  ) -> @taffy_geometry.Size[@taffy_style.Dimension] {
-    @taffy_geometry.Size(width=dim_for_val(w), height=dim_for_val(h))
+  ) -> @chicle_geometry.Size[@chicle_style.Dimension] {
+    @chicle_geometry.Size(width=dim_for_val(w), height=dim_for_val(h))
   }
 
-  fn grid_track_to_taffy(track : GridTrack) -> @taffy_style.Dimension {
+  fn grid_track_to_chicle(track : GridTrack) -> @chicle_style.Dimension {
     match track {
-      GridTrack::Auto => @taffy_helpers.auto()
-      GridTrack::Px(px) => @taffy_helpers.length(f2d(px))
-      GridTrack::Percent(p) => @taffy_helpers.percent(f2d(p))
-      GridTrack::Fr(w) => @taffy_helpers.fr(f2d(w))
-      GridTrack::MinContent => @taffy_helpers.grid_min_content()
-      GridTrack::MaxContent => @taffy_helpers.grid_max_content()
+      GridTrack::Auto => @chicle_helpers.auto()
+      GridTrack::Px(px) => @chicle_helpers.length(f2d(px))
+      GridTrack::Percent(p) => @chicle_helpers.percent(f2d(p))
+      GridTrack::Fr(w) => @chicle_helpers.fr(f2d(w))
+      GridTrack::MinContent => @chicle_helpers.grid_min_content()
+      GridTrack::MaxContent => @chicle_helpers.grid_max_content()
     }
   }
 
-  fn grid_track_repetition_to_taffy(
+  fn grid_track_repetition_to_chicle(
     repetition : GridTrackRepetition,
-  ) -> @taffy_style.GridTrackRepetition {
+  ) -> @chicle_style.GridTrackRepetition {
     match repetition {
-      GridTrackRepetition::Count(n) => @taffy_helpers.repeat_count(n)
-      GridTrackRepetition::AutoFill => @taffy_helpers.repeat_auto_fill()
-      GridTrackRepetition::AutoFit => @taffy_helpers.repeat_auto_fit()
+      GridTrackRepetition::Count(n) => @chicle_helpers.repeat_count(n)
+      GridTrackRepetition::AutoFill => @chicle_helpers.repeat_auto_fill()
+      GridTrackRepetition::AutoFit => @chicle_helpers.repeat_auto_fit()
     }
   }
 
-  fn repeated_grid_track_to_taffy(
+  fn repeated_grid_track_to_chicle(
     rep : RepeatedGridTrack,
-  ) -> @taffy_style.Dimension {
-    let tracks : Array[@taffy_style.Dimension] = []
+  ) -> @chicle_style.Dimension {
+    let tracks : Array[@chicle_style.Dimension] = []
     for track in rep.tracks {
-      tracks.push(grid_track_to_taffy(track))
+      tracks.push(grid_track_to_chicle(track))
     }
     match rep.repetition {
       GridTrackRepetition::Count(1) =>
         if tracks.length() == 1 {
           tracks[0]
         } else {
-          @taffy_helpers.repeat(
-            grid_track_repetition_to_taffy(rep.repetition),
+          @chicle_helpers.repeat(
+            grid_track_repetition_to_chicle(rep.repetition),
             tracks,
           )
         }
       _ =>
-        @taffy_helpers.repeat(
-          grid_track_repetition_to_taffy(rep.repetition),
+        @chicle_helpers.repeat(
+          grid_track_repetition_to_chicle(rep.repetition),
           tracks,
         )
     }
   }
 
-  fn grid_template_to_taffy(
+  fn grid_template_to_chicle(
     template : Array[RepeatedGridTrack],
-  ) -> Array[@taffy_style.Dimension] {
-    let dims : Array[@taffy_style.Dimension] = []
+  ) -> Array[@chicle_style.Dimension] {
+    let dims : Array[@chicle_style.Dimension] = []
     for rep in template {
-      dims.push(repeated_grid_track_to_taffy(rep))
+      dims.push(repeated_grid_track_to_chicle(rep))
     }
     dims
   }
 
-  fn grid_tracks_to_taffy(
+  fn grid_tracks_to_chicle(
     tracks : Array[GridTrack],
-  ) -> Array[@taffy_style.Dimension] {
-    let dims : Array[@taffy_style.Dimension] = []
+  ) -> Array[@chicle_style.Dimension] {
+    let dims : Array[@chicle_style.Dimension] = []
     for track in tracks {
-      dims.push(grid_track_to_taffy(track))
+      dims.push(grid_track_to_chicle(track))
     }
     dims
   }
 
-  fn overflow_axis_to_taffy(axis : OverflowAxis) -> @taffy_style.Overflow {
+  fn overflow_axis_to_chicle(axis : OverflowAxis) -> @chicle_style.Overflow {
     match axis {
-      OverflowAxis::Visible => @taffy_helpers.overflow_visible()
-      OverflowAxis::Hidden => @taffy_helpers.overflow_hidden()
-      OverflowAxis::Scroll => @taffy_helpers.overflow_scroll()
-      OverflowAxis::Clip => @taffy_helpers.overflow_clip()
+      OverflowAxis::Visible => @chicle_helpers.overflow_visible()
+      OverflowAxis::Hidden => @chicle_helpers.overflow_hidden()
+      OverflowAxis::Scroll => @chicle_helpers.overflow_scroll()
+      OverflowAxis::Clip => @chicle_helpers.overflow_clip()
     }
   }
 
-  fn overflow_to_taffy(
+  fn overflow_to_chicle(
     overflow : Overflow,
-  ) -> @taffy_geometry.Point[@taffy_style.Overflow] {
-    @taffy_geometry.Point(
-      x=overflow_axis_to_taffy(overflow.x),
-      y=overflow_axis_to_taffy(overflow.y),
+  ) -> @chicle_geometry.Point[@chicle_style.Overflow] {
+    @chicle_geometry.Point(
+      x=overflow_axis_to_chicle(overflow.x),
+      y=overflow_axis_to_chicle(overflow.y),
     )
   }
 
-  fn display_to_taffy(display : Display) -> @taffy_style.Display {
+  fn display_to_chicle(display : Display) -> @chicle_style.Display {
     match display {
-      Display::Block => @taffy_helpers.display_block()
-      Display::Flex => @taffy_helpers.display_flex()
-      Display::Grid => @taffy_helpers.display_grid()
-      Display::None => @taffy_helpers.display_none()
+      Display::Block => @chicle_helpers.display_block()
+      Display::Flex => @chicle_helpers.display_flex()
+      Display::Grid => @chicle_helpers.display_grid()
+      Display::None => @chicle_helpers.display_none()
     }
   }
 
-  fn position_to_taffy(position_type : PositionType) -> @taffy_style.Position {
+  fn position_to_chicle(
+    position_type : PositionType,
+  ) -> @chicle_style.Position {
     match position_type {
-      PositionType::Relative => @taffy_helpers.position_relative()
-      PositionType::Absolute => @taffy_helpers.position_absolute()
+      PositionType::Relative => @chicle_helpers.position_relative()
+      PositionType::Absolute => @chicle_helpers.position_absolute()
     }
   }
 
-  fn flex_direction_to_taffy(
+  fn flex_direction_to_chicle(
     dir : FlexDirection,
-  ) -> @taffy_style.FlexDirection {
+  ) -> @chicle_style.FlexDirection {
     match dir {
-      FlexDirection::Row => @taffy_helpers.flex_direction_row()
-      FlexDirection::RowReverse => @taffy_helpers.flex_direction_row_reverse()
-      FlexDirection::Column => @taffy_helpers.flex_direction_column()
+      FlexDirection::Row => @chicle_helpers.flex_direction_row()
+      FlexDirection::RowReverse => @chicle_helpers.flex_direction_row_reverse()
+      FlexDirection::Column => @chicle_helpers.flex_direction_column()
       FlexDirection::ColumnReverse =>
-        @taffy_helpers.flex_direction_column_reverse()
+        @chicle_helpers.flex_direction_column_reverse()
     }
   }
 
-  fn flex_wrap_to_taffy(wrap : FlexWrap) -> @taffy_style.FlexWrap {
+  fn flex_wrap_to_chicle(wrap : FlexWrap) -> @chicle_style.FlexWrap {
     match wrap {
-      FlexWrap::NoWrap => @taffy_helpers.flex_wrap_no_wrap()
-      FlexWrap::Wrap => @taffy_helpers.flex_wrap_wrap()
-      FlexWrap::WrapReverse => @taffy_helpers.flex_wrap_wrap_reverse()
+      FlexWrap::NoWrap => @chicle_helpers.flex_wrap_no_wrap()
+      FlexWrap::Wrap => @chicle_helpers.flex_wrap_wrap()
+      FlexWrap::WrapReverse => @chicle_helpers.flex_wrap_wrap_reverse()
     }
   }
 
-  fn align_items_to_taffy(items : AlignItems) -> @taffy_style.AlignItems? {
+  fn align_items_to_chicle(items : AlignItems) -> @chicle_style.AlignItems? {
     match items {
       AlignItems::Default => None
-      AlignItems::Baseline => Some(@taffy_helpers.align_items_baseline())
-      AlignItems::Center => Some(@taffy_helpers.align_items_center())
-      AlignItems::End => Some(@taffy_helpers.align_items_end())
-      AlignItems::FlexEnd => Some(@taffy_helpers.align_items_flex_end())
-      AlignItems::FlexStart => Some(@taffy_helpers.align_items_flex_start())
-      AlignItems::Start => Some(@taffy_helpers.align_items_start())
-      AlignItems::Stretch => Some(@taffy_helpers.align_items_stretch())
+      AlignItems::Baseline => Some(@chicle_helpers.align_items_baseline())
+      AlignItems::Center => Some(@chicle_helpers.align_items_center())
+      AlignItems::End => Some(@chicle_helpers.align_items_end())
+      AlignItems::FlexEnd => Some(@chicle_helpers.align_items_flex_end())
+      AlignItems::FlexStart => Some(@chicle_helpers.align_items_flex_start())
+      AlignItems::Start => Some(@chicle_helpers.align_items_start())
+      AlignItems::Stretch => Some(@chicle_helpers.align_items_stretch())
     }
   }
 
-  fn justify_items_to_taffy(
+  fn justify_items_to_chicle(
     items : JustifyItems,
-  ) -> @taffy_style.JustifyItems? {
+  ) -> @chicle_style.JustifyItems? {
     match items {
       JustifyItems::Default => None
-      JustifyItems::Baseline => Some(@taffy_helpers.align_items_baseline())
-      JustifyItems::Center => Some(@taffy_helpers.align_items_center())
-      JustifyItems::End => Some(@taffy_helpers.align_items_end())
-      JustifyItems::Start => Some(@taffy_helpers.align_items_start())
-      JustifyItems::Stretch => Some(@taffy_helpers.align_items_stretch())
+      JustifyItems::Baseline => Some(@chicle_helpers.align_items_baseline())
+      JustifyItems::Center => Some(@chicle_helpers.align_items_center())
+      JustifyItems::End => Some(@chicle_helpers.align_items_end())
+      JustifyItems::Start => Some(@chicle_helpers.align_items_start())
+      JustifyItems::Stretch => Some(@chicle_helpers.align_items_stretch())
     }
   }
 
-  fn align_self_to_taffy(align_self : AlignSelf) -> @taffy_style.AlignSelf? {
+  fn align_self_to_chicle(align_self : AlignSelf) -> @chicle_style.AlignSelf? {
     match align_self {
       AlignSelf::Auto => None
-      AlignSelf::Baseline => Some(@taffy_helpers.align_items_baseline())
-      AlignSelf::Center => Some(@taffy_helpers.align_items_center())
-      AlignSelf::End => Some(@taffy_helpers.align_items_end())
-      AlignSelf::FlexEnd => Some(@taffy_helpers.align_items_flex_end())
-      AlignSelf::FlexStart => Some(@taffy_helpers.align_items_flex_start())
-      AlignSelf::Start => Some(@taffy_helpers.align_items_start())
-      AlignSelf::Stretch => Some(@taffy_helpers.align_items_stretch())
+      AlignSelf::Baseline => Some(@chicle_helpers.align_items_baseline())
+      AlignSelf::Center => Some(@chicle_helpers.align_items_center())
+      AlignSelf::End => Some(@chicle_helpers.align_items_end())
+      AlignSelf::FlexEnd => Some(@chicle_helpers.align_items_flex_end())
+      AlignSelf::FlexStart => Some(@chicle_helpers.align_items_flex_start())
+      AlignSelf::Start => Some(@chicle_helpers.align_items_start())
+      AlignSelf::Stretch => Some(@chicle_helpers.align_items_stretch())
     }
   }
 
-  fn justify_self_to_taffy(
+  fn justify_self_to_chicle(
     justify_self : JustifySelf,
-  ) -> @taffy_style.JustifySelf? {
+  ) -> @chicle_style.JustifySelf? {
     match justify_self {
       JustifySelf::Auto => None
-      JustifySelf::Baseline => Some(@taffy_helpers.align_items_baseline())
-      JustifySelf::Center => Some(@taffy_helpers.align_items_center())
-      JustifySelf::End => Some(@taffy_helpers.align_items_end())
-      JustifySelf::Start => Some(@taffy_helpers.align_items_start())
-      JustifySelf::Stretch => Some(@taffy_helpers.align_items_stretch())
+      JustifySelf::Baseline => Some(@chicle_helpers.align_items_baseline())
+      JustifySelf::Center => Some(@chicle_helpers.align_items_center())
+      JustifySelf::End => Some(@chicle_helpers.align_items_end())
+      JustifySelf::Start => Some(@chicle_helpers.align_items_start())
+      JustifySelf::Stretch => Some(@chicle_helpers.align_items_stretch())
     }
   }
 
-  fn align_content_to_taffy(
+  fn align_content_to_chicle(
     content : AlignContent,
-  ) -> @taffy_style.AlignContent? {
+  ) -> @chicle_style.AlignContent? {
     match content {
       AlignContent::Default => None
-      AlignContent::Center => Some(@taffy_helpers.align_content_center())
-      AlignContent::End => Some(@taffy_helpers.align_content_end())
-      AlignContent::FlexEnd => Some(@taffy_helpers.align_content_flex_end())
-      AlignContent::FlexStart => Some(@taffy_helpers.align_content_flex_start())
+      AlignContent::Center => Some(@chicle_helpers.align_content_center())
+      AlignContent::End => Some(@chicle_helpers.align_content_end())
+      AlignContent::FlexEnd => Some(@chicle_helpers.align_content_flex_end())
+      AlignContent::FlexStart =>
+        Some(@chicle_helpers.align_content_flex_start())
       AlignContent::SpaceAround =>
-        Some(@taffy_helpers.align_content_space_around())
+        Some(@chicle_helpers.align_content_space_around())
       AlignContent::SpaceBetween =>
-        Some(@taffy_helpers.align_content_space_between())
+        Some(@chicle_helpers.align_content_space_between())
       AlignContent::SpaceEvenly =>
-        Some(@taffy_helpers.align_content_space_evenly())
-      AlignContent::Start => Some(@taffy_helpers.align_content_start())
-      AlignContent::Stretch => Some(@taffy_helpers.align_content_stretch())
+        Some(@chicle_helpers.align_content_space_evenly())
+      AlignContent::Start => Some(@chicle_helpers.align_content_start())
+      AlignContent::Stretch => Some(@chicle_helpers.align_content_stretch())
     }
   }
 
-  fn justify_content_to_taffy(
+  fn justify_content_to_chicle(
     content : JustifyContent,
-  ) -> @taffy_style.JustifyContent? {
+  ) -> @chicle_style.JustifyContent? {
     match content {
       JustifyContent::Default => None
-      JustifyContent::Center => Some(@taffy_helpers.justify_content_center())
-      JustifyContent::End => Some(@taffy_helpers.justify_content_end())
-      JustifyContent::FlexEnd => Some(@taffy_helpers.justify_content_flex_end())
+      JustifyContent::Center => Some(@chicle_helpers.justify_content_center())
+      JustifyContent::End => Some(@chicle_helpers.justify_content_end())
+      JustifyContent::FlexEnd =>
+        Some(@chicle_helpers.justify_content_flex_end())
       JustifyContent::FlexStart =>
-        Some(@taffy_helpers.justify_content_flex_start())
+        Some(@chicle_helpers.justify_content_flex_start())
       JustifyContent::SpaceAround =>
-        Some(@taffy_helpers.justify_content_space_around())
+        Some(@chicle_helpers.justify_content_space_around())
       JustifyContent::SpaceBetween =>
-        Some(@taffy_helpers.justify_content_space_between())
+        Some(@chicle_helpers.justify_content_space_between())
       JustifyContent::SpaceEvenly =>
-        Some(@taffy_helpers.justify_content_space_evenly())
-      JustifyContent::Start => Some(@taffy_helpers.justify_content_start())
-      JustifyContent::Stretch => Some(@taffy_helpers.justify_content_stretch())
+        Some(@chicle_helpers.justify_content_space_evenly())
+      JustifyContent::Start => Some(@chicle_helpers.justify_content_start())
+      JustifyContent::Stretch => Some(@chicle_helpers.justify_content_stretch())
     }
   }
 
-  fn grid_auto_flow_to_taffy(flow : GridAutoFlow) -> @taffy_style.GridAutoFlow {
+  fn grid_auto_flow_to_chicle(
+    flow : GridAutoFlow,
+  ) -> @chicle_style.GridAutoFlow {
     match flow {
-      GridAutoFlow::Row => @taffy_helpers.grid_auto_flow_row()
-      GridAutoFlow::RowDense => @taffy_helpers.grid_auto_flow_row_dense()
-      GridAutoFlow::Column => @taffy_helpers.grid_auto_flow_column()
-      GridAutoFlow::ColumnDense => @taffy_helpers.grid_auto_flow_column_dense()
+      GridAutoFlow::Row => @chicle_helpers.grid_auto_flow_row()
+      GridAutoFlow::RowDense => @chicle_helpers.grid_auto_flow_row_dense()
+      GridAutoFlow::Column => @chicle_helpers.grid_auto_flow_column()
+      GridAutoFlow::ColumnDense => @chicle_helpers.grid_auto_flow_column_dense()
     }
   }
 
-  fn grid_placement_to_taffy(
+  fn grid_placement_to_chicle(
     value : GridPlacement,
-  ) -> @taffy_geometry.Line[@taffy_style.GridPlacement] {
+  ) -> @chicle_geometry.Line[@chicle_style.GridPlacement] {
     let span = match value.span {
       Some(v) => if v == 0 { 1 } else { v }
       None => 1
     }
     match (value.start, value.end) {
       (Some(start), Some(end)) =>
-        @taffy_geometry.Line(
-          start=@taffy_helpers.line(start),
-          end=@taffy_helpers.line(end),
+        @chicle_geometry.Line(
+          start=@chicle_helpers.line(start),
+          end=@chicle_helpers.line(end),
         )
       (Some(start), None) =>
-        @taffy_geometry.Line(
-          start=@taffy_helpers.line(start),
-          end=@taffy_helpers.span(span),
+        @chicle_geometry.Line(
+          start=@chicle_helpers.line(start),
+          end=@chicle_helpers.span(span),
         )
       (None, Some(end)) =>
-        @taffy_geometry.Line(
-          start=@taffy_helpers.span(span),
-          end=@taffy_helpers.line(end),
+        @chicle_geometry.Line(
+          start=@chicle_helpers.span(span),
+          end=@chicle_helpers.line(end),
         )
       (None, None) =>
-        @taffy_geometry.Line(
-          start=@taffy_helpers.span(span),
-          end=@taffy_helpers.place_auto(),
+        @chicle_geometry.Line(
+          start=@chicle_helpers.span(span),
+          end=@chicle_helpers.place_auto(),
         )
     }
   }
@@ -2096,16 +2102,16 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
   fn style_for_entity(
     entity : @core.Entity,
     is_root : Bool,
-  ) -> @taffy_style.Style {
+  ) -> @chicle_style.Style {
     let node = match (try! world.get_by_key(entity, ecs_key_node)) {
       Some(v) => v
       None => Node::Node()
     }
-    let mut style = @taffy_style.Style::default()
-      .with_display(display_to_taffy(node.display))
-      .with_position(position_to_taffy(node.position_type))
+    let mut style = @chicle_style.Style::default()
+      .with_display(display_to_chicle(node.display))
+      .with_position(position_to_chicle(node.position_type))
       .with_inset(
-        @taffy_geometry.Rect(
+        @chicle_geometry.Rect(
           left=dim_for_val(node.left),
           right=dim_for_val(node.right),
           top=dim_for_val(node.top),
@@ -2118,62 +2124,62 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
       .with_size(size_for_vals(node.width, node.height))
       .with_min_size(size_for_vals(node.min_width, node.min_height))
       .with_max_size(size_for_vals(node.max_width, node.max_height))
-      .with_flex_direction(flex_direction_to_taffy(node.flex_direction))
-      .with_flex_wrap(flex_wrap_to_taffy(node.flex_wrap))
+      .with_flex_direction(flex_direction_to_chicle(node.flex_direction))
+      .with_flex_wrap(flex_wrap_to_chicle(node.flex_wrap))
       .with_flex_grow(node.flex_grow.to_double())
       .with_flex_shrink(node.flex_shrink.to_double())
       .with_flex_basis(dim_for_val(node.flex_basis))
-      .with_grid_template_rows(grid_template_to_taffy(node.grid_template_rows))
+      .with_grid_template_rows(grid_template_to_chicle(node.grid_template_rows))
       .with_grid_template_columns(
-        grid_template_to_taffy(node.grid_template_columns),
+        grid_template_to_chicle(node.grid_template_columns),
       )
-      .with_grid_auto_rows(grid_tracks_to_taffy(node.grid_auto_rows))
-      .with_grid_auto_columns(grid_tracks_to_taffy(node.grid_auto_columns))
-      .with_grid_auto_flow(grid_auto_flow_to_taffy(node.grid_auto_flow))
-      .with_grid_row(grid_placement_to_taffy(node.grid_row))
-      .with_grid_column(grid_placement_to_taffy(node.grid_column))
+      .with_grid_auto_rows(grid_tracks_to_chicle(node.grid_auto_rows))
+      .with_grid_auto_columns(grid_tracks_to_chicle(node.grid_auto_columns))
+      .with_grid_auto_flow(grid_auto_flow_to_chicle(node.grid_auto_flow))
+      .with_grid_row(grid_placement_to_chicle(node.grid_row))
+      .with_grid_column(grid_placement_to_chicle(node.grid_column))
       .with_gap(
-        @taffy_geometry.Size(
+        @chicle_geometry.Size(
           width=dim_for_val(node.column_gap),
           height=dim_for_val(node.row_gap),
         ),
       )
-      .with_overflow(overflow_to_taffy(node.overflow))
+      .with_overflow(overflow_to_chicle(node.overflow))
       .with_scrollbar_width(node.scrollbar_width.to_double())
     if node.aspect_ratio is Some(r) {
       style = style.with_aspect_ratio(r.to_double())
     }
-    match align_items_to_taffy(node.align_items) {
+    match align_items_to_chicle(node.align_items) {
       Some(v) => style = style.with_align_items(v)
       None => ()
     }
-    match justify_items_to_taffy(node.justify_items) {
+    match justify_items_to_chicle(node.justify_items) {
       Some(v) => style = style.with_justify_items(v)
       None => ()
     }
-    match align_content_to_taffy(node.align_content) {
+    match align_content_to_chicle(node.align_content) {
       Some(v) => style = style.with_align_content(v)
       None => ()
     }
-    match justify_content_to_taffy(node.justify_content) {
+    match justify_content_to_chicle(node.justify_content) {
       Some(v) => style = style.with_justify_content(v)
       None => ()
     }
-    match align_self_to_taffy(node.align_self) {
+    match align_self_to_chicle(node.align_self) {
       Some(v) => style = style.with_align_self(v)
       None => ()
     }
-    match justify_self_to_taffy(node.justify_self) {
+    match justify_self_to_chicle(node.justify_self) {
       Some(v) => style = style.with_justify_self(v)
       None => ()
     }
     if is_root {
       style = style
-        .with_position(@taffy_helpers.position_relative())
+        .with_position(@chicle_helpers.position_relative())
         .with_size(
-          @taffy_geometry.Size(
-            width=@taffy_helpers.length(f2d(root_viewport_size.x)),
-            height=@taffy_helpers.length(f2d(root_viewport_size.y)),
+          @chicle_geometry.Size(
+            width=@chicle_helpers.length(f2d(root_viewport_size.x)),
+            height=@chicle_helpers.length(f2d(root_viewport_size.y)),
           ),
         )
     }
@@ -2188,7 +2194,7 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
       @math.Vec2::new(0.0F, 0.0F),
       @math.Vec2::new(root_ctx.viewport_size.x, root_ctx.viewport_size.y),
     )
-    let taffy = @taffy_tree.TaffyTree()
+    let chicle = @chicle_tree.ChicleTree()
     let entity_to_node : @hashmap.HashMap[(Int, Int), Int] = @hashmap.HashMap([])
     fn build(entity : @core.Entity, is_root : Bool) -> Array[Int] {
       let child_ids : Array[Int] = []
@@ -2202,13 +2208,13 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
       }
       let style = style_for_entity(entity, is_root)
       let id = if child_ids.length() == 0 {
-        taffy.new_leaf(style)
+        chicle.new_leaf(style)
       } else {
-        taffy.new_with_children(style, child_ids)
+        chicle.new_with_children(style, child_ids)
       }
       if (try! world.contains_by_key(entity, ecs_key_content_size)) ||
         (try! world.contains_by_key(entity, @text.ecs_key_text)) {
-        try! taffy.set_node_context(id, entity)
+        try! chicle.set_node_context(id, entity)
       }
       entity_to_node.set(entity_key(entity), id)
       [id]
@@ -2223,38 +2229,38 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
       root_children.length() == 1 {
       root_children[0]
     } else {
-      let viewport_root_style = @taffy_style.Style::default()
-        .with_position(@taffy_helpers.position_relative())
+      let viewport_root_style = @chicle_style.Style::default()
+        .with_position(@chicle_helpers.position_relative())
         .with_size(
-          @taffy_geometry.Size(
-            width=@taffy_helpers.length(f2d(root_ctx.viewport_size.x)),
-            height=@taffy_helpers.length(f2d(root_ctx.viewport_size.y)),
+          @chicle_geometry.Size(
+            width=@chicle_helpers.length(f2d(root_ctx.viewport_size.x)),
+            height=@chicle_helpers.length(f2d(root_ctx.viewport_size.y)),
           ),
         )
-      taffy.new_with_children(viewport_root_style, root_children)
+      chicle.new_with_children(viewport_root_style, root_children)
     }
-    let avail = @taffy_geometry.Size(
-      width=@taffy_helpers.available_space_definite(
+    let avail = @chicle_geometry.Size(
+      width=@chicle_helpers.available_space_definite(
         f2d(root_ctx.viewport_size.x),
       ),
-      height=@taffy_helpers.available_space_definite(
+      height=@chicle_helpers.available_space_definite(
         f2d(root_ctx.viewport_size.y),
       ),
     )
-    fn available_to_option(v : @taffy_geometry.AvailableSpace) -> Double? {
+    fn available_to_option(v : @chicle_geometry.AvailableSpace) -> Double? {
       match v {
-        @taffy_geometry.AvailDefinite(x) => Some(x)
+        @chicle_geometry.AvailDefinite(x) => Some(x)
         _ => None
       }
     }
 
     fn resolve_dimension(
-      dim : @taffy_style.Dimension,
+      dim : @chicle_style.Dimension,
       parent : Double?,
     ) -> Double? {
       match dim {
-        @taffy_style.DimLength(x) => Some(x)
-        @taffy_style.DimPercent(p) =>
+        @chicle_style.DimLength(x) => Some(x)
+        @chicle_style.DimPercent(p) =>
           match parent {
             Some(base) => Some(base * p)
             None => None
@@ -2288,12 +2294,12 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
     }
 
     fn measure(
-      known : @taffy_geometry.Size[Double?],
-      available : @taffy_geometry.Size[@taffy_geometry.AvailableSpace],
+      known : @chicle_geometry.Size[Double?],
+      available : @chicle_geometry.Size[@chicle_geometry.AvailableSpace],
       _node_id : Int,
       ctx : @core.Entity?,
-      style : @taffy_style.Style,
-    ) -> @taffy_geometry.Size[Double] {
+      style : @chicle_style.Style,
+    ) -> @chicle_geometry.Size[Double] {
       match ctx {
         Some(entity) => {
           let intrinsic = auto_size_for_entity(entity)
@@ -2345,13 +2351,13 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
           }
           let out_w = clamp_f64(width.unwrap_or(intrinsic_w), s_min_w, s_max_w)
           let out_h = clamp_f64(height.unwrap_or(intrinsic_h), s_min_h, s_max_h)
-          @taffy_geometry.Size(width=out_w, height=out_h)
+          @chicle_geometry.Size(width=out_w, height=out_h)
         }
-        None => @taffy_geometry.Size::zero()
+        None => @chicle_geometry.Size::zero()
       }
     }
 
-    taffy.compute_layout_with_measure(root_node_id, avail, measure) catch {
+    chicle.compute_layout_with_measure(root_node_id, avail, measure) catch {
       _ => return
     }
     fn apply_layout(entity : @core.Entity, parent_rect : @math.Rect) -> Unit {
@@ -2367,7 +2373,7 @@ pub fn ui_layout_system(world : @ecs.World) -> Unit {
       guard entity_to_node.get(entity_key(entity)) is Some(node_id) else {
         return
       }
-      let tl = taffy.layout(node_id) catch { _ => return }
+      let tl = chicle.layout(node_id) catch { _ => return }
       let parent_origin = parent_rect.min
       let loc = @math.Vec2::new(d2f(tl.location.x), d2f(tl.location.y))
       let size = @math.Vec2::new(d2f(tl.size.width), d2f(tl.size.height))
diff --git a/mgstudio-engine/ui_render/ui_render.mbt b/mgstudio-engine/ui_render/ui_render.mbt
index 31d9d2590..dc0af2de9 100644
--- a/mgstudio-engine/ui_render/ui_render.mbt
+++ b/mgstudio-engine/ui_render/ui_render.mbt
@@ -40,7 +40,7 @@ pub fn ui_render_extract_system(world : @ecs.World) -> Unit {
   ) -> @math.Rect? {
     match layouts {
       Some(layout_assets) =>
-        match layout_assets.get(atlas.layout) {
+        match atlas.layout_asset(layout_assets) {
           Some(layout_value) =>
             if atlas.index >= 0 && atlas.index < layout_value.textures.length() {
               Some(layout_value.textures[atlas.index].as_rect())
diff --git a/mgstudio-engine/visibility/moon.pkg b/mgstudio-engine/visibility/moon.pkg
index 1dccd5e41..43695a3f6 100644
--- a/mgstudio-engine/visibility/moon.pkg
+++ b/mgstudio-engine/visibility/moon.pkg
@@ -13,4 +13,8 @@ import {
   "Milky2018/mgstudio/asset",
 } for "test"
 
+import {
+  "moonbitlang/core/bench",
+} for "wbtest"
+
 supported_targets = "native"
diff --git a/mgstudio-engine/visibility/pkg.generated.mbti b/mgstudio-engine/visibility/pkg.generated.mbti
index 27711e5e0..a0343497d 100644
--- a/mgstudio-engine/visibility/pkg.generated.mbti
+++ b/mgstudio-engine/visibility/pkg.generated.mbti
@@ -9,8 +9,6 @@ import {
 }
 
 // Values
-pub fn check_visibility_system(@ecs.World) -> Unit
-
 pub let ecs_key_inherited_visibility : @ecs.ComponentKey[InheritedVisibility]
 
 pub let ecs_key_no_auto_aabb : @ecs.ComponentKey[NoAutoAabb]
@@ -70,15 +68,16 @@ pub fn NoFrustumCulling::NoFrustumCulling() -> Self
 pub impl @ecs.Component for NoFrustumCulling
 
 pub struct ViewVisibility {
-  mut bits : Int
+  bits : Int
 } derive(Eq, @debug.Debug)
+pub fn ViewVisibility::advance_frame(Self) -> Self
 pub fn ViewVisibility::get(Self) -> Bool
 pub fn ViewVisibility::hidden() -> Self
 pub fn ViewVisibility::is_visible(Self) -> Bool
 pub fn ViewVisibility::new(Bool) -> Self
-pub fn ViewVisibility::set_visible(Self) -> Unit
-pub fn ViewVisibility::update(Self) -> Unit
+pub fn ViewVisibility::visible() -> Self
 pub fn ViewVisibility::was_visible_now_hidden(Self) -> Bool
+pub fn ViewVisibility::with_visible(Self) -> Self
 pub impl @ecs.Component for ViewVisibility
 pub impl ToJson for ViewVisibility
 pub impl @json.FromJson for ViewVisibility
@@ -137,4 +136,8 @@ pub impl @json.FromJson for VisibilityRange
 // Type aliases
 
 // Traits
+pub(open) trait SetViewVisibility {
+  fn set_visible(Self) -> Unit
+}
+pub impl SetViewVisibility for @ecs.Write[ViewVisibility]
 
diff --git a/mgstudio-engine/visibility/view_visibility_change_detection_wbtest.mbt b/mgstudio-engine/visibility/view_visibility_change_detection_wbtest.mbt
new file mode 100644
index 000000000..b495b8a78
--- /dev/null
+++ b/mgstudio-engine/visibility/view_visibility_change_detection_wbtest.mbt
@@ -0,0 +1,115 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "visibility: view visibility only changes on semantic transitions" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let stable_visible = world.spawn()
+  let becomes_visible = world.spawn()
+  let becomes_hidden = world.spawn()
+  let stable_hidden = world.spawn()
+  for
+    pair in [
+      (stable_visible, true),
+      (becomes_visible, false),
+      (becomes_hidden, true),
+      (stable_hidden, false),
+    ] {
+    let (entity, visible) = pair
+    try! world.set_by_key(
+      entity,
+      ecs_key_view_visibility,
+      ViewVisibility::new(visible),
+    )
+  }
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let tick_context = @core.SystemTickContext::new()
+  tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(tick_context)
+
+  reset_view_visibility_system(world)
+  for entity in [stable_visible, becomes_visible] {
+    let view_visibility = (try! world.get_mut(
+      entity,
+      key=ecs_key_view_visibility,
+    )).unwrap()
+    SetViewVisibility::set_visible(view_visibility)
+  }
+  mark_newly_hidden_entities_invisible_system(world)
+
+  let changed = world
+    .changed_components(ecs_key_view_visibility, @core.SystemTicks::new(1, 2))
+    .read()
+  debug_inspect(changed.contains(stable_visible), content="false")
+  debug_inspect(changed.contains(becomes_visible), content="true")
+  debug_inspect(changed.contains(becomes_hidden), content="true")
+  debug_inspect(changed.contains(stable_hidden), content="false")
+  for
+    pair in [
+      (stable_visible, true),
+      (becomes_visible, true),
+      (becomes_hidden, false),
+      (stable_hidden, false),
+    ] {
+    let (entity, expected) = pair
+    let current = (try! world.get_by_key(entity, ecs_key_view_visibility)).unwrap()
+    debug_inspect(current.get() == expected, content="true")
+  }
+}
+
+///|
+test "visibility: gpu culling follows inherited visibility changes" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let entity = world.spawn()
+  try! world.set_by_key(
+    entity,
+    ecs_key_inherited_visibility,
+    InheritedVisibility::visible(),
+  )
+  try! world.set_by_key(
+    entity,
+    ecs_key_view_visibility,
+    ViewVisibility::hidden(),
+  )
+  try! world.set_by_key(
+    entity,
+    ecs_key_no_cpu_culling,
+    NoCpuCulling::NoCpuCulling(),
+  )
+  let first_tick_context = @core.SystemTickContext::new()
+  first_tick_context.set(@core.SystemTicks::new(0, 1))
+  world.set_tick_context(first_tick_context)
+
+  check_visibility_gpu_culling_system(world)
+  debug_inspect(
+    (try! world.get_by_key(entity, ecs_key_view_visibility)).unwrap().get(),
+    content="true",
+  )
+
+  world.increment_change_tick() |> ignore
+  world.increment_change_tick() |> ignore
+  let second_tick_context = @core.SystemTickContext::new()
+  second_tick_context.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(second_tick_context)
+  let inherited = (try! world.get_mut(entity, key=ecs_key_inherited_visibility)).unwrap()
+  inherited.set(InheritedVisibility::hidden())
+  check_visibility_gpu_culling_system(world)
+  debug_inspect(
+    (try! world.get_by_key(entity, ecs_key_view_visibility)).unwrap().get(),
+    content="false",
+  )
+}
diff --git a/mgstudio-engine/visibility/visibility.mbt b/mgstudio-engine/visibility/visibility.mbt
index b45493db6..3ff05af16 100644
--- a/mgstudio-engine/visibility/visibility.mbt
+++ b/mgstudio-engine/visibility/visibility.mbt
@@ -81,6 +81,7 @@ pub fn Visibility::toggle_visible_hidden(self : Visibility) -> Visibility {
 }
 
 ///|
+#valtype
 pub struct InheritedVisibility {
   visible : Bool
 } derive(Eq, Debug)
@@ -122,8 +123,9 @@ pub fn InheritedVisibility::is_visible(self : InheritedVisibility) -> Bool {
 }
 
 ///|
+#valtype
 pub struct ViewVisibility {
-  mut bits : Int
+  bits : Int
 } derive(Eq, Debug)
 
 ///|
@@ -147,6 +149,13 @@ pub fn ViewVisibility::hidden() -> ViewVisibility {
   ViewVisibility::new(false)
 }
 
+///|
+/// Returns the state used by entities that are visible in both the current and
+/// previous frame.
+pub fn ViewVisibility::visible() -> ViewVisibility {
+  ViewVisibility::{ bits: 3 }
+}
+
 ///|
 pub fn ViewVisibility::get(self : ViewVisibility) -> Bool {
   (self.bits & 1) != 0
@@ -165,15 +174,36 @@ pub fn ViewVisibility::was_visible_now_hidden(self : ViewVisibility) -> Bool {
 
 ///|
 // Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::ViewVisibility::update`.
-pub fn ViewVisibility::update(self : ViewVisibility) -> Unit {
-  self.bits = (self.bits & 1) << 1
+// This value-returning API intentionally does not keep Bevy's mutating method
+// name: an old `value.update()` call would otherwise compile and discard the
+// replacement value after the MoonBit value-type migration.
+pub fn ViewVisibility::advance_frame(self : ViewVisibility) -> ViewVisibility {
+  ViewVisibility::{ bits: (self.bits & 1) << 1 }
 }
 
 ///|
 // Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::SetViewVisibility::set_visible`.
-pub fn ViewVisibility::set_visible(self : ViewVisibility) -> Unit {
-  if (self.bits & 1) == 0 {
-    self.bits = self.bits | 1
+pub fn ViewVisibility::with_visible(self : ViewVisibility) -> ViewVisibility {
+  ViewVisibility::{ bits: self.bits | 1 }
+}
+
+///|
+// Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::SetViewVisibility`.
+pub(open) trait SetViewVisibility {
+  fn set_visible(Self) -> Unit
+}
+
+///|
+pub impl SetViewVisibility for @ecs.Write[ViewVisibility] with fn set_visible(
+  self,
+) {
+  let current = self.peek()
+  if (current.bits & 1) == 0 {
+    if (current.bits & 2) != 0 {
+      self.bypass_change_detection(fn(value) { value.with_visible() })
+    } else {
+      self.set(current.with_visible())
+    }
   }
 }
 
diff --git a/mgstudio-engine/visibility/visibility_bench_wbtest.mbt b/mgstudio-engine/visibility/visibility_bench_wbtest.mbt
new file mode 100644
index 000000000..bc375a89e
--- /dev/null
+++ b/mgstudio-engine/visibility/visibility_bench_wbtest.mbt
@@ -0,0 +1,31 @@
+// Copyright 2026 International Digital Economy Academy
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+///|
+test "bench visibility: reset view visibility" (b : @bench.T) {
+  let world = @ecs.World::new()
+  defer world.close()
+  for _ in 0..<102_400 {
+    let entity = world.spawn()
+    try! world.set_by_key(
+      entity,
+      ecs_key_view_visibility,
+      ViewVisibility::visible(),
+    )
+  }
+  b.bench(name="reset ViewVisibility x102400", count=50U, () => {
+    reset_view_visibility_system(world)
+    b.keep(world.read_change_tick())
+  })
+}
diff --git a/mgstudio-engine/visibility/visibility_system.mbt b/mgstudio-engine/visibility/visibility_system.mbt
index c07036d8c..d740181c7 100644
--- a/mgstudio-engine/visibility/visibility_system.mbt
+++ b/mgstudio-engine/visibility/visibility_system.mbt
@@ -181,16 +181,45 @@ pub fn visibility_propagate_system(world : @ecs.World) -> Unit {
     start_entities.push((entity, parent_visible))
   }
 
-  for entity in world.changed_components(ecs_key_visibility, tick).read() {
-    add_start_entity(world, start_entities, start_seen, entity)
-  }
-  for entity in world.added_components(ecs_key_visibility, tick).read() {
-    add_start_entity(world, start_entities, start_seen, entity)
-  }
-  for entity in world.changed_components(@hierarchy.ecs_key_parent, tick).read() {
-    add_start_entity(world, start_entities, start_seen, entity)
+  let changed_query : @ecs.Query[
+    @core.Entity,
+    (
+      @ecs.With[Visibility],
+      @ecs.With[InheritedVisibility],
+      @ecs.Or[(@ecs.Changed[Visibility], @ecs.Changed[@hierarchy.Parent])],
+    ),
+  ] = @ecs.query_filtered(
+    world,
+    (
+      @ecs.With::new(ecs_key_visibility),
+      @ecs.With::new(ecs_key_inherited_visibility),
+      @ecs.Or::new(
+        (
+          @ecs.Changed::new(ecs_key_visibility),
+          @ecs.Changed::new(@hierarchy.ecs_key_parent),
+        ),
+      ),
+    ),
+  )
+  let used_batch = try! changed_query.try_for_each_filtered_table(fn(
+    batch,
+    rows,
+  ) {
+    try! rows.for_each(fn(row_index) {
+      add_start_entity(
+        world,
+        start_entities,
+        start_seen,
+        batch.entity(row_index),
+      )
+    })
+  })
+  if !used_batch {
+    try! changed_query.for_each(fn(_entity, changed_entity) {
+      add_start_entity(world, start_entities, start_seen, changed_entity)
+    })
   }
-  for entity in world.added_components(@hierarchy.ecs_key_parent, tick).read() {
+  for entity in world.removed_components(@hierarchy.ecs_key_parent, tick).read() {
     add_start_entity(world, start_entities, start_seen, entity)
   }
   if start_entities.length() == 0 {
@@ -245,23 +274,45 @@ fn reset_view_visibility_system(world : @ecs.World) -> Unit {
     world,
     @ecs.Without::new(ecs_key_no_cpu_culling),
   )
-  try! query.view(fn(_entity, view_visibility) {
-    view_visibility.modify(fn(value) { value.update() })
+  try! query.for_each_table(fn(batch) {
+    let view_visibility = batch.write(ecs_key_view_visibility).unwrap()
+    view_visibility.update_inplace_bypass_change_detection(fn(values) {
+      for row_index in 0..<values.length() {
+        values[row_index] = values[row_index].advance_frame()
+      }
+    })
   })
 }
 
 ///|
-// Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::check_visibility`.
-pub fn check_visibility_system(world : @ecs.World) -> Unit {
+// Bevy source: `bevy/crates/bevy_camera/src/visibility/mod.rs::check_visibility_gpu_culling`.
+fn check_visibility_gpu_culling_system(world : @ecs.World) -> Unit {
   let query : @ecs.Query[
     (@ecs.Write[ViewVisibility], @ecs.Read[InheritedVisibility]),
-    @ecs.All,
-  ] = @ecs.query(world)
+    (
+      @ecs.With[NoCpuCulling],
+      @ecs.Or[(@ecs.Changed[InheritedVisibility], @ecs.Added[NoCpuCulling])],
+    ),
+  ] = @ecs.query_filtered(
+    world,
+    (
+      @ecs.With::new(ecs_key_no_cpu_culling),
+      @ecs.Or::new(
+        (
+          @ecs.Changed::new(ecs_key_inherited_visibility),
+          @ecs.Added::new(ecs_key_no_cpu_culling),
+        ),
+      ),
+    ),
+  )
   try! query.view(fn(_entity, data) {
     let (view_visibility, inherited_visibility) = data
-    if inherited_visibility.value().get() {
-      view_visibility.modify(fn(value) { value.set_visible() })
+    let next = if inherited_visibility.value().get() {
+      ViewVisibility::visible()
+    } else {
+      ViewVisibility::hidden()
     }
+    view_visibility.set_if_neq(next) |> ignore
   })
 }
 
@@ -272,12 +323,13 @@ fn mark_newly_hidden_entities_invisible_system(world : @ecs.World) -> Unit {
     world,
     @ecs.Without::new(ecs_key_no_cpu_culling),
   )
-  try! query.view(fn(_entity, view_visibility) {
-    view_visibility.modify(fn(value) {
-      if value.was_visible_now_hidden() {
-        value.bits = 0
+  try! query.for_each_table(fn(batch) {
+    let view_visibility = batch.write(ecs_key_view_visibility).unwrap()
+    for row_index in 0..<batch.length() {
+      if view_visibility.peek(row_index).was_visible_now_hidden() {
+        view_visibility.set(row_index, ViewVisibility::hidden())
       }
-    })
+    }
   })
 }
 
@@ -313,7 +365,7 @@ fn register_visibility_required_components(
   world.register_required_components_with(
     ecs_key_visibility,
     ecs_key_view_visibility,
-    fn() { ViewVisibility::new(true) },
+    fn() { ViewVisibility::hidden() },
   )
 }
 
@@ -344,8 +396,8 @@ pub fn visibility_plugin(app : @app.App[@ecs.World]) -> @app.App[@ecs.World] {
     .in_set(visibility_set_visibility_propagate),
   )
   .add_post_update_system_config(
-    @app.system(check_visibility_system)
-    .named("mgstudio.visibility.check_visibility")
+    @app.system(check_visibility_gpu_culling_system)
+    .named("mgstudio.visibility.check_visibility_gpu_culling")
     .in_set(visibility_set_check_visibility),
   )
   .add_post_update_system_config(
diff --git a/mgstudio-engine/visibility/visibility_system_test.mbt b/mgstudio-engine/visibility/visibility_system_test.mbt
index c15f31a81..8b2a44e2d 100644
--- a/mgstudio-engine/visibility/visibility_system_test.mbt
+++ b/mgstudio-engine/visibility/visibility_system_test.mbt
@@ -117,6 +117,64 @@ test "visibility: incrementally added child inherits hidden parent after initial
   debug_inspect(inherited.unwrap().is_visible(), content="false")
 }
 
+///|
+test "visibility: removing Parent restores inherited visibility" {
+  let world = @ecs.World::new()
+  defer world.close()
+  ignore(world.increment_change_tick())
+  let initial_ctx = @core.SystemTickContext::new()
+  initial_ctx.set(@core.SystemTicks::new(0, 1))
+  world.set_tick_context(initial_ctx)
+  let parent = world.spawn_empty()
+  try! world.set_by_key(
+    parent,
+    ecs_key_visibility,
+    @visibility.Visibility::Hidden,
+  )
+  try! world.set_by_key(
+    parent,
+    ecs_key_inherited_visibility,
+    @visibility.InheritedVisibility::new(true),
+  )
+  let child = world.spawn_empty()
+  try! world.set_by_key(
+    child,
+    @hierarchy.ecs_key_parent,
+    @hierarchy.Parent::new(parent),
+  )
+  try! world.set_by_key(
+    child,
+    ecs_key_visibility,
+    @visibility.Visibility::Inherited,
+  )
+  try! world.set_by_key(
+    child,
+    ecs_key_inherited_visibility,
+    @visibility.InheritedVisibility::new(true),
+  )
+  @visibility.visibility_propagate_system(world)
+  debug_inspect(
+    (try! world.get_by_key(child, ecs_key_inherited_visibility))
+    .unwrap()
+    .is_visible(),
+    content="false",
+  )
+
+  ignore(world.increment_change_tick())
+  let removed_ctx = @core.SystemTickContext::new()
+  removed_ctx.set(@core.SystemTicks::new(1, 2))
+  world.set_tick_context(removed_ctx)
+  try! (world.remove_by_key(child, @hierarchy.ecs_key_parent) |> ignore)
+  @visibility.visibility_propagate_system(world)
+
+  debug_inspect(
+    (try! world.get_by_key(child, ecs_key_inherited_visibility))
+    .unwrap()
+    .is_visible(),
+    content="true",
+  )
+}
+
 ///|
 test "visibility: incrementally added child honors hidden parent before parent propagation" {
   let world = @ecs.World::new()
@@ -408,17 +466,18 @@ test "visibility: inherited visibility visible-hidden helpers match bevy semanti
 test "visibility: view visibility hidden/get helpers match bevy semantics" {
   debug_inspect(@visibility.ViewVisibility::new(true).get(), content="true")
   debug_inspect(@visibility.ViewVisibility::hidden().get(), content="false")
+  debug_inspect(@visibility.ViewVisibility::visible().get(), content="true")
 }
 
 ///|
 test "visibility: view visibility tracks current and previous frame bits" {
-  let view_visibility = @visibility.ViewVisibility::new(true)
+  let mut view_visibility = @visibility.ViewVisibility::new(true)
   debug_inspect(view_visibility.get(), content="true")
   debug_inspect(view_visibility.was_visible_now_hidden(), content="false")
-  view_visibility.update()
+  view_visibility = view_visibility.advance_frame()
   debug_inspect(view_visibility.get(), content="false")
   debug_inspect(view_visibility.was_visible_now_hidden(), content="true")
-  view_visibility.set_visible()
+  view_visibility = view_visibility.with_visible()
   debug_inspect(view_visibility.get(), content="true")
   debug_inspect(view_visibility.was_visible_now_hidden(), content="false")
 }
diff --git a/mgstudio-engine/window/moon.pkg b/mgstudio-engine/window/moon.pkg
index 1f62e54f3..b8bd5117a 100644
--- a/mgstudio-engine/window/moon.pkg
+++ b/mgstudio-engine/window/moon.pkg
@@ -6,6 +6,7 @@ import {
   "Milky2018/mgstudio/input/events" @input_events,
   "Milky2018/mgstudio/math",
   "Milky2018/window/core" @window_core,
+  "Milky2018/windowing" @raw_windowing,
   "Milky2018/mgstudio/window/windowing_native" @windowing,
   "moonbitlang/core/hashmap",
   "moonbitlang/core/float",
diff --git a/mgstudio-engine/window/pkg.generated.mbti b/mgstudio-engine/window/pkg.generated.mbti
index accc064f1..4a1296122 100644
--- a/mgstudio-engine/window/pkg.generated.mbti
+++ b/mgstudio-engine/window/pkg.generated.mbti
@@ -8,6 +8,7 @@ import {
   "Milky2018/mgstudio/image",
   "Milky2018/mgstudio/input/events",
   "Milky2018/mgstudio/math",
+  "Milky2018/windowing",
   "moonbitlang/core/debug",
   "moonbitlang/core/json",
   "moonbitlang/core/ref",
@@ -482,13 +483,18 @@ pub(all) struct PrimaryWindow {
 } derive(Eq, @debug.Debug)
 pub impl @ecs.Component for PrimaryWindow
 
-pub(all) struct RawHandleWrapper {
+pub struct RawHandleWrapper {
   window : Int
-} derive(Eq, @debug.Debug)
-pub fn RawHandleWrapper::content_view_handle(Self) -> UInt64?
-pub fn RawHandleWrapper::new(WindowWrapper) -> Self
+  window_handle_ : @windowing.WindowHandle
+  display_handle_ : @windowing.DisplayHandle
+} derive(@debug.Debug)
+pub fn RawHandleWrapper::display_handle(Self) -> @windowing.DisplayHandle
+pub fn RawHandleWrapper::new(Int, @windowing.WindowHandle, @windowing.DisplayHandle) -> Self
 pub fn RawHandleWrapper::window(Self) -> Int
+pub fn RawHandleWrapper::window_handle(Self) -> @windowing.WindowHandle
 pub impl @ecs.Component for RawHandleWrapper
+pub impl @windowing.HasDisplayHandle for RawHandleWrapper
+pub impl @windowing.HasWindowHandle for RawHandleWrapper
 
 pub(all) struct RawHandleWrapperHolder {
   handle : @ref.Ref[RawHandleWrapper?]
@@ -800,11 +806,6 @@ pub(all) struct WindowThemeChanged {
 } derive(Eq)
 pub impl @ecs.Message for WindowThemeChanged
 
-pub(all) struct WindowWrapper {
-  window : Int
-} derive(Eq, @debug.Debug)
-pub fn WindowWrapper::new(Int) -> Self
-
 // Type aliases
 pub using @events {type ButtonState}
 
diff --git a/mgstudio-engine/window/raw_handle.mbt b/mgstudio-engine/window/raw_handle.mbt
index 3ac9430cd..d1758c4a3 100644
--- a/mgstudio-engine/window/raw_handle.mbt
+++ b/mgstudio-engine/window/raw_handle.mbt
@@ -13,35 +13,56 @@
 // limitations under the License.
 
 ///|
-pub(all) struct WindowWrapper {
+pub struct RawHandleWrapper {
   window : HostWindow
-} derive(Eq, Debug)
+  window_handle_ : @raw_windowing.WindowHandle
+  display_handle_ : @raw_windowing.DisplayHandle
+} derive(Debug)
 
 ///|
-pub fn WindowWrapper::new(window : HostWindow) -> WindowWrapper {
-  WindowWrapper::{ window, }
+pub fn RawHandleWrapper::new(
+  window : HostWindow,
+  window_handle : @raw_windowing.WindowHandle,
+  display_handle : @raw_windowing.DisplayHandle,
+) -> RawHandleWrapper {
+  RawHandleWrapper::{
+    window,
+    window_handle_: window_handle,
+    display_handle_: display_handle,
+  }
 }
 
 ///|
-pub(all) struct RawHandleWrapper {
-  window : HostWindow
-} derive(Eq, Debug)
+pub fn RawHandleWrapper::window(self : RawHandleWrapper) -> HostWindow {
+  self.window
+}
 
 ///|
-pub fn RawHandleWrapper::new(window : WindowWrapper) -> RawHandleWrapper {
-  RawHandleWrapper::{ window: window.window }
+pub fn RawHandleWrapper::window_handle(
+  self : RawHandleWrapper,
+) -> @raw_windowing.WindowHandle {
+  self.window_handle_
 }
 
 ///|
-pub fn RawHandleWrapper::window(self : RawHandleWrapper) -> HostWindow {
-  self.window
+pub fn RawHandleWrapper::display_handle(
+  self : RawHandleWrapper,
+) -> @raw_windowing.DisplayHandle {
+  self.display_handle_
 }
 
 ///|
-pub fn RawHandleWrapper::content_view_handle(
-  self : RawHandleWrapper,
-) -> UInt64? {
-  @windowing.content_view_handle(self.window)
+pub impl @raw_windowing.HasWindowHandle for RawHandleWrapper with fn window_handle(
+  self,
+) {
+  self.window_handle()
+}
+
+///|
+pub impl @raw_windowing.HasDisplayHandle for RawHandleWrapper with fn display_handle(
+  self,
+) {
+  self.display_handle()
 }
 
 ///|
diff --git a/mgstudio-engine/window/window_runtime.mbt b/mgstudio-engine/window/window_runtime.mbt
index 94ff17075..e6a5145e1 100644
--- a/mgstudio-engine/window/window_runtime.mbt
+++ b/mgstudio-engine/window/window_runtime.mbt
@@ -782,8 +782,12 @@ fn window_create_runtime_for_entity(
   )
   let cursor_options = window_current_cursor_options(world, entity)
   let cursor_icon = window_current_cursor_icon(world, entity)
+  let (window_handle, display_handle) = match @windowing.handles(host_window) {
+    Some(handles) => handles
+    None => abort("window: newly created host window has no native handles")
+  }
   let raw_handle_wrapper = RawHandleWrapper::new(
-    WindowWrapper::new(host_window),
+    host_window, window_handle, display_handle,
   )
   host_window_set_visible(host_window, visible=window.visible)
   if window.visible && window.focused {
diff --git a/mgstudio-engine/window/window_test.mbt b/mgstudio-engine/window/window_test.mbt
index 03f4a251c..87473a269 100644
--- a/mgstudio-engine/window/window_test.mbt
+++ b/mgstudio-engine/window/window_test.mbt
@@ -90,9 +90,52 @@ fn read_window_created(world : @ecs.World) -> Array[WindowCreated] {
 }
 
 ///|
-test "window: RawHandleWrapper exposes host-owned content view handle lookup" {
-  let raw_handle = RawHandleWrapper::new(WindowWrapper::new(-1))
-  debug_inspect(raw_handle.content_view_handle() is None, content="true")
+priv struct UnavailableHandleProvider {}
+
+///|
+impl @raw_windowing.WindowHandleProvider for UnavailableHandleProvider with fn raw_window_handle(
+  _self,
+) {
+  raise @raw_windowing.HandleError::Unavailable
+}
+
+///|
+impl @raw_windowing.DisplayHandleProvider for UnavailableHandleProvider with fn raw_display_handle(
+  _self,
+) {
+  raise @raw_windowing.HandleError::Unavailable
+}
+
+///|
+fn test_raw_handle(window : HostWindow) -> RawHandleWrapper {
+  let provider = UnavailableHandleProvider::{  }
+  RawHandleWrapper::new(
+    window,
+    @raw_windowing.WindowHandle::from_provider(
+      provider as &@raw_windowing.WindowHandleProvider,
+    ),
+    @raw_windowing.DisplayHandle::from_provider(
+      provider as &@raw_windowing.DisplayHandleProvider,
+    ),
+  )
+}
+
+///|
+test "window: RawHandleWrapper owns typed window and display handles" {
+  let raw_handle = test_raw_handle(-1)
+  debug_inspect(raw_handle.window(), content="-1")
+  try raw_handle.window_handle().as_raw() catch {
+    @raw_windowing.HandleError::Unavailable =>
+      debug_inspect(true, content="true")
+  } noraise {
+    _ => debug_inspect(false, content="true")
+  }
+  try raw_handle.display_handle().as_raw() catch {
+    @raw_windowing.HandleError::Unavailable =>
+      debug_inspect(true, content="true")
+  } noraise {
+    _ => debug_inspect(false, content="true")
+  }
 }
 
 ///|
diff --git a/mgstudio-engine/window/windowing_native/moon.pkg b/mgstudio-engine/window/windowing_native/moon.pkg
index 70d51e711..3e448a10e 100644
--- a/mgstudio-engine/window/windowing_native/moon.pkg
+++ b/mgstudio-engine/window/windowing_native/moon.pkg
@@ -3,6 +3,7 @@ import {
   "Milky2018/window/core" @window_core,
   "Milky2018/window/dpi" @window_dpi,
   "Milky2018/window/macos" @window_macos,
+  "Milky2018/windowing",
   "moonbitlang/core/encoding/utf8",
   "moonbitlang/core/ref",
 }
diff --git a/mgstudio-engine/window/windowing_native/pkg.generated.mbti b/mgstudio-engine/window/windowing_native/pkg.generated.mbti
index a0494ed33..783f44de8 100644
--- a/mgstudio-engine/window/windowing_native/pkg.generated.mbti
+++ b/mgstudio-engine/window/windowing_native/pkg.generated.mbti
@@ -6,6 +6,7 @@ import {
   "Milky2018/window/core",
   "Milky2018/window/dpi",
   "Milky2018/window/macos",
+  "Milky2018/windowing",
   "moonbitlang/core/ref",
 }
 
@@ -20,8 +21,6 @@ pub fn bind_accessibility_requested(@ref.Ref[Bool]) -> Unit
 
 pub fn commit_pending_accessibility_update() -> Bool
 
-pub fn content_view_handle(Int) -> UInt64?
-
 pub fn create(logical_width~ : Int, logical_height~ : Int, physical_width~ : Int, physical_height~ : Int, use_physical_size_on_create~ : Bool, title~ : String, name? : String?, visible~ : Bool, resizable~ : Bool, decorations~ : Bool, transparent? : Bool, panel? : Bool, focused? : Bool, close_button_enabled? : Bool, minimize_button_enabled? : Bool, maximize_button_enabled? : Bool, min_inner_width? : Float, min_inner_height? : Float, max_inner_width? : Float?, max_inner_height? : Float?, movable_by_window_background? : Bool, fullsize_content_view? : Bool, has_shadow? : Bool, titlebar_shown? : Bool, titlebar_transparent? : Bool, titlebar_show_title? : Bool, titlebar_show_buttons? : Bool, borderless_game? : Bool, skip_taskbar? : Bool, clip_children? : Bool) -> Int
 
 pub fn create_utf8(Int, Int, Int, Int, Bool, Bytes, UInt64, Bytes?, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Float, Float, Float?, Float?, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool, Bool) -> Int
@@ -44,6 +43,8 @@ pub fn focus_window(Int) -> Unit
 
 pub fn focused(Int) -> Bool
 
+pub fn handles(Int) -> (@windowing.WindowHandle, @windowing.DisplayHandle)?
+
 pub fn height(Int) -> Int
 
 pub fn input_app_lifecycle_event_count() -> Int
diff --git a/mgstudio-engine/window/windowing_native/raw.mbt b/mgstudio-engine/window/windowing_native/raw.mbt
index 6711bdd63..924149272 100644
--- a/mgstudio-engine/window/windowing_native/raw.mbt
+++ b/mgstudio-engine/window/windowing_native/raw.mbt
@@ -1907,14 +1907,12 @@ pub fn position_y(window : Int) -> Int {
 }
 
 ///|
-pub fn content_view_handle(window : NativeWindowHandle) -> UInt64? {
+pub fn handles(
+  window : NativeWindowHandle,
+) -> (@windowing.WindowHandle, @windowing.DisplayHandle)? {
   match native_window_ref(window) {
-    Some(window_ref) => {
-      let handle = window_ref.val.content_view_handle() catch {
-        _ => return None
-      }
-      Some(handle)
-    }
+    Some(window_ref) =>
+      Some((window_ref.val.window_handle(), window_ref.val.display_handle()))
     None => None
   }
 }
diff --git a/mgstudio-engine/winit/state.mbt b/mgstudio-engine/winit/state.mbt
index 23f3dd2ec..060b056b3 100644
--- a/mgstudio-engine/winit/state.mbt
+++ b/mgstudio-engine/winit/state.mbt
@@ -37,6 +37,28 @@ fn runner_surface_binding_find(
   None
 }
 
+///|
+fn runner_host_entry_is_closing(
+  world : @ecs.World,
+  entry : @window.WindowHostEntry,
+) -> Bool {
+  (try! world.get_by_key(entry.entity, @window.ecs_key_closing_window))
+  is Some(_)
+}
+
+///|
+fn runner_surface_binding_has_host_entry(
+  binding : RunnerSurfaceBinding,
+  entries : Array[@window.WindowHostEntry],
+) -> Bool {
+  for entry in entries {
+    if entry.host_window == binding.host_window {
+      return true
+    }
+  }
+  false
+}
+
 ///|
 fn runner_surface_binding_ordered(
   bindings : Array[RunnerSurfaceBinding],
@@ -405,11 +427,29 @@ fn WinitAppRunnerState::mark_app_update_complete(
   if self.frame_limit > 0 {
     self.frame_count_ref.val = self.frame_count_ref.val + 1
     if self.frame_count_ref.val >= self.frame_limit {
-      @window.window_request_close_all_hosts(self.app_ref.val.world())
+      self.close_all_host_windows()
     }
   }
 }
 
+///|
+fn WinitAppRunnerState::release_all_surfaces(
+  self : WinitAppRunnerState,
+) -> Unit {
+  for binding in self.runner_surfaces {
+    @render.host_gpu_release_surface(binding.surface)
+  }
+  self.runner_surfaces.clear()
+}
+
+///|
+fn WinitAppRunnerState::close_all_host_windows(
+  self : WinitAppRunnerState,
+) -> Unit {
+  self.release_all_surfaces()
+  @window.window_request_close_all_hosts(self.app_ref.val.world())
+}
+
 ///|
 fn WinitAppRunnerState::run_tick(self : WinitAppRunnerState) -> Unit {
   self.reset_on_update()
@@ -427,13 +467,23 @@ fn WinitAppRunnerState::run_tick(self : WinitAppRunnerState) -> Unit {
     @app.TimelineTraceCategory::System,
     "mgstudio_winit::runner.surface_bindings",
   )
-  let host_entries = @window.window_host_entries(world)
+  let host_entries : Array[@window.WindowHostEntry] = []
+  for entry in @window.window_host_entries(world) {
+    if !runner_host_entry_is_closing(world, entry) {
+      host_entries.push(entry)
+    }
+  }
   @app.timeline_trace_emit_counter_int(
     "winit.runner.host_windows",
     host_entries.length(),
   )
   let next_surfaces : Array[RunnerSurfaceBinding] = []
   let previous_surfaces = self.runner_surfaces
+  for previous in previous_surfaces {
+    if !runner_surface_binding_has_host_entry(previous, host_entries) {
+      @render.host_gpu_release_surface(previous.surface)
+    }
+  }
   for entry in host_entries {
     let host_window = entry.host_window
     let window_component = try! world.get_by_key(
@@ -484,7 +534,12 @@ fn WinitAppRunnerState::run_tick(self : WinitAppRunnerState) -> Unit {
       continue
     }
 
-    let surface = @render.host_gpu_create_surface(host_window)
+    let raw_handle = match
+      (try! world.get_by_key(entry.entity, @window.ecs_key_raw_handle_wrapper)) {
+      Some(handle) => handle
+      None => abort("winit: host window has no typed raw handle wrapper")
+    }
+    let surface = @render.host_gpu_create_surface(raw_handle)
     let target_id = @render.host_gpu_surface_target_id(surface)
     if width > 0 && height > 0 {
       @render.host_gpu_configure_surface(
@@ -583,17 +638,17 @@ fn WinitAppRunnerState::run_tick(self : WinitAppRunnerState) -> Unit {
       )
       self.debug_screenshot_saved = true
       if self.debug_screenshot_exit_on_save {
-        @window.window_request_close_all_hosts(self.app_ref.val.world())
+        self.close_all_host_windows()
         return
       }
     }
   }
   if @render.screenshot_parity_capture_completed() {
-    @window.window_request_close_all_hosts(self.app_ref.val.world())
+    self.close_all_host_windows()
     return
   }
   if self.app_ref.val.should_exit() is Some(_) {
-    @window.window_request_close_all_hosts(self.app_ref.val.world())
+    self.close_all_host_windows()
     return
   }
 }
@@ -698,7 +753,7 @@ fn WinitAppRunnerState::redraw_requested(
   }
 
   if self.app_ref.val.should_exit() is Some(_) {
-    @window.window_request_close_all_hosts(self.app_ref.val.world())
+    self.close_all_host_windows()
     @app.timeline_trace_end_span(
       @app.TimelineTraceCategory::System,
       "mgstudio_winit::redraw_requested",
diff --git a/mgstudio-engine/winit/state_wbtest.mbt b/mgstudio-engine/winit/state_wbtest.mbt
index 611a2dcea..7b1640488 100644
--- a/mgstudio-engine/winit/state_wbtest.mbt
+++ b/mgstudio-engine/winit/state_wbtest.mbt
@@ -116,3 +116,15 @@ test "winit: runner keeps event loop alive for logical windows awaiting host cre
 
   debug_inspect(runner_has_logical_windows(world), content="true")
 }
+
+///|
+test "winit: runner excludes closing windows before releasing their surfaces" {
+  let world = @ecs.World::new()
+  defer world.close()
+  let entity = world.spawn()
+  let entry = @window.WindowHostEntry::new(entity, 17)
+  debug_inspect(runner_host_entry_is_closing(world, entry), content="false")
+  try! (world.entity_mut(entity).insert_component(@window.ClosingWindow::{  })
+  |> ignore)
+  debug_inspect(runner_host_entry_is_closing(world, entry), content="true")
+}
diff --git a/scripts/bevy_asset_mirror.sha256 b/scripts/bevy_asset_mirror.sha256
new file mode 100644
index 000000000..3252b3ec8
--- /dev/null
+++ b/scripts/bevy_asset_mirror.sha256
@@ -0,0 +1,353 @@
+# SHA-256, pinned Bevy source path, mgstudio mirror path
+# Bevy baseline: 1413bc4e3632233b8fa610a6cf14b90258556c51
+f3ffbb42dbca654d07ea24e477c480bbc7152db1e94dff6e131074c050780bdc	bevy/crates/bevy_anti_alias/src/smaa/SMAAAreaLUT.ktx2	mgstudio-engine/anti_alias/smaa/SMAAAreaLUT.ktx2
+a3b8e1c35883a8b678b18c6c1f548331810995f1e8c692afaea448ccaad28d36	bevy/crates/bevy_anti_alias/src/smaa/SMAASearchLUT.ktx2	mgstudio-engine/anti_alias/smaa/SMAASearchLUT.ktx2
+4193ba4ec4318238c1b703f6ae189547be6ba59ea682a4dce14a86756cb7881d	bevy/assets/android-res/mipmap-mdpi/ic_launcher.png	mgstudio-engine/assets/android-res/mipmap-mdpi/ic_launcher.png
+a66f4cb0fa6d874198278e3aa7714915f8f37344ba63bb10e0366f886cb7dac5	bevy/assets/branding/banner.png	mgstudio-engine/assets/branding/banner.png
+7b90571125870b8ca14002ce544a6b8ab7aef1c03a20d327e2e56b9e15d73ed0	bevy/assets/branding/bevy_bird_dark.png	mgstudio-engine/assets/branding/bevy_bird_dark.png
+07baa595ba8418a88e18c926936e097ac81861ecf0a78e11fe65cbb6f6dd72de	bevy/assets/branding/bevy_bird_dark.svg	mgstudio-engine/assets/branding/bevy_bird_dark.svg
+0f538f08089d18cae33fd57dc3c23c2c7a540eb5716ad1c3bef6bd457589ebb7	bevy/assets/branding/bevy_bird_simpleicons.svg	mgstudio-engine/assets/branding/bevy_bird_simpleicons.svg
+9395b8b86dfda80feec6782521816d550235232cfdc2b771e956e14a20038ad7	bevy/assets/branding/bevy_logo_dark.png	mgstudio-engine/assets/branding/bevy_logo_dark.png
+ccdcf6f902b71b2c833ae76fc07e87c8adf2612ed4db208ec8a7b601e6af434c	bevy/assets/branding/bevy_logo_dark.svg	mgstudio-engine/assets/branding/bevy_logo_dark.svg
+e6ea64d33b0d79f802c3e3d6bc13b789dec47e01c90ac0d5865a9bf2f2de0571	bevy/assets/branding/bevy_logo_dark_big.png	mgstudio-engine/assets/branding/bevy_logo_dark_big.png
+b66f71898e4ca7a859abe691e55a8fafaf46dfed5f3a1a529210e1af04458acf	bevy/assets/branding/bevy_logo_light.png	mgstudio-engine/assets/branding/bevy_logo_light.png
+4f69be10ce48ea30ae1ebb39e025271ab7f1391c1e426239e674966301ef4f48	bevy/assets/branding/bevy_logo_light.svg	mgstudio-engine/assets/branding/bevy_logo_light.svg
+a93bac1e35f9f6a44dec6be1dac9708e1a53ce881f8a09b1642faae8d3230f27	bevy/assets/branding/bevy_logo_light_dark_and_dimmed.svg	mgstudio-engine/assets/branding/bevy_logo_light_dark_and_dimmed.svg
+229823f1ba404c0bbc98f848fc9e6511bbb1dad4f687d3484ec066a120618167	bevy/assets/branding/bevy_solari.svg	mgstudio-engine/assets/branding/bevy_solari.svg
+6b501c6ce53a9465e083668a7298e78b514796217a0cb50112bb2d88d2a7b666	bevy/assets/branding/icon.png	mgstudio-engine/assets/branding/icon.png
+b5bbd0ddf88b6d234690be8f2608767ab02877f577791374bb00be4214700fe4	bevy/assets/branding/icon.svg	mgstudio-engine/assets/branding/icon.svg
+af6ab4da976ab56cac4096bae738ef120266046da4ffa2008dfedcf71739b148	bevy/assets/cursors/kenney_crosshairPack/License.txt	mgstudio-engine/assets/cursors/kenney_crosshairPack/License.txt
+eda9d813a986bb6f834efee0c0bbced60d24d8db83b23120c333dd7b928b17fe	bevy/assets/cursors/kenney_crosshairPack/Tilesheet/crosshairs_tilesheet_white.png	mgstudio-engine/assets/cursors/kenney_crosshairPack/Tilesheet/crosshairs_tilesheet_white.png
+ef6b56b5e44068ef2b5c8cf50b3254ae25d2248c32323f3255c1b96d38bc8562	bevy/assets/data/asset.custom	mgstudio-engine/assets/data/asset.custom
+33b723664f0d71804f8327c7aeaae7eebc210ab9d1e1ed8dcb5fbc238ed9a353	bevy/assets/data/asset_no_extension	mgstudio-engine/assets/data/asset_no_extension
+bae4e4b40fbda4eb74eaad1506ab8fb4a318807d00da7f1881a0f0d794eb71c2	bevy/assets/data/compressed_image.png.gz	mgstudio-engine/assets/data/compressed_image.png.gz
+f0b7a4467ea49e28cc34776b8fc6504a1caec9125fbac79bc405f3ba4c8d1f89	bevy/assets/docs/Mesh.png	mgstudio-engine/assets/docs/Mesh.png
+4124dfb229356f113bdb1128506ba71fa3b5ad6923136bf896ba42fba1bd42b1	bevy/assets/environment_maps/cubes_reflection_probe_specular_rgb9e5_zstd.ktx2	mgstudio-engine/assets/environment_maps/cubes_reflection_probe_specular_rgb9e5_zstd.ktx2
+170f0852e7e22d097ab7e0d7239fabb14bf473cb84994fa69ff1645026fe6a93	bevy/assets/environment_maps/info.txt	mgstudio-engine/assets/environment_maps/info.txt
+3094075b9db292f17333b089aa9c2b2b1ac31aa6cceb6ced3f849f3aafcf09c2	bevy/assets/environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2	mgstudio-engine/assets/environment_maps/pisa_diffuse_rgb9e5_zstd.ktx2
+b5eddbb37839319b5604a7bd97c6916e9351f73d872138d91b0917169285e42d	bevy/assets/environment_maps/pisa_specular_rgb9e5_zstd.ktx2	mgstudio-engine/assets/environment_maps/pisa_specular_rgb9e5_zstd.ktx2
+ed072ab62981cd3b1f57a366706155eee32932b82fab6ac496aa217165245155	bevy/assets/environment_maps/sky_skybox.ktx2	mgstudio-engine/assets/environment_maps/sky_skybox.ktx2
+240a3e0d37d2e86b614063f5347eb02d4f99ca6c254de6b82871ff8d95532a7d	bevy/assets/external/.gitignore	mgstudio-engine/assets/external/.gitignore
+59c8f87bcfc0f8a39b79ce3463b4e8f7e66aac91f910adcc9c942595f530d566	bevy/assets/fonts/EBGaramond-LICENSE	mgstudio-engine/assets/fonts/EBGaramond-LICENSE
+cbb9ada477cb8595ea1a5cda7d79a501178dd4e009082d69158b9775014948c8	bevy/assets/fonts/EBGaramond12-Regular.otf	mgstudio-engine/assets/fonts/EBGaramond12-Regular.otf
+587dd9548304fd421cd254f7550bd101c1250ffc95417f2f7f92d55b44ecbe53	bevy/assets/fonts/FiraMono-LICENSE	mgstudio-engine/assets/fonts/FiraMono-LICENSE
+5f9173ce3d05fadef74c7eed06570d54e4f75bd0cd9860726fb2987a7f848292	bevy/assets/fonts/FiraMono-Medium.ttf	mgstudio-engine/assets/fonts/FiraMono-Medium.ttf
+45131c5e913a5c7b4311101303e3c320a97b93a27a64b7262b533ee0d31ae03c	bevy/crates/bevy_text/src/FiraMono-subset.ttf	mgstudio-engine/assets/fonts/FiraMono-subset.ttf
+12b632bf96ea4e760691f345ef7743c549ca387a018681e11094fcf6146244f1	bevy/assets/fonts/FiraSans-Bold.ttf	mgstudio-engine/assets/fonts/FiraSans-Bold.ttf
+8049b15ea03da7982db1152a9927911c47e0a92dc5ed434fa329b143a99b6adb	bevy/crates/bevy_feathers/src/assets/fonts/FiraSans-BoldItalic.ttf	mgstudio-engine/assets/fonts/FiraSans-BoldItalic.ttf
+e48b22ba7f2eab682501ba01b3ddfdbf65dadfafa74d9b2efe1879eb949b5c69	bevy/crates/bevy_feathers/src/assets/fonts/FiraSans-Italic.ttf	mgstudio-engine/assets/fonts/FiraSans-Italic.ttf
+ce5303dcecb360dab738cc93ecf5d1483855f9fc9347938cc1949beb0eb132b7	bevy/crates/bevy_feathers/src/assets/fonts/FiraSans-License.txt	mgstudio-engine/assets/fonts/FiraSans-License.txt
+3dabf3d48bf4599f95cffd92f99ea426a014d5311f52a5eb5ec3af265e97cd97	bevy/crates/bevy_feathers/src/assets/fonts/FiraSans-Regular.ttf	mgstudio-engine/assets/fonts/FiraSans-Regular.ttf
+ae12d1b4e32a29fd115da324e525469ce760157803ab963e22967741e72671e0	bevy/assets/fonts/MonaSans-VariableFont.ttf	mgstudio-engine/assets/fonts/MonaSans-VariableFont.ttf
+9261dcb61fb5e3c587d50d7a9fdae12bc7422d8822d7ac06b8f34550479575de	bevy/assets/fonts/OFL.txt	mgstudio-engine/assets/fonts/OFL.txt
+b13ae5b16b3b0a47cab9b0d487fc08a805a1e6fedfb31cadf2c345e4d479e453	bevy/assets/irradiance_volumes/Example.vxgi.ktx2	mgstudio-engine/assets/irradiance_volumes/Example.vxgi.ktx2
+89a0cf67eb55a3957c80cc67d65b6fc2e0d8229486b11f512982d485f58b59cc	bevy/assets/lightmaps/CornellBox-Box.zstd.ktx2	mgstudio-engine/assets/lightmaps/CornellBox-Box.zstd.ktx2
+de87016fa6b901b85e1df50b302e44c2a19bbe6bbaae31d573648b5d6adf56d8	bevy/assets/lightmaps/CornellBox-Large.zstd.ktx2	mgstudio-engine/assets/lightmaps/CornellBox-Large.zstd.ktx2
+73940587a78ed09b511db599c2cdfa7f62fbcb432939201c65252bcd4504c6de	bevy/assets/lightmaps/CornellBox-Small.zstd.ktx2	mgstudio-engine/assets/lightmaps/CornellBox-Small.zstd.ktx2
+dbac67cb4f8a1974c0b503e1d7f605b2d489d99280dea3dac6ae471ac82c9bc7	bevy/assets/lightmaps/MixedLightingExample-Baked.zstd.ktx2	mgstudio-engine/assets/lightmaps/MixedLightingExample-Baked.zstd.ktx2
+ce2bdbf3a7e4fcc8de4cbc15a97bcd85b61040094fa9ab5e3fe704b3ae271a07	bevy/assets/lightmaps/MixedLightingExample-MixedDirect.zstd.ktx2	mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedDirect.zstd.ktx2
+c0546e42e6a063bc6e5cab935e67a51606ced23b63aa90b6a128f5f06c964064	bevy/assets/lightmaps/MixedLightingExample-MixedIndirect.zstd.ktx2	mgstudio-engine/assets/lightmaps/MixedLightingExample-MixedIndirect.zstd.ktx2
+e2f694b9b9b8023f12371980e59d72a5a951c0e4d2ab3fc6868bc9691a833568	bevy/assets/lightmaps/caustic_directional_texture.png	mgstudio-engine/assets/lightmaps/caustic_directional_texture.png
+2ae552e2dcfd12c4ca63b4a7b2570cbdabbf4638abea87b641c143b744c55c65	bevy/assets/lightmaps/faces_pointlight_texture_blurred.png	mgstudio-engine/assets/lightmaps/faces_pointlight_texture_blurred.png
+f891362734ba7eeda7488e47a13e848d7e893505e3e6a86e166a323b1aaeda70	bevy/assets/lightmaps/torch_spotlight_texture.png	mgstudio-engine/assets/lightmaps/torch_spotlight_texture.png
+fc660db2b2efa44b9968c119959c9ff99ba3d32aff21e728938b6f3e064d587d	bevy/assets/models/AlienCake/alien.glb	mgstudio-engine/assets/models/AlienCake/alien.glb
+64b6cd87fbb42a921b9cc8dfc1049c78ae2b9c9bed9f4dccfec375c488d029bf	bevy/assets/models/AlienCake/cakeBirthday.glb	mgstudio-engine/assets/models/AlienCake/cakeBirthday.glb
+dd025398274695b9d39c6bae12be2eb23d528f2e5982c9fc3a254dc13ca620e6	bevy/assets/models/AlienCake/tile.glb	mgstudio-engine/assets/models/AlienCake/tile.glb
+50f196f7613c3cf40886c0058c8f4a51f6118d5654879f41bb2fcdb5ba989871	bevy/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp.bin	mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp.bin
+53092a2eeaffe4cd693258cfba139012f29df647cc0d359426a5b6141e08cfa8	bevy/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp.gltf	mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp.gltf
+60a3f75f5c6497474bd1792a64d8268d2d1e4e7bd0d6a41e9c676b8689816977	bevy/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_anisotropy.ktx2	mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_anisotropy.ktx2
+c6a49a280de000d8f36f849ea929e3b4db53da1471bdcaf83e86dec5c0ad22ba	bevy/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_basecolor.jpeg	mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_basecolor.jpeg
+4de3ebde4a1d057f464d4a02c0b95600ba81a349ddcdcd88049e214320b56a94	bevy/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_normalbump.ktx2	mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_normalbump.ktx2
+5c516d6f5eb1ea070243bd5036d41e111bea71d1802183c95c43d0556c6d7a80	bevy/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_occlusionroughnessmetal.ktx2	mgstudio-engine/assets/models/AnisotropyBarnLamp/AnisotropyBarnLamp_occlusionroughnessmetal.ktx2
+3266a8e39b9f425b3341cbe5eec7849f44310256bfa651e6b8b40c85ce0ccafb	bevy/assets/models/Box0.bin	mgstudio-engine/assets/models/Box0.bin
+0715772da574fa6a2d6d9af2630251f01a3a52929962c3ca18e73a84df3a299d	bevy/assets/models/CornellBox/CornellBox.glb	mgstudio-engine/assets/models/CornellBox/CornellBox.glb
+49ba7b4cf782cf2d8d6a768e337ca6a24c83e12f39b4c0dd909a1a6621a837ce	bevy/assets/models/DepthOfFieldExample/CircuitBoardLightmap.hdr	mgstudio-engine/assets/models/DepthOfFieldExample/CircuitBoardLightmap.hdr
+f1d6ff05ce69201b2a8cb5e03d9cdcc94f1100bc560e7462be59e00b8c0bb496	bevy/assets/models/DepthOfFieldExample/DepthOfFieldExample.glb	mgstudio-engine/assets/models/DepthOfFieldExample/DepthOfFieldExample.glb
+d5b72423305257896b29d8a3ff7eb09995df707704d6d94b862196bbed1f7ab3	bevy/assets/models/Faces/faces.glb	mgstudio-engine/assets/models/Faces/faces.glb
+9e623a27f837e1cc995d1380da5fd3becf4d29586fefba882fc0ba76b49f94bf	bevy/assets/models/FlightHelmet/FlightHelmet.bin	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet.bin
+c94a08a28305fb49a612cf273330a04e3dfc084306257d52dc00b4447eeb1091	bevy/assets/models/FlightHelmet/FlightHelmet.gltf	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet.gltf
+497b1930ad1452072db0dcdb309228215141621dc62d08f1ed678cbfe5a1bc0b	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_GlassPlasticMat_BaseColor.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_GlassPlasticMat_BaseColor.png
+fc7a24f83c00ccccc9ce2e5d5e82a2bc7c8ee5661b6dc92fc395b8c9ffbbe3a2	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_GlassPlasticMat_Normal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_GlassPlasticMat_Normal.png
+12f6e278e5b5f0c071d2bfff95b519bc35aae36325d87988879222dff557a36f	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_GlassPlasticMat_OcclusionRoughMetal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_GlassPlasticMat_OcclusionRoughMetal.png
+a388aae0ac40ec127f77a3f84e17c9e42f1b741c4deb19e28d70236e90cbb3f8	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_LeatherPartsMat_BaseColor.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_LeatherPartsMat_BaseColor.png
+aa26e372d8583389d96de9c0fec9afd92274e606cf22288652f57a66499dfa91	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_LeatherPartsMat_Normal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_LeatherPartsMat_Normal.png
+e02694339a06df1a7fd3c6588dac5e60cc5878a9103304bb4ebee03ce62d4648	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_LeatherPartsMat_OcclusionRoughMetal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_LeatherPartsMat_OcclusionRoughMetal.png
+6b514ef3307fd83214a7394c0bbe002834cd72df44cc6756f7936dc1e6b659bd	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_LensesMat_BaseColor.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_LensesMat_BaseColor.png
+b193548e20d01512086fec801fdd387acd0609d9e7af3bc700ccceaba9292125	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_LensesMat_Normal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_LensesMat_Normal.png
+3b43563aa888c73391b203431228d16bd490d8cb2dd16f893fc662213516b77a	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_LensesMat_OcclusionRoughMetal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_LensesMat_OcclusionRoughMetal.png
+059d9d234bf3b43d18056b7ef3bf24a8b67ba8a47132d8b62b46ba46e0e01675	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_MetalPartsMat_BaseColor.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_MetalPartsMat_BaseColor.png
+4282a4e739d172161e5a1e7c740c186786c7c2d993525b4bd364b53e3ad402dc	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_MetalPartsMat_Normal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_MetalPartsMat_Normal.png
+988772baa2ecccd85a86560ae698d4a13f981f96744e266c35c97cbbc0adb52e	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_MetalPartsMat_OcclusionRoughMetal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_MetalPartsMat_OcclusionRoughMetal.png
+1e08313c1dd9f17a4e283dc810558938578d08c962a4ea21d8649423f10f2c11	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_RubberWoodMat_BaseColor.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_RubberWoodMat_BaseColor.png
+00c27437a9026ec17172b82d1d03da271c96d326ef941d36fafe20a3f967b1d7	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_RubberWoodMat_Normal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_RubberWoodMat_Normal.png
+77c7f708f8e2e526747a55146d043f3b84934267abefbbf8701218c5778635b1	bevy/assets/models/FlightHelmet/FlightHelmet_Materials_RubberWoodMat_OcclusionRoughMetal.png	mgstudio-engine/assets/models/FlightHelmet/FlightHelmet_Materials_RubberWoodMat_OcclusionRoughMetal.png
+88ab394d8ae42838c9b9f44a2674538466d8af9798359682318f0d3f4855dedc	bevy/assets/models/FlightHelmetLowPoly/FlightHelmetLowPoly.bin	mgstudio-engine/assets/models/FlightHelmetLowPoly/FlightHelmetLowPoly.bin
+e9ef5ded77c86916f65ca357fc64a1d4338c91675745aa9ad7a3c319ff21b0da	bevy/assets/models/FlightHelmetLowPoly/FlightHelmetLowPoly.gltf	mgstudio-engine/assets/models/FlightHelmetLowPoly/FlightHelmetLowPoly.gltf
+a26c864e2e1ad9745c54241d3cfcfb82dbaada95154499f1163ba2151072ea1f	bevy/assets/models/GltfPrimitives/gltf_primitives.glb	mgstudio-engine/assets/models/GltfPrimitives/gltf_primitives.glb
+eff702ce86cdf49b96b088bff22112eb745bd5f4370d4e00085f61042610d089	bevy/assets/models/GolfBall/GolfBall.glb	mgstudio-engine/assets/models/GolfBall/GolfBall.glb
+130ef2e3d5e7f53928ac34dd87320410470e3241147473d2ab891774d1b1db7a	bevy/assets/models/IrradianceVolumeExample/IrradianceVolumeExample.glb	mgstudio-engine/assets/models/IrradianceVolumeExample/IrradianceVolumeExample.glb
+cc423cd25c96a75838c176618ff2d977cbe4f7b4e747e5ac91741e8ff5aa3818	bevy/assets/models/MixedLightingExample/MixedLightingExample.bin	mgstudio-engine/assets/models/MixedLightingExample/MixedLightingExample.bin
+24d6c984df9e5b546f963ddb06ecb89c9bf8ef0a62d7f4bf2eead77206148b09	bevy/assets/models/MixedLightingExample/MixedLightingExample.gltf	mgstudio-engine/assets/models/MixedLightingExample/MixedLightingExample.gltf
+43a2f60d56abf45f4aa9cd2cab78a4feeff99fdf6bb175b79e4252211ef401e2	bevy/assets/models/MixedLightingExample/SheenChairBaseColor.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairBaseColor.jpg
+ae8f7bd0c3eff41f829c9af559addaa089745a4f8bc8b220a5304947df9d4fe7	bevy/assets/models/MixedLightingExample/SheenChairFabricNormal.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairFabricNormal.jpg
+7bb745fe1273b740307597778579501addb4f7fd3a2173555efcf574bf86d443	bevy/assets/models/MixedLightingExample/SheenChairFabricOcclusion.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairFabricOcclusion.jpg
+c5a792c98a9e8845716b2a89e2bd9ec9425444d0b0d3782dcd872b57de525559	bevy/assets/models/MixedLightingExample/SheenChairLabelBaseColor.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairLabelBaseColor.jpg
+bd838931c9a29463c8d06204af141800f1ce26fb2d1e0602e0f0f42f152a98fd	bevy/assets/models/MixedLightingExample/SheenChairOcclusion-SheenChairBaseColor.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairOcclusion-SheenChairBaseColor.jpg
+1e978314929c5c2dc81e032aad97407588c89cd9e12bdcd10ee98a94fc6da7d3	bevy/assets/models/MixedLightingExample/SheenChairOcclusion-SheenChairWoodMetallicRoughness.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairOcclusion-SheenChairWoodMetallicRoughness.jpg
+068aedb0f3d9d2fd1c14423c025e1a554bae6001f0772acd28c01f7c4a8e13e2	bevy/assets/models/MixedLightingExample/SheenChairOcclusion.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairOcclusion.jpg
+f3c304f351504e3636ee8bfef7f383306ee744fb38aec7b506d807b2e838a4f9	bevy/assets/models/MixedLightingExample/SheenChairWoodBaseColor.jpg	mgstudio-engine/assets/models/MixedLightingExample/SheenChairWoodBaseColor.jpg
+47dbf9c40940eda329bef3711eaba0485667f3aceb503c3c48b211280329bbe0	bevy/assets/models/PalmTree/PalmTree.bin	mgstudio-engine/assets/models/PalmTree/PalmTree.bin
+c37a3fe1f9c139e83cef76c65b93553265aedd976b22fbd3ec3354a5f590dd83	bevy/assets/models/PalmTree/PalmTree.gltf	mgstudio-engine/assets/models/PalmTree/PalmTree.gltf
+2736dc458d397840317e4a056e4b40c24d8c2ff5da331aab0a6712f71123c0db	bevy/assets/models/PalmTree/StylizedWater.png	mgstudio-engine/assets/models/PalmTree/StylizedWater.png
+365ee437bbe406b04a7cbf8d9a138f7787d9ec3e7ef1ba2aeb09476a68413aec	bevy/assets/models/SimpleSkin/SimpleSkin.gltf	mgstudio-engine/assets/models/SimpleSkin/SimpleSkin.gltf
+10c52da207fcc3b10bdb694b627a450d82376579eb775790ac602f27d372a9c0	bevy/assets/models/TonemappingTest/TestPattern.png	mgstudio-engine/assets/models/TonemappingTest/TestPattern.png
+f31adaacac2606e654fdf4462b3ed4896f480a12989d07c3a087aa1685a9ac85	bevy/assets/models/TonemappingTest/TonemappingTest.bin	mgstudio-engine/assets/models/TonemappingTest/TonemappingTest.bin
+8bb73356c7b8ea40f3492ccfea84610053f738fe879c0bd6cf93b2e4e5982906	bevy/assets/models/TonemappingTest/TonemappingTest.gltf	mgstudio-engine/assets/models/TonemappingTest/TonemappingTest.gltf
+8db4886743bd0e8a98d964328a1cc58d218cd7d12cdfcd6ed66d266e741cde71	bevy/assets/models/VolumetricFogExample/VolumetricFogExample.glb	mgstudio-engine/assets/models/VolumetricFogExample/VolumetricFogExample.glb
+d97044e701822bac5a62696459b27d7b375aada5de8574ed4362edbba94771f7	bevy/assets/models/animated/Fox.glb	mgstudio-engine/assets/models/animated/Fox.glb
+266c4f88f64f01ef771c84e93cefac2b379ca58323c445effb58048f3b2d2e61	bevy/assets/models/animated/MorphStressTest.gltf	mgstudio-engine/assets/models/animated/MorphStressTest.gltf
+a9f5556fc8d7effac896e69528ffc8c094496e482bc4047c6497852b1d0fd3bb	bevy/assets/models/barycentric/barycentric.gltf	mgstudio-engine/assets/models/barycentric/barycentric.gltf
+60f0cc476d265c1fff27ac1e8bbcd6faa1f0fc05b55506503ed2277be9a14952	bevy/assets/models/cube/cube.bin	mgstudio-engine/assets/models/cube/cube.bin
+c0accae58581306ca98348c0ed9efbe82597426c198a95dc292407fa038083bf	bevy/assets/models/cube/cube.gltf	mgstudio-engine/assets/models/cube/cube.gltf
+a6060282bebd3b98c1b588179c2792cf42f8fed349d9bcd26d5820a910f854c0	bevy/assets/models/cubes/Cubes.glb	mgstudio-engine/assets/models/cubes/Cubes.glb
+9d5994fc362d1d528dee25ed2a9552516a61ffeb1233dd78f2a47984a45d1649	bevy/assets/models/extras/gltf_extras.glb	mgstudio-engine/assets/models/extras/gltf_extras.glb
+e3f6ac533d87a7ec50d7ced5f3e05618f0d6a6d560aea717edf6af041a39878c	bevy/assets/models/ship/craft_speederD.gltf	mgstudio-engine/assets/models/ship/craft_speederD.gltf
+f635e6c05601c1321a5488074c6f98528869dd6a02c37f508a06dbdfe523453d	bevy/assets/models/ship/craft_speederD_data.bin	mgstudio-engine/assets/models/ship/craft_speederD_data.bin
+cabd9d79e35a8da522994d906c616c95109f8cfc807d0229c919b1854d9f2d9e	bevy/assets/models/sphere/sphere.bin	mgstudio-engine/assets/models/sphere/sphere.bin
+d5cd88cf7bcde3fc38824870a9f9321affbbceefcc7784e61ae27f13191ecd8f	bevy/assets/models/sphere/sphere.gltf	mgstudio-engine/assets/models/sphere/sphere.gltf
+baf5f5504f6c1449c954991e7b8177b43c7fe4dd517e879686959b0898975b4d	bevy/assets/models/terrain/Mountains.bin	mgstudio-engine/assets/models/terrain/Mountains.bin
+9762e28709432191d7e689f5670fb74dd4320289655cbeaa7be8ed856fbde00a	bevy/assets/models/terrain/Mountains.gltf	mgstudio-engine/assets/models/terrain/Mountains.gltf
+15ecd7c795c09c591e6b06e8c85d1fdc14c92c4a2689466b88606273f3ab6a91	bevy/assets/models/terrain/terrain.glb	mgstudio-engine/assets/models/terrain/terrain.glb
+83cbbf11f125394fc369c128ea944b0f4e8f33f6efa05e055c572fb9592fe5e2	bevy/assets/models/torus/torus.gltf	mgstudio-engine/assets/models/torus/torus.gltf
+87a65aa8f50b4d0340915acfd6b644a34af2e7bf7c3239440a00d8e364122f53	bevy/assets/pixel/bevy_pixel_dark.png	mgstudio-engine/assets/pixel/bevy_pixel_dark.png
+38044c090fd78db1c3ba7c3d091dc6d73fdfdb614a275a364f892d40c52e1fb9	bevy/assets/pixel/bevy_pixel_light.png	mgstudio-engine/assets/pixel/bevy_pixel_light.png
+5e496830a1c299c12f5ab303da5b4018f088478d69213daabc111702e34fef5f	bevy/assets/shaders/custom_material.frag	mgstudio-engine/assets/shaders/custom_material.frag
+28c9e0acd5a14ae8096ad0ca3c21180f13603cb77ab72b93ae8462d387ad2637	bevy/assets/shaders/custom_material.vert	mgstudio-engine/assets/shaders/custom_material.vert
+fab01fdc8d59c139d2644e4f5acd67e6d50b836ee6346e86cb8ee0628d63ed85	bevy/assets/shaders/custom_material.wesl	mgstudio-engine/assets/shaders/custom_material.wesl
+48adf914abaf55679eb5f0876fec4f9ec1e6d82ad693d29fbcece582f3a9c638	bevy/assets/shaders/util.wesl	mgstudio-engine/assets/shaders/util.wesl
+8c849cf1afc3976ee2d5883300df022bdb4ae67f81c030e9d8bdd2c0860639c4	bevy/assets/sounds/Epic orchestra music.ogg	mgstudio-engine/assets/sounds/Epic orchestra music.ogg
+d5e00fbe0ef8f84b00e0ad4e437c590d05c98f55d4636b99f4eff457960cb395	bevy/assets/sounds/Mysterious acoustic guitar.ogg	mgstudio-engine/assets/sounds/Mysterious acoustic guitar.ogg
+b0139f731c174fdee2259aaab1d943742b2095ddc81c7c0941b1edb74c92245a	bevy/assets/sounds/Windless Slopes.ogg	mgstudio-engine/assets/sounds/Windless Slopes.ogg
+a83896f7dfb64b6a8ad24beb44bfa6665b4275d208ec38de894776dac866d7cf	bevy/assets/sounds/breakout_collision.ogg	mgstudio-engine/assets/sounds/breakout_collision.ogg
+559b8c64ff4cce39a6003fb9bc5cb01d2e9524346754e458ba200a5694d20ff1	bevy/assets/textures/AlphaNoise.png	mgstudio-engine/assets/textures/AlphaNoise.png
+c43b0a2b19b7e5d349385e3a0c31c2a589e1303b690f0472baa91b46fc4be50a	bevy/assets/textures/BlueNoise-Normal.png	mgstudio-engine/assets/textures/BlueNoise-Normal.png
+a8019d1ef164aa32e14bcfbbcd9b2f254d888345a92ca95c3ea22f1849bb71c5	bevy/assets/textures/Game Icons/exitRight.png	mgstudio-engine/assets/textures/Game Icons/exitRight.png
+fce29186a6ffe086346d226195a0649cde399b788dd209922296f07384291f0f	bevy/assets/textures/Game Icons/right.png	mgstudio-engine/assets/textures/Game Icons/right.png
+2e35bb231745af12133f764ebec22574996dee16cd5543f13c7045b08e26aaf2	bevy/assets/textures/Game Icons/wrench.png	mgstudio-engine/assets/textures/Game Icons/wrench.png
+4600bb26a92b642d227e0462fd45aa1cce1149190200d2e026b2fac6e83d585f	bevy/assets/textures/Ryfjallet_cubemap.png	mgstudio-engine/assets/textures/Ryfjallet_cubemap.png
+17929ee6d8d262c5f7e942e091c4d793dc59d2618c3d7fe27784801f83a31158	bevy/assets/textures/Ryfjallet_cubemap_astc4x4.ktx2	mgstudio-engine/assets/textures/Ryfjallet_cubemap_astc4x4.ktx2
+c3d0a7aa9754ee5e1007bfd30b9c4faea694ea317e0c888d534f3d1136048ec3	bevy/assets/textures/Ryfjallet_cubemap_bc7.ktx2	mgstudio-engine/assets/textures/Ryfjallet_cubemap_bc7.ktx2
+572ec9de2fb308808c7812880de27942f0b2d4b83fecf43c4d3d14b210c32728	bevy/assets/textures/Ryfjallet_cubemap_etc2.ktx2	mgstudio-engine/assets/textures/Ryfjallet_cubemap_etc2.ktx2
+adb6faccc7cd9eca8a2fc90f988c31efd913bc531cab45917f54ca2fd04efe41	bevy/assets/textures/Ryfjallet_cubemap_readme.txt	mgstudio-engine/assets/textures/Ryfjallet_cubemap_readme.txt
+6436264108e995224f0154fa79806d35cf09ce1a76081f66927e066326e2039c	bevy/assets/textures/ScratchedGold-Normal.png	mgstudio-engine/assets/textures/ScratchedGold-Normal.png
+f478b665c27bdda7d96fd7ade7ec16810df17a3cce837ae2a04dbeaf0c556f45	bevy/assets/textures/array_texture.png	mgstudio-engine/assets/textures/array_texture.png
+687132232ba5c423670fe33fade89ea7618a66a5dbc05b08da37591e37087eff	bevy/assets/textures/arrow.png	mgstudio-engine/assets/textures/arrow.png
+6c7c939e290851d494d14ce5f90a2b179ac44cbdbbbd074113dcf1cded2bab2b	bevy/assets/textures/basic_metering_mask.png	mgstudio-engine/assets/textures/basic_metering_mask.png
+c42eea52d3c6c56be839fce4df93fe3c85be6705e3249805ae0688212e17b989	bevy/assets/textures/fantasy_ui_borders/License.txt	mgstudio-engine/assets/textures/fantasy_ui_borders/License.txt
+3d0bf19dd6130a22c8eefcb1485daeb68a2a8ed31926af613bc231de8036b475	bevy/assets/textures/fantasy_ui_borders/border_sheet.png	mgstudio-engine/assets/textures/fantasy_ui_borders/border_sheet.png
+fd08021da7ba4b1ad1d28b72d4a8fe5b45bcafed8105fa8fb5238aef5f2dca36	bevy/assets/textures/fantasy_ui_borders/numbered_slices.png	mgstudio-engine/assets/textures/fantasy_ui_borders/numbered_slices.png
+480050cadb258f8d6cd377ffe3ce2f5af3cb7980d6d72aae85752d0c67219620	bevy/assets/textures/fantasy_ui_borders/panel-border-010-repeated.png	mgstudio-engine/assets/textures/fantasy_ui_borders/panel-border-010-repeated.png
+480050cadb258f8d6cd377ffe3ce2f5af3cb7980d6d72aae85752d0c67219620	bevy/assets/textures/fantasy_ui_borders/panel-border-010.png	mgstudio-engine/assets/textures/fantasy_ui_borders/panel-border-010.png
+ec6b95abaafd791f47f8dccf64132773044d43a194fea3de809a62011e593074	bevy/assets/textures/fantasy_ui_borders/panel-border-015.png	mgstudio-engine/assets/textures/fantasy_ui_borders/panel-border-015.png
+f8a05e53ff05c57e65ccef143662b9c10601896b26156f2f2f8d35f54d85b1cb	bevy/assets/textures/food_kenney.png	mgstudio-engine/assets/textures/food_kenney.png
+463590ae73733f815c78dc5c855ca4147010aef4fdc49603f0fe066c277e0d72	bevy/assets/textures/mars_mie_phase.ktx2	mgstudio-engine/assets/textures/mars_mie_phase.ktx2
+5cf7ef47406ee0521731f8a7b299118af815c2274285bd76fccc3961cf197842	bevy/assets/textures/parallax_example/cube_color.png	mgstudio-engine/assets/textures/parallax_example/cube_color.png
+e4e39e11d0319f1ba785eb89e9ee9229a59e9505808b31a87e01840a6e1c73ef	bevy/assets/textures/parallax_example/cube_depth.png	mgstudio-engine/assets/textures/parallax_example/cube_depth.png
+9bbb8cd567dd5ce12fe051b38e7c4a9383d59ad2d9c3367cf0d7c13de2d09412	bevy/assets/textures/parallax_example/cube_normal.png	mgstudio-engine/assets/textures/parallax_example/cube_normal.png
+48b8ac17973c0b6867c62747bd5c9d36a4fa8430b229e4c997ac7601ba9b2ce8	bevy/assets/textures/rpg/chars/gabe/gabe-idle-run.png	mgstudio-engine/assets/textures/rpg/chars/gabe/gabe-idle-run.png
+560c2e33a24e4394097cb7dcf30e214fdb99aefe0e81b74bbd4ef5759653a00b	bevy/assets/textures/rpg/chars/hat-guy/hat-guy.png	mgstudio-engine/assets/textures/rpg/chars/hat-guy/hat-guy.png
+d13b06ba762fc73769d0ecaac8537b0d7ec4e139b543504c36b5449bdb7a3231	bevy/assets/textures/rpg/chars/mani/mani-idle-run.png	mgstudio-engine/assets/textures/rpg/chars/mani/mani-idle-run.png
+2aa79e12ce2c2fbc00f4fd1a5fa4c127312daac69cbe4b4aa83d085f56faa193	bevy/assets/textures/rpg/chars/sensei/sensei.png	mgstudio-engine/assets/textures/rpg/chars/sensei/sensei.png
+9de09659210c8d88ac4d09f262ffc62981be8bea672351de92a4b040fcdf7bee	bevy/assets/textures/rpg/chars/vendor/generic-rpg-vendor.png	mgstudio-engine/assets/textures/rpg/chars/vendor/generic-rpg-vendor.png
+fd6b8d4b557656307dac0ffbae88458623b067b2b7daf69b2cdbcc8b786e5f89	bevy/assets/textures/rpg/mobs/boss_bee.png	mgstudio-engine/assets/textures/rpg/mobs/boss_bee.png
+958066557a68c846ea0626e35c054a804a028bc664cfb90bd2c5157ce9d23604	bevy/assets/textures/rpg/mobs/fox-run.png	mgstudio-engine/assets/textures/rpg/mobs/fox-run.png
+aaf88cf8b56ed306b57bb4aadda18891e6d3e1322a579bfb174431fe1dac7b9d	bevy/assets/textures/rpg/mobs/kobold-idle.png	mgstudio-engine/assets/textures/rpg/mobs/kobold-idle.png
+496f72872b22a82795ab7e40f5e58282488f286875e271e3f5e5cff79fb1f01c	bevy/assets/textures/rpg/mobs/slime-blue.png	mgstudio-engine/assets/textures/rpg/mobs/slime-blue.png
+e3b3db94d28b8ac38d7337fc463194b2ab32793abb68e88aad85e6bd801c1483	bevy/assets/textures/rpg/mobs/slime-green.png	mgstudio-engine/assets/textures/rpg/mobs/slime-green.png
+0509562c7149041705e2e6c65329246c02eadb38260c634bdb07eca00472e22b	bevy/assets/textures/rpg/mobs/slime-orange.png	mgstudio-engine/assets/textures/rpg/mobs/slime-orange.png
+f064442cdab85e6b82f188e536df56b2e10b7c84a0b6b445af2db2aab3760737	bevy/assets/textures/rpg/mobs/worm-run-idle.png	mgstudio-engine/assets/textures/rpg/mobs/worm-run-idle.png
+674dbe0d3c0638b90b899d80ff9323a1ff9be7b6a9c1e8e01ede20dd49dd8388	bevy/assets/textures/rpg/props/generic-rpg-barrel01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-barrel01.png
+4b8d803ad946e2deeab9f7afa8bedf13682cc3905129f4c39a42c958039ecc74	bevy/assets/textures/rpg/props/generic-rpg-barrel02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-barrel02.png
+d05b1484bc18cd73b0769ef3c56997ef767609c25d8d0cae69a596bf815149ef	bevy/assets/textures/rpg/props/generic-rpg-barrel03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-barrel03.png
+7d3f391622467977c6dc2d7b1b13af55b1f227374120e5b0b2537205135d0a21	bevy/assets/textures/rpg/props/generic-rpg-board01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-board01.png
+2007eb9aa26d872a2c37911c5250b0bdc0624e7a187e2b5211e5ab730aee3aaa	bevy/assets/textures/rpg/props/generic-rpg-board02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-board02.png
+4ebd36c65e0985c5a41a0c295b22ad58ccc7b82fd5fdb89467b378f943040839	bevy/assets/textures/rpg/props/generic-rpg-board03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-board03.png
+1900634a47c6ac1701ed3fc561137b9c6ac778a54912b00e9c2304436244421c	bevy/assets/textures/rpg/props/generic-rpg-board04.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-board04.png
+968277602b53bbb2b46117583816828c7e1843f630aabe781ff8489e3906833b	bevy/assets/textures/rpg/props/generic-rpg-bridge.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-bridge.png
+d199150145765588ef471eade5f4faf905022a7165d7ca970df8e7f6145d0559	bevy/assets/textures/rpg/props/generic-rpg-crate01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-crate01.png
+180c2488bc53d8fa13e68688ae2a4d37c89ea0f247d0c6728ac1614dc58fb4b1	bevy/assets/textures/rpg/props/generic-rpg-crate02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-crate02.png
+98b3571ebf03f1dc646ce83e68a6e43861dd1fc3090e75eedc5fa336f8adfb80	bevy/assets/textures/rpg/props/generic-rpg-crate03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-crate03.png
+c4b89881a9d3b9f831bcc5423070e9a7a06a0ac26b33ee16a749faabcf050506	bevy/assets/textures/rpg/props/generic-rpg-fence-complete.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-complete.png
+8b3144b17742ce65cf120decbee744b807918fe26e9345ff0df60d8041b27ac1	bevy/assets/textures/rpg/props/generic-rpg-fence-raw01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw01.png
+17106bd657a058d228f7d26b5a8ba2c30de98d31a7e96d7b9e30ee72387bd5f6	bevy/assets/textures/rpg/props/generic-rpg-fence-raw02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw02.png
+85851589c245cf12a2b094054f6270317919e1c962135a42183fe71b1ee76d4a	bevy/assets/textures/rpg/props/generic-rpg-fence-raw03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw03.png
+df537f8b5a9333ed3631ccd68daf7ea47a43cf804b041c91b8729b2abf32bccc	bevy/assets/textures/rpg/props/generic-rpg-fence-raw04.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw04.png
+7ccf49683b223c6b342d287449ed31b76a4549a9cb5808f13b55316098d6061b	bevy/assets/textures/rpg/props/generic-rpg-fence-raw05.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw05.png
+1f9448b7187bebcd2546388210cda7ca7f9deb6e90340969c63da24b32844926	bevy/assets/textures/rpg/props/generic-rpg-fence-raw06.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw06.png
+c1a2b3d1dac647c937b839ca9dd20e146f0390e0c9edffa18ca9a40d4fbb1cb8	bevy/assets/textures/rpg/props/generic-rpg-fence-raw07.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw07.png
+c48fe4cac62dab34da922ebb411f3d941f7f5ad85c69cf4b499a51744fb002f0	bevy/assets/textures/rpg/props/generic-rpg-fence-raw08.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw08.png
+1ec94e0b4ab52501569a18d749c0fca1154008134ea4c77a5b8ea9a87751ff28	bevy/assets/textures/rpg/props/generic-rpg-fence-raw09.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw09.png
+31138f7721c87ab693c4e60d4b3c6c41931ee1d88031375959594fdb8f39b23a	bevy/assets/textures/rpg/props/generic-rpg-fence-raw10.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw10.png
+36c6aa0a17f687ae2cdd489dfcd6b0cc64594fde6e3a14eef032cf707a8ae7ba	bevy/assets/textures/rpg/props/generic-rpg-fence-raw11.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw11.png
+bc4bb2e3e978f3faf92336888ffd1e6e84cd67adada03766c01be662902fe100	bevy/assets/textures/rpg/props/generic-rpg-fence-raw12.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw12.png
+f303336203b84b1ad1815cbefbfa65eaf9220eeca78c613c209f047c6be37868	bevy/assets/textures/rpg/props/generic-rpg-fence-raw13.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw13.png
+82fef7c2f3683ad9b0fe57f4508c6cc1061c6cf0bfd2a5a69bad0dfd0f70af9c	bevy/assets/textures/rpg/props/generic-rpg-fence-raw14.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw14.png
+3b9cc82a5a591bd139066cabf02fcfdcad462deeb0842a75495ce2da787ea6b6	bevy/assets/textures/rpg/props/generic-rpg-fence-raw15.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw15.png
+ef80d0670e8ae95a8215d943d21edf259ea70cd25287ad809739bc4d57b4ffa8	bevy/assets/textures/rpg/props/generic-rpg-fence-raw16.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw16.png
+cde319fa6667a407f94b84ef3bb967b7a2ba578ea43bf0a9f2179daf5ec2d765	bevy/assets/textures/rpg/props/generic-rpg-fence-raw17.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw17.png
+e6efe6925d848165789a91cc0ea8d363790c7d089417d63458694ea86de3de8f	bevy/assets/textures/rpg/props/generic-rpg-fence-raw18.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw18.png
+2eb4166ee48b8c141e0120f27c529d5c71b6fb8c0e996e0774fd26394587ba5f	bevy/assets/textures/rpg/props/generic-rpg-fence-raw19.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw19.png
+1da916c29d087dd5334bdd276b2a626efe4925b74e6fd03ff6978db22d4fb759	bevy/assets/textures/rpg/props/generic-rpg-fence-raw20.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw20.png
+66bee551a464855498384918a1c0ee64afe7d1ce0c439ecc898140fbf4ad4588	bevy/assets/textures/rpg/props/generic-rpg-fence-raw21.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw21.png
+9ddd10a41ca8d52244830655acd3e07e16e6de87092f8840891fe348ea4fce24	bevy/assets/textures/rpg/props/generic-rpg-fence-raw22.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw22.png
+e81c2c86b34c9264cf2eb2e8665dc0ea07b1385873e2f2c75ff6841bea7fc4a4	bevy/assets/textures/rpg/props/generic-rpg-fence-raw23.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw23.png
+7bd33d61cca4b47c0c1370f98287650a151bc4866c2ced03a65909ce44869ea6	bevy/assets/textures/rpg/props/generic-rpg-fence-raw24.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw24.png
+455d88c1c32e5f0376891adffd37a91d0649091bf7d333e36ee857103071d682	bevy/assets/textures/rpg/props/generic-rpg-fence-raw25.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence-raw25.png
+8c1277193aa880a1e82bcd5542a57dcd737f0ecb04b9fb5b5f9b0b9aa6da73aa	bevy/assets/textures/rpg/props/generic-rpg-fence01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence01.png
+d3450e43725117e14880800ecabf1f772dda3e927666e913dc974113c1c89066	bevy/assets/textures/rpg/props/generic-rpg-fence02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence02.png
+8d1259d015a9f0d2a3d9e91a86c52d9ed3549a5ca7cd4cb70f8737f98430e396	bevy/assets/textures/rpg/props/generic-rpg-fence03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence03.png
+f62d93cbd29b82a2002cd481c82a76f4df713f78d7b7ea98e0c1ec9bd62bd209	bevy/assets/textures/rpg/props/generic-rpg-fence04.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence04.png
+dff0bfd6ad00db81259d1eb17f56ac1da884c7a18b1d932ca745ff5844625066	bevy/assets/textures/rpg/props/generic-rpg-fence05.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence05.png
+c480b141215c09dffd4f749278f8f327d1dd95cff201c3b760d2728c4a6cc42a	bevy/assets/textures/rpg/props/generic-rpg-fence06.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence06.png
+bb7635e8eb2148c6058bbf546f33007cf37ef9bdb2acd9c5fccb3712fc11665c	bevy/assets/textures/rpg/props/generic-rpg-fence07.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence07.png
+f604f337f79e1c281f4274d4baf1449036d901a1a3615605b17519b7d448567a	bevy/assets/textures/rpg/props/generic-rpg-fence08.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence08.png
+a0879dcba2fcf4ed4c0f803f158ca43aa6ebbef5cbbba38ff16359dab57949b4	bevy/assets/textures/rpg/props/generic-rpg-fence09.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence09.png
+ee8f378ee8579064844399752f78584f0f2615e2d09ec527d243d01c51e11bc9	bevy/assets/textures/rpg/props/generic-rpg-fence10.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence10.png
+78580671093d7735a88672ed52b7bb613ade53c90eaa81ef646336f2081b47c8	bevy/assets/textures/rpg/props/generic-rpg-fence11.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence11.png
+f74d7ccb82c1dd1cdc8658330f07cac045eeaecd44ae591027f508458242c863	bevy/assets/textures/rpg/props/generic-rpg-fence12.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence12.png
+83d345474c31017530bba4a31b235a6dde062f845ec98905f2c7306f9650ac8a	bevy/assets/textures/rpg/props/generic-rpg-fence13.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence13.png
+b64558d42253e589126ed5e59e9c5d204978e480844778f3d9069a621b568c41	bevy/assets/textures/rpg/props/generic-rpg-fence14.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fence14.png
+767d1d2f0e119d67824eaa1a85db06c461ca8968c7992db6d621d05b56e169a4	bevy/assets/textures/rpg/props/generic-rpg-fish01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fish01.png
+ee792e9b10a1818b43907dba192e94db8e1dc129a39436241732b9b0f4c27c94	bevy/assets/textures/rpg/props/generic-rpg-fish02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fish02.png
+55574093b4144a7eeb27075ae6116c56b1efdcc654afc75146256021f522599c	bevy/assets/textures/rpg/props/generic-rpg-fish03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fish03.png
+e40a7355c7ef7da0d04dcb1d67a8c63b77765ef0b2c4ea03d45a9912c75bbb81	bevy/assets/textures/rpg/props/generic-rpg-fish04.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-fish04.png
+e15860acdf35cf69ad9fd62946cba642081d9d45a938af572bc99ce9ac687cfc	bevy/assets/textures/rpg/props/generic-rpg-flower01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-flower01.png
+658d4c71a6e0d2706337bfa728d7c3513186b037215d6cf8f829d1fbdf2857dd	bevy/assets/textures/rpg/props/generic-rpg-flower02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-flower02.png
+77f34e921ed7a986b26de74628bc1b4e94791608811878f6255121b681e78060	bevy/assets/textures/rpg/props/generic-rpg-flower03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-flower03.png
+3ae0872f2a30bcdc5581a8d718b1201c48c1e0c180de30be4ceae30aa44df86a	bevy/assets/textures/rpg/props/generic-rpg-flowers.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-flowers.png
+3b50ec601a84c41f0c053660d630f53a81051f10489b2380b98b90e79f10eef2	bevy/assets/textures/rpg/props/generic-rpg-grass01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-grass01.png
+f8b84053d17ea34e62e7b51c07179a54fea7acf44ae3d62adaa4c86400a4d9fc	bevy/assets/textures/rpg/props/generic-rpg-grass02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-grass02.png
+cca76c60353042d3cd75d8597810ba73b89d9bcb788d8015b8f845128fe5b026	bevy/assets/textures/rpg/props/generic-rpg-house-inn.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-house-inn.png
+c30955458ef7306dfe7ee52887e010743f588d8e3abcc998593357a72d898ee9	bevy/assets/textures/rpg/props/generic-rpg-loot01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-loot01.png
+22149a50c87a53ce1a9bcb53f8b8eceb14dbd1504d7590a8de1b9ea86dd0a409	bevy/assets/textures/rpg/props/generic-rpg-loot02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-loot02.png
+12ca496b726ccfd10b1e3e1d6f95772ee1e806ae165240afff1e06a80dae2cfa	bevy/assets/textures/rpg/props/generic-rpg-loot03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-loot03.png
+42989f9d09d2cece9709b2538b350370db6dba000b9c1aebcba9bdd617773c7f	bevy/assets/textures/rpg/props/generic-rpg-loot04.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-loot04.png
+b6c82e8812a868998149c2848b133e22a77c659abfd91d5cfe0ea1fa980e7313	bevy/assets/textures/rpg/props/generic-rpg-loot05.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-loot05.png
+a566db5c93c9e98c47d33e7293abd38e6ebb086a6f420371b7e1d2c14934e6fd	bevy/assets/textures/rpg/props/generic-rpg-mini-lake.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-mini-lake.png
+d17c19165e7bbcd7b77d3db258732db7efb6ccea9806ee46b647dae4fb6b6462	bevy/assets/textures/rpg/props/generic-rpg-rock01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rock01.png
+7290cd6d7b0b34be196ec373678f8ab00a461e36c72ba11b215d6434cf18856f	bevy/assets/textures/rpg/props/generic-rpg-rock02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rock02.png
+69a56716b30377e358684dfc340ce728a0488011f265ad7909dc75bf9600814a	bevy/assets/textures/rpg/props/generic-rpg-rock03.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rock03.png
+48039dad168e501f0c563d81d7b2b9c0d4bfc3f349a6994aedfb4210b5dc2705	bevy/assets/textures/rpg/props/generic-rpg-rock04.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rock04.png
+344a5ec71c5a5f9cdaadbbaf1ae501c464c1ce24a11983637c697b02959ab1c3	bevy/assets/textures/rpg/props/generic-rpg-rock05.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rock05.png
+0710dfe5c99ebffae6803ddb3583eb8582aae4e908f42a04a663e90010a0634e	bevy/assets/textures/rpg/props/generic-rpg-rock06.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rock06.png
+5d1adca8af0193d75219191174a8800471bd11e9e2df2f8cb7bfcdc3408c616c	bevy/assets/textures/rpg/props/generic-rpg-rod.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-rod.png
+b792de3e113db1de51f5a08c9ab663baadc6d5269c99d4899b7e43fa495628b9	bevy/assets/textures/rpg/props/generic-rpg-trasure-open.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-trasure-open.png
+8dc4392d176a34f150b52072b6bdff73e7ddd773775857fa68316360352e1b13	bevy/assets/textures/rpg/props/generic-rpg-treasure-closed.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-treasure-closed.png
+91f13f3a3d676bcd66e5039655bddc40fac2c0f75568dfc4865dc42d3b58e756	bevy/assets/textures/rpg/props/generic-rpg-tree01.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-tree01.png
+ff2766733482d20bd290ea40cae2daeb30b6e87167e19058de0aab4da507be9a	bevy/assets/textures/rpg/props/generic-rpg-tree02.png	mgstudio-engine/assets/textures/rpg/props/generic-rpg-tree02.png
+27dedd42fa8791c6bffcc841d82fd95197dfa481a8ead8d51e3dfdcb69706045	bevy/assets/textures/rpg/tiles/generic-rpg-Slice.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-Slice.png
+decfa8ddb16ecc1446cd4aedfa819d60d1b125b11d07702d05a24ee658c1f371	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall01.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall01.png
+b3d3abce5809ad1bd432d093deb5a6e8ca4f531b5629c5bfb39bcbab1dc8e64f	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall02.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall02.png
+341c3f175a7e49a4309d0e80bfaa4d01e7964cc60b8322d988d623c6b97429b3	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall03.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall03.png
+262900320cbbd7ffcd8449dbc58bf264d81ba5c5b2b0108ea5b5a50264493d9f	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall04.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall04.png
+26792f99274a730e5aaa0efee8bc9ef06b179c57a303b7f51d2d6a52a7196afc	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall05.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall05.png
+17150620c148496106509ae94ec694cd415e5eb5224621db9a745199e2b05408	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall06.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall06.png
+a82360257b1ea9ac7a594c9168937d6590bd11ae1b45756683a19d84e7a3eb6b	bevy/assets/textures/rpg/tiles/generic-rpg-tile-waterfall07.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile-waterfall07.png
+accb6b49b3c97f89f0969b16e48e75e22ffbc186648f714c9bde336c14294ef4	bevy/assets/textures/rpg/tiles/generic-rpg-tile01.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile01.png
+1318d8ac2deefba1a96f92d74dbdb2de059a81f81801e085e9548d7a3b882c6d	bevy/assets/textures/rpg/tiles/generic-rpg-tile02.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile02.png
+779e63ee377798da47169d63531364fcca6ced04a62afca3a4442bd4a0876f3a	bevy/assets/textures/rpg/tiles/generic-rpg-tile03.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile03.png
+1457ade23cb6514d9a959c18daa5d7776d5cf7eb7aec4f1b3677c42eb379566e	bevy/assets/textures/rpg/tiles/generic-rpg-tile04.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile04.png
+8be8c09e23fe88cb0367988f76937d49f981e934e4589d15b0ec8e2ffad1d5ec	bevy/assets/textures/rpg/tiles/generic-rpg-tile05.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile05.png
+0c3b1576c0969eb397e7613d67c852db229aea0c2b75929a81a98010dfd3dc94	bevy/assets/textures/rpg/tiles/generic-rpg-tile06.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile06.png
+a8b6c4a9bcf46d02c1601c78f954166ebf0b7e2914172f348dccb90a625e4705	bevy/assets/textures/rpg/tiles/generic-rpg-tile07.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile07.png
+6feedb9e99d32f65f26e88efd302ba75c5e2dd8df498bf81da9a08b1eb7d1eee	bevy/assets/textures/rpg/tiles/generic-rpg-tile08.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile08.png
+d032868087a52597623cad9b825d2e7673a18ee24e69c8c44c095a523c16784c	bevy/assets/textures/rpg/tiles/generic-rpg-tile09.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile09.png
+fd1052b5c77233b104a61b2a838b402111832e5e305313c80b6e575a0cb79ff4	bevy/assets/textures/rpg/tiles/generic-rpg-tile10.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile10.png
+8ea1d2e7e0b72d66ea2a755fdd7445bb5acb41a88d85f3a40e349adc65c04056	bevy/assets/textures/rpg/tiles/generic-rpg-tile11.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile11.png
+e65a5de0ff90adda6148eceec0dd9bb8ce53a5b9732e26feb912aad237797d13	bevy/assets/textures/rpg/tiles/generic-rpg-tile12.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile12.png
+e754e5fc81d780dfd418271a05862286f64a9793466974fe342dd463320cb8d7	bevy/assets/textures/rpg/tiles/generic-rpg-tile13.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile13.png
+61fc5311e4c68cae396b64726a22ee64987d51cb557c4558760858687329f2f8	bevy/assets/textures/rpg/tiles/generic-rpg-tile14.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile14.png
+a2e4a4651f0555b5c67d76027988fca72a5aa93f209fbb4a9269b8a3b09a3c72	bevy/assets/textures/rpg/tiles/generic-rpg-tile15.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile15.png
+7a8c53cd1ff4cfe5010ab69e63582267439516bffdafcfdb1600d9cb25c83181	bevy/assets/textures/rpg/tiles/generic-rpg-tile16.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile16.png
+df025763bd762a89d60b4e459bb5eea0c3ec0007c3f43b6e98f2a3d7de17ae6b	bevy/assets/textures/rpg/tiles/generic-rpg-tile17.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile17.png
+9a2a7a089394c4a1d3b043845b168e4f2cfe9744752104d54db2dd85922710e9	bevy/assets/textures/rpg/tiles/generic-rpg-tile18.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile18.png
+8c649a8aeeae028de916a8add6912f3621fa2e463154304959e7f7ff29a09b34	bevy/assets/textures/rpg/tiles/generic-rpg-tile19.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile19.png
+ed68eae678a34642fbc7f61770455b518f36181db6dcb2f03702b934306d5e92	bevy/assets/textures/rpg/tiles/generic-rpg-tile20.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile20.png
+1fa139b4e1139659db7c9aadd09d231184b006cae701e48d8d521d1940b7bddc	bevy/assets/textures/rpg/tiles/generic-rpg-tile21.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile21.png
+a3737b8e2005c1f5f798ce93130e733c96c3f448d72f8e234cd41e7abc6992ae	bevy/assets/textures/rpg/tiles/generic-rpg-tile22.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile22.png
+ccd442fa4d703028459b6aacb8c9e7064eacb9276cf1c80f5f3876002acd2a8f	bevy/assets/textures/rpg/tiles/generic-rpg-tile23.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile23.png
+e97c10beb6211b072f3c83f311a45d7376295cdf222e9fc0acae62676995b885	bevy/assets/textures/rpg/tiles/generic-rpg-tile24.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile24.png
+496867cd4745eb2617d27cfa994c362a234918a981496e3b0deca2c78ef845df	bevy/assets/textures/rpg/tiles/generic-rpg-tile25.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile25.png
+2887f0fc8bdfc78cd97d7e767fcbaa4601d24fa233ca8b7cdfc63fffac721591	bevy/assets/textures/rpg/tiles/generic-rpg-tile26.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile26.png
+58cc0816a3146095da933dda7fe7090a896a992582b11cf81776ea7e795ed77b	bevy/assets/textures/rpg/tiles/generic-rpg-tile27.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile27.png
+2e5b7ef034647de078baa6cc3f25aa91f52009275b0895f20c2726aff70390a9	bevy/assets/textures/rpg/tiles/generic-rpg-tile28.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile28.png
+c55e7f294da86c2827e4a3a07ece502cc6490737b1158283c2451a66f02f654e	bevy/assets/textures/rpg/tiles/generic-rpg-tile29.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile29.png
+b1a54d16c88f4aa97bb73775e4dee9056308d544a58fad38161a45d0387b7201	bevy/assets/textures/rpg/tiles/generic-rpg-tile30.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile30.png
+b7f81ef6401564aeda9a85474ec06808025e5759efab2c7d632e75cda3f52571	bevy/assets/textures/rpg/tiles/generic-rpg-tile31.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile31.png
+dfb555c6d649f2b89d113059ce2111d33fb490f377f19f16a232962759868137	bevy/assets/textures/rpg/tiles/generic-rpg-tile32.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile32.png
+383dea9a74243046fe0372c61b3663771972b29b48e81629b6aee4e2652c0117	bevy/assets/textures/rpg/tiles/generic-rpg-tile33.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile33.png
+449b72707503fca9cb97805a7648c45fde01e814b9be51e7d614ec21d763473c	bevy/assets/textures/rpg/tiles/generic-rpg-tile34.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile34.png
+1958f8373f9723142ef560fe9a148f35ead2cde2a9df9532f2488e6f4dc9f839	bevy/assets/textures/rpg/tiles/generic-rpg-tile35.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile35.png
+6e4bff126568afef55c96b700b94f1e775cdd3b76a8d7e32dd0f41bad3e41b64	bevy/assets/textures/rpg/tiles/generic-rpg-tile37.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile37.png
+27dedd42fa8791c6bffcc841d82fd95197dfa481a8ead8d51e3dfdcb69706045	bevy/assets/textures/rpg/tiles/generic-rpg-tile38.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile38.png
+f1570b7f249679b151e2ced100a8516bb708e901c022a9dabd434d3923d3c9cb	bevy/assets/textures/rpg/tiles/generic-rpg-tile39.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile39.png
+c70f1b34b78d51802d06ec0c47184dafa1a0332afb01f1ff489ced615e8123d8	bevy/assets/textures/rpg/tiles/generic-rpg-tile40.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile40.png
+0cc1dd77483bf317d65be8cd650d9f882e1f7a6cbc52a886b22dca7395db2cca	bevy/assets/textures/rpg/tiles/generic-rpg-tile41.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile41.png
+d155bae64700a815167f7223b8a19ae348fe09ccd487a5c8ca5f9a18cf462fff	bevy/assets/textures/rpg/tiles/generic-rpg-tile42.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile42.png
+912d23db6aaedc69e43902a89ad4803ae15ea28254cb8ceb02f636f3f7132e9a	bevy/assets/textures/rpg/tiles/generic-rpg-tile43.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile43.png
+0e14fd322c28b0bb1359c9402cdbc81f6cf2d0637506fe3eda69dae04d4b64fe	bevy/assets/textures/rpg/tiles/generic-rpg-tile44.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile44.png
+68a95a8222a7075496def803f539b468ea4730b16d2b0aabb2ca4787b35a016e	bevy/assets/textures/rpg/tiles/generic-rpg-tile45.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile45.png
+13bf184ad6af5fba88fe9359fe88e6aba3f79d16ec9bb9584db8d581c6febb91	bevy/assets/textures/rpg/tiles/generic-rpg-tile46.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile46.png
+450e3d38aded327637ecf27aae605304e5680e8b24abcb6441bb6d902c375540	bevy/assets/textures/rpg/tiles/generic-rpg-tile47.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile47.png
+9638f6019af80e28e92e2c65257c9a2e20200a527045e6bf260179209a521163	bevy/assets/textures/rpg/tiles/generic-rpg-tile48.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile48.png
+f61faec7c5d347f987128b1d3be17f58b4e54940309ad5fcee9d85c472c70e0b	bevy/assets/textures/rpg/tiles/generic-rpg-tile49.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile49.png
+8970a0c547f8fe83a087f6eff2dc02c1287649fafa9d22daadbe372ae08a2787	bevy/assets/textures/rpg/tiles/generic-rpg-tile50.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile50.png
+e974f86b9a6675c0f56db86d76576f6d16e715d602aec3efd51767ca12311fdb	bevy/assets/textures/rpg/tiles/generic-rpg-tile51.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile51.png
+1787f1b023c7b865ebc2765c85644f5f44e08e4f6beeb455c9ee4fcd90506200	bevy/assets/textures/rpg/tiles/generic-rpg-tile52.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile52.png
+b9dff6a40315af9033d38a44b62df679cc3d8331767e1051002296cc333b25ff	bevy/assets/textures/rpg/tiles/generic-rpg-tile53.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile53.png
+a103e8509e2b66bb4d932b04ab6b8cb3c63f4bc5f9984178ce24a28e16e68094	bevy/assets/textures/rpg/tiles/generic-rpg-tile54.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile54.png
+831d66150424b4b23e5db75f6b4f266d0002a66905118b843ab673a11a149a2f	bevy/assets/textures/rpg/tiles/generic-rpg-tile55.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile55.png
+ba78d2cab7e8b2ea5521de93ccca117a355449e816da1e14aa477b84428a80c1	bevy/assets/textures/rpg/tiles/generic-rpg-tile56.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile56.png
+57c53dae26f856cff00d907eceba9556b4df1e5f6a9bcf3c155a8800e1c09c6d	bevy/assets/textures/rpg/tiles/generic-rpg-tile57.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile57.png
+43078abc5fc88579e662dde52fcf0c212d0f94e706791f39d55a01990a0bf92f	bevy/assets/textures/rpg/tiles/generic-rpg-tile58.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile58.png
+f2267b8629679e8ce15d11e8bc55d90a57f95d8bede15ae0d8d809b0befe9c79	bevy/assets/textures/rpg/tiles/generic-rpg-tile59.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile59.png
+3c7e95b764655ca61095e2f26c03debd4074577be443523baf602034185d561c	bevy/assets/textures/rpg/tiles/generic-rpg-tile60.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile60.png
+cd2c6a45276478cc04259d6bbd16cbbc40a7d9e2f6ba989baecea00f54fe11cf	bevy/assets/textures/rpg/tiles/generic-rpg-tile61.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile61.png
+8ed57c70759231ee3ef07b3add5702a421b633cbfe657bd3d0fa577dcb7ae4f2	bevy/assets/textures/rpg/tiles/generic-rpg-tile62.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile62.png
+27f39010d43ea6d824891e6cf64b8aed3e13226f525cf727e55aa1feefb7e612	bevy/assets/textures/rpg/tiles/generic-rpg-tile63.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile63.png
+4f9c7e56a54294d4016a7d1768a45f85677228655b97955b5b378ae283b5aae9	bevy/assets/textures/rpg/tiles/generic-rpg-tile64.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile64.png
+4bd6ebd45f464063643d782d61b069348d584ad22d9ed4a5ecf41073158e4978	bevy/assets/textures/rpg/tiles/generic-rpg-tile65.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile65.png
+0c421c24ca6d9e942b19f0ecb6f3aa3d2dccfc9346b5d0a66b719b9c8e76e38a	bevy/assets/textures/rpg/tiles/generic-rpg-tile66.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile66.png
+11dbd2c65024e34cbe96877eee1179c5e3ce7a80d30856639f3218cd940e418e	bevy/assets/textures/rpg/tiles/generic-rpg-tile67.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile67.png
+42621e86b2621ad188235b17caa09a080fe7200a43a788ea545f42bc988e3535	bevy/assets/textures/rpg/tiles/generic-rpg-tile68.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile68.png
+3fdfae4a2028d596c90975729df8c5db54b00f38146f7478ae2b50895e8d6a80	bevy/assets/textures/rpg/tiles/generic-rpg-tile69.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile69.png
+27dedd42fa8791c6bffcc841d82fd95197dfa481a8ead8d51e3dfdcb69706045	bevy/assets/textures/rpg/tiles/generic-rpg-tile70.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile70.png
+f50c95f8310c5f0e7c8f3217233d97cb2057b6d5881e651306a894be20794c15	bevy/assets/textures/rpg/tiles/generic-rpg-tile71.png	mgstudio-engine/assets/textures/rpg/tiles/generic-rpg-tile71.png
+b2ec6d6bce604b3435b8c3eacdf12d5656f24dcf4a32b5ef65a5114d424224a6	bevy/assets/textures/rpg/ui/generic-rpg-ui-inventario.png	mgstudio-engine/assets/textures/rpg/ui/generic-rpg-ui-inventario.png
+5a3a14daccc7733420fbd7b1942d2de91f1abf0f6785f129be878c873a319106	bevy/assets/textures/rpg/ui/generic-rpg-ui-inventario01.png	mgstudio-engine/assets/textures/rpg/ui/generic-rpg-ui-inventario01.png
+330a1143edf812afdeb74a904ff1360ada865627a9ae226e57a5e1b1c7ba7ac5	bevy/assets/textures/rpg/ui/generic-rpg-ui-inventario02.png	mgstudio-engine/assets/textures/rpg/ui/generic-rpg-ui-inventario02.png
+6f85121cc918e74d39333da09ff632f42fa0c8736abd4418844d69f58bb2a926	bevy/assets/textures/rpg/ui/generic-rpg-ui-inventario03.png	mgstudio-engine/assets/textures/rpg/ui/generic-rpg-ui-inventario03.png
+32049aa269d5155bd2505b614bb7ab4415db435a83c2af4c94b2f59c4437611f	bevy/assets/textures/rpg/ui/generic-rpg-ui-inventario04.png	mgstudio-engine/assets/textures/rpg/ui/generic-rpg-ui-inventario04.png
+338b10208b4f25e59b4ba2178b7397a8615607a47db898b5b47e017f9d508937	bevy/assets/textures/rpg/ui/generic-rpg-ui-text-box.png	mgstudio-engine/assets/textures/rpg/ui/generic-rpg-ui-text-box.png
+4f00d6568aa58a37639aaf513ff72b908e488ef9171d949916ace13da6498f36	bevy/assets/textures/simplespace/License.txt	mgstudio-engine/assets/textures/simplespace/License.txt
+3c90ed538ccc3e4c7aa2f6c553b0d4c379d47066ca020ae2af37d22e07e1da6e	bevy/assets/textures/simplespace/enemy_A.png	mgstudio-engine/assets/textures/simplespace/enemy_A.png
+7986aa0290f348ae6bc1c283f872cf4c7b0f0e3710ff2bfc3b1788769aeddb76	bevy/assets/textures/simplespace/enemy_B.png	mgstudio-engine/assets/textures/simplespace/enemy_B.png
+1ae65bbee63d655f14129c86b44275cff4539b0fe3dc030a694737d97e775901	bevy/assets/textures/simplespace/ship_C.png	mgstudio-engine/assets/textures/simplespace/ship_C.png
+d278b2bf8cee12dbc6706b21c01ace4ccfd532593935e08d4a4512edbede8726	bevy/assets/textures/slice_square.png	mgstudio-engine/assets/textures/slice_square.png
+227ab246fa38e211b0af7ca31ff0db0e71b0ed9e449b6c002269230017924cd8	bevy/assets/textures/slice_square_2.png	mgstudio-engine/assets/textures/slice_square_2.png
+7fe3227764fd224629bb92b794917493aaf16bbd9eb610d1fb12a1a52f43603c	bevy/assets/textures/spiaggia_di_mondello_1k.hdr	mgstudio-engine/assets/textures/spiaggia_di_mondello_1k.hdr
+02b6997abe327ae0fd9af9dbb1c1ef4c4e1eac81daf0fb9f5f2c35f2b2afcfcf	bevy/crates/bevy_core_pipeline/src/tonemapping/luts/AgX-default_contrast.ktx2	mgstudio-engine/assets/textures/tonemapping/AgX-default_contrast.ktx2
+793bd0e2b75c1eff50f9836c967f98e4e20ea2ff5c6cf5b5d0b2e7412387d3c6	bevy/crates/bevy_core_pipeline/src/tonemapping/luts/Blender_-11_12.ktx2	mgstudio-engine/assets/textures/tonemapping/Blender_-11_12.ktx2
+0a680861d32a617095fad3ab5af9b7bdb80771d118b84a2483a12f9960e461fe	bevy/crates/bevy_core_pipeline/src/tonemapping/luts/tony_mc_mapface.ktx2	mgstudio-engine/assets/textures/tonemapping/tony_mc_mapface.ktx2
+ed65a763ceb939b02e4996941ae2b8e4865a291865d623f7ffd8fe55b0685cdb	bevy/assets/textures/uv_checker_bw.png	mgstudio-engine/assets/textures/uv_checker_bw.png
+5601b1bb8cf38282dfcca20721241082b2319ce68f93e0a72d372eebfed2bedd	bevy/assets/textures/water_normals.png	mgstudio-engine/assets/textures/water_normals.png
+64e2b45c6b01fab61c702602a1af01b3a89c260cfe79b269f264ffd505bdb2fd	bevy/assets/volumes/bunny.ktx2	mgstudio-engine/assets/volumes/bunny.ktx2
+4dae202ce3d71dd36273ea522ecd12df2b89aa29abfb0acdb74c0727e58c427e	bevy/assets/volumes/fog_noise.ktx2	mgstudio-engine/assets/volumes/fog_noise.ktx2
+87a65aa8f50b4d0340915acfd6b644a34af2e7bf7c3239440a00d8e364122f53	bevy/examples/asset/files/bevy_pixel_dark.png	mgstudio-engine/examples/asset/files/bevy_pixel_dark.png
+87a65aa8f50b4d0340915acfd6b644a34af2e7bf7c3239440a00d8e364122f53	bevy/examples/asset/files/bevy_pixel_dark_with_meta.png	mgstudio-engine/examples/asset/files/bevy_pixel_dark_with_meta.png
+87a65aa8f50b4d0340915acfd6b644a34af2e7bf7c3239440a00d8e364122f53	bevy/examples/asset/files/bevy_pixel_dark_with_settings.png	mgstudio-engine/examples/asset/files/bevy_pixel_dark_with_settings.png
+9a60745c822cfa292988dccaa4fec582fc45944e3e851f692be67ba76582e8ba	bevy/examples/asset/files/bevy_pixel_light.png	mgstudio-engine/examples/asset/files/bevy_pixel_light.png
+8b7f0244828e3729868f2060e10f184663a3ca87b58e733cb7cf7aa86b168117	bevy/crates/bevy_pbr/src/bluenoise/stbn.ktx2	mgstudio-engine/pbr/bluenoise/stbn.ktx2
+3090e8136a63be266b635f4f3700c5b3daf93a1a9d288699577c1e0c7d194415	bevy/crates/bevy_pbr/src/environment_map/dfg.ktx2	mgstudio-engine/pbr/environment_map/dfg.ktx2
+9387e608cb925af0fa56739d0cc0cb674bddc226e45fe7f2065df722587d06e8	bevy/crates/bevy_pbr/src/ltc/ltc.ktx2	mgstudio-engine/pbr/ltc/ltc.ktx2
+ddb499393c1d0e41dcc52c24d0179d9e8d86bc7680d9ee10faee56ca676f7fa1	bevy/crates/bevy_pbr/src/meshlet/meshlet_preview.png	mgstudio-engine/pbr/meshlet/meshlet_preview.png
diff --git a/scripts/sync_bevy_assets.py b/scripts/sync_bevy_assets.py
new file mode 100755
index 000000000..c0b86d9f8
--- /dev/null
+++ b/scripts/sync_bevy_assets.py
@@ -0,0 +1,145 @@
+#!/usr/bin/env python3
+"""Synchronize non-WGSL resource mirrors with the pinned Bevy baseline."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import shutil
+import subprocess
+import sys
+from pathlib import Path
+
+
+BEVY_BASELINE_COMMIT = "1413bc4e3632233b8fa610a6cf14b90258556c51"
+MANIFEST_PATH = Path("scripts/bevy_asset_mirror.sha256")
+
+
+def repository_root() -> Path:
+    return Path(__file__).resolve().parents[1]
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as source:
+        for chunk in iter(lambda: source.read(1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def read_manifest(root: Path) -> list[tuple[str, Path, Path]]:
+    manifest = root / MANIFEST_PATH
+    if not manifest.is_file():
+        raise RuntimeError(f"missing Bevy asset manifest: {manifest}")
+
+    entries: list[tuple[str, Path, Path]] = []
+    for line_number, line in enumerate(manifest.read_text().splitlines(), start=1):
+        if not line or line.startswith("#"):
+            continue
+        fields = line.split("\t")
+        if len(fields) != 3:
+            raise RuntimeError(f"invalid manifest row {line_number}")
+        expected_hash, source, destination = fields
+        entries.append((expected_hash, Path(source), Path(destination)))
+    return entries
+
+
+def require_pinned_bevy(root: Path) -> None:
+    bevy_root = root / "bevy"
+    if not (bevy_root / ".git").exists():
+        raise RuntimeError(f"missing Bevy checkout: {bevy_root}")
+    result = subprocess.run(
+        ["git", "-C", str(bevy_root), "rev-parse", "HEAD"],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    actual = result.stdout.strip()
+    if actual != BEVY_BASELINE_COMMIT:
+        raise RuntimeError(
+            f"expected Bevy baseline {BEVY_BASELINE_COMMIT}, got {actual}"
+        )
+
+
+def check_entries(
+    root: Path,
+    entries: list[tuple[str, Path, Path]],
+    check_sources: bool,
+) -> int:
+    failures: list[str] = []
+    for expected_hash, source_relative, destination_relative in entries:
+        if check_sources:
+            source = root / source_relative
+            if not source.is_file():
+                failures.append(f"missing source: {source_relative}")
+            elif sha256(source) != expected_hash:
+                failures.append(f"unexpected source bytes: {source_relative}")
+
+        destination = root / destination_relative
+        if not destination.is_file():
+            failures.append(f"missing mirror: {destination_relative}")
+        elif sha256(destination) != expected_hash:
+            failures.append(f"out-of-date mirror: {destination_relative}")
+
+    if failures:
+        print("Bevy non-WGSL resource mirror is out of date:", file=sys.stderr)
+        for failure in failures:
+            print(f"  {failure}", file=sys.stderr)
+        return 1
+    print(f"checked {len(entries)} pinned Bevy non-WGSL resource mirrors")
+    return 0
+
+
+def synchronize(root: Path, entries: list[tuple[str, Path, Path]]) -> int:
+    updated = 0
+    for expected_hash, source_relative, destination_relative in entries:
+        source = root / source_relative
+        if not source.is_file() or sha256(source) != expected_hash:
+            print(f"invalid pinned source: {source_relative}", file=sys.stderr)
+            return 1
+        destination = root / destination_relative
+        if destination.is_file() and sha256(destination) == expected_hash:
+            continue
+        destination.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copyfile(source, destination)
+        updated += 1
+    print(
+        f"synchronized {len(entries)} pinned Bevy non-WGSL resource mirrors "
+        f"({updated} updated)"
+    )
+    return 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(
+        description="Synchronize non-WGSL resources from the pinned Bevy baseline."
+    )
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument(
+        "--check",
+        action="store_true",
+        help="verify sources and mirrors against the pinned Bevy checkout",
+    )
+    mode.add_argument(
+        "--check-manifest",
+        action="store_true",
+        help="verify mirrors without requiring a Bevy checkout",
+    )
+    args = parser.parse_args()
+
+    root = repository_root()
+    try:
+        entries = read_manifest(root)
+        if args.check_manifest:
+            return check_entries(root, entries, check_sources=False)
+        require_pinned_bevy(root)
+        if args.check:
+            return check_entries(root, entries, check_sources=True)
+        return synchronize(root, entries)
+    except (OSError, RuntimeError, subprocess.CalledProcessError) as error:
+        print(error, file=sys.stderr)
+        return 2
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())