diff --git a/.github/workflows/native-cartridge-views.yml b/.github/workflows/native-cartridge-views.yml
new file mode 100644
index 000000000..5ca95c26a
--- /dev/null
+++ b/.github/workflows/native-cartridge-views.yml
@@ -0,0 +1,41 @@
+name: Native cartridge observation views
+on:
+  pull_request:
+    paths:
+      - 'src/battle/Gen3SafariText.lua'
+      - 'src/battle/Gen3Battle.lua'
+      - 'src/core/game3/mb.lua'
+      - 'src/core/game3/constants.lua'
+      - 'src/import/gba/field_label_facts.lua'
+      - 'tests/engine/native_constant_queries.lua'
+      - 'src/core/game3/rom_text.lua'
+      - 'src/core/game3/battle/profile.lua'
+      - 'src/core/game3/battle/healthbox.lua'
+      - 'tests/engine/native_safari_text_views.lua'
+      - 'tests/engine/native_rom_text_ir.lua'
+      - 'tests/engine/compatibility_cell_semantics.lua'
+      - '.github/workflows/native-cartridge-views.yml'
+  workflow_dispatch:
+permissions:
+  contents: read
+concurrency:
+  group: native-cartridge-views-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  contracts:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v7
+      - run: sudo apt-get update && sudo apt-get install -y luajit
+      - name: Native authority and retired-view boundaries
+        run: |
+          luajit tests/engine/native_safari_text_views.lua
+          luajit tests/engine/native_constant_queries.lua
+          luajit tests/engine/compatibility_cell_semantics.lua
+          luajit tests/engine/native_rom_text_ir.lua
+          luajit tests/engine/native_battle_chrome.lua
+      - name: Existing native Gen2 presentation
+        run: |
+          luajit tests/engine/gen2_battle_window.lua
+          luajit tests/engine/gen2_battle_scene.lua
diff --git a/.github/workflows/native-file-picker.yml b/.github/workflows/native-file-picker.yml
new file mode 100644
index 000000000..454070b8d
--- /dev/null
+++ b/.github/workflows/native-file-picker.yml
@@ -0,0 +1,31 @@
+name: Native desktop file selection
+on:
+  pull_request:
+    paths:
+      - 'src/core/FilePicker.lua'
+      - 'src/core/HostShell.lua'
+      - 'src/import/RomImporter.lua'
+      - 'tests/engine/native_file_picker.lua'
+      - 'tests/*picker*'
+      - 'tests/rom_importer_android_mod_pick_test.lua'
+      - '.github/workflows/native-file-picker.yml'
+  workflow_dispatch:
+permissions:
+  contents: read
+concurrency:
+  group: native-file-picker-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  contracts:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v7
+      - run: sudo apt-get update && sudo apt-get install -y luajit
+      - name: Model desktop commands without opening dialogs
+        run: luajit tests/engine/native_file_picker.lua
+      - name: Preserve native pointer release and mobile fallback
+        run: |
+          luajit tests/parity_picker_pointer_grab.lua
+          luajit tests/rom_importer_no_picker_test.lua
+          luajit tests/rom_importer_android_mod_pick_test.lua
diff --git a/.github/workflows/native-flight.yml b/.github/workflows/native-flight.yml
new file mode 100644
index 000000000..63a600113
--- /dev/null
+++ b/.github/workflows/native-flight.yml
@@ -0,0 +1,41 @@
+name: Native region picker and flight boundary
+on:
+  pull_request:
+    paths:
+      - 'src/compat/gen1/NativeRegionMap.lua'
+      - 'src/world/Gen3FlyTargets.lua'
+      - 'src/world/Gen3FlyArrival.lua'
+      - 'src/core/game3/field_effects.lua'
+      - 'src/render/Transition.lua'
+      - 'tests/engine/native_fly_arrival.lua'
+      - 'src/ui/Gen3RegionMap.lua'
+      - 'src/ui/Gen3RsRegionMap.lua'
+      - 'src/ui/game3/region_map.lua'
+      - 'src/ui/game3/rse/region_map.lua'
+      - 'src/core/game3/field.lua'
+      - 'src/world/OverworldController.lua'
+      - 'tests/engine/native_region_map_observations.lua'
+      - 'tests/engine/native_fly_boundary.lua'
+      - '.github/workflows/native-flight.yml'
+  workflow_dispatch:
+permissions:
+  contents: read
+concurrency:
+  group: native-flight-${{ github.ref }}
+  cancel-in-progress: true
+jobs:
+  contracts:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v7
+      - run: sudo apt-get update && sudo apt-get install -y luajit
+      - name: Native observations and once-only departure
+        run: |
+          luajit tests/engine/native_region_map_observations.lua
+          luajit tests/engine/native_fly_boundary.lua
+          luajit tests/engine/native_fly_arrival.lua
+          luajit tests/engine/native_field_observations.lua
+      - name: Existing native admission and other generations
+        run: |
+          luajit tests/engine/gen2_battle_scene.lua
diff --git a/.github/workflows/native-phase-scopes.yml b/.github/workflows/native-phase-scopes.yml
new file mode 100644
index 000000000..778065b59
--- /dev/null
+++ b/.github/workflows/native-phase-scopes.yml
@@ -0,0 +1,15 @@
+name: Native coroutine phase ownership
+on:
+  pull_request:
+  workflow_dispatch:
+permissions:
+  contents: read
+jobs:
+  contracts:
+    runs-on: ubuntu-latest
+    timeout-minutes: 5
+    steps:
+      - uses: actions/checkout@v7
+      - run: sudo apt-get update && sudo apt-get install -y luajit
+      - run: luajit tests/engine/native_coroutine_phase_scopes.lua
+      - run: luajit tests/engine/native_game_coroutine_scopes.lua
diff --git a/LICENSE-ROXAS2712.md b/LICENSE-ROXAS2712.md
new file mode 100644
index 000000000..fbcffd47c
--- /dev/null
+++ b/LICENSE-ROXAS2712.md
@@ -0,0 +1,88 @@
+# Roxas2712 — Fork Contributions
+
+Version 1.0 · Effective 25 October 2026
+
+Copyright © 2026 Roxas2712, to the extent of rights held.
+All rights reserved except as expressly granted below or already granted.
+
+## 1. Scope and ownership
+
+This notice applies only to original contributions made by Roxas2712
+(GitHub: Roxas2712) to `Roxas2712/Gen2Recomped`, including original additions
+within modified files, insofar as he owns the relevant rights. Git history,
+pull-request diffs and source provenance identify contributions; a commit
+author or a whole-file change alone does not establish ownership of every
+part of that file.
+
+It does not claim ownership of Cedric's work, Gen1Recomp / BOIS CLUB GAMES
+work, other contributors' work, third-party dependencies, or ROM-derived
+content. Their applicable licences and notices remain in force. It does not
+grant permission to distribute the complete combined fork where another
+rights holder's permission is required.
+
+## 2. General permission and reserved rights
+
+For contributions covered by this notice and not already licensed more
+broadly, you may read and study the published source and make private,
+non-commercial modifications and builds for your own use. This grants no
+general permission to redistribute, sublicense, sell, or offer those
+contributions as a hosted service. Other uses require Roxas2712's
+written permission, except for the specific permission below and rights
+available independently under applicable law.
+
+Keep the relevant copyright, licence and attribution notices. Do not
+represent Roxas2712's contributions as exclusively authored by someone
+else. Public source availability alone does not put them in the public
+domain or grant an open-source licence.
+
+## 3. Specific permission for Cedric / UNDERdecoded
+
+Roxas2712 expressly grants Cedric (Ced; GitHub: UNDERdecoded /
+UNDERdecodedHD) a non-exclusive, worldwide, perpetual, royalty-free
+permission to use, reproduce, integrate, modify and distribute the covered
+contributions that Roxas2712 submits or expressly offers through pull
+requests to `UNDERdecoded/Gen2Recomped`, for Cedric's Gen2Recomped /
+RetroRecompiled project. This includes its renamed continuation maintained
+by Cedric, its official builds, and its commercial operation.
+
+Cedric may license the incorporated contributions to recipients as part of
+that project, subject to preserving this permission's applicable credit and
+notice requirements. This permission is not a copyright assignment, is not
+exclusive, and does not cover unpublished work, separate repositories,
+ModCompass service operation, credentials, or content not offered in those
+pull requests. Roxas2712 retains his own rights to his contributions.
+
+For uses relying on this permission:
+
+- retain the relevant source copyright and licence notices;
+- give visible credit in the project's README or equivalent public project
+  page, and in the application's existing About / Credits view, if present;
+- use at least the following credit, or a substantially equivalent one:
+
+  > Contributions by Roxas2712 —
+  > https://github.com/Roxas2712
+
+A maintained consolidated contributor credit is sufficient; a separate
+credit on every screen or for every change is not required. Adapted
+contributions must not be attributed exclusively to another author. Other
+contributors' credits must also remain intact.
+
+## 4. Earlier licences and permissions remain effective
+
+This notice does not revoke, narrow, or retrospectively add conditions to
+any permission already validly granted, including MIT / GPL grants,
+separate agreements, or permissions arising from previously submitted
+pull requests. Where an earlier grant permits a use independently of this
+notice, its existing terms govern that use. For such earlier uses, the
+visible credit above is requested to the extent it is not already required.
+
+For subsequent contributions, this is the default statement of Roxas2712's own reserved rights and the specific PR permission, subject to any
+applicable existing licence obligations or separately agreed terms. It
+does not change another rights holder's licence or guarantee compatibility
+of a particular combination of code.
+
+## 5. No warranty
+
+To the extent permitted by applicable law, these contributions are provided
+as is, without warranty. No support obligation, endorsement, or rights to
+third-party code, game assets, names, or trademarks are granted.
diff --git a/docs/native-battle-animation-runtime.md b/docs/native-battle-animation-runtime.md
new file mode 100644
index 000000000..5baca515a
--- /dev/null
+++ b/docs/native-battle-animation-runtime.md
@@ -0,0 +1,72 @@
+# Native battle animation bridge
+
+`src.core.game3.battle.anim` presents the admitted GBA battle through its native
+`BattleState`, `Gen3MoveAnim` and `Gen3BallAnim` owners. It does not load another
+battle engine or rewrite a mod package. FireRed, LeafGreen, Emerald, Ruby and
+Sapphire use the same boundary and their own imported identifiers and records.
+
+## Shared clock and ownership
+
+The native update opens one presentation phase. A source `Anim.update()` can
+advance that phase while a custom ending or pose holds the combat update.
+Repeated source calls and a later native base call consume the same display
+steps. The native dt drives sprite animations. Outside that phase, source
+updates cannot manufacture frames.
+
+Move/ball effects, visual waits, HP drain and EXP fill remain native operations.
+Only the native combat update consumes command rows, input and outcomes.
+Source-launched clips occupy the native animation player and hold the command
+queue until that clip finishes. A presentation serial distinguishes a finished
+source clip from a newer native animation on the same player. Reset/unload
+cancels only a clip still owned by that source admission.
+
+`present(id)` has stable identity for an admitted battler. It observes native
+display HP/maximum/level/status/EXP, visibility, offsets and affine effects.
+Source visual overrides compose around the existing native sprite draw;
+reading a native effect never applies it a second time. `shownBattler` carries
+an owned presentation override without replacing the native combatant.
+Replacing the session, save, data or catalogue retires old poses and callbacks.
+
+`GameVersion.layout(id)` also reports the registered GBA family (`frlg` or
+`rse`) so an unchanged field companion probe can recognize the native host.
+It supports current-version and colon queries without changing cache/save
+selection; an explicit registered layout takes precedence.
+
+## Geometry and screen effects
+
+`anim_coords` exposes authored anchors and ordering for singles and doubles.
+Current imported cartridge coordinates take precedence over the standard
+240x160 anchors. Temporary side bindings restore on success and failure and
+preserve trailing nil arguments/results.
+
+Supported screen effects are inversion, fade to white/black, darkening,
+grayscale and blending to a custom colour. Repeated begin calls reapply within
+one guarded render seam; nested seams restore their caller's shader. The native
+graphics guard restores render targets, transforms, shaders and leaked pushes
+after an error. Synthetic asymmetric sprites test orientation as well as colour.
+
+## Current boundary
+
+This bridge implements native move launch/observation, source pose tweens,
+display ratios, sequence observations, screen effects and coordinate bindings.
+It deliberately does not advertise a complete presentation API version.
+Authored animation commands, mutable VM/sprite/task/palette callbacks,
+particle bands, trainer/intro/switch/catch stage control, source HP/EXP tween
+commands and complete custom UI captures still require integration. A module
+being importable is not evidence of a complete mod boot or playable campaign.
+
+## Validation
+
+- `tests/engine/native_battle_animation.lua`: all five editions; shared clocks,
+  owned clip completion, held command queues, stale poses/callbacks and 180-frame
+  native trajectory comparisons per edition with and without the bridge.
+- `tools/battle-animation-runtime/lifecycle-check.lua`: SDK entry failure,
+  teardown and native peer callback identities.
+- `tools/battle-animation-runtime/coords-check.lua`: optional local contract
+  oracle supplied through `BATTLE_COORDS_ORACLE`; no external engine is bundled.
+- `tools/battle-animation-runtime/host`: actual Metal/OpenGL sprite and screen
+  effect rendering, pixel comparisons and graphics error restoration.
+
+Local qualification runs use the repository's QA storage manager, frozen source
+copies and dedicated LOVE identities. They use synthetic imported data and art;
+they do not open player profiles, save files or ROM originals.
diff --git a/docs/native-battle-chrome.md b/docs/native-battle-chrome.md
new file mode 100644
index 000000000..74cd2af70
--- /dev/null
+++ b/docs/native-battle-chrome.md
@@ -0,0 +1,42 @@
+# Native battle chrome and particle observations
+
+Battle panel wrappers enter the existing native panel pass. Repeated base
+calls paint once, including translucent artwork. Window queries use imported
+cartridge templates and the actual native surface width. Healthbox captures
+validate the current battle and battler, use native geometry, and apply owned
+offsets inside a restored graphics scope. Native shown ailment state stays
+separate from queued logical status changes.
+
+Trainer images and picture offsets resolve from native imported records.
+Additional genuine window templates and the native trainer portrait index
+are retained by new imports. Existing imports retain their available records;
+unavailable windows and artwork are reported rather than invented.
+
+The particle observation module projects actual native event poses at the
+current clip/frame. It cannot advance a clock or create combat particles.
+Reversible position, scale, reflection, visibility and custom drawing changes
+compose around the same native event painter, including OAM-composited draws.
+The ordinary native path avoids these observations until a consumer asks for
+the pool. Retired events and unloaded owners leave no visible source rows.
+This is not a complete external animation VM or managed-sprite API.
+
+ROM-free tests cover all five GBA editions. The real Metal/OpenGL host uses
+asymmetric synthetic sprites and panels, independent pixel remapping, native
+text shaders, multiple logical widths and healthbox offsets. It does not load
+the original package or demonstrate complete gameplay.
+
+The unchanged local package has progressed beyond the previously missing
+battle chrome, healthbox, trainer-picture and picture-coordinate imports.
+Additional battle/UI contracts remain. The complete battle presentation
+protocol is not advertised by this change. No private runtime or cartridge
+assets are included.
+
+## Public-host composition
+
+The API-2 candidate builds on #327 and its declared prerequisites. It passes
+315 chrome/particle, 916 companion, 1,466 terrain, 486 collision and nine
+lifecycle checks, plus 3/3 SDK suites. Engine: 95/106 versus reference 94/105,
+with the identical eleven inherited failed suites. Actual Metal and OpenGL
+runs each pass the same 778 graphics checks, 90 comparisons and 185 readbacks
+on the composed public candidate. No full unchanged-package gameplay
+acceptance is inferred from those fixtures.
diff --git a/docs/native-companion-runtime.md b/docs/native-companion-runtime.md
new file mode 100644
index 000000000..0d4738143
--- /dev/null
+++ b/docs/native-companion-runtime.md
@@ -0,0 +1,77 @@
+# Native companion runtime
+
+Source consumers on FireRed, LeafGreen, Emerald, Ruby and Sapphire can use
+native party residents, encounter admission, field phases and modal screens.
+The adapters do not load another game engine or copy an application save.
+
+## Native ownership
+
+- Session party members are typed views with cartridge-numbered identifiers.
+  HP, status, friendship, nickname and held items write to their admitted
+  resident. Move IDs and maximum PP are read-only; PP edits are validated
+  together before committing. Retired views reject writes.
+- Bag handles use native pocket/capacity rules. Capacity queries run against
+  detached inventory containers; negative quantities cannot remove items.
+  Dex and Safari queries inspect the admitted native session.
+- Authored wild encounters validate species, level, personality, six IVs,
+  moves/PP, item, HP and status before construction. Native encounter
+  admission retains its healthy-party, busy-world and single-pending-request
+  guards. Native cleanup runs even after the requester is unloaded; its
+  continuation runs at most once. Roaming identity and wounds remain native.
+- Field locks belong to a mod and tag. Interactions, follower updates and
+  party-menu wrappers consume their native phase once. Short player gestures
+  advance on the player's fixed step and respect the native pose owner.
+- Draw-only actors join native sorting temporarily. They do not become NPCs,
+  collision objects or independently updated entities. Rendering errors restore
+  the original entity collection. Follower artwork can use an owned renderer.
+- Dialogue uses the native TextBox printer. Choice, evolution and move-reminder
+  screens use the native StateStack. A UI flow owns its child screens across
+  pop/push continuations; retirement removes those screens and discards its
+  callback without removing an explicitly foreign overlay.
+- EXP awards share native growth, stats and level-up events. Damage queries
+  use the native formula/ruleset. Imported moves, item effects, fonts, sounds
+  and cries remain native resources. Nested two-tone text restores both the
+  shader binding and the outer ink/shadow uniforms.
+
+Optional conveniences attach through an owned option provider. Timed outdoor
+encounters reorder existing land entries while preserving native position
+weights and rates. Ball shortcuts use idle command admission and the ordinary
+bag/catch transaction. Repel reuse asks before consuming another item.
+Summary details cycle native stats, IVs and EVs without changing the Pokemon.
+Disabling the owner disables these options.
+
+## Qualification and remaining work
+
+ROM-free fixtures exercise all five editions, including encounter identity,
+PP validation, lock isolation, native menu navigation, evolution cancellation
+and completion, free-slot learning, and unloading a full-moveset reminder.
+Run `luajit tests/engine/native_companion_runtime.lua`, the engine tier and
+SDK tier. The companion GPU host additionally checks real text pixels and
+nested native shader uniforms on Metal and OpenGL; it extends the native
+battle orientation/effect oracle.
+
+The local unchanged 1.0.9 package now passes its companion-member probe.
+Initialization subsequently requires additional battle/UI presentation
+modules, beginning with `src.ui.game3.battle_chrome`. This change does not
+advertise the complete battle presentation protocol or claim that the whole
+package is playable. Effect-specific field combat, additional UI contracts,
+full package graphics and end-to-end gameplay require further qualification.
+
+Local test starters use managed frozen candidates and disposable profiles,
+retain an 8 GiB free-space reserve, and do not read or modify player profiles.
+No private runtime source or game assets are included in this contribution.
+
+## Public-host composition
+
+This draft composes the existing terrain (#318), battle-animation (#317) and
+field-move (#304) offers. The local API-2 qualification retains the previously
+qualified map, player, session, modal-stack and rendering prerequisites in its
+frozen reference; these dependencies must be composed before treating this as
+a standalone runnable change. Internal admission/read helpers do not advertise
+another public API version.
+
+The composed public candidate passes 916 companion checks, 1,466 terrain
+checks, 486 collision checks, nine API-2 lifecycle checks and three SDK suites.
+Its engine result is 94/105 suites versus 93/104 in the frozen reference, with
+the identical eleven inherited failures. The initial source-member probe is
+not a full package initialization or gameplay acceptance.
diff --git a/docs/native-companion-terrain.md b/docs/native-companion-terrain.md
new file mode 100644
index 000000000..ab1bbf0a9
--- /dev/null
+++ b/docs/native-companion-terrain.md
@@ -0,0 +1,31 @@
+# Native companion terrain observations
+
+Contributions by Roxas2712 — <https://github.com/Roxas2712>.
+Existing upstream rights and notices remain applicable to the shared native machinery.
+
+The GBA source namespace now reads grass, next elevation and ledge landing
+from the native map owner. Elevation zero remains a real height; bridge
+markers preserve the incoming height. Native movement and source queries
+share the same transition and ledge classifier. Dataset overrides, older
+standing-cell ledges, later-edition jump distances and callback arity remain
+native. Queries never move actors, execute movement hooks or trigger warps.
+
+`src.core.game3.encounters` provides `ensureLoaded`, `terrainAt` and `tableFor`
+(`table_for` alias). Tables expose detached land/water/rocks/fishing areas,
+with cartridge species indices and source level-range field names. Map
+aliases resolve through the checked native map binding. Native header and
+script-variable changes are visible on the next query; unknown species or
+retired maps are refused instead of silently substituting another monster.
+Altering Cave header selection is shared with native encounter generation.
+These reads do not consume RNG or install another import cache.
+
+This is a partial interface. Encounter rolling, encounter identity transfer
+into battles, companion actor collection, follower commands and UI hooks
+still need their own integrations. No complete companion or presentation
+capability version is advertised, and unchanged Origami 1.0.9 initialization
+is not yet expected to succeed.
+
+Validation uses synthetic native owners for all five GBA editions, actual
+native hop dispatch, height/bridge transitions, cave/underwater terrain,
+sparse species indices, alternate headers, retired bindings, detached
+records and real SDK failure/teardown alongside a native peer.
diff --git a/docs/native-field-collision.md b/docs/native-field-collision.md
new file mode 100644
index 000000000..da94d2fbc
--- /dev/null
+++ b/docs/native-field-collision.md
@@ -0,0 +1,52 @@
+# Compatibility collision reads and native entry permission
+
+The collision module reads the live native GBA session. Classified COLL bytes
+remain detached source-format observations, while `canEnter` calls the existing
+native permission owner. No collision grid, actor state, warp event, script or
+save is changed by a query. Hypothetical origins, elevations and surf states
+use an observational mover; its real native actor and connected-map aliases
+are excluded from self-collision.
+
+Source behavior comes from original bank attributes and the existing semantic
+translator, including neighboring banks and authored borders. The existing
+map graph determines which metatile/pair a world coordinate samples. Native
+grid revisions and source-bank replacements remain visible. Classified arrays
+are cached by owned layout/revision; mutating such an observation cannot
+change native entry permission. Native extents remain authoritative for entry
+and bounds even where the source art layout has padding.
+
+The module exposes current-map/behavior/elevation/cell/grid observations,
+native walkable/water queries, source-format active warp observations and
+`canEnter`. Header-only warps on non-warp terrain stay inactive. Loader teardown
+retires readers and arrays after wrapper unwind. Held detached cells do not
+retain native maps or source banks. Sessions whose world belongs to an earlier
+dataset cannot grant movement.
+
+## Verification and integration
+
+`luajit tools/field-collision/check.lua` runs 486 ROM-free checks across all five
+editions using real native map and collision implementations. It covers native
+permission/reason agreement, source-bank semantics, connected/border sampling,
+grid changes, hypothetical requests, active/dead warps, detached overrides,
+dataset replacement, real loader teardown and weak-reference retirement.
+The player phase's 261 checks also pass with this session guard.
+
+The composed fork's full unchanged 1.0.9 source loader probe now reaches the
+missing `src.core.game3.tileset_native` module for all five editions. Full
+initialization, GPU rendering and gameplay remain unaccepted. These probes
+use fixture game data and read the full source package without modifying it.
+
+The standalone upstream diff requires player/session PR #254 and map-read
+PR #251 with its terrain/identity dependencies. All-five testing also requires
+cartridge PRs #183, #186 and #187. Its focused fixture runs in the composed
+fork; it cannot independently exercise missing prerequisite interfaces on
+pristine upstream main.
+
+## Remaining work
+
+Custom source-authored collision providers, binding/loading a different map,
+typed script writes and the rest of the source collision/field service
+surface still need integration. They must enter native commands rather than
+turning the detached presentation grid into a second simulation. The atlas,
+distinct session facade, field/UI/battle services and end-to-end acceptance
+remain separate workstreams.
diff --git a/docs/native-field-effect-sheets.md b/docs/native-field-effect-sheets.md
new file mode 100644
index 000000000..7be235b44
--- /dev/null
+++ b/docs/native-field-effect-sheets.md
@@ -0,0 +1,44 @@
+# Owned field-effect artwork
+
+`src.core.game3.field_effects` now supplies the resource part of the compatible
+field-effect interface: `install`, `manifest`, `manifestObject`, `loadSheet`
+(`getSpriteSheet`), `invalidate`, `release` and owner cancellation. It does not
+implement effect tasks, timers, start/wait commands, actor lists, reflections
+or draw phases. No empty task observations or additional simulation are used
+to imply that those contracts have been completed.
+
+The native catalogue uses identified imported tall-grass, surf-blob, ripple,
+sparkle, FRLG bird and independent emote-strip records when present. It does
+not claim that every edition imports each record. Each record's own geometry
+and frame order remain authoritative. Independent native emote strips are
+not renamed into a presumed combined fifteen-frame strip. Additional artwork
+and the native effect phase/state bridge remain required.
+
+A loaded sheet owns its ImageData, Image, full-frame quads and eight-pixel
+front crops. Neither Assets' image cache nor an actor SpriteRenderer is lent.
+Repeated requests share these owned resources with per-mod leases. Retirement
+uses a private allocation list: replacing public sheet fields cannot cause a
+borrowed image to be released. Actual generated-asset overrides are resolved
+at each request; changed paths/geometry retire the preceding owned sheet.
+
+An explicitly installed cache may provide the original `field_effects/objects.lua`
+and raw RGBA payloads through its own `read` method. No conversion file is
+written. Manifests run with an empty environment and bounded instructions,
+then validate scalar/table metadata, finite geometry, names, paths and duplicate
+identities. Payload length must exactly match the declared geometry. An authored
+manifest remains authoritative; a missing/malformed declared asset is not
+silently substituted with unrelated native artwork. Public manifest results
+are detached copies; ordinary cached sheet requests avoid copying the manifest.
+
+Providers bind to the current game/dataset/save/mod-set/edition cohort.
+Replacement, failed-entry rollback, late validation rejection, asset flushes
+and teardown retire owned allocations. Reentrant cache reads revalidate the
+cohort before publication. Preparation failures release partial allocations
+and allow a later retry. There is a bounded texture-memory budget; exhausting
+it reports an unavailable resource instead of returning a partial sheet.
+
+Validation uses synthetic, asymmetric pixel fixtures for all five GBA editions,
+actual SDK owner rollback/teardown and real Metal/OpenGL image/frame/crop
+readbacks. These are resource tests, not original effect-task parity, cartridge
+artwork extraction parity, unchanged package initialization, gameplay, full
+renderer or complete mod-coexistence acceptance.
diff --git a/docs/native-field-move-presentation.md b/docs/native-field-move-presentation.md
new file mode 100644
index 000000000..a130ad565
--- /dev/null
+++ b/docs/native-field-move-presentation.md
@@ -0,0 +1,29 @@
+# Native field-move presentation ownership
+
+`src.core.game3.field_move_show_mon` uses the existing `Gen3FieldMove`
+StateStack admission. `start` and the native entry seam use that admission's
+Pokemon, optional pose and guarded continuation. `step` consumes only the
+current native update scope. Native draw wrappers consume one draw body;
+explicit source draws render the current native picture in the caller's
+coordinates. The renderer's frame serial prevents the normal UI pass from
+painting the same externally rendered cut-in again. Drawing never advances
+the streak or player-pose clock.
+
+The cut-in retains its own 240x160 GBA surface. A mod's dialogue-box theme
+cannot shrink it to the Game Boy surface or enlarge it to a DS surface.
+
+The native admission owns its front image and resolves actual generated-asset
+overrides. Completion, explicit reset, failed entry and owner retirement
+release it and restore the prior player pose. Covered admissions cannot pop a
+foreign screen or advance through direct source ticks. Cancelling a source
+owner under another screen retires its callback immediately and leaves that
+cover in place. Continuations preserve nil returns/errors and cannot execute
+twice or before native completion. Retired callbacks release captured data,
+and cohort references are weak so retained wrappers cannot keep a retired
+save alive. Observer release leaves engine-owned continuations intact.
+
+The optional cartridge profile, authenticated strip import and supported cry
+options are documented in [native-field-move-runtime.md](native-field-move-runtime.md).
+The ordinary native style is retained without an active observer. Full
+portrait/form/personality handling, complete field task scheduling and the
+unchanged complete renderer/gameplay remain open acceptance work.
diff --git a/docs/native-field-move-runtime.md b/docs/native-field-move-runtime.md
new file mode 100644
index 000000000..8c9a39d19
--- /dev/null
+++ b/docs/native-field-move-runtime.md
@@ -0,0 +1,23 @@
+# Imported field-move presentation on the native state
+
+This extends the native `Gen3FieldMove` admission with a cartridge presentation program. The normal native style remains the default when there is no active compatible observer. Existing native sprite hooks and asset overrides still resolve the front picture. No second world, player or task clock is created.
+
+The compatible field-move namespace exposes `start`, `isActive`, `step`, `draw`, `reset` and `invalidate`. Entry configures an actual stack state. Only that state's native update advances the presentation. Wrapped base calls share a once-only phase; an arbitrary `step()` cannot drive another frame. Read-only `_fx` observations are detached from the actual state. Rendering an effect through the source world pass suppresses the same admission's native UI draw within the renderer's frame serial.
+
+The optional program uses separate indoor and outdoor 256×80 strips, a 24-tick optional pose, cartridge-style window reveal/hide, picture motion/hold and one cry. `noDuck` and per-call cry volume feed the existing audio engine; the next ordinary cry restores its normal volume. An unrelated active cry retains ownership of its music attenuation.
+
+## Imported data and ownership
+
+The existing field-effects import stage authenticates the actual complete ROM SHA-1 before extracting strips. Bounds and declared tile counts are checked. The compact cache contains indices and palette words; RGBA is expanded only on admission. An older manifest can use the audited exact-digest profile, while discovery writes explicit optional `fieldMoveStreaks` metadata. Unknown revisions decline this artifact. The GBA-only cache revision forces an import refresh without migrating player data.
+
+Profiles cover FireRed, LeafGreen, Emerald, Ruby and Sapphire. Source locations and presentation facts were checked against the corresponding primary cartridge projects: [FireRed](https://github.com/pret/pokefirered/blob/master/src/field_effect.c), [Emerald](https://github.com/pret/pokeemerald/blob/master/src/field_effect.c), [Ruby/Sapphire](https://github.com/pret/pokeruby/blob/master/src/field_effect.c). No cartridge payloads are bundled.
+
+A mounted field-art provider can supply the same raw strips directly. Missing or malformed declared provider data fails admission; it cannot silently select another provider. Front images, strips, image data and quads are privately tracked per admission, including failed preparation and reload. Changing a public sprite field never transfers ownership of a borrowed native image. Pose ownership uses an admission token, so an old admission cannot restore over a newer pose.
+
+Callbacks and states belong to the current game/data/save/mod-set/edition/stack/world. A covered state cannot complete another screen. Source-owner cancellation removes only its own admission, including behind another screen, and discards captured continuations. Observer teardown preserves native continuations. Duplicate, early, reentrant and failed continuations retain their guards.
+
+## Validation and remaining scope
+
+ROM-free checks exercise admission, wrappers, cohort changes, resource ownership, actual SDK entry/late-validation/teardown, and the existing music/cry engines. Independent private oracles use immutable original blobs for per-tick state comparison and separately decode both strips from all five ROMs. The GPU host compares the original drawing routine against the native program on Metal/OpenGL, including repeated and externally composed draws. Front artwork in that host is an asymmetric synthetic fixture; it does **not** prove every cartridge portrait, form or personality variant.
+
+Full special-form/personality picture handling, native field-effect tasks and actor/overlay scheduling, party-slot selection, the unchanged complete renderer and real full-package gameplay are still separate acceptance work. A loadable module or matching cut-in is not full mod compatibility.
diff --git a/docs/native-field-runtime.md b/docs/native-field-runtime.md
new file mode 100644
index 000000000..a2532f3d3
--- /dev/null
+++ b/docs/native-field-runtime.md
@@ -0,0 +1,91 @@
+# Native field runtime adapters
+
+Source fades observe the actual native script, warp, white-flash and battle
+return states. Field fade requests share the extracted native FadeOverlay,
+its fixed-step clock and whole-window veil. Sixteen palette steps and owned
+holds do not replace native script timing or its abandoned-fade watchdog.
+Unload cancels only the requesting owner's flow and continuation.
+
+Source warp requests enter the existing native admission controller. Map
+identities, bounds, input ownership, arrival bookkeeping and callback lifetime
+remain native. The native transition retains its actual arrival kind while
+active. Revoking a source continuation cannot rewind an admitted native warp.
+
+Weather audio follows the existing native weather and frame clock, without
+another weather simulation or gameplay RNG. `field.weather.sound` can claim a
+weather playback request. Native weather uses a separate cached voice from
+scripted/mod effects of the same sequence; removing the wrapper resumes native
+weather on the next field tick. Missing imported sequences have no substitute.
+
+`dataset.cache()` reads generated artifacts through the native cache filesystem
+and current cartridge prefix. Readers retire on import, edition, root or session
+replacement. This is read-only access to existing native files, not a second
+importer, hydration path, alternate extraction layout or worker format.
+
+The source START adapter opens/closes the real GBA menu and enters its native
+input/draw phases once. Flow cancellation preserves unrelated overlays. Custom
+row callbacks and content-template presentation need additional integration.
+
+Focused checks across FireRed, LeafGreen, Emerald, Ruby and Sapphire pass:
+385 fade, 180 warp, 105 weather, 115 artifact-reader and 90 START-menu checks.
+An API-2 loader/native-world fixture verifies source warps without requiring
+another public API version. The original native warp suite also passes 206 checks.
+
+On the earlier fork baseline, 485/485 engine suites, all three SDK suites and
+B30 pass. The final-main regression is tracked separately. Metal and OpenGL each
+pass 1,364 fade checks with 320 pixel comparisons/readbacks; RGBA8 comparisons
+allow 1.51 channel quanta for factor quantization and final colour rounding.
+
+Unchanged 1.0.9 initializes through the actual Metal/LOVE loader in all five
+editions on synthetic imported data. This does not prove gameplay: the battle
+card still reports a missing palette module, and native field/gameplay, complete
+battle presentation and remaining UI contracts require further qualification.
+
+QA uses disposable profiles, preserved frozen inputs and an 8 GiB reserve.
+Player profiles, private runtime files and game assets are not included.
+
+## Public-host composition
+
+This API-2 offer builds on #328/#327 and their declared native map, player,
+session, modal-stack and rendering prerequisites. The existing native warp
+admission helper is reused internally; it does not advertise another public
+API version. The composed API-2 candidate passes all five focused suites,
+916 companion, 1,466 terrain, 486 collision and nine lifecycle checks plus
+all three SDK suites. Engine results are 100/111 versus 95/106 in the frozen
+reference, with the identical eleven inherited failed suites.
+
+The unchanged-package loading result above belongs to the fork; it is not a
+claim that this standalone public branch accepts or fully runs that package.
+
+Additional source observations reuse native ownership: checked cartridge map
+aliases share one physical definition, warp forecasts avoid committing a warp,
+weather follows the native importer enum and cycle, and previews observe actual
+native admission. Door observations currently cover the native Petalburg slide,
+not general source-started door tasks. Healing snapshots and native drawing
+share the same borrowed ROM-art selection and offsets.
+
+Source audio borrows a distinct cached playback and retires with that playback,
+owner or session. It cannot change another owner's gain or stop its voice.
+Unloaded native UI/field classes cannot admit ordinary mod screens through nil
+metatables. Resident animation observations build on the separate atlas offer;
+they do not implement named RGBA animation banks.
+
+Detached `Renderer:frameRects()` metrics share the native compositor's viewport
+calculation. Source field producers can request the real drawable resolution
+and pass an existing canvas directly to the scaling compositor. Private native
+scratch is reused and is not exposed to callers. Shader conversion is handled
+by the separate orientation offer #193. Complete mod, battle, door and UI
+presentation acceptance remains open.
+
+
+The indexed-palette adapter now reuses a factored native shader factory with separate native-background and source banks. Native backdrops retain their continuous texture alpha and replace sixteen individual palette uploads with one array upload. Source RGB555 arithmetic, blending, affine/gray resolution and a real cutout shader share this implementation; owner teardown cannot release the native bank. This does not implement animation-pack adoption, another animation VM, or the complete battle presentation protocol.
+
+The fork and composed public baseline each pass 7,771 palette checks and 382 native animation checks; battle admission passes 382 on the fork and 397 on the older public baseline. Metal and OpenGL each pass 1,168 RGBA8 GPU comparisons. The deliberately shared-bank Metal counterexample fails at the intended nested native/source palette comparison. A corrected raw-output measurement uses premultiplied replacement blending; the earlier alpha-multiplying measurement failure is preserved. A new unchanged FireRed run reaches the field and START → ASCENDANT with no loader errors; the battle card now reports the next missing contract, `Ui.takeCommand`, and remains unavailable. None of these checks qualifies full unchanged-mod gameplay.
+
+
+Native source move commands are borrowed at the existing selection commit boundary and taken once. Changed slots/targets re-enter native selection and refusal handling; actual source PP transactions are flushed before validation. Covered, replaced or retired admissions cannot commit stale choices. Ordinary/native-only paths and other native controller-owned action classes keep their owners. Live cursor writes update validated native indices instead of shadowing them, and UI busy/dialog observations read the actual native queue. This command interception currently covers move choices; the remaining command classes and complete presentation protocol are not claimed.
+
+Both baselines pass 390 command/cursor/observation checks, including doubles, changed targets, cancellation, PP refusal, exceptions, native callback ownership and multiple/nil native return values. The fork retains 382 admission and 382 animation checks; the public composition retains 397 admission and 382 animation checks. Its refreshed full engine result is 127/138 with exactly the same eleven inherited failed suites as the preserved reference; Modkit 3/3 passes. The older public input bodies were factored into shared selectors without changing their normalized source bodies or backporting newer battle rules. Unchanged FireRed high/ultra field runs still load with no loader errors; the battle renderer now reaches its next missing contract, `src.core.game3.display`. The original high-quality FXAA card is active and available on the real Metal run; initial pre-preset health snapshots were stale. Ultra supersampling remains a separate optional setting and is being qualified independently.
+
+
+Real unchanged FireRed quality observations now cover Metal and OpenGL: High runs its active FXAA card at 1024x768, while Ultra with the separate supersampling switch enabled renders and returns a 1536x1152 world for that window. The native compositor scales it once and retains upright native UI. A separate real Retina Metal run reports a 2048x1536 drawable for 1024x768 logical units and an upright 3072x2304 Ultra world. These are starting-room render/capture observations, not full gameplay or performance benchmarks. The original mod deliberately bounds field resolution when its optional supersampling setting is off; its own quality policy is preserved.
diff --git a/docs/native-help-presentation.md b/docs/native-help-presentation.md
new file mode 100644
index 000000000..db1a8cc18
--- /dev/null
+++ b/docs/native-help-presentation.md
@@ -0,0 +1,38 @@
+# Native cartridge Help presentation
+
+FR/LG imports now publish verified question/answer references, context lists,
+topic order/visibility, original nine-tile decorations and keypad artwork in
+`constants.gen3Help`. The structured text catalog remains the only text
+decoder and translation authority. Other editions receive no invented Help
+resource. Both the resource marker and structured-text revision invalidate
+stale GBA imports; Gen2 markers keep their existing behavior.
+
+`src.ui.Gen3HelpMenu` is a real native stack modal. Its list controller is
+the existing `ListMenu`; answers retain original extended glyph cells,
+keypad icons, placeholders and explicit text positions. Closing, owner
+shutdown and dataset/save replacement retire only the owned modal and its
+images, including under an unrelated covering screen. Images are created
+once per open modal and released on exit or failed construction.
+
+`src.ui.game3.help_system` observes that modal and lends its draw body to a
+zero-argument source wrapper during the actual native draw only. Repeated
+base calls share one paint. Outside-phase queries cannot advance input or
+paint another frame. It does not load a second runtime or retain ROM readers.
+
+Progress filtering reads the real native flag keys, current item registry and
+unique caught Kanto dex IDs. HM acquisition flags, map possession and the
+post-Brock basic-term order do not mutate any save state.
+
+This is a bounded presentation prerequisite, not complete retail Help:
+callers currently supply an explicit native context (1..34). Automatic L/R
+activation, first-use tutorial state,
+audio ducking and every native context transition are still unqualified.
+No global button interception or gameplay flag writes are introduced before
+those owners are integrated. Full map battles, terrariums, OS-window output
+and interactive frame rate require separate visual/runtime acceptance.
+
+Metadata and numeric interface facts were checked against the pinned primary
+pret/pokefirered source at `ce6406d8c2eaf46d543c8a2606de0c3cb1951982`
+(`help_system.c`, `help_system_util.c`, `text.c`, `charmap.txt`) and actual
+verified FR/LG cartridges. No cartridge prose/pixels or private runtime are
+published. Existing address-profile provenance and third-party rights remain.
diff --git a/docs/native-modal-observations.md b/docs/native-modal-observations.md
new file mode 100644
index 000000000..bf1900d39
--- /dev/null
+++ b/docs/native-modal-observations.md
@@ -0,0 +1,21 @@
+# Native battle modal observations
+
+The source `bag_menu`, `pokedex`, `party_menu` and `stat_growth` queries report
+actual native controllers in the current stack, including covered controllers.
+They do not allocate another screen, advance input or close unrelated menus.
+The queries distinguish an unopened constructed controller from an open one.
+
+Native bag, ordinary/FRLG dex, party and stat-window constructors stamp their
+actual edition/data/save/stack/mod-loader cohort. A class name alone cannot
+admit an unbound screen. Replacement of any owner field rejects the old
+observation, including replacement before the first query. Missing nested
+classes must never fall back to matching the enclosing battle class.
+
+The observation registry has weak state keys and weak owner slots. It must
+not retain a removed state/world through the value-to-game-to-stack cycle on
+LuaJIT. Non-GBA queries remain absent and the native Gen2 stat constructor
+keeps its existing state and callbacks.
+
+This unit supplies real visibility queries needed by unchanged map/terrarium
+viewport selection. Full bag/dex source commands, wide battle surfaces,
+complete scene visuals and frame rate still need their own acceptance.
diff --git a/docs/native-ui-pass.md b/docs/native-ui-pass.md
new file mode 100644
index 000000000..f8b025a3e
--- /dev/null
+++ b/docs/native-ui-pass.md
@@ -0,0 +1,32 @@
+# Native GBA UI drawing pass
+
+`src.ui.game3.ui_pass.drawUi()` borrows the current native modal draw phase.
+The function takes no arguments. Calling it between native phases does not
+paint a second frame. Repeated base calls inside a wrapper share one native
+result, including failures and trailing nils.
+
+The native Game painter retains its state order, visibility, surface fitting
+and centering. World owners, admitted battles and states explicitly marked
+`isOverworld` or `isBattleState` retain their own render passes. Contiguous
+ordinary overlay groups use the UI boundary; interleaved scene owners split
+the groups without reordering them. Existing native UI controllers continue
+to own input and logic. Unpatched modules keep the direct native painter.
+
+A wrapper may redirect its borrowed UI group to an owned canvas. Graphics
+scope restoration covers canvas, shader, transforms, blend/color, stack and
+physical scissor, including mixed pixel densities and callback failures.
+Replacing the Game data, save, loader, stack or any stack member invalidates
+the already resolved UI phase. Native drawers run under their native owner;
+the source wrapper keeps its own callback attribution.
+
+This is a drawing contract. It neither allocates HUD targets nor advertises
+the complete battle-presentation protocol. Help controllers, full unchanged
+mod gameplay, map/terrarium visual acceptance and interactive frame rates
+require their own evidence.
+
+Validation entry points are `tests/engine/native_ui_pass.lua` and
+`tools/native-ui-pass-gpu`. The GPU fixture captures the actual compositor
+through the existing final-output owner, compares default/wrapped frames,
+checks independent UI rectangles at DPI 1/2, rejects a displaced positive
+control and checks physical clipping after a source error. It does not
+establish OS-window or gameplay acceptance.
diff --git a/docs/qa/native-foundation/action-observations.md b/docs/qa/native-foundation/action-observations.md
new file mode 100644
index 000000000..f3b8f0c2d
--- /dev/null
+++ b/docs/qa/native-foundation/action-observations.md
@@ -0,0 +1,62 @@
+# Read-only native action order
+
+The native turn planner already establishes order and queues its action bodies.
+Observations now bind that actual order to those actual function rows. They do
+not create an executable action queue, resolve a move, change an action or add
+a frame. Native queue dispatch marks the executing row and retires it on failure;
+the existing native end-of-turn retires the observation ledger.
+
+The source battle facade exposes a detached `_actions` array with stable,
+read-only action records and `_actionI` for its executing/physical head row
+(one-based, zero when no mapped row owns that position). The move key and side
+come from the actual queued native entry. The records describe selected commands,
+not a prediction that the move will pass status, targeting or damage checks.
+
+Edition, native dataset/save/loader/stack/queue and source admission changes retire
+observations. Restoring a prior pointer does not revive the old lease. Unqualified
+native act wrappers or replaced pending callbacks retain their behavior while
+losing the verified observation; another function is never labelled as the
+original native command. The observations retain no native controller through an
+external stale proxy. Gen2 keeps its native dispatch and constructs no GBA ledger.
+
+## Qualification and limits
+
+Focused qualification passes782 checks, including real native move-used producer
+observation, typed pairs/next iteration, detached arrays, stable identities, read-only records, cohort/source
+retirement, callback replacement, unknown native wrappers and native failure.
+Complete deterministic turns compare HP, PP, every RNG invocation and frame/phase
+sequences with observation registration off/on across all five GBA editions.
+The first comparison retained a mismatch because wild construction selected
+random enemy IVs/personality before binding battle RNG. The owned fixture now
+prepares identical mon records and shown HP for both runs; native combat is not
+simulated. No player profile or private mod bytes are changed.
+
+This is an observation prerequisite. `_phase`, `Ui.busy`, native execution and
+animation sequence admission are unchanged. No resolver or sequence stub is
+installed, and Action Card readiness stays gated. A typed native HP/RNG
+continuation and real resolver/sequence ownership remain required before source
+contact suspension can be admitted. Whole-source, predecessor and unchanged-mod
+qualification follow separately.
+
+
+Frozen source `f0627a735e` (before the additional nil/false loader hardening)
+passes all126 selected CPU groups. Exact predecessor comparison `8c498caaf6`
+executes the identical owned turn probe against that tree and predecessor
+`ddd4035807` without overlaying either native controller. HP, PP, RNG invocations
+and every frame/phase record match across all five editions. Latest source and
+older-public integration qualification are recorded separately.
+
+Final current-main code `5eca0614` (main `c4bd3b36`), frozen `f11ba60038`,
+passes133 selected CPU groups including782 focused action checks. Exact
+predecessor `f9fc881eb2` retains identical full-turn HP/PP/RNG/frame traces
+across all five GBA editions. Older-public composition `c9eed01598` passes55
+groups, retaining its older native controller bodies. Raw older-public execution
+still requires the declared shared typed-iteration prerequisite; this is not
+standalone upstream CI acceptance. The scoped CI workflow belongs to the complete
+native fork, not the incomplete older-public prerequisite chain.
+
+Unchanged package `bddb5181`, Sapphire run `567f801dd0`, completes native
+new-game/field entry, paper battle, real RAGE selection (PP20 to19), player
+HP63 to46 and enemy HP57 to49, then native/source cleanup without loader errors.
+The after-move capture is upright. This owned prepared fresh-profile functional
+run is not continuous story, visible-desktop or FPS acceptance.
diff --git a/docs/qa/native-foundation/action-sequences.md b/docs/qa/native-foundation/action-sequences.md
new file mode 100644
index 000000000..29eb6a3a9
--- /dev/null
+++ b/docs/qa/native-foundation/action-sequences.md
@@ -0,0 +1,44 @@
+# Native action presentation rows
+
+`battle.anim_seq.begin` decorates the actual presentation rows created by one
+verified native action callback. It receives detached event arrays with immutable
+identities. The native used-message and move-animation constructors provide their
+provenance; message language and content are never used to identify an event.
+Other rows remain opaque native events. The same native queue executes HP, items,
+experience, UI and gameplay callbacks.
+
+A decorator may omit only this admission's qualified move-animation and
+move-used message events. Retained events keep their native order. Foreign,
+duplicate, reordered or missing mandatory events are rejected. Native row/cohort
+changes, covered screens and retired phases invalidate permission. The first
+base request owns the once-only choice; filtering commits only when the whole
+decorator returns successfully. Errors cannot replay the native action or partly
+commit presentation filtering. A row carrying another native protocol keeps its
+mandatory identity. Returned event views retain no controller after retirement.
+
+Only native action-plan rows open this production boundary. Default and no-op
+behavior use the original native queue and clock. No additional interpreter,
+executable event stream or combat calculation is created. Used-message IDs name
+the actual native `_ItemUseText001` producer. Source requires no translated text
+comparison.
+
+This supplies the begin/filter subset, not the complete animation-driver API.
+Resolver, pre-dispatch action phase and typed HP/RNG continuation remain open;
+Action Card stays gated. Other sequence methods and arbitrary detached event
+playback are not advertised. No unchanged-mod contact-cue or performance
+acceptance is derived from synthetic native tests.
+
+The owned native fixture compares complete HP/PP/every-RNG/frame traces for all
+five GBA editions with the module absent, default, and no-op decorated. Targeted
+cases exercise actual producers, protected rows, phase/cohort loss, callback
+attribution, malformed/foreign requests and errors before/after the base call.
+Player data and private mod sources are not changed.
+
+Native code `89cc72df`, frozen `d6e85beb74`, passes all134 selected CPU
+groups including168 targeted checks. The later portable test-entry adaptation
+changes no production bytes. Older-public code `821e486e`, exact composition
+`d4055d8093`, passes all56 groups with the older native controller retained;
+only owned constructor provenance is inserted. It has no independent GPU or
+standalone dependency-chain acceptance. Previous unchanged-package Sapphire
+`567f801dd0` and FireRed `a9906a0866` qualify the predecessor action-observation
+packet, not this new sequence filter. Fork CI is pending separately.
diff --git a/docs/qa/native-foundation/animation-update-hooks.md b/docs/qa/native-foundation/animation-update-hooks.md
new file mode 100644
index 000000000..77f20d78f
--- /dev/null
+++ b/docs/qa/native-foundation/animation-update-hooks.md
@@ -0,0 +1,15 @@
+# Native animation update decorations
+
+The unchanged mod's settled paper/terrarium captures contain correct native HUD pixels but only folded fragments appear in the completed scene. Its existing unfolding/return effects decorate `Anim.update`; the native path updated internal presentation work directly, so that public decoration never received a native tick. This is a missing native lifecycle seam, not missing HUD visibility. Actual probes `b6a1ff860b`/`3cf74d32ad` confirm correct owned HUD ink, live native visibility, the active end-frame wrapper and expected target/quad state. ROM-free Metal control `7e3ec7cc5d` rejects a proposed logical-quad/DPI cause in12 cases; no DPI workaround is added.
+
+Native battle phases now notify a decorated animation update at phase end. The callback receives the native delta. Its public base borrows completed once-only presentation work and cannot run another native frame or queue. If source code already called the public base explicitly in that phase, the native owner skips a duplicate notification. Covered/retired admissions cannot notify; errors poison the native phase. Native return tuples are preserved independently of decorator return values. Unwrapped callers and other generations retain the existing native path.
+
+Frozen source `100abace91` passes syntax and23 suites (24 groups), including755 decoration/owner/delta/failure/coverage checks. The fixture compares complete native command/HP/timer traces for undecorated, automatically notified and explicitly called source cases across five GBA editions; existing animation/VM/task/intro/capture/session/command, UI, Gen2 window/queue/scene/live-view/summary, checkpoint and suspend regressions pass. The first fixture used a nonexistent convenience wait method; the second omitted explicit caller-owner metadata and expected a native frame before an intentional early error. Failed attempts remain retained; native behavior was not weakened to satisfy them.
+
+Exact older public composition `b2decee4a7` passes22 groups, including the755 decoration checks, without replacing its older native controllers. Actual unchanged-mod run `ab2651195e-firered` completes five settled paper/native/terrarium switches: both3D views are upright and now contain the complete unfolding HUD and menu. A real native EMBER action consumes AP25→24 once, changes player HP63→48/enemy HP60→30, and retires the source presentation to idle with starts1/finishes1.
+
+The newer fork main `65a70949` is merged into the integration branch at `7162f7dd`. Frozen combined source `aa4e50f0a4` passes29 groups, including the five additional Gen2 party-item/AP/connection-target/battle-PACK/live-party regressions. Actual refreshed-source run `3166061216-firered` also completes five settled upright views with visible HUD/menu, EMBER (AP25→24 once; player HP63→44/enemy HP61→37) and cleanup to idle with starts1/finishes1.
+
+That refreshed run samples240 wall-frame intervals per view without HUD pixel scans or draw/end-frame diagnostic wrappers. Paper means are16.665/16.663ms (about60FPS); terrarium mean16.808ms (59.49FPS), p95 18.300ms/max28.925ms. These are short starting-room measurements with native vsync1. Optional callback-cost timing was not enabled in this first benchmark; its zero-filled update/draw aggregates are unavailable, not measured zero. Future samples leave absent timing buckets absent. Broader gameplay, other-edition visuals, OS-window and sustained field-voxel60FPS remain unqualified. QA uses isolated profiles and20GiB free reserve; player saves remain untouched.
+
+Contributions by Roxas2712. Existing native code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
diff --git a/docs/qa/native-foundation/battle-ball-art.md b/docs/qa/native-foundation/battle-ball-art.md
new file mode 100644
index 000000000..83776f141
--- /dev/null
+++ b/docs/qa/native-foundation/battle-ball-art.md
@@ -0,0 +1,43 @@
+# Native battle ball artwork
+
+`battle.ui.ballQuad(ballId, frame)` reads the existing imported 16×16 ball
+atlas. IDs and frames are zero-based. An admitted native GBA battle is
+required; unknown cells return no picture. The query cannot start a ball,
+advance its timeline, consume RNG or mutate the native battle.
+
+One source-owned image and at most 36 cached quads cover twelve styles and
+three frames. The native asset cache retains its own image: releasing source
+art cannot release native painter resources. Battle admission, dataset/save/
+loader/edition replacement, asset invalidation and owner retirement determine
+resource lifetime. Covered battles can still observe their own artwork.
+
+The current composed fork had not integrated the native ball metadata already
+offered with edition PRs #186/#187. Its Ruby/Sapphire manifests still used the
+Emerald addresses. The existing verified native metadata now selects the
+original sheet/palette/shared-open/particle tables, nine send-out opcode sites
+and RS sound identities. The native extractor and timeline remain responsible
+for decoding and animation. `rs-ball-art-v1` invalidates only the affected
+edition caches; it does not migrate saves. The separate public edition offers
+already contain these facts; the UI-art query does not replace those offers.
+
+Address facts were cross-checked against the original cartridge bytes and
+[pret/pokeruby](https://github.com/pret/pokeruby/tree/5784633ce4ef7ade1a7f2d2d0c288e3d5e6cdd7f),
+`src/pokeball.c` and `src/battle_anim_special.c`. No alternate extractor or
+foreign runtime body is included. The existing opcode checks remain strict;
+RS retains its 39/30-frame player/opponent send-outs and caught jingle 371.
+
+`tests/engine/native_battle_ball_art.lua` covers all cells, malformed requests,
+sharing and retirement with actual native admissions in all five GBA editions.
+`tools/native-ball-art` uses the actual importer and SHA1-verified local ROMs
+with graphics disabled; it checks every decoded cell and records RGBA hashes.
+Use a fresh owned QA identity and the project's managed storage launcher.
+
+This is an artwork/query contract. It does not advertise presentation API v2
+or establish map-battle/terrarium visuals, physical-window output or FPS.
+The unchanged mod-owned drawing bridge still requires further native sprite,
+particle and menu contracts. Keep those failures visible.
+
+The focused public UI offer depends on the separately offered native edition
+profiles for Ruby/Sapphire (#186/#187). Their profile/cache changes are not
+duplicated in this UI branch. The all-edition ROM fixture requires those
+profiles in the composed source.
diff --git a/docs/qa/native-foundation/battle-menu-continuity.md b/docs/qa/native-foundation/battle-menu-continuity.md
new file mode 100644
index 000000000..7c5ac2b40
--- /dev/null
+++ b/docs/qa/native-foundation/battle-menu-continuity.md
@@ -0,0 +1,46 @@
+# Native battle menu continuity and trainer party rows
+
+The source-facing swap observation is a detached `{cursor = index-1}` record,
+matching the zero-based drawing protocol. `_swapIndex` exposes the native
+one-based number; the native `moveSwapIndex`, input handling, move/PP records
+and command owner are unchanged. Mutating a returned record cannot change the
+native selection.
+
+Public party-bar painting and native HUDs share one existing native row
+renderer: icon packing, opposite-edge geometry, arrival timing and first-paint
+stamp. Public decorators borrow each native row once; held draws do not start
+a clock, native failures cannot be swallowed/replayed, and callbacks restore
+graphics state. Positions, opacity, hidden icons and per-icon offsets are
+presentation only. Bars and icon sheets may have different texel densities
+while keeping their imported logical dimensions. Unsupported extended sheets
+are diagnosed rather than advertised.
+
+Fork source `1830bd24b6`, including main `0f49e5c2` at merge `77a13eeb`, passes
+47 CPU groups including491 continuity/density checks. Eight additional groups
+on the same frozen bytes pass3014 checks for native Gen2 models, healthboxes,
+modal admission, stat growth and level-up drawing. Older-public composition
+`d50e49cc03` passes30 CPU groups with the same491 new checks. Its native
+controller body receives checked narrow changes, not the newer fork body.
+
+GPU runs `fb6791647c` (fork) and `d9100003e8` (public) each pass4322 checks
+across1440 constructed frames on Metal and on OpenGL: both rows, six arrival
+ages, five editions, widths240/320, DPI1/2, independently varied image density,
+custom positions/opacity/slots/offsets and unchanged native clocks.
+
+Actual unchanged Origami1.0.9 run `74566232b9-firered` uses earlier source
+`95a8db3301`: real trainer constructor, paper/native/terrarium/native/paper
+switches, native move-swap/restore/cancel input, unchanged HP/PP and cleanup.
+A separate current-main run `c98bf7d9bc-firered` uses `1830bd24b6` and repeats
+the trainer/menu path in one scene with raw HUD/font diagnostics. These are
+bounded FireRed checks, not five-edition artwork/full-game/window/FPS acceptance.
+An earlier observer failure before the first scene was an owned diagnostic bug;
+its failed evidence is preserved and the observer was repaired.
+
+The apparent mirrored menu text was tested against the imported bitmap:
+normal orientation matches with0.162 mean RGB error, while mirrored variants
+produce21.97–38.40. Primitive asymmetric font/HD/small-face and canvas-slice
+probes also pass. Low contrast and the selected wide/flat menu fit remain
+presentation concerns; no global flip or private-mod change was made.
+
+Managed QA keeps20GiB free and uses separate identities. Player saves and
+private reference code are untouched.
diff --git a/docs/qa/native-foundation/battle-menu-frames.md b/docs/qa/native-foundation/battle-menu-frames.md
new file mode 100644
index 000000000..a784b162a
--- /dev/null
+++ b/docs/qa/native-foundation/battle-menu-frames.md
@@ -0,0 +1,15 @@
+# Native battle menu frames
+
+Actual unchanged-package run `a5e30e7856-firered` stops in UI drawing at missing `Ui.drawMenuFrames`. The binding now borrows the existing native generic panel/window geometry and the actual native RS panel/chrome owner. Generic imported panels already contain their selected user frame; a one-use receipt prevents painting another frame over that panel. RS retains its separate native user-frame layer and selected style. Wide and Safari paths retain their native fallback. No private renderer body is substituted.
+
+Receipts are bound to the admitted native view, native frame, compositor serial or active graphics scope, mode and actual render target. Canvas handles remain opaque even when represented by tables; only MRT binding descriptions compare structurally. Cohort/owner retirement invalidates receipts. Frame drawing is graphics-fenced and never advances battle queues, RNG, HP or native clocks.
+
+This branch includes main `6d2bf2f4` through merge `81e89d2f`. Both native text-reader ABIs remain supported: boolean structured mode and options-table mode, with RS-only NAME_END allowed solely by its explicit native option. Native Wally healthbox behavior is preserved; its shared observation returns a boolean even while hidden.
+
+Frozen candidate `8e6c8853cd` passes syntax and all24 targeted suites (25 groups):263 frame checks,639 text/import IR checks,571 stage checks, selection/particle/picture/entry/capture/command/session/UI and RS import/map/boot/panel/cache contracts, plus current Gen2 window/queue/scene/live-view/summary regressions. The initial fixture omitted native font passthrough and RS panel metadata; the next attempt exposed a real nil-versus-false visibility regression. Both failed runs remain retained. Source/test hashes identify the final passing tree.
+
+The actual unchanged-mod map/native/terrarium reprobe is running. No accepted scene frame, physical-window, complete tutorial presentation or60FPS result is claimed by these CPU tests. Tests use isolated QA profiles and20GiB free reserve; player saves remain untouched.
+
+Contributions by Roxas2712. Existing native code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
+
+Public composition: this older public baseline lacks the native RS panel class and Wally controller. The offer adds the shared renderer/query helper and focused scoped UI hooks only, retaining the older native bodies. Its fixture checks optional RS owner delegation with the actual chrome contract shape; it does not qualify the absent native RS controller or fork-only merge fixes. Separate RS offers remain prerequisites for that native default path. Public composition qualification is pending.
diff --git a/docs/qa/native-foundation/battle-move-labels.md b/docs/qa/native-foundation/battle-move-labels.md
new file mode 100644
index 000000000..ec4baf7fd
--- /dev/null
+++ b/docs/qa/native-foundation/battle-move-labels.md
@@ -0,0 +1,9 @@
+# Native battle move labels
+
+The unchanged move-menu painter calls `Moves.displayName` for each actual cartridge move slot. This binding now reuses the existing native Pokemon move-name observation and its owned dataset context. It accepts native/source move records and numeric strings, preserves empty-slot markers, reads current native labels and returns explicit absence for unknown imported moves. No second name registry is built.
+
+Frozen source `e857aa1d18` passes syntax and23 suites (24 groups), including261 native Pokemon/label checks and existing UI/cursor/menu/picture/stage/selection/particle/battle, Gen2, checkpoint and suspend regressions. A stricter actual unchanged-mod run now holds each scene for90 frames, requires reveal readiness, saves owned HUD ink separately, and exercises the real move menu plus a native damaging action/AP commit. Results are pending; no clean visual or60FPS acceptance is claimed.
+
+The preceding actual `62630d5234-firered` completes five settled view switches with identical native HP/AP. Its paper and terrarium images are upright, but combat HUD/menu is absent despite431525/276176 nontransparent pixels in the owned HUD canvas. This is a confirmed composition problem, not missing native UI state: both healthbox observations and the bottom-UI/status visibility queries are true. Current short FPS badges are not a sustained performance qualification.
+
+QA enforces20GiB free reserve and uses isolated profiles, never player saves. Contributions by Roxas2712. Existing native code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
diff --git a/docs/qa/native-foundation/battle-palette-manifests.md b/docs/qa/native-foundation/battle-palette-manifests.md
new file mode 100644
index 000000000..672d05149
--- /dev/null
+++ b/docs/qa/native-foundation/battle-palette-manifests.md
@@ -0,0 +1,30 @@
+# Native window and PP palette manifests
+
+The chrome manifest exposes detached `textboxPal`, `windowTextPal` and
+`ppTextPal` arrays from the active native dataset. Full palette validation and
+RS edition tags prevent mixed or malformed metadata from reaching the font.
+Replacing/mutating imported palettes is visible immediately, while mutations of
+returned records cannot rewrite the native import.
+
+The existing validated textbox stage retains its already decoded menu-palette
+bytes. Emerald additionally reads the bounded sixteen-word `gPPTextPalette`
+raw table, independently of the compressed window palette. FR/LG never read
+Emerald's raw address. RS reuses its native panel/default-font records. The
+three affected cache markers advance to `gba-textbox-palette-v2`, superseding
+the earlier first-bank-only revision; other editions and save formats are
+unchanged. Original resource provenance remains attached.
+
+Fork source `f3a7211a9b` passes46 CPU groups. Public composition `f9ac06f6ce`
+passes29. Both include108 new manifest/ownership checks and expanded extraction
+checks covering raw PP bounds and palette separation. The unchanged-adapter
+CPU audit with complete synthetic imported records also passes command, move,
+target and message drawing for all five editions; synthetic records are not
+cartridge visual acceptance.
+
+Owned-output GPU runs `4b065a5ef2` (fork) and `2a44aeafe5` (public) each pass4044
+checks across576 constructed frames on Metal and on OpenGL. In addition to
+cursor density/effects and direct indexed text, the actual two-tone font is
+checked through both window and PP manifest palettes for all five editions,
+at DPI1/2. The owned fixture hash is recorded separately from the frozen CPU
+source. No full-game, real-artwork, OS-window or sustained-FPS claim is made.
+Managed QA retains20GiB free and does not access player profiles.
diff --git a/docs/qa/native-foundation/battle-selection.md b/docs/qa/native-foundation/battle-selection.md
new file mode 100644
index 000000000..e562a0a20
--- /dev/null
+++ b/docs/qa/native-foundation/battle-selection.md
@@ -0,0 +1,11 @@
+# Native selection presentation
+
+The confirmed unchanged-mod actor capture in `43b5eb8d59-firered` stops at missing `Ui.targetHidden`. Actor capture also reads selection displacement and a white palette coefficient. These queries now observe the admitted native battle rather than creating a UI clock.
+
+The native GBA presentation update records the actual choosing actor and target in a weakly scoped native owner. No new controller references enter logical checkpoint/journal fields; diagnostics are detached scalars. Existing native ticks own target changes, eight-frame blink periods and selection bounce origins. Queries never start or advance a controller. Native battler painting and native healthbox placement use the same controller as source UI consumers. Other engine generations do not enter this new update path. The existing native transform-white state supplies the bounded 0..16 coefficient; this does not implement a separate preview/menu state machine.
+
+Integer selection motion uses imported `gen3BattleAnimSine`, starts at128 for healthboxes and192 for mons, and uses signed fixed-point floor division. Ordinary selection delta is7; target healthbox delta is15. Missing imported sine values yield no verified displacement. No floating sine substitute is introduced. Reference: [pret/pokefirered battle_main.c](https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/src/battle_main.c) (`DoBounceEffect`, `SpriteCB_BounceEffect`, `SpriteCB_ShowAsMoveTarget`, `SpriteCB_BlinkVisible`) and [battle_controller_player.c](https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/src/battle_controller_player.c) (`HandleInputChooseAction`, `HandleInputChooseTarget`). This reference is not an all-edition cartridge parity claim.
+
+The new fixture covers five admitted GBA battles, query purity, signed integer motion, continuity through move selection, real additional battlers in doubles, target changes, eight-frame boundaries, side bindings, white coefficients and replacement/retirement. After the free reserve recovered, current-main frozen fork `83b3a9d0c3` passes all19 groups, including758 selection checks,288 particle checks and the current Gen2 window/queue/scene/live-view/summary plus suspend regressions. This qualifies the recorded combined tree, not an independent public composition. The initial particle fixture attempt `7970e2a8aa` omitted imported native coordinates and is retained; adding the missing fixture data leaves the real native fallback unchanged. The actual graphics reprobe is running. No actual graphics fix, clean map/terrarium frame, physical-window result or FPS acceptance is claimed yet. Player saves and original inputs are untouched.
+
+Contributions by Roxas2712. Applicable third-party notices are preserved. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
diff --git a/docs/qa/native-foundation/battle-stage.md b/docs/qa/native-foundation/battle-stage.md
new file mode 100644
index 000000000..8fb7511c1
--- /dev/null
+++ b/docs/qa/native-foundation/battle-stage.md
@@ -0,0 +1,13 @@
+# Native battle stage observations
+
+The battle presentation reads the stage belonging to the currently admitted native GBA battle. Entry slide/window, trainer portraits, healthbox visibility, party-row animation and the actual ball are observations of existing owners. Queries do not advance the battle, queue, RNG or ball clock. The native painter shares its healthbox/window/party-offset predicates with the observation surface.
+
+Capture and full-stage consumers share the same retained ball handle. Native ball frame, position, identity and visibility are projected once; replacing the ball, leaving combat, replacing the data/save cohort or retiring the source owner invalidates stale handles. Stage tables are read-only and support the existing source iteration contract. This addition does not advertise a complete presentation protocol or implement absent animation effects.
+
+Frozen fork candidate `401092536a` passed syntax and all14 targeted suites: 561 stage, 560 entry, 691 capture, 382 session, 382 animation, 390 command, 170 ball-presentation, 432 task, 1917 ball-art, 585 cutout, 210 UI, 60 Gen2 scene, 366 Gen2 live-view and326 Gen2 summary checks. Stage cases cover all five GBA admissions, live native ball movement, catch/stage identity, trainer identity/offsets, window boundaries, observation-only reads, covering and replaced/retired sessions. The first fixture attempt `2bbfe3af73` incorrectly loaded the catch observer after native request dispatch; its failure is retained.
+
+Actual unchanged private-mod battle entry `b3345e9e75-firered` got past the cutout query and stopped at its wrapper of missing `Anim.stage`. Follow-up `43b5eb8d59-firered` reaches the actual native command phase, then the unchanged actor capture falls back because `Ui.targetHidden` is absent. No scene frame passed acceptance. CPU checks do not establish clean map/terrarium frames, physical-window output, full gameplay or60 FPS. Every test uses an isolated QA profile and20 GiB free-space enforcement; player saves are never used.
+
+Contributions by Roxas2712. Existing native artwork, battle code and third-party rights retain their original provenance. See NOTICE.md and LICENSE-ROXAS2712.md for the specific Cedric / UNDERdecoded integration permission and credit requirements.
+
+Public composition `7d6cfc91f4` passes all14 groups against the previously qualified public stack, with exact stage/capture hooks and original older native controller bodies. The public capture projection is offered in #340; the stage is offered in #329. The public branch retains its existing status-HUD policy rather than copying a fork-only provider.
diff --git a/docs/qa/native-foundation/battle-text-colors.md b/docs/qa/native-foundation/battle-text-colors.md
new file mode 100644
index 000000000..bd4a33755
--- /dev/null
+++ b/docs/qa/native-foundation/battle-text-colors.md
@@ -0,0 +1,27 @@
+# Native indexed battle text colours
+
+The public chrome query returns a font colour record (`fg`, `shadow`, transparent
+`bg`) for each indexed foreground/shadow pair. Numeric foreground aliases and
+the second shadow return preserve existing tuple callers. No-argument queries
+retain the native message role. Records are detached and follow live palette,
+dataset and edition changes; invalid indices fail before drawing.
+
+RS uses its already imported, edition-bound palette. The validated FR/LG and
+Emerald textbox stage now retains all sixteen first-bank BGR555 words rather
+than discarding them after composing images. Only those three import cache
+markers gain `gba-textbox-palette-v1`; player save formats are unchanged. Older
+role-only data can answer its exact named indices. Unavailable arbitrary pairs
+return the existing white font fallback with a diagnostic, never numeric font
+options or fabricated palette entries.
+
+Fork frozen source `a9c30f1ace` passes 43 groups, including 10,490 indexed-colour,
+real proportional-font and owner-isolation checks, 78 real extraction/cache
+checks and 315 existing chrome checks. The older public composition
+`f35174ef21` passes 27 groups, including the same two new contract groups.
+Its test uses the existing readiness marker closure where the later pure cache
+descriptor is unavailable; no new unrelated production API is added.
+
+The subsequent unchanged-adapter CPU audit passes the text-colour boundary.
+Full game, cartridge artwork, window appearance and sustained FPS acceptance
+remain separate. Reference mods and player profiles were untouched; managed QA
+retains at least 20 GiB free.
diff --git a/docs/qa/native-foundation/battle-voiceover.md b/docs/qa/native-foundation/battle-voiceover.md
new file mode 100644
index 000000000..2ee10ecfa
--- /dev/null
+++ b/docs/qa/native-foundation/battle-voiceover.md
@@ -0,0 +1,15 @@
+# Native tutorial cue and menu observations
+
+Actual unchanged-mod run `9e0c34238d-firered` passes native menu-frame painting, then fails at missing `Ui.voiceoverDim`. UI queries now observe a native tutorial cue owner instead of starting a second renderer or returning a fabricated success state.
+
+The existing native Teachy-TV queue tags its actual imported messages, including the status lesson's healthbox cue and its final narration. Native ticks own the0..8 coefficient and five-tick palette steps; the native queue holds the caption until fade-in and holds the next action until return fades finish. Spotlight cues also have their own native healthbox coefficient and return stages. Queries never advance the clock, consume input or roll combat RNG. The ordinary native painter consumes the same state. The FR/LG controller is inert on Hoenn and other generations. Cartridge facts: [Pokedude controller](https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/src/battle_controller_pokedude.c), target8/delay4 and status-lesson healthbox callback.
+
+This is not full retail tutorial presentation parity. The ordinary native caption still uses its existing window. Intermediate healthbox palette interpolation, complete Oak/old-man cue scheduling, voiceover window art and audio ducking remain open; the source bridge's boolean spotlight observation cannot describe intermediate palette levels. No complete presentation-version marker is advertised.
+
+AP state observations reuse the existing native summary thresholds, retaining the separate palette-index ABI. Move-type observations preserve explicit per-slot type identities, including numeric zero. Quick-ball prompts read the actual native availability/inventory owner; they do not launch a second item transaction. Existing native quick-item input/commit remains unchanged.
+
+Frozen candidate `9a3b3bb1d4` passes syntax and26 suites (27 groups), including5,344 tutorial/query checks,1,387 native checkpoint continuation checks, current battle/menu/picture/selection/particle/entry/capture/UI and Gen2 regressions. Active tutorial fades explicitly reject decision checkpoints; normal checkpoints retain their existing continuation. The first fixture omitted settled native HP observations; it also exposed a real false-versus-nil cross-edition observation error, now fixed and retained as failed proof. The actual graphics run uses preceding candidate `b3aa3aef0c`, with identical rendering/controller source bytes; the final candidate adds only explicit checkpoint rejection and its fixture. Actual unchanged-mod run `78b938448b-firered` passes the previous UI failures and now stops at missing `Window.cursorPx` in the action-menu painter, before any accepted scene frame. No physical-window or60FPS acceptance follows from CPU tests.
+
+Exact older public composition `8dae697ea3` passes all20 groups. The first two public attempts retained an older caption wait/cursor in the quick-item fixture; the final fixture uses a separate genuine native admission. It offers focused native queue/tick/draw and query hooks while retaining older public native bodies and message-phase spelling. The older public baseline lacks the native checkpoint owner, so that guard remains fork-only.
+
+QA enforces20GiB free reserve and uses isolated test identities, never player saves. Contributions by Roxas2712. Existing native code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
diff --git a/docs/qa/native-foundation/battler-coordinate-queries.md b/docs/qa/native-foundation/battler-coordinate-queries.md
new file mode 100644
index 000000000..ad8a8922d
--- /dev/null
+++ b/docs/qa/native-foundation/battler-coordinate-queries.md
@@ -0,0 +1,11 @@
+# Native base battler coordinates
+
+The rendering adapter queries `pic_coords.battlerCoords(double, id)` for its untransformed sprite anchors. The native engine already owns the imported singles/doubles layout and its canonical fallback anchors. This query reads those owners instead of adding another coordinate registry or using camera/animation offsets.
+
+The result has `x/y` and indexed `1/2` fields and is detached from native records. It follows current datasets immediately, retains the explicitly requested layout independently of an animation's double/coordinate overrides, and rejects invalid slots, non-finite numbers and malformed records. Missing variant/slot data uses that variant's existing native anchor; it cannot accidentally select the other variant. No game is bootstrapped for a query, and other generations do not obtain a fabricated GBA owner.
+
+Frozen fork source `37b9261a00` on main `56d27ead` passes35 groups, including995 coordinate checks across FireRed, LeafGreen, Emerald, Ruby and Sapphire. Tests cover imported/default coordinates, changed and partially absent datasets, invalid records, detached mutations, animation-override isolation and unchanged native HP/AP/frame/queue/RNG. Existing battle/animation, RS healthbox, Gen2 party/AP/map/PACK/live-view, checkpoint/suspend and native process/quit regressions pass. Exact older-public composition `f33d99d2af` passes23 groups including the same995 checks, without replacing its native controllers or adding the newer fork lifecycle/RS bodies.
+
+This is an observational query contract. It does not qualify the remaining profile, caught-dex, substitute/stat-mask or complete presentation-provider interfaces, or extend previous graphical/performance results to this source. QA uses isolated identities and20GiB free reserve; player profiles and reference mods remain untouched.
+
+Contributions by Roxas2712. Existing code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and visible-credit requirements.
diff --git a/docs/qa/native-foundation/cartridge-semantic-views.md b/docs/qa/native-foundation/cartridge-semantic-views.md
new file mode 100644
index 000000000..0b9b52da7
--- /dev/null
+++ b/docs/qa/native-foundation/cartridge-semantic-views.md
@@ -0,0 +1,54 @@
+# Native Safari text and canonical metatile views
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for contribution terms and specific integration
+permission for Cedric / UNDERdecoded. Existing notices and rights remain intact.
+
+`core.game3.mb` shares the existing canonical native metatile namespace and
+edition translators. It does not maintain another set of behavior IDs, alter
+raw cartridge bytes or change collision/classification rules. This spelling
+alone does not implement absent named metatile-label constants or door forecasts.
+
+`Gen3SafariText` projects the current native Safari owner's imported IR through
+`native.safari.<role>` keys. It validates the current edition/fingerprint and
+native specification, returns detached nodes, and converts only the battle
+placeholder representation to the existing formatter's namespace. Native IR,
+prose, interpreter operands, rules, HP/AP, balls and RNG remain untouched.
+Explicit text/prose edits and tombstones retain priority; translation remains
+with the existing text service. There is no cache migration or replacement prose.
+
+`battle.profile.of(view)` supplies a read-only Safari presentation view for an
+actually admitted native Safari battle. Closing/replacing the battle, dataset,
+source view or edition retires its fields. It does not advertise rule/action
+or theme capabilities. Unsupported native owners expose no fabricated profile.
+The source healthbox query delegates the Safari player's panel to the same
+native counter painter used by the ordinary native HUD. The opponent panel and
+source offsets retain their existing behavior. No second layout or ball counter
+is maintained.
+
+Fork source `cb02fe24a7` on main `4e481a9c` passes 79 CPU groups, including
+196 Safari text/profile/HUD checks, 807 existing collision semantics checks,
+639 native text IR checks and the current native Safari rules/runtime suites.
+Exact older-public composition `30716ff9f5` passes 44 groups: 807 collision,
+576 IR checks and 8 import/unsupported-owner/generation boundary checks. It retains
+its older native bodies and does not contain the later native Safari owner;
+positive Safari controller/HUD qualification is not claimed for that baseline.
+The narrow callback and shared helper remain dormant without that native owner.
+
+The late-text fixture models required native UI stages' text writes rather
+than trying to read absent stat/Safari ROM tables from a short synthetic string.
+Actual final publication still owns the nativePlain snapshot. The old stages
+are restored after the check. CI checks these observations plus existing Gen2
+battle window/scene behavior.
+
+Unchanged-mod FireRed Safari `549ab98f50` completes its native constructor,
+paper view and idle cleanup. Its image exposed the ordinary player HP panel
+where Safari balls should appear; that failure is retained as evidence and led
+to the shared native-counter delegation. Corrected source `cb02fe24a7` run `69041aad74-firered` exits0 after all five
+paper/native/terrarium/native/paper views and idle cleanup. Its inspected paper
+frame shows the native Safari counter with30 balls instead of player HP.
+An actual Ruby Safari recheck is in progress. Full Safari throw/reaction/capture parity, all-edition/all-map
+visual acceptance and sustained60FPS are not inferred.
+
+QA uses owned profiles, preserves player saves and enforces20GiB free, above
+the requested8GiB minimum. Private mods and private runtime files are unchanged.
diff --git a/docs/qa/native-foundation/coroutine-phase-scopes.md b/docs/qa/native-foundation/coroutine-phase-scopes.md
new file mode 100644
index 000000000..3402df512
--- /dev/null
+++ b/docs/qa/native-foundation/coroutine-phase-scopes.md
@@ -0,0 +1,56 @@
+# Native coroutine phase ownership
+
+Native script bodies and Game3 methods remain owned by their existing native
+call sites. An actively resumed source child can consume its parent's body once.
+A suspended child cannot lend a phase or callback owner to an unrelated caller.
+
+The shared scope registry selects a coroutine's own active phase before inherited
+ones. Nested related phases retain their ordinary order. Ambiguous independent
+roots do not lend authority. Parent return retires pending children and borrowed
+body claims; their later cleanup cannot restore an expired phase over a newer
+one. Retirement also prevents that source coroutine from acquiring another
+registry's authority or flushing pending Pokemon writes. Weak heads/locals do
+not pin an abandoned coroutine; child registries are allocated only when needed.
+
+Native failures, including false-valued errors, cannot be swallowed and retried.
+Existing source/native return tuples retain their nil positions. The native
+controller remains the simulation clock; no action queue or animation sequence
+is introduced.
+
+## Limits and qualification
+
+This is prerequisite safety work for source-controlled action presentation. It
+does not create Engine.resolveMove, an action plan, animation event filtering,
+interactive choice policy, or a complete HP/RNG continuation guard. Arbitrary
+Lua statements already suspended inside a native body cannot be rolled back or
+preempted by a scope registry. The action Card remains gated until its complete
+native execution and presentation contracts are qualified.
+
+Retained baseline `ad7f267d73` reproduces suspended child leakage, consumption of
+a newer caller's body and restoration of an expired phase on source `97452fb1`.
+Focused source `029e4c5917` passes48 script-phase and30 game/callback tests, plus
+existing callback, follower, script, field, battle menu, fly arrival and Gen2
+lifecycle groups. Whole-source and exact older-public composition qualification
+follow separately; private mod code and player profiles are not changed.
+
+The shared script helper is also offered in #282 with identical source bytes.
+This offer contains the narrow Game3 phase/attribution integration and both
+ROM-free contract cases. Its game-owner fixture uses Emerald, which the older
+public tree already admits; it does not claim positive live RS scene acceptance.
+
+## Frozen combined qualification
+
+Native code `52a40875` / frozen `22c20c029b` passes all121 selected CPU groups.
+Exact older-public composition `27cb70b9bb` passes54 groups, including48
+phase tests,30 callback/game tests and467 real script-space ownership checks.
+It applies only the shared once-only helper and published Game3 adapter changes;
+older native controller bodies remain unchanged. The first raw script-PR probe
+retains a missing NativeSession prerequisite; it is not claimed as an integrated
+pass. The raw offered phase helper separately passes48 checks.
+
+The unchanged private package completes Ruby new-game/naming, real native map
+cancel/reopen and flight on this frozen source in run `353d5c5f1d`. Landing setup
+is ready under the opaque transition, then the player reaches Littleroot5,9 with
+free input,355050 vertices and no mod/renderer errors. Its stationary240-frame
+Metal observation averages16.330ms, with p95 24.786ms and max142.098ms. This is
+not a stable-sixty-FPS, all-view, continuous-story or visible-desktop claim.
diff --git a/docs/qa/native-foundation/frame-widget-presentation.md b/docs/qa/native-foundation/frame-widget-presentation.md
new file mode 100644
index 000000000..aeebc6df0
--- /dev/null
+++ b/docs/qa/native-foundation/frame-widget-presentation.md
@@ -0,0 +1,35 @@
+# Native frame widgets
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for the contribution terms and specific integration
+permission for Cedric / UNDERdecoded. Existing notices and rights remain intact.
+
+The existing Font user, standard, dialogue and signpost helpers offer `frame`
+contexts to the native presentation provider. Pixel bounds come from the same
+native record/cap rules used by actual painting, including old caches without
+dialogue/sign artwork. The source tile-template helper borrows the native standard
+frame rather than the user-selected frame. No new controller, atlas or draw clock
+is introduced.
+
+A provider handles the decoration or falls back to the native helper. Repeated
+base requests borrow one paint; native helper-to-helper fallbacks remain native
+and cannot recursively re-enter the provider. Native failures remain fatal even
+when caught by a decorator. Base return tuples and the native font's colour/font
+postconditions survive provider isolation, both inside a base caller and before
+the next ordinary label. Provider canvas/scissor/stack changes remain fenced.
+
+`frameWidgets` is now advertised alongside `nativeUiStack` and `windowLayers`.
+The complete PC/bag/naming/summary/battle theme families remain gated. Frames
+without an admitted provider, and all other generations, keep their native bodies
+without creating frame contexts.
+
+Frozen fork `5cb5cc460c` passes 62 CPU groups, including 657 frame/provider checks;
+independent older-public composition `fd7c59ce81` passes 33 groups with the same
+657 checks. Fork GPU `de618dc80c` and public GPU `e710c2c5d9` each pass 4,322 checks
+across 480 frames on both Metal and OpenGL. Owned asymmetric frame strips and the
+following native label compare against ordinary native output: five editions,
+all four frame kinds, imported/fallback artwork, DPI 1/2, scale 1/2 and false,
+borrowed-base and failed-provider paths. These synthetic pixel checks do not
+establish complete themed-family, cartridge-art, full-game, window or sustained
+performance acceptance. QA keeps isolated profiles and at least 20 GiB free;
+player saves and private runtime files remain untouched.
diff --git a/docs/qa/native-foundation/gba-battle-source-boundary.md b/docs/qa/native-foundation/gba-battle-source-boundary.md
new file mode 100644
index 000000000..5f24b3cc6
--- /dev/null
+++ b/docs/qa/native-foundation/gba-battle-source-boundary.md
@@ -0,0 +1,75 @@
+# Native GBA battle source boundary
+
+This is an incremental presentation and observation bridge over the existing
+`BattleState`. It does not establish complete unchanged-package boot or play.
+
+## Implemented boundaries
+
+- The admitted native stack owns battle identity, input, combat, RNG and exit.
+- Stable source observations translate cartridge species/move/item/ability/type
+  identifiers and flattened Pokemon fields. Trainer class and trainer id remain
+  different fields. HP/status changes and PP transactions reach native Pokemon;
+  unsupported move replacements fail before an update.
+- Native start notifications, update, UI pump, whole-screen drawing and the
+  background pass have independent scopes. Repeated base calls consume each
+  native body once. Calls outside an update scope cannot tick combat.
+- Every queued native update/draw rechecks the original admission after source
+  hooks, including the inner UI/background hooks. Save, dataset, loader, stack,
+  edition and imported catalogue replacement retire the old binding; restoring
+  an earlier pointer cannot revive that binding. Native method bodies execute
+  outside a source callback owner.
+- Explicit battle/UI captures suppress the repeated native screen draw within
+  the same renderer frame and render target. A separate preview target cannot
+  suppress the main screen. Capturing never advances combat.
+- LuaJIT `pairs`/`next` expose typed battle fields, preserving nested typed
+  identity. Iterator registry values are weak, so an unused observation cannot
+  retain its own weak key through a closure.
+- Covered battles remain observable, but cannot update or pop their cover.
+  Mod retirement invalidates its source views without cancelling native combat.
+  Completed views keep detached observations and reject further native writes.
+- Basic source wild/trainer requests reuse the native encounter admission and
+  cleanup provider when present. Authored source parties, extended options,
+  headless simulation and source-controlled link termination remain unsupported.
+  Constructor-request acceptance is not yet independently qualified here.
+- Pokemon observations use native imported records. Height and weight convert
+  metres/kilograms to cartridge decimetres/hectograms. Static pictures are owned
+  by the source service; native animation frames remain borrowed.
+- Separate presentation players reuse native `MonAnim`/`PicAnim` timing. Their
+  timing is the existing native implementation, not a proof of exact source
+  sprite callbacks. They cannot consume combat commands.
+
+Older native controllers without HUD visibility or move-grid query methods
+return an explicit unavailable reason for those observations. This does not
+advertise the complete presentation protocol on that host.
+
+## Qualification
+
+The focused engine suites cover all five registered GBA editions using
+synthetic imported data and actual native constructors, stack admissions and
+exit. They exercise repeated base calls, covered states, UI input/draw scopes,
+owner/data/edition retirement, numeric identity, PP and detached final views.
+View-only collection checks isolate this bridge from the host's global facade
+cache; they do not certify the entire host's Game/save collection policy.
+
+`tools/battle-source-runtime/host` draws the actual native `Gen3Battle` on a
+GPU. It compares default and wrapped pixels, replaces only the field pass,
+checks that the native command-area pixels remain identical, and checks
+graphics restoration after a failing callback. Artwork and battle records are
+synthetic; these are not original-package or cartridge gameplay checks.
+
+## Remaining presentation work
+
+The UI module deliberately does not advertise the complete sprite/particle
+presentation protocol. Native animation VM, effect, healthbox, trainer, ball,
+text, catch, switch and intro presentation interfaces still need their own
+bindings. So do complete party/save collection schemas and authored source
+Pokemon operations. Original-package initialization, real play sequences,
+source effect timing/art parity and physical target acceptance remain open.
+
+The last unchanged-package loader probe advances beyond battle, Pokemon,
+motion and UI imports to the missing `src.core.game3.battle.anim` interface.
+
+Older native hosts also retire already-loaded battle, Pokemon-picture and
+motion services at loader unwind, even when their stream service is not yet
+driven by loader retirement. This releases observations and owned pictures;
+it does not pop or finish the actual native battle.
diff --git a/docs/qa/native-foundation/gba-color-effects.md b/docs/qa/native-foundation/gba-color-effects.md
new file mode 100644
index 000000000..eed51f9bf
--- /dev/null
+++ b/docs/qa/native-foundation/gba-color-effects.md
@@ -0,0 +1,11 @@
+# Native colour-effect drawing
+
+`gba_fx.draw/active/withClip` now cover five-bit fade colours, grayscale, brightness bands, object-window masks and clipping. Alpha combines the transformed source with the native underlay snapshot in one pass. The draw callback runs once, including when fade and alpha are combined; two simulated blend passes cannot consume a native drawing receipt twice.
+
+Each nested draw uses a separate shader bank, so restoring a shader handle also restores the caller's effective uniforms. A bounded pool reuses programs and native alpha surfaces; masks remain borrowed and are detached after painting. Errors restore render target, shader, colour, blend and scissor. Teardown during a painter is deferred until the active draw exits. Object-window/band coordinates use logical target pixels, including DPI2; the existing default native-alpha program retains its integer arithmetic.
+
+Fork source `929266d044` passes38 groups including93 effect/ownership tests and the earlier profile, coordinate, battle, Gen2, checkpoint/suspend and session regressions. The same frozen bytes also pass the two additional native level-up streak/facade contracts. Exact older-public composition `c72042ec0c` passes25 groups plus those two level-up contracts. The shared alpha helper extension belongs to PR339; the drawing interface belongs to PR329. Small checked helper patches retain the older public native controllers.
+
+Owned-output GPU probes pass346 checks each on Metal/OpenGL for both fork `3baa88a3d7` and public `da50b66c1f`. Samples cover all17 fade coefficients, brightness, grayscale ordering, combined alpha, object windows, bands, clips, default native alpha and DPI1/2. Each run observes64 painter calls. These are ROM-free pixel/resource tests, not full game, OS-window or sustained performance acceptance. Reference mods and player saves remain unchanged; managed QA enforces20GiB free reserve.
+
+Contributions by Roxas2712. Existing native code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and visible-credit requirements.
diff --git a/docs/qa/native-foundation/hoenn-dex-observations.md b/docs/qa/native-foundation/hoenn-dex-observations.md
new file mode 100644
index 000000000..1a05c38fd
--- /dev/null
+++ b/docs/qa/native-foundation/hoenn-dex-observations.md
@@ -0,0 +1,58 @@
+# Native Hoenn dex/search observations and RS menu text
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for the contribution terms and specific integration
+permission for Cedric / UNDERdecoded. Existing notices and rights remain intact.
+
+`ui.game3.rse.pokedex.active()` observes the actual constructor-admitted Hoenn
+listing/search screen. It exposes zero-based selection and mode, national mode,
+and detached parameter cursor/scroll records. Closing/replacing the screen,
+stack, save, dataset, loader or source view retires retained observations.
+Observation cleanup never closes a native menu or mutates native preferences.
+The fork binds both the existing RS controller and generic Hoenn controller;
+the older-public offer binds the controllers present on its own baseline.
+No later RS controller body is copied into that composition.
+
+RS semantic battle-text reads select the actual cartridge's command prompt and
+swap prompt. PP and type each select their own line of the shared native record;
+both preserve leading structured controls. The active-Pokemon prompt remains
+separate from the player-name/Safari prompt. Explicit canonical prose/record
+edits, removals and translation remain authoritative. Queries retain no dataset.
+The label relationship is documented by the public
+[RS battle strings](https://github.com/pret/pokeruby/blob/5784633ce4ef7ade1a7f2d2d0c288e3d5e6cdd7f/src/data/battle_strings_en.h).
+No replacement cartridge lettering or cache migration is introduced.
+
+`Gen3TextPen` shares measurement and painting of embedded positioning controls
+through the native proportional font. Minimum-width cells preserve complete
+Unicode/charmap ligatures; clipping skips ink without changing pen position.
+Ordinary strings keep the existing path. Unsupported/truncated positioning
+controls fail before any glyph is painted, with native face/shader/colour state
+restored. This is a bounded synchronous layout adapter, not a dialogue VM.
+The current-main Safari composition also paints the RS user frame once while
+retaining the native labels/cursor and native battle state.
+
+Frozen fork `0f4111a361` on main `4e481a9c` passes 72 CPU groups, including
+214 Hoenn observation, 56 semantic RS text, 180 pen-layout and 22 RS Safari
+frame checks. Exact older-public composition `6248b0294b` passes 37 groups,
+including 174 Hoenn, 56 RS text and 180 pen checks. The smaller Hoenn count
+reflects the absent later RS controller; its constructor is not claimed tested.
+
+Owned-output probes `b34e4d27e7` (fork source `f08e55c19c`) and `bbd293c34c`
+(public source `a56e42c307`) each pass 402 checks / 160 frames on each Metal
+and OpenGL backend: actual native font shaders, asymmetric glyphs, main/small
+faces, HD off/on, DPI 1/2, scale 1/2, Unicode/ligatures and rejected malformed
+controls. These probe the pen/font paths; later semantic text selection is
+covered separately by the newer CPU snapshots and actual runs.
+
+Unchanged-mod Ruby run `0fe7c55780-ruby` completes the native trainer battle,
+paper/native/terrarium/native/paper view changes, move swap/restore/cancel and
+idle presentation cleanup with exit 0. Its images exposed the subsequent pen
+and prompt-selection fixes; it is not accepted as evidence of those later fixes.
+Fresh runs `92d67353a1-ruby` and `1f2a1ba9d3-sapphire` both exit 0 on
+source `0f4111a361`: clean AP labels, all five trainer-battle views, native
+move swap/restore/cancel, actual RS dex constructors and parameter navigation,
+then native close and observation retirement. Those real RS constructors are
+qualified separately from the earlier typed-state CPU fixtures.
+No complete gameplay, all-map visual or sustained-FPS acceptance is inferred.
+QA uses owned disposable profiles, preserves player saves and enforces at least
+20 GiB free, exceeding the requested 8 GiB.
diff --git a/docs/qa/native-foundation/host-file-picker.md b/docs/qa/native-foundation/host-file-picker.md
new file mode 100644
index 000000000..eb62f7e6a
--- /dev/null
+++ b/docs/qa/native-foundation/host-file-picker.md
@@ -0,0 +1,33 @@
+# Shared native desktop file selection
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for contribution terms and the specific integration
+permission for Cedric / UNDERdecoded. Existing rights/notices remain intact.
+
+Source consumers can use `FilePicker.available/open/commands/matches/read/basename`
+and the standard image filter. The native importer's by-extension picker uses
+that same command builder. Dialogs still launch only through its existing
+pointer-release path; importing or querying the module never creates Game or a
+save owner. Reads are binary and read-only, with handles closed on read failure.
+
+The builder validates filters and preserves UTF-8 titles as data. POSIX shell
+and AppleScript quoting are separate. Windows passes dynamic title/filter data
+as byte arrays, preserves the existing no-copy fast path for ASCII paths, and
+uses unique non-ASCII staging paths with fail-closed copy errors. A canceled
+Linux chooser does not open a second dialog; it selects the available zenity
+or kdialog backend before launch. Unsupported hosts retain their existing
+mobile/no-picker workflows. Failed dialog reads close their pipe and return
+no selected path.
+
+Frozen fork `939f268ed2` passes 76 CPU groups. Exact older-public composition
+`d6a78527f9` passes 41 groups. Both include 90 modeled desktop-picker checks,
+27 existing pointer-grab checks, 12 no-picker checks and 14 Android picker
+checks. The public test's older source-text counter was counting comments as
+process calls; it now excludes comments, as the current native test already
+does. The actual pointer-release scenarios and single process funnel remain
+checked. The public composition retains its existing native shell/importer
+bodies and applies only these narrow changes. CI runs the four picker suites.
+
+No real Windows/Linux dialog, desktop-wide UI acceptance or sprite-pack
+installation is inferred from command-model tests. QA uses owned profiles,
+preserves player saves and enforces 20 GiB free, above the requested 8 GiB.
diff --git a/docs/qa/native-foundation/move-effect-symbols.md b/docs/qa/native-foundation/move-effect-symbols.md
new file mode 100644
index 000000000..3aee59fa4
--- /dev/null
+++ b/docs/qa/native-foundation/move-effect-symbols.md
@@ -0,0 +1,31 @@
+# Canonical native move-effect symbols
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for the contribution terms and specific integration
+permission for Cedric / UNDERdecoded. Existing notices and rights remain intact.
+
+`Gen3EffectCatalog` provides constant-time ID/name queries and detached snapshots
+for all 214 GBA dispatch slots, including unused slots. The canonical identifier
+facts come from [the pinned public constant header](https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/include/constants/battle_move_effects.h)
+(SHA-256 `fa15e285903818cc3cc7ecb2ca32c11d8317b14d261ca2d1caf44e614b53828a`).
+The exact header is retained separately as a factual test fixture. Runtime storage
+uses one compact ordered list and two lookup tables built once, with no session,
+save, importer or combat bootstrap.
+
+`battle.effect_ids` returns its own snapshot, so decorating source constants
+cannot mutate native authority. `battle.moves.get(...).effectSymbol` identifies
+the current imported raw byte. Unknown custom bytes remain usable and unnamed;
+old records without the byte are never reverse-guessed from native dispatch
+names. Native move records, cache formats and effect execution stay unchanged.
+Publishing an identifier does not implement an absent effect, action readiness
+gate, executor or animation event producer.
+
+Frozen fork `27e2bc33e1`, refreshed with main `e6dbce6a`, passes 64 CPU groups,
+including 4,531 symbol/snapshot/imported-query checks and the merged optional
+image failure/retry checks. Independent older-public composition `f4e264523f`
+passes 34 groups with the same 4,531 symbol checks; its native controllers and
+asset owner remain separate. Unchanged-mod run `e4a3201258-firered` completes the
+real trainer, five view changes and native move-swap/restore/cancel with exit 0
+and idle cleanup. No full action-command, all-edition gameplay, complete visual
+or sustained-FPS acceptance follows. QA keeps isolated profiles and at least
+20 GiB free; player saves and private runtime files remain untouched.
diff --git a/docs/qa/native-foundation/move-rule-metadata.md b/docs/qa/native-foundation/move-rule-metadata.md
new file mode 100644
index 000000000..7395a5631
--- /dev/null
+++ b/docs/qa/native-foundation/move-rule-metadata.md
@@ -0,0 +1,44 @@
+# Native move and critical-rule observations
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for the contribution terms and specific integration
+permission for Cedric / UNDERdecoded. Existing notices and rights remain intact.
+
+`battle.moves.get` now publishes the actual imported move index as both `id`
+and `numId`, with `nativeId` retaining the native registry key. Numeric strings
+and the existing `{id=...}` / `{move=...}` forms resolve through BattleIds.
+The effect field projects the validated cartridge `gen3Effect` byte, including
+zero; `nativeEffect` retains the native dispatch name. Different cartridge effects
+can share that name, so an old cache without the original byte is never reverse
+guessed. Invalid present bytes are rejected with a diagnostic. Native records and
+effect dispatch stay unchanged.
+
+The query also preserves native flags, percentage secondary chance, the existing
+native probability, contact/critical properties and multi-hit metadata. Nested
+flag/hit tables are detached, including explicit false values. A native hit
+producer is described as present rather than invoked or exposed as another move
+execution path. Each query reads the current registry; no new cross-frame move
+cache hides live native edits or catalogue replacement.
+
+`battle.rules.crit.CHANCE` returns a detached zero-indexed denominator table from
+the same private constant used by native Damage. Mutating it cannot alter native
+critical rolls. This is GBA metadata only: it does not provide an action executor,
+input suspension, animation event producer, RNG owner or complete gameplay
+profile. Optional action commands still need those native phase contracts before
+they can be enabled.
+
+Current-main integration retains both the Gen2 typed queue admission/completion
+and existing GBA switch/capture/streak/voiceover hooks. Qualification checks those
+owners together, including GBA effect/Substitute timing and native Gen2 event
+checkpoint reconstruction. The older-public composition keeps its existing
+critical calculation and RNG origin; the portable fixture checks its own stage
+inputs and denominator span without substituting a later native controller.
+
+Frozen current-main source `90363e8026` passes 61 CPU groups, including 630 new
+move/rule checks, 801 typed-queue checks, 27 typed-checkpoint checks, 13,778 GBA
+effect checks, 6,338 Substitute presentation checks and 104,512 Substitute fade
+checks. Older-public source `f4b45ce538` separately passes 32 CPU groups with the
+same 630 move/rule observations. These are metadata and native phase regressions,
+not complete action-command, full-game, visual or sustained-FPS acceptance.
+QA uses isolated owned profiles and at least 20 GiB free; player saves and private
+runtime files remain untouched.
diff --git a/docs/qa/native-foundation/particle-pass.md b/docs/qa/native-foundation/particle-pass.md
new file mode 100644
index 000000000..60ee15c89
--- /dev/null
+++ b/docs/qa/native-foundation/particle-pass.md
@@ -0,0 +1,15 @@
+# Native particle passes
+
+The unchanged battle bridge calls `Anim.drawParticles` in bands around its battler captures. The native binding borrows existing event and copied-background painters; it does not create particles, a script VM, a task scheduler or another frame clock.
+
+`Gen3Battle.moveOamObjects` factors the native hardware ordering already used by `drawMoveOamObjects`. The default native painter retains its existing singles path and doubles fallback. The explicit source pass can classify all four real battlers into source bands, shares one ordering sample per guarded UI capture, and uses actual native priority, subpriority, live OAM Y and retained tie ranks. First exact key/Y ties retain the existing `global-sprite-slot-history` residual. Unknown direct OAM events use the existing native event-order/front-layer fallback; no priority is invented. This is not complete hardware sprite-slot parity.
+
+The pass borrows native monbg copies before/within/after OBJ as appropriate, then native Surf/flourish extras with `skipEvents`, so OBJ are not drawn twice by that extra layer. Existing particle decorators retain their native event positions. Each draw is graphics-scoped; replaced admissions/clips, owner teardown and callback failures stop the borrowed pass without advancing or cancelling the native effect. The native OAM tie diagnostic is also classified as presentation in suspend witnesses.
+
+The new ROM-free fixture compares the actual native singles painter trace against source bands over all five GBA admissions, checks separate captures at the same frame, query-only clocks/RNG/HP/queue, native particle decorators and failed-callback target restoration, changed cohorts, actual generic monbg copies, unknown-key fallback and all four real doubles slots. Current-main frozen fork `83b3a9d0c3` passes all19 groups, including288 particle and758 selection checks plus the current native Gen2 window/queue/scene/live-view/summary and suspend regressions. Source/test hashes match the candidate. The first attempt `7970e2a8aa` correctly selected the native fallback because its synthetic import omitted battler coordinates; that failed fixture is retained and its explicit imported coordinate data is now present. This is a combined-fork CPU qualification; the exact public composition and actual graphics reprobe are still pending. No actual graphics fix, clean map/terrarium frame, physical-window result or FPS acceptance is claimed.
+
+Earlier CPU probe `95cc3d63ee` reaches a real missing `Anim.drawParticles` call in the unchanged bridge. Actual battle probe `43b5eb8d59-firered` reaches the native command and stops earlier at missing `Ui.targetHidden`; its separately offered selection binding still needs actual graphics retesting. Tests and future graphics runs use isolated QA profiles and never player saves.
+
+Contributions by Roxas2712. Existing native code, art and applicable third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
+
+Public baseline note: this older public branch does not contain the fork-only SuspendJournal owner. Its one-line OAM diagnostic classification and semantic-witness fixture remain in the fork offer; no private/native Journal body is copied into this public PR.
diff --git a/docs/qa/native-foundation/picture-identity.md b/docs/qa/native-foundation/picture-identity.md
new file mode 100644
index 000000000..fb36045a7
--- /dev/null
+++ b/docs/qa/native-foundation/picture-identity.md
@@ -0,0 +1,11 @@
+# Native picture identity
+
+Actual unchanged-mod run `998ae70f38-firered` passes the previous stage/target/bounce calls, reaches native command selection, then actor capture fails because `Pokemon.picSpecies` is missing. Native source Pokemon queries now expose registered cartridge picture identities, base-picture normalization and Unown personality selection without inventing logical species records or using National Dex numbers as internal slots.
+
+The native GBA graphics namespace has Unown A at201 and its other27 pictures at413..439, independently of the412-row name table. The fixed supported edition profiles all declare that name-table size. The personality selector reads the low two bits of each byte and normalizes signed uint32 representations. It uses portable integer arithmetic without requiring a bit library during module loading. Reference: [pret/pokefirered species constants](https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/include/constants/species.h) and [LoadSpecialPokePic](https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/src/decompress.c).
+
+Explicit registered native content takes precedence over a picture alias; an alias collision is rejected rather than displaying a different logical species. Ordinary picture requests retain one native context lookup and their existing owned-image cache. Current native imports do not expose the27 extra Unown pictures, so those requests return an explicit missing-art result instead of silently displaying A. Other alternate-form pictures, dynamic Spinda artwork and full picture protocol parity remain open; this query does not claim those features.
+
+Frozen current-main candidate `f7513c67d9` passes syntax and all18 targeted suites:532 picture identity checks,206 existing Pokemon metadata/art-ownership checks, the qualified selection/particle/stage/battle/UI/ball tests and current Gen2 Unown/palette/scene/live-view/summary/window/queue regressions. Source/test hashes match the candidate. A new actual graphics probe is running. No clean map/terrarium frame, physical-window result, full gameplay or60FPS acceptance follows from these CPU tests. QA enforces20GiB free and never uses player saves.
+
+Contributions by Roxas2712. Existing native code and applicable third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
diff --git a/docs/qa/native-foundation/playfield-query.md b/docs/qa/native-foundation/playfield-query.md
new file mode 100644
index 000000000..05083947d
--- /dev/null
+++ b/docs/qa/native-foundation/playfield-query.md
@@ -0,0 +1,22 @@
+# Native playfield cutout query
+
+`src.render.Playfield.cutout(width, height)` observes the rectangle reserved by
+the existing native `GameViewport` during its current frame. This is the lazy
+query required by unchanged battle/menu layout consumers; it does not install
+a skin, allocate a target, change a scissor or begin another viewport phase.
+
+Explicit full-window dimensions return the native rectangle in window space.
+Dimensions of the already entered native target return local origin `(0,0)`
+and its actual extent. This avoids subtracting the same window offset twice.
+Logical dimensions do not change with DPI. Unrelated preview/actor target
+sizes, invalid dimensions, a retired frame and the ordinary full-window path
+return no reserved cutout, preserving the caller's safe-area/touch fallback.
+
+Only `cutout` is offered. The independent `push`/`pop`/skin-owner protocol is
+not advertised. Native Gen2 rendering still enters and exits its existing
+viewport directly.
+
+The actual unchanged-package native battle probe `cf9cd39d2b-firered` reaches
+native entry but fails before scene frames because this module was absent.
+Keep that failed receipt; CPU geometry checks alone do not qualify the later
+map/terrarium frame, physical-window output, portrait touch play or FPS.
diff --git a/docs/qa/native-foundation/presentation-profiles.md b/docs/qa/native-foundation/presentation-profiles.md
new file mode 100644
index 000000000..3b629848d
--- /dev/null
+++ b/docs/qa/native-foundation/presentation-profiles.md
@@ -0,0 +1,11 @@
+# Native presentation profile queries
+
+Rendering adapters select their edition family, proportional font and RS sprite layout through `profile.forSession`. These facts now come from the native version registry and existing font module. Queries do not bootstrap another game or choose another cache, save, importer or rules engine. Other generations and unknown editions are rejected rather than redirected to a GBA fallback.
+
+Profiles and nested font/UI records are immutable and reused while their version facts remain unchanged. Replacing a native registry record or changing its label/layout invalidates the cached projection. The cache holds edition metadata only, not a game/session/save. This surface deliberately does not advertise a full gameplay, extractor or screen profile.
+
+Fork source `7372419961` on main `e6020353` passes37 groups, including266 profile checks across all five GBA editions, real native proportional-font measurements, coordinate/battle/Gen2 regressions and both process/mounted-session shutdown contracts. Exact older-public composition `e05a1f91ac` passes24 groups with the same266 checks, retaining its older native controllers. The initial fixture also caught a non-string-ID boolean guard; corrected before qualification.
+
+The unchanged adapter's CPU audit `14c959a524` now draws both battlers and the captured-actor fallback in all five editions; the previous missing-profile failures are gone. Its full UI reaches a synthetic fixture's absent `gText_BattleMenu` record. This is a fixture limit, not a new actual-game failure or visual acceptance. The remaining colour-effect and complete device/provider interfaces stay separate. Reference mods and player saves remain unchanged; managed QA enforces20GiB free reserve.
+
+Contributions by Roxas2712. Existing native code and third-party rights retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and visible-credit requirements.
diff --git a/docs/qa/native-foundation/presentation-providers.md b/docs/qa/native-foundation/presentation-providers.md
new file mode 100644
index 000000000..ec1215085
--- /dev/null
+++ b/docs/qa/native-foundation/presentation-providers.md
@@ -0,0 +1,62 @@
+# Native presentation providers
+
+Contributions by Roxas2712 — https://github.com/Roxas2712.
+See LICENSE-ROXAS2712.md for the contribution terms and specific integration
+permission for Cedric / UNDERdecoded. Existing notices and rights remain intact.
+
+`src.ui.game3.presentation` and the native compositor share one
+`NativePresentation` owner. API version 1 supports provider registration,
+enablement, drawing/notifications, widgets, deferred layers, window completion
+and health observations. Registration records the calling mod owner independently
+of its provider ID, so ordinary mod cleanup retires both. Replaced registrations
+have distinct disposer identities.
+
+The native Game frame admits the current source game view. Its data, save, loader,
+edition, stack identity and entire state sequence must remain current until each
+paint. A retired view also invalidates the frame. The service owns no simulation,
+input queue, save format, imported image or extra rendering loop.
+
+Native modal groups offer `ui_stack` layers without moving world or battle scene
+owners into the UI pass. The compositor flushes them on its current window target
+before the native battle transition, veil and final output. The existing explicit
+compose-hook takeover flushes after that hook returns. A provider's `present`
+callback controls its own window layout; fallback uses the native UI surface and
+the compositor's fitting policy. It keeps capture/postprocess targets bound.
+
+Widget and deferred native painters are once-only leases, including their return
+tuples. Provider failure or mid-frame disable/removal returns admitted work to the
+native fallback. A swallowed native error still fails the frame. Graphics state,
+canvas, scissor, leaked pushes and callback ownership are fenced. Finished leases
+release their native closure and frame references; nested layers during flush
+paint inline. Limits are 64 registered providers and 128 queued layers per frame;
+additional layers paint immediately. Session shutdown drops stale callbacks.
+
+Only `nativeUiStack`, `windowLayers` and the separately qualified `frameWidgets`
+are advertised. PC, bag, naming, summary,
+battle paper devices and other themed families need their actual native call
+sites and context projections before their feature flags can become true. This
+foundation deliberately does not enable an experimental theme or claim those
+families are complete. Other generations keep their existing compositor.
+
+Frozen fork `f4f6a295a7` passes 48 CPU groups, including 538 provider checks.
+Owned-output run `70560fd6d9` passes 1,682 checks across 240 frames on each of
+Metal and OpenGL: five editions, logical widths 240/320, target DPI 1/2, two
+window sizes, fallback/error cases and nested painting. Unchanged-mod run
+`1eb7007342-firered` completes a real trainer, five view changes and native
+move-swap/restore/cancel input with exit 0 and idle cleanup. The older-public
+composition `1dbf66c04e` independently passes 31 CPU groups with the same 538
+provider checks. Its separate owned-output run `461c91ab60` also passes 1,682
+checks across 240 frames on each backend.
+
+Earlier trainer benchmark `58ae54db42-firered`, source `1830bd24b6`, records
+240 readback-free intervals per view averaging about 60 FPS in paper, native
+and terrarium views. Its driver finished, but the wrapper failed in a later
+macOS screen-lock diagnostic timeout. A separate recovery receipt retains
+that failure and the source association; it does not relabel the run accepted.
+The diagnostic starter now records that optional timeout rather than discarding
+native completion metadata.
+
+These checks establish bounded frame and integration behavior, not complete
+family, full-game, all-edition visual, OS-window or sustained performance parity.
+QA uses fresh owned profiles, preserves player saves and retains at least 20 GiB
+free.
diff --git a/docs/qa/native-foundation/rs-menu-cursor.md b/docs/qa/native-foundation/rs-menu-cursor.md
new file mode 100644
index 000000000..b116a5441
--- /dev/null
+++ b/docs/qa/native-foundation/rs-menu-cursor.md
@@ -0,0 +1,29 @@
+# Shared native RS outline cursor
+
+The public cursor and the fork's native RS battle panel share
+`Gen3RsMenuCursor`. It uses the imported common-UI manifest and central native
+Assets cache. Detached segment queries preserve the cartridge's cap/overlap
+positions; a bounded sixteen-width plan cache avoids constructing strips on
+ordinary repeated draws. Edition/dataset replacement, asset invalidation and
+owner teardown retire manifest metadata. Borrowed images are never released by
+the cursor, and graphics failures restore the caller's state.
+
+Images retain their logical 8/32 by16 size independently of texel density.
+The native controller changes only its cursor binding; no rule, input, queue,
+clock, random or save owner is replaced. The older-public composition offers
+the shared drawing service and public facade against its own controller set;
+it does not overlay the fork's later RS controller body.
+
+Fork frozen source `16fd33d5e5` passes45 groups, including644 cursor checks and
+RS native-panel readiness. The older-public composition `b60bac3ca5` passes28
+groups, including131 portable cursor checks. The fork additionally compares
+513 widths against its retained pinned native reference.
+
+Owned-output GPU runs `acc5ab25cd` (fork) and `bb8bfe6dd8` (public) each pass
+1474 checks across256 constructed frames on Metal and on OpenGL: golden cap/
+overlap placement, DPI1/2, texture density1/2/3, fades/grayscale/brightness,
+and actual native two-tone font pixels through the indexed colour facade for
+all five editions. Synthetic artwork is deliberate: these are drawing-contract
+proofs, not cartridge-art, OS-window, full-game or sustained-FPS acceptance.
+Managed QA keeps20GiB free and uses separate identities; reference mods and
+player saves are untouched.
diff --git a/docs/qa/native-foundation/window-cursor.md b/docs/qa/native-foundation/window-cursor.md
new file mode 100644
index 000000000..bf73463e4
--- /dev/null
+++ b/docs/qa/native-foundation/window-cursor.md
@@ -0,0 +1,7 @@
+# Native pixel cursor binding
+
+Actual unchanged-mod run `78b938448b-firered` stops in the action-menu painter at missing `Window.cursorPx`. The pixel cursor now borrows the current native Theme cursor symbol and the existing imported proportional-font painter. Native colors, optional face selection, proportional advance and graphics-state/error restoration remain owned by those existing helpers. No private glyph atlas or hardcoded replacement cursor is added.
+
+Frozen source `ee555e80d2` passes syntax and all23 targeted suites (24 groups), including145 glyph/cursor checks,5344 tutorial/UI checks and existing native menu/battle/START, Gen2 window/queue/scene/live-view/summary, checkpoint and suspend regressions. The fixture changes the native symbol between draws and verifies both actual pixel coordinates and restored face/shader/color state. Actual unchanged-mod graphics reprobe is running; clean scene, OS-window and60FPS acceptance remain open. QA uses isolated profiles and20GiB free reserve; player saves remain untouched.
+
+Contributions by Roxas2712. Existing native code and third-party notices retain their provenance. See NOTICE.md and LICENSE-ROXAS2712.md for Cedric / UNDERdecoded integration permission and credit requirements.
diff --git a/src/battle/BattleState.lua b/src/battle/BattleState.lua
index 297e84c74..8c9400a5f 100644
--- a/src/battle/BattleState.lua
+++ b/src/battle/BattleState.lua
@@ -10,6 +10,7 @@
 -- bide, recharge, confusion, screens, substitute, transform, ...) is
 -- ported from engine/battle/core.asm; see docs/behavior-porting-notes.md.
 
+local nativeMoveUsed = {} -- identity of the native announcement producer
 local Assets = require("src.render.Assets")
 local Catching = require("src.battle.Catching")
 local Damage = require("src.battle.Damage")
@@ -53,6 +54,8 @@ local TEXT_AREA_ROWS = { 112, 128 }
 local BattleState = {}
 BattleState.__index = BattleState
 BattleState.isOpaque = true
+-- Native source observations identify this admitted controller directly.
+BattleState.isBattleState = true
 
 -- pokered prints the battle lines itself (engine/battle/core.asm and the
 -- move-effect banks), and the importer extracts every one of them, so the
@@ -596,10 +599,7 @@ function BattleState:sgbPalettes()
   return nil
 end
 
-local Rulesets = {
-  gen1_faithful = require("src.battle.rulesets.gen1_faithful"),
-  modern_clean = require("src.battle.rulesets.modern_clean"),
-}
+local Rulesets = require('src.battle.Rulesets')
 
 -- the Poké Ball toss chain (TossBallAnimation) plays even with battle
 -- animations off: PlayMoveAnimation jumps to it before checking wOptions
@@ -936,7 +936,9 @@ local StatBox = {}
 StatBox.__index = StatBox
 
 function StatBox.new(game, mon, onDone)
-  return setmetatable({ game = game, mon = mon, onDone = onDone }, StatBox)
+  local state=setmetatable({ game = game, mon = mon, onDone = onDone }, StatBox)
+  if GameVersion.isGen3()then require('src.compat.gen1.NativeModalObservation').capture(state,game)end
+  return state
 end
 
 function StatBox:update()
@@ -1364,6 +1366,12 @@ function BattleState.giveWildHeldItem(data, mon, rng, compoundEyes)
 end
 
 function BattleState.newWild(game, species, level, opts)
+  local authored
+  if opts and opts.wildRecord then
+    local why;authored,why=require('src.battle.WildRecord').validate(game.data,opts.wildRecord)
+    assert(authored,why)
+    assert(authored.species==species and authored.level==level,'encounter identity mismatch')
+  end
   local self = newBattle(game)
   self.kind = "wild"
   local playerMon = Party.firstHealthy(game.save.party)
@@ -1428,6 +1436,7 @@ function BattleState.newWild(game, species, level, opts)
   if opts and opts.roamerSeed then
     Pokemon.applySeed(game.data, wild, opts.roamerSeed)
   end
+  if authored then require('src.battle.WildRecord').apply(game.data,wild,authored)end
   self.enemy = makeBattler(game.data, wild, false)
   require("src.battle.Gen2Wild").initialize(self, opts)
   if self.roamer then
@@ -2318,9 +2327,12 @@ end
 
 -- insert message right after the currently-executing queue item (the
 -- counter is reset by updateQueue before each fn item runs)
-function BattleState:sayNext(text)
+function BattleState:sayNext(text, provenance)
   self.nextInsert = (self.nextInsert or 0) + 1
-  table.insert(self.queue, self.nextInsert, { text = text })
+  local row = { text = text }
+  local sequence=GameVersion.isGen3()and package.loaded['src.core.game3.battle.anim_seq']
+  if sequence and provenance==nativeMoveUsed then sequence._nativeMessage(row)end
+  table.insert(self.queue, self.nextInsert, row)
 end
 
 -- insert a UI push right after the current queue item (dex page, the
@@ -2593,11 +2605,9 @@ function BattleState:beginMsgLine()
   self.shown[#self.shown + 1] = {}
 end
 
-function BattleState:updateQueue()
-  if self.waitingUI then
-    if self.game.stack:top() ~= self then return true end
-    self.waitingUI = nil
-  end
+-- Only display controllers live here. Command holds, HP awards, turn rows
+-- and completion remain in updateQueue, even while a mod holds presentation.
+function BattleState:updateMovePresentation()
   -- HOENN'S PARTICLES TICK BEFORE THE QUEUE'S OWN HOLD, and the whole
   -- reason the animations looked broken is that they used to tick after it.
   --
@@ -2648,11 +2658,16 @@ function BattleState:updateQueue()
       if not anim.caught then self.gen3Ball = nil end
     end
   end
+end
+
+-- Display-only waits and bar completion. Returning idle grants no command;
+-- only updateQueue may consume a battle row after this gate.
+function BattleState:updateQueuePresentation()
+  self:updateMovePresentation()
+  local source = GameVersion.isGen3() and package.loaded['src.core.game3.battle.anim']
+  if source and source._holdsNativeQueue(self) then return true end
   -- a queued hold (faint slide, hit blink) counts down before the next row
-  if self.waitFrames and self.waitFrames > 0 then
-    self.waitFrames = self.waitFrames - 1
-    return true
-  end
+  if self:stepPresentationWait() then return true end
   -- WaitForSoundToFinish (home/delay.asm:15-20) blocks until the sfx has
   -- actually stopped sounding, which is how the original gives a sound its
   -- own clear window instead of letting the next beat play over it
@@ -2682,6 +2697,16 @@ function BattleState:updateQueue()
     if self:stepExpBar() then return true end
     self.expFilling = nil
   end
+  return false
+end
+
+function BattleState:updateQueue()
+  if self.waitingUI then
+    if self.game.stack:top() ~= self then return true end
+    self.waitingUI = nil
+  end
+  if self:updateQueuePresentation() then return true end
+  if GameVersion.isGen3() and require('src.battle.Gen3VoiceoverPresentation').gate(self) then return true end
   if self.animPlaying then
     self.animPlayer:update()
     if self.animPlayer.pollEffects and self.applyAnimEffect then
@@ -2720,7 +2745,8 @@ function BattleState:updateQueue()
     if not item then return false end
     if item.fn then
       self.nextInsert = 0 -- sayNext inserts right after this item
-      item.fn()
+      local plan=GameVersion.isGen3()and package.loaded['src.battle.Gen3ActionPlan']
+      if plan then plan.run(self,item)else item.fn()end
       self.current = nil
       return true
     end
@@ -4085,6 +4111,10 @@ end
 -- simply stayed gone -- for as long as the opponent took to choose.
 function BattleState:tickFx()
   self.frame = self.frame + 1
+  if GameVersion.isGen3() then
+    require('src.battle.Gen3SelectionPresentation').update(self)
+    require('src.battle.Gen3VoiceoverPresentation').update(self)
+  end
   self:updateFx()
 end
 
@@ -4270,17 +4300,147 @@ function BattleState:touchpressed(_, px, py)
   end
   return true
 end
+function BattleState:updateBattlerPresentation(dt)
+  for _, b in activeBattlers(self) do
+    if b and b.picAnim then b.picAnim:update(dt) end
+    if b and b.monAnim then b.monAnim:update(dt) end
+  end
+end
+
+function BattleState:stepPresentationWait()
+  if self.waitFrames and self.waitFrames > 0 then
+    self.waitFrames = self.waitFrames - 1
+    return true
+  end
+  return false
+end
+
+-- Advance an ending/pose hold without executing battle commands or input.
+function BattleState:updatePresentation(dt)
+  self:tickFx()
+  self:updateBattlerPresentation(dt)
+  self:updateQueuePresentation()
+end
+
+-- Native input and borrowed source choices share these same selectors.
+-- Bodies factored from this file's existing native handlers (Cedric); the
+-- public baseline retains its own refusal messages, locks and target rules.
+function BattleState:chooseMenu(choice)
+  -- BattleMenu_Pack `.contest` (core.asm:4990): `ld a, PARK_BALL /
+  -- ld [wCurItem], a / call DoItemEffect`.  No pack, no submenu -- the
+  -- third slot IS the ball, so the item action becomes the throw.
+  if choice == "item" and self.bugContest then
+    self:bugContestBall()
+    return
+  end
+  if choice == "fight" and self.ghost then
+    self:say(Strings("%s is too\nscared to move!", self.player.name))
+    self.phase = "messages"
+    self.afterQueue = "menu"
+    self:act(function()
+      self:executeAction(self.enemy, self.player, self:enemyAction())
+    end)
+    self:act(function() self:endOfTurn() end)
+  elseif choice == "fight" then
+    -- After the menu: own trapping/Bide or foe Wrap skips the move
+    -- list and forces the locked action (core.asm:320-329)
+    local fightLock = self:fightLockedAction(self.player)
+    if fightLock then
+      self:resolveTurn(fightLock)
+      return
+    end
+    local who = self:menuBattler()
+    if not self:playerHasPP(who) then
+      -- _NoMovesLeftText, then Struggle engages
+      self:say(Strings("%s has no\nmoves left!", who.name))
+      self:chooseAction({ id = "STRUGGLE", pp = 1, struggle = true })
+      return
+    end
+    self.phase = "moveSelect"
+    self.moveIndex = math.min(self.moveIndex, #who.curMoves)
+    self.moveSwapIndex = nil
+  elseif choice == "run" then
+    self:tryRun()
+  elseif choice == "item" then
+    self:openItems()
+  else
+    self:openParty()
+  end
+  return true
+end
+function BattleState:chooseMove(index)
+  local chooser=self:menuBattler()
+  local moves=chooser.curMoves
+  self.moveIndex=index
+  local mv = moves[self.moveIndex]
+  local mvDef = mv and self.data.moves[mv.id]
+  if chooser.disabledSlot == self.moveIndex then
+    self:say(self:romText("_MoveDisabledText", "The move is\ndisabled!"))
+    self.phase = "messages"
+    self.afterQueue = "menu"
+  -- TAUNT and TORMENT refuse the move at SELECTION rather than after the
+  -- fact, the way DISABLE already does, so the player is never told to
+  -- pick again for something the game was never going to allow.
+  elseif self.bw and require("src.battle.Gen5MoveRules").moveBlocked(self, chooser, mvDef, true) then
+    -- BLACK AND WHITE: the Choice lock, Imprison, Gravity, Heal Block
+    self:say(require("src.battle.Gen5MoveRules").moveBlocked(self, chooser, mvDef, true))
+    self.phase = "messages"
+    self.afterQueue = "menu"
+  elseif self:tauntBlocks(chooser, mvDef) then
+    self:say(Strings("%s can't use\n%s after the\ntaunt!",
+                     chooser.name, mvDef and mvDef.name or mv.id))
+    self.phase = "messages"
+    self.afterQueue = "menu"
+  elseif self:tormentBlocks(chooser, mvDef) then
+    self:say(Strings("%s can't use the\nsame move twice in\na row due to the\nTORMENT!",
+                     chooser.name))
+    self.phase = "messages"
+    self.afterQueue = "menu"
+  elseif mv.pp <= 0 then
+    self:say(self:romText("_MoveNoPPText", "No PP left for\nthis move!"))
+    self.phase = "messages"
+    self.afterQueue = "menu"
+  elseif Targeting.needsChoice(self, self:choosingBattler(), mvDef) then
+    -- WHICH OF THE TWO, when the move takes one and there are two.
+    --
+    -- Emerald's selector cycles over the legal slots and names the
+    -- candidate; nothing else in the menu changes.  A single battle
+    -- never gets here, because needsChoice answers false whenever there
+    -- is only one thing to aim at -- and on the Game Boy cartridges the
+    -- moves carry no target byte at all, so it answers false for every
+    -- move in the game.
+    self.pendingMove = mv
+    self.targetChoices = Targeting.choices(self, self:menuBattler())
+    self.targetIndex = 1
+    self.phase = "targetSelect"
+  else
+    self:chooseAction(mv)
+  end
+  return true
+end
+function BattleState:chooseTarget(index)
+  local list=self.targetChoices or{}
+  self.targetIndex=index
+  local mv = self.pendingMove
+  local pick = list[self.targetIndex]
+  self.pendingMove, self.targetChoices = nil, nil
+  self.chosenTargets = self.chosenTargets or {}
+  local who = self:menuBattler()
+  if who and who.position then self.chosenTargets[who.position] = pick end
+  self:chooseAction(mv)
+  return true
+end
+
 function BattleState:update(dt)
+  local shortcuts=package.loaded['src.mods.FeatureOptions']and require('src.battle.QuickItem')
+  local quick=shortcuts and shortcuts.request(self)
   self:tickFx()
   -- one sample a second into the fight, while it is still on screen
   self._stadiumReportTicks = (self._stadiumReportTicks or 0) + 1
   if self._stadiumReportTicks == 60 then self:reportStadiumBattle("mid") end
   -- Crystal pic animations run off the wall clock like every other battle
   -- pic effect; a Gold/Silver battler has no picAnim and this is a no-op.
-  for _, b in activeBattlers(self) do
-    if b and b.picAnim then b.picAnim:update(dt) end
-    if b and b.monAnim then b.monAnim:update(dt) end
-  end
+  self:updateBattlerPresentation(dt)
   local input = self.game.input
 
   -- L PUTS THE BOTTOM SCREEN AWAY, AND BRINGS IT BACK.
@@ -4455,6 +4615,7 @@ function BattleState:update(dt)
   end
 
   if self.phase == "menu" then
+    if quick and shortcuts.dispatch(self,quick)then return end
     -- WHO THIS MENU IS FOR, when the left flank is gone.
     --
     -- `self.player` is the left flank, and in a double battle that flank can
@@ -4542,47 +4703,7 @@ function BattleState:update(dt)
       end
     end
     if input:wasPressed("a") then
-      local choice = self:menuActions()[self.menuIndex]
-      -- BattleMenu_Pack `.contest` (core.asm:4990): `ld a, PARK_BALL /
-      -- ld [wCurItem], a / call DoItemEffect`.  No pack, no submenu -- the
-      -- third slot IS the ball, so the item action becomes the throw.
-      if choice == "item" and self.bugContest then
-        self:bugContestBall()
-        return
-      end
-      if choice == "fight" and self.ghost then
-        self:say(Strings("%s is too\nscared to move!", self.player.name))
-        self.phase = "messages"
-        self.afterQueue = "menu"
-        self:act(function()
-          self:executeAction(self.enemy, self.player, self:enemyAction())
-        end)
-        self:act(function() self:endOfTurn() end)
-      elseif choice == "fight" then
-        -- After the menu: own trapping/Bide or foe Wrap skips the move
-        -- list and forces the locked action (core.asm:320-329)
-        local fightLock = self:fightLockedAction(self.player)
-        if fightLock then
-          self:resolveTurn(fightLock)
-          return
-        end
-        local who = self:menuBattler()
-        if not self:playerHasPP(who) then
-          -- _NoMovesLeftText, then Struggle engages
-          self:say(Strings("%s has no\nmoves left!", who.name))
-          self:chooseAction({ id = "STRUGGLE", pp = 1, struggle = true })
-          return
-        end
-        self.phase = "moveSelect"
-        self.moveIndex = math.min(self.moveIndex, #who.curMoves)
-        self.moveSwapIndex = nil
-      elseif choice == "run" then
-        self:tryRun()
-      elseif choice == "item" then
-        self:openItems()
-      else
-        self:openParty()
-      end
+      self:chooseMenu(self:menuActions()[self.menuIndex])
     end
     return
   end
@@ -4616,50 +4737,7 @@ function BattleState:update(dt)
         self.moveSwapIndex = nil
         return
       end
-      local mv = moves[self.moveIndex]
-      local mvDef = mv and self.data.moves[mv.id]
-      if chooser.disabledSlot == self.moveIndex then
-        self:say(self:romText("_MoveDisabledText", "The move is\ndisabled!"))
-        self.phase = "messages"
-        self.afterQueue = "menu"
-      -- TAUNT and TORMENT refuse the move at SELECTION rather than after the
-      -- fact, the way DISABLE already does, so the player is never told to
-      -- pick again for something the game was never going to allow.
-      elseif self.bw and require("src.battle.Gen5MoveRules").moveBlocked(self, chooser, mvDef, true) then
-        -- BLACK AND WHITE: the Choice lock, Imprison, Gravity, Heal Block
-        self:say(require("src.battle.Gen5MoveRules").moveBlocked(self, chooser, mvDef, true))
-        self.phase = "messages"
-        self.afterQueue = "menu"
-      elseif self:tauntBlocks(chooser, mvDef) then
-        self:say(Strings("%s can't use\n%s after the\ntaunt!",
-                         chooser.name, mvDef and mvDef.name or mv.id))
-        self.phase = "messages"
-        self.afterQueue = "menu"
-      elseif self:tormentBlocks(chooser, mvDef) then
-        self:say(Strings("%s can't use the\nsame move twice in\na row due to the\nTORMENT!",
-                         chooser.name))
-        self.phase = "messages"
-        self.afterQueue = "menu"
-      elseif mv.pp <= 0 then
-        self:say(self:romText("_MoveNoPPText", "No PP left for\nthis move!"))
-        self.phase = "messages"
-        self.afterQueue = "menu"
-      elseif Targeting.needsChoice(self, self:choosingBattler(), mvDef) then
-        -- WHICH OF THE TWO, when the move takes one and there are two.
-        --
-        -- Emerald's selector cycles over the legal slots and names the
-        -- candidate; nothing else in the menu changes.  A single battle
-        -- never gets here, because needsChoice answers false whenever there
-        -- is only one thing to aim at -- and on the Game Boy cartridges the
-        -- moves carry no target byte at all, so it answers false for every
-        -- move in the game.
-        self.pendingMove = mv
-        self.targetChoices = Targeting.choices(self, self:menuBattler())
-        self.targetIndex = 1
-        self.phase = "targetSelect"
-      else
-        self:chooseAction(mv)
-      end
+      self:chooseMove(self.moveIndex)
     end
     return
   end
@@ -4680,13 +4758,7 @@ function BattleState:update(dt)
       self.pendingMove, self.targetChoices = nil, nil
       self.phase = "moveSelect"
     elseif input:wasPressed("a") then
-      local mv = self.pendingMove
-      local pick = list[self.targetIndex]
-      self.pendingMove, self.targetChoices = nil, nil
-      self.chosenTargets = self.chosenTargets or {}
-      local who = self:menuBattler()
-      if who and who.position then self.chosenTargets[who.position] = pick end
-      self:chooseAction(mv)
+      self:chooseTarget(self.targetIndex)
     end
     return
   end
@@ -4973,7 +5045,7 @@ function BattleState:queuePokedudeVoices(indices)
       pd.voiceDone[index] = true
       local text = self:pokedudeVoice(index)
       if type(text) == "string" and text ~= "" then
-        self:say(text)
+        require('src.battle.Gen3VoiceoverPresentation').queue(self,text,pd.lesson=='status'and index==2)
         queued = true
       end
     end
@@ -5736,8 +5808,12 @@ function BattleState:resolveTurn(playerAction)
   self.phase = "messages"
   self.afterQueue = "menu"
 
-  for _, entry in ipairs(order) do
-    self:act(function()
+  local nativePlan
+  if GameVersion.isGen3()and package.loaded['src.core.game3.battle']then
+    nativePlan=require('src.battle.Gen3ActionPlan').begin(self,order)
+  end
+  for slot, entry in ipairs(order) do
+    local nativeAction=function()
       -- WHO IT HITS IS DECIDED HERE, not when the turn was sorted.
       --
       -- Between the sort and this entry running, the target can faint --
@@ -5760,11 +5836,14 @@ function BattleState:resolveTurn(playerAction)
                  or self:defaultTargetFor(entry[1])
       end
       self:executeAction(entry[1], target, entry[3])
-    end)
+    end
+    self:act(nativeAction)
+    if nativePlan then require('src.battle.Gen3ActionPlan').attach(self,nativePlan,self.queue[#self.queue],slot,nativeAction)end
   end
   self:act(function()
     -- the collected choices belong to the turn that just ran, not the next
     self.pendingActions, self.chosenTargets = nil, nil
+    if nativePlan then require('src.battle.Gen3ActionPlan').retire(self)end
     self:endOfTurn()
   end)
 end
@@ -8151,7 +8230,7 @@ function BattleState:performMove(user, target, moveInst, isCalled, suppressAnima
 
   self.moveAnimRow = nil
   if not (user.thrashTurns and moveInst == user.thrashMove and user.thrashAnnounced) then
-    self:sayNext(self:romText("_ItemUseText001", "%s\nused %s!", displayName(user), move.name))
+    self:sayNext(self:romText("_ItemUseText001", "%s\nused %s!", displayName(user), move.name), nativeMoveUsed)
     -- the move's animation plays right after the announcement; the
     -- damage path attaches the target's hit blink to this row so the
     -- blink follows the animation (pokered's order).  Mimic is the
@@ -8163,6 +8242,8 @@ function BattleState:performMove(user, target, moveInst, isCalled, suppressAnima
                            attackerPosition = user.position,
                            targetPosition = target and target.position,
                            animContext = animContext }
+      local sequence=GameVersion.isGen3()and package.loaded['src.core.game3.battle.anim_seq']
+      if sequence then sequence._nativeMove(self.moveAnimRow)end
       table.insert(self.queue, self.nextInsert, self.moveAnimRow)
     end
   end
@@ -10699,7 +10780,7 @@ function BattleState:finish()
     local text = index and self:pokedudeVoice(index)
     if type(text) == "string" and text ~= "" then
       pd.voiceDone[index] = true
-      self:say(text)
+      require('src.battle.Gen3VoiceoverPresentation').queue(self,text,false)
       self.phase = "messages"
       self.afterQueue = "finish"
       return
@@ -11433,6 +11514,11 @@ function BattleState:gen3AnimSquash(battler)
 end
 
 function BattleState:drawBattlerPic(battler, x, y, scale)
+  if GameVersion.isGen3() then
+    local selection=require('src.battle.Gen3SelectionPresentation')
+    if selection.hidden(self,battler) then return end
+    y=y+selection.offset(self,'mon',battler)
+  end
   if self:gen3AnimMonBgHidden(battler) then return end
   local angle, rise = self:gen3AnimRotate(battler)
   local sqx, sqy = self:gen3AnimSquash(battler)
@@ -12855,4 +12941,67 @@ function BattleState:drawClassic()
   end
 end
 
+-- Source wrappers observe the real GBA owner. Unrequested modules and other
+-- generations keep the direct native path; there is no additional clock.
+do
+  local unpack_=table.unpack or unpack
+  local function pack(...)return{n=select('#',...),...}end
+  local update, draw, field, exit, enter = BattleState.update, BattleState.draw,
+    BattleState.drawBattleField, BattleState.exit, BattleState.enter
+  local Clock = require('src.battle.PresentationClock')
+  for _, name in ipairs{'tickFx','updateBattlerPresentation','updateMovePresentation',
+                        'stepHPDrain','stepExpBar','stepPresentationWait','updateQueuePresentation'} do
+    local body = BattleState[name]
+    BattleState[name] = function(self, ...)
+      return Clock.once(self, name, body, ...)
+    end
+  end
+  BattleState._drawNative = draw
+  local battlerDraw = BattleState.drawBattlerPic
+  function BattleState:drawBattlerPic(battler, ...)
+    local anim = GameVersion.isGen3() and package.loaded['src.core.game3.battle.anim']
+    if anim then return anim._drawBattler(self, battler, battlerDraw, ...) end
+    return battlerDraw(self, battler, ...)
+  end
+  local chooseAction=BattleState.chooseAction
+  function BattleState:chooseAction(action)
+    local ui=GameVersion.isGen3() and package.loaded['src.core.game3.battle.ui']
+    if ui then return ui._nativeCommand(self,action,chooseAction) end
+    return chooseAction(self,action)
+  end
+  function BattleState:enter()
+    enter(self)
+    local source = GameVersion.isGen3() and package.loaded['src.core.game3.battle']
+    if source then return source._nativeEnter(self) end
+  end
+  function BattleState:update(dt)
+    local source = GameVersion.isGen3() and package.loaded['src.core.game3.battle']
+    local anim = source and package.loaded['src.core.game3.battle.anim']
+    if anim then
+      return Clock.run(self, dt, function()
+        local result=pack(source._nativeUpdate(self, dt, update))
+        anim._nativeAfterUpdate(self)
+        return unpack_(result,1,result.n)
+      end)
+    end
+    if source then return source._nativeUpdate(self, dt, update) end
+    return update(self, dt)
+  end
+  function BattleState:draw()
+    local source = GameVersion.isGen3() and package.loaded['src.core.game3.battle']
+    if source then return source._nativeDraw(self, draw) end
+    return draw(self)
+  end
+  function BattleState:drawBattleField()
+    local source = GameVersion.isGen3() and package.loaded['src.core.game3.battle']
+    if source then return source._nativeField(self, field) end
+    return field(self)
+  end
+  function BattleState:exit()
+    local source = package.loaded['src.core.game3.battle']
+    if source then source._nativeExit(self) end
+    return exit(self)
+  end
+end
+
 return BattleState
diff --git a/src/battle/CaughtMarker.lua b/src/battle/CaughtMarker.lua
new file mode 100644
index 000000000..b76d76305
--- /dev/null
+++ b/src/battle/CaughtMarker.lua
@@ -0,0 +1,82 @@
+-- Eligibility and strict boolean verdict shared by the native GB/GBA renderers.
+local Runtime = require("src.mods.Runtime")
+local Version = require("src.core.GameVersion")
+local M = {}
+function M.caught(game, species)
+  local dex = game and game.save and game.save.pokedex
+  return not not (dex and ((dex.owned and dex.owned[species]) or (dex.caught and dex.caught[species])))
+end
+function M.visible(battle, battler)
+  local gen = Version.generation()
+  battler = battler or battle.enemy
+  if
+    gen > 3
+    or not battler
+    or battler.isPlayer
+    or not battler.mon
+    or (battle.kind ~= "wild" and battle.kind ~= "safari")
+    or not M.caught(battle.game, battler.mon.species)
+  then
+    return false
+  end
+  -- Gold latches the already-caught bit when the encounter starts, then checks
+  -- the active species again when drawing (e.g. after Transform).
+  if gen == 2 and not battle.caughtMark then
+    return false
+  end
+  if
+    gen == 3
+    and (
+      battle.demo
+      or battle.dudeDemo
+      or battle.pokedudeDemo
+      or battle.firstBattle
+      or (battle.ghost and not battle.ghostUnveiled)
+    )
+  then
+    return false
+  end
+  local default = gen > 1
+  if not Runtime.wantsHook("battle.caught_marker_visible") then
+    return default
+  end
+  return Runtime.call("battle.caught_marker_visible", function()
+    return default
+  end, battle) == true
+end
+-- Legacy standalone compositors can carry a partial battle fixture.
+function M.forBattle(battle, battler)
+  local method = battle.caughtMarkerVisible
+  if type(method) == "function" then
+    return method(battle, battler)
+  end
+  return M.visible(battle, battler)
+end
+-- The GBA renderer creates this element for a presented healthbox and retains
+-- its verdict until that presentation changes, as in the reference engine.
+function M.gbaVisible(battle, battler)
+  if not battler or battler.shownStatus or (battle.isDouble and battle:isDouble()) then
+    return false
+  end
+  local old = battler._caughtIcon
+  local species = battler.mon and battler.mon.species
+  if
+    old
+    and old.mon == battler.mon
+    and old.species == species
+    and old.name == battler.name
+    and old.status == battler.shownStatus
+  then
+    return old.show
+  end
+  local show = M.visible(battle, battler)
+  battler._caughtIcon = {
+    mon = battler.mon,
+    species = species,
+    name = battler.name,
+    status = battler.shownStatus,
+    show = show,
+  }
+  return show
+end
+return M
diff --git a/src/battle/Damage.lua b/src/battle/Damage.lua
index 2664e4b17..265bac42b 100644
--- a/src/battle/Damage.lua
+++ b/src/battle/Damage.lua
@@ -81,6 +81,12 @@ Damage.stageOf = stageOf
 -- (1/16, 1/8, 1/4, 1/3, 1/2).  Speed stops mattering entirely, which is why a
 -- ruleset that sets critStages cannot just tune the Gen 1 numbers.
 local CRIT_STAGE_DEN = { [0] = 16, 8, 4, 3, 2 }
+-- Detached observations share the calculation's authority. Source queries
+-- cannot change native critical rates by mutating a returned table.
+function Damage.gen3CritDenominators()
+  local out={};for stage,den in pairs(CRIT_STAGE_DEN)do out[stage]=den end
+  return out
+end
 
 function Damage.critRoll(ruleset, attacker, moveId, rng, highCrit, data)
   rng = rng or love.math.random
diff --git a/src/battle/Experience.lua b/src/battle/Experience.lua
index 2c0dc6401..701c78196 100644
--- a/src/battle/Experience.lua
+++ b/src/battle/Experience.lua
@@ -122,6 +122,15 @@ function Experience.apply(data, mon, defeatedDef, level, isTrainer,
   end
   -- Lucky Egg is a per-recipient x1.5 held-item boost in Generation II.
   gained = HeldItems.modifyExperience(data, mon, gained)
+  return Experience.add(data, mon, gained)
+end
+
+-- Shared absolute award: scripted rewards use native growth, stats and events.
+-- Defeat-only EVs, held boosts and exp.gain remain in apply above.
+function Experience.add(data, mon, gained)
+  assert(type(gained)=='number'and gained==gained and gained>=0 and gained%1==0,'invalid experience award')
+  local speciesDef=require('src.pokemon.Gen4Forms').definition(data,mon)
+  local consts=data.constants
   mon.exp = mon.exp + gained
 
   local cap = consts and consts.levelCap or 100
diff --git a/src/battle/Gen3ActionPlan.lua b/src/battle/Gen3ActionPlan.lua
new file mode 100644
index 000000000..5527e2e79
--- /dev/null
+++ b/src/battle/Gen3ActionPlan.lua
@@ -0,0 +1,126 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observations of the native turn order and its actual queue rows. This
+-- ledger never starts, removes, schedules or reorders an action on its own.
+local Version=require('src.core.GameVersion')
+local Iteration=require('src.compat.gen1.TableIteration')
+local M={}
+local actionKeys={'kind','meta','move','user','target','userId','targetId','order'}
+local function actionPairs(_,source)
+  local out={}
+  for _,key in ipairs(actionKeys)do out[key]=source[key]end
+  return out
+end
+local ABSENT={}
+local function loader(game)
+  local value=game and game.mods
+  return value==nil and ABSENT or value
+end
+local function valid(b,p)
+  if not p or p.retired then return false end
+  if not b or b._sourceActionPlan~=p or b.result then p.retired=true;return false end
+  local r=p.refs;local game=r[2]
+  if r[1]~=b or not game or b.game~=game or b.data~=r[3]or game.data~=r[3]
+    or game.save~=r[4]or loader(game)~=r[5]or game.stack~=r[6]
+    or b.queue~=r[7]or Version.get()~=p.edition or not Version.isGen3()then p.retired=true;return false end
+  for _,state in ipairs(game.stack and game.stack.states or{})do if state==b then return true end end
+  p.retired=true;return false
+end
+function M.begin(b,order)
+  if not Version.isGen3()then return end
+  M.retire(b)
+  local game=b.game
+  local p={order=order,rows={},fns={},completed={},byRow=setmetatable({},{__mode='k'}),views=setmetatable({},{__mode='k'}),edition=Version.get(),
+    refs=setmetatable({b,game,b.data,game and game.save,loader(game),game and game.stack,b.queue},{__mode='v'})}
+  b._sourceActionPlan=p
+  return p
+end
+function M.attach(b,p,row,index,nativeFn)
+  if b._sourceActionPlan~=p then return false end
+  assert(p.order[index],'native action does not belong to its turn')
+  -- A separate native act wrapper may replace/suppress the queued body.
+  -- Keep that behavior; do not mislabel another row as this native action.
+  if type(row)~='table'or row.fn~=nativeFn or p.byRow[row]then M.retire(b);p.retired=true;return false end
+  p.rows[index]=row;p.fns[index]=nativeFn;p.byRow[row]=index
+  return true
+end
+function M.retire(b)
+  local p=b._sourceActionPlan
+  if p then p.retired=true end
+  b._sourceActionPlan=nil
+end
+function M.run(b,item)
+  local p=b._sourceActionPlan
+  if not(valid(b,p)and p.byRow[item])then return item.fn()end
+  local index=p.byRow[item]
+  if p.completed[index]or item.fn~=p.fns[index]then M.retire(b);return item.fn()end
+  -- This is the same native fn invocation. An exception must retire its
+  -- observation instead of leaving a falsely executing action behind.
+  p.current=item
+  local sequence=package.loaded['src.core.game3.battle.anim_seq']
+  local ok,why
+  if sequence then ok,why=pcall(sequence._nativeAction,b,item,item.fn)
+  else ok,why=pcall(item.fn)end
+  p.current=nil
+  if not ok then M.retire(b);error(why,0)end
+  p.completed[index]=true
+end
+local function actionValid(b,p,index)
+  if not p.completed[index]and p.rows[index].fn~=p.fns[index]then M.retire(b);return false end
+  return true
+end
+function M.cursor(b)
+  local p=b and b._sourceActionPlan
+  if not valid(b,p)then return 0 end
+  local index=p.byRow[p.current or b.queue[1]]
+  if not index or p.completed[index]or not actionValid(b,p,index)then return 0 end
+  return index
+end
+local function side(b,actor)
+  if actor==b.player then return 'player'end
+  if actor==b.enemy then return 'enemy'end
+end
+local function actionView(b,p,admission,index)
+  local views=p.views[admission]
+  if not views then views={};p.views[admission]=views end
+  local old=views[index];if old then return old end
+  local refs=setmetatable({b,p,admission},{__mode='v'})
+  local retired=false
+  local view=setmetatable({}, {
+    __index=function(_,key)
+      local screen,plan,current=refs[1],refs[2],refs[3]
+      if retired then return nil end
+      if not valid(screen,plan)or not current or current.retired or current.screen~=screen
+        or not current.ids:valid()or not actionValid(screen,plan,index)then retired=true;return nil end
+      local entry=plan.order[index];local action=entry and entry[3]
+      if not action then return nil end
+      if key=='kind'then return not action.special and action.id~=nil and'move'or'meta'end
+      if key=='meta'then return not not action.special or action.id==nil or not side(screen,entry[1])or not side(screen,entry[2])end
+      if key=='move'then return not action.special and action.id or nil end
+      if key=='user'then return side(screen,entry[1])end
+      if key=='target'then return side(screen,entry[2])end
+      if key=='userId'then return entry[1]and entry[1].position end
+      if key=='targetId'then return entry[2]and entry[2].position end
+      if key=='order'then return index end
+    end,
+    __newindex=function()error('native action observation is read-only',2)end,
+    __metatable='native action observation',
+  })
+  -- Use the shared LuaJIT pairs/next authority. The reader has no closure
+  -- over this view, its native battle or its source admission.
+  Iteration.register(view,actionPairs)
+  views[index]=view
+  return view
+end
+function M.snapshot(b,admission)
+  local p=b and b._sourceActionPlan
+  if not valid(b,p)or not admission or admission.retired or admission.screen~=b or not admission.ids:valid()then return end
+  local out={}
+  for i=1,#p.order do
+    if p.rows[i]then
+      if not actionValid(b,p,i)then return nil end
+      out[i]=actionView(b,p,admission,i)
+    end
+  end
+  return out
+end
+return M
diff --git a/src/battle/Gen3Battle.lua b/src/battle/Gen3Battle.lua
index dcaa62f71..8e6b32fd3 100644
--- a/src/battle/Gen3Battle.lua
+++ b/src/battle/Gen3Battle.lua
@@ -36,6 +36,7 @@
 -- the window edges fall.  Those are staging, and they are marked below.
 
 local Assets = require("src.render.Assets")
+local Selection = require("src.battle.Gen3SelectionPresentation")
 local Logger = require("src.core.Logger")
 local Theme = require("src.ui.Theme")
 local Font = require("src.render.Font")
@@ -217,45 +218,15 @@ end
 local stripCache = {}
 local stripQuads = {}
 local bandQuads = setmetatable({}, { __mode = "k" })
-local moveBgIndexShaderCache = nil
-
-local function moveBgIndexShader()
-  if moveBgIndexShaderCache ~= nil then return moveBgIndexShaderCache or nil end
-  if not (love.graphics and love.graphics.newShader) then
-    moveBgIndexShaderCache = false
-    return nil
-  end
-  local uniforms, choices = {}, {}
-  for i = 0, 15 do uniforms[#uniforms + 1] = ("extern vec3 c%d;"):format(i) end
-  for i = 0, 15 do
-    choices[#choices + 1] = ((i == 0) and "if" or "else if")
-      .. (" (idx < %.1f) rgb = c%d;"):format(i + 0.5, i)
-  end
-  local src = table.concat(uniforms, "\n") .. [[
-    vec4 effect(vec4 colour, Image tex, vec2 uv, vec2 screen) {
-      vec4 px = Texel(tex, uv);
-      number idx = floor(px.r * 15.0 + 0.5);
-      vec3 rgb = c0;
-  ]] .. table.concat(choices, "\n") .. [[
-      return vec4(rgb, px.a) * colour;
-    }
-  ]]
-  local ok, shader = pcall(love.graphics.newShader, src)
-  moveBgIndexShaderCache = ok and shader or false
-  return ok and shader or nil
-end
+local moveBgPalette = require('src.render.Gen3IndexedPalette').new()
 
 local function drawIndexedMoveBg(g, battle, layer)
   if not (layer and layer.indexed and layer.indexImage and layer.palette) then
     return false
   end
   local okImage, image = pcall(Assets.image, layer.indexImage)
-  local shader = moveBgIndexShader()
+  local shader = moveBgPalette:sendNormalized(layer.palette)
   if not (okImage and image and shader) then return false end
-  for i = 0, 15 do
-    local c = layer.palette[i + 1] or { 0, 0, 0 }
-    shader:send("c" .. i, { c[1] or 0, c[2] or 0, c[3] or 0 })
-  end
   local oldShader = g.getShader and g.getShader() or nil
   local sx, sy, sw, sh
   if g.getScissor then sx, sy, sw, sh = g.getScissor() end
@@ -900,7 +871,7 @@ local function levelAt(battle, battler, x, y, text)
   end
 end
 
-local function drawStatusPanel(battle, battler, x, y, player)
+local function drawStatusPanelBody(battle, battler, x, y, player)
   local record = hudRecord(battle)
   local images = record and record.images or {}
   local panel = hudImage(player and images.player or images.opponent)
@@ -1204,6 +1175,16 @@ end
 --
 -- AND THE FOE'S ROW IS A TRAINER'S ONLY.  A wild battle has no party to show,
 -- so BattleIntroDrawPartySummaryScreens raises the player's alone.
+-- Expose the same native painter to source healthbox captures.
+Gen3Battle.drawStatusPanel=drawStatusPanelBody
+local function drawStatusPanel(battle,battler,x,y,player)
+  local source=package.loaded['src.core.game3.battle.healthbox']
+  if source then return source._nativeDraw(battle,battler,x,y,player,function()
+    return drawStatusPanelBody(battle,battler,x,y,player)
+  end)end
+  return drawStatusPanelBody(battle,battler,x,y,player)
+end
+
 local function summaryRecord(battle)
   local record = hudRecord(battle)
   local summary = record and record.partySummary
@@ -1281,49 +1262,62 @@ Gen3Battle.SUMMARY_BALL_FRAMES = 4
 -- twenty-four off the RIGHT of it.  So on a wider surface the foe's row does
 -- not move and the player's moves out by the whole of the extra width, which
 -- is the flip flag this function already reads for the mirroring.
-local function drawSummaryRow(summary, side, party, age, extra)
+local function drawSummaryRow(summary, side, party, age, extra, presentation)
   local edge = side.flip and 0 or math.floor(tonumber(extra) or 0)
   local bar, balls = hudImage(summary.bar), hudImage(summary.balls)
-  if not (bar and balls) then return end
+  if not (bar and balls) then return false end
   local cell = summary.ballSide or 8
   local barW = summary.barWidth or bar:getWidth()
+  local barScale=barW/bar:getWidth()
+  assert(not summary.barHeight or bar:getHeight()*barScale==summary.barHeight,'invalid native party bar density')
   -- how far in the row has travelled: 0 is fully off its own edge, 1 home
-  local slide = Gen3Battle.SUMMARY_SLIDE_FRAMES
-  local p = 1
-  if age and slide > 0 then p = math.max(0, math.min(1, age / slide)) end
-  -- eased so it settles rather than stopping dead
-  local eased = 1 - (1 - p) * (1 - p)
   -- the foe's row lives on the left of the screen and enters from there; the
   -- player's lives on the right and enters from the right
-  local dir = side.flip and -1 or 1
-  local dx = dir * (1 - eased) * (barW + 16)
-  love.graphics.setColor(1, 1, 1, 1)
+  local slide = Gen3Battle.SUMMARY_SLIDE_FRAMES
+  local dx = Gen3Battle.summaryRowOffset(summary,side,age)
+  local offsetX,offsetY=0,0
+  local alpha=1
+  if presentation then
+    local anchor=side.barX+(side.flip and barW or edge)
+    offsetX=(presentation.x or anchor)-anchor
+    offsetY=(presentation.y or side.barY)-side.barY
+    dx=presentation.ox==nil and dx or presentation.ox
+    alpha=presentation.alpha or 1
+  end
+  love.graphics.setColor(1, 1, 1, alpha)
   -- the strip, mirrored for the foe: drawn from its far corner with a
   -- negative x scale, which is what ST_OAM_HFLIP does to the four pieces
   if side.flip then
-    love.graphics.draw(bar, side.barX + barW + dx, side.barY, 0, -1, 1)
+    love.graphics.draw(bar, side.barX + barW + dx + offsetX, side.barY + offsetY, 0, -barScale, barScale)
   else
-    love.graphics.draw(bar, side.barX + edge + dx, side.barY)
+    if barScale==1 then love.graphics.draw(bar, side.barX + edge + dx + offsetX, side.barY + offsetY)
+    else love.graphics.draw(bar, side.barX + edge + dx + offsetX, side.barY + offsetY,0,barScale,barScale)end
   end
   -- ...and the icons, laid out from the middle of the screen outwards
-  local slots = Gen3Battle.summarySlots(summary, side, party)
+  local slots = presentation and presentation.slots or Gen3Battle.summarySlots(summary, side, party)
   local count = summary.count or 6
   local icons = summary.icons or {}
   local bw, bh = balls:getDimensions()
+  assert(bh>0 and bw>=bh and bw%bh==0,'invalid native party icon density')
+  local ballScale=cell/bh
   for slot = 1, count do
     local column = icons[slots[slot] or "empty"]
     -- each icon waits for the bar to land and then for its own turn; with no
     -- age at all (a caller that does not track one) every icon is already down
     local due = slide + (slot - 1) * Gen3Battle.SUMMARY_BALL_FRAMES
-    if column and (age == nil or age >= due) then
-      local quad = love.graphics.newQuad(column * cell, 0, cell, cell,
+    local hidden=presentation and presentation.ballHidden
+    local show=hidden and not hidden[slot]or not hidden and(age==nil or age>=due)
+    if column and show then
+      local quad = love.graphics.newQuad(column * bh, 0, bh, bh,
                                          bw, bh)
-      love.graphics.draw(balls, quad,
-                         side.ballX + edge
-                           + (slot - 1) * (summary.step or 10) + dx,
-                         side.ballY)
+      local ballDx=presentation and presentation.ballOx and(presentation.ballOx[slot]or 0)or dx
+      local x=side.ballX+edge+(slot-1)*(summary.step or 10)+ballDx+offsetX
+      local y=side.ballY+offsetY
+      if ballScale==1 then love.graphics.draw(balls,quad,x,y)
+      else love.graphics.draw(balls,quad,x,y,0,ballScale,ballScale)end
     end
   end
+  return true
 end
 
 -- Both teams when two trainers walked up; see BattleState:foeSummaryParty.
@@ -1336,6 +1330,61 @@ local function foeRowParty(battle)
   return battle.enemyParty
 end
 
+function Gen3Battle.partySummary(battle,player)
+  if not battle.introBalls then return end
+  local summary=summaryRecord(battle)
+  local row=summary and summary[player and'player'or'opponent']
+  if not row then return end
+  if not player and(not battle.enemyParty or battle.kind~='trainer'and battle.kind~='link')then return end
+  return summary,row,player and(battle.playerParty or battle.game.save.party)or foeRowParty(battle)
+end
+function Gen3Battle.summaryBarWidth(summary)
+  local bar=hudImage(summary.bar)
+  return summary.barWidth or bar and bar:getWidth()
+end
+function Gen3Battle.summaryRowOffset(summary,side,age)
+  local width=Gen3Battle.summaryBarWidth(summary)
+  if not width then return nil end
+  local p=1
+  if age and Gen3Battle.SUMMARY_SLIDE_FRAMES>0 then p=math.max(0,math.min(1,age/Gen3Battle.SUMMARY_SLIDE_FRAMES))end
+  local eased=1-(1-p)*(1-p)
+  return(side.flip and -1 or 1)*(1-eased)*(width+16)
+end
+-- Presentation overrides borrow the same row geometry, icon packing and
+-- first-paint stamp as native HUDs. No battle/input clock is advanced here.
+function Gen3Battle.paintPartySummary(battle,player,presentation)
+  local summary,row,party=Gen3Battle.partySummary(battle,player)
+  if not summary then return false end
+  if presentation then
+    assert(type(presentation)=='table','invalid party summary presentation')
+    for _,key in ipairs{'x','y','ox','alpha'}do
+      local v=presentation[key]
+      assert(v==nil or type(v)=='number'and v==v and math.abs(v)<math.huge,'invalid party summary '..key)
+    end
+    assert(presentation.alpha==nil or presentation.alpha>=0 and presentation.alpha<=1,'invalid party summary alpha')
+    assert(not presentation.extended,'extended native party summary unavailable')
+    for _,key in ipairs{'slots','ballHidden','ballOx'}do
+      assert(presentation[key]==nil or type(presentation[key])=='table','invalid party summary '..key)
+    end
+    for i=1,summary.count or 6 do
+      local key=presentation.slots and presentation.slots[i]
+      assert(key==nil or type(key)=='string'and(summary.icons or{})[key]~=nil,'invalid party summary icon')
+      local hidden=presentation.ballHidden and presentation.ballHidden[i]
+      assert(hidden==nil or type(hidden)=='boolean','invalid party summary hidden flag')
+      local offset=presentation.ballOx and presentation.ballOx[i]
+      assert(offset==nil or type(offset)=='number'and offset==offset and math.abs(offset)<math.huge,'invalid party summary ball offset')
+    end
+  end
+  if battle.introBallsFrom==nil then battle.introBallsFrom=battle.frame or 0 end
+  local age=battle.frame and(battle.frame-battle.introBallsFrom)or nil
+  return drawSummaryRow(summary,row,party,age,Gen3Battle.extra(battle),presentation)
+end
+function Gen3Battle.drawPartySummary(battle,player)
+  local draw=function()return Gen3Battle.paintPartySummary(battle,player)end
+  local chrome=package.loaded['src.ui.game3.battle_chrome']
+  if chrome and chrome._nativePartySummary then return chrome._nativePartySummary(battle,player,draw)end
+  return draw()
+end
 local function drawIntroBalls(battle)
   if not battle.introBalls then return end
   if not require("src.core.GameVersion").isGen3() then
@@ -1347,27 +1396,8 @@ local function drawIntroBalls(battle)
                        8)
     return
   end
-  local summary = summaryRecord(battle)
-  if not summary then return end
-  -- WHEN THE ROWS WENT UP, stamped on the first frame they are actually
-  -- drawn rather than on the frame the flag was raised: the flag is set in
-  -- BattleState:enter, while the two silhouettes are still sliding in and
-  -- these rows are not on screen yet, so counting from there would have the
-  -- whole slide happen behind the intro and land the rows already home.
-  if battle.introBallsFrom == nil then
-    battle.introBallsFrom = battle.frame or 0
-  end
-  local age = battle.frame and (battle.frame - battle.introBallsFrom) or nil
-  if battle.enemyParty and summary.opponent
-      and (battle.kind == "trainer" or battle.kind == "link") then
-    drawSummaryRow(summary, summary.opponent, foeRowParty(battle), age,
-                   Gen3Battle.extra(battle))
-  end
-  if summary.player then
-    drawSummaryRow(summary, summary.player,
-                   battle.playerParty or battle.game.save.party, age,
-                   Gen3Battle.extra(battle))
-  end
+  Gen3Battle.drawPartySummary(battle,false)
+  Gen3Battle.drawPartySummary(battle,true)
 end
 
 -- RECONSTRUCTED: the foe's box upper left, the player's lower right, which
@@ -1439,22 +1469,69 @@ local function healthboxAt(battle, key, panel, fx, fy)
   return Gen3Battle.hudPlace(constants, which, h, Gen3Battle.extra(battle))
 end
 
+-- Geometry comes from the same panel images and placement records as HUDs.
+function Gen3Battle.healthboxGeometry(battle,id)
+  local player=id%2==0
+  local record=hudRecord(battle);local images=record and record.images or{}
+  local key=player and 'player' or 'opponent'
+  if id>=2 then key=key..'Doubles' end
+  local image=hudImage(images[key]or images[player and 'player'or'opponent'])
+  local h=image and image:getHeight()or 32
+  if battle:isDouble()then
+    local keys={[0]='playerLeft','opponentLeft','playerRight','opponentRight'}
+    local c=battle.data.constants.gen3BattlerCoords
+    local pos=c and c.healthbox and c.healthbox[keys[id]]
+    if not pos then return nil,'native double healthbox placement unavailable'end
+    return pos.x-32+(player and Gen3Battle.extra(battle)or 0),pos.y-math.floor(h/2),h
+  end
+  if id>=2 then return nil,'absent single-battle slot'end
+  local x,y=healthboxAt(battle,player and 'singlesPlayer'or'singlesOpponent',image)
+  return x,y,h
+end
+
+-- The same native visibility predicate serves drawing and typed observers.
+function Gen3Battle.healthboxVisible(battle,id,slide,showStatus)
+  if showStatus==nil then showStatus=true end
+  if not showStatus or slide~=0 then return false end
+  local double=battle.isDouble and battle:isDouble()
+  local b=id==0 and battle.player or id==1 and battle.enemy or battle:battlerAt(id)
+  if not b or id>=2 and not double then return false end
+  if double then
+    if not b.mon or b.fainted then return false end
+    if id%2==0 then return not battle.showPlayerBack end
+  elseif id==0 then
+    return not battle.safari and not battle.demo and not battle.showPlayerBack
+  elseif b.fainted then return false end
+  return not battle.showEnemyTrainer and not battle.enemySendingOut
+    and not battle:growInScale(b) and not battle.introBalls
+end
+function Gen3Battle.drawSafariLabel(label,x,y)
+  local pen=require('src.render.Gen3TextPen')
+  local width=pen.drawCompound(label,x,y)
+  if width~=nil then return width end
+  Font.draw(label,x,y);return Font.width(label)
+end
+
+function Gen3Battle.drawSafariPanel(battle,x,y)
+  if not battle.gen3Safari then return false end
+  if battle.rsBattlePanel then
+    return require('src.battle.Gen3RsHealthbox').drawSafari(battle,x,y,battle.rsBattlePanel.font)
+  end
+  return require('src.battle.Gen3NativeHealthbox').drawSafari(battle,x,y)
+end
 local function drawHUDs(battle, slide)
   local record = hudRecord(battle)
   local images = record and record.images or {}
   local double = battle.isDouble and battle:isDouble()
-  if not double and battle.enemy and not battle.showEnemyTrainer
-      and not battle.enemySendingOut and not battle:growInScale(battle.enemy)
-      and slide == 0 and not battle.introBalls and not battle.enemy.fainted then
+  if not double and Gen3Battle.healthboxVisible(battle,1,slide,true) then
     local x, y = healthboxAt(battle, "singlesOpponent",
                              hudImage(images.opponent), 8, 8)
-    drawStatusPanel(battle, battle.enemy, x, y, false)
+    drawStatusPanel(battle, battle.enemy, x, y+Selection.offset(battle,'hb',battle.enemy), false)
   end
-  if not double and not battle.safari and battle.player and not battle.demo
-      and not battle.showPlayerBack and slide == 0 then
+  if not double and Gen3Battle.healthboxVisible(battle,0,slide,true) then
     local x, y = healthboxAt(battle, "singlesPlayer",
                              hudImage(images.player), 112, 64)
-    drawStatusPanel(battle, battle.player, x, y, true)
+    drawStatusPanel(battle, battle.player, x, y+Selection.offset(battle,'hb',battle.player), true)
   end
   -- ...AND THE OTHER TWO PANELS.
   --
@@ -1501,15 +1578,8 @@ local function drawHUDs(battle, slide)
     --
     -- Same conditions, per side, so a double intro reads like two singles
     -- happening at once, which is what it is.
-    local enemyReady = not battle.showEnemyTrainer
-                       and not battle.enemySendingOut
-                       and not battle.introBalls
-    local playerReady = not battle.showPlayerBack
     for _, row in ipairs(pairs_) do
       local b = battle:battlerAt(row.pos)
-      local ready = row.player and playerReady
-                    or (not row.player and enemyReady
-                        and not (b and battle:growInScale(b)))
       -- ...AND IT STAYS UP WHILE THE BAR EMPTIES.
       --
       -- Reported from play: in a double battle a Pokemon's panel vanishes the
@@ -1523,7 +1593,7 @@ local function drawHUDs(battle, slide)
       -- cry and starts the slide, which runs AFTER the drain, so the bar has
       -- emptied by the time it turns true.  Both layouts now answer the same
       -- question, and an empty slot is still nil rather than a zeroed one.
-      if ready and b and b.mon and not b.fainted then
+      if Gen3Battle.healthboxVisible(battle,row.pos,slide,true) then
         local panel = hudImage(row.img)
         local h = 32
         if panel and panel.getHeight then
@@ -1539,7 +1609,7 @@ local function drawHUDs(battle, slide)
           -- ride the right edge; opponentLeft and opponentRight are the
           -- left-hand pair (44 and 32) and stay put.
           local edge = row.player and Gen3Battle.extra(battle) or 0
-          local px, py = pos.x - 32 + edge, pos.y - math.floor(h / 2)
+          local px, py = pos.x - 32 + edge, pos.y - math.floor(h / 2)+Selection.offset(battle,'hb',b)
           drawStatusPanel(battle, b, px, py, row.player)
           if b == aimed and math.floor((battle.frame or 0) / 8) % 2 == 0 then
             love.graphics.setColor(1, 1, 0.3, 1)
@@ -1781,7 +1851,7 @@ end
 
 -- Draws the panel and answers whether it did, so a caller can fall back to
 -- its own drawn box on a cache that has none.
-local function drawPanel(battle, which)
+local function drawPanelBody(battle, which)
   local img, record = panelImage(battle, which)
   if not img then return false end
   love.graphics.setColor(1, 1, 1, 1)
@@ -1792,6 +1862,14 @@ local function drawPanel(battle, which)
   return true
 end
 
+-- Source panel wrappers run inside this existing native drawing phase.
+Gen3Battle.drawPanel=drawPanelBody
+local function drawPanel(battle,which)
+  local source=package.loaded['src.ui.game3.battle_chrome']
+  if source then return source._panel(battle,which,function()return drawPanelBody(battle,which)end)end
+  return drawPanelBody(battle,which)
+end
+
 -- THE TEXT IS PRINTED TWICE.  Every string in a Gen 3 battle is a foreground
 -- pass over a shadow pass one pixel down and right; the shadow is what makes
 -- white legible on teal, and dropping it is most of why black-on-white was
@@ -1807,6 +1885,8 @@ local function paintPair(battle, key)
   return norm(row.foreground), norm(row.shadow)
 end
 
+Gen3Battle.textColors=paintPair
+
 -- ...ONCE, THROUGH THE PAGE'S OWN TWO TONES.
 --
 -- Reported from play: "the textbox in battle doesnt seem to be using the
@@ -1963,7 +2043,11 @@ local function drawCommandMenu(battle)
       local prompt = record and record.prompt
       local chooser = (battle.menuBattler and battle:menuBattler()) or battle.player
       local who = chooser and chooser.name or ""
-      if prompt and prompt[1] and prompt[2] then
+      local quick=package.loaded['src.mods.FeatureOptions']and require('src.battle.QuickItem').label(battle)
+      if quick then
+        Font.draw(fitName(quick,88),w.prompt.textX+dx,w.prompt.row1+dy)
+        Font.draw("L: NEXT R: THROW",w.prompt.textX+dx,w.prompt.row2+dy)
+      elseif prompt and prompt[1] and prompt[2] then
         Font.draw(prompt[1], w.prompt.textX + dx, w.prompt.row1 + dy)
         local second = tostring(prompt[2]):gsub("{MON}", fitName(who, 88))
         Font.draw(second, w.prompt.textX + dx, w.prompt.row2 + dy)
@@ -2317,12 +2401,12 @@ end
 -- (20/30 and 40/50).  In singles, monbg copies are inserted between the exact
 -- OBJ priority bands: same-priority OBJ wins over BG, while splitbgprio can
 -- promote BG1 from priority 2 to priority 1.
-function Gen3Battle.drawMoveOamObjects(battle, slide, sx, sy)
+function Gen3Battle.moveOamObjects(battle, allowDouble)
   local anim = battle and battle.gen3AnimPlaying and battle.gen3Anim
   if not (anim and anim.oamEventDescriptors) then return false, "inactive" end
   if battle.isDouble then
     local ok, double = pcall(battle.isDouble, battle)
-    if ok and double then return false, "double-battler-slot" end
+    if ok and double and not allowDouble then return false, "double-battler-slot" end
   end
 
   local events, reason = anim:oamEventDescriptors(battle, Gen3Battle)
@@ -2349,6 +2433,12 @@ function Gen3Battle.drawMoveOamObjects(battle, slide, sx, sy)
      or not addBattler(battle.enemy, "enemy", 2) then
     return false, "unknown-battler-oam"
   end
+  if allowDouble and battle.isDouble and battle:isDouble() then
+    if not addBattler(battle:battlerAt(2), "player", 3)
+       or not addBattler(battle:battlerAt(3), "enemy", 4) then
+      return false, "unknown-battler-oam"
+    end
+  end
   for _, item in ipairs(events) do
     item.seed = 1000 + (item.index or 0)
     objects[#objects + 1] = item
@@ -2386,7 +2476,12 @@ function Gen3Battle.drawMoveOamObjects(battle, slide, sx, sy)
     if item.event and anim.oamRanks then anim.oamRanks[item.event] = i end
   end
   battle._gen3OamObjectRanks = previous
+  return objects,copies,anim
+end
 
+function Gen3Battle.drawMoveOamObjects(battle, slide, sx, sy)
+  local objects,copies,anim=Gen3Battle.moveOamObjects(battle,false)
+  if not objects then return false,copies end
   local function drawObject(item)
     if item.kind == "battler" then
       battle:drawPicsLayer(slide, sx, sy, item.side, true)
@@ -2905,7 +3000,7 @@ local function ballSheet(battle, key)
   return (ok and img) or nil
 end
 
-function Gen3Battle.drawBall(battle)
+local function drawNativeBall(battle)
   local record, anim = Gen3Battle.ballRecord(battle)
   if not anim then return end
   local g = love.graphics
@@ -3013,6 +3108,18 @@ function Gen3Battle.drawBall(battle)
   g.setColor(1, 1, 1, 1)
 end
 
+function Gen3Battle.drawBall(battle)
+  local source=package.loaded['src.core.game3.battle.ball_open']
+  if source then return source._nativeDraw(battle,drawNativeBall) end
+  return drawNativeBall(battle)
+end
+
+function Gen3Battle.introWindow(battle)
+  local fi=battle.frlgIntro
+  if not fi or fi.t>=60 then return end
+  local half=fi.t<=32 and fi.t or 32+(fi.t-32)*4
+  if half<80 then return 80-half,80+half end
+end
 function Gen3Battle.draw(battle)
   local g = love.graphics
   battle:drawBattleField()
@@ -3109,20 +3216,28 @@ function Gen3Battle.draw(battle)
   -- across the field, and a screen shake moves the field
   shaken(function() Gen3Battle.drawBall(battle) end)
   battle:drawAnimLayer()
+  local voice=require('src.battle.Gen3VoiceoverPresentation')
+  local dim=voice.dim(battle)
+  if dim>0 then
+    g.setColor(0,0,0,dim);g.rectangle('fill',0,0,Gen3Battle.width(battle),Gen3Battle.HEIGHT)
+    g.setColor(1,1,1,1)
+    if voice.lit(battle)and Gen3Battle.healthboxVisible(battle,0,slide)then
+      local record=hudRecord(battle);local image=hudImage(record and record.images and record.images.player)
+      local x,y=healthboxAt(battle,'singlesPlayer',image,112,64)
+      drawStatusPanel(battle,battle.player,x,y+Selection.offset(battle,'hb',battle.player),true)
+    end
+  end
   shaken(function() battle:drawTextArea() end)
 
   -- the window opening out of the middle: 1 row a side for 32 frames, then 4
   -- (BattleIntroSlide1 cases 2 and 3); nothing shows outside it
-  local fi = battle.frlgIntro
-  if fi and fi.t < 60 then
-    local half = fi.t <= 32 and fi.t or (32 + (fi.t - 32) * 4)
-    if half < 80 then
-      local W, H = Gen3Battle.WIDTH, Gen3Battle.HEIGHT
-      g.setColor(0, 0, 0, 1)
-      g.rectangle("fill", 0, 0, W, 80 - half)
-      g.rectangle("fill", 0, 80 + half, W, H - 80 - half)
-      g.setColor(1, 1, 1, 1)
-    end
+  local top,bottom=Gen3Battle.introWindow(battle)
+  if top then
+    local W,H=Gen3Battle.WIDTH,Gen3Battle.HEIGHT
+    g.setColor(0,0,0,1)
+    g.rectangle('fill',0,0,W,top)
+    g.rectangle('fill',0,bottom,W,H-bottom)
+    g.setColor(1,1,1,1)
   end
 
   if fx and fx.flash and fx.flash > 0 and battle.frame % 4 < 2 then
diff --git a/src/battle/Gen3BattleFrames.lua b/src/battle/Gen3BattleFrames.lua
new file mode 100644
index 000000000..263ed8e4c
--- /dev/null
+++ b/src/battle/Gen3BattleFrames.lua
@@ -0,0 +1,51 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Decorations borrow the actual native panel/window/frame owners.
+local Native=require('src.battle.Gen3Battle')
+local Font=require('src.render.Font')
+local Version=require('src.core.GameVersion')
+local M={}
+local function rs(b)
+ local v=Version.get();local owner=b.rsBattlePanel
+ if (v=='ruby'or v=='sapphire')and owner and owner.chrome and owner.images
+  and (not b.safari or b.gen3Safari)and Native.width(b)==240 then return owner end
+end
+function M.rects(b,which)
+ local s,w=Native.strip(b),Native.windows(b)
+ if which=='action'then
+  if b.safari then return{{s.tx,s.ty,s.tw,s.th}}end
+  return{{w.prompt.tx,w.prompt.ty,w.prompt.tw,w.prompt.th},{w.action.tx,w.action.ty,w.action.tw,w.action.th}}
+ elseif which=='moves'then
+  local right=20
+  if w.moves then right=math.max(w.moves[2].tx+w.moves[2].tw,w.moves[4].tx+w.moves[4].tw)-s.tx end
+  local detail=s.tx+20
+  if w.moves then detail=math.max(w.moves[2].tx+w.moves[2].tw,w.moves[4].tx+w.moves[4].tw)end
+  local edge=Native.extra(b)/8;detail=detail+edge
+  return{{s.tx,s.ty,right,s.th},{detail,s.ty,30+edge-detail,s.th}}
+ end
+ return{}
+end
+function M.panel(b,which)
+ local owner=rs(b)
+ if owner and owner.images[which]then
+  love.graphics.setColor(1,1,1,1);love.graphics.draw(owner.images[which],0,112)
+  return true,false -- Native RS user frames are a separate native layer.
+ end
+ local drawn=Native.drawPanel(b,which)
+ return drawn,drawn==true -- Generic native panels already contain the frame.
+end
+function M.rsFrames(b,which,owner)
+ owner=owner or rs(b);if not owner then return false end
+ owner.chrome.setFrameType(math.max(0,((b.game.save.options or{}).gen3Frame or 1)-1))
+ local rectangles=which=='action'and{{18,15,11,4}}
+  or which=='moves'and{{1,15,20,4},{23,15,6,4}}or{}
+ for _,r in ipairs(rectangles)do owner.chrome.userFrame(owner.chrome._frameType or 0,r[1],r[2],r[3],r[4])end
+ return true,#rectangles
+end
+function M.draw(b,which,included)
+ if included then return true,0 end
+ local owner=rs(b);if owner then return M.rsFrames(b,which,owner)end
+ local rectangles=M.rects(b,which)
+ for _,r in ipairs(rectangles)do Font.drawBox(r[1],r[2],r[3],r[4])end
+ return true,#rectangles
+end
+return M
diff --git a/src/battle/Gen3EffectCatalog.lua b/src/battle/Gen3EffectCatalog.lua
new file mode 100644
index 000000000..c71049c73
--- /dev/null
+++ b/src/battle/Gen3EffectCatalog.lua
@@ -0,0 +1,46 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Canonical GBA dispatch identifiers, from the public constant header:
+-- https://github.com/pret/pokefirered/blob/ce6406d8c2eaf46d543c8a2606de0c3cb1951982/include/constants/battle_move_effects.h
+-- Header SHA-256: fa15e285903818cc3cc7ecb2ca32c11d8317b14d261ca2d1caf44e614b53828a.
+-- Names are metadata facts, including unused slots, not effect implementations.
+local names=[[
+HIT SLEEP POISON_HIT ABSORB BURN_HIT FREEZE_HIT PARALYZE_HIT EXPLOSION DREAM_EATER MIRROR_MOVE ATTACK_UP
+DEFENSE_UP SPEED_UP SPECIAL_ATTACK_UP SPECIAL_DEFENSE_UP ACCURACY_UP EVASION_UP ALWAYS_HIT ATTACK_DOWN
+DEFENSE_DOWN SPEED_DOWN SPECIAL_ATTACK_DOWN SPECIAL_DEFENSE_DOWN ACCURACY_DOWN EVASION_DOWN HAZE BIDE
+RAMPAGE ROAR MULTI_HIT CONVERSION FLINCH_HIT RESTORE_HP TOXIC PAY_DAY LIGHT_SCREEN TRI_ATTACK REST OHKO
+RAZOR_WIND SUPER_FANG DRAGON_RAGE TRAP HIGH_CRITICAL DOUBLE_HIT RECOIL_IF_MISS MIST FOCUS_ENERGY RECOIL
+CONFUSE ATTACK_UP_2 DEFENSE_UP_2 SPEED_UP_2 SPECIAL_ATTACK_UP_2 SPECIAL_DEFENSE_UP_2 ACCURACY_UP_2
+EVASION_UP_2 TRANSFORM ATTACK_DOWN_2 DEFENSE_DOWN_2 SPEED_DOWN_2 SPECIAL_ATTACK_DOWN_2
+SPECIAL_DEFENSE_DOWN_2 ACCURACY_DOWN_2 EVASION_DOWN_2 REFLECT POISON PARALYZE ATTACK_DOWN_HIT
+DEFENSE_DOWN_HIT SPEED_DOWN_HIT SPECIAL_ATTACK_DOWN_HIT SPECIAL_DEFENSE_DOWN_HIT ACCURACY_DOWN_HIT
+EVASION_DOWN_HIT SKY_ATTACK CONFUSE_HIT TWINEEDLE VITAL_THROW SUBSTITUTE RECHARGE RAGE MIMIC METRONOME
+LEECH_SEED SPLASH DISABLE LEVEL_DAMAGE PSYWAVE COUNTER ENCORE PAIN_SPLIT SNORE CONVERSION_2 LOCK_ON SKETCH
+UNUSED_60 SLEEP_TALK DESTINY_BOND FLAIL SPITE FALSE_SWIPE HEAL_BELL QUICK_ATTACK TRIPLE_KICK THIEF MEAN_LOOK
+NIGHTMARE MINIMIZE CURSE UNUSED_6E PROTECT SPIKES FORESIGHT PERISH_SONG SANDSTORM ENDURE ROLLOUT SWAGGER
+FURY_CUTTER ATTRACT RETURN PRESENT FRUSTRATION SAFEGUARD THAW_HIT MAGNITUDE BATON_PASS PURSUIT RAPID_SPIN
+SONICBOOM UNUSED_83 MORNING_SUN SYNTHESIS MOONLIGHT HIDDEN_POWER RAIN_DANCE SUNNY_DAY DEFENSE_UP_HIT
+ATTACK_UP_HIT ALL_STATS_UP_HIT UNUSED_8D BELLY_DRUM PSYCH_UP MIRROR_COAT SKULL_BASH TWISTER EARTHQUAKE
+FUTURE_SIGHT GUST FLINCH_MINIMIZE_HIT SOLAR_BEAM THUNDER TELEPORT BEAT_UP SEMI_INVULNERABLE DEFENSE_CURL
+SOFTBOILED FAKE_OUT UPROAR STOCKPILE SPIT_UP SWALLOW UNUSED_A3 HAIL TORMENT FLATTER WILL_O_WISP MEMENTO
+FACADE FOCUS_PUNCH SMELLINGSALT FOLLOW_ME NATURE_POWER CHARGE TAUNT HELPING_HAND TRICK ROLE_PLAY WISH ASSIST
+INGRAIN SUPERPOWER MAGIC_COAT RECYCLE REVENGE BRICK_BREAK YAWN KNOCK_OFF ENDEAVOR ERUPTION SKILL_SWAP
+IMPRISON REFRESH GRUDGE SNATCH LOW_KICK SECRET_POWER DOUBLE_EDGE TEETER_DANCE BLAZE_KICK MUD_SPORT
+POISON_FANG WEATHER_BALL OVERHEAT TICKLE COSMIC_POWER SKY_UPPERCUT BULK_UP POISON_TAIL WATER_SPORT CALM_MIND
+DRAGON_DANCE CAMOUFLAGE
+]]
+local byName,byId,count={},{},0
+for name in names:gmatch('%S+')do
+ assert(not byName[name],'duplicate native move-effect symbol')
+ byName[name],byId[count]=count,name;count=count+1
+end
+assert(count==214,'incomplete native move-effect symbols')
+local C={}
+function C.id(name)if type(name)=='string'then return byName[name]end end
+function C.name(id)
+ if type(id)=='number'and id%1==0 and id>=0 and id<count then return byId[id]end
+end
+function C.count()return count end
+function C.snapshot()
+ local out={};for name,id in pairs(byName)do out[name]=id end;return out
+end
+return C
diff --git a/src/battle/Gen3MoveAnim.lua b/src/battle/Gen3MoveAnim.lua
index f6a3a09ea..ab1700be9 100644
--- a/src/battle/Gen3MoveAnim.lua
+++ b/src/battle/Gen3MoveAnim.lua
@@ -754,6 +754,7 @@ function Gen3MoveAnim:start(moveId, attackerIsPlayer, attackerPosition, targetPo
                             branchCtx, battle)
   local anim = self:recordFor(moveId, branchCtx)
   if not hasVisual(anim) then return false end
+  self.presentationSerial = (self.presentationSerial or 0) + 1
   self.events = anim.events or {}
   self.shakes = anim.shakes
   self.blends = anim.blends
@@ -4243,7 +4244,14 @@ local function drawHardwareAlphaImage(g, image, blend, ...)
 end
 Gen3MoveAnim.drawHardwareAlphaImage = drawHardwareAlphaImage
 
-function Gen3MoveAnim:drawEvent(event, battle, Gen3Battle, Assets, pose,
+function Gen3MoveAnim:drawEvent(event,battle,Gen3Battle,Assets,pose,allowSplitBlend)
+  local source=package.loaded['src.core.game3.battle.anim_sprites']
+  if source then return source._drawEvent(self,event,battle,function(...)
+    return self:drawEventBody(...)
+  end,event,battle,Gen3Battle,Assets,pose,allowSplitBlend)end
+  return self:drawEventBody(event,battle,Gen3Battle,Assets,pose,allowSplitBlend)
+end
+function Gen3MoveAnim:drawEventBody(event, battle, Gen3Battle, Assets, pose,
                                 allowSplitBlend)
   pose = pose or self:eventPose(event, battle, Gen3Battle)
   if not pose then return false end
diff --git a/src/battle/Gen3SafariText.lua b/src/battle/Gen3SafariText.lua
new file mode 100644
index 000000000..ae7b9f585
--- /dev/null
+++ b/src/battle/Gen3SafariText.lua
@@ -0,0 +1,37 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Read the native Safari owner's already-imported IR; no replacement prose,
+-- decoder, interpreter or action clock. Named roles stay edition-bound.
+local Version=require('src.core.GameVersion')
+local Copy=require('src.mods.Merge').deepCopy
+local M={PREFIX='native.safari.'}
+function M.spec(data,edition)
+ if type(data)~='table'then return end
+ local info=Version.info(edition)
+ local catalog=type(data.text_pointers)=='table'and data.text_pointers.namedIR
+ local s=type(data.constants)=='table'and data.constants.gen3SafariNative
+ if not(info and info.generation==3 and type(catalog)=='table'and catalog.schema==1
+   and catalog.edition==edition and catalog.romSha1==info.sha1 and type(s)=='table')then return end
+ local ok,owner=pcall(require,'src.import.Gen3SafariAssets')
+ if ok and type(owner)=='table'and type(owner.valid)=='function'and owner.valid(s,edition)then return s end
+end
+function M.read(data,edition,key)
+ if type(key)~='string'or key:sub(1,#M.PREFIX)~=M.PREFIX then return end
+ local s=M.spec(data,edition);local role=key:sub(#M.PREFIX+1)
+ local raw=s and s.textIR[role];if type(raw)~='table'then return end
+ local profile=require('src.import.Gen3BattleTextCatalog').profile(edition)
+ local nodes,plain={},{}
+ local breaks={nl='\n',scroll='\v',para='\f'}
+ for _,node in ipairs(raw)do
+  local row=Copy(node)
+  if row.t=='bph'then
+   if not profile.placeholders[row.code]then return end
+   row.t='ph';plain[#plain+1]=('{PH:%02X}'):format(row.code)
+  elseif row.t=='text'then plain[#plain+1]=row.s
+  elseif row.t=='tag'then plain[#plain+1]=row.tag
+  elseif breaks[row.t]then plain[#plain+1]=breaks[row.t]
+  elseif row.t~='ext'and row.t~='eos'then return end
+  nodes[#nodes+1]=row
+ end
+ return table.concat(plain),nodes
+end
+return M
diff --git a/src/battle/Gen3SelectionPresentation.lua b/src/battle/Gen3SelectionPresentation.lua
new file mode 100644
index 000000000..debe583a2
--- /dev/null
+++ b/src/battle/Gen3SelectionPresentation.lua
@@ -0,0 +1,65 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Selection motion belongs to the native battle frame, never to a UI query.
+-- Cartridge reference: pokefirered ce6406d8, battle_main DoBounceEffect /
+-- SpriteCB_BounceEffect / SpriteCB_ShowAsMoveTarget / SpriteCB_BlinkVisible.
+local M={}
+local records=setmetatable({},{__mode='k'})
+local function selection(b)
+ if b.phase=='menu' or b.phase=='moveSelect' then return 'choose' end
+ if b.phase=='targetSelect' then return 'target' end
+end
+local function target(b)
+ return b.phase=='targetSelect' and (b.targetChoices or{})[b.targetIndex or 1] or nil
+end
+local function live(b)
+ local c=records[b]
+ if c and c.refs[1]==b.data and c.refs[2]==b.game.save then return c end
+end
+local function bind(previous,battler,delta,frame)
+ if not battler then return nil end
+ if previous and previous.battler==battler and previous.delta==delta then return previous end
+ return {battler=battler,delta=delta,from=frame}
+end
+function M.update(b)
+ local mode=selection(b)
+ if not mode or not(b.game and b.game.save and b.data and b.menuBattler) then records[b]=nil;return end
+ local c=live(b)
+ if not c then c={refs=setmetatable({b.data,b.game.save},{__mode='v'})};records[b]=c end
+ local frame=b.frame or 0
+ local actor=b:menuBattler();local aimed=target(b)
+ c.mon=bind(c.mon,actor,7,frame)
+ local highlighted=actor;if mode=='target' then highlighted=aimed end
+ c.hb=bind(c.hb,highlighted,mode=='target' and 15 or 7,frame)
+ if aimed~=c.target then c.target=aimed;c.targetFrom=frame end
+end
+function M.hidden(b,battler)
+ local c=live(b);local aimed=target(b)
+ return c~=nil and battler~=nil and aimed==battler and c.target==battler
+  and math.floor(((b.frame or 0)-c.targetFrom)/8)%2==1 or false
+end
+function M.offset(b,kind,battler)
+ local c=live(b);if not c or not selection(b) then return 0 end
+ local row=c[kind]
+ if not row or row.battler~=battler then return 0 end
+ local expected=b:menuBattler()
+ if kind=='hb' and selection(b)=='target' then expected=target(b) end
+ local delta=kind=='hb' and selection(b)=='target' and 15 or 7
+ if expected~=battler or row.delta~=delta then return 0 end
+ local sine=b.data.constants and b.data.constants.gen3BattleAnimSine
+ local age=math.max(0,(b.frame or 0)-row.from)
+ local index=((kind=='hb' and 128 or 192)+age*row.delta)%256
+ local value=sine and sine[index]
+ -- No imported sine table means no verified displacement. Do not substitute
+ -- floating-point trigonometry for the cartridge's signed integer shift.
+ if type(value)~='number' then return 0 end
+ return math.floor(value/256)+1
+end
+-- Detached diagnostics never expose a battle/data/save reference or feed a
+-- logical checkpoint/journal field. The native owner is weakly scoped.
+function M._snapshot(b)
+ local c=live(b);if not c then return nil end
+ return {monFrom=c.mon and c.mon.from,healthboxDelta=c.hb and c.hb.delta,
+  targetFrom=c.targetFrom,targetPosition=c.target and c.target.position,
+  healthboxPosition=c.hb and c.hb.battler.position}
+end
+return M
diff --git a/src/battle/Gen3VoiceoverPresentation.lua b/src/battle/Gen3VoiceoverPresentation.lua
new file mode 100644
index 000000000..f646672ce
--- /dev/null
+++ b/src/battle/Gen3VoiceoverPresentation.lua
@@ -0,0 +1,54 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native tutorial cues own their queue hold and palette-fade clock. UI only reads.
+-- pokefirered ce6406d8: PokedudeAction_PrintVoiceoverMessage and
+-- PokedudeAction_PrintMessageWithHealthboxPals (target 8, delay 4).
+local Version=require('src.core.GameVersion')
+local M={}
+local function active(b)return Version.isFRLG()and b and b.game and b.data end
+function M.queue(b,text,highlight)
+ if type(text)~='string'or text==''then return false end
+ b.queue[#b.queue+1]={text=text,gen3Voiceover=true,gen3VoiceoverHealthbox=highlight==true}
+ return true
+end
+function M.gate(b)
+ if not active(b)then return false end
+ local s=b.gen3Voiceover
+ if s then
+  if s.phase~='message'then return true end
+  if b.current==s.cue or b.queue[1]==s.cue then return false end
+  s.phase=s.cue.gen3VoiceoverHealthbox and'unhighlight'or'out';s.clock=0
+  return true
+ end
+ local cue=not b.current and b.queue[1]
+ if not(cue and cue.gen3Voiceover)then return false end
+ b.gen3Voiceover={phase='in',coefficient=0,healthboxCoefficient=0,clock=0,cue=cue}
+ return true
+end
+function M.update(b)
+ local s=active(b)and b.gen3Voiceover
+ if not s or s.phase=='message'then return end
+ s.clock=s.clock+1;if s.clock<5 then return end;s.clock=0
+ if s.phase=='in'then
+  s.coefficient=math.min(8,s.coefficient+1);s.healthboxCoefficient=s.coefficient
+  if s.coefficient==8 then s.phase=s.cue.gen3VoiceoverHealthbox and'highlight'or'message'end
+ elseif s.phase=='highlight'then
+  s.healthboxCoefficient=math.max(0,s.healthboxCoefficient-1)
+  if s.healthboxCoefficient==0 then s.phase='message'end
+ elseif s.phase=='unhighlight'then
+  s.healthboxCoefficient=math.min(8,s.healthboxCoefficient+1)
+  if s.healthboxCoefficient==8 then s.phase='out'end
+ elseif s.phase=='out'then
+  s.coefficient=math.max(0,s.coefficient-1);s.healthboxCoefficient=s.coefficient
+  if s.coefficient==0 then b.gen3Voiceover=nil end
+ end
+end
+function M.dim(b)
+ local s=active(b)and b.gen3Voiceover
+ return s and s.coefficient/16 or 0
+end
+function M.lit(b)
+ local s=active(b)and b.gen3Voiceover
+ return not not s and s.cue.gen3VoiceoverHealthbox==true and s.healthboxCoefficient==0
+  and s.coefficient>0 or false
+end
+return M
diff --git a/src/battle/MenuAuxiliary.lua b/src/battle/MenuAuxiliary.lua
new file mode 100644
index 000000000..2364a1c7d
--- /dev/null
+++ b/src/battle/MenuAuxiliary.lua
@@ -0,0 +1,163 @@
+-- Public START action at an idle player command menu, before native navigation.
+local Runtime = require("src.mods.Runtime")
+local M = {}
+local BUSY = {
+  "current",
+  "nextInsert",
+  "pendingHit",
+  "waitingUI",
+  "waitingSound",
+  "draining",
+  "animPlaying",
+  "growIn",
+  "shrinkOut",
+  "ghostReveal",
+  "mimicCtx",
+  "result",
+  "gen3BallPlaying",
+  "gen4TouchPress",
+}
+local COUNTERS = { "waitFrames", "hitSfxWait", "introSlide" }
+local VARIANTS = {
+  "safari",
+  "ghost",
+  "scopeReveal",
+  "demo",
+  "pokedudeDemo",
+  "noCatch",
+  "palace",
+  "arena",
+  "ally",
+  "factory",
+  "pyramid",
+  "pike",
+  "battleTower",
+  "trainerTower",
+  "secretBase",
+  "eReader",
+}
+local function nonempty(value)
+  return type(value) == "table" and next(value) ~= nil
+end
+local function defaultAction()
+  return false
+end
+function M.ready(battle)
+  local game = battle and battle.game
+  if
+    not game
+    or not game.save
+    or not game.data
+    or battle.phase ~= "menu"
+    or (battle.kind ~= "wild" and battle.kind ~= "trainer")
+  then
+    return false
+  end
+  local stack = game.stack
+  if not stack or not stack.top or stack:top() ~= battle then
+    return false
+  end
+  if
+    nonempty(battle.queue)
+    or nonempty(battle.pendingActions)
+    or nonempty(battle.chosenTargets)
+    or (battle.afterQueue and battle.afterQueue ~= "menu")
+  then
+    return false
+  end
+  for _, field in ipairs(VARIANTS) do
+    if battle[field] then
+      return false
+    end
+  end
+  for _, field in ipairs(BUSY) do
+    if battle[field] then
+      return false
+    end
+  end
+  for _, field in ipairs(COUNTERS) do
+    local value = battle[field]
+    if value and value ~= 0 then
+      return false
+    end
+  end
+  if battle.showEnemyTrainer or battle.showPlayerBack or battle.enemySendingOut then
+    return false
+  end
+  local actor = battle.choosingBattler and battle:choosingBattler() or battle.player
+  if
+    not actor
+    or actor.ally
+    or not actor.mon
+    or (actor.mon.hp or 0) <= 0
+    or (battle.menuLockedAction and battle:menuLockedAction(actor))
+    or actor.bwSkyDropped
+  then
+    return false
+  end
+  local count = battle.isDouble and battle:isDouble() and 4 or 2
+  local enemyStanding = false
+  for position = 0, count - 1 do
+    local battler = battle.battlerAt and battle:battlerAt(position)
+      or (position == 0 and battle.player or position == 1 and battle.enemy)
+    if battler and battler.mon then
+      local mon = battler.mon
+      if
+        (mon.hp or 0) <= 0
+        or battler.fainted
+        or battler.faintQueued
+        or battler.draining
+        or battler.drainFloor ~= nil
+        or battler.drainHold ~= nil
+        or battler.shownHP ~= mon.hp
+        or battler.shownStatus ~= mon.status
+      then
+        return false
+      end
+      if position % 2 == 1 then
+        enemyStanding = true
+      end
+    elseif count == 2 then
+      return false
+    end
+  end
+  return enemyStanding
+end
+function M.request(battle)
+  if not Runtime.wantsHook("battle.menu_auxiliary") then
+    return
+  end
+  local game = battle.game
+  if not game or not game.input or not game.input:wasPressed("start") or not M.ready(battle) then
+    return
+  end
+  return {
+    game = game,
+    save = game.save,
+    data = game.data,
+    stack = game.stack,
+    session = game.sessionStartedAt,
+    kind = battle.kind,
+  }
+end
+local function current(battle, token)
+  local game = token.game
+  return battle.game == game
+    and game.save == token.save
+    and game.data == token.data
+    and game.stack == token.stack
+    and game.sessionStartedAt == token.session
+    and battle.kind == token.kind
+    and M.ready(battle)
+end
+function M.dispatch(battle, token)
+  -- Retire input captured for an owner/session that changed during native FX.
+  if not current(battle, token) then
+    return true
+  end
+  local result = Runtime.call("battle.menu_auxiliary", defaultAction, token.game, { kind = token.kind })
+  -- A pushed overlay or changed session must never receive the same input as
+  -- the retired battle menu, even if the wrapper returned false or raised.
+  return result == true or not current(battle, token)
+end
+return M
diff --git a/src/battle/PresentationClock.lua b/src/battle/PresentationClock.lua
new file mode 100644
index 000000000..b27b6655f
--- /dev/null
+++ b/src/battle/PresentationClock.lua
@@ -0,0 +1,37 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Presentation holds borrow a native update; they never drain its command
+-- queue. Results (including failures and nils) are shared within that update.
+local M={}
+local phases=setmetatable({},{__mode='k'})
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+function M.active(screen)return phases[screen]~=nil end
+function M.delta(screen)return phases[screen]and phases[screen].delta end
+function M.called(screen,key)
+ local phase=phases[screen];return phase~=nil and phase.steps[key]~=nil
+end
+function M.once(screen,key,body,...)
+  local phase=phases[screen]
+  if not phase then return body(screen,...)end
+  local entry=phase.steps[key]
+  if not entry then
+    entry={};phase.steps[key]=entry
+    entry.result=pack(pcall(body,screen,...))
+  end
+  local r=entry.result
+  if not r then return nil,'presentation step is already executing'end
+  if not r[1]then error(r[2],0)end
+  return unpack(r,2,r.n)
+end
+function M.run(screen,dt,body,...)
+  if phases[screen]then return body(...)end
+  local phase={steps={},delta=dt};phases[screen]=phase
+  local result=pack(pcall(body,...));phases[screen]=nil
+  -- A wrapper cannot swallow a failed display step and retry that step.
+  for _,entry in pairs(phase.steps)do
+    if entry.result and not entry.result[1]then error(entry.result[2],0)end
+  end
+  if not result[1]then error(result[2],0)end
+  return unpack(result,2,result.n)
+end
+return M
diff --git a/src/battle/QuickItem.lua b/src/battle/QuickItem.lua
new file mode 100644
index 000000000..3ef2907de
--- /dev/null
+++ b/src/battle/QuickItem.lua
@@ -0,0 +1,52 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Optional ball shortcuts enter the ordinary native bag/catch transaction.
+local Ready=require('src.battle.MenuAuxiliary')
+local Effects=require('src.inventory.ItemEffects')
+local Q={}
+local function available(battle)
+ local features=package.loaded['src.mods.FeatureOptions']
+ return features and features.enabled('quickBall')and require('src.core.GameVersion').isGen3()
+  and battle.kind=='wild'and not battle:isDouble()and Ready.ready(battle)
+end
+local function balls(battle)
+ local out={}
+ for key,n in pairs(battle.game.save.inventory or{})do
+  local def=battle.data.items[key]
+  if n>0 and Effects.isBall(key,def)then out[#out+1]=key end
+ end
+ table.sort(out,function(a,b)
+  local x,y=battle.data.items[a],battle.data.items[b]
+  local i,j=x and x.index or 65535,y and y.index or 65535
+  if i~=j then return i<j end;return tostring(a)<tostring(b)
+ end)
+ return out
+end
+function Q.request(battle)
+ if not available(battle)then return end
+ local input=battle.game.input
+ if not(input:wasPressed('l')or input:wasPressed('r'))then return end
+ return{game=battle.game,save=battle.game.save,data=battle.data,stack=battle.game.stack,throw=input:wasPressed('r')}
+end
+function Q.selected(battle)
+ local list=balls(battle);local selected=battle.quickItem
+ for i,id in ipairs(list)do if id==selected then return id,i,list end end
+ return list[1],1,list
+end
+function Q.dispatch(battle,token)
+ if battle.game~=token.game or battle.game.save~=token.save or battle.data~=token.data or battle.game.stack~=token.stack
+  or not available(battle)then return true end
+ local id,index,list=Q.selected(battle)
+ if not id then return true end
+ if token.throw then return require('src.ui.BagMenu').throwBall(battle.game,battle,id)end
+ battle.quickItem=list[index%#list+1]
+ require('src.core.Sound').play(battle.data,'Press_AB');return true
+end
+function Q.label(battle)
+ if not available(battle)then return nil end
+ local id=Q.selected(battle);local row=id and battle.data.items[id]
+ return row and row.name
+end
+function Q.prompt(battle)
+ local label=Q.label(battle);return label and(label..'\nL: NEXT R: THROW')or nil
+end
+return Q
diff --git a/src/battle/Rulesets.lua b/src/battle/Rulesets.lua
new file mode 100644
index 000000000..01f27df1e
--- /dev/null
+++ b/src/battle/Rulesets.lua
@@ -0,0 +1,7 @@
+-- Native built-in battle rules shared by simulation and field queries.
+return {
+  gen1_faithful = require("src.battle.rulesets.gen1_faithful"),
+  gen3_emerald = require("src.battle.rulesets.gen3_emerald"),
+  gen4_platinum = require("src.battle.rulesets.gen4_platinum"),
+  modern_clean = require("src.battle.rulesets.modern_clean"),
+}
diff --git a/src/battle/WildRecord.lua b/src/battle/WildRecord.lua
new file mode 100644
index 000000000..7cc541d39
--- /dev/null
+++ b/src/battle/WildRecord.lua
@@ -0,0 +1,74 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Authored native encounters carry an individual into the ordinary battle
+-- constructor. Validation is pure and happens before RNG/dex/stack changes.
+local M={}
+local fields={species=true,level=true,personality=true,ivs=true,item=true,hp=true,status=true,
+  moves=true,roamer=true}
+local stats={'hp','attack','defense','speed','spatk','spdef'}
+local function uint(n,max)return type(n)=='number'and n==n and n>=0 and n<=max and n%1==0 end
+function M.validate(data,record)
+  if type(record)~='table'then return nil,'encounter record required'end
+  for key in pairs(record)do if not fields[key]then return nil,'unsupported encounter field: '..tostring(key)end end
+  if not(data.pokemon and data.pokemon[record.species])then return nil,'unknown native species'end
+  if not(uint(record.level,100)and record.level>=1)then return nil,'invalid encounter level'end
+  local out={species=record.species,level=record.level}
+  if record.personality~=nil then
+    if not uint(record.personality,4294967295)then return nil,'invalid encounter personality'end
+    out.personality=record.personality
+  end
+  if record.ivs~=nil then
+    if type(record.ivs)~='table'then return nil,'invalid encounter IVs'end
+    out.ivs={}
+    for _,key in ipairs(stats)do
+      if not uint(record.ivs[key],31)then return nil,'invalid encounter IV '..key end
+      out.ivs[key]=record.ivs[key]
+    end
+    for key in pairs(record.ivs)do if out.ivs[key]==nil then return nil,'unknown encounter IV '..tostring(key)end end
+  end
+  if record.item~=nil then
+    if record.item~=false and not(data.items and data.items[record.item])then return nil,'unknown encounter item'end
+    out.item=record.item
+  end
+  if record.hp~=nil then
+    if not(uint(record.hp,65535)and record.hp>0)then return nil,'invalid encounter HP'end
+    out.hp=record.hp
+  end
+  if record.status~=nil then
+    if not uint(record.status,255)or record.status>7 and not({[8]=true,[16]=true,[32]=true,[64]=true,[128]=true})[record.status]then
+      return nil,'invalid encounter status'
+    end
+    out.status=record.status
+  end
+  if record.moves~=nil then
+    if type(record.moves)~='table'or#record.moves<1 or#record.moves>4 then return nil,'invalid encounter moves'end
+    out.moves={}
+    for i,row in ipairs(record.moves)do
+      local id=type(row)=='table'and row.id or row
+      local def=data.moves and data.moves[id]
+      if not def then return nil,'unknown encounter move'end
+      local pp=type(row)=='table'and row.pp or def.pp
+      if not(uint(pp,255)and pp<=(def.pp or 0))then return nil,'invalid encounter PP'end
+      out.moves[i]={id=id,pp=pp}
+    end
+    for i in pairs(record.moves)do
+      if not uint(i,4)or i<1 or i>#out.moves then return nil,'invalid encounter move slot'end
+    end
+  end
+  if record.roamer~=nil and type(record.roamer)~='boolean'then return nil,'invalid roaming encounter'end
+  out.roamer=record.roamer
+  return out
+end
+function M.apply(data,mon,record)
+  if record.personality~=nil or record.ivs then
+    require('src.pokemon.Pokemon').applySeed(data,mon,{personality=record.personality,ivs=record.ivs})
+  end
+  if record.item~=nil then mon.item=record.item or nil end
+  if record.moves then mon.moves=record.moves end
+  if record.hp then mon.hp=math.min(record.hp,mon.stats.hp)end
+  if record.status~=nil then
+    local bits=record.status
+    mon.status=bits>0 and(bits<=7 and'SLP'or({[8]='PSN',[16]='BRN',[32]='FRZ',[64]='PAR',[128]='PSN'})[bits])or nil
+    mon.sleepTurns=bits>0 and bits<=7 and bits or nil;mon.toxic=bits==128 or nil
+  end
+end
+return M
diff --git a/src/compat/game3/BattleCommandPhase.lua b/src/compat/game3/BattleCommandPhase.lua
new file mode 100644
index 000000000..a330bb041
--- /dev/null
+++ b/src/compat/game3/BattleCommandPhase.lua
@@ -0,0 +1,104 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- A borrowed native move-selection boundary, not a command queue. Only the
+-- existing controller commits the returned choice and advances battle rules.
+local M={}
+local pending
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function integer(v,lo,hi)return type(v)=='number'and v==v and v%1==0 and v>=lo and v<=hi end
+function M.take()
+ local p=pending
+ if not p or p.consumed or p.committing then return nil end
+ p.consumed=true
+ return p.command
+end
+function M.dispatch(screen,action,body,source)
+ if pending then
+  if pending.screen==screen and pending.committing then
+   local values=pack(body(screen,action));pending.result=values;return unpack(values,1,values.n)
+  end
+  return false,'native command phase is already pending'
+ end
+ local Battle=require('src.core.game3.battle')
+ local game=screen.game
+ if Battle._screen()~=screen or not game or game.stack:top()~=screen then
+  return false,'native battle does not own input'
+ end
+ if screen.phase~='moveSelect'and screen.phase~='targetSelect'
+     or screen.kind=='link'or screen.spectating or screen.demo or screen.pokedudeDemo
+     or screen.palace or screen.arena then return body(screen,action)end
+ local actor=screen:menuBattler();local slot
+ for i,m in ipairs(actor and actor.curMoves or{})do if m==action then slot=i;break end end
+ -- Forced actions, switches and other sequencers keep their existing owner.
+ if not slot then return body(screen,action)end
+ local ids=require('src.compat.gen1.BattleIds').new(screen.data)
+ local move=ids:read('moves',action.id)
+ if not move then return body(screen,action)end
+ local pos=screen:choosingSlotNow()
+ local target=screen.chosenTargets and screen.chosenTargets[pos]
+ local targetId=target and target.position
+ local command={kind='move',user='player',battler=pos,slot=slot,move=move,target=targetId}
+ local admission=Battle.getState()
+ local p={screen=screen,command=command};pending=p
+ local phase,turn,save,data,stack,mon,moves=screen.phase,screen.turnCount,game.save,game.data,game.stack,actor.mon,actor.curMoves
+ local result=pack(pcall(function()
+  local nextCommand=source()
+  if Battle._screen()~=screen or Battle.getState()~=admission or game.stack~=stack or stack:top()~=screen
+      or game.save~=save or game.data~=data or screen.data~=data or not ids.valid()
+      or screen.phase~=phase or screen.turnCount~=turn or screen:menuBattler()~=actor
+      or actor.mon~=mon or actor.curMoves~=moves or moves[slot]~=action
+      or screen:choosingSlotNow()~=pos or screen.result or screen.dead or screen.waitingUI
+      or actor.fainted or not actor.mon or(actor.mon.hp or 0)<=0
+      or(screen.chosenTargets and screen.chosenTargets[pos])~=target then
+   return false,'native command context changed'
+  end
+  if nextCommand==nil then
+   if screen.chosenTargets then screen.chosenTargets[pos]=nil end
+   screen.phase='moveSelect'
+   return false,'native move selection cancelled'
+  end
+  assert(type(nextCommand)=='table'and getmetatable(nextCommand)==nil,'command must be a plain move record')
+  local fields={kind=true,user=true,battler=true,slot=true,move=true,target=true}
+  for key in pairs(nextCommand)do assert(fields[key],'unsupported native move command field')end
+  assert(nextCommand.kind=='move'and nextCommand.user=='player'and nextCommand.battler==pos,'native move command changed its acting battler')
+  local selected=nextCommand.slot
+  assert(integer(selected,1,#moves)and selected<=4,'invalid native move command slot')
+  local nextMove=moves[selected]
+  assert(nextCommand.move==ids:read('moves',nextMove.id),'native command move does not match its slot')
+  local chosen=nextCommand.target;local nativeTarget
+  if chosen~=nil then
+   assert(integer(chosen,0,3),'invalid native move target')
+   for _,candidate in ipairs(require('src.battle.Targeting').choices(screen,actor))do
+    if candidate.position==chosen then nativeTarget=candidate;break end
+   end
+   assert(nativeTarget,'native move target is not selectable')
+  end
+  if not Battle._flushNative(screen)then return false,'native command admission retired'end
+  p.committing=true
+  local selection=package.loaded['src.battle.Gen3MoveSelection']
+  if selection and selection.manualReason then
+   local reason=selection.manualReason(screen,actor,nextMove,selected)
+   if selected==slot and chosen==targetId and not reason then return body(screen,action)end
+  end
+  -- Modified choices go back through the native refusal/target selector.
+  if screen.chosenTargets then screen.chosenTargets[pos]=nil end
+  screen.phase='moveSelect'
+  local a,b=screen:chooseMove(selected)
+  if screen.phase=='targetSelect'and nativeTarget then
+   for i,candidate in ipairs(screen.targetChoices or{})do
+    if candidate==nativeTarget then
+     a,b=screen:chooseTarget(i)
+     if p.result then return unpack(p.result,1,p.result.n)end
+     return a,b
+    end
+   end
+   return false,'native move target changed'
+  end
+  if p.result then return unpack(p.result,1,p.result.n)end
+  return a,b
+ end))
+ pending=nil
+ if not result[1]then error(result[2],0)end
+ return unpack(result,2,result.n)
+end
+return M
diff --git a/src/compat/game3/Follower.lua b/src/compat/game3/Follower.lua
new file mode 100644
index 000000000..8628ac6f6
--- /dev/null
+++ b/src/compat/game3/Follower.lua
@@ -0,0 +1,50 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.world.OptionalFollower')
+local F={setShouldSpawn=Native.setShouldSpawn}
+function F.current(world)
+  local game=package.loaded['src.core.Game']
+  world=world or game and game.overworld
+  local npc=world and Native.current(world)or nil
+  if npc and require('src.core.GameVersion').isGen3()then return require('src.core.game3.objects').find(npc.def.index)end
+  return npc
+end
+function F.actor()
+ local npc=F.current();if not(npc and npc.visible~=false and not npc.hidden and npc.sprite)then return nil end
+ return{kind='follower',i=npc.localId,x=npc.px,y=npc.py,sortY=npc.py,elevation=npc.currentElevation,
+  facing=npc.facing,walkPhase=npc.moving and 1 or 0,renderer=npc.sprite}
+end
+function F.reset()
+ local game,world=require('src.compat.gen1.NativeSession').resolve()
+ if not game then return false end
+ return Native.reset(world)
+end
+function F.at(_,x,y)
+ local npc=F.current();if npc and not npc.moving and npc.cellX==x and npc.cellY==y then return npc end
+end
+function F.update()return require('src.compat.gen1.ScriptBoundary').invoke('follower.update')end
+local nativeUpdate=F.update
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+function F._dispatch(game,world,body)
+ local Call=require('src.compat.gen1.SourceCall')
+ local function advance()
+  local result=pack(body())
+  -- A wrapped source follower starts as an unpainted logical actor. Native
+  -- consumers retain their normal artwork; merely reading the facade cannot
+  -- hide it. Existing owned renderers also keep their installing owner.
+  local who=F.update~=nativeUpdate and Call.owner(F,'update')
+  local actor=who and Native.current(world)
+  if actor then
+   local _,assigned=require('src.compat.gen1.SourceActors').renderer(actor)
+   if not assigned then
+    local view=F.current(world)
+    if view then require('src.core.Game3')._withCallbackOwner(who,function()view.sprite=nil end)end
+   end
+  end
+  return unpack(result,1,result.n)
+ end
+ return require('src.compat.gen1.ScriptBoundary').dispatch('follower.update',advance,function(...)
+  return Call.call(F,'update',...)
+ end,require('src.core.Game3').forNative(game))
+end
+return F
diff --git a/src/compat/gen1/BattleIds.lua b/src/compat/gen1/BattleIds.lua
new file mode 100644
index 000000000..cbc8b08c7
--- /dev/null
+++ b/src/compat/gen1/BattleIds.lua
@@ -0,0 +1,56 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Cartridge indices belong to this imported dataset, including sparse species
+-- slots. Portable names and National Dex numbers are not substitutes for them.
+local M={}
+local schema={pokemon={'speciesOrder','pokemon'},moves={'moveOrder','moves'},items={'itemOrder','items'},
+ abilities={'abilityOrder','abilities',1},types={'typeOrder','types',1},trainers={'trainerOrder','trainers'}}
+function M.new(data)
+ local indexes={}
+ local constants=data.constants
+ local catalogues={}
+ for kind,spec in pairs(schema)do
+  catalogues[kind]={order=constants and constants[spec[1]],rows=data[spec[2]]or constants and constants[spec[2]]}
+ end
+ local function valid()
+  if data.constants~=constants then return false end
+  for kind,c in pairs(catalogues)do
+   local spec=schema[kind]
+   if (constants and constants[spec[1]])~=c.order or(data[spec[2]]or constants and constants[spec[2]])~=c.rows then return false end
+  end
+  return true
+ end
+ local function index(kind)
+  if indexes[kind]then return indexes[kind]end
+  local spec=assert(schema[kind],'unknown battle identifier kind')
+  local constants=data.constants or{};local rows=data[spec[2]]or constants[spec[2]]or{}
+  local order=constants[spec[1]]or{};local forward,reverse={},{}
+  local function add(number,key)
+   if type(number)~='number'or number<0 or number%1~=0 then return end
+   if forward[number]~=nil and forward[number]~=key then forward[number]=false else forward[number]=key end
+   if reverse[key]~=nil and reverse[key]~=number then reverse[key]=false else reverse[key]=number end
+  end
+  for number,key in pairs(order)do if type(number)=='number'and rows[key]~=nil then add(number-(spec[3]or 0),key)end end
+  for key,row in pairs(rows)do
+   if type(row)=='table'and type(row.index)=='number'and order[row.index+(spec[3]or 0)]==nil then add(row.index,key)end
+  end
+  local result={forward=forward,reverse=reverse,rows=rows};indexes[kind]=result;return result
+ end
+ return {
+  valid=valid,
+  read=function(_,kind,key)
+   if not valid()then return nil end
+   if key==nil or key==false then return(kind=='items'or kind=='abilities')and 0 or nil end
+   local i=index(kind);local n=i.reverse[key]
+   if n~=nil then return n or nil end
+   if type(key)=='number'and i.rows[key]then return key end
+  end,
+  native=function(_,kind,value)
+   if not valid()then return nil end
+   if value==nil or value==0 and(kind=='items'or kind=='abilities')then return nil end
+   local i=index(kind)
+   if type(value)=='number'then return i.forward[value]or nil end
+   if i.rows[value]then return value end
+  end,
+ }
+end
+return M
diff --git a/src/compat/gen1/BattleRequests.lua b/src/compat/gen1/BattleRequests.lua
new file mode 100644
index 000000000..a1c234e83
--- /dev/null
+++ b/src/compat/gen1/BattleRequests.lua
@@ -0,0 +1,123 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Queued native encounters reuse the host's admission, trainer flags,
+-- afterBattle cleanup and callback cancellation. Unsupported source-owned
+-- party simulations are rejected before constructing or rolling a Pokemon.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Version=require('src.core.GameVersion')
+local R={}
+local fields={wild=true,foe=true,trainerId=true,onDone=true}
+function R.start(opts)
+  if type(opts)~='table'then return false,'invalid battle options'end
+  for key in pairs(opts)do if not fields[key]then return false,'native battle option unavailable: '..tostring(key)end end
+  if opts.onDone~=nil and type(opts.onDone)~='function'then return false,'invalid battle continuation'end
+  local game,why=Native.resolve();if not game then return false,why end
+  local Host=require('src.mods.Runtime');local facade=require('src.core.Game3')
+  local owner=Host.currentMod or facade._callbackOwner()
+  local loader=game.mods;local mod=loader and loader.mods and loader.mods[owner]
+  if not(mod and loader.hooks and type(loader.hooks.wrap)=='function')then return false,'battle request has no live mod owner'end
+  local save,data,edition=game.save,game.data,Version.get()
+  local function licensed()
+    return game.mods==loader and game.save==save and game.data==data and Version.get()==edition
+      and loader.mods[owner]==mod and mod.enabled~=false and not mod.failed
+  end
+  local function current()return Native.game()end
+  local function world(g)return{overworld=function()return Native.world(g)end}end
+  local available,admission=pcall(require,'src.mods.Api3WildBattle')
+  if not available then return false,'native encounter admission provider unavailable: '..tostring(admission)end
+  local start=admission.new
+  if opts.wild==true then
+    local foe=opts.foe
+    if type(foe)~='table'then return false,'wild battle requires a species and level'end
+    for key in pairs(foe)do if key~='species'and key~='level'then return false,'authored wild Pokemon field unavailable: '..tostring(key)end end
+    local species=Ids.new(data):native('pokemon',foe.species)
+    if not species then return false,'unknown cartridge species'end
+    if type(foe.level)~='number'or foe.level%1~=0 or foe.level<1 or foe.level>100 then return false,'invalid wild level'end
+    -- Resolve has already validated the cartridge key; the native plan avoids
+    -- interpreting it again as a portable species name.
+    local plan={resolve=function()return species end,construct=function(g,key)
+      return require('src.battle.BattleState').newWild(g,key,foe.level)
+    end}
+    return start(loader,owner,current,world,licensed,require,nil,plan)(species,foe.level,opts.onDone)
+  end
+  if opts.foe~=nil then return false,'trainer requests require the imported trainer id'end
+  if opts.trainerId==nil then return false,'native trainer id required'end
+  return start(loader,owner,current,world,licensed,require,nil,
+    require('src.mods.ScriptBattles').nativeTrainer)(opts.trainerId,1,opts.onDone)
+end
+-- Full source encounter records use the same guarded admission as portable
+-- battles; numeric source IDs are converted before the native plan is built.
+function R.startWild(value,encounter,opts)
+  opts=opts or{}
+  if type(opts)~='table'or type(encounter)~='table'then return nil,'invalid wild encounter request'end
+  for key in pairs(opts)do if key~='done'then return nil,'native wild option unavailable: '..tostring(key)end end
+  if opts.done~=nil and type(opts.done)~='function'then return nil,'invalid battle continuation'end
+  local game,why=Native.resolve(value)
+  if not game or game~=Native.game()then return nil,why or'foreign native game'end
+  local host=require('src.mods.Runtime');local facade=require('src.core.Game3')
+  local owner=host.currentMod or facade._callbackOwner()
+  local loader=game.mods;local mod=loader and loader.mods and loader.mods[owner]
+  if not(mod and loader.hooks and loader.hooks.wrap)then return nil,'battle request has no live mod owner'end
+  local data,save,edition=game.data,game.save,Version.get();local ids=Ids.new(data)
+  local fields={species=true,level=true,personality=true,ivs=true,item=true,hp=true,status=true,moves=true,pp=true,roamer=true}
+  local raw={}
+  for key,v in pairs(encounter)do if not fields[key]then return nil,'unsupported encounter field: '..tostring(key)end;raw[key]=v end
+  raw.species=ids:native('pokemon',encounter.species)
+  if encounter.item~=nil then
+    raw.item=encounter.item==0 and false or ids:native('items',encounter.item)
+    if raw.item==nil then return nil,'unknown cartridge held item'end
+  end
+  if encounter.ivs~=nil then
+    if type(encounter.ivs)~='table'then return nil,'invalid encounter IVs'end
+    raw.ivs={}
+    local names={hp='hp',atk='attack',def='defense',spe='speed',spa='spatk',spd='spdef',
+      attack='attack',defense='defense',speed='speed',spatk='spatk',spdef='spdef'}
+    for key,v in pairs(encounter.ivs)do
+      local target=names[key];if not target or raw.ivs[target]~=nil then return nil,'invalid encounter IV name'end
+      raw.ivs[target]=v
+    end
+  end
+  raw.pp=nil
+  if encounter.moves~=nil then
+    if type(encounter.moves)~='table'then return nil,'invalid encounter moves'end
+    raw.moves={}
+    for i,row in ipairs(encounter.moves)do
+      local id=type(row)=='table'and(row.id or row.move or row.moveId)or row
+      local native=ids:native('moves',id)
+      if not native then return nil,'unknown cartridge move'end
+      local pp=type(row)=='table'and row.pp or type(encounter.pp)=='table'and encounter.pp[i]
+      raw.moves[i]={id=native,pp=pp or data.moves[native].pp}
+    end
+    for i in pairs(encounter.moves)do
+      if type(i)~='number'or i%1~=0 or i<1 or i>#raw.moves then return nil,'invalid encounter move slot'end
+    end
+  end
+  local record;record,why=require('src.battle.WildRecord').validate(data,raw)
+  if not record then return nil,why end
+  local roamer
+  if record.roamer then
+    roamer=require('src.world.Gen3Roamers').active(save)
+    if not roamer or roamer.species~=record.species or roamer.level~=record.level
+        or record.personality~=nil and roamer.personality~=record.personality then return nil,'roaming individual changed'end
+    -- A source snapshot cannot overwrite the native roaming individual.
+    record.personality=roamer.personality
+    record.ivs=nil
+    record.hp=nil;record.status=nil
+
+  end
+  local function licensed()
+    return game.mods==loader and game.data==data and game.save==save and Version.get()==edition
+      and loader.mods[owner]==mod and mod.enabled~=false and not mod.failed and ids:valid()
+  end
+  local plan={resolve=function()return record.species end,construct=function(g,key)
+    local options={wildRecord=record}
+    if roamer then options.roamer='gen3';options.roamerSeed=roamer;options.roamerHP=roamer.hp;options.roamerStatus=roamer.status end
+    local battle=require('src.battle.BattleState').newWild(g,key,record.level,options)
+    if save.safari then battle:makeSafari(save.safari)end
+    return battle
+  end}
+  return require('src.mods.Api3WildBattle').new(loader,owner,function()return Native.game()end,
+    function(g)return{overworld=function()return Native.world(g)end}end,licensed,require,nil,plan)(record.species,record.level,opts.done)
+end
+
+return R
diff --git a/src/compat/gen1/BattleRuntime.lua b/src/compat/gen1/BattleRuntime.lua
new file mode 100644
index 000000000..4ef2fc296
--- /dev/null
+++ b/src/compat/gen1/BattleRuntime.lua
@@ -0,0 +1,77 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe real native stack admissions. Completed source views keep no save,
+-- controller, imported dataset or borrowed GPU resource alive.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Views=require('src.compat.gen1.BattleView')
+local Ids=require('src.compat.gen1.BattleIds')
+local R={};R.__index=R
+local function owner()
+  local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+  return host and host.currentMod or facade and facade._callbackOwner()
+end
+local function cohort(c)
+  return c.game.data==c.data and c.game.save==c.save and c.game.mods==c.loader
+    and c.game.stack==c.stack and Version.get()==c.edition and c.ids:valid()
+end
+local function member(c)
+  if c.retired or not cohort(c)then return false end
+  for _,state in ipairs(c.stack.states or{})do if state==c.screen then return true end end
+  return false
+end
+function R.new()return setmetatable({records=setmetatable({},{__mode='kv'})},R)end
+function R:retire(c,completed)
+  if not c or c.retired then return end
+  c.views:retire();c.retired=true
+  self.records[c.screen]=nil
+  if self.current==c then self.current=nil end
+  if completed then
+    self.last=c.views.view
+    self.lastSession=setmetatable({c.game,c.data,c.save,c.stack,c.loader},{__mode='v'})
+    self.lastEdition=c.edition
+  end
+  c.game,c.screen,c.data,c.save,c.stack,c.loader,c.ids=nil,nil,nil,nil,nil,nil,nil
+end
+function R:bind(screen)
+  local game=screen and Native.game(screen.game)
+  if not(game and game==Native.game()and screen.isBattleState and screen.data==game.data and game.stack and game.save)then return end
+  local c=self.records[screen]
+  if c and member(c)then local who=owner();if who then c.users[who]=true end;return c end
+  if c then self:retire(c,false)end
+  c={screen=screen,game=game,data=game.data,save=game.save,stack=game.stack,loader=game.mods,edition=Version.get(),users={},ids=Ids.new(game.data)}
+  if not member(c)then return end
+  if self.current and self.current~=c then self:retire(self.current,false)end
+  c.views=Views.new(game,screen,function()return member(c)end,c.ids)
+  local who=owner();if who then c.users[who]=true end
+  self.records[screen]=c;self.current=c;self.last=nil
+  return c
+end
+function R:active(value)
+  local game=Native.game(value)
+  if value~=nil and game~=Native.game()then return nil end
+  local last=self.lastSession
+  if last and(not game or last[1]~=game or last[2]~=game.data or last[3]~=game.save
+      or last[4]~=game.stack or last[5]~=game.mods or self.lastEdition~=Version.get())then
+    self.last,self.lastSession,self.lastEdition=nil,nil,nil
+  end
+  if self.current and(not member(self.current)or self.current.game~=game)then self:retire(self.current,false)end
+  if not game then return end
+  for i=#(game.stack and game.stack.states or{}),1,-1 do
+    local state=game.stack.states[i]
+    if state.isBattleState and state.game==game then return self:bind(state)end
+  end
+end
+function R:exit(screen)
+  local c=self.records[screen]
+  if c then self:retire(c,cohort(c))end
+end
+function R:release()
+  if self.current then self:retire(self.current,false)end
+  self.last,self.lastSession,self.lastEdition=nil,nil,nil
+end
+function R:poll()self:active()end
+function R:releaseOwner(who)
+  if self.current and self.current.users[who]then self:retire(self.current,false)end
+end
+R.member=member
+return R
diff --git a/src/compat/gen1/BattleView.lua b/src/compat/gen1/BattleView.lua
new file mode 100644
index 000000000..3921f615b
--- /dev/null
+++ b/src/compat/gen1/BattleView.lua
@@ -0,0 +1,234 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Live, typed source observations over one admitted native battle. Views own
+-- their arrays; they never lend the native controller/save under source names.
+local Ids=require('src.compat.gen1.BattleIds')
+local Iteration=require('src.compat.gen1.TableIteration')
+local M={}
+local residents=setmetatable({},{__mode="k"})
+function M.nativeMon(view)
+ local d=residents[view];if not d then return nil,false end
+ local e=d.environment
+ if not e.context or not e.valid()then return nil,true end
+ e:flush();return d.entry.raw,true,e.context.game
+end
+local statNames={attack='attack',defense='defense',speed='speed',spAtk='spatk',spDef='spdef',hp='hp'}
+local statusBits={PSN=8,BRN=16,FRZ=32,PAR=64,TOX=128}
+local function status(mon)
+ if mon.status=='SLP'then return math.max(1,math.min(7,tonumber(mon.sleepTurns)or 1))end
+ if mon.status=='PSN'and mon.toxic then return 128 end
+ return statusBits[mon.status]or 0
+end
+local function integer(v,lo,hi)return type(v)=='number'and v==v and v%1==0 and v>=lo and v<=hi end
+local monKeys={'species','nickname','level','hp','maxHp','attack','defense','speed','spAtk','spDef',
+ 'moves','pp','maxPp','item','status','ability','personality','friendship','isEgg','otId','otSecretId'}
+local battlerKeys={'id','side','flank','mon','species','type1','type2','ability','item','status','fainted','stages','partyIndex'}
+local stateKeys={'player','enemy','battlers','party','playerParty','enemyParty','turn','wild','double','over','result',
+ 'weather','weatherTurns','session','playerIndex','enemyIndex','trainerClass','trainerName','trainerPicId',
+ 'link','safari','tutorial','oldManTutorial','pokedude','firstBattle','ghostBattle','kinds','rng'}
+local reserved={}
+for _,key in ipairs(stateKeys)do reserved[key]=true end
+function M.new(game,screen,valid,identifiers)
+ local e={context={game=game,screen=screen,data=game.data},entries=setmetatable({},{__mode='k'}),
+  caches={},arrays={},valid=valid,retired=false}
+ local ids=identifiers or Ids.new(game.data)
+ local function at(pos)
+  local s=e.context and e.context.screen;if not s then return end
+  if pos==0 then return s.player elseif pos==1 then return s.enemy end
+  return s.battlerAt and s:battlerAt(pos)
+ end
+ local read
+ local function collection(name,values,convert)
+  local a=e.arrays[name]
+  if not a then a={view={}};e.arrays[name]=a end
+  local out=a.view;local old=#out
+  for i,value in ipairs(values or{})do out[i]=convert and convert(value,i)or value end
+  for i=#(values or{})+1,old do out[i]=nil end
+  return out
+ end
+ local function proxy(kind,raw)
+  if not raw then return nil end
+  local cache=e.caches[kind];if not cache then cache=setmetatable({},{__mode='kv'});e.caches[kind]=cache end
+  local existing=cache[raw];if existing then return existing end
+  local d={kind=kind,raw=raw};local view={};cache[raw]=view;e.entries[view]=d
+  if kind=="mon"then residents[view]={entry=d,environment=e}end
+  setmetatable(view,{__index=function(_,key)
+   if d.snapshot then return d.snapshot[key]end
+   if not e.context or not e.valid()then return nil end
+   return read(d,key)
+  end,__newindex=function(t,key,value)
+   assert(e.context and e.valid(),'native battle view retired')
+   if kind=='mon'and(key=='hp'or key=='nickname'or key=='item'or key=='status')then
+    local mon=d.raw
+    if key=='hp'then assert(integer(value,0,mon.stats.hp),'invalid native HP');mon.hp=value
+    elseif key=='nickname'then assert(type(value)=='string'and#value<=32,'invalid native nickname');mon.nickname=value
+    elseif key=='item'then
+     local item=ids:native('items',value);assert(value==0 or item,'unknown native held item');mon.item=item
+    else
+     assert(integer(value,0,255),'invalid native status')
+     local inverse={[8]='PSN',[16]='BRN',[32]='FRZ',[64]='PAR',[128]='PSN'}
+     assert(value==0 or value<=7 or inverse[value],'unsupported combined native status')
+     mon.status=value>0 and(value<=7 and'SLP'or inverse[value])or nil
+     mon.sleepTurns=value>0 and value<=7 and value or nil;mon.toxic=value==128 or nil
+    end
+   elseif kind=='state'and not reserved[key]then
+    -- Presentation extensions belong to this view; they cannot replace the
+    -- controller's command queue, party aliases or completion result.
+    rawset(t,key,value)
+   else error('native battle '..kind..' '..tostring(key)..' is not directly writable',2)end
+  end})
+  -- LuaJIT does not consult __pairs. Keep registry values weak so its
+  -- weak key cannot retain itself through this environment's public view.
+  local observation=setmetatable({environment=e,entry=d},{__mode='v'})
+  Iteration.register(view,function(spec,source)
+   local environment,entry=spec.environment,spec.entry
+   assert(environment and entry,'native battle view retired')
+   local out={};for key,value in Iteration.rawPairs(source)do out[key]=value end
+   if entry.snapshot then for key,value in pairs(entry.snapshot)do out[key]=value end;return out end
+   assert(environment.context and environment.valid(),'native battle view retired')
+   local keys=entry.kind=='state'and stateKeys or entry.kind=='battler'and battlerKeys or entry.kind=='mon'and monKeys
+     or{'attack','defense','speed','spAtk','spDef','accuracy','evasion'}
+   for _,key in ipairs(keys)do out[key]=environment.read(entry,key)end
+   return out
+  end,observation)
+  return view
+ end
+ local function partyIndex(party,mon)for i,value in ipairs(party or{})do if value==mon then return i end end end
+ local function party()local c=e.context;return c.screen.playerParty or c.game.save.party or{}end
+ local function moveArrays(mon)
+  local d=e.moveArrays and e.moveArrays[mon]
+  if not d then
+   e.moveArrays=e.moveArrays or{};d={moves={},pp={},maxPp={},baseline={}};e.moveArrays[mon]=d
+  end
+  -- PP edits use an explicit native transaction before the next native body.
+  if not d.pending then
+   for _,key in ipairs{'moves','pp','maxPp'}do for i in pairs(d[key])do d[key][i]=nil end end
+   d.baseline={};d.ids={};d.maximum={}
+   for i,mv in ipairs(mon.moves or{})do
+    d.moves[i]=ids:read('moves',mv.id);d.pp[i]=mv.pp;d.baseline[i]=mv.pp
+    local def=(e.context.data.moves or{})[mv.id]
+    d.maxPp[i]=def and def.pp and def.pp+math.floor(def.pp/5)*(mv.ppUps or 0)or nil
+    d.ids[i]=d.moves[i];d.maximum[i]=d.maxPp[i]
+   end
+   d.pending=true
+  end
+  return d
+ end
+ read=function(d,key)
+  local raw=d.raw;local c=e.context
+  if d.kind=='mon'then
+   if key=='species'then return ids:read('pokemon',raw.species)end
+   if key=='item'then return ids:read('items',raw.item)end
+   if key=='ability'then
+    local b;for pos=0,3 do local actual=at(pos);if actual and actual.mon==raw then b=actual;break end end
+    return ids:read('abilities',b and b.ability or raw.ability)
+   end
+   if key=='hp'then return raw.hp end
+   if key=='maxHp'then return raw.stats and raw.stats.hp end
+   if statNames[key]then return raw.stats and raw.stats[statNames[key]]end
+   if key=='status'then return status(raw)end
+   if key=='moves'or key=='pp'or key=='maxPp'then return moveArrays(raw)[key]end
+   if key=='otId'then return raw.otId or raw.otID end
+   if key=='otSecretId'then return raw.otSecretId or raw.secretId end
+   if key=='friendship'then return raw.friendship or raw.happiness end
+   if key=='nickname'or key=='level'or key=='personality'or key=='isEgg'then return raw[key]end
+  elseif d.kind=='battler'then
+   local pos=raw.position
+   if pos==nil then for i=0,3 do if at(i)==raw then pos=i;break end end end
+   if key=='id'then return pos end
+   if key=='side'then return pos and(pos%2==0 and'player'or'enemy')end
+   if key=='flank'then return pos and(pos<2 and'left'or'right')end
+   if key=='mon'then return proxy('mon',raw.mon)end
+   if key=='species'then return ids:read('pokemon',raw.species or raw.mon.species)end
+   if key=='ability'then return ids:read('abilities',raw.ability)end
+   if key=='item'then return ids:read('items',raw.mon.item)end
+   if key=='status'then return status(raw.mon)end
+   if key=='fainted'then return raw.fainted==true or raw.mon.hp<=0 end
+   if key=='partyIndex'then return partyIndex(pos and pos%2==0 and party()or c.screen.enemyParty,raw.mon)or 1 end
+   if key=='stages'then return proxy('stages',raw.stages or{})end
+   if key=='type1'or key=='type2'then return ids:read('types',(raw.curTypes or{})[key=='type1'and 1 or 2])end
+  elseif d.kind=='stages'then return raw[statNames[key]or key]
+  elseif d.kind=='state'then
+   if key=='player'or key=='enemy'then return proxy('battler',raw[key])end
+   if key=='battlers'then
+    e.battlers=e.battlers or{};for pos=0,3 do e.battlers[pos]=proxy('battler',at(pos))end;return e.battlers
+   end
+   if key=='party'or key=='playerParty'then return collection('party',party(),function(mon)return proxy('mon',mon)end)end
+   if key=='enemyParty'then
+    e.wildParty=e.wildParty or{};e.wildParty[1]=raw.enemy and raw.enemy.mon
+    return collection('enemyParty',raw.enemyParty or e.wildParty,function(mon)return proxy('mon',mon)end)
+   end
+   if key=='turn'then return raw.turnCount or 0 end
+   if key=='wild'then return raw.kind=='wild'end
+   if key=='double'then return raw.isDouble and raw:isDouble()or raw.double==true end
+   if key=='over'then return raw.result~=nil or raw.dead==true end
+   if key=='result'then return raw.result end
+   if key=='weather'then return raw.field and raw.field.weather end
+   if key=='weatherTurns'then return raw.field and raw.field.weatherTurns end
+   if key=='playerIndex'then return partyIndex(party(),raw.player and raw.player.mon)end
+   if key=='enemyIndex'then return raw.enemyIndex or(raw.enemy and 1)end
+   if key=='trainerClass'then return raw.trainer and raw.trainer.class or raw.trainerClass end
+   if key=='trainerName'then return raw.trainerName or raw.trainer and raw.trainer.name end
+   if key=='trainerPicId'then return raw.trainer and(raw.trainer.picIndex or raw.trainer.index)end
+   if key=='session'then return require('src.core.Game3').forNative(c.game).session end
+   if key=='link'then return raw.kind=='link'end
+   if key=='safari'then return raw.safari~=nil and raw.safari~=false end
+   if key=='ghostBattle'then return raw.ghost==true end
+   if key=='tutorial'or key=='oldManTutorial'then return raw.demo==true or raw.dudeDemo==true end
+   if key=='pokedude'then return raw.pokedudeDemo~=nil and raw.pokedudeDemo~=false end
+   if key=='firstBattle'then return raw.firstBattle==true end
+   if key=='kinds'then
+    e.kinds=e.kinds or{};e.kinds.tutorial=raw.pokedudeDemo and'pokedude'or(raw.demo and'oldMan'or nil);return e.kinds
+   end
+   if key=='rng'then return e.rng end
+  end
+ end
+ e.read=read
+ e.view=proxy('state',screen)
+ e.rng=function(...)assert(e.context and e.valid(),'native battle RNG retired');return e.context.screen.rng(...)end
+ function e:flush()
+  if not self.context or not self.valid()then return false end
+  local writes={}
+  for mon,d in pairs(self.moveArrays or{})do
+   for i,value in pairs(d.moves)do assert(value==d.ids[i],'source move replacement requires native move learning')end
+   for i,value in pairs(d.ids)do assert(d.moves[i]==value,'source move replacement requires native move learning')end
+   for i,value in pairs(d.maxPp)do assert(value==d.maximum[i],'source maximum PP is read-only')end
+   for i,value in pairs(d.maximum)do assert(d.maxPp[i]==value,'source maximum PP is read-only')end
+   for i in pairs(d.baseline)do assert(d.pp[i]~=nil,'source PP slot cannot be removed')end
+   for i,value in pairs(d.pp)do
+    assert(d.baseline[i]~=nil,'unknown source PP slot')
+    if value~=d.baseline[i]then
+     local mv=mon.moves and mon.moves[i];local maximum=d.maxPp[i]
+     assert(mv and mv.pp==d.baseline[i],'native move PP changed during source edit')
+     assert(integer(value,0,maximum or 99),'invalid source move PP')
+     writes[#writes+1]={move=mv,value=value}
+    end
+   end
+  end
+  for _,write in ipairs(writes)do write.move.pp=write.value end
+  for mon,d in pairs(self.moveArrays or{})do d.pending=false;moveArrays(mon)end
+  return true
+ end
+ function e:retire()
+  if self.retired then return end
+  for mon,d in pairs(self.moveArrays or{})do d.pending=false;moveArrays(mon)end
+  -- Populate only declared observations. No native queue, functions, save or
+  -- data table is copied into the completed record or retained by its views.
+  local seen={}
+  repeat
+   local pending=false
+   for view,d in pairs(self.entries)do if not seen[view]then
+   pending=true;seen[view]=true;local snapshot={}
+   for _,key in ipairs(d.kind=='state'and stateKeys or d.kind=='battler'and battlerKeys or d.kind=='mon'and monKeys or{'attack','defense','speed','spAtk','spDef','accuracy','evasion'})do
+    if key~='session'and key~='rng'then snapshot[key]=read(d,key)end
+   end
+   d.snapshot=snapshot
+   end end
+   if not pending then break end
+  until false
+  for _,d in pairs(self.entries)do d.raw=nil end
+  self.context,self.moveArrays,self.wildParty,self.valid=nil,nil,nil,function()return false end
+  self.retired=true;ids=nil
+ end
+ return e
+end
+return M
diff --git a/src/compat/gen1/CollisionRuntime.lua b/src/compat/gen1/CollisionRuntime.lua
new file mode 100644
index 000000000..32b719ebe
--- /dev/null
+++ b/src/compat/gen1/CollisionRuntime.lua
@@ -0,0 +1,94 @@
+-- Source observations and native permission queries have different alphabets:
+-- classified COLL bytes are views; actual entry permission stays native.
+local Session=require('src.compat.gen1.NativeSession')
+local Map=require('src.core.game3.map')
+local Tiles=require('src.render.Gen3Tiles')
+local Behavior=require('src.compat.gen1.MetatileBehavior')
+local Version=require('src.core.GameVersion')
+local Native=require('src.world.Collision')
+local M={}
+local function integer(v)return type(v)=='number'and v==v and math.abs(v)<math.huge and v%1==0 end
+local directions={up=true,down=true,left=true,right=true}
+function M.new()
+  local readers=setmetatable({},{__mode='k'})
+  local grids=setmetatable({},{__mode='k'})
+  local runtime={}
+  local function context(game)
+    local g,w,p=Session.resolve(game);if not g then return nil,w end
+    local maps,why=Map._context(g);if not maps then return nil,why end
+    return g,w,p,maps
+  end
+  function runtime:current(game)
+    local g,_,_,maps=context(game);if not g then return nil end
+    return maps:current()
+  end
+  function runtime:behaviorMid(def,mid,game)
+    if not(integer(mid)and mid>=0 and mid<1024)then return nil end
+    local g,_,_,maps=context(game);if not g or not maps:isOwned(def)then return nil end
+    local native=g.data.maps[def.nativeId]
+    local pair=native and g.data.tilesets[native.tileset]
+    local sets=g.data.map_tilesets
+    local a=pair and sets and sets[pair.primaryKey]
+    local b=pair and sets and sets[pair.secondaryKey]
+    local geometry=g.data.constants and g.data.constants.gen3Layout
+    if not(a and b and geometry)then return nil end
+    local cached=readers[pair]
+    if not cached or cached.primary~=a or cached.secondary~=b or cached.geometry~=geometry
+        or cached.split~=geometry.metatilesInPrimary then
+      cached={primary=a,secondary=b,geometry=geometry,split=geometry.metatilesInPrimary,
+        reader=Tiles.new({primary=a,secondary=b},geometry)}
+      readers[pair]=cached
+    end
+    local raw=cached.reader:sourceBehavior(mid)
+    return raw~=nil and Behavior.fromRaw(Version.get(),raw)or nil
+  end
+  function runtime:behavior(def,x,y,game)
+    if not(integer(x)and integer(y))then return nil end
+    local layout=def and def.midLayout
+    if not layout or x<0 or y<0 or x>=layout.width or y>=layout.height then return nil end
+    return self:behaviorMid(def,layout:midAt(x,y),game)
+  end
+  function runtime:grid(game)
+    local def=self:current(game);local layout=def and def.midLayout
+    if not layout then return nil end
+    local cached=grids[layout]
+    if not cached or cached.revision~=layout._revision then
+      cached={revision=layout._revision,cells=layout:collArray()};grids[layout]=cached
+    end
+    return cached.cells
+  end
+  function runtime:canEnter(game,x,y,opts)
+    if not(integer(x)and integer(y))then return false,'bounds'end
+    local g,w,p=Session.resolve(game);if not g then return false,'bounds'end
+    opts=opts or {}
+    local fx,fy=opts.fromX or p.cellX,opts.fromY or p.cellY
+    if not(integer(fx)and integer(fy))then return false,'bounds'end
+    local direction=opts.dir
+    if direction~=nil and not directions[direction]then return false,'direction'end
+    if not direction then
+      if fx==x and fy~=y then direction=y>fy and'down'or'up'
+      elseif fy==y and fx~=x then direction=x>fx and'right'or'left'end
+    end
+    local elevation=opts.elevation
+    if elevation==nil then elevation=p.elevation end
+    local surfing=opts.surfing
+    if surfing==nil then surfing=p.surfing end
+    local cast=w.cast or w.entities or {}
+    local mover=p
+    if fx~=p.cellX or fy~=p.cellY or elevation~=p.elevation or surfing~=p.surfing then
+      mover={};for k,v in pairs(p)do mover[k]=v end
+      mover.cellX,mover.cellY,mover.elevation,mover.surfing=fx,fy,elevation,surfing
+      local filtered={}
+      for _,entity in ipairs(cast)do
+        if entity~=p and entity.of~=p then filtered[#filtered+1]=entity end
+      end
+      cast=filtered
+    end
+    return Native.mayEnter(w.map,cast,mover,x,y,direction)
+  end
+  function runtime:release()
+    readers=setmetatable({},{__mode='k'});grids=setmetatable({},{__mode='k'})
+  end
+  return runtime
+end
+return M
diff --git a/src/compat/gen1/CoroutineScopes.lua b/src/compat/gen1/CoroutineScopes.lua
new file mode 100644
index 000000000..d4c337d55
--- /dev/null
+++ b/src/compat/gen1/CoroutineScopes.lua
@@ -0,0 +1,96 @@
+-- Dynamic native scopes may be borrowed by an actively resumed child. A
+-- suspended child cannot lend its scope to an unrelated native operation.
+local M={}
+local MAIN={}
+-- Retirement crosses phase/attribution registries. A source coroutine that
+-- outlives a borrowed native phase cannot acquire another caller's authority.
+local revoked=setmetatable({},{__mode='k'})
+local function thread()
+  local co,main=coroutine.running()
+  return main and MAIN or co or MAIN
+end
+function M.retired()return revoked[thread()]==true end
+local function visible(frame,co)
+  if frame.closed then return false end
+  local creator=frame.creator
+  return creator==co or creator==MAIN or coroutine.status(creator)=='normal'
+end
+local function previous(frame,key)
+  repeat frame=frame and frame[key] until not frame or not frame.closed
+  return frame
+end
+local function within(frame,ancestor)
+  while frame do
+    if frame==ancestor then return true end
+    frame=frame.parent
+  end
+  return false
+end
+local function selectFrame(head,key,co)
+  local frame=head
+  -- A resumed coroutine's own phase wins over an unrelated caller's newer
+  -- phase. Creation order alone does not describe coroutine ancestry.
+  while frame do
+    if not frame.closed and frame.creator==co then return frame end
+    frame=frame[key]
+  end
+  local selected
+  frame=head
+  while frame do
+    if visible(frame,co)then
+      if not selected or within(frame,selected)then selected=frame
+      elseif not within(selected,frame)then
+        -- Lua exposes running/suspended status, not a resumer ancestry API.
+        -- Independent native roots cannot safely lend a phase to this child.
+        return nil,'ambiguous native coroutine scope'
+      end
+    end
+    frame=frame[key]
+  end
+  return selected
+end
+function M.new()
+  -- Weak heads do not keep an abandoned suspended coroutine (and the native
+  -- body on its stack) alive. Live dispatch calls retain their own frame.
+  local names=setmetatable({},{__mode='v'})
+  local latest=setmetatable({},{__mode='v'})
+  local locals=setmetatable({},{__mode='kv'})
+  local stack={}
+  function stack:find(name)
+    local co=thread()
+    if revoked[co] or locals[co]and locals[co].closed then return nil,'native coroutine scope retired'end
+    return selectFrame(names[name],'previousName',co)
+  end
+  function stack:push(name,value,parent)
+    local co=thread()
+    assert(not revoked[co]and not(locals[co]and locals[co].closed),'native coroutine scope retired')
+    parent=parent or selectFrame(latest[1],'previousAll',co)
+    assert(not parent or not parent.closed,'native coroutine scope retired')
+    local frame={name=name,value=value,creator=co,parent=parent,
+      previousName=names[name],previousAll=latest[1],previousLocal=locals[co]}
+    if parent then
+      parent.children=parent.children or setmetatable({},{__mode='k'})
+      parent.children[frame]=true
+    end
+    names[name],latest[1],locals[co]=frame,frame,frame
+    return frame
+  end
+  local function retire(frame,forced)
+    if frame.closed then return end
+    frame.closed=true
+    if forced and frame.creator~=MAIN and frame.creator~=thread()then revoked[frame.creator]=true end
+    -- A parent returning retires nested dispatches that yielded in a child.
+    -- Their later finally blocks cannot restore an expired native phase.
+    if frame.children then for child in pairs(frame.children)do retire(child,true)end end
+    if frame.parent then frame.parent.children[frame]=nil end
+    if names[frame.name]==frame then names[frame.name]=previous(frame,'previousName')end
+    if latest[1]==frame then latest[1]=previous(frame,'previousAll')end
+    frame.value,frame.body,frame.result=nil,nil,nil
+  end
+  function stack:close(frame)
+    retire(frame,false)
+    if locals[frame.creator]==frame then locals[frame.creator]=frame.previousLocal end
+  end
+  return stack
+end
+return M
diff --git a/src/compat/gen1/DecodedLayout.lua b/src/compat/gen1/DecodedLayout.lua
new file mode 100644
index 000000000..7619a9585
--- /dev/null
+++ b/src/compat/gen1/DecodedLayout.lua
@@ -0,0 +1,134 @@
+-- Legacy decoded 16px layout contract. These are mod-owned layouts,
+-- not aliases to the shared native Map or its two-bit collision grid.
+-- coll here is the old classified COLL_* byte; it is not raw GBA collision.
+local Layout = {}
+Layout.__index = Layout
+
+function Layout.fromDecoded(decoded, mapId, pair, blob)
+  local layout = setmetatable({
+    mapId = mapId, pair = pair or "sevii_outdoor",
+    width = decoded.width or 0, height = decoded.height or 0,
+    trueWidth = decoded.trueWidth or decoded.width or 0,
+    trueHeight = decoded.trueHeight or decoded.height or 0,
+    borderWidth = decoded.borderWidth or 1, borderHeight = decoded.borderHeight or 1,
+    borderMids = decoded.borderMids or { 0 }, cells = decoded.cells or {},
+    overrides = {}, _revision = 0,
+  }, Layout)
+  if blob then
+    layout._workerSource = {
+      blob = blob, cells = decoded.cells, width = decoded.width, height = decoded.height,
+      trueWidth = decoded.trueWidth or decoded.width, trueHeight = decoded.trueHeight or decoded.height,
+    }
+  end
+  return layout
+end
+
+local function outside(layout, x, y)
+  return x < 0 or y < 0 or x >= (layout.trueWidth or layout.width)
+    or y >= (layout.trueHeight or layout.height)
+end
+local function borderMid(layout, x, y)
+  return layout.borderMids[(y % layout.borderHeight) * layout.borderWidth + x % layout.borderWidth + 1] or 0
+end
+function Layout:cellAt(x, y)
+  local row = self.overrides[y * 1024 + x]
+  if row then return row end
+  if outside(self, x, y) then return { mid = borderMid(self, x, y), coll = 255, elev = 0 } end
+  return self.cells[y * self.width + x + 1] or { mid = 0, coll = 255, elev = 0 }
+end
+local baseCellAt = Layout.cellAt
+local function field(layout, x, y, key, missing, border)
+  if layout.cellAt ~= baseCellAt then return layout:cellAt(x, y)[key] end
+  local row = layout.overrides[y * 1024 + x]
+  if row then return row[key] end
+  if outside(layout, x, y) then
+    if border ~= nil then return border end
+    return borderMid(layout, x, y)
+  end
+  row = layout.cells[y * layout.width + x + 1]
+  if row then return row[key] end
+  return missing
+end
+function Layout:midAt(x, y) return field(self, x, y, "mid", 0) end
+function Layout:collAt(x, y) return field(self, x, y, "coll", 255, 255) end
+function Layout:elevAt(x, y) return field(self, x, y, "elev", 0, 0) end
+
+function Layout:collArray()
+  if self.width * self.height <= 0 then return nil end
+  local out = {}
+  for y = 0, self.height - 1 do
+    for x = 0, self.width - 1 do
+      local i = y * self.width + x + 1
+      local override, row = self.overrides[y * 1024 + x], self.cells[i]
+      -- Padding stays blocked even if a caller stored an outside override.
+      out[i] = not outside(self, x, y) and (override and override.coll or row and row.coll or 255) or 255
+    end
+  end
+  return out
+end
+
+local function invalidate(layout, coordinates)
+  local view = package.loaded["src.core.game3.field_view"]
+  if not view then return end
+  if coordinates and #coordinates <= 128 and view.invalidateLayoutCell then
+    for i = 1, #coordinates, 2 do view.invalidateLayoutCell(layout, coordinates[i], coordinates[i + 1]) end
+  else view._nativeDirty = true end
+end
+function Layout:applyOverride(x, y, mid, coll, elev)
+  self._revision = (self._revision or 0) + 1
+  x, y = tonumber(x) or 0, tonumber(y) or 0
+  self.overrides[y * 1024 + x] = { mid = tonumber(mid) or 0, coll = coll ~= nil and coll or 255, elev = elev or 0 }
+  invalidate(self, { x, y })
+end
+function Layout:setMetatiles(rows)
+  local coordinates = {}
+  for _, row in ipairs(rows or {}) do
+    local x, y = tonumber(row.x) or 0, tonumber(row.y) or 0
+    local before = self:cellAt(x, y)
+    self.overrides[y * 1024 + x] = {
+      mid = tonumber(row.mid) or before.mid or 0,
+      coll = row.coll ~= nil and row.coll or before.coll,
+      elev = row.elev ~= nil and row.elev or before.elev or 0,
+    }
+    coordinates[#coordinates + 1] = x; coordinates[#coordinates + 1] = y
+  end
+  if #coordinates > 0 then self._revision = (self._revision or 0) + 1; invalidate(self, coordinates) end
+  return #coordinates / 2
+end
+function Layout:stamp(source, ox, oy)
+  if type(source) ~= "table" or type(source.cells) ~= "table" then return 0 end
+  ox, oy = tonumber(ox) or 0, tonumber(oy) or 0
+  local count = 0
+  for y = 0, (source.trueHeight or source.height or 0) - 1 do
+    for x = 0, (source.trueWidth or source.width or 0) - 1 do
+      local row = source.cells[y * source.width + x + 1]
+      if row then
+        self.overrides[(oy + y) * 1024 + ox + x] = { mid = row.mid or 0, coll = row.coll ~= nil and row.coll or 255, elev = row.elev or 0 }
+        count = count + 1
+      end
+    end
+  end
+  invalidate(self)
+  if count > 0 then self._revision = (self._revision or 0) + 1 end
+  return count
+end
+function Layout:clearOverrides()
+  if next(self.overrides) then self.overrides = {}; self._revision = (self._revision or 0) + 1 end
+  invalidate(self)
+end
+
+function Layout:workerPacked()
+  local source = self._workerSource
+  if not source or self.cells ~= source.cells or self.width ~= source.width or self.height ~= source.height
+    or self.trueWidth ~= source.trueWidth or self.trueHeight ~= source.trueHeight
+    or self.cellAt ~= baseCellAt or self.midAt ~= Layout.midAt then return nil end
+  local assets = package.loaded["src.render.Assets"]
+  if assets and assets.loader and #assets.loader:overrideOrder() > 0 then return nil end
+  local overrides, borders = {}, {}
+  for key, row in pairs(self.overrides) do overrides[key] = { mid = row.mid } end
+  for i = 1, self.borderWidth * self.borderHeight do borders[i] = self.borderMids[i] end
+  return { blob = source.blob, off = 17 + source.blob:byte(15) * source.blob:byte(16) * 2,
+    width = self.width, trueWidth = self.trueWidth, trueHeight = self.trueHeight,
+    borderWidth = self.borderWidth, borderHeight = self.borderHeight, borderMids = borders, overrides = overrides }
+end
+return Layout
diff --git a/src/compat/gen1/FieldEffectCache.lua b/src/compat/gen1/FieldEffectCache.lua
new file mode 100644
index 000000000..4c7817682
--- /dev/null
+++ b/src/compat/gen1/FieldEffectCache.lua
@@ -0,0 +1,67 @@
+-- Explicit cache input only. No cartridge import or player filesystem I/O.
+local M={}
+local function integer(n,lo,hi)return type(n)=='number'and n==n and n%1==0 and n>=lo and n<=hi end
+local function copy(v,state,depth)
+  local kind=type(v)
+  if kind=='number'then assert(v==v and math.abs(v)<math.huge,'nonfinite field metadata');return v end
+  if kind=='string'then assert(#v<=4096,'field metadata string limit');return v end
+  if kind=='boolean'or kind=='nil'then return v end
+  assert(kind=='table'and depth<24 and not state.seen[v],'invalid field metadata table')
+  assert(getmetatable(v)==nil,'field metadata metatable unavailable')
+  state.seen[v]=true;local out={}
+  for k,x in pairs(v)do
+    state.nodes=state.nodes+1;assert(state.nodes<=65536,'field metadata node limit')
+    assert(type(k)=='string'and#k<=256 or integer(k,-65536,65536),'invalid field metadata key')
+    out[k]=copy(x,state,depth+1)
+  end
+  state.seen[v]=nil;return out
+end
+local function decode(bytes)
+  if type(bytes)~='string'or#bytes>1048576 then return nil,'field manifest size limit'end
+  if bytes:byte(1)==27 then return nil,'field manifest must be text'end
+  local chunk,why
+  if setfenv then chunk,why=loadstring(bytes,'@field-effect-manifest');if chunk then setfenv(chunk,{})end
+  else chunk,why=load(bytes,'@field-effect-manifest','t',{})end
+  if not chunk then return nil,why end
+  if jit and jit.off then jit.off(chunk,true)end
+  local hook,mask,count=debug.gethook()
+  debug.sethook(function()error('field manifest instruction limit')end,'',200000)
+  local ok,result=pcall(chunk);debug.sethook(hook,mask,count)
+  if not ok or type(result)~='table'then return nil,'invalid field manifest'end
+  local safe,value=pcall(copy,result,{nodes=0,seen={}},0)
+  if not safe then return nil,tostring(value)end
+  return value
+end
+local function relative(path)
+  if type(path)~='string'or#path==0 or#path>256 or path:sub(1,1)=='/'or path:find('[\\:%z]')then return false end
+  for part in path:gmatch('[^/]+')do if part=='..'or part=='.'then return false end end
+  return not path:find('//',1,true)
+end
+function M.manifest(cache,root,family)
+  local bytes=cache:read(root..'/objects.lua')
+  if bytes==nil then return nil end
+  local manifest,why=decode(bytes);if not manifest then return nil,why end
+  if manifest.family and manifest.family~=family then return nil,'field manifest belongs to another cartridge family'end
+  local names={}
+  for _,key in ipairs({'objects','extras'})do
+    local list=manifest[key]
+    if list~=nil and type(list)~='table'then return nil,'invalid field object list'end
+    for _,row in pairs(list or{})do
+      if type(row)~='table'or type(row.name)~='string'or not row.name:match('^[%w_%-]+$')or#row.name>80
+          or not integer(row.fw,8,128)or not integer(row.fh,8,128)or not integer(row.frames,1,256)
+          or row.fw*row.fh*row.frames>1048576 or not relative(row.rgba)then
+        return nil,'invalid field object geometry or path'
+      end
+      if names[row.name]then return nil,'ambiguous field object name'end
+      names[row.name]=row
+    end
+  end
+  manifest._byName=names;return manifest
+end
+function M.rgba(cache,root,row)
+  local bytes=cache:read(root..'/'..row.rgba)
+  if type(bytes)~='string'or#bytes~=row.fw*row.fh*row.frames*4 then return nil,'invalid field RGBA payload'end
+  return bytes
+end
+M.copy=function(value)return copy(value,{nodes=0,seen={}},0)end
+return M
diff --git a/src/compat/gen1/FieldEffectRuntime.lua b/src/compat/gen1/FieldEffectRuntime.lua
new file mode 100644
index 000000000..c06e2cfe4
--- /dev/null
+++ b/src/compat/gen1/FieldEffectRuntime.lua
@@ -0,0 +1,147 @@
+-- Owned field-effect artwork over the native dataset or an explicit cache.
+-- This service has no actor, animation, task, RNG or gameplay clock.
+local Session=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Catalog=require('src.render.Gen3FieldEffectCatalog')
+local Cache=require('src.compat.gen1.FieldEffectCache')
+local Assets=require('src.render.Assets')
+local R={};R.__index=R
+local ENGINE={}
+local function owner()
+  local runtime=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+  return runtime and runtime.currentMod or facade and facade._callbackOwner and facade._callbackOwner()or ENGINE
+end
+local function release(value)if value and value.release then pcall(value.release,value)end end
+local function root()
+  local extract=package.loaded['src.import.gba.extract_island1']
+  return ((extract and extract.CACHE_ROOT)or'data/generated/gba')..'/field_effects'
+end
+local function signature(r)return table.concat({r.path or r.rgba,r.fw,r.fh,r.frames},'\0')end
+function R.new()
+  return setmetatable({loaded={},owned={},providers={},bytes=0,maxBytes=64*1024*1024},R)
+end
+function R:drop(sheet)
+  local held=self.owned[sheet];if not held then return end
+  self.owned[sheet]=nil;self.bytes=self.bytes-held.bytes
+  -- Public sheet tables are mutable. Retire only allocations recorded at
+  -- construction, never an image/quad a mod later assigned to that table.
+  for _,part in ipairs(held.parts)do release(part)end
+  sheet.image,sheet.imageData,sheet.quads,sheet.quadsFront=nil,nil,{},{};sheet._retired=true
+end
+function R:invalidate()
+  for sheet in pairs(self.owned)do self:drop(sheet)end
+  self.loaded={};self.context=nil
+end
+function R:release()self:invalidate();self.providers={}end
+function R:current()
+  local game,why=Session.game();local edition=Version.get()
+  if not(game and type(game.data)=='table'and type(game.data.constants)=='table')then
+    self:release();return nil,why or'no native field-effect dataset'
+  end
+  local provider
+  for i=#self.providers,1,-1 do
+    local p=self.providers[i]
+    if p.game==game and p.data==game.data and p.save==game.save and p.mods==game.mods and p.edition==edition then
+      provider=provider or p
+    else table.remove(self.providers,i)end
+  end
+  local c=self.context;local prefix=root()
+  if c and(c.game~=game or c.data~=game.data or c.constants~=game.data.constants or c.sprites~=game.data.sprites
+      or c.save~=game.save or c.mods~=game.mods or c.edition~=edition or c.provider~=provider
+      or c.root~=prefix or c.assets~=Assets.loader)then self:invalidate();c=nil end
+  if not c then
+    c={game=game,data=game.data,constants=game.data.constants,sprites=game.data.sprites,
+      save=game.save,mods=game.mods,edition=edition,provider=provider,root=prefix,assets=Assets.loader}
+    self.context=c
+  end
+  return c
+end
+function R:install(cache)
+  if cache~=nil and(type(cache)~='table'or type(cache.read)~='function')then return nil,'invalid field cache provider'end
+  local c,why=self:current();if not c then return nil,why end
+  local who=owner()
+  for i=#self.providers,1,-1 do if self.providers[i].owner==who then table.remove(self.providers,i)end end
+  if cache then self.providers[#self.providers+1]={owner=who,cache=cache,game=c.game,data=c.data,save=c.save,mods=c.mods,edition=c.edition}end
+  self:invalidate();return self:manifest()
+end
+function R:catalog()
+  local c,why=self:current();if not c then return nil,why end
+  if c.provider and not c.providerRead then
+    c.providerRead=true
+    local ok,manifest,err=pcall(Cache.manifest,c.provider.cache,c.root,Version.isFRLG(c.edition)and'frlg'or'rse')
+    if not ok then c.manifestError=tostring(manifest)else c.manifest,c.manifestError=manifest,err end
+    if self:current()~=c then return nil,'field cache cohort retired during manifest read'end
+  end
+  if c.manifestError then return nil,c.manifestError end
+  return c
+end
+function R:manifest()
+  local c,why=self:catalog();if not c then return nil,why end
+  if c.manifest then return Cache.copy(c.manifest)end
+  local manifest={family=Version.isFRLG(c.edition)and'frlg'or'rse',objects={},extras={},_byName={}}
+  for name,row in pairs(Catalog.records(c.data))do
+    local item={name=name,fw=row.fw,fh=row.fh,frames=row.frames,nativePath=row.path}
+    manifest.objects[#manifest.objects+1]=item;manifest._byName[name]=item
+  end
+  table.sort(manifest.objects,function(a,b)return a.name<b.name end)
+  return manifest
+end
+function R:record(name)
+  if type(name)~='string'or#name>80 or not name:match('^[%w_%-]+$')then return nil,'invalid field sheet name'end
+  local c,why=self:catalog();if not c then return nil,why end
+  if c.manifest then
+    local row=c.manifest._byName[name]
+    if not row then return nil,'field sheet absent from installed manifest'end
+    return row,c,true
+  end
+  local row=Catalog.records(c.data)[name]
+  if not row then return nil,'native field sheet unavailable'end
+  return row,c,false
+end
+function R:get(name)
+  local row,c,explicit=self:record(name);if not row then return nil,c end
+  local sig=signature(row)
+  if not explicit then sig=sig..'\0'..Assets.resolve(row.path)end
+  local cached=self.loaded[name];local held=cached and self.owned[cached]
+  if held and held.signature==sig then held.owners[owner()]=true;return cached end
+  if cached then self:drop(cached);self.loaded[name]=nil end
+  if not(love and love.image and love.graphics)then return nil,'field sheet graphics unavailable'end
+  local size=row.fw*row.fh*row.frames*8
+  if self.bytes+size>self.maxBytes then return nil,'owned field sheet budget exhausted'end
+  local parts={};local function keep(x)parts[#parts+1]=x;return x end
+  local ok,sheet=pcall(function()
+    local data
+    if explicit then
+      local bytes,why=Cache.rgba(c.provider.cache,c.root,row);assert(bytes,why)
+      data=keep(love.image.newImageData(row.fw,row.fh*row.frames,'rgba8',bytes))
+    else data=keep(love.image.newImageData(Assets.resolve(row.path)))end
+    assert(data:getWidth()==row.fw and data:getHeight()==row.fh*row.frames,'field sheet image dimensions differ')
+    local limits=love.graphics.getSystemLimits and love.graphics.getSystemLimits()
+    assert(not limits or row.fh*row.frames<=limits.texturesize,'field sheet exceeds GPU limit')
+    local image=keep(love.graphics.newImage(data));image:setFilter('nearest','nearest')
+    local made={image=image,imageData=data,fw=row.fw,fh=row.fh,frames=row.frames,quads={},quadsFront={}}
+    for i=0,row.frames-1 do
+      made.quads[i]=keep(love.graphics.newQuad(0,i*row.fh,row.fw,row.fh,row.fw,row.fh*row.frames))
+      made.quadsFront[i]=keep(love.graphics.newQuad(0,i*row.fh+row.fh-8,row.fw,8,row.fw,row.fh*row.frames))
+    end
+    assert(self:current()==c,'field sheet cohort retired during preparation')
+    local latest,context,provider=self:record(name)
+    assert(context==c and provider==explicit and signature(latest)==signature(row)
+      and(explicit or sig==signature(latest)..'\0'..Assets.resolve(latest.path)),'field sheet record changed during preparation')
+    assert(self.bytes+size<=self.maxBytes,'owned field sheet budget exhausted during preparation')
+    return made
+  end)
+  if not ok then for _,part in ipairs(parts)do release(part)end;return nil,tostring(sheet)end
+  self.owned[sheet]={signature=sig,bytes=size,parts=parts,owners={[owner()]=true}};self.bytes=self.bytes+size
+  self.loaded[name]=sheet;return sheet
+end
+function R:releaseOwner(who)
+  for i=#self.providers,1,-1 do if self.providers[i].owner==who then table.remove(self.providers,i)end end
+  for name,sheet in pairs(self.loaded)do
+    local held=self.owned[sheet]
+    if held then held.owners[who]=nil;if next(held.owners)==nil then self:drop(sheet);self.loaded[name]=nil end end
+  end
+  self:current()
+end
+function R:poll()self:current()end
+return R
diff --git a/src/compat/gen1/FieldMoveRuntime.lua b/src/compat/gen1/FieldMoveRuntime.lua
new file mode 100644
index 000000000..cf4cc368d
--- /dev/null
+++ b/src/compat/gen1/FieldMoveRuntime.lua
@@ -0,0 +1,137 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Bind compatible field-move operations to the actual native stack state.
+local Session=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local R={};R.__index=R
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function owner()
+  local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+  return host and host.currentMod or facade and facade._callbackOwner and facade._callbackOwner()
+end
+local function current(c)
+  return not c.retired and c.game.data==c.data and c.game.save==c.save and c.game.mods==c.mods and Version.get()==c.edition
+end
+function R.new()return setmetatable({records=setmetatable({},{__mode='kv'}),callbacks=setmetatable({},{__mode='k'})},R)end
+function R:bind(state)
+  local c=self.records[state];if c then return current(c)and state:valid(false)and c or nil end
+  local game=Session.game(state.game);if not(game and state:valid(false))then return nil end
+  c={state=state,game=game,data=game.data,save=game.save,mods=game.mods,edition=Version.get(),owner=owner(),sourceStarted=state.sourceOwned==true}
+  c.nativeCallback=state.onDone
+  local callback=c.nativeCallback
+  local admission=setmetatable({state},{__mode='v'})
+  c.continue=function()
+    if c.detachedCallback then return c.detachedCallback()end
+    if c.cancelled then return false,'native field move owner retired'end
+    if c.error then error(c.error,0)end
+    if c.result then return unpack(c.result,1,c.result.n)end
+    if c.running then return false,'native field move continuation is already executing'end
+    local live=admission[1]
+    if not(c.exited and c.completed and live and live.callbackReady)then return false,'native field move has not completed'end
+    c.running=true;local fn=callback;callback=nil;c.nativeCallback=nil;admission[1]=nil
+    local result=pack(pcall(function()if fn then return fn()end end));fn=nil;c.running=false
+    if not result[1]then c.error=result[2];error(result[2],0)end
+    c.result={n=result.n-1};for i=2,result.n do c.result[i-1]=result[i]end
+    return unpack(c.result,1,c.result.n)
+  end
+  c.forgetCallback=function()callback=nil;c.nativeCallback=nil;admission[1]=nil end
+  state.onDone=c.continue;c.installed=c.continue;self.records[state]=c;self.callbacks[c]=true
+  return c
+end
+function R:current()
+  local game=Session.game();if not game then return nil end
+  local class=package.loaded['src.world.Gen3FieldMove']
+  if not class then return nil end
+  for i=#(game.stack and game.stack.states or{}),1,-1 do
+    local state=game.stack.states[i]
+    if getmetatable(state)==class and not state.done then return self:bind(state)end
+  end
+end
+function R:exit(state)
+  local c=self.records[state];if not c or c.exited then return end
+  c.exited=true;c.completed=state.completed==true and current(c)
+  if not c.completed then c.forgetCallback()end
+  self.records[state]=nil;c.retired=true;c.state,c.game,c.data,c.save,c.mods=nil,nil,nil,nil,nil
+end
+function R:detach(c)
+  local state=c.state
+  if state and state.onDone==c.installed then state.onDone=c.nativeCallback
+  elseif state then c.detachedCallback=c.nativeCallback end
+  c.forgetCallback();c.retired=true
+  if state then self.records[state]=nil end
+  c.state,c.game,c.data,c.save,c.mods=nil,nil,nil,nil,nil
+end
+local function cancelCallback(c)
+  c.cancelled=true;c.result=nil;c.error=nil;c.forgetCallback()
+end
+function R:release()
+  local selected={};for c in pairs(self.callbacks)do selected[#selected+1]=c end
+  for _,c in ipairs(selected)do
+    if c.sourceStarted then
+      if c.state then c.state:retire()end;cancelCallback(c)
+    elseif c.state then self:detach(c)end
+  end
+  self.records=setmetatable({},{__mode='kv'})
+end
+function R:cancelOwner(who)
+  local selected={}
+  for c in pairs(self.callbacks)do if c.owner==who then selected[#selected+1]=c end end
+  for _,c in ipairs(selected)do
+    if c.sourceStarted then
+      if c.state then c.state:retire()end;cancelCallback(c)
+    elseif c.state then self:detach(c)end
+  end
+  return #selected>0
+end
+function R:mon(game,value)
+  local mon=type(value)=='table'and value or{species=value};local out={}
+  for k,v in pairs(mon)do out[k]=v end
+  if type(out.species)=='number'and not(game.data.pokemon and game.data.pokemon[out.species])then out.species=(game.data.constants.speciesOrder or{})[out.species]or out.species end
+  if not(game.data.pokemon and game.data.pokemon[out.species])then return nil,'native species artwork unavailable'end
+  if mon.isShiny~=nil then out.shiny=mon.isShiny==true end
+  return out
+end
+function R:start(mon,opts,callback)
+  local game,world=Session.resolve()
+  if not(game and world and Session.acceptsInput(game,world,world.player))then return false,'no available native field-move owner'end
+  if self:current()then return false,'native field move is busy'end
+  local converted,why=self:mon(game,mon);if not converted then return false,why end
+  opts=opts or{};if type(opts)~='table'or(callback~=nil and type(callback)~='function')then return false,'invalid field move options'end
+  return require('src.world.Gen3FieldMove').show(game,converted,callback,
+    {presentation='cartridge',pose=opts.pose==true,noDuck=opts.noDuck==true,sourceStarted=true,sourceOwner=owner()})
+end
+function R:configure(c,mon,opts,callback)
+  if not(current(c)and c.state:valid(true))then return false,'native field move admission retired'end
+  if c.configured then return true end
+  opts=opts or{};assert(type(opts)=='table','invalid field move options')
+  local converted,why=self:mon(c.game,mon);if not converted then return false,why end
+  local ok,err=c.state:configure(converted,opts,callback);if not ok then return false,err end
+  c.installed=callback
+  c.owner=c.owner or owner();c.configured=true
+  return true
+end
+function R:phase(c,name,body,fn,...)
+  if not c or not current(c)or not c.state:valid(name=='step')then return false,'native field move admission retired'end
+  local result=pack(Boundary.dispatch('field_move.'..name,body,fn,...))
+  if c.error then error(c.error,0)end
+  return unpack(result,1,result.n)
+end
+function R:reset()
+  local c=self:current();if not c then return false end
+  local who=owner();if c.owner and who and c.owner~=who then return false,'native field move belongs to another mod'end
+  return c.state:complete(false)
+end
+function R:snapshot()
+  local c=self:current();local fx=c and c.state.effect
+  if not fx then return nil end
+  local out={}
+  for k,v in pairs(fx)do if type(v)~='table'and type(v)~='function'then out[k]=v end end
+  if fx.sprite then out.sprite={};for k,v in pairs(fx.sprite)do out.sprite[k]=v end end
+  local order=c.data.constants.speciesOrder or{}
+  for id,species in pairs(order)do if species==fx.species then out.species=id;break end end
+  out.shiny=require('src.pokemon.Pokemon').isShiny(c.state.mon)
+  out.picSpecies=out.species
+  return out
+end
+return R
diff --git a/src/compat/gen1/MapRuntime.lua b/src/compat/gen1/MapRuntime.lua
new file mode 100644
index 000000000..1d28a9588
--- /dev/null
+++ b/src/compat/gen1/MapRuntime.lua
@@ -0,0 +1,203 @@
+-- Compatibility map observations over one native session. Never loads a map,
+-- runs a script/player, or lends native definitions to compatibility writers.
+local Identity = require('src.compat.gen1.MapIdentity')
+local PairIdentity = require('src.compat.gen1.PairIdentity')
+local Views = require('src.compat.gen1.MapViews')
+local Version = require('src.core.GameVersion')
+local Connections = require('src.core.game3.connections')
+local M = {}
+local mapTypes = {NONE=0,TOWN=1,CITY=2,ROUTE=3,UNDERGROUND=4,UNDERWATER=5,OCEAN_ROUTE=6,UNKNOWN=7,INDOOR=8,SECRET_BASE=9}
+local function numericBoolean(v) if v == nil then return nil end; return (v == true or v == 1) and 1 or 0 end
+local function copy(v)
+  if type(v) ~= 'table' then return v end
+  local out = {}; for k, value in pairs(v) do out[k] = copy(value) end; return out
+end
+local overworld=require('src.compat.gen1.NativeSession').world
+function M.new(getGame, getEdition)
+  assert(type(getGame)=='function' and type(getEdition)=='function','native session resolvers required')
+  local handle = {}
+  local views = Views.new(getGame,getEdition)
+  local observing=false
+  local owner,data,nativeMaps,edition,binding,pairBinding,epoch
+  local maps,known,published,loaded = {},setmetatable({},{__mode='k'}),{},{}
+  local ended,allIndexed = false,false
+  local function clear()
+    if observing or ended then
+      views:release();views=not ended and Views.new(getGame,getEdition)or nil;observing=false
+    end
+    if pairBinding then pairBinding:release() end
+    owner,data,nativeMaps,edition,binding,pairBinding,epoch=nil,nil,nil,nil,nil,nil,nil
+    maps,known,published,loaded={},setmetatable({},{__mode='k'}),{},{}
+    allIndexed=false
+  end
+  local function session()
+    if ended then return nil,'map runtime released' end
+    local game,id=getGame(),getEdition()
+    local info=Version.info(id)
+    if type(game)~='table' or not info or info.generation~=3 or not Identity.lookup(id,0,0)
+        or type(game.data)~='table' or type(game.data.maps)~='table' then
+      clear();return nil,'no native GBA session'
+    end
+    if game~=owner or data~=game.data or nativeMaps~=game.data.maps or edition~=id then
+      clear();owner,data,nativeMaps,edition=game,game.data,game.data.maps,id
+      binding=Identity.bind(nativeMaps,id);epoch={}
+      if type(data.tilesets)=='table' and type(data.map_tilesets)=='table' then
+        pairBinding=PairIdentity.bind(data.tilesets,data.map_tilesets,id)
+      end
+    end
+    return game
+  end
+  local function resolve(id)
+    local native,def=binding:nativeId(id)
+    if not native then
+      local canonical=binding:legacyId(id)
+      if canonical then native,def=binding:nativeId(canonical) end
+    end
+    if native then return native,def,binding:legacyId(native) end
+    return nil,'map identity unavailable or retired'
+  end
+  local function destination(id)
+    local canonical=binding:legacyId(id)
+    if canonical then return canonical end
+    if type(id)=='string' then
+      local g,n=id:match('^MAP_G(%d+)_N(%d+)$')
+      if g then return Identity.lookup(edition,tonumber(g),tonumber(n)) end
+      return Identity.lookup(edition,id)
+    end
+  end
+  function handle:definition(id)
+    local game,why=session();if not game then return nil,why end
+    local native,def,canonical=resolve(id);if not native then return nil,def end
+    local prior=maps[canonical]
+    if prior then return prior end
+    local pair=pairBinding and pairBinding:descriptor(def.tileset)
+    if not pair or type(pair.tileset)~='string'then return nil,'source tileset pair identity unavailable' end
+    local kind=mapTypes[def.mapType] or tonumber(def.mapType) or 0
+    local indoor=kind==4 or kind==8 or kind==9
+    local rows={}
+    for _,row in ipairs(def.sourceConnections or {})do
+      local target=destination(row.map)
+      if not target then return nil,'connection identity unavailable' end
+      rows[#rows+1]={dir=row.dir,map=target,offset=row.offset}
+    end
+    if def.connections and next(def.connections) and not def.sourceConnections then
+      return nil,'original connection order unavailable'
+    end
+    local warps={}
+    for _,row in ipairs(def.warps or {})do
+      local converted=copy(row);converted.nativeDestination=row.destMap;converted.destMap=destination(row.destMap)
+      if not converted.destMap and type(row.destMap)=='string' then
+        local g,n=row.destMap:match('^MAP_G(%d+)_N(%d+)$')
+        converted.mapGroup,converted.mapNum=tonumber(g),tonumber(n)
+      end
+      warps[#warps+1]=converted
+    end
+    local cycling,escaping,running=numericBoolean(def.allowCycling),numericBoolean(def.allowEscaping),numericBoolean(def.allowRunning)
+    local show=numericBoolean(def.showMapName)or 0
+    local flags=tonumber(def.flags)
+    if edition=='ruby'or edition=='sapphire'then
+      -- RS policies are type-based; byte 26 is the source name-popup value,
+      -- not Emerald's permission bit field. Preserve native state separately.
+      cycling=(kind~=8 and kind~=9 and kind~=5)and 1 or 0
+      local name=canonical:sub(4)
+      if name=='ROUTE110_SEASIDE_CYCLING_ROAD_SOUTH_ENTRANCE'or name=='ROUTE110_SEASIDE_CYCLING_ROAD_NORTH_ENTRANCE'then cycling=1 end
+      if name=='SEAFLOOR_CAVERN_ROOM9'or name=='CAVE_OF_ORIGIN_B4F'then cycling=0 end
+      escaping=kind==4 and 1 or 0;running=kind==8 and 0 or 1
+      if flags then show=flags==1 and 1 or 0 end
+    elseif flags then
+      local shift=(edition=='firered'or edition=='leafgreen')and 4 or 8
+      show=math.floor(flags/shift)==1 and 1 or 0
+    end
+    local view={id=canonical,name=canonical,nativeId=native,nativePair=def.tileset,
+      width=def.width,height=def.height,kind=indoor and 'indoor' or (kind==3 and 'route' or 'town'),
+      environment=indoor and 'INDOOR' or (kind==3 and 'ROUTE' or 'TOWN'),pair=pair.id,tileset=pair.tileset,
+      connections=rows,warps=warps,regionMapSectionId=def.regionMapSection,
+      showMapName=show,floorNum=def.floorNum or 0,
+      weather=def.weather or 0,mapType=kind,cave=numericBoolean(def.cave),
+      allowEscaping=escaping,allowRunning=running,
+      bikingAllowed=cycling,battleType=def.battleScene,music=def.music,
+      borderWidth=def.sourceBorderWidth,borderHeight=def.sourceBorderHeight,native=true}
+    for _,row in ipairs(rows)do
+      if row.dir=='dive'or row.dir=='emerge'then view[row.dir]={map=row.map,offset=tonumber(row.offset)or 0}end
+    end
+    local weak=setmetatable({handle},{__mode='v'});local generation=epoch
+    setmetatable(view,{__index=function(_,key)
+      local runtime=weak[1]
+      if key=='midLayout' and runtime then return runtime:layout(canonical,view,generation) end
+    end})
+    known[view]=generation;maps[canonical]=view
+    return view
+  end
+  function handle:layout(id,def,generation)
+    local game,why=session();if not game then return nil,why end
+    if def and (known[def]~=epoch or (generation and generation~=epoch))then
+      return nil,'owned map definition retired'
+    end
+    if not def then def,why=self:definition(id);if not def then return nil,why end end
+    observing=true
+    local view;view,why=views:map(id);if not view then return nil,why end
+    local prior=published[def.id]
+    if prior~=view then
+      local previous=prior and prior.midLayout
+      view.midLayout.pair=def.pair
+      view.midLayout._revision=math.max(view.revision,(previous and previous._revision or 0)+1)
+      published[def.id]=view
+    end
+    loaded[def.id]=true
+    return view.midLayout
+  end
+  function handle:definitions()
+    local game,why=session();if not game then return nil,why end
+    if allIndexed then return maps end
+    for key in pairs(nativeMaps)do
+      local canonical=binding:legacyId(key)
+      if canonical then
+        local def,err=self:definition(canonical);if not def then return nil,err end
+      end
+    end
+    allIndexed=true
+    return maps
+  end
+  function handle:current()
+    local game,why=session();if not game then return nil,why end
+    local ow=overworld(game)
+    if not (ow and ow.map and nativeMaps[ow.map.id]==ow.map.def)then
+      allIndexed=false;views:current();return nil,'no active native map'
+    end
+    local def;def,why=self:definition(ow.map.id);if not def then return nil,why end
+    local layout;layout,why=self:layout(def.id,def);if not layout then return nil,why end
+    return def
+  end
+  function handle:neighbors(def)
+    def=def or self:current()
+    if not def or known[def]~=epoch then return {},{} end
+    local list,byDir={},{}
+    for _,row in ipairs(def.connections or {})do
+      local target=self:definition(row.map)
+      if target and Connections.cardinal(row.dir) then
+        local layout=self:layout(row.map,target)
+        if layout then
+          local record={dir=row.dir,map=row.map,mapId=row.map,offset=row.offset,def=target}
+          list[#list+1]=record;byDir[row.dir]=byDir[row.dir]or record
+        end
+      end
+    end
+    return byDir,list
+  end
+  function handle:loadedCount()
+    local n=0;for _ in pairs(loaded)do n=n+1 end;return n
+  end
+  function handle:invalidate(id)
+    local game=session();if not game then return end
+    views:invalidate(id)
+    if id==nil then clear() end
+  end
+  function handle:isOwned(def) session();return epoch~=nil and known[def]==epoch end
+  function handle:loadedLayouts() session();return loaded end
+  function handle:release()
+    if ended then return end
+    ended=true;clear();getGame,getEdition=nil,nil
+  end
+  return handle
+end
+return M
diff --git a/src/compat/gen1/MapViews.lua b/src/compat/gen1/MapViews.lua
new file mode 100644
index 000000000..cae5d712b
--- /dev/null
+++ b/src/compat/gen1/MapViews.lua
@@ -0,0 +1,215 @@
+-- Owned compatibility snapshots over the native map owner. No map loads,
+-- renderer construction, shared-definition writes or save access.
+local Views = {}
+local editions = { firered = true, leafgreen = true, emerald = true, ruby = true, sapphire = true }
+local directions = {north=true,south=true,east=true,west=true,dive=true,emerge=true}
+local function uint(n, max)
+  return type(n) == "number" and n >= 0 and n <= max and n % 1 == 0
+end
+local function same(a, b)
+  if not a or #a ~= #b then return false end
+  for i = 1, #a do if a[i] ~= b[i] then return false end end
+  return true
+end
+local world=require('src.compat.gen1.NativeSession').world
+local function kind(mapType)
+  local numbers = {NONE=0,TOWN=1,CITY=2,ROUTE=3,UNDERGROUND=4,UNDERWATER=5,OCEAN_ROUTE=6,UNKNOWN=7,INDOOR=8,SECRET_BASE=9}
+  mapType = numbers[mapType] or tonumber(mapType) or 0
+  if mapType == 4 or mapType == 8 or mapType == 9 then return "indoor", "INDOOR" end
+  -- Match the public census registration, including its ocean/underwater
+  -- classification, rather than silently changing imported mod semantics.
+  if mapType == 3 then return "route", "ROUTE" end
+  return "town", "TOWN"
+end
+
+function Views.new(getGame, getEdition)
+  assert(type(getGame) == "function" and type(getEdition) == "function", "native map view resolvers required")
+  -- Companion contracts are loaded on construction, never by a native boot
+  -- that does not request compatibility observations.
+  local Identity = require("src.compat.gen1.MapIdentity")
+  local Behavior = require("src.compat.gen1.MetatileBehavior")
+  local Classes = require("src.compat.gen1.CollisionClass")
+  local Layout = require("src.compat.gen1.DecodedLayout")
+  local Tiles = require("src.render.Gen3Tiles")
+  local Versions = require("src.core.GameVersion")
+  local function weakCache() return setmetatable({}, {__mode = "v"}) end
+  local owner, data, maps, edition, binding, cache, ended = nil, nil, nil, nil, nil, weakCache(), false
+  local serial, published = 0, setmetatable({}, {__mode = "k"})
+  local ids = setmetatable({}, {__mode = "k"})
+  local function token(value)
+    if type(value) ~= "table" then return value or false end
+    if not ids[value] then ids[value] = {} end
+    return ids[value]
+  end
+  local handle = {}
+  local function reset() cache = weakCache(); binding = nil; owner, data, maps, edition = nil, nil, nil, nil end
+  local function currentOwner()
+    if ended then return nil, "map view owner released" end
+    local game, id = getGame(), getEdition()
+    if type(game) ~= "table" or not editions[id] or not Versions.info(id)
+        or not game.data or type(game.data.maps) ~= "table" then
+      reset(); return nil, "no native GBA session"
+    end
+    local ow = world(game)
+    if not (ow and ow.map and game.data.maps[ow.map.id] == ow.map.def) then
+      reset(); return nil, "no active native map"
+    end
+    if game ~= owner or game.data ~= data or game.data.maps ~= maps or id ~= edition then
+      reset(); owner, data, maps, edition = game, game.data, game.data.maps, id
+      binding = Identity.bind(maps, edition)
+    end
+    return ow
+  end
+  local function loaded(ow, id, def)
+    if ow.map.id == id or ow.map.def == def then return ow.map end
+    for _, row in ipairs(ow.neighbors or {}) do
+      if row.map and (row.map.id == id or row.map.def == def) then return row.map end
+    end
+  end
+  local function build(id)
+    local ow, why = currentOwner(); if not ow then return nil, why end
+    local nativeId, def = binding:nativeId(id)
+    if not nativeId and maps[id] then
+      local alias = binding:legacyId(id)
+      if alias then nativeId, def = binding:nativeId(alias) end
+    end
+    if not nativeId then return nil, "map identity unavailable" end
+    local canonical = binding:legacyId(nativeId)
+    local live = loaded(ow, nativeId, def)
+    if live and live.def ~= def then return nil, "resident map definition changed" end
+    local w, h = def.width, def.height
+    if not uint(w, 1024) or w == 0 or not uint(h, 1024) or h == 0 or def.blockPx ~= 16 then
+      return nil, "native layout dimensions unavailable"
+    end
+    local sets, constants = data.map_tilesets, data.constants
+    local pair = data.tilesets and data.tilesets[def.tileset]
+    local a = pair and sets and sets[pair.primaryKey]
+    local b = pair and sets and sets[pair.secondaryKey]
+    local geometry = constants and constants.gen3Layout
+    if not (a and b and geometry and Tiles.sourceBehavior
+        and uint(geometry.metatilesInPrimary,1023) and geometry.metatilesInPrimary > 0
+        and uint(geometry.tilesInPrimary,1023) and geometry.tilesInPrimary > 0
+        and uint(geometry.palettesInPrimary,15) and geometry.palettesInPrimary > 0
+        and geometry.metatileLayers == 2) then return nil, "original tileset attributes unavailable" end
+    local rawFlags = constants.gen3SourceBehaviorFlags
+    local frlg = edition == "firered" or edition == "leafgreen"
+    if not frlg and not (rawFlags and rawFlags.version == 1 and type(rawFlags.raw) == "string"
+        and #rawFlags.raw == 240 and rawFlags.romSha1 == Versions.info(edition).sha1) then
+      return nil, "original terrain flags unavailable"
+    end
+    local bw, bh, border = def.sourceBorderWidth, def.sourceBorderHeight, def.sourceBorder
+    if not uint(bw, 255) or bw == 0 or not uint(bh, 255) or bh == 0
+        or type(border) ~= "string" or #border ~= bw * bh * 2 then return nil, "original border unavailable" end
+    if def.connections and next(def.connections) and not def.sourceConnections then
+      return nil, "original connection order unavailable"
+    end
+    local decodedBlocks = def._blockArraySource == def.blocks and def._blockArray
+    local stamp = {token(owner),token(maps),edition,token(def), token(live), live and live.gridRevision or 0,
+      token(def.blocks), token(def.collisionCells), token(def.elevationCells), token(def.sourceConnections), token(def.warps), w, h,
+      token(decodedBlocks),
+      token(a), token(b), a.attributes or false, b.attributes or false, a.sourceAttributes or false, b.sourceAttributes or false,
+      a.sourceAttributeBytes or false, b.sourceAttributeBytes or false,
+      a.sourceBehaviorMask or false, b.sourceBehaviorMask or false,
+      rawFlags and rawFlags.raw or false, border, bw, bh, token(geometry), geometry.metatilesInPrimary,
+      geometry.tilesInPrimary,geometry.palettesInPrimary,geometry.metatileLayers,def.mapType or 0}
+    local cached = cache[nativeId]
+    if cached and same(published[cached].stamp, stamp) then return cached end
+    local terrain = Tiles.new({primary = a, secondary = b}, geometry)
+    local flags = {}
+    if not frlg then
+      for raw = 0, 239 do
+        local bits = rawFlags.raw:byte(raw + 1)
+        if bits > 7 then return nil, "invalid original terrain flags" end
+        flags[Behavior.fromRaw(edition, raw)] = bits
+      end
+    end
+    local classify = Classes.new(frlg and "frlg" or "rse", flags)
+    local mapKind, environment = kind(def.mapType)
+    local warps = {}
+    for _, row in ipairs(def.warps or {}) do
+      if uint(row.x, w - 1) and uint(row.y, h - 1) then warps[row.y * w + row.x + 1] = true end
+    end
+    local paddedW, paddedH = w + w % 2, h + h % 2
+    local cells = {}
+    for y = 0, paddedH - 1 do for x = 0, paddedW - 1 do
+      local sx, sy = math.min(x, w - 1), math.min(y, h - 1)
+      local index = sy * w + sx + 1
+      local mid = live and live.blockPatch and live.blockPatch[index]
+      if mid == nil then
+        local blocks = decodedBlocks or def.blocks
+        if type(blocks) == "table" then mid = blocks[index]
+        elseif type(blocks) == "string" and #blocks >= index * 2 then
+          mid = (blocks:byte(index * 2 - 1) + blocks:byte(index * 2) * 256) % 1024
+        end
+      end
+      local collision = live and live.collisionPatch and live.collisionPatch[index]
+      if collision == nil then collision = def.collisionCells and def.collisionCells[index] end
+      local elevation = live and live.elevationPatch and live.elevationPatch[index]
+      if elevation == nil then elevation = def.elevationCells and def.elevationCells[index] end
+      if not uint(mid, 1023) or not uint(collision, 3) or not uint(elevation, 15) then return nil, "native cell source unavailable" end
+      if mapKind == "indoor" and (x >= w or y >= h) then mid, collision, elevation = 0, 1, 0 end
+      local raw = terrain:sourceBehavior(mid)
+      if raw == nil then return nil, "original cell behavior unavailable" end
+      local behavior = Behavior.fromRaw(edition, raw)
+      local coll = classify.fromCell(mid, collision, behavior, mapKind)
+      -- Resolve the native pack's final blocking guard after classification.
+      -- These are the land classes emitted by our classifier; water, walls
+      -- and directional ledges retain their own categories.
+      if collision ~= 0 and (coll == 0 or coll == 0x18 or coll == 0x2b
+          or ((coll == 0x71 or coll == 0x72) and not (x < w and y < h and warps[index]))) then coll = 7 end
+      cells[#cells + 1] = {mid = mid, coll = coll, elev = elevation}
+    end end
+    local borders = {}; for i = 1, bw * bh do borders[i] = (border:byte(i * 2 - 1) + border:byte(i * 2) * 256) % 1024 end
+    local converted = {}
+    for _, row in ipairs(def.sourceConnections or {}) do
+      if not directions[row.dir]
+          or type(row.offset) ~= "number" or row.offset % 1 ~= 0 then return nil,"invalid source connection" end
+      local destination = binding:legacyId(row.map)
+      if not destination then return nil, "connection map identity unavailable" end
+      converted[#converted + 1] = {dir = row.dir, map = destination, offset = row.offset}
+    end
+    local convertedWarps = {}
+    for _, row in ipairs(def.warps or {}) do
+      local destination = row.destMap
+      local canonicalDestination = binding:legacyId(destination)
+      local group, number
+      if not canonicalDestination and type(destination) == "string" then
+        group, number = destination:match("^MAP_G(%d+)_N(%d+)$")
+        group, number = tonumber(group), tonumber(number)
+        canonicalDestination = group and Identity.lookup(edition, group, number) or Identity.lookup(edition, destination)
+      end
+      convertedWarps[#convertedWarps+1]={x=row.x,y=row.y,elevation=row.elevation,destWarp=row.destWarp,
+        destMap=canonicalDestination,nativeDestination=destination,
+        mapGroup=not canonicalDestination and group or nil,mapNum=not canonicalDestination and number or nil}
+    end
+    local snapshot = {id = canonical, nativeId = nativeId, nativePair = def.tileset,
+      width = w, height = h, kind = mapKind, environment = environment,
+      connections = converted, warps = convertedWarps}
+    -- The native pair key is explicit. Atlas-name compatibility is a separate
+    -- provider and this observation is not installed as the old map module.
+    snapshot.midLayout = Layout.fromDecoded({width = paddedW, height = paddedH, trueWidth = w, trueHeight = h,
+      cells = cells, borderWidth = bw, borderHeight = bh, borderMids = borders}, canonical, def.tileset)
+    serial = serial + 1; snapshot.revision = serial
+    cache[nativeId], published[snapshot] = snapshot, {stamp = stamp,id = nativeId}
+    return snapshot
+  end
+  function handle:current()
+    local ow, why = currentOwner(); if not ow then return nil, why end
+    return build(ow.map.id)
+  end
+  function handle:map(id) return build(id) end
+  function handle:isCurrent(view)
+    local record = published[view]; if not record then return false end
+    local fresh = build(record.id)
+    return fresh == view
+  end
+  function handle:invalidate(id)
+    if id == nil then cache = weakCache(); return end
+    local _, why = currentOwner(); if why then return end
+    local key = binding:nativeId(id)
+    cache[key or id] = nil
+  end
+  function handle:release() ended = true; reset(); getGame, getEdition = nil, nil end
+  return handle
+end
+return Views
diff --git a/src/compat/gen1/NativeModalObservation.lua b/src/compat/gen1/NativeModalObservation.lua
new file mode 100644
index 000000000..65f9c6e95
--- /dev/null
+++ b/src/compat/gen1/NativeModalObservation.lua
@@ -0,0 +1,35 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Constructor-bound native modal observations. Weak owner slots avoid a
+-- weak-key/value/stack cycle keeping a retired world alive under LuaJIT.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local M={}
+local records=setmetatable({},{__mode='k'})
+function M.capture(state,game)
+ if Version.isGen3()and Native.game()==game and game.stack then
+  records[state]={edition=Version.get(),hasMods=game.mods~=nil,
+   refs=setmetatable({game,game.data,game.save,game.stack,game.mods},{__mode='v'})}
+ end
+ return state
+end
+function M.find(classes)
+ local game=Native.game();if not(game and game.stack)then return end
+ for i=#game.stack.states,1,-1 do
+  local state=game.stack.states[i];local class=getmetatable(state)
+  local matching=false
+  for _,name in ipairs(classes)do
+   local nested=type(name)=='table'
+   local module=package.loaded[nested and name[1]or name]
+   local candidate=module
+   if nested then candidate=module and module[name[2]]end
+   if candidate~=nil and class==candidate then matching=true;break end
+  end
+  if matching then
+   local row=records[state];local r=row and row.refs
+   if r and state.game==game and row.edition==Version.get()and r[1]==game
+    and r[2]~=nil and r[2]==game.data and r[3]~=nil and r[3]==game.save
+    and r[4]==game.stack and r[5]==game.mods and row.hasMods==(game.mods~=nil)then return state end
+  end
+ end
+end
+return M
diff --git a/src/compat/gen1/NativeRegionMap.lua b/src/compat/gen1/NativeRegionMap.lua
new file mode 100644
index 000000000..13c291520
--- /dev/null
+++ b/src/compat/gen1/NativeRegionMap.lua
@@ -0,0 +1,121 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observations of the admitted native picker, never a second map controller.
+local Native=require('src.compat.gen1.NativeSession')
+local Modal=require('src.compat.gen1.NativeModalObservation')
+local Version=require('src.core.GameVersion')
+local Targets=require('src.world.Gen3FlyTargets')
+local M={}
+local current
+local function screen()
+ local game=Native.resolve();if not(game and game.stack and type(game.stack.states)=='table')then return end
+ local s=Modal.find({'src.ui.Gen3RegionMap'})
+ return s and not s.closed and s or nil
+end
+local function valid(c)
+ local r=c and not c.retired and c.refs
+ if not(r and r[1]and r[2]and r[6])then return false end
+ local game,s=r[1],r[2];local G=package.loaded['src.core.Game3']
+ return G and G.native(r[6])==game and Native.game()==game and Version.get()==c.edition
+  and game.data==r[3]and game.save==r[4]and game.mods==r[5]and screen()==s
+  and s.rsNative==r[7]and(not r[7]or s.rsNative.state==r[8])
+end
+local function release()
+ if current then current.retired=true;current.refs=nil;current.view=nil;current.users={}end
+ current=nil
+end
+local function ready(c)
+ if not valid(c)then return false end
+ local game,s=c.refs[1],c.refs[2];local stack=game.stack
+ local top=stack.active and stack:active()or stack.states[#stack.states]
+ if top~=s or s.area then return false end
+ if c.refs[7]then
+  local raw=c.refs[8];return not c.refs[7].closed and raw.state==12 and raw.inputFn~='move'
+ end
+ return not s:zooming()
+end
+local function section(c)
+ if not valid(c)then return end
+ if c.refs[7]then return c.refs[8].mapSecId end
+ local place=c.refs[2]:current();return place and place.section
+end
+local function destination(c,sec,pos)
+ if not valid(c)then return end
+ local game,s=c.refs[1],c.refs[2]
+ if not s.fly or sec~=section(c)then return end
+ if c.refs[7]then
+  local rs=c.refs[7];local raw=c.refs[8]
+  if pos~=nil and pos~=raw.posWithinMapSec then return end
+  local kind=rs.native.mapSecType(raw,sec)
+  if kind~=rs.native.TYPE.CITY_CANFLY and kind~=rs.native.TYPE.BATTLE_FRONTIER then return end
+  local dest=rs:destination(sec,raw.posWithinMapSec)
+  return dest and Targets.detached(game,dest.map,dest)
+ end
+ if s.frlg and s.page~=(s.playerPage or'kanto')then return end
+ return Targets.destination(game,sec,s.targets)
+end
+function M.active(family)
+ local s=screen();local game=Native.game()
+ local frlg=Version.isFRLG()
+ if not(s and game)then release();return end
+ if family and(family=='frlg')~=frlg then return end
+ if not valid(current)then
+  release();local G=require('src.core.Game3');local view=G.forNative(game)
+  if not view then return end
+  local rs=s.rsNative
+  local c={edition=Version.get(),users={},refs=setmetatable({game,s,game.data,game.save,game.mods,view,rs,rs and rs.state},{__mode='v'})}
+  c.view=setmetatable({},{__index=function(_,key)
+   if key=='open'then return valid(c)end
+   if not valid(c)then return end
+   local state=c.refs[2];local raw=c.refs[8]
+   if key=='mode'then return state.fly and'fly'or state.area and'area'or'wall'end
+   if key=='mapSecId'then return section(c)end
+   if raw and(key=='state'or key=='inputFn'or key=='posWithinMapSec'or key=='chose')then return raw[key]end
+   -- The generic picker has no fade task: 12 denotes its real input-ready
+   -- phase in this observation protocol, rather than an invented timer.
+   if key=='state'then return ready(c)and 12 or 0 end
+   if key=='inputFn'then return ready(c)and'full'or nil end
+   if key=='selectedRegion'then return state.page end
+   if key=='playersRegion'then return state.playerPage or(state.frlg and'kanto'or nil)end
+   if key=='cursor'then return{x=state.cx,y=state.cy,moveCounter=raw and raw.moveCounter or 0}end
+  end,__newindex=function()error('native region map observations are read-only',2)end})
+  current=c
+ end
+ local host=package.loaded['src.mods.Runtime'];local G=package.loaded['src.core.Game3']
+ local who=host and host.currentMod or G and G._callbackOwner()
+ if who then current.users[who]=true end
+ return current.view
+end
+local function admitted(view)
+ return current and valid(current)and(view==nil or view==current.view)and current or nil
+end
+function M.ready()local c=admitted();return c and ready(c)or false end
+function M.section()local c=admitted();return c and section(c)end
+function M.destination(sec,pos)
+ local c=admitted();if c then return destination(c,sec,pos)end
+end
+function M.kind(view,sec)
+ local c=admitted(view);if not c or sec~=section(c)then return 0 end
+ if c.refs[7]then return c.refs[7].native.mapSecType(c.refs[8],sec)end
+ -- This older native controller only classifies selectable fly targets.
+ -- Do not guess route/city/landmark identities for other atlas sections.
+ return destination(c,sec)and 2 or 0
+end
+function M.manifest()
+ local game=Native.resolve()
+ assert(game and not Version.isFRLG(),'native Hoenn atlas requires an admitted field')
+ local s=screen()
+ if s and s.rsNative then return require('src.mods.Merge').deepCopy(s.rsNative.kit:manifest())end
+ local spec=game.data.constants and game.data.constants.gen3RsMap
+ if spec then
+  local ok,kit=pcall(require,'src.ui.Gen3RsMapKit')
+  assert(ok and kit.available(game),'native RS atlas owner unavailable')
+  return require('src.mods.Merge').deepCopy(kit.new(game):manifest())
+ end
+ return require('src.ui.Gen3RegionMap').manifest(game)
+end
+M._service={release=release,poll=function()if current and not valid(current)then release()end end,
+ releaseOwner=function(_,who)
+  if current and current.users[who]then current.users[who]=nil;if not next(current.users)then release()end end
+ end}
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/compat/gen1/NativeSession.lua b/src/compat/gen1/NativeSession.lua
new file mode 100644
index 000000000..b98db4b08
--- /dev/null
+++ b/src/compat/gen1/NativeSession.lua
@@ -0,0 +1,79 @@
+-- Resolve the live owner without bootstrapping Game or keeping a retired world.
+local Version = require('src.core.GameVersion')
+local M = {}
+local entering=setmetatable({},{__mode='k'})
+local unpack=table.unpack or unpack
+local function pack(...)return {n=select('#',...),...}end
+function M.withWorld(game,world,fn,...)
+  local owner,why=M.game(game);assert(owner,why)
+  assert(type(world)=='table'and world.isOverworld and world.map and world.player
+    and owner.data and owner.data.maps and owner.data.maps[world.map.id]==world.map.def,'foreign native world scope')
+  local previous=entering[owner];entering[owner]=world
+  local result=pack(pcall(fn,...));entering[owner]=previous
+  if not result[1]then error(result[2],0)end
+  return unpack(result,2,result.n)
+end
+function M.game(game)
+  local explicit = game ~= nil
+  local facade = package.loaded['src.core.Game3']
+  if type(facade) == 'table' and type(facade.native) == 'function' then
+    game = facade.native(game)
+    if explicit and game == nil then return nil, 'native Game3 facade retired' end
+  end
+  game = game or package.loaded['src.core.Game']
+  local info = Version.info(Version.get())
+  if type(game) ~= 'table' or not info or info.generation ~= 3 then
+    return nil, 'no native GBA session'
+  end
+  return game
+end
+function M.data(game)
+  local owner,why=M.game(game);if not owner then return nil,why end
+  local data=owner.data
+  if type(data)~='table'or type(data.tilesets)~='table'or type(data.map_tilesets)~='table'
+      or type(data.constants)~='table'or type(data.constants.gen3Layout)~='table'then
+    return nil,'native GBA tileset data unavailable'
+  end
+  return owner,data
+end
+-- Admission lookup is also used by map readers that can run before a player
+-- is constructed. Edition/data validation stays with each typed consumer.
+function M.world(game)
+  if type(game)~='table'then return nil end
+  local states = game.stack and game.stack.states
+  local world=entering[game]
+  if not world and type(states) == 'table' then
+    for i = #states, 1, -1 do
+      if states[i].isOverworld then world = states[i]; break end
+    end
+    -- The physical list can contain overlays only. Its persistent world is
+    -- still a real native admission, independently of the convenience pointer.
+    if not world then world=game.stack.worldState end
+  elseif not world then
+    world = game.overworld
+  end
+  return world and world.isOverworld and world or nil
+end
+function M.resolve(game)
+  local why;game,why=M.game(game);if not game then return nil,why end
+  local world=M.world(game)
+  if not (world and world.isOverworld and world.player and world.map) then
+    return nil, 'no active native player'
+  end
+  if not (game.data and game.data.maps and world.map.def
+      and game.data.maps[world.map.id] == world.map.def) then
+    return nil, 'native world belongs to a retired dataset'
+  end
+  return game, world, world.player
+end
+function M.acceptsInput(game, world, player)
+  local owner, current, actor = M.resolve(game)
+  if owner ~= game or current ~= world or actor ~= player then return false end
+  local states = game.stack and game.stack.states
+  if type(states)=='table' then
+    local active=type(game.stack.active)=='function' and game.stack:active() or states[#states]
+    if active~=world then return false end
+  end
+  return not world.battleActive and not (world.busy and world:busy())
+end
+return M
diff --git a/src/compat/gen1/ObjectRuntime.lua b/src/compat/gen1/ObjectRuntime.lua
new file mode 100644
index 000000000..b2734daaf
--- /dev/null
+++ b/src/compat/gen1/ObjectRuntime.lua
@@ -0,0 +1,208 @@
+-- Owned, live observations of the native object pool. No second actor loop.
+local Session = require('src.compat.gen1.NativeSession')
+local Identity = require('src.compat.gen1.MapIdentity')
+local Version = require('src.core.GameVersion')
+local R = {}; R.__index = R
+local directions = {up=true,down=true,left=true,right=true}
+local function finite(v) return type(v)=='number' and v==v and math.abs(v)<math.huge end
+local function integer(v,lo,hi) return finite(v) and v%1==0 and v>=lo and v<=hi end
+local function copy(v,seen)
+  if type(v)~='table' then
+    if type(v)=='string' or type(v)=='number' or type(v)=='boolean' then return v end
+    return nil
+  end
+  seen=seen or {}; if seen[v] then return seen[v] end
+  local out={}; seen[v]=out
+  for k,value in pairs(v) do if type(k)=='string' or type(k)=='number' then out[k]=copy(value,seen) end end
+  return out
+end
+local fields={cellX='cellX',cellY='cellY',px='px',py='py',targetX='targetX',targetY='targetY',
+  moving='moving',progress='progress',facing='facing',stepFlip='stepFlip',animClock='animClock',
+  invisible='invisible',hidden='hidden',passable='passable',runtime='runtime',
+  customFrame='fixedFrame',raiseX='shiftPx',homeX='roamOriginX',homeY='roamOriginY'}
+local boolWrite={hidden='hidden',invisible='invisible',passable='passable'}
+function R.new() return setmetatable({views=setmetatable({},{__mode='kv'}),records=setmetatable({},{__mode='kv'})},R) end
+function R:release()
+  if self.context then self.context.retired=true end
+  self.context=nil
+end
+function R:current(game)
+  local g,w,p=Session.resolve(game)
+  local c=self.context
+  if not g then self:release(); return nil,w end
+  if c and (c.retired or c.game~=g or c.world~=w or c.player~=p or c.map~=w.map or c.def~=w.map.def or c.data~=g.data
+      or c.maps~=g.data.maps or c.save~=g.save or c.loader~=g.mods or c.edition~=Version.get()
+      or c.binding:legacyId(w.map.id)~=c.id) then
+    self:release(); c=nil
+  end
+  if not c then
+    c={game=g,world=w,player=p,map=w.map,def=w.map.def,data=g.data,maps=g.data.maps,
+      save=g.save,loader=g.mods,edition=Version.get()}
+    c.binding=Identity.bind(c.maps,c.edition)
+    local why; c.id,why=c.binding:legacyId(w.map.id)
+    if not c.id then return nil,why end
+    self.context=c
+  end
+  return c
+end
+local function live(c)
+  if c.retired then return false end
+  local g,w,p=Session.resolve(c.game)
+  if g~=c.game or w~=c.world or p~=c.player or w.map~=c.map or w.map.def~=c.def
+      or g.data~=c.data or g.data.maps~=c.maps or g.save~=c.save or g.mods~=c.loader
+      or Version.get()~=c.edition or c.binding:legacyId(c.map.id)~=c.id then c.retired=true; return false end
+  return true
+end
+local function member(c,e,mapId)
+  if not live(c) then return false end
+  if mapId==c.map.id then
+    for _,a in ipairs(c.world.npcs or c.world.entities or {}) do if a==e then return true end end
+  else
+    for _,nb in ipairs(c.world.neighbors or {}) do
+      if nb.map and nb.map.id==mapId and c.maps[mapId]==nb.map.def then
+        for _,a in ipairs(nb.peers or {}) do if a==e then return true end end
+      end
+    end
+    for _,ghost in ipairs(c.world.ghosts or {}) do
+      local map=ghost.nb and ghost.nb.map
+      if map and map.id==mapId and c.maps[mapId]==map.def and ghost.npc==e then return true end
+    end
+  end
+  return false
+end
+function R:view(c,e,mapId)
+  local class=package.loaded['src.world.NPC']
+  if type(class)~='table' or getmetatable(e)~=class or type(e.def)~='table'
+      or not integer(e.def.index,1,65535) then return nil,'unsupported native object identity' end
+  local id,why=c.binding:legacyId(mapId); if not id then return nil,why end
+  local record=self.views[e]
+  if record and record.context==c and record.mapId==mapId and not record.retired then return record.view end
+  record={context=c,actor=e,mapId=mapId,extras={},definition=copy(e.def)}
+  record.definition.localId=e.def.index
+  local function valid()
+    if record.retired then return false end
+    if not member(c,e,mapId) or c.binding:legacyId(mapId)~=id then record.retired=true; return false end
+    return true
+  end
+  local function read(_,key)
+    if not valid() then return nil end
+    if key=='passable' then return e.passable==true or e.def.passable==true end
+    if key=='runtime' then return e.def.runtime==true end
+    if fields[key] then return e[fields[key]] end
+    if key=='def' then return record.definition end
+    if key=='localId' or key=='originLocalId' then return e.def.index end
+    if key=='id' then return e.id end
+    if key=='originMapId' then return id end
+    if key=='originMapGroup' then return c.maps[mapId].group end
+    if key=='originMapNum' then return c.maps[mapId].number end
+    if key=='graphicsId' then
+      -- The extractor preserves the cartridge row on the actual sprite.
+      -- Variable sprites resolve to a different sheet without changing def.
+      local sprite=e.sprite and e.sprite.def
+      local key=type(sprite)=='table' and sprite.id
+      return type(key)=='string' and tonumber(key:match('^SPRITE_G3_(%d+)$')) or e.def.graphicsId
+    end
+    if key=='visible' then return not(e.hidden or e.visible==false or e.berryVisualEmpty) end
+    if key=='currentElevation' or key=='elevation' then return e.elevation or e.gen3Elevation or e.def.elevation or 0 end
+    if key=='stepFrames' then return e.scriptStepLen or e.stepFrames or 16 end
+    if key=='raiseY' then
+      local observed={}; for k,v in pairs(e) do observed[k]=v end
+      setmetatable(observed,class)
+      local _,_,py=class.pose(observed)
+      return e.py-py
+    end
+    if key=='movementType' then return e.gen3MovementType or e.def.movementType end
+    if key=='frozen' then return e.frozen==true or e.gen3ScriptFrozen==true end
+    if key=='scriptBusy' then
+      for _,mv in ipairs(c.world.scriptMoves or {}) do if mv.entity==e then return true end end
+      return false
+    end
+    return record.extras[key]
+  end
+  local function write(_,key,value)
+    assert(valid(),'native object view retired')
+    if key=='sprite'then
+      assert(value==nil or type(value)=='table'and type(value.draw)=='function','invalid object renderer')
+      local host=require('src.mods.Runtime');local facade=require('src.core.Game3')
+      local who=host.currentMod or facade._callbackOwner();assert(who,'object renderer requires a mod owner')
+      record.extras.sprite=value;record.presentationSet=true;record.presentationOwner=who
+      require('src.compat.gen1.SourceActors').bind(e,record)
+    elseif boolWrite[key] then
+      assert(type(value)=='boolean','invalid object boolean'); e[boolWrite[key]]=value
+    elseif key=='visible' then
+      assert(type(value)=='boolean','invalid object visibility'); e.hidden=not value; e.visible=value
+    elseif key=='facing' then
+      assert(directions[value],'invalid object facing'); e.facing=value
+    elseif key=='raiseX' then
+      assert(finite(value) and math.abs(value)<=16777216,'invalid object offset'); e.shiftPx=value
+    elseif key=='customFrame' then
+      local frames=e.sprite and e.sprite.def and math.max(e.sprite.def.frames or 1,e.sprite.def.poseFrames or 1) or 1
+      assert(value==nil or integer(value,0,frames-1),'invalid object frame'); e.fixedFrame=value
+    elseif key=='frozen' then
+      assert(type(value)=='boolean','invalid object freeze'); e.gen3ScriptFrozen=value or nil
+    elseif fields[key] or key=='def' or key=='localId' or key=='graphicsId' or key=='id'
+        or key=='currentElevation' or key=='elevation' or key=='stepFrames' or key=='movementType'
+        or key=='scriptBusy' or key=='raiseY' or type(key)=='string' and key:match('^origin') then
+      error('object '..key..' requires a native command owner',2)
+    else record.extras[key]=value end
+  end
+  record.view=setmetatable({},{__index=read,__newindex=write})
+  self.views[e]=record
+  self.records[record.view]=record
+  return record.view
+end
+function R:actor(view)
+  local r=view and self.records[view]
+  if r then
+    if not r.retired and r.view.localId~=nil then return r.actor,r.context,r.mapId end
+    r.retired=true; return nil,'native object view retired'
+  end
+  return nil,'foreign object view'
+end
+function R:pool(mapId,game)
+  local c,why=self:current(game); if not c then return nil,why end
+  local nativeId=c.map.id
+  if mapId then
+    nativeId=c.binding:nativeId(mapId)
+    if not nativeId then
+      -- Registries can acquire authored maps without replacing data.maps.
+      -- Re-index on a miss; never fall back to the current map's objects.
+      c.binding=Identity.bind(c.maps,c.edition)
+      nativeId=c.binding:nativeId(mapId)
+    end
+    if not nativeId then return nil,'unknown object map' end
+  end
+  local list,seen,ids={},{},{}
+  local function add(e)
+    if seen[e] then return true end
+    local view,err=self:view(c,e,nativeId); if not view then return nil,err end
+    if ids[view.localId] then return nil,'ambiguous native object local ID' end
+    seen[e]=true; ids[view.localId]=true; list[#list+1]=view
+    return true
+  end
+  if nativeId==c.map.id then
+    for _,e in ipairs(c.world.npcs or c.world.entities or {}) do
+      if e~=c.player then local ok,err=add(e); if not ok then return nil,err end end
+    end
+  else
+    for _,nb in ipairs(c.world.neighbors or {}) do
+      if nb.map and nb.map.id==nativeId then
+        for _,e in ipairs(nb.peers or {}) do local ok,err=add(e); if not ok then return nil,err end end
+      end
+    end
+    for _,ghost in ipairs(c.world.ghosts or {}) do
+      if ghost.nb and ghost.nb.map and ghost.nb.map.id==nativeId then
+        local ok,err=add(ghost.npc); if not ok then return nil,err end
+      end
+    end
+  end
+  return list,c
+end
+function R:walkPhase(view)
+  local e=self:actor(view)
+  return e and not e.sliding and e:walkPhase() or 0
+end
+R.integer=integer
+R.copy=copy
+R.directions=directions
+return R
diff --git a/src/compat/gen1/PlayerPose.lua b/src/compat/gen1/PlayerPose.lua
new file mode 100644
index 000000000..61d258ed1
--- /dev/null
+++ b/src/compat/gen1/PlayerPose.lua
@@ -0,0 +1,43 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Short field gestures use the native player's fixed step and pose owner.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local M={}
+local active
+local function release()
+ local a=active;active=nil
+ if a and a.player._gen3FieldMovePoseOwner==a then
+  a.player.fieldMove,a.player.fieldMovePose,a.player.fieldMoveFrames=a.previous,a.pose,a.frames
+  a.player._gen3FieldMovePoseOwner=a.previousOwner
+ end
+end
+local function live(a)
+ local g,w,p=Native.resolve()
+ return a and g==a.game and w==a.world and p==a.player and w.map==a.map and g.data==a.data
+  and g.save==a.save and g.mods==a.loader and Version.get()==a.edition
+end
+function M.start(duration,kind)
+ if active and not live(active)then release()end
+ local g,w,p=Native.resolve();if not g or p.moving or p._gen3FieldMovePoseOwner then return false end
+ duration=duration or 28
+ assert(type(duration)=='number'and duration%1==0 and duration>=1 and duration<=3600,'invalid field gesture duration')
+ assert(kind==nil or type(kind)=='string','invalid field gesture kind')
+ local host=require('src.mods.Runtime');local facade=require('src.core.Game3');local who=host.currentMod or facade._callbackOwner()
+ if not who then return false end
+ active={game=g,world=w,player=p,map=w.map,data=g.data,save=g.save,loader=g.mods,edition=Version.get(),who=who,
+  remaining=duration,previous=p.fieldMove,pose=p.fieldMovePose,frames=p.fieldMoveFrames,previousOwner=p._gen3FieldMovePoseOwner}
+ p._gen3FieldMovePoseOwner=active;p.fieldMove=true;p.fieldMovePose=kind or'field_move';p.fieldMoveFrames=duration
+ return true
+end
+function M.tick(player)
+ local a=active;if not a then return end
+ if not live(a)or a.player._gen3FieldMovePoseOwner~=a then release();return end
+ if player~=a.player then return end
+ a.remaining=a.remaining-1;a.player.fieldMoveFrames=a.remaining
+ if a.remaining<=0 then release()end
+end
+M.release=release
+M.releaseOwner=function(_,who)if active and active.who==who then release()end end
+M.poll=function()if active and not live(active)then release()end end
+require('src.core.game3.asset_stream').register(M)
+return M
diff --git a/src/compat/gen1/PokemonView.lua b/src/compat/gen1/PokemonView.lua
new file mode 100644
index 000000000..fc53d6e0e
--- /dev/null
+++ b/src/compat/gen1/PokemonView.lua
@@ -0,0 +1,127 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Typed party observations share native residents, never another party/save.
+local Ids=require('src.compat.gen1.BattleIds')
+local M={}
+local records=setmetatable({},{__mode='k'})
+local environments=setmetatable({},{__mode='k'})
+local Iteration=require('src.compat.gen1.TableIteration')
+local stats={maxHp='hp',attack='attack',defense='defense',speed='speed',spAtk='spatk',spDef='spdef'}
+local bits={PSN=8,BRN=16,FRZ=32,PAR=64}
+local function uint(n,hi)return type(n)=='number'and n==n and n>=0 and n<=hi and n%1==0 end
+function M.status(mon)
+  if mon.status=='SLP'then return math.max(1,math.min(7,mon.sleepTurns or 1))end
+  return mon.status=='PSN'and mon.toxic and 128 or bits[mon.status]or 0
+end
+function M.setStatus(mon,value)
+  if value==nil then value=0 end
+  assert(uint(value,255)and(value<=7 or({[8]=true,[16]=true,[32]=true,[64]=true,[128]=true})[value]),'invalid native status')
+  mon.status=value>0 and(value<=7 and'SLP'or({[8]='PSN',[16]='BRN',[32]='FRZ',[64]='PAR',[128]='PSN'})[value])or nil
+  mon.sleepTurns=value>0 and value<=7 and value or nil;mon.toxic=value==128 or nil
+end
+function M.new(game,valid)
+  local e={game=game,data=game.data,ids=Ids.new(game.data),entries=setmetatable({},{__mode='k'}),cache=setmetatable({},{__mode='kv'}),valid=valid}
+  environments[e]=true
+  function e:live()
+    if not self.game then return false end
+    if not self.valid()or not self.ids:valid()then self:release();return false end
+    return true
+  end
+  function e:release()
+    for _,entry in pairs(self.entries)do entry.raw=nil;entry.arrays=nil end
+    self.game,self.data,self.ids=nil,nil,nil;self.cache={};self.valid=function()return false end
+  end
+  local function vectors(d)
+    if d.arrays then return d.arrays end
+    local a={moves={},pp={},maxPp={},baseline={},native={}}
+    for i,row in ipairs(d.raw.moves or{})do
+      local def=e.data.moves[row.id]
+      a.moves[i]=e.ids:read('moves',row.id);a.pp[i]=row.pp;a.baseline[i]=row.pp
+      a.maxPp[i]=(def and def.pp or 0)+math.floor((def and def.pp or 0)/5)*(row.ppUps or 0)
+      a.native[i]=row
+    end
+    d.arrays=a;return a
+  end
+  function e:flush()
+    if not self:live()then return end
+    local writes,clear={},{}
+    for _,d in pairs(self.entries)do
+      local a=d.arrays
+      if a and d.raw then
+        for i,row in ipairs(a.native)do
+          assert(d.raw.moves[i]==row and e.ids:read('moves',row.id)==a.moves[i],'native moves changed during source edit')
+          local def=e.data.moves[row.id];local maximum=def.pp+math.floor(def.pp/5)*(row.ppUps or 0)
+          assert(a.maxPp[i]==maximum,'native maximum PP is read-only')
+          assert(uint(a.pp[i],maximum),'invalid native PP')
+          assert(a.pp[i]==a.baseline[i]or row.pp==a.baseline[i],'native PP changed during source edit')
+          if a.pp[i]~=a.baseline[i]then writes[#writes+1]={row,a.pp[i]}end
+        end
+        for i in pairs(a.pp)do assert(uint(i,#a.native)and i>0,'invalid native PP slot')end
+        for i,v in pairs(a.moves)do assert(a.native[i]and e.ids:read('moves',a.native[i].id)==v,'native move list is read-only')end
+        for i,v in pairs(a.maxPp)do
+          local row=a.native[i];local def=row and e.data.moves[row.id]
+          assert(def and v==def.pp+math.floor(def.pp/5)*(row.ppUps or 0),'native maximum PP is read-only')
+        end
+        clear[#clear+1]=d
+      end
+    end
+    for _,write in ipairs(writes)do write[1].pp=write[2]end
+    for _,d in ipairs(clear)do d.arrays=nil end
+  end
+  function e:view(mon)
+    if not self:live()or type(mon)~='table'then return nil end
+    local old=self.cache[mon];if old then return old end
+    local view={};local d={raw=mon,env=self};self.cache[mon]=view;self.entries[view]=d;records[view]=d
+    setmetatable(view,{__index=function(_,key)
+      if not e:live()or not d.raw then return nil end
+      local m=d.raw
+      if key=='species'then return e.ids:read('pokemon',m.species)end
+      if key=='item'then return e.ids:read('items',m.item)end
+      if key=='status'then return M.status(m)end
+      if key=='friendship'or key=='happiness'then return m.happiness end
+      if key=='isEgg'or key=='egg'then return require('src.pokemon.Party').isEgg(m)end
+      if key=='moves'or key=='pp'or key=='maxPp'then return vectors(d)[key]end
+      if stats[key]then return m.stats and m.stats[stats[key]]end
+      if key=='otId'then return m.otId or m.otID end
+      if key=='otSecretId'then return m.otSecretId or m.secretId end
+      if key=='ivs'then
+        local out={};for a,b in pairs{hp='hp',atk='attack',def='defense',spe='speed',spa='spatk',spd='spdef'}do out[a]=m.ivs and m.ivs[b]end;return out
+      end
+      if key=='hp'or key=='level'or key=='exp'or key=='nickname'or key=='personality'or key=='sleep'then
+        return m[key=='sleep'and'sleepTurns'or key]
+      end
+    end,__newindex=function(_,key,value)
+      assert(e:live()and d.raw,'native party view retired')
+      local m=d.raw
+      if key=='hp'then assert(uint(value,m.stats.hp),'invalid native HP');m.hp=value
+      elseif key=='friendship'or key=='happiness'then assert(uint(value,255),'invalid native friendship');m.happiness=value
+      elseif key=='nickname'then assert(type(value)=='string'and#value<=32,'invalid native nickname');m.nickname=value
+      elseif key=='status'then M.setStatus(m,value)
+      elseif key=='sleep'then assert(uint(value or 0,7),'invalid native sleep');m.sleepTurns=value
+      elseif key=='item'then
+        local item=e.ids:native('items',value);assert(value==0 or item,'unknown native item');m.item=item
+      else error('native party '..tostring(key)..' belongs to its command owner',2)end
+    end})
+    Iteration.register(view,function(spec,source)
+      assert(spec.environment and spec.environment:live(),'native party view retired')
+      local out={}
+      for _,key in ipairs{'species','item','hp','level','exp','nickname','personality','friendship','status','ivs','otId','otSecretId','isEgg','maxHp','attack','defense','speed','spAtk','spDef','moves','pp','maxPp'}do
+        local value=source[key]
+        if type(value)=='table'then local a={};for k,v in pairs(value)do a[k]=v end;value=a end
+        out[key]=value
+      end
+      return out
+    end,setmetatable({environment=e},{__mode='v'}))
+    return view
+  end
+  return e
+end
+function M.resolve(view)
+  local d=records[view]
+  if not d then return nil,false end
+  if not d.env:live()then return nil,true end
+  d.env:flush();return d.raw,true,d.env.game
+end
+function M.flush()
+  for e in pairs(environments)do e:flush()end
+end
+return M
diff --git a/src/compat/gen1/ScriptBoundary.lua b/src/compat/gen1/ScriptBoundary.lua
new file mode 100644
index 000000000..66093de5f
--- /dev/null
+++ b/src/compat/gen1/ScriptBoundary.lua
@@ -0,0 +1,38 @@
+-- Native owners open a scope; source base calls can consume its body once.
+-- Queries made between native phases cannot advance another script clock.
+local M={}
+local scopes=require('src.compat.gen1.CoroutineScopes').new()
+local BODY={}
+local unpack=table.unpack or unpack
+local function pack(...)return {n=select('#',...),...}end
+function M.invoke(name)
+  local s=scopes:find(name)
+  if not s then return nil,'script operation belongs to its native phase'end
+  if s.failed then error(s.failure,0)end
+  if not s.called then
+    s.called=true
+    local claim=scopes:push(BODY,nil,s)
+    local r=pack(pcall(s.body))
+    local retired=s.closed or claim.closed
+    scopes:close(claim)
+    s.body=nil
+    if not r[1]then s.failed=true;s.failure=r[2];error(r[2],0)end
+    if retired then error('native script phase retired while suspended',0)end
+    s.result={n=r.n-1};for i=2,r.n do s.result[i-1]=r[i]end
+  end
+  if not s.result then return nil,'native script phase is already executing' end
+  return unpack(s.result,1,s.result.n)
+end
+function M.dispatch(name,body,source,...)
+  local s=scopes:push(name);s.body=body
+  local result=pack(pcall(source,...))
+  local retired,failed,failure=s.closed,s.failed,s.failure
+  scopes:close(s)
+  -- A wrapper cannot swallow a failing native command and retry it.
+  if failed then error(failure,0)end
+  if retired then error('native script phase retired while suspended',0)end
+  if not result[1]then error(result[2],0)end
+  return unpack(result,2,result.n)
+end
+function M.active(name)return scopes:find(name)~=nil end
+return M
diff --git a/src/compat/gen1/SessionView.lua b/src/compat/gen1/SessionView.lua
new file mode 100644
index 000000000..89ebc6b3e
--- /dev/null
+++ b/src/compat/gen1/SessionView.lua
@@ -0,0 +1,163 @@
+-- Typed observations of one native GBA save, never another save/simulation.
+-- Collection schemas (party, bag, script stores) have separate adapters; do
+-- not lend differently shaped native tables under those source names.
+local Native=require('src.compat.gen1.NativeSession')
+local Identity=require('src.compat.gen1.MapIdentity')
+local Version=require('src.core.GameVersion')
+local ScriptStore=require('src.compat.gen1.ScriptStore')
+local ScriptMap=require('src.compat.gen1.ScriptMap')
+local Iteration=require('src.compat.gen1.TableIteration')
+local M={}
+local records=setmetatable({},{__mode='k'})
+local stores=setmetatable({},{__mode='k'})
+local function finite(n)return type(n)=='number'and n==n and math.abs(n)<math.huge end
+function M.seconds(save)
+  local value=save and save.playTime
+  if type(value)=='table'then
+    local function number(a,b)local n=tonumber(a)or tonumber(b)or 0;return finite(n)and n>=0 and n or 0 end
+    return number(value.hours)*3600+number(value.minutes,value.mins)*60
+      +number(value.seconds,value.secs)+number(value.frames,value.vblanks)/60
+  end
+  local n=tonumber(value);return finite(n)and n>=0 and n or 0
+end
+function M.new(game)
+  local owner,why=Native.game(game);if not owner then return nil,why end
+  local data,save,edition=owner.data,owner.save,Version.get()
+  if type(data)~='table'or type(data.maps)~='table'or type(save)~='table'then return nil,'native save data unavailable'end
+  if not Identity.lookup(edition,0,0)then return nil,'native source map catalogue unavailable'end
+  local binding=Identity.bind(data.maps,edition)
+  local record={owner=owner,data=data,save=save,edition=edition,maps=data.maps,clock={}}
+  local scripts=assert(ScriptStore.new(owner))
+  local flags,vars=ScriptMap.new(scripts,'flags'),ScriptMap.new(scripts,'vars')
+  local view={}
+  local bag,dex,party={},{},{}
+  stores[bag]={record=record,kind='bag'};stores[dex]={record=record,kind='dex'}
+  function record:valid()
+    if self.retired then return false end
+    if not scripts:valid()or Version.get()~=edition or owner.data~=data or owner.save~=save or data.maps~=self.maps then
+      self.retired=true;scripts:release();if self.mons then self.mons:release()end;return false
+    end
+    return true
+  end
+  record.mons=require('src.compat.gen1.PokemonView').new(owner,function()return record:valid()end)
+  function record:seconds()return M.seconds(save)end
+  function record:world()
+    if not self:valid()then return end
+    local _,world,player=Native.resolve(owner);return world,player
+  end
+  function record:map()
+    local world=self:world();local id=world and world.map.id or(save.player and save.player.map)
+    return id and binding:legacyId(id)
+  end
+  local function current()
+    if not record:valid()then return nil end
+    return save.player or{},record:world()
+  end
+  setmetatable(view,{
+    __index=function(_,key)
+      local player,world,actor=current();if not player then return nil end
+      if key=='version'then return edition end
+      if key=='generation'then return 3 end
+      if key=='flags'then return flags end
+      if key=='vars'then return vars end
+      if key=='engine'then return 'game3'end
+      if key=='bag'then return bag end
+      if key=='dex'then return dex end
+      if key=='party'then
+        local count=#(save.party or{})
+        for i,m in ipairs(save.party or{})do party[i]=record.mons:view(m)end
+        for i=#party,count+1,-1 do party[i]=nil end
+        return party
+      end
+      if key=='secretId'then return player.secretId or player.sid or 0 end
+      if key=='safari'then
+        local out;if save.safari then out={};for k,v in pairs(save.safari)do if type(v)~='table'then out[k]=v end end end
+        return out
+      end
+      if key=='map'then return record:map()end
+      if key=='x'or key=='y'then return actor and actor[key=='x'and'cellX'or'cellY']or player[key]end
+      if key=='facing'then return actor and actor.facing or player.facing end
+      if key=='name'then return player.name end
+      if key=='rivalName'then return player.rival end
+      if key=='trainerId'then return player.id end
+      if key=='gender'then return player.gender end
+      if key=='money'or key=='coins'or key=='modData'or key=='meta'or key=='options'then return save[key]end
+      if key=='biking'then return save.onBike==true end
+      if key=='bikeType'then return actor and actor.acroBike and'acro'or save.bikeType end
+      if key=='surfing'then if actor then return actor.surfing==true end;return player.surfing==true end
+      if key=='underwater'then return world and world.map.def.mapType=='UNDERWATER'or false end
+      if key=='elevation'then return actor and actor.elevation or player.elevation end
+      local seconds=record:seconds();local whole=math.floor(seconds)
+      if key=='playTime'or key=='playtime'then
+        local clock=record.clock
+        clock.hours,clock.minutes,clock.seconds=math.floor(whole/3600),math.floor(whole/60)%60,whole%60
+        clock.vblanks=math.floor((seconds-whole)*60+.000001)
+        return clock
+      end
+      if key=='hours'or key=='playTimeHours'then return math.floor(whole/3600)end
+      if key=='minutes'or key=='playTimeMinutes'then return math.floor(whole/60)%60 end
+      if key=='seconds'or key=='playTimeSeconds'then return whole%60 end
+    end,
+    __newindex=function(t,key,value)
+      assert(record:valid(),'native session view retired')
+      local player=save.player
+      if key=='money'or key=='coins'then
+        assert(finite(value)and value>=0 and value%1==0 and value<4294967296,'invalid session '..key)
+        save[key]=value
+      elseif key=='flags'or key=='vars'then
+        ScriptMap.replace(scripts,key,value)
+      elseif key=='name'or key=='rivalName'then
+        assert(player and type(value)=='string'and#value<=10 and not value:find('%c'),'invalid player name')
+        player[key=='name'and'name'or'rival']=value
+      elseif key=='gender'then
+        assert(player and(value==0 or value==1),'invalid player gender');player.gender=value
+      elseif key=='trainerId'then
+        assert(player and finite(value)and value>=0 and value<=65535 and value%1==0,'invalid native trainer id');player.id=value
+      elseif key=='biking'then
+        assert(type(value)=='boolean','invalid bike state');save.onBike=value
+      elseif key=='party'or key=='bag'or key=='dex'or key=='secretId'or key=='safari'or key=='map'or key=='x'or key=='y'or key=='facing'or key=='elevation'or key=='surfing'
+          or key=='version'or key=='generation'or key=='engine'or key=='options'or key=='modData'or key=='meta'
+          or key=='playTime'or key=='playtime'or key=='hours'or key=='minutes'or key=='seconds'
+          or key=='playTimeHours'or key=='playTimeMinutes'or key=='playTimeSeconds'then
+        error('session '..key..' belongs to its native command owner',2)
+      else
+        -- Temporary presentation/preview fields stay detached. Persistence
+        -- belongs to mod.save; this never adds fields to a player's save.
+        rawset(t,key,value)
+      end
+    end,
+  })
+  record.scripts=scripts
+  local fields={'version','generation','engine','map','x','y','facing','name','rivalName','trainerId','gender',
+    'party','bag','dex','secretId','safari','money','coins','modData','meta','options','biking','bikeType','surfing','underwater','elevation',
+    'playTime','flags','vars'}
+  Iteration.register(view,function(state,source)
+    assert(state:valid(),'native session view retired')
+    local out={}
+    -- Include detached presentation fields without recursing through the
+    -- registered iterator. No registry callback captures its own weak key.
+    for k,v in Iteration.rawPairs(source)do out[k]=v end
+    for _,key in ipairs(fields)do
+      local v=source[key]
+      if key=='flags'or key=='vars'then v=Iteration.snapshot(v)
+      elseif key=='playTime'and v then
+        v={hours=v.hours,minutes=v.minutes,seconds=v.seconds,vblanks=v.vblanks}
+      end
+      out[key]=v
+    end
+    return out
+  end,record)
+  records[view]=record
+  return view,record
+end
+function M.record(view)return records[view]end
+function M.release(view)
+  local record=records[view]
+  if record then record.retired=true;record.scripts:release();if record.mons then record.mons:release()end end
+end
+function M.store(value,kind)
+  local entry=stores[value]
+  if entry and entry.kind==kind and entry.record:valid()then return entry.record.owner,entry.record.save end
+end
+
+return M
diff --git a/src/compat/gen1/SourceActors.lua b/src/compat/gen1/SourceActors.lua
new file mode 100644
index 000000000..af8f3e711
--- /dev/null
+++ b/src/compat/gen1/SourceActors.lua
@@ -0,0 +1,92 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Draw-only actors join native sorting, never NPC updates or collision pools.
+local Native=require('src.compat.gen1.NativeSession')
+local Scope=require('src.render.GraphicsScope')
+local M={}
+-- An installed presentation is owned even when the mod drops its view.
+-- Retire it explicitly with the native actor/cohort or its installing owner.
+local bindings=setmetatable({},{__mode='k'})
+function M.bind(actor,record)bindings[actor]=record end
+function M.poll()
+ for actor,r in pairs(bindings)do
+  if r.retired or not r.presentationSet or r.view.localId==nil then bindings[actor]=nil end
+ end
+end
+function M.renderer(actor)
+ local r=bindings[actor]
+ if not r then return nil,false end
+ if r.retired or not r.presentationSet or r.view.localId==nil then bindings[actor]=nil;return nil,false end
+ return r.extras.sprite,true
+end
+function M.releaseOwner(_,who)
+ for actor,r in pairs(bindings)do if r.presentationOwner==who then
+  r.presentationSet=nil;r.extras.sprite=nil;bindings[actor]=nil
+ end end
+end
+function M.release()
+ for actor,r in pairs(bindings)do r.presentationSet=nil;r.extras.sprite=nil;bindings[actor]=nil end
+end
+require('src.core.game3.asset_stream').register(M)
+local function finite(n)return type(n)=='number'and n==n and math.abs(n)<math.huge end
+function M.collect(actors)
+ assert(type(actors)=='table','actor collection required')
+ local g,w=Native.resolve();if not g then return actors end
+ local refs=setmetatable({game=g,world=w,map=w.map,save=g.save,data=g.data},{__mode='v'})
+ local edition=require('src.core.GameVersion').get()
+ local function valid()
+  local owner,current=Native.resolve()
+  return owner~=nil and owner==refs.game and current==refs.world and current.map==refs.map and owner.save==refs.save
+   and owner.data==refs.data and require('src.core.GameVersion').get()==edition
+ end
+ for i,r in ipairs(w.ripples or{})do
+  local row={kind='native_ripple',i=i,x=r.px,y=r.py,sortY=r.py,elevation=0,_nativeEffect=true}
+  local observed=setmetatable({r},{__mode='v'})
+  row.draw=function(_,cx,cy)
+   if not valid()then return false end
+   local world,ripple=refs.world,observed[1];if not ripple then return false end
+   local exists=false;for _,v in ipairs(world.ripples or{})do if v==ripple then exists=true end end
+   if not exists then return false end
+   local sprite=world:rippleSprite();if sprite then world:drawRippleRing(sprite,ripple,cx,cy);return true end;return false
+  end
+  actors[#actors+1]=row
+ end
+ return actors
+end
+function M.withActors(game,world,body)
+ local source=package.loaded['src.core.game3.field_effects']
+ if not(source and source.collectActors)or source._hasActorExtensions and not source._hasActorExtensions()then return body()end
+ local rows={};local nativeRows={}
+ -- Native effect records remain identifiable even if a mod removes flags.
+ M.collect(rows);for _,row in ipairs(rows)do nativeRows[row]=true end
+ local boundary=require('src.compat.gen1.ScriptBoundary')
+ local base=function(target)
+  if target~=rows then return M.collect(target)end
+  return rows
+ end
+ boundary.dispatch('field.collectActors',function()return base(rows)end,function()
+  return require('src.compat.gen1.SourceCall').call(source,'collectActors',rows,world.camera and world.camera.x or 0,world.camera and world.camera.y or 0)
+ end)
+ local additions={};local open=true
+ for _,row in ipairs(rows)do if not nativeRows[row]then
+  assert(type(row)=='table'and finite(row.x)and finite(row.y)and finite(row.sortY or row.y),'invalid field actor position')
+  assert(type(row.draw)=='function'or type(row.renderer)=='table'and type(row.renderer.draw)=='function','field actor needs a renderer')
+  local e={px=row.x,py=row.sortY or row.y,cellX=math.floor(row.x/16),cellY=math.floor(row.y/16),
+   elevation=row.elevation or 0,gen3Elevation=row.elevation or 0,facing=row.facing or'down',passable=true,def={passable=true},customSourceActor=true}
+  function e:pose()return row.renderer,row.x,row.y,self.facing,row.walkPhase or 0,false,false end
+  function e:draw(cx,cy)
+   if not open then return false end
+   if row.draw then return row:draw(cx,cy)end
+   return row.renderer:draw(row.x,row.y,cx,cy,self.facing,row.walkPhase or 0,row.stepFlip==true)
+  end
+  additions[#additions+1]=e
+ end end
+ if #additions==0 then return body()end
+ local original=world.entities;local combined={}
+ for i,e in ipairs(original or{})do combined[i]=e end
+ for _,e in ipairs(additions)do combined[#combined+1]=e end
+ world.entities=combined
+ local ok,result=Scope.call(body);open=false;world.entities=original
+ if not ok then error(result,0)end
+ return result
+end
+return M
diff --git a/src/compat/gen1/SourceCall.lua b/src/compat/gen1/SourceCall.lua
new file mode 100644
index 000000000..0cd45af92
--- /dev/null
+++ b/src/compat/gen1/SourceCall.lua
@@ -0,0 +1,17 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Attribute a native phase to the mod that installed its source wrapper.
+local M={}
+function M.owner(module,name)
+ local facade=require('src.core.Game3');local host=package.loaded['src.mods.Runtime']
+ local owner=host and host.currentMod or facade._callbackOwner()
+ local seams=package.loaded['src.mods.ModSeams']
+ for i=#(seams and seams._journal or{}),1,-1 do
+  local change=seams._journal[i]
+  if change.tbl==module and change.key==name and change.after==module[name]then owner=change.owner;break end
+ end
+ return owner
+end
+function M.call(module,name,...)
+ return require('src.core.Game3')._withCallbackOwner(M.owner(module,name),module[name],...)
+end
+return M
diff --git a/src/compat/gen1/SourcePokemon.lua b/src/compat/gen1/SourcePokemon.lua
new file mode 100644
index 000000000..570100e51
--- /dev/null
+++ b/src/compat/gen1/SourcePokemon.lua
@@ -0,0 +1,63 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Resolve typed residents or project detached mod records onto native rules.
+-- A numeric source species is never used as a native catalogue key.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local PartyViews=require('src.compat.gen1.PokemonView')
+local Stats=require('src.pokemon.Stats')
+local M={}
+local names={hp='hp',atk='attack',def='defense',spe='speed',spa='spatk',spd='spdef'}
+local fields={maxHp='hp',attack='attack',defense='defense',speed='speed',spAtk='spatk',spDef='spdef'}
+function M.resident(value)
+ local mon,known,game=PartyViews.resolve(value)
+ if known then return mon,known,game end
+ local battles=package.loaded['src.compat.gen1.BattleView']
+ if battles then return battles.nativeMon(value)end
+ return nil,false
+end
+function M.resolve(value)
+ assert(type(value)=='table','Pokemon record required')
+ local mon,known,game=M.resident(value)
+ if known then assert(mon,'native Pokemon view retired');return mon,game,function()end end
+ game=assert(Native.game(),'no native Pokemon dataset')
+ local data=game.data;local ids=Ids.new(data)
+ local key=assert(ids:native('pokemon',value.species),'unknown cartridge species')
+ local def=data.pokemon[key];local level=tonumber(value.level)or 5
+ assert(level==level and level%1==0 and level>=1 and level<=100,'invalid Pokemon level')
+ mon={species=key,level=level,personality=value.personality or 0,ivs={},evs={},moves={},hp=value.hp,exp=value.exp,
+  happiness=value.friendship or value.happiness or def.friendship or 70,nickname=value.nickname,isEgg=value.isEgg,
+  item=ids:native('items',value.item),otId=value.otId,otSecretId=value.otSecretId}
+ assert(type(mon.personality)=='number'and mon.personality%1==0 and mon.personality>=0 and mon.personality<4294967296,'invalid personality')
+ mon.nature=(data.constants.natureOrder or{})[mon.personality%25+1]
+ mon.abilitySlot=mon.personality%2+1
+ for a,b in pairs(names)do
+  local iv=(value.ivs or{})[a]or(value.ivs or{})[b]or 0
+  local ev=(value.evs or{})[a]or(value.evs or{})[b]or 0
+  assert(type(iv)=='number'and iv%1==0 and iv>=0 and iv<=31,'invalid IV')
+  assert(type(ev)=='number'and ev%1==0 and ev>=0 and ev<=255,'invalid EV')
+  mon.ivs[b],mon.evs[b]=iv,ev
+ end
+ mon.stats=Stats.calcGen3(def,level,mon.ivs,mon.evs,mon.nature)
+ -- Explicit combat stats may include temporary overworld modifiers.
+ for a,b in pairs(fields)do
+  local n=value[a]
+  if type(n)=='number'and n>0 then assert(n==n and n<math.huge,'invalid combat stat');mon.stats[b]=n end
+ end
+ mon.hp=math.max(0,math.min(mon.stats.hp,mon.hp or mon.stats.hp))
+ PartyViews.setStatus(mon,value.status)
+ for i,id in ipairs(value.moves or{})do
+  local native=assert(ids:native('moves',id),'unknown cartridge move')
+  mon.moves[i]={id=native,pp=(value.pp or{})[i]or data.moves[native].pp}
+ end
+ local function commit()
+  assert(Native.game()==game and game.data==data and ids:valid(),'native Pokemon dataset retired')
+  for a,b in pairs(fields)do value[a]=mon.stats[b]end
+  value.level,value.exp,value.hp=mon.level,mon.exp,mon.hp
+  value.status=PartyViews.status(mon)
+ end
+ return mon,game,commit
+end
+function M.ensure(value)
+ local mon,_,commit=M.resolve(value);commit();return value,mon
+end
+return M
diff --git a/src/compat/gen1/UiFlow.lua b/src/compat/gen1/UiFlow.lua
new file mode 100644
index 000000000..0f7ba2158
--- /dev/null
+++ b/src/compat/gen1/UiFlow.lua
@@ -0,0 +1,66 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native stack flows keep callbacks and child screens in one live cohort.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local M={}
+local flows=setmetatable({},{__mode='k'})
+function M.new(done)
+ assert(done==nil or type(done)=='function','invalid UI continuation')
+ local g,w,p=Native.resolve();if not(g and g.stack)then return nil,'no native UI owner'end
+ local host=require('src.mods.Runtime');local facade=require('src.core.Game3')
+ local who=host.currentMod or facade._callbackOwner();local loader=g.mods
+ local mod=who and loader and loader.mods and loader.mods[who]
+ if not(mod and mod.enabled~=false and not mod.failed)then return nil,'no live mod UI owner'end
+ local f={game=g,world=w,player=p,map=w.map,save=g.save,data=g.data,stack=g.stack,loader=loader,mod=mod,
+  edition=Version.get(),who=who,done=done,states={}}
+ flows[f]=true
+ function f:valid()
+  if self.retired then return false end
+  local current,world,player=Native.resolve()
+  return current==self.game and world==self.world and player==self.player and world.map==self.map
+   and current.save==self.save and current.data==self.data and current.stack==self.stack and current.mods==self.loader
+   and Version.get()==self.edition and self.loader.mods[self.who]==self.mod and self.mod.enabled~=false and not self.mod.failed
+ end
+ function f:admit(fn,...)
+  assert(self:valid(),'native UI flow retired')
+  local stack=self.stack;local previous=stack._nativeUiAdmission;stack._nativeUiAdmission=self
+  local function pack(...)return{n=select('#',...),...}end
+  local result=pack(pcall(fn,...));stack._nativeUiAdmission=previous
+  if not result[1]then error(result[2],0)end
+  return (table.unpack or unpack)(result,2,result.n)
+ end
+ function f:attach(state)
+  assert(self:valid(),'native UI flow retired');state.nativeUiFlow=self;self.states[#self.states+1]=state;return state
+ end
+ function f:push(state)self:attach(state);self.stack:push(state);return state end
+ function f:retire()
+  if self.retired then return end
+  self.retired=true;self.done=nil
+  local states=self.states;self.states={}
+  if self.stack and self.stack.removeAll then self.stack:removeAll(states)end
+  for _,s in ipairs(states)do if s.nativeUiFlow==self then s.nativeUiFlow=nil end end
+  flows[self]=nil;self.game,self.world,self.player,self.map,self.save,self.data,self.loader,self.mod,self.stack=nil,nil,nil,nil,nil,nil,nil,nil,nil
+ end
+ function f:finish(...)
+  if not self:valid()then self:retire();return false end
+  local callback,owner=self.done,self.who;self.done=nil;self:retire()
+  if callback then facade._withCallbackOwner(owner,callback,...)end
+  return true
+ end
+ return f
+end
+function M.inherit(stack,state)
+ local top=stack:top();local flow=stack._nativeUiAdmission or top and top.nativeUiFlow
+ if flow and rawget(state,"nativeUiFlow")==nil and not state.modOwnedScreen and flow:valid()then flow:attach(state)end
+end
+function M.poll()
+ local retire={};for f in pairs(flows)do if not f:valid()then retire[#retire+1]=f end end
+ for _,f in ipairs(retire)do f:retire()end
+end
+function M.releaseOwner(_,who)
+ local retire={};for f in pairs(flows)do if f.who==who then retire[#retire+1]=f end end
+ for _,f in ipairs(retire)do f:retire()end
+end
+function M.release()local retire={};for f in pairs(flows)do retire[#retire+1]=f end;for _,f in ipairs(retire)do f:retire()end end
+require('src.core.game3.asset_stream').register(M)
+return M
diff --git a/src/core/Data.lua b/src/core/Data.lua
index ca41e93a0..224ede426 100644
--- a/src/core/Data.lua
+++ b/src/core/Data.lua
@@ -535,6 +535,20 @@ local function normalizeMapId(mapId)
   return table.concat(out)
 end
 
+-- Imported GBA addresses already identify physical headers. A readable or
+-- normalized spelling must share that record, rather than create another
+-- header at the same group/number. Keep authored/non-GBA aliases unchanged.
+local function gbaMapSlot(maps, source)
+  if not require("src.core.GameVersion").isGen3() then return false end
+  local group, number = source:match("^MAP_G(%d+)_N(%d+)$")
+  group, number = tonumber(group), tonumber(number)
+  local def = maps[source]
+  return group ~= nil and source == string.format("MAP_G%02d_N%02d", group, number)
+    and type(def) == "table" and def.id == source
+    and def.group == group and def.number == number
+    and (def.sourceId == nil or def.sourceId == source)
+end
+
 -- AN ALIAS REMEMBERS WHAT IT WAS MADE FROM.
 --
 -- `normalizeMapId` exists for the Game Boy games, where a map id like
@@ -558,6 +572,7 @@ end
 local function aliasMap(maps, source)
   local alias = normalizeMapId(source)
   if alias == source or maps[alias] or not maps[source] then return end
+  if gbaMapSlot(maps, source) then maps[alias] = maps[source]; return end
   local mapped = copy(maps[source])
   mapped.id = alias
   mapped.sourceId = source
@@ -580,7 +595,12 @@ local function seedMapAliases(maps, aliases)
       local mapped = copy(maps[friendlyId]); mapped.id = rawId; maps[rawId] = mapped
     end
     if not maps[friendlyId] and maps[rawId] then
-      local mapped = copy(maps[rawId]); mapped.id = friendlyId; maps[friendlyId] = mapped
+      if gbaMapSlot(maps, rawId) then maps[friendlyId] = maps[rawId]
+      else
+        local mapped = copy(maps[rawId]); mapped.id = friendlyId
+        if require("src.core.GameVersion").isGen2() then mapped.sourceId = maps[rawId].sourceId or rawId end
+        maps[friendlyId] = mapped
+      end
     end
   end
 end
@@ -1934,7 +1954,7 @@ function Data:seedDefaults()
       end
     end
   end
-  if require("src.core.GameVersion").get() == "firered" then
+  if require("src.core.GameVersion").isFRLG() then
     seedMapAliases(self.maps, FIRERED_STORY_MAP_ALIASES)
     preferMapAliases(self.maps, FIRERED_STORY_MAP_ALIASES)
     for mapId, textConst in pairs(FIRERED_STORY_OBJECT_TEXT) do
diff --git a/src/core/FilePicker.lua b/src/core/FilePicker.lua
new file mode 100644
index 000000000..cca832874
--- /dev/null
+++ b/src/core/FilePicker.lua
@@ -0,0 +1,84 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Shared desktop picker contract. RomImporter retains the one dialog launch
+-- path, including pointer-grab release; importing this module starts nothing.
+local Host=require('src.core.HostShell')
+local M={IMAGE={label='Image',exts={'png','jpg','jpeg'}}}
+local function promptOk(value)return type(value)=='string'and #value<=512 and not value:find('%z')end
+local function kindOf(kind)
+ kind=kind or M.IMAGE
+ if type(kind)~='table'or type(kind.exts)~='table'or #kind.exts<1 or #kind.exts>16 then return end
+ local label=kind.label or 'File'
+ if type(label)~='string'or #label>128 or label:find('[%z\r\n|]')then return end
+ local exts,seen={},{}
+ for _,ext in ipairs(kind.exts)do
+  if type(ext)~='string'or #ext>24 or not ext:match('^[%w][%w_.-]*$')then return end
+  ext=ext:lower();if not seen[ext]then seen[ext]=true;exts[#exts+1]=ext end
+ end
+ return{label=label,exts=exts}
+end
+local function backend()
+ if not Host.canSpawnProcess()then return end
+ local os=love.system.getOS()
+ if os=='OS X'or os=='Windows'then return os end
+ if os=='Linux'then
+  if Host.hasCommand('zenity')then return 'zenity'end
+  if Host.hasCommand('kdialog')then return 'kdialog'end
+ end
+end
+function M.available()return backend()~=nil end
+function M.matches(name,kind)
+ local k=kindOf(kind);if not k or type(name)~='string'then return false end
+ name=name:lower()
+ for _,ext in ipairs(k.exts)do if name:sub(-#ext-1)=='.'..ext then return true end end
+ return false
+end
+local function shell(value)return "'"..value:gsub("'","'\\''").."'"end
+local function apple(value)return '"'..value:gsub('\\','\\\\'):gsub('"','\\"'):gsub('\n','\\n'):gsub('\r','\\r')..'"'end
+-- Untrusted UTF-8 travels as decimal bytes, never as PowerShell/cmd syntax.
+local function windows(value)
+ local bytes={};for i=1,#value do bytes[i]=tostring(value:byte(i))end
+ return '([Text.Encoding]::UTF8.GetString([byte[]]@('..table.concat(bytes,',')..')))'
+end
+function M.commands(prompt,kind)
+ local k=kindOf(kind)
+ if not k or not promptOk(prompt)then return end
+ local os=backend();if not os then return end
+ local globs,types={},{}
+ for i,ext in ipairs(k.exts)do globs[i]='*.'..ext;types[i]=apple(ext)end
+ if os=='OS X'then
+  local script='POSIX path of (choose file with prompt '..apple(prompt)..' of type {'..table.concat(types,', ')..'})'
+  return{'osascript -e '..shell(script)..' 2>/dev/null'}
+ elseif os=='Windows'then
+  local patterns=table.concat(globs,';')
+  local filter=k.label..' ('..patterns..')|'..patterns..'|All files (*.*)|*.*'
+  local script=table.concat({'Add-Type -AssemblyName System.Windows.Forms;',
+   '$d=New-Object System.Windows.Forms.OpenFileDialog;','$d.Title='..windows(prompt)..';',
+   '$d.Filter='..windows(filter)..';',"if($d.ShowDialog() -eq 'OK'){$p=$d.FileName;$ascii=$true;",
+   'foreach($c in $p.ToCharArray()){if([int]$c -lt 32 -or [int]$c -gt 126){$ascii=$false}};',
+   '[Console]::OutputEncoding=[Text.Encoding]::UTF8;if($ascii){[Console]::Write($p)}else{',
+   "$t=Join-Path $env:TEMP ('pokeport_base_'+[Guid]::NewGuid().ToString('N')+'.bin');",
+   'try{Copy-Item -LiteralPath $p -Destination $t -ErrorAction Stop;[Console]::Write($t)}catch{}}}'})
+  local command='powershell -NoProfile -STA -Command "'..script..'"'
+  if #command>7000 then return end
+  return{command}
+ elseif os=='zenity'then
+  return{'zenity --file-selection --title='..shell(prompt)..' --file-filter='..shell(k.label..' | '..table.concat(globs,' '))..' 2>/dev/null'}
+ else
+  return{'kdialog --getopenfilename "$HOME" '..shell(table.concat(globs,' ')..'|'..k.label)..' --title '..shell(prompt)..' 2>/dev/null'}
+ end
+end
+function M.open(prompt,kind)
+ local k=kindOf(kind);if not k or not promptOk(prompt)then return end
+ return require('src.import.RomImporter').chooseFileByExt(k.exts,nil,{title=prompt,label=k.label})
+end
+function M.basename(path)return tostring(path or''):match('([^/\\]+)$')or tostring(path or'')end
+function M.read(path)
+ if type(path)~='string'or path:find('%z')then return nil,'invalid native file path'end
+ local opened,file,why=pcall(io.open,path,'rb')
+ if not opened or not file then return nil,opened and why or file end
+ local ok,bytes,err=pcall(file.read,file,'*a');pcall(file.close,file)
+ if not ok then return nil,bytes end
+ if not bytes or bytes==''then return nil,err or 'empty file'end
+ return bytes
+end
+return M
diff --git a/src/core/Game.lua b/src/core/Game.lua
index 0ebe75e81..bcf1450d2 100644
--- a/src/core/Game.lua
+++ b/src/core/Game.lua
@@ -1004,78 +1004,17 @@ function Game:toggleFrameProfile()
   return FrameProfile.toggle()
 end
 
-function Game:_draw()
-  -- the UI canvas clears transparent when the overworld's world pass
-  -- shows through beneath it; opaque full-screen states get the classic
-  -- white clear
-  local base = self.stack:visibleBase()
-  local worldBelow = self.stack.states[base] == self.overworld
-  -- a world-bg battle keeps the map drawing under whatever it opened, so the
-  -- world pass can run for a frame whose CLEAR is still an opaque menu's
-  local drawFrom = Game.drawBaseInStack(self.stack, base)
-  local worldDrawn = self.stack.states[drawFrom] == self.overworld
-  -- A wide battle holds its 304px surface through every menu or prompt it
-  -- opens. States that do not draw the wide battle composition are centred
-  -- in that surface below, so their classic coordinates and hit testing stay
-  -- unchanged. Outside a battle, including the title screen, the option is
-  -- intentionally inactive because it is a battle-layout setting.
-  local wideBattle = Game.wideBattleInStack(self.stack)
-  -- ...and a Gen 3 battle that widened its own screen holds it the same way,
-  -- ahead of the topmost-uiSize pick (see Game.heldSurfaceInStack).
-  local held = not wideBattle and Game.heldSurfaceInStack(self.stack) or nil
-  local native = not wideBattle
-    and (held or Game.nativeSurfaceInStack(self.stack)) or nil
-  local classicOffset, classicOffsetY = 0, 0
-  if wideBattle and wideBattle.uiSize then
-    Renderer:setUISize(wideBattle:uiSize())
-    classicOffset = math.floor((select(1, Renderer:uiSize()) - Renderer.WIDTH) / 2)
-  elseif native then
-    Renderer:setUISize(native:uiSize())
-    -- ...and a state that did NOT ask for the bigger surface is centred in
-    -- it, the way the wide battle centres its menus: its layout is in Game
-    -- Boy coordinates and must land in the middle rather than in a corner.
-    local uw, uh = Renderer:uiSize()
-    classicOffset = math.floor((uw - Renderer.WIDTH) / 2)
-    classicOffsetY = math.floor((uh - Renderer.HEIGHT) / 2)
-  else
-    Renderer:setUISize(Renderer.WIDTH, Renderer.HEIGHT)
-  end
-  -- the surface every state below is either drawing in or being centred
-  -- inside, resolved before any of them draws
-  local surfW, surfH = Renderer:uiSize()
-  -- BATTLE SIZE: scale the battle surface to the window instead of the
-  -- classic integer letterbox.  Read from the whole stack, not just the top,
-  -- so a party menu or text box opened mid-battle keeps the same surface.
-  Renderer.uiFill = Game.fillScaleInStack(self.stack)
-  -- BATTLE BG "world": dim the overworld the battle is drawn over.  Read off
-  -- the stack for the same reason as uiFill above -- a prompt opened during
-  -- the battle must not drop the dim for a frame.
-  Renderer.battleDim = Game.worldBgBattleDim(self.stack)
-  -- ...and for the same reason the UI's own scale has to know the world is
-  -- still the backdrop while an opaque menu covers it.  Renderer:uiScale
-  -- steps the UI down with the survey zoom only while a world is behind it,
-  -- gated on this frame's world pass -- which the party menu and the bag end
-  -- by being opaque.  Without this hold they lose the step-down and blit at
-  -- full fit scale over a battle drawn at the zoomed-out one.
-  Renderer.uiWorldHold = Renderer.battleDim ~= nil
-  -- ...and a battle keeps its dialogue box and YES/NO inside its own screen
-  -- instead of letting them dock to the window edge.
-  -- UI LAYOUT: CENTERED (the default) is a fixed letterbox -- every element
-  -- stays inside the 160x144 canvas and the UI does not follow the survey
-  -- zoom, so the screen furniture never moves or resizes under the player.
-  -- That is the composition the port shipped with.  DYNAMIC opts into both
-  -- halves: the dialogue box docks to the window's bottom edge, the START
-  -- menu to its top right, and the whole UI steps down with the zoom.
-  Renderer.uiCentered = not Game.dynamicUI(self.save)
-  Renderer.uiAnchorHold = Game.uiAnchorsHeldInStack(self.stack)
+local function paintResolvedFrame(self, drawFrom, worldBelow, worldDrawn, native, classicOffset, classicOffsetY, surfW, surfH)
   Renderer:beginFrame(worldBelow)
+  local presentation=package.loaded['src.render.NativePresentation']
+  if presentation then presentation._nativeBegin(self,Renderer:uiSize())end
   -- SINGLE-SCREEN DS PLAY: an opaque DS screen at the bottom of what is
   -- drawn (a menu, the bag, the box -- no world pass under it) is drawn with
   -- everything over it at the window's scale, letters smoothed, rather than
   -- blown up afterwards (src/render/SuperSample.lua). The battle does the
   -- same for itself when it is drawn over the world.
-  local function drawStates()
-    for i = drawFrom, #self.stack.states do
+  local function drawStates(first, last)
+    for i = first or drawFrom, last or #self.stack.states do
       local state = self.stack.states[i]
       local wideState = state and state.isWideBattleLayout
         and state:isWideBattleLayout()
@@ -1115,13 +1054,19 @@ function Game:_draw()
       end
     end
   end
+  local paintStates=drawStates
+  local uiPass=require('src.core.GameVersion').isGen3()
+    and package.loaded['src.ui.game3.ui_pass']
+  if uiPass and (uiPass._wrapped()or presentation and presentation._active())then
+    paintStates=function()return uiPass._nativeStates(self,self.stack,drawFrom,drawStates)end
+  end
   local baseState = self.stack.states[drawFrom]
   local SuperSample = require("src.render.SuperSample")
   if not worldDrawn and baseState and require("src.core.GameVersion").isNds()
      and SuperSample.singleScreen(self) and not SuperSample.active then
-    SuperSample.draw(self, self.stack:top(), drawStates)
+    SuperSample.draw(self, self.stack:top(), paintStates)
   else
-    drawStates()
+    paintStates()
   end
   -- SGB colorization: the topmost state that knows its palette owns the
   -- screen (overlays like text boxes inherit from what's beneath them);
@@ -1194,6 +1139,78 @@ function Game:_draw()
   if not Renderer.splitViewport then TouchControls:draw() end
 end
 
+function Game:_draw()
+  -- the UI canvas clears transparent when the overworld's world pass
+  -- shows through beneath it; opaque full-screen states get the classic
+  -- white clear
+  local base = self.stack:visibleBase()
+  local worldBelow = self.stack.states[base] == self.overworld
+  -- a world-bg battle keeps the map drawing under whatever it opened, so the
+  -- world pass can run for a frame whose CLEAR is still an opaque menu's
+  local drawFrom = Game.drawBaseInStack(self.stack, base)
+  local worldDrawn = self.stack.states[drawFrom] == self.overworld
+  -- A wide battle holds its 304px surface through every menu or prompt it
+  -- opens. States that do not draw the wide battle composition are centred
+  -- in that surface below, so their classic coordinates and hit testing stay
+  -- unchanged. Outside a battle, including the title screen, the option is
+  -- intentionally inactive because it is a battle-layout setting.
+  local wideBattle = Game.wideBattleInStack(self.stack)
+  -- ...and a Gen 3 battle that widened its own screen holds it the same way,
+  -- ahead of the topmost-uiSize pick (see Game.heldSurfaceInStack).
+  local held = not wideBattle and Game.heldSurfaceInStack(self.stack) or nil
+  local native = not wideBattle
+    and (held or Game.nativeSurfaceInStack(self.stack)) or nil
+  local classicOffset, classicOffsetY = 0, 0
+  if wideBattle and wideBattle.uiSize then
+    Renderer:setUISize(wideBattle:uiSize())
+    classicOffset = math.floor((select(1, Renderer:uiSize()) - Renderer.WIDTH) / 2)
+  elseif native then
+    Renderer:setUISize(native:uiSize())
+    -- ...and a state that did NOT ask for the bigger surface is centred in
+    -- it, the way the wide battle centres its menus: its layout is in Game
+    -- Boy coordinates and must land in the middle rather than in a corner.
+    local uw, uh = Renderer:uiSize()
+    classicOffset = math.floor((uw - Renderer.WIDTH) / 2)
+    classicOffsetY = math.floor((uh - Renderer.HEIGHT) / 2)
+  else
+    Renderer:setUISize(Renderer.WIDTH, Renderer.HEIGHT)
+  end
+  -- the surface every state below is either drawing in or being centred
+  -- inside, resolved before any of them draws
+  local surfW, surfH = Renderer:uiSize()
+  -- BATTLE SIZE: scale the battle surface to the window instead of the
+  -- classic integer letterbox.  Read from the whole stack, not just the top,
+  -- so a party menu or text box opened mid-battle keeps the same surface.
+  Renderer.uiFill = Game.fillScaleInStack(self.stack)
+  -- BATTLE BG "world": dim the overworld the battle is drawn over.  Read off
+  -- the stack for the same reason as uiFill above -- a prompt opened during
+  -- the battle must not drop the dim for a frame.
+  Renderer.battleDim = Game.worldBgBattleDim(self.stack)
+  -- ...and for the same reason the UI's own scale has to know the world is
+  -- still the backdrop while an opaque menu covers it.  Renderer:uiScale
+  -- steps the UI down with the survey zoom only while a world is behind it,
+  -- gated on this frame's world pass -- which the party menu and the bag end
+  -- by being opaque.  Without this hold they lose the step-down and blit at
+  -- full fit scale over a battle drawn at the zoomed-out one.
+  Renderer.uiWorldHold = Renderer.battleDim ~= nil
+  -- ...and a battle keeps its dialogue box and YES/NO inside its own screen
+  -- instead of letting them dock to the window edge.
+  -- UI LAYOUT: CENTERED (the default) is a fixed letterbox -- every element
+  -- stays inside the 160x144 canvas and the UI does not follow the survey
+  -- zoom, so the screen furniture never moves or resizes under the player.
+  -- That is the composition the port shipped with.  DYNAMIC opts into both
+  -- halves: the dialogue box docks to the window's bottom edge, the START
+  -- menu to its top right, and the whole UI steps down with the zoom.
+  Renderer.uiCentered = not Game.dynamicUI(self.save)
+  Renderer.uiAnchorHold = Game.uiAnchorsHeldInStack(self.stack)
+  local display = require('src.core.GameVersion').generation() == 3
+    and package.loaded['src.core.game3.display']
+  if display then
+    return display._nativePresent(self, paintResolvedFrame, drawFrom, worldBelow, worldDrawn, native, classicOffset, classicOffsetY, surfW, surfH)
+  end
+  return paintResolvedFrame(self, drawFrom, worldBelow, worldDrawn, native, classicOffset, classicOffsetY, surfW, surfH)
+end
+
 -- overworld survey zoom: wheel up / '=' zooms in, wheel down / '-' out
 function Game:zoomStep(delta)
   local view=self:zoomView()
diff --git a/src/core/Game3.lua b/src/core/Game3.lua
new file mode 100644
index 000000000..92c3ae9e5
--- /dev/null
+++ b/src/core/Game3.lua
@@ -0,0 +1,300 @@
+-- A distinct facade for source wrappers. The existing Game still owns every
+-- simulation, frame and IO operation; requiring this cannot bootstrap it.
+local Native=require('src.compat.gen1.NativeSession')
+local Views=require('src.compat.gen1.SessionView')
+local Version=require('src.core.GameVersion')
+local CoroutineScopes=require('src.compat.gen1.CoroutineScopes')
+local G={}
+local entries=setmetatable({},{__mode='k'})
+local owners=setmetatable({},{__mode='k'})
+local scopes=CoroutineScopes.new()
+local BODY={}
+local bases={}
+local bootLeases=setmetatable({},{__mode='k'})
+local mouseBodies=setmetatable({},{__mode='k'})
+local callbackOwners={}
+local actorCallbackOwners={}
+local callbackScopes=CoroutineScopes.new()
+local unpack=table.unpack or unpack
+local function pack(...)return {n=select('#',...),...}end
+function G._callbackOwner()
+  local frame=callbackScopes:find('owner')
+  return frame and frame.value
+end
+function G._withCallbackOwner(owner,fn,...)
+  local frame=callbackScopes:push('owner',owner)
+  local result=pack(pcall(fn,...))
+  local views=package.loaded['src.compat.gen1.PokemonView']
+  if result[1]and not frame.closed and not CoroutineScopes.retired()and views then
+    local ok,why=pcall(views.flush)
+    if not ok then result={n=2,false,why}end
+  end
+  local retired=frame.closed or CoroutineScopes.retired()
+  callbackScopes:close(frame)
+  if not result[1]then error(result[2],0)end
+  if retired then error('native callback owner retired while suspended',0)end
+  return unpack(result,2,result.n)
+end
+local function methodOwner(name)
+  local seams=package.loaded['src.mods.ModSeams'];local journal=seams and seams._journal or{}
+  for i=#journal,1,-1 do
+    local change=journal[i]
+    if change.tbl==G and change.key==name and change.after==G[name]then return change.owner end
+  end
+end
+local function entry(view)
+  local e=entries[view]
+  assert(e and not e.retired,'native Game3 facade retired or unbound')
+  return e
+end
+function G.native(value)
+  if value==nil then return package.loaded['src.core.Game']end
+  local e=entries[value]
+  if e then return not e.retired and e.owner or nil end
+  if type(value)=='table'and type(rawget(value,'game'))=='table'then return G.native(rawget(value,'game'))end
+  return value
+end
+local function session(e)
+  if e.session then
+    local record=Views.record(e.session)
+    if record and record:valid()then return e.session end
+    Views.release(e.session);e.session=nil
+  end
+  e.session=Views.new(e.owner)
+  return e.session
+end
+local function forward(view,name,...)
+  assert(not CoroutineScopes.retired(),'native Game3 coroutine retired')
+  local e=entry(view);local c=scopes:find(name)
+  if c and c.view==view then
+    if c.called then
+      if c.failed then error(c.failure,0)end
+      if c.result then return unpack(c.result,1,c.result.n)end
+      return
+    end
+    c.called=true
+    local claim=scopes:push(BODY,nil,c)
+    local result=pack(pcall(c.native,e.owner,...))
+    local retired=c.closed or claim.closed
+    scopes:close(claim)
+    if not result[1]then c.failed=true;c.failure=result[2];error(result[2],0)end
+    if retired then error('native Game3 phase retired while suspended',0)end
+    c.result={n=result.n-1};for i=2,result.n do c.result[i-1]=result[i]end
+    return unpack(c.result,1,c.result.n)
+  end
+  local method=e.owner[name]
+  if type(method)~='function'then return nil,'native method unavailable: '..name end
+  return method(e.owner,...)
+end
+for _,name in ipairs({'update','draw','keypressed','keyreleased','textinput','wheelmoved',
+    'touchpressed','touchmoved','touchreleased','gamepadpressed','gamepadreleased','gamepadaxis',
+    'joystickpressed','joystickreleased','joystickaxis','joystickhat','joystickremoved','focus','visible',
+    'mousepressed','mousemoved','mousereleased','writeOptions','applyOptions','writeSave','returnToTitle',
+    'logicSpeed','speedLocked','_resolveLogicSpeed','zoomStep',
+    'returnToLauncher','restartWithMods'})do
+  local key=name;G[key]=function(view,...)return forward(view,key,...)end;bases[key]=G[key]
+end
+function G.fixedUpdate(view,...)return forward(view,'_step',...)end
+bases.fixedUpdate=G.fixedUpdate
+function G.reset(view)
+  local e=entry(view)
+  local runtime=package.loaded['src.core.game3.runtime'];if runtime and runtime.release then runtime.release()end
+  if e.session then Views.release(e.session);e.session=nil end
+  e.overrides={};e.overridden={};e.bootEpoch={}
+end
+bases.reset=G.reset
+function G._handleBootAction(view,action)
+  local e=entry(view);local lease=type(action)=='table'and bootLeases[action]
+  if not lease or lease.view~=view or lease.epoch~=e.bootEpoch or action.action~=lease.kind then
+    return nil,'boot action belongs to a retired or absent native title callback'
+  end
+  if lease.failed then error(lease.failed,0)end
+  if lease.done then return unpack(lease.result,1,lease.result.n)end
+  if lease.owner.data~=lease.data or lease.owner.save~=lease.save or lease.owner.mods~=lease.loader then
+    return nil,'native title callback retired'
+  end
+  if not lease.done then
+    lease.done=true
+    local ok,why=xpcall(function()lease.result=pack(lease.callback())end,debug.traceback)
+    if not ok then lease.failed=why;error(why,0)end
+  end
+  return unpack(lease.result,1,lease.result.n)
+end
+bases._handleBootAction=G._handleBootAction
+function G._bootAction(owner,action,callback)
+  if Version.generation()~=3 or G._handleBootAction==bases._handleBootAction then return callback()end
+  local view=G.forNative(owner);if not view then return callback()end
+  local e=entries[view]
+  bootLeases[action]={view=view,owner=owner,data=owner.data,save=owner.save,loader=owner.mods,
+    epoch=e.bootEpoch,kind=action.action,callback=callback}
+  return G._dispatch('_handleBootAction',owner,function()return bases._handleBootAction(view,action)end,action)
+end
+function G.stepGC()if collectgarbage then return collectgarbage('step',1)end end
+function G._stepGC()
+  if Version.generation()~=3 then return false end
+  G.stepGC();return true
+end
+function G.forNative(value)
+  local native=G.native(value)
+  if value~=nil and native==nil then return nil,'native Game3 facade retired'end
+  local owner,why=Native.game(native);if not owner then return nil,why end
+  local existing=owners[owner]
+  if existing and not entries[existing].retired then
+    local e=entries[existing]
+    if e.loader==owner.mods or e.resetting then return existing end
+    G._notifyReset(owner);e.retired=true;if e.session then Views.release(e.session)end
+  end
+  local view={};local e={owner=owner,overrides={},overridden={},loader=owner.mods,bootEpoch={}};entries[view]=e;owners[owner]=view
+  setmetatable(view,{
+    __index=function(_,key)
+      if G[key]~=nil then return G[key]end
+      if e.retired then return nil end
+      if e.overridden[key]then return e.overrides[key]end
+      if key=='mods'then return e.loader end
+      if key=='generation'then return 3 end
+      if key=='session'or key=='save'then return session(e)end
+      if key=='phase'then return Native.resolve(owner)and'field'or'boot'end
+      if key=='options'then return owner.save and owner.save.options end
+      if key=='data'then
+        if e.dataset~=owner.data then
+          e.dataset=owner.data
+          local dataset=e.dataset
+          e.dataView=setmetatable({}, {__index=function(_,field)
+            if owner.data~=dataset then return nil end
+            if field=='maps'then return require('src.core.game3.map').definitions(owner)end
+            return dataset and dataset[field]
+          end})
+        end
+        return e.dataView
+      end
+      local value=owner[key]
+      if type(value)~='function'then return value end
+    end,
+    __newindex=function(t,key,value)
+      assert(not e.retired,'native Game3 facade retired')
+      if key=='data'or key=='generation'or key=='phase'then error('Game3 '..key..' belongs to its native owner',2)end
+      if key=='speedOverride'then
+        assert(value==nil or value==false or(type(value)=='number'and value>0 and value<math.huge),'invalid native speed override')
+        owner.speedOverride=value;return
+      end
+      -- Source previews lease their own session/save/options and methods.
+      -- Such replacements must never overwrite the native Game or save.
+      if key=='session'or key=='save'or key=='options'or key=='stack'then
+        assert(value==nil or type(value)=='table','invalid Game3 '..key);e.overrides[key]=value;e.overridden[key]=true
+      else rawset(t,key,value)end
+    end,
+  })
+  return view
+end
+function G.new(owner)
+  if owner==nil then return nil,'native game creation belongs to the host'end
+  return G.forNative(owner)
+end
+function G._dispatch(name,owner,native,...)
+  assert(not CoroutineScopes.retired(),'native Game3 coroutine retired')
+  local sourceName=name=='_step'and'fixedUpdate'or name
+  if mouseBodies[owner]and(name=='touchpressed'or name=='touchmoved'or name=='touchreleased')
+      and select(1,...)=='mouse'then return native(owner,...)end
+  if Version.generation()~=3 or G[sourceName]==bases[sourceName]or scopes:find(name)then return native(owner,...)end
+  local view=G.forNative(owner);if not view then return native(owner,...)end
+  local c=scopes:push(name);c.view,c.native=view,native
+  local args=pack(...);local result
+  local ok,why=xpcall(function()
+    result=pack(G._withCallbackOwner(methodOwner(sourceName)or G._callbackOwner(),G[sourceName],view,unpack(args,1,args.n)))
+  end,debug.traceback)
+  local retired=c.closed
+  scopes:close(c)
+  if c.failed then error(c.failure,0)end
+  if retired then error('native Game3 phase retired while suspended',0)end
+  if not ok then error(why,0)end
+  return unpack(result,1,result.n)
+end
+function G._pointer(name,owner,native,...)
+  local function body(game,...)
+    local previous=mouseBodies[game];mouseBodies[game]=(previous or 0)+1
+    local args=pack(...);local result
+    local ok,why=xpcall(function()result=pack(native(unpack(args,1,args.n)))end,debug.traceback)
+    mouseBodies[game]=previous
+    if not ok then error(why,0)end
+    return unpack(result,1,result.n)
+  end
+  return G._dispatch(name,owner,body,...)
+end
+function G.release()
+  for view,e in pairs(entries)do e.retired=true;if e.session then Views.release(e.session)end end
+  owners=setmetatable({},{__mode='k'})
+  callbackOwners={}
+  actorCallbackOwners={}
+end
+function G._observeActorMod(owner)if type(owner)=='string'then actorCallbackOwners[owner]=true end end
+function G._observeMod(owner)if type(owner)=='string'then callbackOwners[owner]=true end end
+function G._retireMod(owner)callbackOwners[owner]=nil;actorCallbackOwners[owner]=nil end
+function G._usesSourceRecords(owner)return callbackOwners[owner]==true and Version.generation()==3 end
+function G._usesCallbacks(owner)return (callbackOwners[owner]==true or actorCallbackOwners[owner]==true)and Version.generation()==3 end
+local function callbackGame(owner)
+  if not callbackOwners[owner]or Version.generation()~=3 then return end
+  local native=package.loaded['src.core.Game'];if type(native)~='table'then return end
+  return native,G.forNative(native)
+end
+function G._event(owner,name,payload)
+  if not G._usesSourceRecords(owner)or type(payload)~='table'or name:match('^mod%.[%w_%-]+%.')then return payload end
+  local native=package.loaded['src.core.Game'];if type(native)~='table'then return payload end
+  local rawGame=rawget(payload,'game')
+  local saveEvent=name=='save.created'or name=='save.loaded'or name=='save.writing'or name=='save.loading'
+  if payload~=native and rawGame~=native and not saveEvent then return payload end
+  local view=G.forNative(native);if not view then return payload end
+  if payload==native then return view end
+  local out={};for k,v in pairs(payload)do out[k]=v end
+  if rawGame==native then out.game=view;setmetatable(out,{__index=view});entries[out]=entries[view]end
+  if saveEvent then
+    for _,key in ipairs({'save','raw'})do
+      local raw=rawget(payload,key)
+      if type(raw)=='table'then
+        if raw==native.save then out[key]=view.session
+        else out[key]=Views.new({data=native.data,save=raw})end
+      end
+    end
+  end
+  return out
+end
+function G._invokeEvent(owner,name,callback,payload)
+  return G._withCallbackOwner(owner,callback,G._event(owner,name,payload))
+end
+function G._invokeHook(owner,callback,nextFn,...)
+  local native,view=callbackGame(owner)
+  if not view then
+    local function nextNative(...)return G._withCallbackOwner(nil,nextFn,...)end
+    return G._withCallbackOwner(owner,callback,nextNative,...)
+  end
+  local function public(values)
+    for i=1,values.n do if values[i]==native then values[i]=view end end
+    return values
+  end
+  local function raw(values)
+    for i=1,values.n do local e=entries[values[i]];if e then values[i]=not e.retired and e.owner or nil end end
+    return values
+  end
+  local function nextPublic(...)
+    local args=raw(pack(...))
+    local result=public(pack(G._withCallbackOwner(nil,nextFn,unpack(args,1,args.n))))
+    return unpack(result,1,result.n)
+  end
+  local args=public(pack(...))
+  local result=raw(pack(G._withCallbackOwner(owner,callback,nextPublic,unpack(args,1,args.n))))
+  return unpack(result,1,result.n)
+end
+function G._notifyReset(owner)
+  if Version.generation()~=3 then return false end
+  local view=owners[owner];local e=view and entries[view]
+  if not e or e.retired or e.resetNotified then return false end
+  e.resetNotified=true;e.resetting=true
+  local ok,why=xpcall(function()G.reset(view)end,debug.traceback)
+  if not ok then
+    bases.reset(view)
+    require('src.mods.Runtime').reportError('compatibility','reset failed: '..tostring(why))
+    require('src.core.Logger').warn('compatibility reset failed: %s',tostring(why))
+  end
+  e.resetting=nil
+  return true
+end
+return G
diff --git a/src/core/GameVersion.lua b/src/core/GameVersion.lua
index 330f4f3e9..8d0464c60 100644
--- a/src/core/GameVersion.lua
+++ b/src/core/GameVersion.lua
@@ -1117,6 +1117,14 @@ end
 -- ways no amount of widening an `isGen2()` reaches -- a filesystem instead of
 -- a flat ROM, two screens instead of one, and a 3D field.  This exists so the
 -- Gen 4 work has a gate to hang itself on without touching the branches the
+-- Registered GBA family for source mod probes; cache/save ownership stays native.
+local gbaLayouts={firered='frlg',leafgreen='frlg',ruby='rse',sapphire='rse',emerald='rse'}
+function GameVersion.layout(id,versionId)
+  if id==GameVersion then id=versionId end
+  local info=GameVersion.info(id)
+  return info and(info.layout or gbaLayouts[info.id])or nil
+end
+
 -- other three generations take.
 function GameVersion.isGen4(id)
   return GameVersion.generation(id) == 4
diff --git a/src/core/Gen3WeatherIds.lua b/src/core/Gen3WeatherIds.lua
new file mode 100644
index 000000000..a49fe9fd7
--- /dev/null
+++ b/src/core/Gen3WeatherIds.lua
@@ -0,0 +1,19 @@
+-- Copyright (c) 2026 Cedric. All rights reserved.
+-- Source-available under the Gen2Recomped License (see LICENSE.md): you may
+-- read, build and privately modify this file; you may not redistribute it or
+-- use it commercially. Cartridge-derived data is excluded and is not the
+-- copyright holder's to license.
+
+
+-- Shared GBA field-weather identifiers, retained from the native importer.
+local names = {
+  [0] = "NONE", [1] = "SUNNY_CLOUDS", [2] = "SUNNY", [3] = "RAIN",
+  [4] = "SNOW", [5] = "RAIN_THUNDERSTORM", [6] = "FOG_HORIZONTAL",
+  [7] = "VOLCANIC_ASH", [8] = "SANDSTORM", [9] = "FOG_DIAGONAL",
+  [10] = "UNDERWATER", [11] = "SHADE", [12] = "DROUGHT", [13] = "DOWNPOUR",
+  [14] = "UNDERWATER_BUBBLES", [15] = "ABNORMAL",
+  [20] = "ROUTE119_CYCLE", [21] = "ROUTE123_CYCLE",
+}
+local byName={}
+for id,name in pairs(names)do byName[name]=id end
+return {names=names,byName=byName}
diff --git a/src/core/HostShell.lua b/src/core/HostShell.lua
index e7e54b0d2..7b26d3d17 100644
--- a/src/core/HostShell.lua
+++ b/src/core/HostShell.lua
@@ -109,6 +109,18 @@ function HostShell.popen(command, mode)
   return pipe
 end
 
+-- Probe executable names only; callers cannot supply a shell expression.
+function HostShell.hasCommand(name)
+  if not HostShell.canSpawnProcess() or type(name)~='string' or #name>80
+      or not name:match('^[%w][%w_.+-]*$') then return false end
+  local windows=love.system.getOS()=='Windows'
+  local pipe=HostShell.popen(windows and('where '..name..' 2>NUL')or("command -v '"..name.."' 2>/dev/null"))
+  if not pipe then return false end
+  local ok,value=pcall(pipe.read,pipe,'*a')
+  pcall(pipe.close,pipe)
+  return ok and type(value)=='string'and value:find('%S')~=nil
+end
+
 -- Restart the whole app. The obvious love.event.quit("restart") re-runs LÖVE's
 -- boot in-process, which calls love.filesystem.init a second time -- and inside
 -- an AppImage physfs is already initialized, so that second init throws
diff --git a/src/core/Music.lua b/src/core/Music.lua
index e5b95baf6..fca19f123 100644
--- a/src/core/Music.lua
+++ b/src/core/Music.lua
@@ -136,7 +136,14 @@ end
 -- the jingle ends (see update()).
 -- Called by Sound.playCry: unlike a fanfare, the song keeps playing and is
 -- merely attenuated for as long as the cry sounds.
-function Music.duckForCry(data, src)
+function Music.duckForCry(data, src, noDuck)
+  if noDuck then
+    if cryDuck and cryDuck.src==src then
+      cryDuck=nil
+      if not state.fade then applyVolume(state.source);applyVolume(state.loopSource)end
+    end
+    return
+  end
   local c = data and data.constants and data.constants.gen3Cry
   local duck = c and tonumber(c.duckBgm)
   local scale = c and tonumber(c.scale)
diff --git a/src/core/Sound.lua b/src/core/Sound.lua
index 7093a32f5..0b3a54297 100644
--- a/src/core/Sound.lua
+++ b/src/core/Sound.lua
@@ -12,6 +12,8 @@ local Runtime = require("src.mods.Runtime")
 local Sound = {}
 
 local cache = {}
+local effectUses = setmetatable({}, { __mode = "k" })
+local effectCapture
 -- port addition: 0-7 SFX volume from save.options.sfxVol (OptionsMenu),
 -- scaling the 0.8 base every source gets
 local BASE_VOLUME = 0.8
@@ -227,6 +229,7 @@ end
 
 local function playPath(data, key, def, pitch, tempo)
   key = tostring(key)
+  if effectCapture and not effectCapture.source then key = key .. "@borrow:" .. effectCapture.owner end
   if not love.audio or not def then return nil end
   -- INTERRUPTION: building a Source now would fail and cache `false` below,
   -- permanently disabling this effect (see sessionSuspended, case 2)
@@ -245,6 +248,8 @@ local function playPath(data, key, def, pitch, tempo)
     src = s
   end
   if not restart(src) then return nil end
+  local use = { key = key }; effectUses[src] = use
+  if effectCapture and not effectCapture.source then effectCapture.source, effectCapture.use = src, use end
   return src
 end
 
@@ -264,14 +269,76 @@ end
 -- PlaySoundWaitForCurrent -> WaitForSoundToFinish can poll it
 -- Resolve a cartridge effect by its extracted native name, including effects
 -- that have no shared engine role in audio.sfx.
-function Sound.playNamedEffect(data,name)
-  for id,song in pairs(data and data.audio and data.audio.songs or {}) do
-    if type(song)=="table" and song.sfxName==name and tonumber(song.index) then
-      local src=playPath(data,id,{song=id,m4a=tonumber(song.index)})
-      if src then played("sfx",name) end
-      return src
+-- Native numeric/symbolic sequence aliases must resolve unambiguously.
+function Sound.sequenceKey(data, name)
+  if type(name) ~= "string" and type(name) ~= "number" then return nil end
+  local songs = data and data.audio and data.audio.songs or {}
+  if (type(name) == "string" or type(name) == "number") and (type(songs[name]) == "string" or type(songs[name]) == "table") then
+    return name, songs[name]
+  end
+  local key, found
+  for id, song in pairs(songs) do
+    if type(song) == "table" and (song.sfxName == name or song.musName == name
+       or type(name) == "number" and song.index == name) then
+      if found and found ~= song then return nil, "ambiguous native audio id" end
+      key, found = id, song
     end
   end
+  return key, found
+end
+
+-- Borrow the first playback atomically. Events may start another effect
+-- before playSe returns; a replaced playback cannot transfer its new owner
+-- to the earlier caller. Borrowed cache variants preserve native voice gain.
+function Sound.borrowEffect(owner, play, ...)
+  local previous = effectCapture
+  local capture = { owner = tostring(owner) }
+  effectCapture = capture
+  local ok, src = pcall(play, ...)
+  effectCapture = previous
+  if not ok then error(src, 0) end
+  local use = capture.use
+  if not use or capture.source ~= src then return src, nil end
+  local function valid()
+    return not sessionSuspended and effectUses[src] == use and cache[use.key] == src
+  end
+  return src, { valid = valid, level = function()return volumeFor(use.key)end, stop = function()
+    if not valid() then return false end
+    effectUses[src] = nil
+    safeAudio("Source:stop", src.stop, src)
+    return true
+  end }
+end
+
+function Sound.playNamedEffect(data, name)
+  local id, song = Sound.sequenceKey(data, name)
+  if not id then return nil end
+  local def = song
+  if type(song) == "table" and tonumber(song.index) and not song.file then
+    def = { song = id, m4a = tonumber(song.index) }
+  end
+  local src = playPath(data, id, def)
+  if src then played("sfx", name) end
+  return src
+end
+
+-- Weather owns a separate native voice: an ambient stop must not cut off a
+-- mod or scripted one-shot of the same cartridge sequence.
+function Sound.playWeatherEffect(data, name, looping)
+  return Runtime.call("field.weather.sound", function(value)
+    local id, song = Sound.sequenceKey(data, value)
+    if not id then return nil end
+    local def = song
+    if type(song) == "table" and tonumber(song.index) and not song.file then
+      def = { song = id, m4a = tonumber(song.index) }
+    end
+    local src = playPath(data, "weather:" .. tostring(id), def)
+    if src then
+      safeAudio("Source:setLooping", src.setLooping, src, looping == true)
+      played("sfx", value)
+    end
+    return src
+  end, name)
 end
 
 function Sound.play(data, name)
@@ -630,7 +697,12 @@ function Sound.playCry(data, species, opts)
   end
   -- set every time rather than at build: the cached source outlives a change
   -- of game, and the scale is the loaded cartridge's
-  pcall(src.setVolume, src, volumeFor(key) * cryScale(data))
+  local scale=cryScale(data)
+  if opts and type(opts.volume)=='number'and opts.volume==opts.volume and opts.volume>=0 and opts.volume<=256 then
+    local unit=data.constants and data.constants.gen3Cry and tonumber(data.constants.gen3Cry.scale)or 256
+    if unit and unit>0 then scale=opts.volume/unit end
+  end
+  pcall(src.setVolume, src, volumeFor(key) * scale)
   -- Interactive Dex playback owns its source; loop/effect settings must never
   -- leak onto the cached cry used by battles, NPC scripts or other menus.
   if opts and opts.isolated and src.clone then
@@ -638,7 +710,7 @@ function Sound.playCry(data, species, opts)
     if ok and copy then src=copy end
   end
   if not restart(src) then return nil end
-  require("src.core.Music").duckForCry(data, src)
+  require("src.core.Music").duckForCry(data, src,opts and opts.noDuck==true)
   played("cry", species, species)
   return src
 end
diff --git a/src/core/StateStack.lua b/src/core/StateStack.lua
index baf622c4c..16715e27d 100644
--- a/src/core/StateStack.lua
+++ b/src/core/StateStack.lua
@@ -87,6 +87,7 @@ end
 -- settled state; the wants guard keeps the no-listener path allocation-free
 
 function StateStack:push(state, ...)
+  local flows=package.loaded["src.compat.gen1.UiFlow"];if flows then flows.inherit(self,state)end
   table.insert(self.states, state)
   if state.enter then state:enter(...) end
   local depth = #self.states
@@ -105,15 +106,14 @@ function StateStack:push(state, ...)
   end
 end
 
-function StateStack:pop()
-  local state = table.remove(self.states)
+local function finishRemoval(self, state)
   if state and state.exit then state:exit() end
   -- A POP THAT EMPTIES THE STACK is not debug-level news.  The engine does it
   -- on purpose in exactly two places and pushes the replacement in the same
   -- breath; everywhere else it is one pop too many, and the thing it leaves
   -- behind -- a screen that never changes, with no error -- gives the reader
   -- nothing to search for.  So it is said in words, once per culprit.
-  if state ~= nil and #self.states == 0 then
+  if state ~= nil and #self.states == 0 and not self.worldState then
     Logger.warn("state stack: popping %s emptied the stack -- nothing will "
       .. "update or draw until something is pushed back", 
       StateStack.describe(state))
@@ -127,6 +127,35 @@ function StateStack:pop()
   return state
 end
 
+function StateStack:pop()
+  local state = table.remove(self.states)
+  if state and self._modalTracker then self._modalTracker:removed(state) end
+  return finishRemoval(self, state)
+end
+
+-- Remove actual native states, including a named modal beneath another one.
+-- Detach the whole selection before callbacks: a new screen opened by exit
+-- must survive and must never receive another removed screen's exit event.
+function StateStack:removeAll(selected)
+  local wanted, removed = {}, {}
+  for _, state in ipairs(selected) do wanted[state] = true end
+  for i = #self.states, 1, -1 do
+    local state = self.states[i]
+    if wanted[state] then
+      table.remove(self.states, i)
+      if self._modalTracker then self._modalTracker:removed(state) end
+      removed[#removed + 1] = state
+    end
+  end
+  local firstError
+  for _, state in ipairs(removed) do
+    local ok, err = pcall(finishRemoval, self, state)
+    if not ok and not firstError then firstError = err end
+  end
+  if firstError then error(firstError, 0) end
+  return #removed
+end
+
 function StateStack:top()
   return self.states[#self.states]
 end
@@ -174,7 +203,12 @@ end
 -- that wants both puts the motion in animate and calls it from update.
 function StateStack:update(dt)
   local top = self:top()
-  if top and top.update then top:update(dt) end
+  if top and top.update then
+    local flow=top.nativeUiFlow
+    if flow then
+      if flow:valid()then flow:admit(top.update,top,dt)else flow:retire()end
+    else top:update(dt)end
+  end
   for i = self:visibleBase(), #self.states - 1 do
     local state = self.states[i]
     if state.animate then state:animate(dt) end
diff --git a/src/core/game3/audio.lua b/src/core/game3/audio.lua
new file mode 100644
index 000000000..466e32484
--- /dev/null
+++ b/src/core/game3/audio.lua
@@ -0,0 +1,103 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Sound=require('src.core.Sound')
+local A={}
+local Version=require('src.core.GameVersion')
+local records,sources,metadata={},{},{}
+local ENGINE={}
+local function who()
+ local host=package.loaded['src.mods.Runtime']
+ return host and host.currentMod or require('src.core.Game3')._callbackOwner()or ENGINE
+end
+local function finite(n)return type(n)=='number'and n==n and math.abs(n)<math.huge end
+local function current(r)
+ local g=Native.game()
+ return g==r.game and g.data==r.data and g.save==r.save and g.mods==r.mods and Version.get()==r.edition
+end
+local function remove(src,r)
+ if r.lease then r.lease.stop()end
+ records[src]=nil;metadata[src]=nil
+end
+local function poll()
+ for src,r in pairs(records)do
+  if not current(r)or not r.lease.valid()then remove(src,r)end
+ end
+ for i=#sources,1,-1 do sources[i]=nil end
+ for src in pairs(records)do sources[#sources+1]=src end
+ return #sources
+end
+local function gain(g)
+ local opts=g and g.save and g.save.options or{}
+ if opts.audioMuted then return 0 end
+ return math.max(0,math.min(7,tonumber(opts.sfxVol)or 7))/7
+end
+function A.isReady()
+ local g=Native.game();return g~=nil and type(g.data and g.data.audio)=='table'and love~=nil and love.audio~=nil and not g.audioSuspended
+end
+function A.playSe(id,opts)
+  local g=Native.game();if not g or not A.isReady()then return false end
+  if opts~=nil and(type(opts)~='table'or getmetatable(opts)~=nil)then return false,'invalid sound options'end
+  opts=opts or{}
+  for key,value in pairs(opts)do
+   if(key~='volume'and key~='sourceVolume')or not finite(value)or value<0 or value>(key=='volume'and 16 or 1)then
+    return false,'unsupported native sound option: '..tostring(key)
+   end
+  end
+  local value=require('src.core.game3.se_ids').resolve(id)
+  if not finite(value)or value<0 or value%1~=0 then return false end
+  local owner=who()
+  local source,lease=Sound.borrowEffect(owner,function()
+   if Sound.waitSe then return Sound.playSe(g.data,value)end
+   return Sound.playNamedEffect(g.data,id)or Sound.playNamedEffect(g.data,value)or Sound.playId(g.data,value)
+  end)
+  if not source then return false end
+  if not lease or not lease.valid()then return false,'native playback was superseded'end
+  local volume=opts.sourceVolume
+  if volume==nil then
+   volume=lease.level()*(opts.volume or 1)
+  end
+  pcall(source.setVolume,source,math.max(0,math.min(1,volume)))
+  records[source]={game=g,data=g.data,save=g.save,mods=g.mods,edition=Version.get(),owner=owner,id=value,lease=lease}
+  metadata[source]={id=value}
+  poll();return true
+end
+function A.stopSe(id)
+ poll();local value=id~=nil and require('src.core.game3.se_ids').resolve(id)or nil
+ if id~=nil and value==nil then return 0 end
+ local owner=who();local count=0
+ for src,r in pairs(records)do
+  if r.owner==owner and(id==nil or r.id==value)then remove(src,r);count=count+1 end
+ end
+ poll();return count
+end
+function A.isSePlaying(id)
+ poll();local value=id~=nil and require('src.core.game3.se_ids').resolve(id)or nil
+ if id~=nil and value==nil then return false end
+ for src,r in pairs(records)do
+  if(id==nil or r.id==value)then local ok,playing=pcall(src.isPlaying,src);if ok and playing then return true end end
+ end
+ return false
+end
+-- Observe and retire native voices. The engine's audio clock stays with the
+-- native music/sound services, including frames a renderer holds for loading.
+function A.update()return poll()end
+function A.playCry(species,mode,pan)
+  local g=Native.game();if not g then return false end
+  local key=Ids.new(g.data):native('pokemon',species);if not key then return false end
+  return Sound.playCry(g.data,key,{noDuck=type(mode)=='table'and mode.noDuck or mode==1,
+    volume=type(mode)=='table'and mode.volume or nil})~=nil
+end
+function A.isCryFinished()if Sound.isCryFinished then return Sound.isCryFinished()end;return not Sound.anyPlaying('cry')end
+A._seSources,A._seMeta=sources,metadata
+A._service={release=function()
+ for src,r in pairs(records)do remove(src,r)end;poll()
+end,releaseOwner=function(_,owner)
+ for src,r in pairs(records)do if r.owner==owner then remove(src,r)end end;poll()
+end,poll=poll}
+require('src.core.game3.asset_stream').register(A._service)
+return setmetatable(A,{__index=function(_,key)
+ local g=Native.game()
+ if key=='_sfxVolume'then return gain(g)end
+ if key=='_suspended'then return not g or g.audioSuspended==true end
+end})
diff --git a/src/core/game3/bag.lua b/src/core/game3/bag.lua
new file mode 100644
index 000000000..233e3479d
--- /dev/null
+++ b/src/core/game3/bag.lua
@@ -0,0 +1,31 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Views=require('src.compat.gen1.SessionView')
+local Ids=require('src.compat.gen1.BattleIds')
+local Native=require('src.inventory.Bag')
+local B={}
+local function context(bag,id)
+  local game,save=Views.store(bag,'bag');if not game then return end
+  local key=Ids.new(game.data):native('items',id)
+  if key then return game,save,key end
+end
+function B.canAdd(bag,id,qty)
+  local g,s,key=context(bag,id)
+  return g~=nil and Native.canAdd(s,key,qty,g.data)or false
+end
+function B.add(bag,id,qty)
+  local g,s,key=context(bag,id);qty=qty or 1
+  if not(g and Native.canAdd(s,key,qty,g.data))then return false,0 end
+  local ok=Native.add(s,key,qty,g.data);return ok,ok and qty or 0
+end
+function B.has(bag,id,qty)
+  local g,s,key=context(bag,id)
+  return g~=nil and(s.inventory[key]or 0)>=(qty or 1)or false
+end
+function B.count(bag,id)local g,s,key=context(bag,id);return g and(s.inventory[key]or 0)or 0 end
+function B.remove(bag,id,qty)
+  local g,s,key=context(bag,id)
+  qty=qty or 1
+  if type(qty)~='number'or qty~=qty or qty%1~=0 or qty<1 or qty>999 or not g or not B.has(bag,id,qty)then return false end
+  Native.remove(s,key,qty or 1);return true
+end
+return B
diff --git a/src/core/game3/battle.lua b/src/core/game3/battle.lua
new file mode 100644
index 000000000..e764d357e
--- /dev/null
+++ b/src/core/game3/battle.lua
@@ -0,0 +1,207 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source battle presentation and observations, driven by the native owner.
+local Runtime=require('src.compat.gen1.BattleRuntime')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Scope=require('src.render.GraphicsScope')
+local M={}
+local runtime=Runtime.new()
+local function admitted(c)
+  if Runtime.member(c)then return true end
+  runtime:retire(c,false);return false
+end
+local captures=setmetatable({},{__mode='k'})
+local function serial()local renderer=package.loaded['src.render.Renderer'];return renderer and renderer.frameSerial end
+local function sameTarget(a,b,depth)
+  if a==b then return true end
+  if type(a)~='table'or type(b)~='table'or(depth or 0)>=4 then return false end
+  -- LOVE canvases are userdata; preserve identity for table-based test or
+  -- external wrappers too. Only the MRT binding description is structural.
+  if a.typeOf or b.typeOf or a.getDimensions or b.getDimensions or a.getWidth or b.getWidth then return false end
+  for k,v in pairs(a)do if not sameTarget(v,b[k],(depth or 0)+1)then return false end end
+  for k in pairs(b)do if a[k]==nil then return false end end
+  return true
+end
+local function target(value,depth)
+  if depth==nil then value=love.graphics.getCanvas();depth=0 end
+  if type(value)~='table'or value.typeOf or value.getDimensions or value.getWidth or depth>=4 then return value end
+  local out={};for k,v in pairs(value)do out[k]=target(v,depth+1)end;return out
+end
+M._renderTarget=target
+M._sameRenderTarget=sameTarget
+local function call(name,...)
+  local facade=require('src.core.Game3');local owner=facade._callbackOwner()
+  local seams=package.loaded['src.mods.ModSeams']
+  for i=#(seams and seams._journal or{}),1,-1 do
+    local change=seams._journal[i]
+    if change.tbl==M and change.key==name and change.after==M[name]then owner=change.owner;break end
+  end
+  return facade._withCallbackOwner(owner,M[name],...)
+end
+function M.isActive()return runtime:active()~=nil end
+function M.getState()local c=runtime:active();return c and c.views.view or runtime.last end
+function M.getResult()local view=M.getState();return view and view.result end
+function M.start(opts)
+  if Boundary.active('battle.start')then return Boundary.invoke('battle.start')end
+  return require('src.compat.gen1.BattleRequests').start(opts)
+end
+function M.songInfo(st)
+  st=st or M.getState();local kinds=st and st.kinds or{}
+  return{wild=st and st.wild or false,link=st and st.link or false,
+    trainerClass=st and st.trainerClass,trainerName=st and st.trainerName,frontier=kinds.frontier,
+    kind=kinds.kyogreGroudon and'kyogreGroudon'or kinds.regi and'regi'or nil}
+end
+function M.statWindowPhase()
+  local c=runtime:active();if not c then return false end
+  local class=c.screen.StatBox;if not class then return false end
+  for _,state in ipairs(c.stack.states)do
+    if getmetatable(state)==class then return true end
+  end
+  return false
+end
+function M.update()return Boundary.invoke('battle.update')end
+local function draw(value,w,h)
+  local c=runtime:active(value);if not c then return false,'no admitted native battle'end
+  local bw,bh=c.screen:uiSize();w,h=w or bw,h or bh
+  if w~=bw or h~=bh then return false,'battle capture must use the native surface size'end
+  if Boundary.active('battle.draw')then return Boundary.invoke('battle.draw')end
+  -- A capture can draw the native screen but cannot re-enter source wrappers.
+  return M._captureNative(c.screen)
+end
+M.draw=draw
+function M._captureNative(screen)
+  local c=runtime:active();if not c or c.screen~=screen then return false,'native battle admission retired'end
+  local ok,result=Scope.call(function()
+    return require('src.core.Game3')._withCallbackOwner(nil,screen._drawNative,screen)
+  end)
+  if not ok then error(result,0)end
+  if admitted(c)then captures[screen]={serial=serial(),target=target()}end
+  return true
+end
+function M.abort(result)
+  result=result or'run'
+  local c=runtime:active();if not c then return false,'no admitted native battle'end
+  if c.stack:top()~=c.screen then return false,'native battle is covered by another state'end
+  if c.aborting then return false,'native battle completion already requested'end
+  if result~='run'and result~='lose'and result~='win'and result~='caught'then
+    return false,'a native battle outcome is required'
+  end
+  -- Aborting cannot award a victory or catch that the native rules never made.
+  if result~='run'and c.screen.result~=result then return false,'outcome has not been decided by the native battle'end
+  if c.screen.kind=='link'then return false,'link termination belongs to the native peer protocol'end
+  c.views:flush();c.aborting=true;c.screen.result=result;c.screen:finish();return true
+end
+function M._nativeEnter(screen)
+  local c=runtime:bind(screen);if not c then return end
+  if c.notified then return end;c.notified=true
+  local st=c.views.view
+  return Boundary.dispatch('battle.start',function()return true end,function()
+    return call('start',{wild=st.wild,playerParty=st.playerParty,foe=st.enemy and st.enemy.mon,
+      trainerId=screen.trainer and screen.trainer.id})
+  end)
+end
+function M.reset()
+  if runtime:active()then return false,'cannot reset an admitted native battle'end
+  runtime:release();return true
+end
+function M._nativeUpdate(screen,dt,body)
+  captures[screen]=nil
+  local c=runtime:bind(screen);if not c then return body(screen,dt)end
+  if c.stack:top()~=screen then return false,'native battle is covered by another state'end
+  if Boundary.active('battle.update')then return Boundary.invoke('battle.update')end
+  return Boundary.dispatch('battle.update',function()
+    if not admitted(c)then return false,'native battle admission retired'end
+    if c.stack:top()~=screen then return false,'native battle is covered by another state'end
+    local function native(owner,step)
+      if not admitted(c)then return false,'native battle admission retired'end
+      if c.stack:top()~=screen then return false,'native battle is covered by another state'end
+      c.views:flush()
+      local intro=package.loaded['src.core.game3.battle.intro_seq']
+      if intro then
+        return require('src.core.Game3')._withCallbackOwner(nil,intro._nativeUpdate,owner,step,body)
+      end
+      return require('src.core.Game3')._withCallbackOwner(nil,body,owner,step)
+    end
+    local ui=package.loaded['src.core.game3.battle.ui']
+    if ui then return ui._nativeUpdate(screen,dt,native)end
+    return native(screen,dt)
+  end,function()
+    local anim=package.loaded['src.core.game3.battle.anim']
+    if anim then anim._nativeStep(screen,dt)end
+    if not admitted(c)or c.stack:top()~=screen then return false,'native battle admission retired'end
+    local result=call('update',dt,require('src.core.Game3').forNative(c.game))
+    if admitted(c)and c.stack:top()==screen then c.views:flush()end
+    return result
+  end)
+end
+function M._nativeDraw(screen,body)
+  local c=runtime:bind(screen);if not c then return body(screen)end
+  if screen.introBalls and screen.introBallsFrom==nil then screen.introBallsFrom=screen.frame or 0 end
+  if Boundary.active('battle.draw')then return Boundary.invoke('battle.draw')end
+  local capture=captures[screen];local frame=serial()
+  if capture and sameTarget(capture.target,target())and(capture.serial~=nil and capture.serial==frame or capture.serial==nil)then
+    if capture.serial==nil then captures[screen]=nil end;return true
+  end
+  local ui=package.loaded['src.core.game3.battle.ui']
+  local function guarded(owner)
+    if not admitted(c)then return false,'native battle admission retired'end
+    return require('src.core.Game3')._withCallbackOwner(nil,body,owner)
+  end
+  local function native()
+    if not admitted(c)then return false,'native battle admission retired'end
+    if ui then return ui._nativeDraw(screen,guarded)end
+    return guarded(screen)
+  end
+  if M.draw==draw then return native()end
+  local w,h=screen:uiSize()
+  local ok,result=Scope.call(function()
+    return Boundary.dispatch('battle.draw',native,function()
+      return call('draw',require('src.core.Game3').forNative(c.game),w,h)
+    end)
+  end)
+  if not ok then error(result,0)end
+  return result
+end
+function M._nativeField(screen,body)
+  local bg=package.loaded['src.core.game3.battle.bg']
+  if not bg then return body(screen)end
+  local c=runtime:bind(screen);if not c then return body(screen)end
+  return bg._nativeDraw(screen,function(owner)
+    if not admitted(c)then return false,'native battle admission retired'end
+    return require('src.core.Game3')._withCallbackOwner(nil,body,owner)
+  end)
+end
+function M._nativeExit(screen)
+  captures[screen]=nil
+  local anim=package.loaded['src.core.game3.battle.anim']
+  if anim then anim._nativeExit(screen)end
+  runtime:exit(screen)
+end
+-- Private typed consumers can resolve a source observation to the same native
+-- admission; callers cannot submit another state or a stale completed view.
+function M._flushNative(screen)
+  local c=runtime:active()
+  if not c or c.screen~=screen or c.stack:top()~=screen or not admitted(c)then return false end
+  c.views:flush();return true
+end
+function M._screen(view)
+  local c=runtime:active()
+  if c and(view==nil or view==c.views.view)then return c.screen end
+end
+local service={poll=function()runtime:poll()end,release=function()captures=setmetatable({},{__mode='k'});runtime:release()end,
+  releaseOwner=function(_,who)runtime:releaseOwner(who)end}
+M._service=service
+require('src.core.game3.asset_stream').register(service)
+setmetatable(M,{__index=function(_,key)
+  local c=runtime:active()
+  if key=='_active'then return c~=nil end
+  if key=='_st'then return c and c.views.view or runtime.last end
+  if not c then return nil end
+  if key=='_actions'or key=='_actionI'then
+    local plan=package.loaded['src.battle.Gen3ActionPlan']
+    if key=='_actionI'then return plan and plan.cursor(c.screen)or 0 end
+    return plan and plan.snapshot(c.screen,c)
+  end
+  if key=='_pendingEnd'then return c.screen.result end
+  if key=='_phase'then return c.screen.result and'ending'or c.screen.phase end
+end})
+return M
diff --git a/src/core/game3/battle/anim.lua b/src/core/game3/battle/anim.lua
new file mode 100644
index 000000000..0276161bc
--- /dev/null
+++ b/src/core/game3/battle/anim.lua
@@ -0,0 +1,301 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- One admitted native presentation owner. This is not a second battle VM;
+-- authored command/particle APIs are advertised only as they are integrated.
+local Battle=require('src.core.game3.battle')
+local Coords=require('src.core.game3.battle.anim_coords')
+local Clock=require('src.battle.PresentationClock')
+local Scope=require('src.render.GraphicsScope')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local Ids=require('src.compat.gen1.BattleIds')
+local A={Coords=Coords,ENEMY_MON={x=176,y=40},PLAYER_MON={x=72,y=80}}
+function A.stage()
+ return require('src.core.game3.battle.stage').current(require('src.compat.gen1.SourceCall').owner(A,'stage'))
+end
+function A.drawParticles(lo,hi)
+ return require('src.core.game3.battle.particle_pass').draw(lo,hi,require('src.compat.gen1.SourceCall').owner(A,'drawParticles'))
+end
+local current
+local numeric={ox=true,oy=true,alpha=true,scale=true,sx=true,sy=true,rotation=true,
+  darken=true,flash=true,displayHp=true,displayMaxHp=true,displayLevel=true,displayExp=true}
+local function retire()
+  if current then
+    local screen=current.screen[1]
+    if screen and current.clip and screen.gen3Anim==current.clip.player
+        and current.clip.serial==screen.gen3Anim.presentationSerial then
+      screen.gen3Anim:release();screen.gen3AnimPlaying=false
+    end
+    current.clip=nil
+    if current.effect then current.effect:release();current.effect=nil end
+    current.tasks={};current.onEnd=nil;current.users={};current.overrides={}
+    current.view=nil;current.screen[1]=nil
+  end
+  current=nil
+end
+local function context()
+  local screen=Battle._screen();local view=Battle.getState()
+  if not screen then retire();return end
+  if not current or current.screen[1]~=screen or current.view~=view then
+    retire()
+    current={screen=setmetatable({screen},{__mode='v'}),view=view,present={},overrides={},
+      tasks={},nextTask=0,users={},ids=Ids.new(screen.data)}
+  end
+  local facade=require('src.core.Game3');local owner=facade._callbackOwner()
+  local host=package.loaded['src.mods.Runtime'];owner=host and host.currentMod or owner
+  if owner then current.users[owner]=true end
+  return current,screen
+end
+local function battler(screen,id)
+  if id==0 then return screen.player elseif id==1 then return screen.enemy end
+  return screen:battlerAt(id)
+end
+local function number(v)return type(v)=='number'and v==v and v~=math.huge and v~=-math.huge end
+local function callback(fn,...)
+  if fn then return require('src.core.Game3')._withCallbackOwner(fn.owner,fn.call,...)end
+end
+local function owned(fn)
+  if fn==nil then return end
+  assert(type(fn)=='function','presentation callback must be a function')
+  local host=package.loaded['src.mods.Runtime']
+  return{call=fn,owner=host and host.currentMod or require('src.core.Game3')._callbackOwner()}
+end
+local function read(d,id,key)
+  local active,screen=context();if active~=d then return nil end
+  local b=battler(screen,id);if not b then return nil end
+  local p=d.overrides[id]
+  if p[key]~=nil then return p[key]end
+  if key=='id'then return id end
+  if key=='side'then return Coords.sideOf(id)end
+  if key=='visible'then return not b.fainted and not screen:fxHidden(b)and not screen:gen3AnimMonBgHidden(b)end
+  if key=='invisible'or key=='battlerInvisible'then return screen:gen3AnimMonBgHidden(b)end
+  if key=='ox'or key=='oy'then
+    local x,y=screen:gen3AnimShake(b);local fx=screen.picFx and screen.picFx[b]
+    return(key=='ox'and x+(fx and fx.ox or 0)or y+(fx and fx.oy or 0))
+  end
+  if key=='scale'then return screen:gen3AnimScale(b)or 1 end
+  if key=='sx'or key=='sy'then
+    local x,y=screen:gen3AnimSquash(b);return(key=='sx'and x or y)or 1
+  end
+  if key=='rotation'then return screen:gen3AnimRotate(b)or 0 end
+  if key=='alpha'then local fx=screen:gen3AnimSpecialMonState(b);return fx and fx.alpha or 1 end
+  if key=='hFlip'then return false end
+  if key=='darken'or key=='flash'then return 0 end
+  if key=='displayHp'then return b.shownHP or b.mon.hp end
+  if key=='displayMaxHp'then return b.mon.stats.hp end
+  if key=='displayLevel'then return b.mon.level end
+  if key=='displayStatus'then
+    -- Logical status may already describe a queued future event. The native
+    -- HUD owns the shown ailment; false is its explicit healthy sentinel.
+    local status=b.shownStatus
+    if not status then return false end
+    if status=='SLP'then return 1 end
+    return({PSN=8,BRN=16,FRZ=32,PAR=64,TOX=128})[status]or false
+  end
+  if key=='displayExp'then return screen:expFraction(b.mon)end
+end
+function A.idOf(key)
+  if key=='attacker_side'then
+    local _,screen=context();local anim=screen and screen.gen3Anim
+    return anim and anim.attackerPosition or 0
+  end
+  return Coords.idOf(key)
+end
+A.sideOf,A.isDouble,A.setDouble=Coords.sideOf,Coords.isDouble,Coords.setDouble
+A.coords,A.subpriority,A.bgPriorityRank=Coords.coords,Coords.subpriority,Coords.bgPriorityRank
+A.monDrawOrder,A.particleBand,A.battlerIds=Coords.monDrawOrder,Coords.particleBand,Coords.ids
+function A.x(value)
+  local _,screen=context();local anim=screen and screen.gen3Anim
+  value=tonumber(value)or 0
+  return anim and anim.attackerIsPlayer==false and -value or value
+end
+function A.present(key)
+  local d,screen=context();local id=A.idOf(key)
+  if not d or id==nil or id>=2 and not Coords.isDouble(d.view)or not battler(screen,id)then return nil end
+  if not d.present[id]then
+    d.overrides[id]={}
+    d.present[id]=setmetatable({},{__index=function(_,k)return read(d,id,k)end,
+      __newindex=function(_,k,v)
+        assert(context()==d,'native battle presentation retired')
+        assert(k~='id'and k~='side','native battler identity is read-only')
+        if v~=nil and(numeric[k]or type(v)=='number')then assert(number(v),'invalid presentation number')end
+        d.overrides[id][k]=v
+      end})
+  end
+  return d.present[id]
+end
+function A.battlerCenter(key)
+  local p=A.present(key);local base=Coords.coords(nil,A.idOf(key))
+  if not p or not base then return nil end
+  return base.x+(p.ox or 0),base.y+(p.oy or 0)
+end
+function A.shownBattler(key,fallback)local p=A.present(key);return p and p.shown or fallback end
+function A.setShown(key,value)local p=A.present(key);if p then p.shown=value;return true end;return false end
+function A.ballIdOf(key)
+  local d,screen=context();local id=A.idOf(key);local b=d and id and battler(screen,id)
+  if not b then return nil end
+  return require('src.battle.Gen3BallAnim').ballIndex(screen.data,b.mon.ball or'POKE_BALL',screen.data.items)
+end
+function A.displayHpRatio(key,fallback)
+  local p=A.present(key);local mon=fallback and fallback.mon
+  local hp=p and p.displayHp or mon and mon.hp or 0
+  local maximum=math.max(1,p and p.displayMaxHp or mon and mon.maxHp or 1)
+  return math.max(0,math.min(1,hp/maximum)),hp,maximum
+end
+function A.displayExpRatio(key,fallback)
+  local p=A.present(key or'player')
+  return p and p.displayExp or 0,p and p.displayLevel or fallback and fallback.mon and fallback.mon.level or 1
+end
+function A.hpTweening()
+  local _,screen=context();if not screen then return false end
+  for _,id in ipairs(Coords.ids())do
+    local b=battler(screen,id)
+    if b and b.shownHP and(b.shownHP~=b.mon.hp or b.draining or(b.drainHold or 0)>0)then return true end
+  end
+  return false
+end
+local function effect()
+  local d=context();if not d then return end
+  if not d.effect then d.effect=require('src.render.BattleScreenEffect').new()end
+  return d.effect
+end
+function A.setScreenEffect(opts)local e=effect();return e and e:set(opts)or false end
+function A.screenEffect()local e=effect();return e and e.value end
+function A.beginScreenEffect()local e=effect();return e and e:begin()or false end
+function A.endScreenEffect()local e=effect();return e and e:finish()or false end
+function A.busy()
+  local d,screen=context()
+  return d~=nil and(screen.gen3AnimPlaying==true or screen.gen3BallPlaying==true
+    or A.hpTweening()or screen.expFilling==true or next(d.tasks)~=nil)or false
+end
+function A.setSeqBusy(value)local d=context();if d then d.seqBusy=value==true end end
+function A.seqBusy()local d=context();return d and d.seqBusy==true or false end
+function A.tweenStage(frames,onStep,onComplete)
+  local d=context();if not d then return nil,'no admitted native battle'end
+  assert(number(frames)and frames>=0,'invalid presentation duration')
+  d.nextTask=d.nextTask+1
+  local task={id=d.nextTask,frames=0,total=math.max(1,math.ceil(frames)),step=owned(onStep),done=owned(onComplete)}
+  d.tasks[task.id]=task
+  return task
+end
+function A._nativeStep(screen,dt)
+  if not Clock.active(screen)then return false,'animation update belongs to its native battle phase'end
+  local d,actual=context();if actual~=screen or screen.game.stack:top()~=screen then return false end
+  return Clock.once(screen,'source.presentation',function()
+    local clip=d.clip
+    if clip then
+      if clip.player~=screen.gen3Anim or clip.serial~=screen.gen3Anim.presentationSerial then
+        d.clip,d.onEnd=nil,nil
+      elseif screen.gen3AnimPlaying then
+        require('src.core.Game3')._withCallbackOwner(nil,screen.updateMovePresentation,screen)
+      end
+    end
+    -- Snapshot the IDs: a callback may schedule another tween, which starts
+    -- next frame, or retire the admission, which cancels the remaining work.
+    local ids={};for id in pairs(d.tasks)do ids[#ids+1]=id end;table.sort(ids)
+    for _,id in ipairs(ids)do
+      if context()~=d or screen.game.stack:top()~=screen then return false end
+      local task=d.tasks[id]
+      if task then
+        task.frames=task.frames+1
+        callback(task.step,math.min(1,task.frames/task.total),task)
+        if context()~=d then return false end
+        if task.frames>=task.total then d.tasks[id]=nil;callback(task.done)end
+      end
+    end
+    if context()==d and screen.game.stack:top()==screen and d.onEnd and not screen.gen3AnimPlaying then
+      local done=d.onEnd;d.onEnd,d.clip=nil,nil;callback(done)
+    elseif context()==d and not screen.gen3AnimPlaying then d.clip=nil
+    end
+    return true
+  end)
+end
+function A._holdsNativeQueue(screen)
+  local d,actual=context();local clip=d and d.clip
+  return actual==screen and clip~=nil and clip.player==screen.gen3Anim
+    and clip.serial==screen.gen3Anim.presentationSerial and screen.gen3AnimPlaying==true
+end
+local publicUpdateStep='source.animation.public'
+local function update(dt)
+  if Boundary.active('battle.animation.update')then return Boundary.invoke('battle.animation.update')end
+  local _,screen=context()
+  if not screen or not Clock.active(screen)then return false,'animation update belongs to its native battle phase'end
+  if screen.game.stack:top()~=screen then return false,'native battle is covered by another state'end
+  return Clock.once(screen,publicUpdateStep,function()
+    A._nativeStep(screen,Clock.delta(screen))
+    if Battle._screen()~=screen or screen.game.stack:top()~=screen then return false,'native battle admission retired'end
+    -- Explicit source holds and the native body share the same display steps.
+    require('src.core.Game3')._withCallbackOwner(nil,screen.updatePresentation,screen,Clock.delta(screen))
+    return true
+  end)
+end
+A.update=update
+-- Native frames also notify decoration-only wrappers. If a source update
+-- already called its base, do not invoke the public wrapper a second time.
+-- A wrapper's base here borrows completed presentation work, never another
+-- native frame or command queue.
+function A._nativeAfterUpdate(screen)
+  if A.update==update or not Clock.active(screen)or Clock.called(screen,publicUpdateStep)then return end
+  local _,actual=context()
+  if actual~=screen or screen.game.stack:top()~=screen then return end
+  return Clock.once(screen,publicUpdateStep,function()
+    return Boundary.dispatch('battle.animation.update',function()
+      if Battle._screen()~=screen or screen.game.stack:top()~=screen then return false,'native battle admission retired'end
+      A._nativeStep(screen,Clock.delta(screen));return true
+    end,function()return Call.call(A,'update',Clock.delta(screen))end)
+  end)
+end
+function A.launchMove(moveId,opts)
+  opts=opts or{};local d,screen=context()
+  if not d then return false,'no admitted native battle'end
+  if screen.game.stack:top()~=screen then return false,'native battle is covered by another state'end
+  if screen.gen3AnimPlaying then return false,'native animation is already active'end
+  local native=d.ids:native('moves',moveId);local anim=screen.gen3Anim
+  if not native or not anim or not anim:has(native,opts)then return false,'no native animation record'end
+  if opts.miss then return false,'native miss presentation requires its authored command'end
+  local attacker=A.idOf(opts.attackerId or opts.attackerSide or'player')
+  local target=A.idOf(opts.targetId or opts.targetSide or'enemy')
+  if attacker==nil or target==nil or not battler(screen,attacker)or not battler(screen,target)then
+    return false,'animation requires admitted native battlers'
+  end
+  local done=owned(opts.onEnd)
+  if not require('src.core.Game3')._withCallbackOwner(nil,anim.start,anim,native,attacker%2==0,attacker,target,opts,screen)then return false end
+  screen.gen3AnimPlaying=true;d.onEnd=done;d.clip={player=anim,serial=anim.presentationSerial}
+  return true
+end
+function A.reset()
+  retire();Coords._service.release();return true
+end
+function A._nativeExit(screen)
+  if current and current.screen[1]==screen then A.reset()end
+end
+-- Applied around the existing native sprite draw, preserving its scanlines,
+-- tints, substitutes and affine effects. Only source overrides compose here;
+-- querying present() never feeds native effects back into themselves.
+function A._drawBattler(screen,b,body,...)
+  local d,actual=context();local id=b.position or(b.isPlayer and 0 or 1)
+  local p=d and actual==screen and d.overrides[id]
+  if not p or next(p)==nil then return body(screen,b,...)end
+  if p.visible==false or p.invisible or p.battlerInvisible or p.blinkHidden then return end
+  if not(p.hFlip or(p.ox or 0)~=0 or(p.oy or 0)~=0 or(p.rotation or 0)~=0
+      or(p.scale or 1)~=1 or(p.sx or 1)~=1 or(p.sy or 1)~=1 or(p.alpha or 1)~=1)then
+    return body(screen,b,...)
+  end
+  local args={...};local x,y,scale=args[1],args[2],args[3]or 1
+  local img=screen:battlerPic(b);local w,h=img:getDimensions()
+  local cx,cy=x+w*scale/2,y+h*scale/2
+  local ok,result=Scope.call(function()
+    local g=love.graphics
+    g.translate(cx+(p.ox or 0),cy+(p.oy or 0));g.rotate(p.rotation or 0)
+    g.scale((p.scale or 1)*(p.sx or 1)*(p.hFlip and -1 or 1),(p.scale or 1)*(p.sy or 1))
+    g.translate(-cx,-cy)
+    local r,green,blue,a=g.getColor();g.setColor(r,green,blue,a*(p.alpha or 1))
+    return body(screen,b,x,y,scale)
+  end)
+  if not ok then error(result,0)end
+  return result
+end
+A._service={release=A.reset,poll=function()context()end,releaseOwner=function(_,owner)
+  if current and current.users[owner]then A.reset()end
+end}
+require('src.core.game3.asset_stream').register(A._service)
+return A
diff --git a/src/core/game3/battle/anim_coords.lua b/src/core/game3/battle/anim_coords.lua
new file mode 100644
index 000000000..6f8611cf7
--- /dev/null
+++ b/src/core/game3/battle/anim_coords.lua
@@ -0,0 +1,131 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Authored 240x160 sprite anchors, separate from opaque image bounds. Imported
+-- cartridge coordinates override the standard anchors on the native owner.
+local Battle=require('src.core.game3.battle')
+local C={SINGLES={},DOUBLES={}}
+C.SUBPRIORITY={[0]=30,40,20,50}
+C.BG_PRIORITY_RANK={[0]=2,1,1,2}
+C.DRAW_ORDER_SINGLES={1,0}
+C.DRAW_ORDER_DOUBLES={3,1,0,2}
+C.battleState=Battle.getState
+local function point(x,y)return{x=x,y=y,[1]=x,[2]=y}end
+for id,p in pairs{[0]={72,80},{176,40},{48,40},{112,80}}do C.SINGLES[id]=point(p[1],p[2])end
+for id,p in pairs{[0]={32,80},{200,40},{90,88},{152,32}}do C.DOUBLES[id]=point(p[1],p[2])end
+local double,overrides,binding
+local users={}
+local function recordOwner()
+  local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+  local owner=host and host.currentMod or facade and facade._callbackOwner()
+  if owner then users[owner]=true end
+end
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+function C.sideOf(id)return type(id)=='number'and(id%2==0 and'player'or'enemy')or nil end
+function C.partner(id)return type(id)=='number'and(id+2)%4 or nil end
+function C.fixedId(key)
+  if type(key)=='number'and key==key and key>=0 and key<=3 then return math.floor(key)end
+  return({player=0,enemy=1})[key]
+end
+function C.idOf(key)
+  if type(key)=='table'then key=key.id or key.side end
+  if binding and binding[key]~=nil then return binding[key]end
+  return C.fixedId(key)
+end
+function C.bind(attacker,target)
+  recordOwner()
+  if attacker==nil then binding=nil;return end
+  attacker=C.fixedId(attacker);target=C.fixedId(target)
+  binding={}
+  if target then binding[C.sideOf(target)]=target end
+  if attacker then binding[C.sideOf(attacker)]=attacker end
+end
+function C.withBattler(key,fn,...)
+  local previous=binding;local id=C.idOf(key)
+  binding={player=previous and previous.player or 0,enemy=previous and previous.enemy or 1}
+  if id then binding[C.sideOf(id)]=id end
+  local result=pack(pcall(fn,C.sideOf(id),...));binding=previous
+  if not result[1]then error(result[2],0)end
+  return unpack(result,2,result.n)
+end
+function C.sideArg(fn,index)
+  index=index or 1
+  return function(...)
+    local args=pack(...);local id=C.idOf(args[index])
+    if type(args[index])~='number'or not id then return fn(...)end
+    return C.withBattler(id,function(side)
+      args[index]=side;return fn(unpack(args,1,args.n))
+    end)
+  end
+end
+function C.setDouble(value)recordOwner();if value==nil then double=nil else double=not not value end end
+function C.isDouble(st)
+  if double~=nil then return double end
+  st=st or Battle.getState();return st and st.double==true or false
+end
+function C.setCoordinateOverrides(value)recordOwner();local previous=overrides;overrides=value;return previous end
+function C.coords(st,key)
+  local id=C.idOf(key);if id==nil then return nil end
+  local p=overrides and overrides[id]
+  if p then return p end
+  local screen=Battle._screen(st)
+  local imported=screen and screen.data.constants.gen3BattlerCoords
+  local row=imported and(C.isDouble(st)and imported.doubles or imported.singles)
+  p=row and row[id+1]or(C.isDouble(st)and C.DOUBLES or C.SINGLES)[id]
+  return point(p.x or p[1],p.y or p[2])
+end
+function C.ids(st)return C.isDouble(st)and{0,1,2,3}or{0,1}end
+function C.battler(st,key)
+  st=st or Battle.getState();local id=C.idOf(key)
+  if not st or id==nil then return nil end
+  return st.battlers and st.battlers[id]or(id==0 and st.player or id==1 and st.enemy or nil)
+end
+function C.spritePresent(st,key)
+  local id=C.idOf(key);if id==nil or id>=2 and not C.isDouble(st)then return false end
+  local b=C.battler(st,id)
+  if not st then st=Battle.getState()end
+  if st and st.absent and st.absent[id]then return false end
+  return b==nil and id<2 or b~=nil and not b.absent and not b.fainted and(b.mon==nil or(b.mon.hp or 0)>0)
+end
+function C.subpriority(key)return C.SUBPRIORITY[C.idOf(key)]or 40 end
+function C.bgPriorityRank(key)return C.BG_PRIORITY_RANK[C.idOf(key)]or 1 end
+function C.monDrawOrder(st)return C.isDouble(st)and{3,1,0,2}or{1,0}end
+function C.monBehindZ(key,st)
+  local id=C.idOf(key)
+  for i,slot in ipairs(C.monDrawOrder(st))do if slot==id then return(i-1)*100+95 end end
+  return 95
+end
+function C.particleBand(k,st)
+  k=tonumber(k)or 0
+  if k<=0 then return 0,99 end
+  return k*100+1,k>=#C.monDrawOrder(st)and 999 or k*100+99
+end
+function C.layerZ(sub,monbg,bgPriority,st)
+  sub=tonumber(sub)or 0
+  local order=C.monDrawOrder(st);local band=0
+  for i=#order,1,-1 do
+    local id=order[i]
+    local front
+    if monbg and rawget(monbg,id)then front=((bgPriority and bgPriority[C.bgPriorityRank(id)])or 2)>=2
+    else front=sub<C.subpriority(id)end
+    if front then band=i;break end
+  end
+  local rank=math.max(0,math.min(98,98-sub))
+  return band==0 and rank or band*100+1+rank
+end
+function C.zFor(priority,sub,vm,st)
+  priority,sub=priority or 2,sub or 0
+  if priority<=1 then return 900+(255-sub)%99 end
+  if priority>=3 then return math.max(1,math.min(98,98-sub))end
+  return C.layerZ(sub,vm and vm._monbg,vm and vm._bgPrio,st)
+end
+function C.idTable(values)
+  local result=setmetatable({},{__index=function(t,k)local id=C.idOf(k);if id~=nil then return rawget(t,id)end end,
+    __newindex=function(t,k,v)local id=C.idOf(k);rawset(t,id~=nil and id or k,v)end})
+  for k,v in pairs(values or{})do result[k]=v end
+  return result
+end
+C._service={release=function()double,overrides,binding=nil,nil,nil;users={}end}
+C._service.poll=function()if not Battle.isActive()then C._service.release()end end
+C._service.releaseOwner=function(_,owner)if users[owner]then C._service.release()end end
+require('src.core.game3.asset_stream').register(C._service)
+return C
diff --git a/src/core/game3/battle/anim_pal.lua b/src/core/game3/battle/anim_pal.lua
new file mode 100644
index 000000000..4e34adece
--- /dev/null
+++ b/src/core/game3/battle/anim_pal.lua
@@ -0,0 +1,48 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Packed palette arithmetic and a real native indexed shader. Animation
+-- buffers/commands remain native contracts; no substitute VM or clock here.
+local Core=require('src.render.Gen3IndexedPalette')
+local bank=Core.new({cutout=true,paletteAlpha=true})
+local M={rgb=Core.rgb,pack=Core.pack,blend5=Core.blend5,blendColor=Core.blendColor,gray5=Core.gray5}
+local owners,rgba,resolved={},{},{}
+for i=1,16 do rgba[i]={0,0,0,0}end
+local function own()
+ local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+ local who=type(host)=='table'and host.currentMod
+  or type(facade)=='table'and type(facade._callbackOwner)=='function'and facade._callbackOwner()or'engine'
+ owners[who]=true
+end
+local function channel(n)return math.max(0,math.min(31,math.floor(n+.5)))end
+function M.shader()own();return bank:shader()end
+function M.resolve(colours,opts,out)
+ opts=opts or{};out=out or{}
+ local tr,tg,tb=Core.rgb(opts.color)
+ for i=0,15 do
+  local r,g,b=Core.rgb(colours and colours[i])
+  if (tonumber(opts.coeff)or 0)>0 then r,g,b=Core.blend5(r,g,b,opts.coeff,tr,tg,tb)end
+  local a=opts.affine
+  if a then
+   if a.m>=0 and 1-a.m>.0001 then
+    local k=1-a.m
+    r,g,b=Core.blend5(r,g,b,math.floor(k*16+.5),channel(a.r/k*31),channel(a.g/k*31),channel(a.b/k*31))
+   elseif a.m<0 then
+    r,g,b=channel(r*a.m+a.r*31),channel(g*a.m+a.g*31),channel(b*a.m+a.b*31)
+   end
+  end
+  if opts.gray then r,g,b=Core.gray5(r,g,b)end
+  out[i]=Core.pack(r,g,b)
+ end
+ return out
+end
+function M.send(colours,opts)
+ own();opts=opts or{};M.resolve(colours,opts,resolved)
+ for i=0,15 do
+  local r,g,b=Core.rgb(M.blackPass and 0 or resolved[i]);local c=rgba[i+1]
+  c[1],c[2],c[3],c[4]=r/31,g/31,b/31,(i==0 and not opts.opaque0)and 0 or 1
+ end
+ return bank:sendNormalized(rgba)
+end
+local service={release=function()owners={};bank:release()end,
+ releaseOwner=function(_,who)owners[who]=nil;if not next(owners)then bank:release()end end}
+M._service=service;require('src.core.game3.asset_stream').register(service)
+return M
diff --git a/src/core/game3/battle/anim_seq.lua b/src/core/game3/battle/anim_seq.lua
new file mode 100644
index 000000000..fea506100
--- /dev/null
+++ b/src/core/game3/battle/anim_seq.lua
@@ -0,0 +1,144 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Presentation filtering over the rows actually produced by one native action.
+-- Gameplay rows, clocks and executable callbacks remain in the native queue.
+local Battle=require('src.core.game3.battle')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local CoroutineScopes=require('src.compat.gen1.CoroutineScopes')
+local Scopes=CoroutineScopes.new()
+local Call=require('src.compat.gen1.SourceCall')
+local Iteration=require('src.compat.gen1.TableIteration')
+local M={}
+local tags=setmetatable({},{__mode='k'})
+local unpack=table.unpack or unpack
+local function pack(...)return {n=select('#',...),...}end
+local function shallow(t)local out={};for k,v in pairs(t)do out[k]=v end;return out end
+local function same(a,b)
+ for k,v in pairs(a)do if b[k]~=v then return false end end
+ for k,v in pairs(b)do if a[k]~=v then return false end end
+ return true
+end
+local function valid(token)
+ if token.retired then return false end
+ if token.phase and token.phase.closed then token.retired=true;return false end
+ if Battle._screen(token.view)~=token.screen or token.screen.queue~=token.queue
+  or token.screen.game.stack:top()~=token.screen then token.retired=true;return false end
+ local positions={}
+ for index,row in ipairs(token.queue)do
+  if positions[row]then token.retired=true;return false end
+  positions[row]=index
+ end
+ local previous=0
+ for i,row in ipairs(token.rows)do
+  local index=positions[row]
+  if not index or index<=previous or not same(row,token.signatures[i])then token.retired=true;return false end
+  previous=index
+ end
+ return true
+end
+local function facts(_,view)
+ local out={};for _,key in ipairs{'kind','id','move','attackerId','targetId','text','type'}do out[key]=view[key]end
+ return out
+end
+local function event(token,row,tag)
+ local spec={kind='native'}
+ for _,kind in ipairs{'fn','ui','drain','anim','text','wait','sound','exp'}do
+  if row[kind]~=nil then spec.type=kind;break end
+ end
+ if tag=='used'then spec.kind,spec.id,spec.text='msg','_ItemUseText001',row.text
+ elseif tag=='move'then
+  spec.kind,spec.move,spec.attackerId,spec.targetId='move',row.anim,row.attackerPosition,row.targetPosition
+ end
+ local refs=setmetatable({token},{__mode='v'})
+ local view=setmetatable({},{__index=function(_,key)
+  local current=refs[1];if current and valid(current)then return spec[key]end
+ end,__newindex=function()error('native animation event is read-only',2)end,
+ __metatable='native animation event'})
+ Iteration.register(view,facts)
+ return view
+end
+-- Called only at the actual native row constructors. No text matching.
+function M._nativeMessage(row)tags[row]='used'end
+function M._nativeMove(row)tags[row]='move'end
+function M.isMoveUsedId(id)return id=='_ItemUseText001'end
+local function request(token,meta)
+ assert(valid(token),'native animation admission retired')
+ assert(type(meta)=='table'and type(meta.events)=='table','native animation events required')
+ local keep,previous,count={},0,0
+ for key,value in pairs(meta.events)do
+  assert(type(key)=='number'and key%1==0 and key>=1 and key<=#meta.events,'native animation events must be dense')
+  count=count+1
+ end
+ assert(count==#meta.events,'native animation events must be dense')
+ for _,value in ipairs(meta.events)do
+  local index=token.byEvent[value]
+  assert(index and index>previous,'native animation event identity/order changed')
+  previous=index;keep[index]=true
+ end
+ local drop={}
+ for index,row in ipairs(token.rows)do
+  if not keep[index]then
+   assert(token.removable[index],'native gameplay/presentation row cannot be removed')
+   drop[row]=true
+  end
+ end
+ return drop
+end
+function M.begin(meta)
+ local phase=Scopes:find('sequence')
+ if not phase then return false,'animation begin belongs to its native action'end
+ if not phase.called then phase.drop=request(phase.value,meta);phase.called=true end
+ return Boundary.invoke('battle.anim.begin')
+end
+function M._nativeAction(screen,row,body)
+ -- This boundary observes the same native callback once. Outside a live
+ -- source admission there is no presentation permission to lend.
+ local view=Battle.getState()
+ if Battle._screen(view)~=screen then return body()end
+ local queue=screen.queue;local before={}
+ for _,entry in ipairs(queue)do before[entry]=true end
+ local result=pack(body())
+ if Battle._screen(view)~=screen or screen.queue~=queue then return unpack(result,1,result.n)end
+ local token={screen=screen,view=view,queue=queue,rows={},events={},signatures={},removable={},byEvent={}}
+ for _,entry in ipairs(queue)do if not before[entry]then
+  local index=#token.rows+1;token.rows[index]=entry;token.signatures[index]=shallow(entry)
+  local tag=tags[entry]
+  -- A tagged row acquiring any executable/gameplay payload loses its
+  -- removal permission, even if another mod retains its original text.
+  local removable=false
+  if tag=='used'then
+   removable=type(entry.text)=='string';for key in pairs(entry)do if key~='text'then removable=false end end
+  elseif tag=='move'then
+   removable=type(entry.anim)=='string'or type(entry.anim)=='number'
+   local allowed={anim=true,attackerIsPlayer=true,attackerPosition=true,targetPosition=true,animContext=true,hit=true}
+   for key in pairs(entry)do if not allowed[key]then removable=false end end
+   if entry.hit then
+    if type(entry.hit)~='table'then removable=false
+    else for key in pairs(entry.hit)do if key~='sfx'and key~='animType'and key~='blink'then removable=false end end end
+   end
+  end
+  token.removable[index]=removable==true
+  local value=event(token,entry,removable and tag or nil);token.events[index]=value;token.byEvent[value]=index
+ end end
+ if #token.rows==0 then token.retired=true;return unpack(result,1,result.n)end
+ local phase=Scopes:push('sequence',token);token.phase=phase
+ local ok,why=pcall(function()
+  return Boundary.dispatch('battle.anim.begin',function()
+   assert(valid(token),'native animation admission retired');return true
+  end,function()return Call.call(M,'begin',{events=shallow(token.events)})end)
+ end)
+ -- Commit only after every decorator returns successfully. A throwing
+ -- wrapper cannot partly filter the native presentation or replay combat.
+ local expired=phase.closed or CoroutineScopes.retired()
+ if ok and not expired and phase.called and valid(token)then
+  for i=#queue,1,-1 do if phase.drop[queue[i]]then
+   if screen.moveAnimRow==queue[i]then screen.moveAnimRow=nil end
+   table.remove(queue,i)
+   if screen.nextInsert and i<=screen.nextInsert then screen.nextInsert=screen.nextInsert-1 end
+  end end
+ end
+ token.retired=true;Scopes:close(phase)
+ if not ok then error(why,0)end
+ if expired then error('native animation phase retired while suspended',0)end
+ return unpack(result,1,result.n)
+end
+return M
diff --git a/src/core/game3/battle/anim_sprites.lua b/src/core/game3/battle/anim_sprites.lua
new file mode 100644
index 000000000..93a679341
--- /dev/null
+++ b/src/core/game3/battle/anim_sprites.lua
@@ -0,0 +1,86 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native event observations and reversible drawing transforms. There is no
+-- sprite scheduler here: event life, OAM order and animation clocks stay native.
+local Battle=require('src.core.game3.battle')
+local Scope=require('src.render.GraphicsScope')
+local Native=require('src.battle.Gen3Battle')
+local S={}
+local current
+local interested=false
+local function retire()
+ if current then for _,row in ipairs(current.pool)do row.active=false;row.customDraw=nil end end
+ current=nil
+end
+local function context()
+ local screen=Battle._screen();local anim=screen and screen.gen3AnimPlaying and screen.gen3Anim
+ if not(anim and anim.events)then retire();return end
+ if not current or current.screen~=screen or current.anim~=anim or current.serial~=anim.presentationSerial then
+  retire();current={screen=screen,anim=anim,serial=anim.presentationSerial,pool={},entries={},users={}}
+ end
+ local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+ local who=host and host.currentMod or facade and facade._callbackOwner();if who then current.users[who]=true end
+ return current
+end
+local function sample(c)
+ if c.sampled and c.frame==c.anim.frame then return c.pool end
+ c.frame=c.anim.frame;c.sampled=true
+ local seen,out={},{}
+ for _,event in ipairs(c.anim.events)do
+  local pose=c.anim:eventPose(event,c.screen,Native)
+  if pose then
+   local row=c.entries[event]or{};c.entries[event]=row;seen[event]=true
+   local key=c.anim:eventPriorityKey(event,c.screen)
+   local x,y=pose.centreX+(pose.dx or 0),pose.centreY+(pose.dy or 0)
+   row.active,row.visible,row.invisible=true,true,pose.callbackState and pose.callbackState.invisible or false
+   row.x,row.y,row.ox,row.oy=x,y,0,0;row.scaleX,row.scaleY,row.rotation=1,1,0
+   row.alpha,row.age,row.tag,row.template=1,pose.age,event.sheet,event.template
+   row.subpriority=key and key%256;row.priority=key and math.floor(key/256)
+   row.hostId=event.target and c.anim.targetPosition or c.anim.attackerPosition
+   row.image=pose.sheet.image;row.customDraw=nil
+   row._nativeX,row._nativeY=x,y
+   out[#out+1]=row
+  end
+ end
+ for event,row in pairs(c.entries)do if not seen[event]then row.active=false;row.customDraw=nil;c.entries[event]=nil end end
+ -- Keep the pool identity stable for the native clip; removed rows retire.
+ for i,row in ipairs(out)do c.pool[i]=row end
+ for i=#out+1,#c.pool do c.pool[i]=nil end
+ return c.pool
+end
+function S.pool()
+ interested=true
+ local c=context();if not c then return{}end
+ return sample(c)
+end
+function S.activeCount()return#S.pool()end
+function S.forEachActive(fn)
+ assert(type(fn)=='function','particle observer required')
+ for _,row in ipairs(S.pool())do fn(row)end
+end
+local function finite(n)return type(n)=='number'and n==n and math.abs(n)<math.huge end
+function S._drawEvent(anim,event,screen,body,...)
+ if not interested then return body(...)end
+ local c=context()
+ if not c or c.screen~=screen or c.anim~=anim then return body(...)end
+ sample(c);local row=c.entries[event];if not row then return body(...)end
+ if row.active==false or row.visible==false or row.invisible then return true end
+ local x,y=row.x+(row.ox or 0),row.y+(row.oy or 0)
+ local sx,sy,rotation=row.scaleX or 1,row.scaleY or 1,row.rotation or 0
+ assert(finite(x)and finite(y)and finite(sx)and finite(sy)and finite(rotation),'invalid particle presentation transform')
+ local args={n=select('#',...),...}
+ if not row.customDraw and x==row._nativeX and y==row._nativeY and sx==1 and sy==1 and rotation==0 then return body((table.unpack or unpack)(args,1,args.n))end
+ local ok,result=Scope.call(function()
+  local g=love.graphics;g.translate(x,y);g.rotate(rotation);g.scale(sx,sy);g.translate(-row._nativeX,-row._nativeY)
+  if row.customDraw then return row.customDraw(row)end
+  return body((table.unpack or unpack)(args,1,args.n))
+ end)
+ if not ok then error(result,0)end
+ return result
+end
+local function release()retire();interested=false end
+local service={release=release,poll=function()if current then context()end end,
+ releaseOwner=function(_,who)if current and current.users[who]then release()end end}
+S._service=service
+require('src.core.game3.asset_stream').register(service)
+setmetatable(S,{__index=function(_,key)if key=='_pool'then return S.pool()end end})
+return S
diff --git a/src/core/game3/battle/ball_open.lua b/src/core/game3/battle/ball_open.lua
new file mode 100644
index 000000000..97d3666c9
--- /dev/null
+++ b/src/core/game3/battle/ball_open.lua
@@ -0,0 +1,91 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Borrow the native ball painter/timeline; source artwork has its own shader.
+local Battle=require('src.core.game3.battle')
+local Coords=require('src.core.game3.battle.anim_coords')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local Scope=require('src.render.GraphicsScope')
+local M={}
+local shader,users
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function finite(n)return type(n)=='number'and n==n and math.abs(n)<math.huge end
+local function release()
+ if shader then shader:release();shader=nil end
+ users={}
+end
+release()
+function M.ballIdForItem(value)
+ local game=require('src.compat.gen1.NativeSession').game()
+ if not(game and game.data)then return nil end
+ local data=game.data
+ local key=require('src.compat.gen1.BattleIds').new(data):native('items',value)
+ local item=key and data.items[key]
+ local record=require('src.battle.Gen3BallAnim').record(data)
+ return item and record and record.itemToBall and record.itemToBall[item.index]or nil
+end
+function M.monBlend(side)
+ local screen=Battle._screen();local id=Coords.idOf(side)
+ local battler=screen and id and(id==0 and screen.player or id==1 and screen.enemy or screen:battlerAt(id))
+ local anim=battler and screen:gen3BallFor(battler)
+ if not anim then return 0 end
+ local color=anim:colour()
+ return (anim.monBlend or 0)*16,color[1]*31/255,color[2]*31/255,color[3]*31/255
+end
+function M.bgCoeff()
+ local screen=Battle._screen()
+ local anim=screen and screen.gen3AnimPlaying and screen.gen3Anim
+ if anim and anim.flashState then return (anim:flashState()or 0)*16 end
+ return 0
+end
+function M.setBlendShader(coeff,r,g,b)
+ if coeff==nil then return false end
+ assert(finite(coeff),'invalid native palette blend coefficient')
+ if coeff<=0 then return false end
+ assert(finite(r)and finite(g)and finite(b),'invalid native palette blend color')
+ if not shader then
+  shader=love.graphics.newShader([[
+extern vec4 nativePaletteBlend;
+vec4 effect(vec4 color, Image tex, vec2 uv, vec2 screen) {
+ vec4 pixel=Texel(tex,uv);
+ vec3 source=floor(clamp(pixel.rgb,0.0,1.0)*31.0+0.5);
+ vec3 mixed=source+floor((nativePaletteBlend.rgb-source)*nativePaletteBlend.a/16.0);
+ return vec4(mixed/31.0,pixel.a)*color;
+}
+]])
+ end
+ local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+ local owner=host and host.currentMod or facade and facade._callbackOwner()or'engine'
+ users[owner]=true
+ local function channel(v)return math.max(0,math.min(31,math.floor(v+.5)))end
+ shader:send('nativePaletteBlend',{channel(r),channel(g),channel(b),math.max(0,math.min(16,coeff))})
+ love.graphics.setShader(shader)
+ return true
+end
+local function draw()
+ if Boundary.active('battle.ball.draw')then return Boundary.invoke('battle.ball.draw')end
+ local screen=Battle._screen();if not screen then return false,'no admitted native battle'end
+ return require('src.battle.Gen3Battle').drawBall(screen)
+end
+M.draw=draw
+function M._nativeDraw(screen,body)
+ if M.draw==draw then return body(screen)end
+ if Battle._screen()~=screen then return body(screen)end
+ if Boundary.active('battle.ball.draw')then return Boundary.invoke('battle.ball.draw')end
+ local stack=screen.game.stack;local top=stack:top()
+ local result=pack(Scope.call(function()
+  return Boundary.dispatch('battle.ball.draw',function()
+   if Battle._screen()~=screen or screen.game.stack~=stack or stack:top()~=top then
+    return false,'native ball presentation admission changed'
+   end
+   return body(screen)
+  end,function()return Call.call(M,'draw')end)
+ end))
+ if not result[1]then error(result[2],0)end
+ return unpack(result,2,result.n)
+end
+M._service={release=release,releaseOwner=function(_,owner)
+ users[owner]=nil;if not next(users)then release()end
+end}
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/core/game3/battle/bg.lua b/src/core/game3/battle/bg.lua
new file mode 100644
index 000000000..9cd7a851c
--- /dev/null
+++ b/src/core/game3/battle/bg.lua
@@ -0,0 +1,25 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- The background hook consumes only the native field pass, never its HUD.
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Scope=require('src.render.GraphicsScope')
+local B={}
+local function draw()return Boundary.invoke('battle.background')end
+B.draw=draw
+function B._nativeDraw(screen,body)
+  if B.draw==draw then return body(screen)end
+  if Boundary.active('battle.background')then return Boundary.invoke('battle.background')end
+  local ok,result=Scope.call(function()
+    return Boundary.dispatch('battle.background',function()return body(screen)end,function()
+      local facade=require('src.core.Game3');local who=facade._callbackOwner()
+      local seams=package.loaded['src.mods.ModSeams']
+      for i=#(seams and seams._journal or{}),1,-1 do
+        local change=seams._journal[i]
+        if change.tbl==B and change.key=='draw'and change.after==B.draw then who=change.owner;break end
+      end
+      return facade._withCallbackOwner(who,B.draw,screen.gen3TerrainId or screen.terrainId,0,0,0)
+    end)
+  end)
+  if not ok then error(result,0)end
+  return result
+end
+return B
diff --git a/src/core/game3/battle/damage.lua b/src/core/game3/battle/damage.lua
new file mode 100644
index 000000000..d8db859e6
--- /dev/null
+++ b/src/core/game3/battle/damage.lua
@@ -0,0 +1,46 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Detached field skirmishes and native battles use the same damage rules.
+local Source=require('src.compat.gen1.SourcePokemon')
+local Ids=require('src.compat.gen1.BattleIds')
+local Native=require('src.battle.Damage')
+local D={}
+function D.ensureStats(mon,level)
+ if level and not mon.level then mon.level=level end
+ Source.ensure(mon);return mon
+end
+local function battler(value,g,ids)
+ local mon,owner=Source.resolve(value.mon or value)
+ assert(owner==g,'foreign Pokemon dataset')
+ local def=g.data.pokemon[mon.species]
+ local types={}
+ if value.type1~=nil then types[1]=assert(ids:native('types',value.type1),'unknown cartridge type')end
+ if value.type2~=nil then types[2]=assert(ids:native('types',value.type2),'unknown cartridge type')end
+ if #types==0 then for i,t in ipairs(def.types or{})do types[i]=t end end
+ local stages={}
+ for k,v in pairs(value.stages or{})do stages[({spAtk='spatk',spDef='spdef'})[k]or k]=v end
+ local b={mon=mon,def=def,species=mon.species,curStats=mon.stats,curTypes=types,curMoves=mon.moves,
+  stages=stages,items=g.data.items,natures=g.data.constants.natures,statuses=g.data.statuses}
+ if value.ability~=nil then b.abilityOverride=ids:native('abilities',value.ability)or false end
+ return b
+end
+function D.calc(attacker,defender,moveId,opts)
+ opts=opts or{}
+ local _,g=Source.resolve(attacker.mon or attacker);local ids=Ids.new(g.data)
+ local key=assert(ids:native('moves',moveId),'unknown cartridge move')
+ local move={};for k,v in pairs(g.data.moves[key])do move[k]=v end;move.id=key
+ if opts.power~=nil then assert(type(opts.power)=='number'and opts.power>=0,'invalid move power');move.power=opts.power end
+ if opts.moveType~=nil then move.type=assert(ids:native('types',opts.moveType),'unknown cartridge move type')end
+ local Defaults=require('src.battle.RulesetDefaults');local rulesets=g.data.rulesets or require('src.battle.Rulesets')
+ local selected=g.save.options and g.save.options.ruleset
+ local rules=rulesets[selected]or rulesets[Defaults.defaultFor(g)]
+ assert(rules,'native ruleset unavailable')
+ local critical=opts.forceCrit;if opts.noCrit then critical=false end
+ local damage,info=Native.compute(rules,battler(attacker,g,ids),battler(defender,g,ids),move,
+  {rng=opts.rng,forceCrit=critical,weather=opts.weather,data=g.data})
+ if opts.multiplier then assert(type(opts.multiplier)=='number'and opts.multiplier>=0,'invalid damage multiplier');damage=math.floor(damage*opts.multiplier)end
+ return damage,{move=require('src.core.game3.battle.moves').get(moveId),effectiveness=info.typeMult/10,
+  critical=info.crit,status=move.power==0 or move.category=='status'or move.class=='status',
+  physical=(move.category or move.class or require('src.battle.TypeChart').category(move.type))=='physical',
+  ability=info.ability,missed=info.missed}
+end
+return D
diff --git a/src/core/game3/battle/effect_ids.lua b/src/core/game3/battle/effect_ids.lua
new file mode 100644
index 000000000..0218a8444
--- /dev/null
+++ b/src/core/game3/battle/effect_ids.lua
@@ -0,0 +1,3 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source consumers may decorate their snapshot without changing native IDs.
+return require('src.battle.Gen3EffectCatalog').snapshot()
diff --git a/src/core/game3/battle/experience.lua b/src/core/game3/battle/experience.lua
new file mode 100644
index 000000000..3f1ac1911
--- /dev/null
+++ b/src/core/game3/battle/experience.lua
@@ -0,0 +1,57 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Source=require('src.compat.gen1.SourcePokemon')
+local Growth=require('src.pokemon.Growth')
+local Awards=require('src.battle.Experience')
+local E={MAX_LEVEL=100}
+local function definition(value)
+ local g=Native.game();if not g then return end
+ local id=type(value)=='table'and value.species or value
+ local key=Ids.new(g.data):native('pokemon',id)
+ return key and g.data.pokemon[key],g
+end
+function E.expYield(value)local d=definition(value);return d and d.baseExp or 0 end
+function E.growthRate(value)local d=definition(value);return d and d.growthRate end
+function E.expForLevel(value,level)
+ local d,g=definition(value);local rate=d and d.growthRate or value
+ return Growth.expForLevel(rate,level,g and g.data.growth_rates)
+end
+function E.levelForExp(value,exp)
+ local d,g=definition(value);return Growth.levelForExp(d and d.growthRate or value,exp,100,g and g.data.growth_rates)
+end
+function E.gainFor(species,level,opts)
+ opts=opts or{};local d,g=definition(species);if not d then return 0 end
+ local n=Awards.gainFor(d,level,false,opts.participants,false,g.data.constants)
+ local tune=g.data.constants.exp or{}
+ for _,mult in ipairs{opts.luckyEgg and 1.5 or 1,opts.trainer and(tune.trainerMult or 1.5)or 1,opts.traded and(tune.tradedMult or 1.5)or 1}do n=math.floor(n*mult)end
+ return math.max(1,n)
+end
+function E.apply(value,amount)
+ local mon,g,commit=Source.resolve(value)
+ assert(type(amount)=='number'and amount==amount and math.abs(amount)<math.huge,'invalid experience award')
+ amount=math.max(0,math.floor(amount))
+ local d=g.data.pokemon[mon.species];local cap=math.min(100,g.data.constants.levelCap or 100)
+ local function threshold(level)return Growth.expForLevel(d.growthRate,level,g.data.growth_rates)end
+ local start=threshold(mon.level);local nextLevel=threshold(math.min(cap,mon.level+1))
+ if not mon.exp or mon.exp<start or mon.level<cap and mon.exp>=nextLevel then mon.exp=start end
+ local result={gained=0,rawGained=amount,fromLevel=mon.level,toLevel=mon.level,fromExp=mon.exp,toExp=mon.exp,levels={},steps={}}
+ local target=mon.level>=cap and mon.exp or math.min(threshold(cap),mon.exp+amount)
+ while mon.exp<target do
+  local level,from=mon.level,mon.exp
+  local base=threshold(level);local roof=threshold(math.min(level+1,cap));local to=math.min(target,roof)
+  local old={};for k,v in pairs(mon.stats)do old[k]=v end
+  local levels=Awards.add(g.data,mon,to-from)
+  local step={level=level,fromRatio=(from-base)/math.max(1,roof-base),toRatio=(to-base)/math.max(1,roof-base)}
+  if #levels>0 then
+   step.grewTo=mon.level;step.hp=mon.hp;step.maxHp=mon.stats.hp
+   step.oldStats={maxHp=old.hp,atk=old.attack,def=old.defense,spa=old.spatk,spd=old.spdef,spe=old.speed}
+   local s=mon.stats;step.newStats={maxHp=s.hp,atk=s.attack,def=s.defense,spa=s.spatk,spd=s.spdef,spe=s.speed}
+   for _,n in ipairs(levels)do result.levels[#result.levels+1]=n end
+  end
+  result.steps[#result.steps+1]=step
+ end
+ result.toExp,result.toLevel=mon.exp,mon.level;result.gained=mon.exp-result.fromExp
+ commit();return result
+end
+return E
diff --git a/src/core/game3/battle/healthbox.lua b/src/core/game3/battle/healthbox.lua
new file mode 100644
index 000000000..0a3e38775
--- /dev/null
+++ b/src/core/game3/battle/healthbox.lua
@@ -0,0 +1,68 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source healthboxes use native shown state and the existing imported painter.
+local Battle=require('src.core.game3.battle')
+local Coords=require('src.core.game3.battle.anim_coords')
+local Native=require('src.battle.Gen3Battle')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Scope=require('src.render.GraphicsScope')
+local H={}
+local scopes={}
+local function resident(st,key,view)
+ local screen=Battle._screen(st);if not screen then return end
+ local id=Coords.idOf(key);if id==nil then return end
+ local observed=Coords.battler(Battle.getState(),id)
+ if view~=nil and view~=observed then return end
+ local native;if id==0 then native=screen.player elseif id==1 then native=screen.enemy else native=screen:battlerAt(id)end
+ return screen,native,id,observed
+end
+function H.center(st,id)
+ local screen,b=resident(st,id);if not b then return nil end
+ local x,y,h=Native.healthboxGeometry(screen,Coords.idOf(id));if not x then return nil end
+ return{x=x+32,y=y+math.floor(h/2),x+32,y+math.floor(h/2)}
+end
+local function paint(screen,b,id,opts)
+ local x,y=Native.healthboxGeometry(screen,id);if not x then return false end
+ opts=opts or{}
+ for _,key in ipairs{'ox','oy'}do
+  local n=opts[key];assert(n==nil or type(n)=='number'and n==n and math.abs(n)<math.huge,'invalid healthbox offset')
+ end
+ x,y=x+(opts.ox or 0),y+(opts.oy or 0)
+ if id==0 and screen.gen3Safari and Native.drawSafariPanel then return Native.drawSafariPanel(screen,x,y)end
+ return Native.drawStatusPanel(screen,b,x,y,id%2==0)
+end
+function H.draw(side,view,opts)
+ local screen,b,id=resident(opts and opts.st,side,view)
+ if not b then return false,'healthbox is not an admitted native battler'end
+ local name='battle.healthbox.'..id
+ if Boundary.active(name)then
+  if scopes[name]then scopes[name].opts=opts end
+  return Boundary.invoke(name)
+ end
+ return paint(screen,b,id,opts)
+end
+local base=H.draw
+function H._nativeDraw(screen,b,x,y,player,body)
+ if H.draw==base then return body()end
+ local id=b.position
+ if id==nil then
+  if b==screen.player then id=0 elseif b==screen.enemy then id=1
+  else for i=2,3 do if screen:battlerAt(i)==b then id=i;break end end end
+ end
+ local st=Battle.getState();local observed=id and Coords.battler(st,id)
+ if not observed or Battle._screen(st)~=screen then return body()end
+ local name='battle.healthbox.'..id;local previous=scopes[name];local scope={};scopes[name]=scope
+ local ok,result=Scope.call(function()
+  return Boundary.dispatch(name,function()
+   local opts=scope.opts or{};local ox,oy=opts.ox or 0,opts.oy or 0
+   assert(type(ox)=='number'and ox==ox and math.abs(ox)<math.huge and type(oy)=='number'and oy==oy and math.abs(oy)<math.huge,'invalid healthbox offset')
+   if ox~=0 or oy~=0 then love.graphics.translate(ox,oy)end
+   return body()
+  end,function()
+   return require('src.compat.gen1.SourceCall').call(H,'draw',id,observed,{st=st})
+  end)
+ end)
+ scopes[name]=previous
+ if not ok then error(result,0)end
+ return result
+end
+return H
diff --git a/src/core/game3/battle/moves.lua b/src/core/game3/battle/moves.lua
new file mode 100644
index 000000000..8fadec230
--- /dev/null
+++ b/src/core/game3/battle/moves.lua
@@ -0,0 +1,44 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Effects=require('src.battle.Gen3EffectCatalog')
+local M={}
+local function detached(value,seen)
+ if type(value)~='table'then
+  if type(value)=='function'or type(value)=='userdata'or type(value)=='thread'then return nil end
+  return value
+ end
+ seen=seen or{};if seen[value]then return seen[value]end
+ local out={};seen[value]=out
+ for k,v in pairs(value)do if type(k)=='string'or type(k)=='number'then out[k]=detached(v,seen)end end
+ return out
+end
+function M.displayName(value)
+ if type(value)=='table'then value=value.id or value.move end
+ if value==nil or value==false or value==0 or value==''or value=='-------'then return '-------'end
+ if type(value)=='string'then value=tonumber(value)or value end
+ local name=require('src.core.game3.pokemon').moveName(value)
+ return name or nil,name==nil and'imported native move name unavailable'or nil
+end
+function M.get(number)
+ if type(number)=='table'then number=number.id or number.move end
+ if type(number)=='string'then number=tonumber(number)or number end
+ local g=Native.game();if not g then return nil end
+ local ids=Ids.new(g.data);local key=ids:native('moves',number)
+ local row=key and g.data.moves[key];if not row then return nil end
+ local effect=row.gen3Effect
+ if effect~=nil and(type(effect)~='number'or effect~=effect or effect%1~=0 or effect<0 or effect>255)then
+  return nil,'invalid imported native move-effect byte'
+ end
+ local id=ids:read('moves',key)
+ local out={id=id,numId=id,nativeId=key,name=row.name,type=ids:read('types',row.type),
+  power=row.power,accuracy=row.accuracy,pp=row.pp,priority=row.priority,target=row.target,
+  category=row.category or row.class,effect=effect~=nil and effect or row.effect,
+  gen3Effect=effect,effectSymbol=Effects.name(effect),nativeEffect=row.effect,effectChance=row.effectChance,
+  secondaryChance=row.secondaryChance,flags=detached(row.flags),hits=type(row.hits)=='function'and true or detached(row.hits),
+  highCrit=row.highCrit,makesContact=row.makesContact,protectAffected=row.protectAffected,
+  magicCoatAffected=row.magicCoatAffected,snatchAffected=row.snatchAffected,
+  mirrorMoveAffected=row.mirrorMoveAffected,kingsRockAffected=row.kingsRockAffected}
+ return out
+end
+return M
diff --git a/src/core/game3/battle/particle_pass.lua b/src/core/game3/battle/particle_pass.lua
new file mode 100644
index 000000000..ba0a779e8
--- /dev/null
+++ b/src/core/game3/battle/particle_pass.lua
@@ -0,0 +1,96 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Borrow actual native OBJ/copy painters in the caller's battler bands.
+local Battle=require('src.core.game3.battle')
+local Native=require('src.battle.Gen3Battle')
+local Coords=require('src.core.game3.battle.anim_coords')
+local Scope=require('src.render.GraphicsScope')
+local Assets=require('src.render.Assets')
+local M={}
+local current
+local function retire()
+ if current then current.refs[1]=nil;current.view=nil;current.rows=nil;current.users={} end
+ current=nil
+end
+local function live(c)
+ local screen=c.refs[1]
+ return screen and Battle._screen()==screen and Battle.getState()==c.view
+  and screen.gen3Anim==c.refs[2] and screen.gen3AnimPlaying
+end
+local function context(owner)
+ local screen=Battle._screen();local anim=screen and screen.gen3AnimPlaying and screen.gen3Anim
+ if not anim then retire();return end
+ if current and not live(current) then retire() end
+ if not current then current={refs=setmetatable({screen,anim},{__mode='v'}),view=Battle.getState(),users={}} end
+ if owner then current.users[owner]=true end
+ return current,screen,anim
+end
+local function sample(c,screen,anim)
+ local token=Scope.token()
+ if token and c.rows and c.token==token and c.frame==anim.frame and c.serial==anim.presentationSerial then return c.rows end
+ local rows={};local order=Coords.monDrawOrder(c.view);local slot={}
+ for i,id in ipairs(order)do slot[id]=i end
+ local function add(kind,value,z)rows[#rows+1]={kind=kind,value=value,z=z}end
+ local function copies(phase,z)
+  for _,copy in ipairs(anim.monBgCopies and anim:monBgCopies(screen,phase)or{})do add('copy',copy,z)end
+ end
+ copies('pre',50)
+ c.residual=nil
+ local objects,bgs=Native.moveOamObjects(screen,true)
+ if objects then
+  local band=0
+  for priority=3,0,-1 do
+   for _,copy in ipairs(bgs)do if (tonumber(copy.priority)or 2)==priority then add('copy',copy,band*100+50)end end
+   for i=#objects,1,-1 do
+    local row=objects[i]
+    if math.floor(row.key/256)==priority then
+     if row.kind=='battler' then
+      local b=row.battler;local id=b.position or(b==screen.player and 0 or 1)
+      band=slot[id]or band
+     else add('event',row,band*100+50)end
+    end
+   end
+  end
+ else
+  -- Native task/helper barriers without a complete OAM key retain the native
+  -- fallback: actual event order above the battlers, not invented priorities.
+  c.residual=bgs
+  for _,copy in ipairs(anim.monBgCopies and anim:monBgCopies(screen,'oam')or{})do add('copy',copy,50)end
+  for _,row in ipairs(anim:eventsForDraw(screen,Native))do add('event',row,999)end
+ end
+ copies('post',999)
+ -- Surf and flourish keep their own native task/graphics implementations.
+ -- skipEvents prevents this borrowed extra layer from redrawing OBJ events.
+ add('extras',true,999)
+ c.token,c.frame,c.serial,c.rows=token,anim.frame,anim.presentationSerial,rows
+ return rows
+end
+local function bound(n,default)
+ if n==nil then return default end
+ assert(type(n)=='number' and n==n and math.abs(n)<math.huge,'particle band must be finite')
+ return n
+end
+function M.draw(lo,hi,owner)
+ lo,hi=bound(lo,0),bound(hi,999);if lo>hi then return false,'empty particle band' end
+ local c,screen,anim=context(owner);if not c then return false,'inactive native animation' end
+ local rows=sample(c,screen,anim);local count=0
+ local ok,result,reason=Scope.call(function()
+  for _,row in ipairs(rows)do
+   if row.z>=lo and row.z<=hi then
+    if not live(c) or screen.gen3Anim~=anim or anim.frame~=c.frame then retire();return false,'native particle admission changed' end
+    if row.kind=='event' then
+     local entry=row.value;anim:drawEvent(entry.event,screen,Native,Assets,entry.pose,true)
+    elseif row.kind=='copy' then screen:drawGen3MonBgState(row.value)
+    else anim:draw(screen,true) end
+    if not live(c) or screen.gen3Anim~=anim or anim.frame~=c.frame then retire();return false,'native particle admission changed' end
+    count=count+1
+   end
+  end
+  return true,count
+ end)
+ if not ok then error(result,0)end
+ return result,reason
+end
+M._service={release=retire,poll=function()if current and not live(current)then retire()end end,
+ releaseOwner=function(_,owner)if current and current.users[owner]then retire()end end}
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/core/game3/battle/pic_coords.lua b/src/core/game3/battle/pic_coords.lua
new file mode 100644
index 000000000..df0b9fbe3
--- /dev/null
+++ b/src/core/game3/battle/pic_coords.lua
@@ -0,0 +1,41 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Live cartridge-numbered offsets; changing datasets never keeps an old row.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local P={}
+local function finite(n)return type(n)=='number'and n==n and n~=math.huge and n~=-math.huge end
+-- Base sprite anchors are independent of the current render transform and
+-- animation coordinate overrides. Read the live cartridge record each time;
+-- the returned point is detached so callers cannot edit native layout data.
+function P.battlerCoords(double,id)
+  if double~=nil and type(double)~='boolean'then return nil,'double must be a boolean'end
+  id=id==nil and 0 or tonumber(id)
+  if not id or id~=id or id%1~=0 or id<0 or id>3 then return nil,'invalid battler slot'end
+  local game,why=Native.game();if not game then return nil,why end
+  local constants=game.data and game.data.constants
+  local imported=constants and constants.gen3BattlerCoords
+  if imported~=nil and type(imported)~='table'then return nil,'invalid native battler coordinates'end
+  local layout
+  if imported then if double then layout=imported.doubles else layout=imported.singles end end
+  if layout~=nil and type(layout)~='table'then return nil,'invalid native battler coordinates'end
+  local point=layout and layout[id+1]
+  if point==nil then
+    local coords=require('src.core.game3.battle.anim_coords')
+    point=(double and coords.DOUBLES or coords.SINGLES)[id]
+  end
+  if type(point)~='table'then return nil,'invalid native battler coordinates'end
+  local x,y=point.x or point[1],point.y or point[2]
+  if not finite(x)or not finite(y)then return nil,'invalid native battler coordinates'end
+  return{x=x,y=y,[1]=x,[2]=y}
+end
+for _,kind in ipairs{'front','back','elev'}do
+ P[kind]=setmetatable({},{__index=function(_,id)
+  local g=Native.game();if not g then return nil end
+  local key=Ids.new(g.data):native('pokemon',id);local row=key and g.data.pokemon[key]
+  if not row then return nil end
+  if kind=='elev'then return g.data.constants.gen3Elevation and g.data.constants.gen3Elevation[key]or 0 end
+  local coords=kind=='front'and row.frontPicCoords or row.backPicCoords
+  return coords and coords.yOffset
+ end,__newindex=function()error('native picture coordinates are read-only',2)end})
+end
+return P
diff --git a/src/core/game3/battle/profile.lua b/src/core/game3/battle/profile.lua
new file mode 100644
index 000000000..923cbfa44
--- /dev/null
+++ b/src/core/game3/battle/profile.lua
@@ -0,0 +1,33 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Bounded native presentation facts. Rules/action/theme capabilities are not
+-- inferred from this view; the admitted native battle remains authoritative.
+local Battle=require('src.core.game3.battle')
+local Native=require('src.compat.gen1.NativeSession')
+local Text=require('src.battle.Gen3SafariText')
+local Version=require('src.core.GameVersion')
+local M={}
+function M.of(state)
+ local b=state~=nil and Battle._screen(state)or nil
+ local game=Native.game();local edition=Version.get()
+ if not(b and game and b.game==game and b.gen3Safari and Text.spec(game.data,edition))then
+  return nil,'no admitted native Safari presentation profile'
+ end
+ local refs=setmetatable({state,b,game.data,b.gen3Safari},{__mode='v'})
+ local function valid()
+  local view,screen=refs[1],refs[2];local g=Native.game()
+  return view~=nil and screen~=nil and Battle._screen(view)==screen
+   and g~=nil and screen.game==g and g.data==refs[3]and screen.gen3Safari==refs[4]
+   and Version.get()==edition and Text.spec(g.data,edition)~=nil
+ end
+ local strings=setmetatable({},{__index=function(_,key)
+  if valid()and key=='safariPrompt'then return Text.PREFIX..'prompt'end
+ end,__newindex=function()error('native battle profile is read-only',2)end})
+ return setmetatable({},{__index=function(_,key)
+  if key=='open'then return valid()end
+  if not valid()then return end
+  if key=='strings'then return strings end
+  if key=='id'then return edition end
+  if key=='family'then return Version.layout(edition)end
+ end,__newindex=function()error('native battle profile is read-only',2)end})
+end
+return M
diff --git a/src/core/game3/battle/rules.lua b/src/core/game3/battle/rules.lua
new file mode 100644
index 000000000..a283d4bed
--- /dev/null
+++ b/src/core/game3/battle/rules.lua
@@ -0,0 +1,7 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observation only; native Damage and the active battle still resolve hits.
+local Native=require('src.compat.gen1.NativeSession')
+local crit=setmetatable({},{__index=function(_,key)
+ if key=='CHANCE'and Native.game()then return require('src.battle.Damage').gen3CritDenominators()end
+end,__newindex=function()error('native critical rule observations are read-only',2)end})
+return{crit=crit}
diff --git a/src/core/game3/battle/stage.lua b/src/core/game3/battle/stage.lua
new file mode 100644
index 000000000..54bf0a498
--- /dev/null
+++ b/src/core/game3/battle/stage.lua
@@ -0,0 +1,142 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Live presentation observations over one actual native battle admission.
+local Battle=require('src.core.game3.battle')
+local Native=require('src.battle.Gen3Battle')
+local Coords=require('src.core.game3.battle.anim_coords')
+local Iteration=require('src.compat.gen1.TableIteration')
+local Ball=require('src.compat.gen1.NativeBallObservation')
+local Timing=require('src.core.Timing')
+local M={}
+local current
+local function retire(c)
+ if not c then return end
+ c.retired=true;c.refs[1]=nil;c.view=nil;c.nodes={};c.users={};c.ballRef=nil;c.ballView=nil
+ if current==c then current=nil end
+end
+local function live(c)
+ local s=not c.retired and c.refs[1]
+ if s and Battle._screen()==s and Battle.getState()==c.view then return s end
+ retire(c)
+end
+local read
+local keys={stage={'slide','slideDone','trainer','ball','balls','healthbox','partyBar','bgSlide','win0'},
+ trainer={'player','enemy'},healthbox={'player','enemy',0,1,2,3},balls={0,1,2,3},
+ portrait={'visible','x','y','ox','oy','frame','gender','picId','pic2','x2'},
+ box={'visible','ox'},bg={'enemyOx','playerOx'},mask={1,2},
+ party={'player','enemy'},bar={'visible','x','y','ox','balls','ballHidden'}}
+local function node(c,kind,id,anim)
+ local name=kind..':'..tostring(id or'')
+ if not anim and c.nodes[name]then return c.nodes[name]end
+ local refs=anim and setmetatable({anim},{__mode='v'})
+ local fieldKeys=anim and Ball.keys or keys[kind]
+ local function get(key)
+  local s=live(c);if not s then if key=='visible'then return false end;return nil end
+  if refs then
+   local a=refs[1];if not a or s.gen3Ball~=a then if key=='visible'then return false end;return nil end
+   return Ball.read(s,a,key)
+  end
+  return read(c,s,kind,id,key)
+ end
+ local value=setmetatable({},{__index=function(_,key)return get(key)end,
+  __newindex=function()error('native battle stage observation is read-only',2)end})
+ local weak=setmetatable({value=value},{__mode='v'})
+ -- The registry must not retain its own weak key through this reader's state.
+ Iteration.register(value,function(spec)
+  local v=spec.value;local out={}
+  if v then for _,key in ipairs(fieldKeys)do out[key]=v[key]end end
+  return out
+ end,weak)
+ if not anim then c.nodes[name]=value end
+ return value
+end
+local function battler(s,id)
+ return id==0 and s.player or id==1 and s.enemy or s:battlerAt(id)
+end
+local function ball(c,s)
+ local a=s.gen3Ball;if not a then return nil end
+ local catch=package.loaded['src.core.game3.battle.catch_seq']
+ local caught=catch and catch._ball
+ if caught and caught.stage then return caught.stage end
+ if c.ballRef and c.ballRef[1]==a then return c.ballView end
+ c.ballRef=setmetatable({a},{__mode='v'});c.ballView=node(c,'ball',nil,a)
+ return c.ballView
+end
+local function slide(s)return(s.introSlide or 0)*Timing.BATTLE_SLIDE_PX_PER_FRAME end
+local names={trainer='trainer',healthbox='healthbox',partyBar='party',bgSlide='bg',balls='balls'}
+read=function(c,s,kind,id,key)
+ if kind=='stage'then
+  if key=='slideDone'then return(s.introSlide or 0)<=0 and(s.frlgIntro and s.frlgIntro.hold or 0)<=0 end
+  if key=='slide'then
+   local intro=s._sourceIntroSequence
+   local total=intro and intro.steps[1].data.slideFrames or Timing.BATTLE_SLIDE_IN_FRAMES
+   return total>0 and math.max(0,math.min(1,1-(s.introSlide or 0)/total))or 1
+  end
+  if key=='ball'then return ball(c,s)end
+  if key=='win0'then local top=Native.introWindow(s);return top and node(c,'mask')or nil end
+  if names[key]then return node(c,names[key])end
+ elseif kind=='trainer'or kind=='party'then
+  local pos=key=='player'and 0 or key=='enemy'and 1
+  if pos then return node(c,kind=='trainer'and'portrait'or'bar',pos)end
+ elseif kind=='healthbox'then
+  local pos=Coords.fixedId(key);if pos then return node(c,'box',pos)end
+ elseif kind=='balls'then
+  if type(key)=='number'and key%1==0 and key>=0 and key<=3 then
+   local b=battler(s,key);local a=b and s:gen3BallFor(b)
+   if a and(a.battler==b or key==1 and not a.battler)then return ball(c,s)end
+  end
+ elseif kind=='mask'then
+  local top,bottom=Native.introWindow(s);return key==1 and top or key==2 and bottom or nil
+ elseif kind=='bg'then
+  if key=='enemyOx'then return -slide(s)end
+  if key=='playerOx'then return slide(s)end
+ elseif kind=='box'then
+  if key=='visible'then return Native.healthboxVisible(s,id,slide(s))end
+  if key=='ox'then return 0 end -- Visible native panels have no slide offset.
+ elseif kind=='portrait'then
+  local player=id==0
+  local constants=s.data.constants.gen3BattlerCoords
+  local positions=constants and(s:isDouble()and constants.doubles or constants.singles)
+  local p=positions and positions[id+1]or(s:isDouble()and Coords.DOUBLES or Coords.SINGLES)[id]
+  if key=='visible'then return player and s.showPlayerBack==true or not player and s.showEnemyTrainer==true end
+  if key=='x'then return p.x or p[1]end
+  if key=='y'then return p.y or p[2]end
+  if key=='ox'then return(player and slide(s)or -slide(s))+s:picOffset(player and'back'or'foe')end
+  if key=='oy'then return 0 end
+  if key=='frame'then return player and(s:backThrowFrame()or 0)or 0 end
+  if key=='picId'and not player then return c.view.trainerPicId end
+  if key=='pic2'and not player then return s.trainerB and s.trainerB.picIndex end
+  if key=='x2'and not player and s.trainerB then
+   local q=positions and positions[4]or Coords.DOUBLES[3];return q.x or q[1]
+  end
+  if key=='gender'and player then
+   local forms=s.data.field and s.data.field.playerForms
+   local form=require('src.pokemon.Sprites').playerForm(s.data,s.game.save)
+   return forms and form and(forms.girl==form and 1 or 0)or nil
+  end
+ elseif kind=='bar'then
+  local summary,row,party=Native.partySummary(s,id==0)
+  if key=='visible'then return summary~=nil end
+  if not summary then return nil end
+  if key=='x'then return row.barX+(row.flip and(Native.summaryBarWidth(summary)or 0)or 0)end
+  if key=='y'then return row.barY end
+  if key=='ox'then return Native.summaryRowOffset(summary,row,(s.frame or 0)-(s.introBallsFrom or s.frame or 0))end
+  if key=='balls'then return Native.summarySlots(summary,row,party)end
+  if key=='ballHidden'then
+   local age=(s.frame or 0)-(s.introBallsFrom or s.frame or 0);local hidden={}
+   for i=1,summary.count or 6 do hidden[i]=age<Native.SUMMARY_SLIDE_FRAMES+(i-1)*Native.SUMMARY_BALL_FRAMES end
+   return hidden
+  end
+ end
+end
+function M.current(owner)
+ local s=Battle._screen();local view=s and Battle.getState()
+ if current and(not live(current)or current.view~=view)then retire(current)end
+ if not s then return nil end
+ if not current then current={refs=setmetatable({s},{__mode='v'}),view=view,nodes={},users={}}end
+ if owner then current.users[owner]=true end
+ return node(current,'stage')
+end
+M._service={release=function()retire(current)end,poll=function()if current then live(current)end end,
+ releaseOwner=function(_,who)if current and current.users[who]then retire(current)end end}
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/core/game3/battle/types.lua b/src/core/game3/battle/types.lua
new file mode 100644
index 000000000..69fc75101
--- /dev/null
+++ b/src/core/game3/battle/types.lua
@@ -0,0 +1,28 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Read names from the admitted native dataset, never from a second type chart.
+local Native = require('src.compat.gen1.NativeSession')
+local Ids = require('src.compat.gen1.BattleIds')
+local M = {}
+local dataset, ids
+
+function M.name(value)
+  local game = Native.game()
+  local data = game and game.data
+  if not data then dataset, ids = nil, nil; return nil end
+  if data ~= dataset or not ids:valid() then
+    dataset, ids = data, Ids.new(data)
+  end
+  local key = ids:native('types', value)
+  if not key then return nil end
+  local chart = data.type_chart and data.type_chart.types
+  local catalogue = data.types or data.constants and data.constants.types
+  local record = chart and chart[key] or catalogue and catalogue[key]
+  local name = record and record.name or key
+  local service = package.loaded['src.translation.Service']
+  return service and service.name(name) or name
+end
+
+local function clear()dataset,ids=nil,nil end
+M._service={release=clear,releaseOwner=clear}
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/core/game3/battle/ui.lua b/src/core/game3/battle/ui.lua
new file mode 100644
index 000000000..079b12e90
--- /dev/null
+++ b/src/core/game3/battle/ui.lua
@@ -0,0 +1,164 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native battle surface and input-phase seams. Sprite/particle presentation
+-- capabilities are separate; this module does not advertise that protocol.
+local Battle=require('src.core.game3.battle')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Scope=require('src.render.GraphicsScope')
+local Ui={}
+function Ui.drawMenuFrames(mode)return require('src.ui.game3.battle_chrome').drawMenuFrames(mode)end
+function Ui.voiceoverDim()
+ local screen=Battle._screen();return screen and require('src.battle.Gen3VoiceoverPresentation').dim(screen)or 0
+end
+function Ui.litHealthboxShown()
+ local screen=Battle._screen();return screen and require('src.battle.Gen3VoiceoverPresentation').lit(screen)or false
+end
+function Ui.moveTypeOf(mon,slot,def)
+ local types=mon and mon.moveTypes
+ if types and types[slot]~=nil then return types[slot]end
+ return def and def.type
+end
+function Ui.ppColorState(current,maximum)
+ current,maximum=tonumber(current)or 0,tonumber(maximum)or 0
+ if current~=current or maximum~=maximum or current==math.huge or maximum==math.huge
+  or current==-math.huge or maximum==-math.huge then return nil,'invalid PP observation'end
+ local palette=require('src.ui.Gen3SummaryLayout').ppColor(current,maximum)
+ return palette==12 and 3 or palette-9
+end
+function Ui.quickBallPrompt()
+ local screen=Battle._screen();return screen and require('src.battle.QuickItem').prompt(screen)or nil
+end
+function Ui.ballQuad(ball,frame)
+ return require('src.core.game3.battle.ui_ball_art').quad(ball,frame)
+end
+local function selectionBattler(key)
+ if type(key)=='number' and (key~=key or key%1~=0 or key<0 or key>3) then return end
+ local screen=Battle._screen();if not screen then return end
+ local id=require('src.core.game3.battle.anim_coords').idOf(key)
+ if id==nil or id>=2 and not screen:isDouble() then return end
+ return screen,screen:battlerAt(id)
+end
+function Ui.targetHidden(key)
+ local screen,b=selectionBattler(key)
+ return screen and require('src.battle.Gen3SelectionPresentation').hidden(screen,b) or false
+end
+function Ui.bounceOffset(kind,key)
+ if kind~='hb' and kind~='mon' then return 0 end
+ local screen,b=selectionBattler(key)
+ return screen and require('src.battle.Gen3SelectionPresentation').offset(screen,kind,b) or 0
+end
+function Ui.previewCoeff(key)
+ local screen,b=selectionBattler(key)
+ local fx=screen and screen:gen3AnimSpecialMonState(b)
+ return math.max(0,math.min(16,(fx and fx.white or 0)*16))
+end
+-- Keep PP thresholds shared with the published native summary renderer.
+function Ui.ppColorIndex(current,maximum)
+ return require('src.ui.Gen3SummaryLayout').ppColor(current,maximum)
+end
+local function call(name,...)
+  local facade=require('src.core.Game3');local who=facade._callbackOwner()
+  local seams=package.loaded['src.mods.ModSeams']
+  for i=#(seams and seams._journal or{}),1,-1 do
+    local change=seams._journal[i]
+    if change.tbl==Ui and change.key==name and change.after==Ui[name]then who=change.owner;break end
+  end
+  return facade._withCallbackOwner(who,Ui[name],...)
+end
+local function query(method,state)
+  local screen=Battle._screen(state);if not screen then return false end
+  if type(screen[method])~='function'then return nil,'native UI query unavailable: '..method end
+  return screen[method](screen)
+end
+function Ui.statusHUDVisible()return query('statusHUDVisible')end
+function Ui.bottomUIVisible(state)
+  return query('bottomUIVisible',state)
+end
+function Ui.moveGridNavigation()
+  return query('moveGridNavigation')
+end
+function Ui.dialogPending()
+ local screen=Battle._screen();if not screen then return false end
+ if screen.current and screen.current.text~=nil then return true end
+ for _,row in ipairs(screen.queue or{})do if row.text~=nil then return true end end
+ return false
+end
+function Ui.busy()
+ local screen=Battle._screen();if not screen then return false end
+ return screen.game.stack:top()~=screen or screen.waitingUI==true
+  or screen.current~=nil or #(screen.queue or{})>0
+  or(screen.waitFrames or 0)>0 or(screen.hitSfxWait or 0)>0
+end
+function Ui.waitingForCommand()
+ local screen=Battle._screen()
+ return screen~=nil and not screen.result and not Ui.busy()
+  and not screen.gen3AnimPlaying and not screen.gen3BallPlaying
+  and(screen.phase=='menu'or screen.phase=='moveSelect'or screen.phase=='targetSelect')or false
+end
+function Ui.bindState(state)
+  if state==nil then
+    if Battle.isActive()then return false,'cannot unbind an admitted native battle UI'end
+    return true
+  end
+  if not Battle._screen(state)then return false,'UI state is not the admitted native battle'end
+  return true
+end
+local function pump()return Boundary.invoke('battle.ui.update')end
+Ui.pump=pump
+local commandPhase=require('src.compat.game3.BattleCommandPhase')
+local takeCommand=commandPhase.take
+Ui.takeCommand=takeCommand
+function Ui._nativeCommand(screen,action,body)
+ if Ui.takeCommand==takeCommand then return body(screen,action)end
+ return commandPhase.dispatch(screen,action,body,function()return call('takeCommand')end)
+end
+local function draw(w,h)
+  local screen=Battle._screen();if not screen then return false,'no admitted native battle'end
+  local bw,bh=screen:uiSize()
+  if w~=nil and w~=bw or h~=nil and h~=bh then return false,'UI capture must use the native battle surface'end
+  if Boundary.active('battle.ui.draw')then return Boundary.invoke('battle.ui.draw')end
+  return Battle._captureNative(screen)
+end
+Ui.draw=draw
+function Ui._nativeDraw(screen,body)
+  if Ui.draw==draw then return body(screen)end
+  if Boundary.active('battle.ui.draw')then return Boundary.invoke('battle.ui.draw')end
+  local w,h=screen:uiSize()
+  local ok,result=Scope.call(function()
+    return Boundary.dispatch('battle.ui.draw',function()return body(screen)end,function()return call('draw',w,h)end)
+  end)
+  if not ok then error(result,0)end
+  return result
+end
+function Ui._nativeUpdate(screen,dt,body)
+  if Ui.pump==pump then return body(screen,dt)end
+  if Boundary.active('battle.ui.update')then return Boundary.invoke('battle.ui.update')end
+  return Boundary.dispatch('battle.ui.update',function()return body(screen,dt)end,function()return call('pump',dt)end)
+end
+setmetatable(Ui,{__index=function(_,key)
+  local screen=Battle._screen()
+  if key=='_st'then return Battle.getState()end
+  if not screen then return nil end
+  if key=='_menuIndex'then return screen.menuIndex end
+  if key=='_moveIndex'then return screen.moveIndex end
+  if key=='_active'then return screen:choosingSlotNow()end
+  if key=='_swap'then
+    local index=screen.moveSwapIndex
+    return index and{cursor=index-1}or nil
+  end
+  if key=='_swapIndex'then return screen.moveSwapIndex end
+  if key=='_mode'then return({menu='menu',moveSelect='moves',mimicSelect='moves',targetSelect='target'})[screen.phase]or'none'end
+end,__newindex=function(t,key,value)
+ if key=='_menuIndex'or key=='_moveIndex'then
+  local screen=Battle._screen()
+  assert(screen and screen.game.stack:top()==screen,'native battle does not own the cursor')
+  local limit,phase
+  if key=='_menuIndex'then limit,phase=#screen:menuActions(),'menu'
+  else local actor=screen:menuBattler();limit,phase=#(actor and actor.curMoves or{}),'moveSelect'end
+  assert(screen.phase==phase,'native battle cursor is not active')
+  assert(type(value)=='number'and value==value and value%1==0 and value>=1 and value<=math.min(4,limit),'invalid native battle cursor')
+  if key=='_menuIndex'then screen.menuIndex=value else screen.moveIndex=value end
+ elseif key=='_st'or key=='_mode'or key=='_active'or key=='_swap'or key=='_swapIndex'then
+  error('native battle UI observation is read-only: '..key,2)
+ else rawset(t,key,value)end
+end})
+return Ui
diff --git a/src/core/game3/battle/ui_ball_art.lua b/src/core/game3/battle/ui_ball_art.lua
new file mode 100644
index 000000000..fbe0b0943
--- /dev/null
+++ b/src/core/game3/battle/ui_ball_art.lua
@@ -0,0 +1,54 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source-owned views of the imported native ball sheet. No ball timeline is
+-- created, and releasing source art cannot invalidate the native asset cache.
+local Battle=require('src.core.game3.battle')
+local Assets=require('src.render.Assets')
+local Call=require('src.compat.gen1.SourceCall')
+local M={}
+local current
+local function release()
+ if current then
+  for _,quad in pairs(current.quads)do quad:release()end
+  if current.image then current.image:release()end
+ end
+ current=nil
+end
+local function integer(n)return type(n)=='number'and n==n and n%1==0 and n>=0 and n<math.huge end
+local function context()
+ local screen=Battle._screen();local view=screen and Battle.getState()
+ if not screen then release();return end
+ local r=screen.data.constants.gen3BallAnim
+ local path=r and r.images and r.images.balls
+ if type(path)~='string'then release();return end
+ local size,frames=r.size,r.frames
+ if not(integer(size)and size>0 and integer(frames)and frames>0)then release();return end
+ if current and(current.view~=view or current.path~=path or current.size~=size or current.frames~=frames)then release()end
+ if not current then current={view=view,path=path,size=size,frames=frames,quads={},users={}}end
+ return current
+end
+function M.quad(ball,frame)
+ local c=context();if not c then return nil,'native ball artwork unavailable'end
+ if not(integer(ball)and integer(frame)and frame<c.frames)then return nil,'invalid native ball cell'end
+ local owner=Call.owner(M,'quad')or'engine';c.users[owner]=true
+ if not c.image then
+  local ok,image=pcall(love.graphics.newImage,Assets.resolve(c.path))
+  if not ok then return nil,tostring(image)end
+  c.image=image
+ end
+ local w,h=c.image:getDimensions()
+ if w~=c.frames*c.size or h%c.size~=0 or ball>=h/c.size then return nil,'native ball cell outside imported sheet'end
+ local key=ball*c.frames+frame
+ local quad=c.quads[key]
+ if not quad then
+  quad=love.graphics.newQuad(frame*c.size,ball*c.size,c.size,c.size,w,h)
+  c.quads[key]=quad
+ end
+ return c.image,quad
+end
+M._service={release=release,poll=function()if current then context()end end,
+ releaseOwner=function(_,who)
+  if current then current.users[who]=nil;if not next(current.users)then release()end end
+ end}
+require('src.core.game3.asset_stream').register(M._service)
+Assets.register(release)
+return M
diff --git a/src/core/game3/battle_bridge.lua b/src/core/game3/battle_bridge.lua
new file mode 100644
index 000000000..e860f4021
--- /dev/null
+++ b/src/core/game3/battle_bridge.lua
@@ -0,0 +1,7 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source requests enter the same native encounter transaction and completion.
+local B={}
+function B.startWild(mod,game,encounter,opts)
+  return require('src.compat.gen1.BattleRequests').startWild(game,encounter,opts)
+end
+return B
diff --git a/src/core/game3/collision.lua b/src/core/game3/collision.lua
new file mode 100644
index 000000000..6cb360c8e
--- /dev/null
+++ b/src/core/game3/collision.lua
@@ -0,0 +1,125 @@
+-- Compatibility reads over owned map views; permissions use the live native
+-- collision owner and never mutate it or run player/warp/script events.
+local Session=require('src.compat.gen1.NativeSession')
+local Map=require('src.core.game3.map')
+local MB=require('src.compat.gen1.MetatileBehavior')
+local runtime=require('src.compat.gen1.CollisionRuntime').new()
+local Collision={}
+local warpBehaviors={}
+for _,name in ipairs({'WATER_DOOR','DEEP_SOUTH_WARP','LAVARIDGE_GYM_B1F_WARP','LAVARIDGE_GYM_1F_WARP',
+  'AQUA_HIDEOUT_WARP','MT_PYRE_HOLE','MOSSDEEP_GYM_WARP','BRIDGE_OVER_OCEAN',
+  'WATER_SOUTH_ARROW_WARP','SHOAL_CAVE_ENTRANCE','STAIRS_OUTSIDE_ABANDONED_SHIP'})do
+  warpBehaviors[MB.require(name)]=true
+end
+local function integer(v)return type(v)=='number'and v==v and math.abs(v)<math.huge and v%1==0 end
+local function current()return runtime:current()end
+function Collision.inBounds(x,y)
+  local g,w=Session.resolve()
+  return g~=nil and integer(x)and integer(y)and w.map:inBounds(x,y)or false
+end
+function Collision.behaviorOn(def,x,y)return runtime:behavior(def,x,y)end
+function Collision.behavior(x,y)return Collision.behaviorOn(current(),x,y)end
+function Collision.worldBehavior(x,y)
+  if not(integer(x)and integer(y))then return nil end
+  local def=current();if not def then return nil end
+  local mid,pair=Map.worldMidAt(x,y,def)
+  if pair==def.pair then return runtime:behaviorMid(def,mid)end
+  for _,entries in ipairs({Map.neighborList,Map.world})do
+    for _,row in ipairs(entries)do
+      local target=row.def
+      if target and target.pair==pair then return runtime:behaviorMid(target,mid)end
+    end
+  end
+end
+function Collision.cell(x,y)
+  local def=current();local layout=def and def.midLayout
+  return layout and integer(x)and integer(y)and Collision.inBounds(x,y)and layout:collAt(x,y)or 255
+end
+function Collision.elevationOn(def,x,y)
+  local layout=def and def.midLayout
+  if not(layout and integer(x)and integer(y))or x<0 or y<0 or x>=layout.width or y>=layout.height then return nil end
+  return layout:elevAt(x,y)
+end
+function Collision.elevationAt(x,y)
+  local g,w=Session.resolve()
+  if g and integer(x)and integer(y)and w.map:inBounds(x,y)then return w.map:cellElevation(x,y)end
+end
+function Collision.canEnter(game,x,y,opts)return runtime:canEnter(game,x,y,opts)end
+function Collision.isWalkable(x,y)
+  local g,w=Session.resolve()
+  return g~=nil and integer(x)and integer(y)and w.map:inBounds(x,y)and w.map:isWalkableCell(x,y)or false
+end
+function Collision.isWater(x,y)
+  local g,w=Session.resolve()
+  return g~=nil and integer(x)and integer(y)and w.map:inBounds(x,y)and w.map:isWaterCell(x,y)or false
+end
+function Collision.isGrass(x,y)
+  local g,w=Session.resolve()
+  return g~=nil and integer(x)and integer(y)and w.map:inBounds(x,y)and w.map:isGrassCell(x,y)or false
+end
+function Collision.nextElevation(def,at,x,y,px,py)
+  local g=Session.resolve();local maps=g and Map._context(g)
+  if not(maps and maps:isOwned(def)and maps:definition(def.id)==def and integer(x)and integer(y))then
+    return at,nil
+  end
+  return require('src.world.Map').elevationTransition(at,
+    Collision.elevationOn(def,x,y),Collision.elevationOn(def,px,py))
+end
+function Collision.ledgeLanding(game,x,y,dir)
+  local g,w=Session.resolve(game)
+  if not(g and integer(x)and integer(y)and w.map:inBounds(x,y))then return nil end
+  local _,fx,fy,distance=require('src.world.Ledge').approach(w.map,g.data,x,y,dir)
+  if not fx then return nil end
+  local delta=require('src.world.Collision').DELTA[dir]
+  local lx,ly=x+delta[1]*(distance or 2),y+delta[2]*(distance or 2)
+  if w.map:inBounds(lx,ly)then return lx,ly end
+end
+function Collision.isWarpMetatileBehavior(behavior)
+  return type(behavior)=='number'and((behavior>=0x60 and behavior<=0x6f)or behavior==0x71 or warpBehaviors[behavior]==true)or false
+end
+function Collision.warpAt(x,y)
+  local def=current();if not(def and Collision.inBounds(x,y))then return nil end
+  local cell=Collision.cell(x,y);local behavior=Collision.behaviorOn(def,x,y)
+  if not((cell>=0x60 and cell<=0x7f)or warpBehaviors[behavior])then return nil end
+  for _,warp in ipairs(def.warps or{})do if warp.x==x and warp.y==y then return warp end end
+end
+function Collision.resolveWarpDestination(value,warp)
+  local game,world=Session.resolve(value)
+  if not(game and type(warp)=='table')then return nil end
+  local Identity=require('src.compat.gen1.MapIdentity')
+  local binding=Identity.bind(game.data.maps,require('src.core.GameVersion').get())
+  local dest=warp.destMap or warp.map
+  local native=type(dest)=='string'and binding:nativeId(dest)
+  if not native and type(dest)=='string'and game.data.maps[dest]then native=dest end
+  if not native and warp.nativeDestination=='MAP_G127_N127'then native=warp.nativeDestination end
+  if not native and tonumber(warp.mapGroup)==127 and tonumber(warp.mapNum)==127 then native='MAP_G127_N127'end
+  if not native and warp.mapGroup~=nil and warp.mapNum~=nil then
+    local canonical=Identity.lookup(require('src.core.GameVersion').get(),warp.mapGroup,warp.mapNum)
+    native=canonical and binding:nativeId(canonical)
+  end
+  if not native then return nil end
+  local index=warp.destWarp or 1
+  if not integer(index)or index<1 then return nil end
+  local id,x,y=require('src.world.Warp').peekDestination(game.data,{destMap=native,destWarp=index},
+    world.lastOutdoor,world.backupWarp,game.save)
+  local canonical=id and binding:legacyId(id)
+  if canonical and integer(x)and integer(y)then return canonical,x,y end
+end
+function Collision.clear()runtime:release()end
+Collision.release=Collision.clear
+setmetatable(Collision,{__index=function(_,key)
+  if key=='_grid'then return runtime:grid()end
+  local def=current();if not def then return nil end
+  if key=='_mapDef'then return def end
+  if key=='_mapId'then return def.id end
+  local layout=def.midLayout
+  if key=='_widthCells'then return layout and layout.width or 0 end
+  if key=='_heightCells'then return layout and layout.height or 0 end
+  if key=='_warps'then
+    local out={};for _,warp in ipairs(def.warps or{})do
+      local active=Collision.warpAt(warp.x,warp.y);if active then out[warp.y*1024+warp.x]=active end
+    end
+    return out
+  end
+end})
+return Collision
diff --git a/src/core/game3/constants.lua b/src/core/game3/constants.lua
new file mode 100644
index 000000000..e660d9727
--- /dev/null
+++ b/src/core/game3/constants.lua
@@ -0,0 +1,67 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Detached names/indices from the current native import, never another ROM.
+local Version=require('src.core.GameVersion')
+local Native=require('src.compat.gen1.NativeSession')
+local C={}
+local function enum(rows,prefix)
+ local names,ids={},{}
+ for name,id in pairs(rows)do
+  if type(name)=='string'and type(id)=='number'then names[(prefix or'')..name]=id;ids[id]=ids[id]or((prefix or'')..name)end
+ end
+ return{byName=names,byId=ids}
+end
+function C.of(edition)
+ edition=edition or Version.get();assert(edition==Version.get(),'foreign native constant dataset')
+ local g=Native.game();assert(g,'no native GBA constant dataset')
+ local data=g.data;local rows={}
+ local forms=data.field and data.field.playerForms or{}
+ for who,r in pairs(forms)do
+  if r.picIndex then
+   local frlg=edition=='firered'or edition=='leafgreen'
+   local name=who=='boy'and(frlg and'TRAINER_PIC_RED'or'TRAINER_PIC_BRENDAN')or who=='girl'and(frlg and'TRAINER_PIC_LEAF'or'TRAINER_PIC_MAY')
+   if name then rows[name]=r.picIndex end
+  end
+ end
+ -- Named special partners retain the picture identity on native trainer rows.
+ for _,r in pairs(data.trainers or{})do
+  if(r.name=='WALLY'or r.name=='STEVEN')and type(r.picIndex)=='number'then
+   local key='TRAINER_PIC_'..r.name
+   if rows[key]and rows[key]~=r.picIndex then error('ambiguous native trainer identity: '..r.name)end
+   rows[key]=r.picIndex
+  end
+ end
+ local sections={}
+ for id,name in pairs(data.constants.gen3MapSections or{})do
+  if type(name)=='table'then name=name.name end
+  if type(name)=='string'then sections['MAPSEC_'..name:upper():gsub('[^%w]+','_')]=id end
+ end
+ local out={game=edition,trainer_classes=enum(rows),region_map_sections=enum(sections)}
+ local labels=require('src.import.gba.field_label_facts').metatileLabels(edition)
+ if labels then out.metatile_labels=enum(labels)end
+ local refs=setmetatable({g,data,g.save,g.mods},{__mode='v'})
+ local hadMods=g.mods~=nil
+ function out:require(kind,name)
+  local owner=refs[1]
+  assert(owner and Native.game()==owner and Version.get()==edition and owner.data==refs[2]
+   and owner.save==refs[3]and owner.mods==refs[4]and hadMods==(owner.mods~=nil),
+   'native constant query retired')
+  assert(type(kind)=='string'and type(name)=='string','invalid native constant name')
+  local value=self:id(kind,name)
+  assert(value~=nil,'missing native constant '..kind..'.'..name)
+  return value
+ end
+ function out:raw(kind)local row=self[kind];return row and require('src.mods.Merge').deepCopy(row)end
+ function out:id(kind,name)local row=self[kind];return row and row.byName[name]end
+ function out:name(kind,id)local row=self[kind];return row and row.byId[id]end
+ return out
+end
+C.active=function(session)
+ if session~=nil then
+  local record=require('src.compat.gen1.SessionView').record(session)
+  local game=Native.game()
+  assert(record and record:valid()and record.owner==game
+   and session==require('src.core.Game3').forNative(game).session,'foreign or retired native constant session')
+ end
+ return C.of()
+end
+return C
diff --git a/src/core/game3/dataset.lua b/src/core/game3/dataset.lua
new file mode 100644
index 000000000..2835a4df7
--- /dev/null
+++ b/src/core/game3/dataset.lua
@@ -0,0 +1,52 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Read imported artifacts through the native cache filesystem. Hydration,
+-- importing and save writes remain with the native data/session owners.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local CacheFs=require('src.import.CacheFs')
+local D={}
+local records=setmetatable({},{__mode='k'})
+local current,currentHandle
+local function retire(c)c.retired=true;c.game,c.data,c.root=nil,nil,nil end
+local function valid(c)
+ local game=Native.game()
+ if c.retired then return false end
+ if game~=c.game or not game or game.data~=c.data or Version.get()~=c.edition or CacheFs.root()~=c.root then
+  retire(c);return false
+ end
+ return true
+end
+local function path(value)
+ if type(value)~='string'or#value>512 or value:find('[%c\\:]')or value:find('..',1,true)
+  or value:find('//',1,true)then return nil end
+ if not(value:match('^data/generated/[%w_./%-]+$')or value:match('^assets/generated/[%w_./%-]+$'))then return nil end
+ return value
+end
+function D.cache()
+ local game=Native.game();local data=game and game.data;local edition=Version.get();local root=CacheFs.root()
+ if current and current.game==game and current.data==data and current.edition==edition and current.root==root and not current.retired then
+  return currentHandle
+ end
+ if current then retire(current)end
+ local c={game=game,data=data,edition=edition,root=root,prefix=Version.cachePrefix()}
+ local h={};records[h]=c;current,currentHandle=c,h
+ function h:read(name)
+  local relative=path(name)
+  if not relative then return nil,'invalid imported artifact path'end
+  if not valid(c)then return nil,'native imported artifact cache retired'end
+  local bytes,why=CacheFs.dataFs().read(c.prefix..relative)
+  return type(bytes)=='string'and bytes or nil,why
+ end
+ function h:exists(name)
+  local relative=path(name)
+  if not relative or not valid(c)then return false end
+  local info=CacheFs.dataFs().getInfo(c.prefix..relative,'file')
+  return info~=nil and info.type=='file'
+ end
+ return h
+end
+D._service={release=function()
+ for _,c in pairs(records)do retire(c)end;current,currentHandle=nil,nil
+end,poll=function()for _,c in pairs(records)do valid(c)end end}
+require('src.core.game3.asset_stream').register(D._service)
+return D
diff --git a/src/core/game3/dex.lua b/src/core/game3/dex.lua
new file mode 100644
index 000000000..8debe1ef5
--- /dev/null
+++ b/src/core/game3/dex.lua
@@ -0,0 +1,15 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Views=require('src.compat.gen1.SessionView')
+local Ids=require('src.compat.gen1.BattleIds')
+local D={}
+local function query(dex,species,seen)
+  local g,s=Views.store(dex,'dex');if not g then return false end
+  local key=Ids.new(g.data):native('pokemon',species)
+  if not key then return false end
+  if seen then return not not(s.pokedex and s.pokedex.seen and s.pokedex.seen[key])end
+  return require('src.battle.CaughtMarker').caught(g,key)
+end
+function D.isCaught(dex,species)return query(dex,species,false)end
+D.isOwned=D.isCaught
+function D.isSeen(dex,species)return query(dex,species,true)end
+return D
diff --git a/src/core/game3/display.lua b/src/core/game3/display.lua
new file mode 100644
index 000000000..89a33cca0
--- /dev/null
+++ b/src/core/game3/display.lua
@@ -0,0 +1,50 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- GBA logical surface fitting and one borrowed native frame-paint boundary.
+-- No new game/render loop, render-target allocation or resource ownership.
+local Renderer=require('src.render.Renderer')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local Scope=require('src.render.GraphicsScope')
+local Version=require('src.core.GameVersion')
+local M={W=240,H=160,TILE=8,COLS=30,ROWS=20}
+local current
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+function M.fit(w,h)
+ local r=Renderer:surfaceRects(M.W,M.H,w,h)
+ return r.Ux,r.uox,r.uoy,r.uvpw,r.uvph,r.Uy
+end
+local function present(game)
+ if not current or game==nil or require('src.core.Game3').native(game)~=current.game then
+  return nil,'display presentation belongs to its native frame'
+ end
+ return Boundary.invoke('display.present')
+end
+M.present=present
+function M._nativePresent(game,paint,...)
+ if M.present==present then return paint(game,...)end
+ if current then return false,'native display frame is already painting'end
+ local G=require('src.core.Game3');local view=G.forNative(game)
+ if not view then return paint(game,...)end
+ local args=pack(...)
+ local cohort={game=game,data=game.data,save=game.save,loader=game.mods,stack=game.stack,
+  edition=Version.get(),top=game.stack:top(),states=game.stack.states,count=#game.stack.states}
+ current=cohort
+ local result=pack(pcall(Scope.call,function()
+  return Boundary.dispatch('display.present',function()
+   if game.data~=cohort.data or game.save~=cohort.save or game.mods~=cohort.loader
+      or game.stack~=cohort.stack or G.native(view)~=game
+      or Version.generation()~=3 or Version.get()~=cohort.edition
+      or game.stack:top()~=cohort.top or game.stack.states~=cohort.states
+      or #game.stack.states~=cohort.count then
+    return false,'native display cohort changed'
+   end
+   return paint(game,unpack(args,1,args.n))
+  end,function()return Call.call(M,'present',view)end)
+ end))
+ current=nil
+ if not result[1]then error(result[2],0)end
+ if not result[2]then error(result[3],0)end
+ return unpack(result,3,result.n)
+end
+return M
diff --git a/src/core/game3/doors.lua b/src/core/game3/doors.lua
new file mode 100644
index 000000000..793ee13de
--- /dev/null
+++ b/src/core/game3/doors.lua
@@ -0,0 +1,40 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe the native Petalburg slide and paint its actual resident metatiles.
+-- General cartridge door sheets and mod-started door tasks are separate APIs.
+local Native=require('src.compat.gen1.NativeSession')
+local Identity=require('src.compat.gen1.MapIdentity')
+local Version=require('src.core.GameVersion')
+local Scope=require('src.render.GraphicsScope')
+local M={}
+local function current(mapId,x,y)
+ local game,world=Native.resolve()
+ local slide=world and world.gymDoorSlide
+ if not(slide and slide.mapId==world.map.id)then return end
+ local canonical=Identity.bind(game.data.maps,Version.get()):legacyId(slide.mapId)
+ if not canonical or mapId~=nil and mapId~=canonical and mapId~=slide.mapId then return end
+ local P=require('src.script.Gen3Commands').PETALBURG_DOORS
+ for _,cell in ipairs(P.ROOMS[slide.room]or{})do
+  if(x==nil or x==cell[1])and(y==nil or y==cell[2])then
+   return{mapId=canonical,x=cell[1],y=cell[2],frame=math.max(0,math.min(4,slide.step-1))/2,
+    nativeFrame=math.max(0,slide.step-1),kind='sliding',timer=slide.timer,opening=true},world
+  end
+ end
+end
+function M.getActiveAnim(mapId,x,y)local pose=current(mapId,x,y);return pose end
+function M.isBusy()return current()~=nil end
+function M.draw(camX,camY)
+ local pose,world=current()
+ local renderer=world and world.map.renderer
+ if not(renderer and renderer.drawMapOnly and renderer.drawAbove)then return false end
+ camX,camY=camX or 0,camY or 0
+ local ok,why=Scope.call(function()
+  local g=love.graphics
+  if g.intersectScissor then g.intersectScissor(pose.x*16-camX,pose.y*16-camY,16,32)
+  else g.setScissor(pose.x*16-camX,pose.y*16-camY,16,32)end
+  renderer:drawMapOnly(camX,camY,64,32)
+  renderer:drawAbove(camX,camY,64,32)
+ end)
+ if not ok then error(why,0)end
+ return true
+end
+return M
diff --git a/src/core/game3/encounters.lua b/src/core/game3/encounters.lua
new file mode 100644
index 000000000..f3869c8e7
--- /dev/null
+++ b/src/core/game3/encounters.lua
@@ -0,0 +1,69 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Detached, numeric-ID observations of native encounter tables. No random
+-- draws, map loading, private cache installation or independent step rolls.
+local Native=require('src.compat.gen1.NativeSession')
+local Map=require('src.core.game3.map')
+local Ids=require('src.compat.gen1.BattleIds')
+local Encounter=require('src.world.Encounter')
+local M={}
+local function context()
+  local g=Native.game()
+  if g and type(g.data)=='table'and type(g.data.encounters)=='table'then return g end
+end
+function M.ensureLoaded()
+  local g=context()
+  return g~=nil and next(g.data.encounters)~=nil or false
+end
+function M.terrainAt(x,y)
+  local g,w=Native.resolve()
+  if not(g and type(x)=='number'and type(y)=='number'and x%1==0 and y%1==0
+      and w.map:inBounds(x,y))then return nil end
+  if require('src.world.Gen3FieldRules').isUnderwaterEncounter(w.map,x,y)
+      or w.map:isWaterCell(x,y)then return 'water'end
+  if w.map:isEncounterCell(x,y)then return 'land'end
+end
+local function area(value,ids)
+  if value==nil then return nil end
+  if type(value)~='table'or type(value.slots)~='table'then return nil,'invalid native encounter area'end
+  local out={rate=value.rate,slots={}}
+  for i,slot in ipairs(value.slots)do
+    local species=type(slot)=='table'and ids:read('pokemon',slot.species)
+    if not species then return nil,'native encounter species has no cartridge index'end
+    out.slots[i]={species=species,level=slot.level,minLevel=slot.min or slot.minLevel,
+      maxLevel=slot.max or slot.maxLevel}
+  end
+  return out
+end
+function M.tableFor(id)
+  local g=context();if not(g and type(id)=='string')then return nil end
+  local maps=Map._context(g);local def=maps and maps:definition(id)
+  local raw=def and g.data.maps[def.nativeId]
+  if not raw then return nil end
+  local native=Encounter.forMap(g.data,raw,def.nativeId,nil,g.save)
+  if not native then return nil end
+  local ids=Ids.new(g.data);local out={}
+  for _,names in ipairs{{'land','grass'},{'water','water'},{'rocks','rock'},{'fishing','fish'}}do
+    local row,why=area(native[names[2]],ids)
+    if why then return nil,why end
+    out[names[1]]=row
+  end
+  return out
+end
+function M.rollSweetScent(id,terrain)
+  local g,w=Native.resolve();if not g or(terrain~='land'and terrain~='water')then return nil end
+  local maps=Map._context(g);local def=maps and maps:definition(id)
+  if not def or def.nativeId~=w.map.id then return nil end
+  local enc,roaming=Encounter.sweetScent(g.data,g.save,w.map.def,w.map.id,terrain=='water',true)
+  if not enc then return nil end
+  local ids=Ids.new(g.data);local out={species=ids:read('pokemon',enc.species),level=enc.level,roamer=roaming~=nil}
+  if roaming then
+    local individual=require('src.world.Gen3Roamers').active(g.save)
+    out.personality=individual.personality
+    if individual.ivs then out.ivs={};for a,b in pairs{hp='hp',atk='attack',def='defense',spe='speed',spa='spatk',spd='spdef'}do out.ivs[a]=individual.ivs[b]end end
+    if(individual.hp or 0)>0 then out.hp=individual.hp end
+    out.status=require('src.compat.gen1.PokemonView').status(individual)
+  end
+  return out
+end
+M.table_for=M.tableFor
+return M
diff --git a/src/core/game3/enhancements.lua b/src/core/game3/enhancements.lua
new file mode 100644
index 000000000..519374d61
--- /dev/null
+++ b/src/core/game3/enhancements.lua
@@ -0,0 +1,21 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Features=require('src.mods.FeatureOptions')
+local E={attach=Features.attach,enabled=Features.enabled}
+function E.text(en,de)
+ local p=Features.provider('quickBall')or Features.provider('repelPrompt')or Features.provider('trainingDetails')or Features.provider('timedEncounters')
+ return p and Features.call(p,'language')=='de'and de or en
+end
+function E.encounterTable(mapId,source)
+ local g=require('src.compat.gen1.NativeSession').game();if not g then return source end
+ local maps=require('src.core.game3.map')._context(g);local def=maps and maps:definition(mapId)
+ if not def then return source end
+ local native=g.data.maps[def.nativeId]
+ if source and source.grass then return require('src.world.EncounterActivity').forMap(g.data,g.save,native,def.nativeId,source)end
+ local p=Features.provider('timedEncounters')
+ if not(p and source and source.land and Features.call(p,'outdoors',mapId)==true)then return source end
+ local out={};for k,v in pairs(source)do out[k]=v end
+ out.land=require('src.world.EncounterActivity').reweight(source.land,require('src.world.EncounterActivity').phase(Features.call(p,'time')),
+  require('src.core.game3.pokemon').national,g.data.constants.encounterActivity)
+ return out
+end
+return E
diff --git a/src/core/game3/evolution.lua b/src/core/game3/evolution.lua
new file mode 100644
index 000000000..94a2cd1f9
--- /dev/null
+++ b/src/core/game3/evolution.lua
@@ -0,0 +1,12 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local E={}
+function E.levelTarget(value,session)
+ local mon,g=require('src.compat.gen1.SourcePokemon').resolve(value)
+ if session then
+  local r=require('src.compat.gen1.SessionView').record(session)
+  assert(r and r:valid()and r.owner==g,'foreign evolution session')
+ end
+ local key=require('src.pokemon.Evolution').pendingFor(g,mon,{kind='levelup'})
+ return key and require('src.compat.gen1.BattleIds').new(g.data):read('pokemon',key)
+end
+return E
diff --git a/src/core/game3/field.lua b/src/core/game3/field.lua
new file mode 100644
index 000000000..9aa69178b
--- /dev/null
+++ b/src/core/game3/field.lua
@@ -0,0 +1,83 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Per-mod field leases share native input admission; no global lock is erased.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local F={}
+local cohort,leases
+local function context()
+ local g,w,p=Native.resolve();if not g then cohort,leases=nil,nil;return end
+ if not cohort or cohort.game~=g or cohort.world~=w or cohort.player~=p or cohort.map~=w.map
+   or cohort.save~=g.save or cohort.data~=g.data or cohort.loader~=g.mods or cohort.edition~=Version.get()then
+  cohort={game=g,world=w,player=p,map=w.map,save=g.save,data=g.data,loader=g.mods,edition=Version.get()};leases={}
+ end
+ return cohort
+end
+local function owner()
+ local runtime=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+ return runtime and runtime.currentMod or facade and facade._callbackOwner()
+end
+function F.lock(tag)
+ local c=context();local who=owner();if not(c and who)then return false end
+ tag=tag or'default';assert(type(tag)=='string'and#tag<=128,'invalid field lock tag')
+ leases[who]=leases[who]or{};leases[who][tag]=true;return true
+end
+function F.unlock(tag)
+ local c=context();local who=owner();if not(c and who)then return false end
+ local held=leases[who];if held then held[tag or'default']=nil;if not next(held)then leases[who]=nil end end
+ return true
+end
+function F._locked(game,world)
+ local c=context();return c~=nil and(not game or game==c.game)and(not world or world==c.world)and next(leases)~=nil
+end
+function F.interact()return Boundary.invoke('field.interact')end
+function F.flyDestination(section)
+ local c=context();if not c then return end
+ local maps=require('src.compat.gen1.NativeRegionMap')
+ if maps.active()then return maps.destination(section)end
+ return require('src.world.Gen3FlyTargets').destination(c.game,section)
+end
+function F.flyTo(section,mon,info)
+ if Boundary.active('field.flyTo')then return Boundary.invoke('field.flyTo')end
+ local c=context();if not c then return nil,'no active native field'end
+ -- Standalone requests retain the public native badge/move/visited/input
+ -- admission. A source caller cannot turn an observation into a teleport.
+ local dest=F.flyDestination(section)
+ if not dest then return nil,'destination unavailable'end
+ return require('src.world.WorldActions').flyTo(c.game,c.world,dest.map)
+end
+function F._dispatchFly(game,world,mapId,mon,spot,body)
+ local c=context();if not c or c.game~=game or c.world~=world then return body()end
+ local G=require('src.core.Game3');local view=G.forNative(game)
+ local sourceMon
+ if mon then for i,raw in ipairs(game.save.party or{})do if raw==mon then sourceMon=view.session.party[i];break end end end
+ local def=game.data.maps[mapId]
+ local section=def and tonumber(def.regionMapSection)
+ local dest=require('src.world.Gen3FlyTargets').detached(game,mapId,spot)
+ return Boundary.dispatch('field.flyTo',body,function()
+  return require('src.compat.gen1.SourceCall').call(F,'flyTo',section,sourceMon,{dest=dest})
+ end)
+end
+function F._dispatch(game,world,body)
+ local c=context();if not c or c.game~=game or c.world~=world then return body()end
+ return Boundary.dispatch('field.interact',body,function(...)return require('src.compat.gen1.SourceCall').call(F,'interact',...)end,require('src.core.Game3').forNative(game))
+end
+local service={release=function()cohort,leases=nil,nil end,
+ releaseOwner=function(_,who)if leases then leases[who]=nil end end,
+ poll=function()if cohort then context()end end}
+require('src.core.game3.asset_stream').register(service)
+F._service=service
+setmetatable(F,{__index=function(_,k)
+ if k=='locked'then return F._locked()end
+ if k=='_game'then local c=context();return c and require('src.core.Game3').forNative(c.game)end
+ if k=='_flyLanding'then
+  local arrival=package.loaded['src.world.Gen3FlyArrival'];return arrival and arrival.landing()or false
+ end
+ end,
+ __newindex=function(t,key,value)
+  if key=='locked'then
+   assert(type(value)=='boolean','invalid field lock')
+   if value then F.lock()else local c=context();local who=owner();if c and who then leases[who]=nil end end
+  else rawset(t,key,value)end
+ end})
+return F
diff --git a/src/core/game3/field_effects.lua b/src/core/game3/field_effects.lua
new file mode 100644
index 000000000..7870833af
--- /dev/null
+++ b/src/core/game3/field_effects.lua
@@ -0,0 +1,44 @@
+-- Field artwork resources. Native effect tasks and phase observations are
+-- separate contracts; no empty animation lists or substitute clocks here.
+local Runtime=require('src.compat.gen1.FieldEffectRuntime')
+local Assets=require('src.render.Assets')
+local Stream=require('src.core.game3.asset_stream')
+local service=Runtime.new()
+local F={}
+Stream.register(service)
+Assets.register(function()service:invalidate()end)
+function F.collectActors(actors,camX,camY)
+  local boundary=require('src.compat.gen1.ScriptBoundary')
+  if boundary.active('field.collectActors')then return boundary.invoke('field.collectActors')end
+  return require('src.compat.gen1.SourceActors').collect(actors)
+end
+function F.startFlyIn()return require('src.world.Gen3FlyArrival').resume()end
+local baseCollect=F.collectActors
+function F._hasActorExtensions()return F.collectActors~=baseCollect end
+function F.install(cache)return service:install(cache)end
+function F.invalidate()service:invalidate()end
+function F.release()
+ service:release()
+ local arrival=package.loaded['src.world.Gen3FlyArrival'];if arrival then arrival.release()end
+end
+function F.cancelOwner(who)service:releaseOwner(who)end
+function F.manifest()return service:manifest()end
+function F.manifestObject(name)
+  local manifest,why=F.manifest();if not manifest then return nil,why end
+  return manifest._byName[name]
+end
+function F.loadSheet(name)return service:get(name)end
+F.getSpriteSheet=F.loadSheet
+setmetatable(F,{__index=function(_,key)
+  if key=='_cache'then local c=service:current();return c and c.provider and c.provider.cache end
+  if key=='_sheets'then service:current();return service.loaded end
+  if key=='_manifest'then return F.manifest()end
+end,__newindex=function(t,key,value)
+  if key=='_cache'then return F.install(value)end
+  if key=='_sheets'then
+    assert(type(value)=='table'and next(value)==nil,'field sheet cache replacement must be empty')
+    return F.invalidate()
+  end
+  rawset(t,key,value)
+end})
+return F
diff --git a/src/core/game3/field_move_show_mon.lua b/src/core/game3/field_move_show_mon.lua
new file mode 100644
index 000000000..03306c53b
--- /dev/null
+++ b/src/core/game3/field_move_show_mon.lua
@@ -0,0 +1,76 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source phases over the engine's actual field-move StateStack admission.
+local Runtime=require('src.compat.gen1.FieldMoveRuntime')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local runtime=Runtime.new()
+local S={}
+local observers={}
+local function call(name,...)
+  local facade=package.loaded['src.core.Game3'];local seams=package.loaded['src.mods.ModSeams'];local who
+  for i=#(seams and seams._journal or{}),1,-1 do
+    local v=seams._journal[i];if v.tbl==S and v.key==name and v.after==S[name]then who=v.owner;break end
+  end
+  if facade and facade._withCallbackOwner then return facade._withCallbackOwner(who or facade._callbackOwner(),S[name],...)end
+  return S[name](...)
+end
+function S.start(mon,opts,callback)
+  if Boundary.active('field_move.start')then
+    local c=runtime.starting;local ok,why=runtime:configure(c,mon,opts,callback)
+    if ok then Boundary.invoke('field_move.start')end
+    return ok,why
+  end
+  return runtime:start(mon,opts,callback)
+end
+function S.isActive()return runtime:current()~=nil end
+function S.step()return Boundary.invoke('field_move.step')end
+function S.draw()
+  if Boundary.active('field_move.draw')then return Boundary.invoke('field_move.draw')end
+  local c=runtime:current();if not c or not c.state:valid(false)then return false end
+  local result=c.state:drawExternal();c.manualDrawn=not c.state.externalDrawSerial;return result
+end
+function S.reset()return runtime:reset()end
+function S.invalidate()
+  local c=runtime:current();if not c then return true end
+  return c.state:reloadArtwork()
+end
+function S._observeMod(who)if type(who)=='string'then observers[who]=true end end
+function S.release()runtime:release();observers={}end
+function S.cancelOwner(who)observers[who]=nil;return runtime:cancelOwner(who)end
+function S._nativeOptions(game)
+  local host=package.loaded['src.mods.Runtime'];local exports=game.mods and game.mods.exports or{}
+  local active=false
+  for who in pairs(observers)do if exports[who]or host and host.currentMod==who then active=true;break end end
+  if not active then return end
+  local f=package.loaded['src.core.game3.field_effects']
+  if require('src.compat.gen1.NativeSession').game()==game and f and f._cache
+      or game.data.constants and game.data.constants.gen3FieldMovePresentation then return{presentation='cartridge',pose=true}end
+end
+function S._nativeStart(state)
+  local c=runtime:bind(state);if not c then return end
+  if c.sourceStarted then return true end
+  local previous=runtime.starting;runtime.starting=c
+  local ok,why=pcall(runtime.phase,runtime,c,'start',function()return true end,function()
+    return call('start',state.mon,{pose=state.poseInstalled==true,noDuck=state.options.noDuck},c.continue)
+  end)
+  runtime.starting=previous
+  if not ok then error(why,0)end
+  return why
+end
+function S._nativeStep(state,body)
+  local c=runtime:bind(state);if not c then return body()end
+  c.manualDrawn=false
+  return runtime:phase(c,'step',body,function()return call('step')end)
+end
+function S._nativeDraw(state,body)
+  local c=runtime:bind(state);if not c then return body()end
+  if c.manualDrawn then c.manualDrawn=false;return true end
+  return runtime:phase(c,'draw',body,function()return call('draw')end)
+end
+local service={release=S.release,releaseOwner=function(_,who)return S.cancelOwner(who)end,poll=function()
+ local stale={};for state in pairs(runtime.records)do if not state:cohortCurrent()then stale[#stale+1]=state end end
+ for _,state in ipairs(stale)do state:retire()end
+end}
+require('src.core.game3.asset_stream').register(service);S._service=service
+function S._nativeExit(state)runtime:exit(state)end
+setmetatable(S,{__index=function(_,key)if key=='_fx'then return runtime:snapshot()end end})
+return S
diff --git a/src/core/game3/field_moves.lua b/src/core/game3/field_moves.lua
new file mode 100644
index 000000000..e77316054
--- /dev/null
+++ b/src/core/game3/field_moves.lua
@@ -0,0 +1,34 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Source=require('src.compat.gen1.SourcePokemon')
+local Actions=require('src.world.WorldActions')
+local F={}
+local function moveKey(game,value)
+ local key=Ids.new(game.data):native('moves',value)
+ return key or type(value)=='string'and value:upper():gsub(' ','_')or nil
+end
+function F.hasBadge(ctx,badge)
+ local g=Native.game();if not(g and g.save)then return false end
+ local key=moveKey(g,badge);local gate=(g.data.constants.gen3FieldMoves or{})[key]
+ if not(gate and gate.badgeFlag)then return true end
+ return g.save.flags and g.save.flags[('FLAG_G3_%04X'):format(gate.badgeFlag)]==true or false
+end
+function F.partyMoveUser(party,move,ctx)
+ local g,w=Native.resolve();if not g then return nil,6 end
+ local key=moveKey(g,move);if not key then return nil,6 end
+ local mon=w.partyKnows and w:partyKnows(key)
+ if not mon then return nil,6 end
+ for i,value in ipairs(party or{})do
+  local raw,known=Source.resident(value)
+  if known and raw==mon then return value,i-1 end
+ end
+ return nil,6
+end
+function F.fromMenu(move,ctx)
+ local g,w=Native.resolve();if not g then return{ok=false,text='No active field.'}end
+ local key=moveKey(g,move);if not key then return{ok=false,text='Unknown field move.'}end
+ local ok,why=Actions.useFieldAction(g,w,key:lower())
+ return{ok=ok==true,text=why}
+end
+return F
diff --git a/src/core/game3/field_weather.lua b/src/core/game3/field_weather.lua
new file mode 100644
index 000000000..f6199f3cc
--- /dev/null
+++ b/src/core/game3/field_weather.lua
@@ -0,0 +1,16 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe the native resolved field weather, including the native cycle stage.
+local Native=require('src.compat.gen1.NativeSession')
+local Weather=require('src.world.Gen3Weather')
+local M={}
+function M.getWeather()
+ local game,world=Native.resolve()
+ if not game then return nil end
+ local name=world:fieldWeather()
+ local resolved=name and Weather.resolve(name,world.weatherFrame or 0,game.save.gen3WeatherStage or 0)
+ local names=game.data.constants and game.data.constants.gen3WeatherNames or require('src.core.Gen3WeatherIds').names
+ for id,value in pairs(names or{})do
+  if value==resolved and type(id)=='number'and id%1==0 and id>=0 then return id end
+ end
+end
+return M
diff --git a/src/core/game3/forced_movement.lua b/src/core/game3/forced_movement.lua
new file mode 100644
index 000000000..2a2750939
--- /dev/null
+++ b/src/core/game3/forced_movement.lua
@@ -0,0 +1,23 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Classify the existing semantic terrain IDs. Native controllers retain
+-- all forced steps, collision, facing, sound and script continuations.
+local Version=require('src.core.GameVersion')
+local MB=require('src.compat.gen1.MetatileBehavior')
+local common={}
+for name in ('WALK_EAST WALK_WEST WALK_NORTH WALK_SOUTH SLIDE_EAST SLIDE_WEST SLIDE_NORTH SLIDE_SOUTH TRICK_HOUSE_PUZZLE_8_FLOOR EASTWARD_CURRENT WESTWARD_CURRENT NORTHWARD_CURRENT SOUTHWARD_CURRENT WATERFALL ICE'):gmatch('%S+')do
+ common[MB.require(name)]=true
+end
+local rse,frlg={},{}
+for key in pairs(common)do rse[key],frlg[key]=true,true end
+for name in ('MUDDY_SLOPE CRACKED_FLOOR SECRET_BASE_JUMP_MAT SECRET_BASE_SPIN_MAT'):gmatch('%S+')do rse[MB.require(name)]=true end
+for name in ('SPIN_RIGHT SPIN_LEFT SPIN_UP SPIN_DOWN'):gmatch('%S+')do frlg[MB.require(name)]=true end
+local M={}
+function M.isRse()
+ local edition=Version.get();return edition=='emerald'or edition=='ruby'or edition=='sapphire'
+end
+function M.isForcedMovementTile(behavior)
+ if type(behavior)~='number'or behavior%1~=0 then return false end
+ local set=M.isRse()and rse or Version.isFRLG()and frlg
+ return set and set[behavior]==true or false
+end
+return M
diff --git a/src/core/game3/gba_fx.lua b/src/core/game3/gba_fx.lua
new file mode 100644
index 000000000..eb2398e29
--- /dev/null
+++ b/src/core/game3/gba_fx.lua
@@ -0,0 +1,141 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native five-bit colour arithmetic over an existing draw callback. Alpha
+-- reuses the native underlay snapshot and executes the callback exactly once.
+local Scope=require('src.render.GraphicsScope')
+local Alpha=require('src.render.NativeGbaAlpha')
+local F={WHITE={31,31,31},BLACK={0,0,0}}
+F.SOURCE=[[
+extern Image nativeGbaUnderlay;
+extern vec2 nativeGbaSurfacePixels;
+extern vec2 nativeGbaCoefficients;
+extern vec4 gbaFxFade;
+extern vec4 gbaFxControls; // gray, brightness, alpha enabled, target density
+extern vec2 gbaFxBand;
+extern Image gbaFxMask;
+extern vec4 gbaFxWindow;
+extern vec2 gbaFxWindowControl;
+vec4 effect(vec4 tint, Image texture, vec2 uv, vec2 screen) {
+ vec4 pixel=Texel(texture,uv);
+ if(pixel.a<0.5)discard;
+ vec3 value=floor(clamp(pixel.rgb,0.0,1.0)*31.0+0.5);
+ if(gbaFxControls.x>0.5){
+  float gray=floor(dot(value,vec3(76.0,151.0,29.0))/256.0);
+  float shade=0.0;
+  if(gray>=30.0)shade=31.0;
+  else if(gray>=25.0)shade=27.0;
+  else if(gray>=20.0)shade=21.0;
+  else if(gray>=15.0)shade=16.0;
+  else if(gray>=10.0)shade=11.0;
+  else if(gray>=5.0)shade=5.0;
+  value=vec3(shade);
+ }
+ value+=floor((gbaFxFade.rgb-value)*gbaFxFade.a);
+ vec2 point=screen/gbaFxControls.w;
+ float brightness=gbaFxControls.y;
+ if(gbaFxBand.x>0.5)brightness=max(0.0,15.0-abs(floor(point.y)-gbaFxBand.y))/16.0;
+ if(gbaFxWindowControl.x>0.5){
+  vec2 mask=(point-gbaFxWindow.xy)/gbaFxWindow.zw;
+  if(mask.x>=0.0&&mask.y>=0.0&&mask.x<1.0&&mask.y<1.0&&Texel(gbaFxMask,mask).a>0.5)
+   brightness=gbaFxWindowControl.y;
+ }
+ value+=floor((vec3(31.0)-value)*brightness);
+ if(gbaFxControls.z>0.5){
+  vec3 under=floor(clamp(Texel(nativeGbaUnderlay,screen/nativeGbaSurfacePixels).rgb,0.0,1.0)*31.0+0.5);
+  value=min(vec3(31.0),floor((value*nativeGbaCoefficients.x+under*nativeGbaCoefficients.y)/16.0));
+  return vec4(value/31.0,1.0);
+ }
+ return vec4(value/31.0,tint.a);
+}
+]]
+local pool,depth,retiring={},0,false
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function finite(n)return type(n)=='number'and n==n and n~=math.huge and n~=-math.huge end
+local function coefficient(value)
+ value=value or 0;assert(finite(value),'invalid GBA colour coefficient')
+ return math.max(0,math.min(16,math.floor(value)))
+end
+local function parameters(fx,blend)
+ assert(fx==nil or fx==false or type(fx)=='table','GBA effects must be a table')
+ assert(blend==nil or blend==false or type(blend)=='table','GBA blend must be a table')
+ fx=fx or{}
+ local color=fx.color or F.BLACK
+ assert(type(color)=='table','GBA fade colour must have three channels')
+ for i=1,3 do assert(finite(color[i])and color[i]%1==0 and color[i]>=0 and color[i]<=31,'invalid GBA fade channel')end
+ assert(fx.gray==nil or type(fx.gray)=='boolean','GBA grayscale must be a boolean')
+ assert(fx.band==nil or finite(fx.band),'invalid GBA brightness band')
+ local win=fx.objWin
+ if win then
+  assert(type(win)=='table'and win.image and finite(win.x)and finite(win.y)
+   and finite(win.w)and win.w>0 and finite(win.h)and win.h>0,'invalid GBA object window')
+ end
+ return{color=color,y=coefficient(fx.y),gray=fx.gray==true,bldy=coefficient(fx.bldy),band=fx.band,
+  win=win,winBldy=win and coefficient(win.bldy)or 0,
+  blend=not not blend,eva=blend and coefficient(blend.eva)or 0,evb=blend and coefficient(blend.evb)or 0}
+end
+function F.active(fx,blend)
+ return not not(blend or fx and((fx.y or 0)>0 or fx.gray or(fx.bldy or 0)>0 or fx.objWin or fx.band~=nil))
+end
+local function release()
+ if depth>0 then retiring=true;return end
+ for _,bank in pairs(pool)do bank.alpha:release();bank.blank:release()end
+ pool={};retiring=false
+end
+function F.draw(draw,fx,blend)
+ assert(type(draw)=='function','GBA effect painter must be callable')
+ local p=parameters(fx,blend)
+ if not F.active(fx,blend)then return draw()end
+ assert(depth<8,'GBA colour nesting limit exceeded')
+ depth=depth+1
+ local bank,values
+ local ok,why=Scope.call(function()
+  local g=love.graphics
+  bank=pool[depth]
+  if not bank then
+   local blank=g.newCanvas(1,1,{format='rgba8',dpiscale=1,msaa=0})
+   bank={alpha=Alpha.new(F.SOURCE),blank=blank};pool[depth]=bank
+  end
+  local function configure(shader)
+   local target=g.getCanvas();if type(target)=='table'and not target.getDimensions then target=target[1];if type(target)=='table'and not target.getDimensions then target=target[1]end end
+   local dpi=target and target.getDPIScale and target:getDPIScale()or g.getDPIScale and g.getDPIScale()or 1
+   shader:send('gbaFxFade',{p.color[1],p.color[2],p.color[3],p.y/16})
+   shader:send('gbaFxControls',{p.gray and 1 or 0,p.bldy/16,p.blend and 1 or 0,dpi})
+   shader:send('gbaFxBand',{p.band~=nil and 1 or 0,p.band or 0})
+   local w=p.win
+   shader:send('gbaFxWindow',w and{w.x,w.y,w.w,w.h}or{0,0,1,1})
+   shader:send('gbaFxWindowControl',{w and 1 or 0,p.winBldy/16})
+   shader:send('gbaFxMask',w and w.image or bank.blank)
+  end
+  local function paint()values=pack(draw())end
+  if p.blend then
+   local painted,reason=bank.alpha:paint(p.eva,p.evb,paint,configure)
+   if not painted then error(reason,0)end
+  else
+   local shader=bank.alpha:program();configure(shader)
+   shader:send('nativeGbaUnderlay',bank.blank)
+   g.setShader(shader);paint()
+  end
+ end)
+ -- Never keep a borrowed object-window image alive in a cached uniform.
+ local detached,detachError=true
+ if bank and bank.alpha.shader then detached,detachError=pcall(bank.alpha.shader.send,bank.alpha.shader,'gbaFxMask',bank.blank)end
+ depth=depth-1
+ if depth==0 and retiring then release()end
+ if not ok then error(why,0)end
+ if not detached then error(detachError,0)end
+ return unpack(values,1,values.n)
+end
+function F.withClip(clip,draw)
+ assert(type(draw)=='function','GBA clip painter must be callable')
+ if not clip then return draw()end
+ for _,key in ipairs{'x','y','w','h'}do assert(finite(clip[key]),'invalid GBA clip rectangle')end
+ local result=pack(Scope.call(function()
+  love.graphics.intersectScissor(clip.x,clip.y,math.max(0,clip.w),math.max(0,clip.h))
+  return draw()
+ end))
+ if not result[1]then error(result[2],0)end
+ return unpack(result,2,result.n)
+end
+F._service={release=release,releaseOwner=release}
+require('src.core.game3.asset_stream').register(F._service)
+return F
diff --git a/src/core/game3/item_use.lua b/src/core/game3/item_use.lua
new file mode 100644
index 000000000..c0cf96dff
--- /dev/null
+++ b/src/core/game3/item_use.lua
@@ -0,0 +1,20 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Field item requests share the native effect and inventory transaction.
+local U={}
+function U.useField(session,bag,id,target)
+ local g,save=require('src.compat.gen1.SessionView').store(bag,'bag')
+ local record=require('src.compat.gen1.SessionView').record(session)
+ if not(g and record and record:valid()and record.owner==g)then return false,false end
+ local key=require('src.compat.gen1.BattleIds').new(g.data):native('items',id)
+ if not key or(save.inventory[key]or 0)<1 then return false,false end
+ local mon
+ if target then mon=require('src.compat.gen1.SourcePokemon').resident(target);if not mon then return false,false end end
+ local kind,messages=require('src.inventory.ItemEffects').use(g.data,save,key,mon,nil,nil,require('src.compat.gen1.NativeSession').world(g))
+ if kind=='consumed'then
+  require('src.inventory.Bag').remove(save,key,1)
+  if key=='REPEL'or key=='SUPER_REPEL'or key=='MAX_REPEL'then require('src.ui.RepelPrompt').remember(save,key)end
+  return true,true,table.concat(messages or{},'\f')
+ end
+ return kind=='used',false,type(messages)=='table'and table.concat(messages,'\f')or nil
+end
+return U
diff --git a/src/core/game3/items_data.lua b/src/core/game3/items_data.lua
new file mode 100644
index 000000000..7c4d01f24
--- /dev/null
+++ b/src/core/game3/items_data.lua
@@ -0,0 +1,43 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Effects=require('src.inventory.ItemEffects')
+local I={}
+local function row(id)
+  local g=Native.game();if not(g and g.data)then return end
+  local ids=Ids.new(g.data);local key=ids:native('items',id)
+  return key and g.data.items[key],key,g,ids
+end
+function I.info(id)
+  local r,key,g,ids=row(id);if not r then return nil end
+  local pocket=({ITEM='ITEMS',BALL='POKE_BALLS',KEY_ITEM='KEY_ITEMS',BERRY='BERRIES'})[r.pocket]or r.pocket
+  return{id=ids:read('items',key),name=r.name,pocket=pocket,price=r.price,description=r.description,
+    holdEffect=r.gen3HoldEffect or r.holdEffect,holdEffectParam=r.holdEffectParam,
+    importance=r.importance,fieldUse=I.fieldUseKind(id)}
+end
+function I.isHm(id)local r=row(id);return r~=nil and r.machine~=nil and r.machine.kind=='HM'or false end
+function I.isTm(id)local r=row(id);return r~=nil and r.machine~=nil or false end
+function I.isEvolutionStone(id)
+  local r,key,g=row(id);if not r then return false end
+  if Effects.isStone(key)then return true end
+  for _,mon in pairs(g.data.pokemon or{})do for _,e in ipairs(mon.evolutions or{})do
+    if e.method=='ITEM'and(e.item==key or e.param==key)then return true end
+  end end
+  return false
+end
+function I.fieldUseKind(id)
+  local r,key,g=row(id);if not r then return 'none'end
+  if r.machine then return 'tm'end
+  if I.isEvolutionStone(id)then return 'evo'end
+  local effect=Effects.recordFor(key,g.data)
+  if key=='RARE_CANDY'or effect and effect.levelUp then return 'level'end
+  if effect and effect.ev then return 'vitamin'end
+  if effect and(effect.pp or effect.ppUp or effect.ppMax)then return 'pp'end
+  if effect and(effect.heal or effect.revive or effect.cures or effect.cureAll)then return 'medicine'end
+  if key=='ESCAPE_ROPE'then return 'escape'end
+  if tostring(key):find('REPEL',1,true)then return 'repel'end
+  return r.fieldUse or'none'
+end
+function I.displayName(id)local r=row(id);return r and r.name end
+function I.toNumericId(id)local r,key,g,ids=row(id);return r and ids:read('items',key)end
+return I
diff --git a/src/core/game3/mb.lua b/src/core/game3/mb.lua
new file mode 100644
index 000000000..1ae941ae6
--- /dev/null
+++ b/src/core/game3/mb.lua
@@ -0,0 +1,3 @@
+-- Share the existing canonical collision namespace and edition translators.
+-- Native behavior bytes, classification rules and map cells retain one owner.
+return require('src.compat.gen1.MetatileBehavior')
diff --git a/src/core/game3/mon_anim.lua b/src/core/game3/mon_anim.lua
new file mode 100644
index 000000000..cf18d74d6
--- /dev/null
+++ b/src/core/game3/mon_anim.lua
@@ -0,0 +1,85 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Mod-owned presentation players reuse the native procedural motions and
+-- imported frame strips. They never tick a battler or consume a command.
+local Session=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Motion=require('src.pokemon.MonAnim')
+local Pictures=require('src.pokemon.PicAnim')
+local Version=require('src.core.GameVersion')
+local M={nativeMotion=true}
+local records=setmetatable({},{__mode='k'})
+local function owner()
+  local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+  return host and host.currentMod or facade and facade._callbackOwner()
+end
+local function retire(c)
+  c.game,c.data,c.loader,c.motion,c.pictures,c.ids=nil,nil,nil,nil,nil,nil;c.stopped=true
+end
+local function valid(c)
+  if not c or c.stopped then return false end
+  if Session.game()~=c.game or c.game.data~=c.data or c.game.mods~=c.loader or Version.get()~=c.edition or not c.ids:valid()then retire(c);return false end
+  return true
+end
+function M.enabled()
+  local game=Session.game();local record=game and game.data and game.data.constants and game.data.constants.gen3MonAnim
+  return type(record)=='table'and type(record.anims)=='table'and next(record.anims)~=nil or false
+end
+function M.newSprite(species)
+  local game=Session.game();if not(game and game.data)then return nil,'no native Pokemon data'end
+  local ids=Ids.new(game.data);local key=ids:native('pokemon',species)
+  if not key then return nil,'unknown cartridge species'end
+  local sprite={frames=0}
+  records[sprite]={game=game,data=game.data,loader=game.mods,edition=Version.get(),key=key,owner=owner(),ids=ids}
+  return sprite
+end
+function M.summary(sprite,species,oneFrame)
+  local c=records[sprite];if not valid(c)then return nil,'native presentation player retired'end
+  if species~=nil and Ids.new(c.data):native('pokemon',species)~=c.key then return nil,'presentation species changed'end
+  c.motion=Motion.new(c.data,c.key)
+  if c.motion then c.motion:restart()end
+  c.pictures=not oneFrame and Pictures.new(c.data,c.key)or nil
+  if c.pictures then c.pictures:start()end
+  sprite.frames=0;return sprite
+end
+function M.step(sprite)
+  local c=records[sprite];if not valid(c)then return false,'native presentation player retired'end
+  if c.motion then c.motion:update(1/60)end
+  if c.pictures then c.pictures:update(1/60)end
+  sprite.frames=sprite.frames+1;return true
+end
+function M.done(sprite)
+  local c=records[sprite]
+  return not valid(c)or(not c.motion or not c.motion:active())
+    and(not c.pictures or c.pictures.paused or c.pictures.steps==nil)
+end
+function M.busy(sprite)return not M.done(sprite)end
+function M.stop(sprite)local c=records[sprite];if c then retire(c)end end
+function M.transform(sprite)
+  local c=records[sprite];local t=valid(c)and c.motion and c.motion:transform()or Motion.IDENTITY
+  local tint=t.tint;local color,coeff=0,0
+  if tint then
+    color=math.floor(tint[1]*31+.5)+math.floor(tint[2]*31+.5)*32+math.floor(tint[3]*31+.5)*1024
+    coeff=(tint[4]or 0)*16
+  end
+  return{x2=t.dx,y2=t.dy,sx=t.sx,sy=t.sy,rotation=t.rot,alpha=t.alpha,
+    invisible=t.alpha==0,frame=valid(c)and c.pictures and c.pictures:frame()or 0,
+    blendColor=color,blendCoeff=coeff}
+end
+function M.framePic(species,frame,shiny)
+  if type(frame)~='number'or frame%1~=0 or frame<=0 then return nil end
+  local game=Session.game();if not(game and game.data)then return nil end
+  local key=Ids.new(game.data):native('pokemon',species);if not key then return nil end
+  local mon={species=key,isShiny=shiny==true}
+  local record=Pictures.record(game.data,key,mon)
+  if shiny and record and not record.shinySheet then return nil,'native shiny frame strip unavailable'end
+  -- Borrow the native frame cache. Only its native owner may retire it.
+  local image=Pictures.frameImage(record,frame,mon)
+  if not image then return nil end
+  local w,h=image:getDimensions();return{image=image,w=w,h=h}
+end
+local service={release=function()for _,c in pairs(records)do retire(c)end end,
+  poll=function()for _,c in pairs(records)do valid(c)end end,
+  releaseOwner=function(_,who)for _,c in pairs(records)do if c.owner==who then retire(c)end end end}
+M._service=service
+require('src.core.game3.asset_stream').register(service)
+return M
diff --git a/src/core/game3/move_learn.lua b/src/core/game3/move_learn.lua
new file mode 100644
index 000000000..3d5a94657
--- /dev/null
+++ b/src/core/game3/move_learn.lua
@@ -0,0 +1,17 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Source=require('src.compat.gen1.SourcePokemon')
+local Ids=require('src.compat.gen1.BattleIds')
+local M={}
+function M.relearnableMoves(value)
+ local mon,g=Source.resolve(value);local d=g.data.pokemon[mon.species];local ids=Ids.new(g.data)
+ local known,seen,out={},{},{}
+ for _,m in ipairs(mon.moves or{})do known[m.id]=true end
+ local function add(key)
+  local n=ids:read('moves',key)
+  if n and not known[key]and not seen[key]then out[#out+1]=n;seen[key]=true end
+ end
+ for _,key in ipairs(d.level1Moves or{})do add(key)end
+ for _,row in ipairs(d.learnset or{})do if row.level<=mon.level then add(row.move)end end
+ return out
+end
+return M
diff --git a/src/core/game3/player.lua b/src/core/game3/player.lua
new file mode 100644
index 000000000..4c66cd2b9
--- /dev/null
+++ b/src/core/game3/player.lua
@@ -0,0 +1,158 @@
+-- Compatibility avatar operations on the live native actor. No second player,
+-- collision simulator, event runner or on-disk save writer lives here.
+local Session = require('src.compat.gen1.NativeSession')
+local runtime = require('src.compat.gen1.PlayerRuntime').new()
+local Player = {}
+local directions = {up={0,-1},down={0,1},left={-1,0},right={1,0}}
+local direct = {}
+for name in ('cellX cellY px py facing moving progress targetX targetY turnTimer turnArmed animClock running surfing fishing spinning moveDir facingLocked'):gmatch('%S+') do direct[name]=name end
+direct.currentElevation='elevation'; direct.elevation='elevation'
+direct.walkInPlace='compatWalkInPlace';direct.walkInPlaceFast='compatWalkInPlaceFast'
+local function owner(game)
+  local c=runtime:scope()
+  if not game and c then game=c.game end
+  return Session.resolve(game)
+end
+local function inputOwner(game)
+  local g,w,p=owner(game)
+  if not g or not Session.acceptsInput(g,w,p) then return nil,'native field input is locked' end
+  return g,w,p
+end
+local function finite(n)return type(n)=='number' and n==n and math.abs(n)<math.huge end
+local function withDirection(dir,run,input)
+  return setmetatable({isDown=function(_,key)
+    if directions[key] then return key==dir end
+    if key=='b' and run~=nil then return run==true end
+    return input and input.isDown and input:isDown(key) or false
+  end,wasPressed=function()return false end,wasReleased=function()return false end},{__index=input})
+end
+function Player.tick(game)return runtime:tick(game)end
+function Player.update(game,input)
+  Player.tick(game)
+  return runtime:input(input)
+end
+local baseUpdate=Player.update
+function Player._dispatch(game,world,input)
+  -- Mere imports do not change ordinary native gameplay. A source wrapper
+  -- opts into this phase by wrapping the established update entry point.
+  if Player.update==baseUpdate then return false end
+  local g,w,p=owner(game)
+  if g~=game or w~=world or not Session.acceptsInput(g,w,p) then return false end
+  local facade=package.loaded['src.core.Game3']
+  facade=type(facade)=='table' and type(facade.forNative)=='function' and facade.forNative(game) or game
+  runtime:run(game,world,facade,input,Player.update)
+  return true
+end
+function Player.tryMove(dir,game,run,input)
+  if not directions[dir] then return nil end
+  local g,w=inputOwner(game);if not g then return nil,w end
+  local c=runtime:scope()
+  if not c then return nil,'movement input belongs to the native fixed-step phase' end
+  -- The real controller retains its ledges, gates, bikes, collision warps,
+  -- sound and movement hooks; translating its input preserves those owners.
+  c.inputPolled=false
+  return runtime:input(withDirection(dir,run,input or g.input))
+end
+function Player.fieldTriggers(game,dir)
+  if not directions[dir] then return nil end
+  local g,w,p=inputOwner(game);if not g or p.moving or p.facing~=dir then return nil end
+  for _,name in ipairs({'checkGen3ArrowWarp','checkEdgeExit','checkLedgeHop','checkBoulderPush','checkGen3Gate'})do
+    if w[name] and w[name](w,dir) then return true end
+  end
+  return false
+end
+function Player.forcedStep(dir,frames,opts)
+  local delta=directions[dir];if not delta then return false end
+  local g,w,p=inputOwner();if not g or p.moving then return false end
+  local c=runtime:scope()
+  if not c or c.advanced then return false end
+  opts=opts or {};frames=frames or p.stepFrames or 16
+  if not finite(frames) or frames<1 or frames%1~=0 then return false end
+  if (opts.ledgeX~=nil or opts.ledgeY~=nil) then
+    -- Native ledge geometry/animation belongs to the native field handler.
+    return w.checkLedgeHop and w:checkLedgeHop(dir) or false
+  end
+  if not opts.keepFacing then p.facing=dir end
+  p.moveDir=dir;p.targetX=p.cellX+delta[1];p.targetY=p.cellY+delta[2]
+  p.moving=true;p.progress=0;p.stepFramesCur=frames;p.bumpFrames=nil
+  return true
+end
+function Player.setVisible(visible)
+  local g,_,p=owner();if not g then return false end
+  p.visible=visible~=false;p.hidden=not p.visible
+  return true
+end
+function Player.isVisible()
+  local g,_,p=owner();return g and not(p.hidden or p.invisible or p.visible==false) or false
+end
+function Player.syncSavePosition(game)
+  local g,w,p=owner(game);if not(g and g.save and g.save.player)then return false end
+  local saved=g.save.player
+  saved.map,saved.x,saved.y,saved.facing=w.map.id,p.cellX,p.cellY,p.facing
+  saved.surfing=p.surfing==true
+  return true -- in-memory native state only; persistence remains SaveIO's job
+end
+function Player.runningDisallowed(x,y)
+  local g,w=owner();if not g then return true end
+  return not(w.map.def and w.map.def.allowRunning)
+    or (w.map.runningBlockedAt and w.map:runningBlockedAt(x,y)) or false
+end
+function Player.canDash()
+  local g,w,p=owner();if not g or p.surfing or w.map.def.mapType=='UNDERWATER' then return false end
+  return w.runFrames and w:runFrames(true)~=nil or false
+end
+function Player.walkPhase()
+  local g,_,p=owner();return g and p:walkPhase() or 0
+end
+function Player.runPose()
+  local g,_,p=owner()
+  if not g or not(p.moving and p.running)or(g.save and g.save.onBike)or p.surfing or(p.hopFrames or 0)>0 then return nil end
+  return p:walkPhase()
+end
+function Player.drawFlip()
+  local g,_,p=owner();return g and math.floor((p.animClock or 0)/16)%2==1 or false
+end
+function Player.startFieldMove(duration,kind)return require("src.compat.gen1.PlayerPose").start(duration,kind)end
+function Player.release()runtime:release()end
+-- Title/intro presentation can inspect the pending native spawn before a
+-- world actor exists. Read its saved cells; all writes and motion still need
+-- an admitted player. No fabricated avatar or independent boot position.
+local function pendingPosition(key)
+  local g=Session.game();local saved=g and g.save and g.save.player
+  local def=saved and g.data and g.data.maps and g.data.maps[saved.map]
+  if not def or not finite(saved.x)or not finite(saved.y)
+    or saved.x%1~=0 or saved.y%1~=0 or saved.x<0 or saved.y<0
+    or(type(def.width)=='number'and saved.x>=def.width)
+    or(type(def.height)=='number'and saved.y>=def.height)then return nil end
+  if key=='px'then return saved.x*16 end
+  if key=='py'then return saved.y*16 end
+  if key=='cellX'then return saved.x end
+  if key=='cellY'then return saved.y end
+  if key=='facing'then return saved.facing end
+end
+setmetatable(Player,{
+  __index=function(_,key)
+    local g,w,p=owner();if key=="running"then return g~=nil and p.running==true end
+    if not g then return pendingPosition(key)end
+    if direct[key]then return p[direct[key]]end
+    if key=='stepFrames'then return p.stepFramesCur or p.stepFrames end
+    if key=='biking'then return g.save and g.save.onBike==true end
+    if key=='bikeType'then return p.acroBike and 'acro' or(g.save and g.save.bikeType)end
+    if key=='underwater'then return w.map.def.mapType=='UNDERWATER'end
+    if key=='jumping'then return (p.hopFrames or 0)>0 end
+    if key=='visible'then return Player.isVisible()end
+    if key=='fieldMoveAnim'then return p.fieldMove and(p.fieldMoveFrames or 1)or 0 end
+    if key=='stepSerial'or key=='prevCellX'or key=='prevCellY'then return runtime:record(p)[key]end
+  end,
+  __newindex=function(t,key,value)
+    if not(direct[key]or key=='stepFrames'or key=='biking'or key=='visible')then rawset(t,key,value);return end
+    local g,_,p=owner();if not g then error('no active native player for '..key,2)end
+    if type(value)=='number' and not finite(value)then error('non-finite player '..key,2)end
+    if direct[key]then p[direct[key]]=value
+    elseif key=='stepFrames'then
+      assert(finite(value)and value>=1 and value%1==0,'invalid player step frames');p.stepFramesCur=value
+    elseif key=='biking'then g.save.onBike=value==true
+    elseif key=='visible'then Player.setVisible(value)end
+  end,
+})
+return Player
diff --git a/src/core/game3/pokecenter_heal.lua b/src/core/game3/pokecenter_heal.lua
new file mode 100644
index 000000000..1e57e1952
--- /dev/null
+++ b/src/core/game3/pokecenter_heal.lua
@@ -0,0 +1,16 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native healing keeps its task, sound and continuation; these are sprite reads.
+local Native=require('src.compat.gen1.NativeSession')
+local Presentation=require('src.world.Gen3HealingPresentation')
+local M={}
+function M.isActive()local _,world=Native.resolve();return world~=nil and world.healAnim~=nil end
+function M.spriteSnapshot()
+ local game,world,player=Native.resolve()
+ if not(game and world.healAnim)then return{}end
+ local sprites=Presentation.snapshot(game,world,world.healAnim)or{}
+ -- The published source snapshot is anchored at the native 240x160 player's
+ -- (112,72), independently of the window or a source supersampling texture.
+ for _,sprite in ipairs(sprites)do sprite.x=sprite.x-player.px+112;sprite.y=sprite.y-player.py+72 end
+ return sprites
+end
+return M
diff --git a/src/core/game3/pokemon.lua b/src/core/game3/pokemon.lua
new file mode 100644
index 000000000..e980b4c99
--- /dev/null
+++ b/src/core/game3/pokemon.lua
@@ -0,0 +1,244 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Cartridge-numbered observations over native imported Pokemon data and art.
+-- This module does not create another party, save, extractor or battle engine.
+local Native=require('src.compat.gen1.NativeSession')
+local Ids=require('src.compat.gen1.BattleIds')
+local Pokemon=require('src.pokemon.Pokemon')
+local Sprites=require('src.pokemon.Sprites')
+local Assets=require('src.render.Assets')
+local Version=require('src.core.GameVersion')
+local P={}
+local current,cache,users=nil,{},{}
+local function release()
+  for _,entry in pairs(cache)do if entry.image and entry.image.release then entry.image:release()end end
+  current,cache,users=nil,{},{}
+end
+local function context()
+  local game=Native.game()
+  if not(game and game.data and type(game.data.pokemon)=='table')then release();return end
+  if not current or current.game~=game or current.data~=game.data or current.loader~=game.mods or current.edition~=Version.get()or not current.ids:valid()then
+    release();current={game=game,data=game.data,loader=game.mods,edition=Version.get(),ids=Ids.new(game.data)}
+  end
+  local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+  local who=host and host.currentMod or facade and facade._callbackOwner()
+  if who then users[who]=true end
+  return current
+end
+local function copy(value,seen)
+  if type(value)~='table'then return type(value)~='function'and value or nil end
+  seen=seen or{};if seen[value]then return seen[value]end
+  local out={};seen[value]=out;for k,v in pairs(value)do out[k]=copy(v,seen)end;return out
+end
+local function species(value)
+  local c=context();if not c then return end
+  local key=c.ids:native('pokemon',value)
+  return key and c.data.pokemon[key],key,c
+end
+function P.ready()return context()~=nil end
+local PictureIds=require('src.pokemon.Gen3PictureIdentity')
+local function numbered(value)return type(value)=='string'and(tonumber(value)or value)or value end
+function P.unownLetter(personality)return PictureIds.letter(personality)end
+function P.picSpecies(value,personality)
+ value=numbered(value)
+ local row,key,c=species(value)
+ if not row then
+  if c and Version.isGen3()then
+   local base,form=PictureIds.base(value)
+   if form~=nil and c.ids:native('pokemon',base)then return value end
+  end
+  return nil,'imported native species unavailable'
+ end
+ local id=c.ids:read('pokemon',key)
+ if not Version.isGen3()then return id end
+ local picture,why=PictureIds.slot(id,personality)
+ if picture~=id and picture~=nil and c.ids:native('pokemon',picture)then
+  return nil,'native picture slot conflicts with a logical species record'
+ end
+ return picture,why
+end
+function P.picBaseSpecies(value)
+ value=numbered(value)
+ local row,key,c=species(value)
+ if row then
+  local id=c.ids:read('pokemon',key)
+  return id,Version.isGen3()and id==PictureIds.UNOWN and 0 or nil
+ end
+ if c and Version.isGen3()then
+  local base,form=PictureIds.base(value)
+  if form~=nil and c.ids:native('pokemon',base)then return base,form end
+ end
+ return nil,'imported native picture identity unavailable'
+end
+function P.speciesOf(mon)
+  if type(mon)~='table'then return nil end
+  local _,key,c=species(mon.species)
+  return key and c.ids:read('pokemon',key)
+end
+function P.friendshipOf(mon)
+  if type(mon)~='table'then return 0 end
+  local raw,known=require('src.compat.gen1.SourcePokemon').resident(mon)
+  if known then return raw and(raw.happiness or 0)or 0 end
+  local value=tonumber(mon.friendship or mon.happiness)
+  if value then return value end
+  local row=species(mon.species);return row and(row.friendship or 70)or 0
+end
+function P.setFriendship(mon,value,event,reason)
+  if type(mon)~='table'then return 0 end
+  value=tonumber(value)or 0
+  assert(value==value and math.abs(value)<math.huge,'invalid friendship')
+  value=math.max(0,math.min(255,math.floor(value)))
+  local raw,known=require('src.compat.gen1.SourcePokemon').resident(mon)
+  assert(not known or raw,'native party view retired')
+  local before=P.friendshipOf(mon)
+  if raw then raw.happiness=value else mon.friendship=value;mon.happiness=value end
+  local Host=require('src.mods.Runtime')
+  if before~=value and not P.isEgg(mon)and Host.wants('happiness.changed')then
+    Host.emit('happiness.changed',{mon=raw or mon,event=event,reason=reason or'event',from=before,to=value,delta=value-before})
+  end
+  return value
+end
+function P.name(value)local row=species(value);return row and row.name end
+function P.keyName(value)local row,key=species(value);return row and(row.key or row.id or key)end
+function P.speciesFromName(value)
+  local c=context();if not c or type(value)~='string'then return nil end
+  local found
+  for key,row in pairs(c.data.pokemon)do
+    if value==key or value==row.id or value==row.name or value==row.key then
+      local id=c.ids:read('pokemon',key)
+      if found and found~=id then return nil,'ambiguous imported species name'end
+      found=id
+    end
+  end
+  return found
+end
+function P.national(value)local row=species(value);return row and row.dex end
+function P.speciesFromNational(number)
+  local c=context();if not c then return nil end
+  local found
+  for key,row in pairs(c.data.pokemon)do if row.dex==number and not row.unused then
+    local id=c.ids:read('pokemon',key)
+    if found and found~=id then return nil,'ambiguous imported National Dex entry'end
+    found=id
+  end end
+  return found
+end
+function P.types(value)
+  local row,_,c=species(value);if not row then return nil end
+  local types=row.types or{row.type1,row.type2}
+  return{c.ids:read('types',types[1]),c.ids:read('types',types[2]or types[1])}
+end
+function P.stats(value)
+  local row=species(value);local s=row and row.baseStats;if not s then return nil end
+  return{hp=s.hp,atk=s.attack,def=s.defense,spe=s.speed,spa=s.spatk or s.special,spd=s.spdef or s.special}
+end
+function P.speciesMeta(value)
+  local row=species(value);if not row then return nil end
+  return{genderRatio=row.genderRatio,eggGroups=copy(row.eggGroups),eggCycles=row.eggCycles,
+    catchRate=row.catchRate,baseFriendship=row.friendship,growthRate=row.growthRate,
+    bodyColor=row.bodyColor,safariFleeRate=row.safariFleeRate}
+end
+function P.dexEntry(value)
+  if type(value)=='table'then value=P.speciesOf(value)end
+  local row=species(value);if not row then return nil end
+  -- Native imports store metres/kilograms; this source contract uses the
+  -- cartridge's decimetres/hectograms. Never pass metres as sprite height.
+  return{height=type(row.height)=='number'and math.floor(row.height*10+.5)or nil,
+    weight=type(row.weight)=='number'and math.floor(row.weight*10+.5)or nil,
+    category=row.category,description=type(row.dexEntry)=='string'and row.dexEntry or nil}
+end
+function P.abilities(value)
+  local row,_,c=species(value);if not row then return nil end
+  local a=row.abilities or{};return{c.ids:read('abilities',a[1]),c.ids:read('abilities',a[2])}
+end
+function P.abilityId(value,personality)
+  local a=P.abilities(value);if not a then return nil end
+  return a[(tonumber(personality)or 0)%2+1]or a[1]
+end
+function P.gender(value,personality)
+  local row,key,c=species(value);if not row then return nil end
+  local gender=Pokemon.genderOf(c.data,{species=key,personality=personality})
+  return({male='M',female='F',none='U',unknown='U'})[gender]
+end
+function P.isShiny(mon)
+  if type(mon)~='table'then return false end
+  local c=context();local key=c and c.ids:native('pokemon',mon.species)
+  local native={};for k,v in pairs(mon)do native[k]=v end
+  -- Typed live views intentionally store their fields behind __index.
+  for _,k in ipairs{'species','personality','otId','otSecretId','trainerId','isShiny','shiny','dvs','ivs','level'}do
+    native[k]=mon[k]
+  end
+  if key then native.species=key end
+  return Pokemon.isShiny(native)
+end
+function P.isEgg(mon)return type(mon)=='table'and(mon.isEgg==true or mon.egg==true)or false end
+function P.displayName(mon)
+  if type(mon)~='table'then return nil end
+  if mon.nickname and mon.nickname~=''then return mon.nickname end
+  return P.name(P.speciesOf(mon))
+end
+function P.moveName(value)
+  local c=context();local key=c and c.ids:native('moves',value)
+  return key and c.data.moves[key].name
+end
+function P.movePp(value)
+  local c=context();local key=c and c.ids:native('moves',value)
+  return key and c.data.moves[key].pp
+end
+function P.movesAtLevel(value,level)
+  local row,_,c=species(value);if not row then return nil end
+  local moves,pp,maximum={},{},{}
+  for i,key in ipairs(Pokemon.movesAtLevel(row,level))do
+    moves[i]=c.ids:read('moves',key);pp[i]=c.data.moves[key]and c.data.moves[key].pp;maximum[i]=pp[i]
+  end
+  return moves,pp,maximum
+end
+function P.movesLearnedAt(value,level)
+  local row,_,c=species(value);if not row then return nil end
+  local out={};for _,entry in ipairs(row.learnset or{})do
+    if entry.level==level then out[#out+1]=c.ids:read('moves',entry.move)end
+  end;return out
+end
+function P.moveIdAt(mon,slot)
+  local value=mon and mon.moves and mon.moves[slot]
+  if type(value)=='number'then return value end
+  local c=context();return c and type(value)=='table'and c.ids:read('moves',value.id)or nil
+end
+function P.moveSlotCount(mon)return mon and mon.moves and#mon.moves or 0 end
+function P.knowsMove(mon,number)
+  for slot=1,P.moveSlotCount(mon)do if P.moveIdAt(mon,slot)==number then return true end end;return false
+end
+local function picture(side,value,form,shiny,personality)
+  value=numbered(value)
+  local row,key,c=species(value)
+  if c and Version.isGen3()then
+    if not row then
+      local base,variant=PictureIds.base(value)
+      if variant and variant>0 and c.ids:native('pokemon',base)then return nil,'native Unown picture variants are not imported' end
+    elseif c.ids:read('pokemon',key)==PictureIds.UNOWN and personality~=nil then
+      local letter,why=PictureIds.letter(personality)
+      if letter==nil then return nil,why end
+      if letter>0 then return nil,'native Unown picture variants are not imported' end
+    end
+  end
+  if not row then return nil,'imported native species unavailable'end
+  if form~=nil and form~=0 then return nil,'native alternate-form picture binding unavailable'end
+  local mon={species=key,personality=personality,isShiny=shiny==true}
+  local path=Sprites.path(c.data,key,side,{mon=mon,kind='battle'})
+  if not path then return nil,'native species picture unavailable'end
+  local old=cache[path];if old then return old end
+  local ok,image=pcall(love.graphics.newImage,Assets.resolve(path))
+  if not ok then return nil,tostring(image)end
+  local w,h=image:getDimensions()
+  local entry={image=image,w=w,h=h};cache[path]=entry;return entry
+end
+function P.frontPic(value,form,shiny,personality)return picture('front',value,form,shiny,personality)end
+function P.backPic(value,form,shiny)return picture('back',value,form,shiny)end
+P.frontSprite=P.frontPic
+P.flushPicCaches=release
+P.invalidate=release
+local service={release=release,poll=function()if current then context()end end,
+  releaseOwner=function(_,who)if users[who]then users[who]=nil;if not next(users)then release()end end end}
+P._service=service
+require('src.core.game3.asset_stream').register(service)
+Assets.register(release)
+return P
diff --git a/src/core/game3/profile.lua b/src/core/game3/profile.lua
new file mode 100644
index 000000000..562b061ca
--- /dev/null
+++ b/src/core/game3/profile.lua
@@ -0,0 +1,55 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Read-only edition/font/layout facts from the native version registry.
+-- This does not select a runtime, cache, save or gameplay capability set.
+local Version=require('src.core.GameVersion')
+local P={}
+local cache={}
+local function readonly(values)
+ return setmetatable({},{__index=values,__newindex=function()
+  error('native presentation profile is read-only',2)
+ end,__pairs=function()return next,values,nil end,__metatable=false})
+end
+local font=readonly{module='src.ui.game3.frlg_font'}
+local ordinary=readonly{}
+local rs=readonly{battleSpriteLayout='rs'}
+function P.isGame3Version(id)
+ local info=type(id)=='string'and Version.info(id)
+ return type(info)=='table'and info.generation==3
+end
+function P.resolveId(id)
+ if id==nil or id==''then id=Version.get()end
+ if not P.isGame3Version(id)then return nil,'no registered native GBA edition'end
+ if not Version.layout(id)then return nil,'native GBA layout is unavailable'end
+ return id
+end
+function P.of(id)
+ local why;id,why=P.resolveId(id);if not id then return nil,why end
+ local info=Version.info(id);local family=Version.layout(id)
+ local special=id=='ruby'or id=='sapphire'
+ local hit=cache[id]
+ if hit and hit.info==info and hit.label==info.label and hit.family==family then return hit.view end
+ local view=readonly{id=id,label=info.label,generation=info.generation,family=family,
+  font=font,ui=special and rs or ordinary}
+ cache[id]={info=info,label=info.label,family=family,view=view}
+ return view
+end
+function P.active()return P.of(Version.get())end
+function P.sessionVersion(session)
+ if session==nil then return Version.get()end
+ if type(session)~='table'then return nil,'profile session must be a table'end
+ local version=session.version
+ if version==nil or version==''then return Version.get()end
+ if type(version)~='string'then return nil,'profile session edition must be a string'end
+ return version
+end
+function P.forSession(session)
+ local id,why=P.sessionVersion(session);if not id then return nil,why end
+ return P.of(id)
+end
+function P.family(session)
+ local row,why=P.forSession(session)
+ if not row then return nil,why end
+ return row.family
+end
+function P.reset()cache={}end
+return P
diff --git a/src/core/game3/rng.lua b/src/core/game3/rng.lua
new file mode 100644
index 000000000..ff7609db4
--- /dev/null
+++ b/src/core/game3/rng.lua
@@ -0,0 +1,17 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Shared host RNG: checkpoint/continue sees the same stream as native play.
+local R={}
+local function random(...)return(love and love.math and love.math.random or math.random)(...)end
+function R.Random()return random(0,65535)end
+function R.Random32()local lo=R.Random();return lo+R.Random()*65536 end
+function R.compat(...)return random(...)end
+function R.mod(n)n=math.floor(tonumber(n)or 0);return n>0 and R.Random()%n or 0 end
+function R.SeedRng(seed)
+  assert(type(seed)=='number'and seed==seed and math.abs(seed)<math.huge,'invalid native RNG seed')
+  return(love and love.math and love.math.setRandomSeed or math.randomseed)(math.floor(seed)%65536)
+end
+function R.mulU32(a,b)
+  local al,bl=a%65536,b%65536
+  return(al*bl+((math.floor(a/65536)*bl+math.floor(b/65536)*al)%65536)*65536)%4294967296
+end
+return R
diff --git a/src/core/game3/safari.lua b/src/core/game3/safari.lua
new file mode 100644
index 000000000..cb9cf4913
--- /dev/null
+++ b/src/core/game3/safari.lua
@@ -0,0 +1,10 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Native=require('src.compat.gen1.NativeSession')
+local Views=require('src.compat.gen1.SessionView')
+local S={}
+function S.isActive(session)
+  local g=Native.game();if not(g and g.save)then return false end
+  if session~=nil then local r=Views.record(session);if not(r and r:valid()and r.owner==g)then return false end end
+  return g.save.safari~=nil and g.save.safari~=false
+end
+return S
diff --git a/src/core/game3/se_ids.lua b/src/core/game3/se_ids.lua
new file mode 100644
index 000000000..6fb632593
--- /dev/null
+++ b/src/core/game3/se_ids.lua
@@ -0,0 +1,20 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Named imported sequences win; the shared cartridge UI constants retain
+-- their edition-specific numbering even before an audio cache is mounted.
+local S={}
+local Version=require('src.core.GameVersion')
+function S.resolve(id)
+  if type(id)=='number'then return id end
+  local Native=require('src.compat.gen1.NativeSession');local g=Native.game()
+  if g then
+    for _,song in pairs(g.data and g.data.audio and g.data.audio.songs or{})do
+      if type(song)=='table'and song.sfxName==id then return song.index end
+    end
+  end
+  return tonumber(id)or S[id]
+end
+setmetatable(S,{__index=function(_,key)
+  if key=='SE_SUCCESS'then return Version.isFRLG()and 25 or 31 end
+  if key=='SE_SELECT'then return 5 end
+end})
+return S
diff --git a/src/core/game3/step_events.lua b/src/core/game3/step_events.lua
new file mode 100644
index 000000000..f642f7d8a
--- /dev/null
+++ b/src/core/game3/step_events.lua
@@ -0,0 +1,10 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native arrivals synchronously hand control to their script, warp or screen.
+-- Observe that owner; do not queue, advance or flush a second step pipeline.
+local Native=require('src.compat.gen1.NativeSession')
+local M={}
+function M.busy()
+ local game,world,player=Native.resolve()
+ return game~=nil and not Native.acceptsInput(game,world,player)or false
+end
+return M
diff --git a/src/core/game3/trainer_pic.lua b/src/core/game3/trainer_pic.lua
new file mode 100644
index 000000000..3e212fbb5
--- /dev/null
+++ b/src/core/game3/trainer_pic.lua
@@ -0,0 +1,60 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Trainer artwork is resolved from native imported records, with owned images.
+local Native=require('src.compat.gen1.NativeSession')
+local Assets=require('src.render.Assets')
+local Version=require('src.core.GameVersion')
+local P={}
+local current,cache,users
+local function release()
+ for _,row in pairs(cache or{})do if row.image and row.image.release then row.image:release()end end
+ current,cache,users=nil,{},{}
+end
+release()
+local function context()
+ local g=Native.game();if not g then release();return end
+ if not current or current.game~=g or current.data~=g.data or current.loader~=g.mods or current.edition~=Version.get()then
+  release();current={game=g,data=g.data,loader=g.mods,edition=Version.get()}
+ end
+ local host=package.loaded['src.mods.Runtime'];local facade=package.loaded['src.core.Game3']
+ local who=host and host.currentMod or facade and facade._callbackOwner();if who then users[who]=true end
+ return g
+end
+local function image(path)
+ if type(path)~='string'then return nil,'native trainer picture unavailable'end
+ if cache[path]then return cache[path]end
+ local ok,img=pcall(love.graphics.newImage,Assets.resolve(path))
+ if not ok then return nil,tostring(img)end
+ local w,h=img:getDimensions();local row={image=img,w=w,h=h,frames=math.max(1,math.floor(h/64))}
+ cache[path]=row;return row
+end
+function P.front(id)
+ local g=context();if not g then return nil,'no native GBA owner'end
+ assert(type(id)=='number'and id%1==0 and id>=0,'invalid trainer picture id')
+ local c=g.data.constants;local path=c.gen3TrainerFront and c.gen3TrainerFront[id]
+ if not path then
+  for _,r in pairs(g.data.trainers or{})do if r.picIndex==id and type(r.pic)=='string'then
+   assert(path==nil or path==r.pic,'ambiguous native trainer picture');path=r.pic
+  end end
+  for _,r in pairs(g.data.field and g.data.field.playerForms or{})do if r.picIndex==id then path=r.intro or r.card or path end end
+ end
+ return image(path)
+end
+function P.back(gender)
+ local g=context();if not g then return nil,'no native GBA owner'end
+ assert(gender==0 or gender==1,'invalid player gender')
+ local record=g.data.constants.gen3TrainerBack;local who=gender==1 and'girl'or'boy'
+ local index=record and record.player and record.player[who]
+ return image(record and record.images and record.images[index])
+end
+function P.backAnims(gender)
+ local g=context();if not g then return nil,'no native GBA owner'end
+ assert(gender==0 or gender==1,'invalid player gender')
+ local r=g.data.constants.gen3TrainerBack;local id=r and r.player and r.player[gender==1 and'girl'or'boy']
+ local row=r and r.anims and r.anims[id]
+ return row and require('src.mods.Merge').deepCopy(row)
+end
+local service={release=release,poll=function()if current then context()end end,
+ releaseOwner=function(_,who)if users[who]then users[who]=nil;if not next(users)then release()end end end}
+P._service=service
+require('src.core.game3.asset_stream').register(service);Assets.register(release)
+return P
diff --git a/src/core/game3/warp.lua b/src/core/game3/warp.lua
new file mode 100644
index 000000000..eba78fbf5
--- /dev/null
+++ b/src/core/game3/warp.lua
@@ -0,0 +1,59 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source warps enter the same guarded native admission as public world warps.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Admission=require('src.mods.Api3Warp')
+local Identity=require('src.compat.gen1.MapIdentity')
+local W={}
+local leases={}
+local function owner()
+ local host=require('src.mods.Runtime')
+ return host.currentMod or require('src.core.Game3')._callbackOwner()
+end
+local function valid(c)
+ return Native.game()==c.game and c.game.mods==c.loader and c.game.save==c.save
+  and c.game.data==c.data and Version.get()==c.edition and c.loader.hooks==c.hooks
+  and c.loader.mods[c.who]==c.mod and c.mod.enabled~=false and not c.mod.failed
+end
+local function cancel(who)
+ for key,c in pairs(leases)do
+  if not who or key==who then Admission.cancelAll(c.loader,key);leases[key]=nil end
+ end
+end
+function W.isBusy()
+ local _,w,p=Native.resolve()
+ return w~=nil and(not not(w.transitioning or w.flyAnim or w.teleportOut
+  or w.whirlSpin or w.gen4Waterfall or p.stairExit))or false
+end
+function W.isEscalatorActive()
+ local _,w=Native.resolve()
+ return w~=nil and w.transitioning==true and w.warpArrivalKind=='escalator'
+end
+function W.request(mod,value,mapId,x,y,facing,opts)
+ local game,why=Native.resolve(value)
+ if not game or game~=Native.game()then return nil,why or'foreign native game'end
+ local who=owner();local loader=game.mods;local record=loader and loader.mods and loader.mods[who]
+ if not(record and loader.hooks and loader.events and record.enabled~=false and not record.failed)then
+  return nil,'warp request has no live mod owner'
+ end
+ local c=leases[who]
+ if c and not valid(c)then cancel(who);c=nil end
+ if not c then
+  c={game=game,loader=loader,mod=record,who=who,save=game.save,data=game.data,edition=Version.get(),hooks=loader.hooks}
+  leases[who]=c
+  c.request=Admission.new(loader,who,3,function()return valid(c)and Native.game()or nil end,
+   function(g)return{overworld=function()return Native.world(g)end}end)
+ end
+ if type(mapId)=='string'and not game.data.maps[mapId]then
+  local mapped=Identity.bind(game.data.maps,Version.get()):nativeId(mapId)
+  if mapped then mapId=mapped end
+ end
+ return c.request(mapId,x,y,facing,opts)
+end
+-- Revocation cancels only this owner's continuation. It cannot rewind an
+-- already admitted native map transition or clear another owner's input.
+function W.clear()local who=owner();if not who or not leases[who]then return false end;cancel(who);return true end
+W._service={release=function()cancel()end,releaseOwner=function(_,who)cancel(who)end,
+ poll=function()for who,c in pairs(leases)do if not valid(c)then cancel(who)end end end}
+require('src.core.game3.asset_stream').register(W._service)
+return W
diff --git a/src/core/game3/weather.lua b/src/core/game3/weather.lua
new file mode 100644
index 000000000..621bfacff
--- /dev/null
+++ b/src/core/game3/weather.lua
@@ -0,0 +1,11 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Native field weather observations use the same enum as the ROM importer.
+local Field=require('src.core.game3.field_weather')
+local M={}
+for name,id in pairs(require('src.core.Gen3WeatherIds').byName)do M[name]=id end
+M.FOG,M.ASH=M.FOG_HORIZONTAL,M.VOLCANIC_ASH
+M.get=Field.getWeather
+function M.isActive()
+ local id=M.get();return id~=nil and id~=M.NONE and id~=M.SUNNY
+end
+return M
diff --git a/src/import/Gen3FieldMoveArt.lua b/src/import/Gen3FieldMoveArt.lua
new file mode 100644
index 000000000..397efedbe
--- /dev/null
+++ b/src/import/Gen3FieldMoveArt.lua
@@ -0,0 +1,72 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Digest-bound GBA tilemap artwork. Store compact indices and palette words;
+-- compose RGBA only for a consumer, without changing existing native art.
+local M={SCHEMA=1,WIDTH=256,HEIGHT=80}
+local function integer(n,lo,hi)return type(n)=='number'and n==n and n%1==0 and n>=lo and n<=hi end
+local function range(rom,at,n)return integer(at,0,rom.size-n)end
+local function strip(rom,spec,checkpoint)
+  assert(type(spec)=='table'and integer(spec.tileCount,1,1024),'invalid field streak geometry')
+  assert(range(rom,spec.tiles,spec.tileCount*32)and range(rom,spec.palette,32)and range(rom,spec.tilemap,640),'field streak ROM bounds')
+  local palette={};for i=1,16 do palette[i]=rom:u16(spec.palette+(i-1)*2)end
+  local tiles={}
+  for t=0,spec.tileCount-1 do
+    local variants={}
+    for flip=0,3 do
+      local rows={}
+      for y=0,7 do
+        local row={};local sy=flip>=2 and 7-y or y
+        for x=0,7 do
+          local sx=flip%2==1 and 7-x or x
+          local b=rom:u8(spec.tiles+t*32+sy*4+math.floor(sx/2))
+          row[x+1]=string.char(sx%2==0 and b%16 or math.floor(b/16))
+        end
+        rows[y+1]=table.concat(row)
+      end
+      variants[flip]=rows
+    end
+    tiles[t]=variants
+  end
+  local rows={}
+  for ty=0,9 do
+    local cells={}
+    for tx=0,31 do
+      local e=rom:u16(spec.tilemap+(ty*32+tx)*2)
+      assert(e%1024<spec.tileCount,'field streak tile outside declared strip')
+      cells[tx+1]=tiles[e%1024][math.floor(e/1024)%4]
+    end
+    for y=1,8 do
+      local row={};for x=1,32 do row[x]=cells[x][y]end
+      rows[#rows+1]=table.concat(row)
+    end
+    if checkpoint then checkpoint()end
+  end
+  return{width=M.WIDTH,height=M.HEIGHT,indexed=table.concat(rows),palette=palette}
+end
+function M.extract(rom,manifest,sha1,edition,checkpoint)
+  local spec=manifest and manifest.fieldMoveStreaks
+  if spec==nil then spec=require('src.import.Gen3FieldMoveProfiles').forSha1(sha1,edition)end
+  if not(type(spec)=='table'and spec.schema==M.SCHEMA and type(sha1)=='string'and#sha1==40
+      and sha1==manifest.romSha1 and sha1==spec.romSha1 and type(spec.strips)=='table')then
+    return nil,'field streak profile is not authenticated'
+  end
+  local ok,rows=pcall(function()
+    local out={schema=M.SCHEMA,romSha1=sha1,edition=edition,strips={}}
+    for _,name in ipairs({'outdoors','indoors'})do out.strips[name]=strip(rom,spec.strips[name],checkpoint)end
+    return out
+  end)
+  if not ok then return nil,tostring(rows)end
+  return rows
+end
+function M.rgba(row)
+  assert(type(row)=='table'and row.width==M.WIDTH and row.height==M.HEIGHT
+    and type(row.indexed)=='string'and#row.indexed==M.WIDTH*M.HEIGHT and type(row.palette)=='table','invalid field streak record')
+  local colors={[0]='\0\0\0\0'}
+  for i=1,15 do
+    local word=row.palette[i+1];assert(integer(word,0,65535),'invalid field streak palette')
+    local function expand(n)return math.floor(n*255/31+.5)end
+    colors[i]=string.char(expand(word%32),expand(math.floor(word/32)%32),expand(math.floor(word/1024)%32),255)
+  end
+  assert(not row.indexed:find('[\16-\255]'),'invalid field streak palette index')
+  return(row.indexed:gsub('.',function(c)return colors[c:byte()]end))
+end
+return M
diff --git a/src/import/Gen3FieldMoveProfiles.lua b/src/import/Gen3FieldMoveProfiles.lua
new file mode 100644
index 000000000..11f6003b8
--- /dev/null
+++ b/src/import/Gen3FieldMoveProfiles.lua
@@ -0,0 +1,28 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Audited strip locations for exact cartridge digests, also used when an
+-- older manifest predates optional fieldMoveStreaks metadata.
+local profiles={
+ ['41cb23d8dccc8ebd7c649cd8fbb58eeace6e2fdc']={edition='firered',schema=1,romSha1='41cb23d8dccc8ebd7c649cd8fbb58eeace6e2fdc',strips={
+  indoors={tiles=0x3CBA90,palette=0x3CBB10,tilemap=0x3CBB30,tileCount=4},
+  outdoors={tiles=0x3CB5F0,palette=0x3CB7F0,tilemap=0x3CB810,tileCount=16},
+ }},
+ ['574fa542ffebb14be69902d1d36f1ec0a4afd71e']={edition='leafgreen',schema=1,romSha1='574fa542ffebb14be69902d1d36f1ec0a4afd71e',strips={
+  indoors={tiles=0x3CB8CC,palette=0x3CB94C,tilemap=0x3CB96C,tileCount=4},
+  outdoors={tiles=0x3CB42C,palette=0x3CB62C,tilemap=0x3CB64C,tileCount=16},
+ }},
+ ['f3ae088181bf583e55daf962a92bb46f4f1d07b7']={edition='emerald',schema=1,romSha1='f3ae088181bf583e55daf962a92bb46f4f1d07b7',strips={
+  indoors={tiles=0x55B2F0,palette=0x55B370,tilemap=0x55B390,tileCount=4},
+  outdoors={tiles=0x55AE50,palette=0x55B050,tilemap=0x55B070,tileCount=16},
+ }},
+ ['f28b6ffc97847e94a6c21a63cacf633ee5c8df1e']={edition='ruby',schema=1,romSha1='f28b6ffc97847e94a6c21a63cacf633ee5c8df1e',strips={
+  indoors={tiles=0x39EDB4,palette=0x39EE34,tilemap=0x39EE54,tileCount=4},
+  outdoors={tiles=0x39E914,palette=0x39EB14,tilemap=0x39EB34,tileCount=16},
+ }},
+ ['3ccbbd45f8553c36463f13b938e833f652b793e4']={edition='sapphire',schema=1,romSha1='3ccbbd45f8553c36463f13b938e833f652b793e4',strips={
+  indoors={tiles=0x39EBFC,palette=0x39EC7C,tilemap=0x39EC9C,tileCount=4},
+  outdoors={tiles=0x39E75C,palette=0x39E95C,tilemap=0x39E97C,tileCount=16},
+ }},
+}
+return{forSha1=function(sha1,edition)
+ local p=profiles[sha1];if p and p.edition==edition then return p end
+end}
diff --git a/src/import/Gen3HelpFacts.lua b/src/import/Gen3HelpFacts.lua
new file mode 100644
index 000000000..16844ca0e
--- /dev/null
+++ b/src/import/Gen3HelpFacts.lua
@@ -0,0 +1,111 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Cartridge table facts, validated against pret/pokefirered help_system.c
+-- ce6406d8c2eaf46d543c8a2606de0c3cb1951982 and both native FR/LG ROMs.
+-- Text remains in the native structured catalog; no second text decoder.
+local M={SCHEMA=1,REVISION=1}
+local titles={'WhatShouldIDo','HowDoIDoThis','WhatDoesThisTermMean',
+ 'AboutThisGame','TypeMatchupList','Exit'}
+local tables={{0x30,0xE4,44},{0x198,0x25C,48},{0x320,0x3D0,43},
+ {0x480,0x4A0,7},{0x4C0,0x550,35}}
+function M.supports(edition)return edition=='firered'or edition=='leafgreen'end
+local function word(value)
+ return string.char(value%256,math.floor(value/256)%256,
+  math.floor(value/65536)%256,math.floor(value/16777216)%256)
+end
+-- Pure decoding is separate from admission so small synthetic readers can
+-- exercise malformed tables without inventing a verified cartridge hash.
+function M.decode(rom,edition,labels,sha1)
+ assert(M.supports(edition),'native Help is an FR/LG resource')
+ local reverse,signature={},{}
+ for name,address in pairs(labels)do
+  if type(name)=='string'and type(address)=='number'and address%1==0
+   and address>=0 and address<rom.size then
+   if not reverse[address]or name<reverse[address]then reverse[address]=name end
+  end
+ end
+ for i,name in ipairs(titles)do
+  local address=assert(labels['Help_Text_'..name],'missing native Help title')
+  signature[i]=word(address+0x08000000)
+ end
+ signature=table.concat(signature)
+ local found=assert(rom.data:find(signature,1,true),'native Help pointer table missing')
+ assert(not rom.data:find(signature,found+1,true),'ambiguous native Help pointer table')
+ local base=found-1;assert(base%4==0,'unaligned native Help pointer table')
+ -- Locate the native topic order beside its boolean context matrix. These
+ -- bytes describe the menu; no runtime heuristic substitutes list emptiness.
+ local orderNeedle=string.char(3,0,1,2,4,5,0,0,0,0,0,1,0,0,0,1,0,1)
+ local orderAt=assert(rom.data:find(orderNeedle,base+0xC30+1,true),'native Help topic matrix missing')-1
+ assert(orderAt>=base+0xC30 and orderAt+6+36*6<=base+0x8F88,'native Help topic matrix exceeds table region')
+ assert(not rom.data:find(orderNeedle,orderAt+2,true),'ambiguous native Help topic matrix')
+ local function pointer(at)
+  assert(at>=0 and at+4<=rom.size,'native Help table exceeds ROM')
+  local address=rom:u32(at)-0x08000000
+  assert(address>=0 and address<rom.size,'native Help pointer exceeds ROM')
+  return address
+ end
+ local function label(address)
+  return assert(reverse[address],'native Help text has no structured catalog label')
+ end
+ local function text(at)return label(pointer(at))end
+ local function list(at,maximum)
+  local result={}
+  for i=0,63 do
+   assert(at+i<rom.size,'native Help list exceeds ROM')
+   local value=rom:u8(at+i)
+   if value==255 then return result end
+   assert(value>=1 and value<=maximum,'invalid native Help entry ID')
+   result[#result+1]=value
+  end
+  error('unterminated native Help list')
+ end
+ local out={schema=M.SCHEMA,edition=edition,romSha1=sha1,topics={},entries={},contexts={},
+  greeting=label(pointer(base)+0x1D1),cancel=label(pointer(base)+0x77),
+  heading='Help_Text_TheHelpSystem',basicTerms=list(base+0x93E,43),topicOrder={},topicFlags={},
+  frame={format='4bpp',tiles={},palette={}}}
+ for i=1,6 do out.topics[i]={label=text(base+(i-1)*4),description=text(base+24+(i-1)*4)}end
+ for i=0,5 do out.topicOrder[i+1]=rom:u8(orderAt+i)+1 end
+ for context=0,35 do
+  local row={};out.topicFlags[context]=row
+  for topic=1,6 do
+   local value=rom:u8(orderAt+6+context*6+topic-1)
+   assert(value==0 or value==1,'invalid native Help topic flag');row[topic]=value==1
+  end
+ end
+ for topic,t in ipairs(tables)do
+  local entries={};out.entries[topic]=entries
+  for i=1,t[3]do entries[i]={question=text(base+t[1]+i*4),answer=text(base+t[2]+i*4)}end
+ end
+ for context=0,35 do
+  local row={};out.contexts[context]=row
+  for topic,t in ipairs(tables)do
+   local at=base+0x960+(context*5+topic-1)*4
+   row[topic]=rom:u32(at)==0 and{}or list(pointer(at),t[3])
+  end
+ end
+ assert(base+0x90A8+32<=rom.size,'native Help artwork exceeds ROM')
+ for i=0,287 do out.frame.tiles[i+1]=rom:u8(base+0x8F88+i)end
+ for i=0,15 do out.frame.palette[i+1]=rom:u16(base+0x90A8+i*2)end
+ return out
+end
+function M.extract(extractor)
+ local Version=require('src.core.GameVersion')
+ local edition=type(extractor.version)=='table'and extractor.version.id or extractor.version
+ if not M.supports(edition)then return nil,'this cartridge has no native Help resource'end
+ local info=Version.info(edition)
+ local verified,digest=pcall(require('src.import.RomVerification').sha1,extractor.rom.data)
+ if not info or extractor.manifest.romSha1~=info.sha1 or not verified or digest~=info.sha1 then
+  return nil,'native Help requires a verified FR/LG cartridge'
+ end
+ local out=M.decode(extractor.rom,edition,require('src.import.gba.text_labels.'..edition),info.sha1)
+ -- Reuse the native naming extractor's edition-adjusted keypad source.
+ -- All thirteen regions are the text.c sKeypadIcons ABI, not new artwork.
+ local at=assert(extractor.FRLG_NAMING and extractor.FRLG_NAMING.KEYPAD_GFX)
+ assert(at>=0 and at+2048<=extractor.rom.size,'native keypad artwork exceeds ROM')
+ out.keypad={tiles={},regions={}}
+ for i=0,2047 do out.keypad.tiles[i+1]=extractor.rom:u8(at+i)end
+ local starts={0,1,2,4,6,9,12,13,14,15,32,33,34}
+ local widths={8,8,16,16,24,24,8,8,8,8,8,8,8}
+ for i,tile in ipairs(starts)do out.keypad.regions[i]={tile=tile,width=widths[i],height=12}end
+ return out
+end
+return M
diff --git a/src/import/RomExtractorGen3.lua b/src/import/RomExtractorGen3.lua
index c2ce0b55e..91d3422cd 100644
--- a/src/import/RomExtractorGen3.lua
+++ b/src/import/RomExtractorGen3.lua
@@ -5857,6 +5857,13 @@ function RomExtractorGen3:extractConstants()
     end
   end
 
+  local helpFacts=require('src.import.Gen3HelpFacts')
+  local helpEdition=type(self.version)=='table'and self.version.id or self.version
+  if helpFacts.supports(helpEdition)then
+    local help,why=helpFacts.extract(self)
+    constants.gen3Help=help
+    if not help then Logger.warn('gen3: native Help unavailable: %s',why)end
+  end
   -- kept on the extractor so later stages share one numbering
   self._speciesIds, self._moveIds = speciesIds, moveIds
   self._constants = constants
@@ -9946,6 +9953,12 @@ function RomExtractorGen3:extractTrainerSprites()
     if not ok then Logger.warn("gen3 trainer pic %d failed", i) end
   end
 
+  -- Retain the native numeric portrait catalogue for presentation consumers.
+  local constants=self._constants or{}
+  constants.gen3TrainerFront=pathFor
+  self._constants=constants
+  self:write("constants",constants)
+
   -- ...AND THE PATH ONTO EVERY TRAINER ROW.
   --
   -- `pic` is a PATH in this engine: BattleState.trainerPicPath hands it
@@ -12034,6 +12047,14 @@ end
 
 function RomExtractorGen3:extractFieldEffects()
   self:beginStage("Gen3 field effects")
+  local ok,digest=pcall(require('src.import.RomVerification').sha1,self.rom.data)
+  local edition=type(self.version)=='table'and self.version.id or self.version
+  local artwork,why=require('src.import.Gen3FieldMoveArt').extract(self.rom,self.manifest,ok and digest or nil,edition,self.checkpoint)
+  local constants=self._constants or{}
+  constants.gen3FieldMovePresentation=artwork
+  self._constants=constants
+  if not artwork then Logger.warn('gen3 field move artwork unavailable: %s',tostring(why))end
+  self:write('constants',constants)
   local heal, howMany, distinct = self:fieldEffectRoles()
   if not heal or howMany ~= 1 then
     Logger.warn("gen3 field effects: %d of the region's %d effect ids sit in "
@@ -25695,14 +25716,7 @@ end
 -- by nothing, and reads as "the feature is missing" rather than "the join is
 -- wrong".
 -- ---------------------------------------------------------------------------
-local GEN3_WEATHER_NAMES = {
-  [0] = "NONE", [1] = "SUNNY_CLOUDS", [2] = "SUNNY", [3] = "RAIN",
-  [4] = "SNOW", [5] = "RAIN_THUNDERSTORM", [6] = "FOG_HORIZONTAL",
-  [7] = "VOLCANIC_ASH", [8] = "SANDSTORM", [9] = "FOG_DIAGONAL",
-  [10] = "UNDERWATER", [11] = "SHADE", [12] = "DROUGHT", [13] = "DOWNPOUR",
-  [14] = "UNDERWATER_BUBBLES", [15] = "ABNORMAL",
-  [20] = "ROUTE119_CYCLE", [21] = "ROUTE123_CYCLE",
-}
+local GEN3_WEATHER_NAMES = require("src.core.Gen3WeatherIds").names
 
 -- ...and which of them a BATTLE begun in it starts under.  Only four of the
 -- sixteen are weather in the battle sense (SetSav1Weather feeds
@@ -32657,7 +32671,17 @@ function RomExtractorGen3:extractBattleWindows()
   end
 
   local constants = self._constants or {}
+  -- Keep additional genuine templates from the identified array. A terminator
+  -- or an invalid row stops the scan; absent windows are never fabricated.
+  local templates={}
+  for id=0,14 do
+    local r=rec(found[0].at+id*8)
+    if not r or r.bg>3 or r.pal>15 or r.left>31 or r.top>63
+       or r.w>30 or r.h>20 then break end
+    templates[id+1]=win(r)
+  end
   constants.gen3BattleWindows = {
+    templates=templates,
     message = win(found[0]),
     prompt = win(found[1]),
     action = win(found[2]),
@@ -54277,6 +54301,9 @@ RomExtractorGen3.BATTLE_TEXTBOX = {
   -- gBattleWindowTextPalette, which is BG palette 5 and is where the menu's
   -- own text colours live
   MENU_PALETTE = 0xD85600, MENU_PALETTE_BYTES = 0x20,
+  -- Emerald battle_interface.c: the four PP ink/shadow pairs are in a
+  -- separate raw sixteen-colour table, not in the compressed window palette.
+  PP_TEXT_PALETTE = 0xD85620,
   COLS = 32, ROWS = 64, WIDTH = 30,
   -- the three panels, by their first map row
   PANELS = { { key = "message", row = 14 }, { key = "action", row = 34 },
@@ -54496,7 +54523,28 @@ function RomExtractorGen3:extractBattleTextbox()
   end
 
   local constants = self._constants or {}
+  -- Preserve the cartridge's first bank for indexed presentation text.
+  -- RGB role triples alone cannot answer arbitrary foreground/shadow pairs.
+  local textboxPalette, windowPalette = {}, {}
+  for i = 0, 15 do
+    textboxPalette[i + 1] = palRaw[i * 2 + 1] + palRaw[i * 2 + 2] * 256
+    windowPalette[i + 1] = menuRaw[i * 2 + 1] + menuRaw[i * 2 + 2] * 256
+  end
+  local ppPalette, ppSource
+  local edition = type(self.version) == 'table' and self.version.id or self.version
+  if edition == 'emerald' then
+    local at = self:symbol('gPPTextPalette') or T.PP_TEXT_PALETTE
+    if type(at) == 'number' and at % 1 == 0 and at >= 0 and at + 32 <= rom.size then
+      local values = {}
+      for i = 0, 15 do values[i + 1] = rom:u16(at + i * 2) end
+      ppPalette, ppSource = values, ('ROM:gPPTextPalette %07X'):format(at)
+    end
+  end
   constants.gen3BattleTextbox = {
+    palette = textboxPalette,
+    windowPalette = windowPalette,
+    ppPalette = ppPalette,
+    ppSource = ppSource,
     images = images,
     frameImages = frameImages,
     y = T.SCREEN_Y,
diff --git a/src/import/RomImporter.lua b/src/import/RomImporter.lua
index cbd913e5a..77dac03d8 100644
--- a/src/import/RomImporter.lua
+++ b/src/import/RomImporter.lua
@@ -1317,6 +1317,14 @@ local function markerFor(version)
   if version == "red" or version == "blue" or version == "yellow" then
     revision = "gen1-trade-art-v1:"
   end
+  if GameVersion.generation(version)==3 then revision=revision..'gba-field-move-art-v1:'end
+  if version=='firered'or version=='leafgreen'or version=='emerald'then
+    revision=revision..'gba-textbox-palette-v2:'
+  end
+  if GameVersion.generation(version)==3 then
+    local help=require('src.import.Gen3HelpFacts')
+    if help.supports(version)then revision=revision..'gba-help-v'..help.REVISION..':'end
+  end
   return CACHE_FORMAT .. revision .. GameVersion.info(version).sha1
 end
 
@@ -2129,8 +2137,9 @@ local function commandOutput(command)
   releasePointerGrab()
   local pipe = HostShell.popen(command)
   if not pipe then return nil end
-  local result = pipe:read("*a")
-  pipe:close()
+  local ok, result = pcall(pipe.read, pipe, "*a")
+  pcall(pipe.close, pipe)
+  if not ok or type(result) ~= "string" then return nil end
   result = trim(result)
   return result ~= "" and result or nil
 end
@@ -2703,73 +2712,14 @@ end
 -- The extension list comes from the manifest rather than being fixed, because
 -- what a mod needs is its own business: STADIUM2_IMPORTER wants a Nintendo 64
 -- cartridge in any of its three byte orders (.z64/.n64/.v64).
-local function chooseFileByExt(exts, promptName)
-  if type(exts) ~= "table" or #exts == 0 then return nil end
-  local prompt = Strings("Choose your %s", promptName or "file")
-  local platform = love.system.getOS()
-  local quoted, globs, semis = {}, {}, {}
-  for index, ext in ipairs(exts) do
-    quoted[index] = '"' .. ext .. '"'
-    globs[index] = "*." .. ext
-    semis[index] = "*." .. ext
-  end
-  if platform == "OS X" then
-    return commandOutput(
-      ([[osascript -e 'POSIX path of (choose file with prompt "%s" of type {%s})' 2>/dev/null]])
-        :format(prompt, table.concat(quoted, ", ")))
-  elseif platform == "Windows" then
-    local script = table.concat({
-      "Add-Type -AssemblyName System.Windows.Forms;",
-      "$d=New-Object System.Windows.Forms.OpenFileDialog;",
-      "$d.Title='" .. prompt .. "';",
-      "$d.Filter='Base file (" .. table.concat(semis, ";") .. ")|"
-        .. table.concat(semis, ";") .. "|All files (*.*)|*.*';",
-      -- THE TEMP COPY IS THE FALLBACK NOW, NOT THE DEFAULT.
-      --
-      -- io.open on Windows needs ANSI bytes, so a path with characters outside
-      -- them cannot be opened at all (#325) and the pick has to be copied to
-      -- an ASCII temp name first.  That was done for EVERY pick, on the
-      -- reasoning that "a cartridge is tens of megabytes, so this copy is the
-      -- one slow step" -- which stopped being true the moment a mod could
-      -- declare a GameCube disc.  A 1.4 GB pick was copied into %TEMP% on the
-      -- system drive before anything looked at it: minutes of apparent freeze,
-      -- 1.4 GB of C: needed to import a file already sitting on G:, and -- the
-      -- reported failure -- Copy-Item leaves $ErrorActionPreference at
-      -- Continue, so a copy that ran out of space still fell through to
-      -- writing the temp path, and the launcher opened a file that was never
-      -- created.  "that file could not be opened", for a file that was right
-      -- there.
-      --
-      -- So: an ASCII path is handed back AS IS, which is every ordinary path
-      -- and costs nothing.  Only a path io.open genuinely cannot take is
-      -- copied, and that copy now has to prove it landed before its
-      -- destination is reported -- otherwise nothing is written and the
-      -- caller falls through to the "copy it into imports/" instructions,
-      -- which at least tell the player what to do next.
-      "if($d.ShowDialog() -eq 'OK'){",
-      "$p=$d.FileName;",
-      "$ascii=$true;",
-      "foreach($c in $p.ToCharArray()){",
-      "if([int]$c -lt 32 -or [int]$c -gt 126){$ascii=$false}};",
-      "[Console]::OutputEncoding=[Text.Encoding]::UTF8;",
-      "if($ascii){[Console]::Write($p)}else{",
-      "$t=Join-Path $env:TEMP 'pokeport_base_pick.bin';",
-      "Copy-Item -LiteralPath $p -Destination $t -Force "
-        .. "-ErrorAction SilentlyContinue;",
-      "if(Test-Path -LiteralPath $t){[Console]::Write($t)}}}",
-    })
-    return commandOutput(
-      'powershell -NoProfile -STA -Command "' .. script .. '"')
-  elseif platform == "Linux" then
-    local path = commandOutput(
-      ([[zenity --file-selection --title="%s" --file-filter="Base file | %s" 2>/dev/null]])
-        :format(prompt, table.concat(globs, " ")))
-    if path then return path end
-    return commandOutput(
-      ([[kdialog --getopenfilename "$HOME" "%s|Base file" 2>/dev/null]])
-        :format(table.concat(globs, " ")))
+local function chooseFileByExt(exts, promptName, opts)
+  opts = opts or {}
+  local prompt = opts.title or Strings("Choose your %s", promptName or "file")
+  local commands = require('src.core.FilePicker').commands(prompt, {label=opts.label or 'Base file',exts=exts})
+  for _,command in ipairs(commands or {}) do
+    -- One selected backend: cancelling its dialog must not open another one.
+    return commandOutput(command)
   end
-  return nil
 end
 
 -- PUBLISHED, because the map editor needs a picker too.
diff --git a/src/import/gba/field_label_facts.lua b/src/import/gba/field_label_facts.lua
new file mode 100644
index 000000000..53a978160
--- /dev/null
+++ b/src/import/gba/field_label_facts.lua
@@ -0,0 +1,12 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Numeric interface facts only, not cartridge bytes or program code.
+-- pret/pokeemerald 731ad5bfd6e6f265508d0efcca0ba42f9dcf5881
+-- pret/pokeruby 5784633ce4ef7ade1a7f2d2d0c288e3d5e6cdd7f
+-- Both: include/constants/metatile_labels.h, Building TV Off/On definitions.
+local M={}
+function M.metatileLabels(edition)
+ if edition=='emerald'or edition=='ruby'or edition=='sapphire'then
+  return{METATILE_Building_TV_Off=0x002,METATILE_Building_TV_On=0x003}
+ end
+end
+return M
diff --git a/src/import/gba/versions.lua b/src/import/gba/versions.lua
new file mode 100644
index 000000000..2cc3dbf6e
--- /dev/null
+++ b/src/import/gba/versions.lua
@@ -0,0 +1,6 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Shared retail portrait indices already used by the native FR/LG importer.
+local V={TRAINER_PIC_RED=135,TRAINER_PIC_LEAF=136}
+return setmetatable(V,{__index=function(_,key)
+ if key=='BUILD'then return require('src.core.GameVersion').get()end
+end})
diff --git a/src/inventory/Bag.lua b/src/inventory/Bag.lua
index b09bf37e8..7640702d6 100644
--- a/src/inventory/Bag.lua
+++ b/src/inventory/Bag.lua
@@ -212,6 +212,18 @@ function Bag.add(save, id, qty, data)
   return true
 end
 
+-- Read-only admission uses the same pocket/container rules on a detached
+-- inventory. A query can never grant a TM CASE or reorder the live bag.
+function Bag.canAdd(save,id,qty,data)
+  if not(save and type(save.inventory)=='table')then return false end
+  qty=qty or 1
+  if type(qty)~='number'or qty~=qty or qty%1~=0 or qty<=0 or qty>999 then return false end
+  local shadow={inventory={},bagOrder={},gen3PyramidBag=save.gen3PyramidBag and true or nil}
+  for key,value in pairs(save.inventory)do shadow.inventory[key]=value end
+  for i,value in ipairs(save.bagOrder or{})do shadow.bagOrder[i]=value end
+  return Bag.add(shadow,id,qty,data)
+end
+
 -- Saves made before the FRLG AddBagItem parity fix could contain TMs/HMs but
 -- no TM CASE.  Retail never permits that state: acquiring the first machine
 -- inserts ITEM_TM_CASE at the same time.  Repair such old port saves on load
diff --git a/src/inventory/ItemEffects.lua b/src/inventory/ItemEffects.lua
index c9119139b..310bca8d7 100644
--- a/src/inventory/ItemEffects.lua
+++ b/src/inventory/ItemEffects.lua
@@ -1550,6 +1550,7 @@ function ItemEffects.use(data, save, itemId, target, battle, moveIndex, ow)
   if itemId == "REPEL" or itemId == "SUPER_REPEL" or itemId == "MAX_REPEL" then
     local steps = itemId == "REPEL" and 100 or itemId == "SUPER_REPEL" and 200 or 250
     save.repelSteps = steps
+    if package.loaded['src.mods.FeatureOptions']then require('src.ui.RepelPrompt').remember(save,itemId)end
     return "consumed", { Strings("%s used\n%s!", save.player.name, name) }
   end
 
diff --git a/src/mods/Api3Warp.lua b/src/mods/Api3Warp.lua
new file mode 100644
index 000000000..c447cdec1
--- /dev/null
+++ b/src/mods/Api3Warp.lua
@@ -0,0 +1,265 @@
+-- API-3 warp admission and callback lifetime over the native overworld path.
+local Runtime = require("src.mods.Runtime")
+local Version = require("src.core.GameVersion")
+local Actions = require("src.world.WorldActions")
+local W = {}
+local contexts = setmetatable({}, { __mode = "k" })
+local observers = setmetatable({}, { __mode = "k" })
+local pending = setmetatable({}, { __mode = "k" })
+local dirs = { up = true, down = true, left = true, right = true }
+local unpack = table.unpack or unpack
+local function pack(...)
+  return { n = select("#", ...), ... }
+end
+local function integer(n)
+  return type(n) == "number" and n == n and n >= 0 and n < math.huge and n % 1 == 0
+end
+local function retire(token)
+  token.done = true
+  token.callback = nil
+  if pending[token.game] == token then
+    pending[token.game] = nil
+  end
+end
+function W.cancelAll(loader, owner)
+  for candidate, context in pairs(contexts) do
+    if not loader or candidate == loader then
+      if owner then
+        context.owners[owner] = nil
+      else
+        contexts[candidate] = nil
+      end
+    end
+  end
+  for _, token in pairs(pending) do
+    if (not loader or token.loader == loader) and (not owner or token.owner == owner) then
+      retire(token)
+    end
+  end
+end
+local function inspect(loader)
+  for _, token in pairs(pending) do
+    if token.loader == loader and not token.valid() then
+      retire(token)
+    end
+  end
+end
+local function observe(loader)
+  local old = observers[loader]
+  if old and old[1] == loader.hooks then
+    return
+  end
+  observers[loader] = setmetatable({ loader.hooks }, { __mode = "v" })
+  -- Installed at facade creation, never spliced into a dispatching hook chain.
+  loader.hooks:wrap("input.step", function(nextFn, ...)
+    if next(pending) == nil then
+      return nextFn(...)
+    end
+    inspect(loader)
+    local result = pack(pcall(nextFn, ...))
+    inspect(loader)
+    if not result[1] then
+      error(result[2], 0)
+    end
+    return unpack(result, 2, result.n)
+  end, math.huge, "engine:api3_warp")
+  for _, event in ipairs({ "map.entered", "map.exited" }) do
+    local name = event
+    loader.events:on(name, function(payload)
+      for _, token in pairs(pending) do
+        if token.loader == loader then
+          if not token.valid() then
+            retire(token)
+          elseif name == "map.entered" then
+            if token.entered or payload.mapId ~= token.destination then
+              retire(token)
+            else
+              token.entered = true
+            end
+          elseif token.entered then
+            retire(token)
+          end
+        end
+      end
+    end, math.huge, "engine:api3_warp")
+  end
+end
+-- Pure destination validation shared by public warps and portable scripts.
+function W.plan(game, ow, generation, mapId, x, y, facing)
+  if type(mapId) ~= "string" or #mapId == 0 or #mapId > 256 or mapId:find("%c") then
+    return nil, "invalid map id"
+  end
+  local maps = game.data and game.data.maps
+  local destination = mapId
+  if generation == 3 and maps and not maps[destination] then
+    local prefix = ({ ruby = "RU_", sapphire = "SA_", emerald = "EM_" })[Version.get()] or "FR_"
+    if maps[prefix .. destination] then
+      destination = prefix .. destination
+    end
+  end
+  local def = maps and maps[destination]
+  if not def then
+    return nil, "unknown map: " .. mapId
+  end
+  if not integer(x) or not integer(y) then
+    return nil, "invalid coordinates"
+  end
+  local scale = generation == 3 and 1 or 2
+  if not integer(def.width) or def.width == 0 or not integer(def.height) or def.height == 0 then
+    return nil, "invalid map dimensions"
+  end
+  if x >= def.width * scale or y >= def.height * scale then
+    return nil, "coordinates out of bounds"
+  end
+  if facing ~= nil and not dirs[facing] then
+    return nil, "invalid facing"
+  end
+  return {
+    mapId = destination,
+    x = x,
+    y = y,
+    facing = facing or (generation ~= 1 and ow.player.facing) or "down",
+    def = def,
+  }
+end
+function W.new(loader, owner, generation, current, native)
+  local context = contexts[loader]
+  if not context then
+    context = { owners = {} }
+    contexts[loader] = context
+  end
+  local lease = {}
+  context.owners[owner] = lease
+  local function licensed()
+    return contexts[loader] == context and context.owners[owner] == lease
+  end
+  observe(loader)
+  local function warp(mapId, x, y, facing, options)
+    if not licensed() then
+      return nil, "warp facade is retired"
+    end
+    local game = current()
+    if not game then
+      return nil, "no game"
+    end
+    local api = native(game)
+    local ow = api:overworld()
+    if not ow then
+      return nil, "no overworld"
+    end
+    local ready, why = Actions.ready(game, ow)
+    if not ready then
+      return nil, why
+    end
+    inspect(loader)
+    if pending[game] or ow.gen3Locked or #(ow.parallelRunners or {}) > 0 or #(ow.parallelQueue or {}) > 0 then
+      return nil, "world is busy"
+    end
+    local plan, reason = W.plan(game, ow, generation, mapId, x, y, facing)
+    if not plan then
+      return nil, reason
+    end
+    local destination = plan.mapId
+    if options ~= nil and (type(options) ~= "table" or getmetatable(options) ~= nil) then
+      return nil, "invalid options"
+    end
+    local opts = {}
+    for key, value in pairs(options or {}) do
+      if key == "arrive" then
+        if value ~= "fly" and value ~= "teleport" then
+          return nil, "invalid arrival"
+        end
+      elseif key == "onDone" then
+        if type(value) ~= "function" then
+          return nil, "invalid callback"
+        end
+      elseif key == "keepMusic" or key == "fade" then
+        if type(value) ~= "boolean" then
+          return nil, "invalid options"
+        end
+        if key == "fade" and generation ~= 3 then
+          return nil, "unsupported fade"
+        end
+      else
+        return nil, "unknown warp option: " .. tostring(key)
+      end
+      opts[key] = value
+    end
+    facing = plan.facing
+    local hooks, events = Runtime.hooks, Runtime.events
+    local token =
+      { game = game, loader = loader, owner = owner, destination = destination, callback = opts.onDone }
+    local save, data, stack, player, version = game.save, game.data, game.stack, ow.player, Version.get()
+    function token.valid()
+      return not token.done
+        and licensed()
+        and current() == game
+        and game.save == save
+        and game.data == data
+        and game.stack == stack
+        and ow.player == player
+        and Version.get() == version
+        and Runtime.hooks == hooks
+        and Runtime.events == events
+        and native(game):overworld() == ow
+    end
+    local accepted, deferred
+    local function finish(...)
+      if token.done then
+        return
+      end
+      if accepted == nil then
+        if not deferred then
+          deferred = pack(...)
+        end
+        return
+      end
+      local valid = token.valid() and ow.map and ow.map.id == destination
+      local callback = valid and token.callback
+      retire(token)
+      if not accepted or not callback then
+        return
+      end
+      local previous = Runtime.currentMod
+      Runtime.currentMod = owner
+      local result = pack(pcall(callback, ...))
+      Runtime.currentMod = previous
+      if not result[1] then
+        Runtime.reportError(owner, "world warp callback failed: " .. tostring(result[2]))
+      end
+    end
+    pending[game] = token
+    local arrival = ow.arriveWarp
+    if opts.arrive then
+      ow.arriveWarp = opts.arrive
+    end
+    local called, result, detail = pcall(
+      ow.startWarpTo,
+      ow,
+      destination,
+      x,
+      y,
+      facing,
+      finish,
+      { via = "warp", keepMusic = opts.keepMusic, fade = opts.fade }
+    )
+    -- The native controller is a void method. Explicit false/refusal and errors
+    -- never count as admission; a callback fired before that result is deferred.
+    accepted = called and result ~= false and not (result == nil and detail ~= nil)
+    if not accepted then
+      retire(token)
+      ow.arriveWarp = arrival
+      if not called then
+        return nil, "world operation failed: " .. tostring(result)
+      end
+      return nil, detail or "world operation failed"
+    end
+    if deferred then
+      finish(unpack(deferred, 1, deferred.n))
+    end
+    return true
+  end
+  -- Synchronous API-3 edits share this owner lease and loader lifecycle.
+  return warp, licensed
+end
+return W
diff --git a/src/mods/Api3WildBattle.lua b/src/mods/Api3WildBattle.lua
new file mode 100644
index 000000000..ee1db1ca5
--- /dev/null
+++ b/src/mods/Api3WildBattle.lua
@@ -0,0 +1,203 @@
+-- API-3 encounter admission over native construction, transition and afterBattle.
+-- Portable scripts may supply a private owned guard and native trainer plan.
+local Runtime = require("src.mods.Runtime")
+local Version = require("src.core.GameVersion")
+local Party = require("src.pokemon.Party")
+local B = {}
+local pending, observers = {}, setmetatable({}, { __mode = "k" })
+local unpack = table.unpack or unpack
+local function pack(...)
+  return { n = select("#", ...), ... }
+end
+local function text(value)
+  local ok, result = pcall(tostring, value)
+  return ok and result or "unprintable error"
+end
+local function retire(token)
+  token.retired, token.callback = true, nil
+  pending[token] = nil
+end
+function B.cancelAll(loader, owner)
+  for token in pairs(pending) do
+    if (not loader or loader == token.loader) and (not owner or owner == token.owner) then
+      retire(token)
+    end
+  end
+end
+local function inspect(loader)
+  for token in pairs(pending) do
+    if token.loader == loader and not token.valid() then
+      retire(token)
+    end
+  end
+end
+local function observe(loader)
+  if observers[loader] == loader.hooks then
+    return
+  end
+  observers[loader] = loader.hooks
+  loader.hooks:wrap("input.step", function(nextFn, ...)
+    inspect(loader)
+    local result = pack(pcall(nextFn, ...))
+    inspect(loader)
+    if not result[1] then
+      error(result[2], 0)
+    end
+    return unpack(result, 2, result.n)
+  end, math.huge, "engine:api3_wild_battle")
+end
+function B.new(loader, owner, current, native, licensed, req, ownedReady, ownedNative)
+  local ids = not ownedNative and require("src.mods.UnifiedIds").new(loader)
+  observe(loader)
+  return function(species, level, callback)
+    if not licensed() then
+      return nil, "world facade is retired"
+    end
+    local game = current()
+    if not game then
+      return nil, "no game"
+    end
+    local ow = native(game):overworld()
+    if not ow then
+      return nil, "no overworld"
+    end
+    local ok, reason = (ownedReady or require("src.mods.Api3WorldEdits").ready)(game, ow)
+    if not ok then
+      return nil, reason
+    end
+    for token in pairs(pending) do
+      if token.game == game then
+        if token.valid() then
+          return nil, "world is busy"
+        end
+        retire(token)
+      end
+    end
+    local key, why
+    if ownedNative then
+      key, why = ownedNative.resolve(game, species, level)
+      if not key then
+        return nil, why
+      end
+      if callback ~= nil and type(callback) ~= "function" then
+        return nil, "invalid callback"
+      end
+    else
+      if type(species) ~= "string" or #species == 0 or #species > 256 or species:find("%c") then
+        return nil, "invalid species id"
+      end
+      if type(level) ~= "number" or level ~= level or level < 1 or level > 100 or level % 1 ~= 0 then
+        return nil, "level must be a whole number 1..100"
+      end
+      if callback ~= nil and type(callback) ~= "function" then
+        return nil, "invalid callback"
+      end
+      local group, why = ids:resolve("pokemon", species)
+      if not group then
+        return nil, why:find("^ambiguous") and why or "unknown species: " .. species
+      end
+      key = group.key
+      if not (game.data.pokemon and game.data.pokemon[key]) then
+        return nil, "unknown species: " .. species
+      end
+    end
+    if not Party.firstHealthy(game.save.party or {}) then
+      return nil, "no healthy party"
+    end
+    if type(ow.pushBattle) ~= "function" or type(ow.afterBattle) ~= "function" then
+      return nil, "battle runtime unavailable"
+    end
+    local save, data, stack, player, world = game.save, game.data, game.stack, ow.player, game.overworld
+    local version, hooks, events = Version.get(), Runtime.hooks, Runtime.events
+    local token = { loader = loader, owner = owner, game = game, callback = callback }
+    local function live()
+      return current() == game
+        and game.save == save
+        and game.data == data
+        and game.stack == stack
+        and game.overworld == world
+        and ow.player == player
+        and native(game):overworld() == ow
+        and Version.get() == version
+    end
+    function token.valid()
+      return not token.retired
+        and licensed()
+        and live()
+        and Runtime.hooks == hooks
+        and Runtime.events == events
+    end
+    local admitted, deferred, finished, battle
+    local function finish(...)
+      if finished then
+        return
+      end
+      if admitted == nil then
+        if not deferred then
+          deferred = pack(...)
+        end
+        return
+      end
+      finished = true
+      local valid, fn = token.valid(), token.callback
+      retire(token)
+      if not admitted or not live() then
+        return
+      end
+      -- Native cleanup still runs after the originating mod has been unloaded.
+      local outcome = (...)
+      local called, err = pcall(function()
+        if ownedNative and ownedNative.cleanup then
+          ownedNative.cleanup(game, ow, key, outcome, battle)
+        end
+        ow:afterBattle(outcome, battle)
+      end)
+      if not called then
+        Runtime.reportError(owner, "world battle cleanup failed: " .. text(err))
+        if ownedReady and valid and fn then
+          pcall(fn, nil, "native battle cleanup failed: " .. text(err))
+        end
+        return
+      end
+      if valid and licensed() and live() and fn then
+        local previous = Runtime.currentMod
+        Runtime.currentMod = owner
+        called, err = pcall(fn, ...)
+        Runtime.currentMod = previous
+        if not called then
+          Runtime.reportError(owner, "world battle callback failed: " .. text(err))
+        end
+      end
+    end
+    pending[token] = true
+    local called, accepted, err = pcall(require("src.mods.Api3WorldEdits").run, game, function()
+      if ownedNative then
+        battle = ownedNative.construct(game, key)
+      else
+        battle = req("src.battle.BattleState").newWild(game, key, level)
+      end
+      if not battle or battle.dead then
+        return nil, "battle failed"
+      end
+      if not token.valid() or ownedReady and not ownedReady(game, ow) then
+        return nil, "battle session changed"
+      end
+      battle.onFinish = finish
+      local value, detail = ow:pushBattle(battle)
+      if value == false or value == nil and detail ~= nil then
+        return nil, detail or "battle failed"
+      end
+      return true
+    end)
+    admitted = called and accepted == true
+    if not admitted then
+      retire(token)
+      return nil, called and (err or "battle failed") or "world operation failed: " .. text(accepted)
+    end
+    if deferred then
+      finish(unpack(deferred, 1, deferred.n))
+    end
+    return true
+  end
+end
+return B
diff --git a/src/mods/Api3WorldEdits.lua b/src/mods/Api3WorldEdits.lua
new file mode 100644
index 000000000..77d8ce2eb
--- /dev/null
+++ b/src/mods/Api3WorldEdits.lua
@@ -0,0 +1,213 @@
+-- Validated API-3 object/block edits over this host's native runtime paths.
+local Actions = require("src.world.WorldActions")
+local Reads = require("src.mods.WorldReads")
+local Runtime = require("src.mods.Runtime")
+local Version = require("src.core.GameVersion")
+local E = {}
+local running = setmetatable({}, { __mode = "k" })
+local function integer(value, maximum)
+  return type(value) == "number"
+    and value == value
+    and value >= 0
+    and value < math.huge
+    and value % 1 == 0
+    and (not maximum or value <= maximum)
+end
+local function identifier(value)
+  return type(value) == "string" and #value > 0 and #value <= 256 and not value:find("%c")
+end
+local function store(value)
+  return value == nil or type(value) == "table"
+end
+local function toggle(game, ow, api, gen, req, mapId, ref, visible)
+  if not identifier(mapId) or not (identifier(ref) or integer(ref)) or type(visible) ~= "boolean" then
+    return nil, "invalid object toggle"
+  end
+  local maps = game.data and game.data.maps
+  local id = mapId
+  if gen == 3 and maps and not maps[id] then
+    local prefix = ({ ruby = "RU_", sapphire = "SA_", emerald = "EM_" })[Version.get()] or "FR_"
+    if maps[prefix .. id] then
+      id = prefix .. id
+    end
+  end
+  local def = maps and maps[id]
+  if not def then
+    return nil, "unknown map: " .. mapId
+  end
+  local save = game.save
+  if not store(save.objectToggles) or not store(save.objectToggles and save.objectToggles[id]) then
+    return nil, "invalid object toggle store"
+  end
+  if not store(save.flags) then
+    return nil, "invalid flag store"
+  end
+  if gen == 1 then
+    -- Gen 1 permits off-map keys and resolves their visibility on map load.
+    return function()
+      return api:toggleObject(id, ref, visible)
+    end
+  end
+  if ow.map.id ~= id then
+    return nil, "map is not active: " .. mapId
+  end
+  local objects = ow.map.def and ow.map.def.objects
+  if type(objects) ~= "table" then
+    return nil, "map has no objects"
+  end
+  local object
+  for i, candidate in ipairs(objects) do
+    local numeric = gen == 2 and i or tonumber(candidate.localId or candidate.index)
+    if numeric == ref or candidate.name == ref or gen == 3 and candidate.id == ref then
+      object = candidate
+      break
+    end
+  end
+  if not object then
+    return nil, "no such object: " .. tostring(ref)
+  end
+  if type(ow.syncObjectVisibility) ~= "function" then
+    return nil, "object runtime unavailable"
+  end
+  local ctx = { game = game, save = save, overworld = ow, mapId = id }
+  local index = object.index
+  if gen == 2 then
+    if not store(save.g2ObjectToggles) then
+      return nil, "invalid object toggle store"
+    end
+  else
+    if not integer(index, 254) or index == 0 then
+      return nil, "invalid object definition"
+    end
+    if
+      not store(save.gen3Spawned)
+      or not store(save.gen3Spawned and save.gen3Spawned[id])
+      or not store(save.gen3SessionObjects)
+    then
+      return nil, "invalid object toggle store"
+    end
+  end
+  return function()
+    if gen == 2 then
+      req("src.script.Gen2Commands").setObjectVisibility(ctx, object, id, visible)
+    else
+      req("src.script.Gen3Commands")
+      local commands = req("src.script.Commands")
+      local command = visible and commands.g3_show_object or commands.g3_hide_object
+      command(ctx, index)
+    end
+    Runtime.emit("world.object_toggled", { mapId = id, objName = ref, visible = visible })
+    return true
+  end
+end
+local function replace(game, ow, api, gen, req, bx, by, block)
+  if not integer(block, gen == 3 and 1023 or 255) then
+    return nil, "invalid block id"
+  end
+  local present, metadata = Reads.activeBlockAt(ow.map, ow.map.id, bx, by)
+  if present == nil then
+    return nil, metadata
+  end
+  local cells = gen == 3 and 1 or 2
+  if ow.map.blockCells ~= cells then
+    return nil, "unsupported block geometry"
+  end
+  if gen ~= 3 and not (ow.map.tileset and ow.map.tileset.blocks and ow.map.tileset.blocks[block + 1]) then
+    return nil, "unknown block id"
+  end
+  local renderer = ow.map.renderer
+  if not renderer or type(renderer.rebuild) ~= "function" then
+    return nil, "block renderer unavailable"
+  end
+  if gen ~= 3 then
+    return function()
+      return api:replaceBlock(bx, by, block)
+    end
+  end
+  return function()
+    -- Like Gen1's Gen3 Field.setMetatile default, use the native non-impassable
+    -- metatile command; it replaces the old collision override as well.
+    req("src.script.Gen3Commands")
+    req("src.script.Commands").g3_set_metatile(
+      { game = game, save = game.save, overworld = ow },
+      bx,
+      by,
+      block,
+      0
+    )
+    renderer:rebuild()
+    ow.map.blocksDirty = nil
+    Runtime.emit("world.block_replaced", { mapId = ow.map.id, bx = bx, by = by, block = block })
+    return true
+  end
+end
+local function invalidate(game, ow, api, gen, req, mapId)
+  if not identifier(mapId) then
+    return nil, "unknown map"
+  end
+  local maps = game.data and game.data.maps
+  local id = mapId
+  if gen == 3 and maps and not maps[id] then
+    local prefix = ({ ruby = "RU_", sapphire = "SA_", emerald = "EM_" })[Version.get()] or "FR_"
+    if maps[prefix .. id] then
+      id = prefix .. id
+    end
+  end
+  if not (maps and maps[id]) then
+    return nil, "unknown map"
+  end
+  if type(ow.reloadMap) ~= "function" then
+    return nil, "map reload unavailable"
+  end
+  return function()
+    return api:invalidateMap(id)
+  end
+end
+-- Shared admission/commit guard for synchronous API-3 world mutations.
+function E.ready(game, ow)
+  local ok, reason = Actions.ready(game, ow)
+  if not ok then
+    return nil, reason
+  end
+  if running[game] or ow.gen3Locked or #(ow.parallelRunners or {}) > 0 or #(ow.parallelQueue or {}) > 0 then
+    return nil, "world is busy"
+  end
+  return true
+end
+function E.run(game, operation, ...)
+  running[game] = true
+  local called, value, why = pcall(operation, ...)
+  running[game] = nil
+  if not called then
+    error(value, 0)
+  end
+  return value, why
+end
+-- Pure validation shared by public edits and an already owned script run.
+function E.plan(game, api, generation, req, name, ...)
+  local ow = api:overworld()
+  if not ow then
+    return nil, "no overworld"
+  end
+  local operation = name == "toggleObject" and toggle or name == "invalidateMap" and invalidate or replace
+  return operation(game, ow, api, generation, req, ...)
+end
+function E.call(game, api, generation, req, name, ...)
+  local ow = api:overworld()
+  if not ow then
+    return nil, "no overworld"
+  end
+  local ok, reason = E.ready(game, ow)
+  if not ok then
+    return nil, reason
+  end
+  local function execute(...)
+    local operation, reason = E.plan(game, api, generation, req, name, ...)
+    if not operation then
+      return nil, reason
+    end
+    return operation()
+  end
+  return E.run(game, execute, ...)
+end
+return E
diff --git a/src/mods/FeatureOptions.lua b/src/mods/FeatureOptions.lua
new file mode 100644
index 000000000..fe15b8082
--- /dev/null
+++ b/src/mods/FeatureOptions.lua
@@ -0,0 +1,48 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Optional native conveniences follow their contributing mod's live options.
+local Host=require('src.mods.Runtime')
+local M={}
+local providers={}
+local function release(p)
+ p.config=nil
+ for i=#providers,1,-1 do if providers[i]==p then table.remove(providers,i)end end
+end
+function M.attach(config)
+ assert(type(config)=='table'and type(config.active)=='function'and type(config.option)=='function','feature options need active/option callbacks')
+ local facade=require('src.core.Game3');local who=Host.currentMod or facade._callbackOwner()
+ assert(who,'feature options need a mod owner')
+ local c={};for _,key in ipairs{'active','option','time','outdoors','language'}do
+  assert(config[key]==nil or type(config[key])=='function','invalid feature callback');c[key]=config[key]
+ end
+ local p={who=who,config=c,hooks=Host.hooks,events=Host.events,errors={}}
+ providers[#providers+1]=p
+ return function()release(p)end
+end
+local function call(p,key,...)
+ local fn=p.config and p.config[key];if not fn then return nil end
+ local result={pcall(require('src.core.Game3')._withCallbackOwner,p.who,fn,...)}
+ if not result[1]then
+  if not p.errors[key]then Host.reportError(p.who,'feature '..key..': '..tostring(result[2]));p.errors[key]=true end
+  return nil
+ end
+ return result[2]
+end
+function M.provider(key)
+ for i=#providers,1,-1 do
+  local p=providers[i]
+  if p.hooks~=Host.hooks or p.events~=Host.events then release(p)
+  else
+   local game=require('src.compat.gen1.NativeSession').game()
+   local mod=game and game.mods and game.mods.mods and game.mods.mods[p.who]
+   if(not game or mod and mod.enabled~=false and not mod.failed)and call(p,'active')==true and call(p,'option',key)==true then return p end
+  end
+ end
+end
+function M.enabled(key)return M.provider(key)~=nil end
+M.call=call
+function M.releaseOwner(_,who)
+ for i=#providers,1,-1 do if providers[i].who==who then release(providers[i])end end
+end
+function M.release()for i=#providers,1,-1 do release(providers[i])end end
+require('src.core.game3.asset_stream').register(M)
+return M
diff --git a/src/mods/Loader.lua b/src/mods/Loader.lua
index 4094a38c4..444fad7d1 100644
--- a/src/mods/Loader.lua
+++ b/src/mods/Loader.lua
@@ -32,6 +32,29 @@ require("src.core.ModCompat").install()
 local Loader = {}
 Loader.__index = Loader
 
+-- Compatibility battle services also retire on older native hosts whose
+-- stream service is available but not yet driven by loader retirement.
+local function retireBattlePresentation()
+  local first
+  for _,name in ipairs({'src.core.game3.battle','src.core.game3.battle.anim','src.core.game3.battle.anim_coords','src.core.game3.pokemon','src.core.game3.mon_anim'})do
+    local module=package.loaded[name];local service=type(module)=='table'and module._service
+    if type(service)=='table'and type(service.release)=='function'then
+      local ok,why=pcall(service.release,service)
+      if not ok and not first then first=why end
+    end
+  end
+  if first then error(first,0)end
+end
+
+-- Only an already-loaded field service owns resources. Retire it after
+-- wrapper unwind without importing a compatibility module on ordinary boot.
+local function retireFieldEffects()
+  for _,name in ipairs({'src.core.game3.field_effects','src.core.game3.field_move_show_mon'})do
+    local service=package.loaded[name]
+    if type(service)=='table' and type(service.release)=='function' then service.release()end
+  end
+end
+
 local MOD_STATE_FILE = "mod_state.lua" -- legacy migration only
 
 -- walk a dotted target path without creating anything; the base view a
@@ -1196,6 +1219,10 @@ end
 -- migration it took goes with them.  The journal only exists around an
 -- entry chunk; a later failure (script validation) purges every registry.
 function Loader:_rollback(modId)
+  local stream=package.loaded['src.core.game3.asset_stream']
+  if stream and stream.cancelOwner then pcall(stream.cancelOwner,modId)end
+  local move=package.loaded['src.core.game3.field_move_show_mon']
+  if move and move.cancelOwner then pcall(move.cancelOwner,modId)end
   for name in pairs(self.journal or self.content) do
     self.content[name]:rollback(modId)
   end
@@ -1309,12 +1336,24 @@ local function stampAudioOwners(data, name, registry)
   owners[key] = map
 end
 
+-- Optional collision observations retire after wrapper unwind, without
+-- loading compatibility modules on an ordinary native boot.
+local function retireCompatibilityCollision()
+  local module = package.loaded["src.core.game3.collision"]
+  if type(module) == "table" and type(module.release) == "function" then module.release() end
+end
+
 function Loader:load(data)
   -- A SECOND LOAD IN ONE PROCESS STARTS FROM THE ENGINE, NOT FROM THE LAST
   -- LOAD'S MODS.  EXIT GAME -> launcher -> Play runs every mod's main.lua
   -- again (and the launcher backdrop boots the plain game in between); the
   -- wraps and flags the previous load put on engine tables come off first.
   ModSeams.unwindAll()
+  retireCompatibilityCollision()
+  retireBattlePresentation()
+  retireFieldEffects()
+  local stream=package.loaded['src.core.game3.asset_stream']
+  if stream and stream.release then stream.release()end
   self.baseData = data
   -- every registry folds against the pristine view of its Data target;
   -- resolution is lazy so optional namespaces may appear later
@@ -1654,6 +1693,11 @@ end
 -- and the next Play loaded every mod on top of what the last one left.
 function Loader.teardown()
   local undone = select(1, ModSeams.unwindAll())
+  retireCompatibilityCollision()
+  retireBattlePresentation()
+  retireFieldEffects()
+  local stream=package.loaded['src.core.game3.asset_stream']
+  if stream and stream.release then stream.release()end
   pcall(function()
     Runtime.install(Events.new(), Hooks.new(), nil)
     Runtime.currentMod = nil
diff --git a/src/mods/ModSeams.lua b/src/mods/ModSeams.lua
index f4d06a01c..ee6d24223 100644
--- a/src/mods/ModSeams.lua
+++ b/src/mods/ModSeams.lua
@@ -44,6 +44,9 @@
 -- still the mod's to guard; this takes away the common case, not the need.
 
 local ModSeams = {}
+-- Mutation journals must remain operable while an entry has temporarily
+-- replaced global iteration (including a wrapper that throws).
+local pairs,next=pairs,next
 
 -- every change, oldest first: { tbl, key, before, after, owner }
 local journal = {}
@@ -105,9 +108,10 @@ end
 -- open a window.  Returns a token for close().  Never throws.
 function ModSeams.open(owner)
   local ok, token = pcall(function()
-    local snap = {}
+    local snap, seen = {}, {}
     for _, entry in ipairs(watched()) do
       snap[#snap + 1] = { t = entry.t, label = entry.label, before = copyOf(entry.t) }
+      seen[entry.t] = true
     end
     -- an engine module required for the FIRST time inside this window is
     -- snapshotted the moment it loads, before the mod gets it back to wrap
@@ -116,6 +120,25 @@ function ModSeams.open(owner)
     local function require2(name, ...)
       local had = package.loaded[name]
       local result = real(name, ...)
+      if name=='src.core.game3.field_move_show_mon'and type(result)=='table'and result._observeMod then
+        result._observeMod(owner)
+      end
+      if name=='src.world.game3.Follower'or name=='src.compat.game3.Follower'then
+        local facade=package.loaded['src.core.Game3']or real('src.core.Game3')
+        if facade and facade._observeActorMod then facade._observeActorMod(owner)end
+      end
+      -- Importing the distinct GBA game/runtime namespace declares that
+      -- this owner's game-bearing callbacks use that facade. No manifest
+      -- rewrite or mod-id-specific conversion is needed.
+      if name == 'src.core.Game3' or name == 'src.core.game3.runtime' or name == 'src.core.game3.battle' or name == 'src.core.game3.battle_bridge'
+          or type(name)=='string' and name:match('^src%.core%.game3%.battle%.') then
+        local facade = package.loaded['src.core.Game3'] or real('src.core.Game3')
+        if facade and facade._observeMod then facade._observeMod(owner) end
+        if type(facade)=='table' and not seen[facade] and not fresh[facade] then
+          fresh[facade]=true
+          snap[#snap+1]={t=facade,label='src.core.Game3',before=copyOf(facade)}
+        end
+      end
       if had == nil and type(name) == "string" and name:match("^src%.")
           and type(result) == "table" and not fresh[result] then
         fresh[result] = true
diff --git a/src/mods/UnifiedIds.lua b/src/mods/UnifiedIds.lua
new file mode 100644
index 000000000..50866a636
--- /dev/null
+++ b/src/mods/UnifiedIds.lua
@@ -0,0 +1,85 @@
+-- Resolve portable names through this boot's own data, never a hard-coded
+-- National Dex/item-number table (ROM hacks can assign entirely different IDs).
+local Ids = {}
+local function slug(name)
+  if type(name) ~= "string" then return nil end
+  name = name:gsub("é", "e"):gsub("É", "E"):gsub("♀", "_F"):gsub("♂", "_M")
+    :gsub("['’]", ""):upper():gsub("[^%w]+", "_"):gsub("^_+", ""):gsub("_+$", "")
+  name = name:gsub("^(TM)(%d+)$", "%1_%2"):gsub("^(HM)(%d+)$", "%1_%2")
+  return name ~= "" and name or nil
+end
+local aliases = { FARFETCH_D = "FARFETCHD", MR__MIME = "MR_MIME" }
+local function canonical(key, row, kind)
+  if kind == "pokemon" or kind == "moves" or kind == "items" then
+    if type(key) ~= "string" or key:match("^SPECIES_%d+$")
+        or key:match("^MOVE_%d+$") or key:match("^ITEM_%d+$") then
+      return aliases[slug(row.name)] or slug(row.name)
+    end
+    return aliases[key] or key
+  end
+  -- Trainer classes, individual trainers and map IDs are game-specific.
+  return type(key) == "number" and tostring(key) or key
+end
+
+function Ids.new(loader)
+  local indexes = {}
+  local function index(kind)
+    if indexes[kind] then return indexes[kind] end
+    local out = { public = {}, native = {} }
+    indexes[kind] = out
+    local registry = assert(loader.content[kind], "unknown registry " .. tostring(kind))
+    -- Preserve identity/name metadata before the loader merges alias keys
+    -- into separate result tables. Presentation-name patches cannot rename IDs.
+    loader._unifiedIdBase = loader._unifiedIdBase or {}
+    local base = loader._unifiedIdBase[kind]
+    if not base then
+      base = {}
+      for key, row in pairs(registry.base and registry.base() or {}) do
+        if type(row) == "table" then
+          base[key] = { identity = row, id = canonical(key, row, kind) }
+        end
+      end
+      loader._unifiedIdBase[kind] = base
+    end
+    local groups = {}
+    for key, row in registry:each() do
+      if type(row) == "table" and (row.name or kind == "encounters") and key ~= 0 then
+        -- Aliases pointing at one pristine record form one identity even
+        -- after an earlier native mod patched only one of its keys.
+        local identity = base[key] and base[key].identity or row
+        local group = groups[identity]
+        if not group then
+          local id = base[key] and base[key].id or canonical(key, row, kind)
+          if id then
+            group = { id = id, key = key, keys = {} }
+            groups[identity] = group
+            local previous = out.public[id]
+            -- false is an ambiguity marker, never last-writer-wins.
+            if previous ~= nil then out.public[id] = false else out.public[id] = group end
+          end
+        end
+        if group then
+          group.keys[#group.keys + 1] = key
+          out.native[key] = group
+          if type(key) == "number" then group.key = key end
+        end
+      end
+    end
+    return out
+  end
+  return {
+    resolve = function(_, kind, id)
+      local found = index(kind).public[id]
+      if found == false then return nil, "ambiguous " .. kind .. " ID: " .. tostring(id) end
+      if not found then return nil, "unknown " .. kind .. " ID: " .. tostring(id) end
+      return found
+    end,
+    read = function(_, kind, id)
+      if id == nil or id == false or id == 0 or id == "" then return nil end
+      local found = index(kind).native[id]
+      return found and found.id or tostring(id)
+    end,
+    entries = function(_, kind) return index(kind).public end,
+  }
+end
+return Ids
diff --git a/src/mods/WorldReads.lua b/src/mods/WorldReads.lua
new file mode 100644
index 000000000..2ca8f2504
--- /dev/null
+++ b/src/mods/WorldReads.lua
@@ -0,0 +1,227 @@
+-- Data-only readers shared by mod.world. Nothing here constructs a Pokemon,
+-- loads a map, calls gameplay methods or advances either random generator.
+local Ids = require("src.mods.UnifiedIds")
+local Reads = {}
+local METHODS = { party = true, activeBlockAt = true, liveMaps = true }
+
+function Reads.supports(name)
+  return type(name) == "string" and METHODS[name] == true
+end
+
+-- Capture native alias identity/name metadata before the loader splits alias
+-- rows during merging. Fresh indexes at read time still include later mods.
+function Reads.context(loader)
+  local ids = Ids.new(loader)
+  for _, kind in ipairs({ "pokemon", "moves", "items" }) do
+    ids:entries(kind)
+  end
+  return {
+    ids = function()
+      return Ids.new(loader)
+    end,
+  }
+end
+
+-- Engine callers can construct WorldAPI without a mod loader too. The
+-- private registry facade only reads data; Ids' bookkeeping stays on it.
+local function dataIds(data)
+  local loader = { content = {} }
+  for _, kind in ipairs({ "pokemon", "moves", "items" }) do
+    local rows = type(data[kind]) == "table" and data[kind] or {}
+    loader.content[kind] = {
+      base = function()
+        return rows
+      end,
+      each = function()
+        return pairs(rows)
+      end,
+    }
+  end
+  return Ids.new(loader)
+end
+
+local function copy(value, seen)
+  local kind = type(value)
+  if kind ~= "table" then
+    if kind == "number" or kind == "string" or kind == "boolean" then
+      return value
+    end
+    return nil
+  end
+  seen = seen or {}
+  if seen[value] then
+    return seen[value]
+  end
+  local out = {}
+  seen[value] = out
+  for key, sub in pairs(value) do
+    if type(key) == "string" or type(key) == "number" then
+      out[key] = copy(sub, seen)
+    end
+  end
+  return out
+end
+local STATUS =
+  { SLP = "sleep", PSN = "poison", BRN = "burn", FRZ = "freeze", PAR = "paralyze", TOX = "toxic" }
+local STAT = {
+  hp = "hp",
+  attack = "attack",
+  defense = "defense",
+  speed = "speed",
+  special = "special",
+  specialAttack = "spatk",
+  specialDefense = "spdef",
+}
+
+-- The same common live-Pokemon shape as the unified callback boundary.
+-- Native diagnostics are data-only copies, including unknown save extensions.
+function Reads.party(game, context)
+  local save = game and game.save
+  if not save then
+    return nil, "no save"
+  end
+  local data = game.data or {}
+  local ids = context and context.ids() or dataIds(data)
+  local out = {}
+  for i, raw in ipairs(save.party or {}) do
+    local stats, moves = {}, {}
+    for key, native in pairs(STAT) do
+      stats[key] = (raw.stats or {})[native]
+    end
+    stats.specialAttack = stats.specialAttack or stats.special
+    stats.specialDefense = stats.specialDefense or stats.special
+    for slot, move in ipairs(raw.moves or {}) do
+      local id = type(move) == "table" and move.id or move
+      local def = (data.moves or {})[id]
+      local ups = type(move) == "table" and (move.ppUps or 0) or 0
+      moves[slot] = {
+        id = ids:read("moves", id),
+        pp = type(move) == "table" and move.pp or nil,
+        maxPp = def and ((def.pp or 0) + ups * math.floor((def.pp or 0) / 5)) or nil,
+        ppUps = ups,
+      }
+    end
+    out[i] = {
+      species = ids:read("pokemon", raw.species),
+      item = ids:read("items", raw.item),
+      nickname = raw.nickname,
+      name = raw.name,
+      level = raw.level,
+      hp = raw.hp,
+      maxHp = raw.stats and raw.stats.hp,
+      status = STATUS[raw.status] or raw.status,
+      isEgg = raw.isEgg == true,
+      stats = stats,
+      moves = moves,
+      native = copy(raw),
+    }
+  end
+  return out
+end
+
+local function integer(value, low)
+  return type(value) == "number"
+    and value == value
+    and value < math.huge
+    and value > -math.huge
+    and value % 1 == 0
+    and value >= low
+end
+
+-- Public block coordinates are zero-based, not walk-cell coordinates. Derive
+-- geometry from this map's runtime tileset, not the selected game's number.
+function Reads.metadata(map)
+  local def = map and map.def
+  if
+    not def
+    or not integer(def.width, 1)
+    or not integer(def.height, 1)
+    or not integer(map.blockCells, 1)
+    or not integer(map.blockTiles, 1)
+    or map.blockTiles * 8 ~= map.blockCells * 16
+  then
+    return nil, "block geometry unavailable"
+  end
+  return {
+    tileSize = map.blockTiles * 8,
+    cellSize = 16,
+    coordinateBase = 0,
+    kind = (def.generation == 4 or def.generation == 5 or def.gen5) and "runtime_cell"
+      or map.blockCells == 1 and "metatile"
+      or "block",
+    width = def.width,
+    height = def.height,
+  }
+end
+
+function Reads.activeBlockAt(map, mapId, bx, by)
+  if map.id ~= mapId then
+    return nil, "map is not active"
+  end
+  if not integer(bx, 0) or not integer(by, 0) then
+    return nil, "invalid block coordinates"
+  end
+  local metadata, reason = Reads.metadata(map)
+  if not metadata then
+    return nil, reason
+  end
+  if bx >= metadata.width or by >= metadata.height then
+    return nil, "block coordinates out of bounds"
+  end
+  local index = by * metadata.width + bx + 1
+  local block = map.blockPatch and map.blockPatch[index]
+  if block == nil then
+    local blocks = map.def.blocks
+    if type(blocks) == "table" then
+      block = blocks[index]
+    elseif type(blocks) == "string" then
+      -- Respect a cache already used by Map:blockAt, without populating it.
+      if map.def._blockArray then
+        block = map.def._blockArray[index]
+      else
+        local lo, hi = blocks:byte(index * 2 - 1, index * 2)
+        if hi then
+          block = (lo + hi * 256) % 1024
+        end
+      end
+    end
+  end
+  if not integer(block, 0) then
+    return nil, "block unavailable"
+  end
+  return block, metadata
+end
+
+function Reads.liveMaps(world)
+  local active = world.map
+  local out = {}
+  local seen = {}
+  local function add(map, x, y, isActive)
+    if not map then
+      return
+    end
+    -- A connected layout can show one map at several different offsets.
+    -- Collapse duplicate placements only, retaining the spatial instances.
+    local key = tostring(map.id) .. ":" .. tostring(x) .. ":" .. tostring(y)
+    if seen[key] then
+      return
+    end
+    seen[key] = true
+    local metadata = Reads.metadata(map)
+    out[#out + 1] = {
+      mapId = map.id,
+      x = x,
+      y = y,
+      active = isActive,
+      width = map.widthCells,
+      height = map.heightCells,
+      block = metadata,
+    }
+  end
+  add(active, 0, 0, true)
+  for _, neighbor in ipairs(world.neighbors or {}) do
+    add(neighbor.map, neighbor.cx or 0, neighbor.cy or 0, false)
+  end
+  return out
+end
+return Reads
diff --git a/src/pokemon/Evolution.lua b/src/pokemon/Evolution.lua
index 321387210..618180d69 100644
--- a/src/pokemon/Evolution.lua
+++ b/src/pokemon/Evolution.lua
@@ -413,14 +413,21 @@ function Evolution.learnEvolutionMoves(game, mon, onDone)
   -- movesLearnedAt uses entry.level == level (exact Gen1 rule); do NOT use
   -- Pokemon.movesAtLevel (<= level), which would over-grant older moves.
   local moves = Experience.movesLearnedAt(def, mon.level)
+  return Evolution.learnMoves(game,mon,moves,function()
+    local from=shedinjaPending[mon];shedinjaPending[mon]=nil
+    if from then Evolution.createShedinja(game,mon,from)end
+    if onDone then onDone()end
+  end)
+end
+
+-- The same free-slot/forget flow also serves explicit native reminders.
+function Evolution.learnMoves(game,mon,moves,onDone)
+  local def=game.data.pokemon[mon.species]
   local i = 0
   local function nextStep()
     i = i + 1
     local moveId = moves[i]
     if not moveId then
-      local from = shedinjaPending[mon]
-      shedinjaPending[mon] = nil
-      if from then Evolution.createShedinja(game, mon, from) end
       if onDone then onDone() end
       return
     end
diff --git a/src/pokemon/Gen3PictureIdentity.lua b/src/pokemon/Gen3PictureIdentity.lua
new file mode 100644
index 000000000..ba3417389
--- /dev/null
+++ b/src/pokemon/Gen3PictureIdentity.lua
@@ -0,0 +1,24 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Cartridge picture slots are distinct from logical species records.
+-- pokefirered ce6406d8: constants/species.h and LoadSpecialPokePic.
+local M={UNOWN=201,FIRST_VARIANT=413,VARIANTS=27}
+function M.letter(personality)
+ local p=tonumber(personality)or 0
+ if p~=p or math.abs(p)==math.huge or p%1~=0 then return nil,'invalid personality' end
+ p=p%4294967296
+ local packed=p%4+4*(math.floor(p/256)%4)+16*(math.floor(p/65536)%4)+64*(math.floor(p/16777216)%4)
+ return packed%28
+end
+function M.slot(species,personality)
+ if species~=M.UNOWN then return species end
+ local form,why=M.letter(personality);if form==nil then return nil,why end
+ return form==0 and species or M.FIRST_VARIANT+form-1
+end
+function M.base(slot)
+ if slot==M.UNOWN then return slot,0 end
+ if type(slot)=='number'and slot%1==0 and slot>=M.FIRST_VARIANT and slot<M.FIRST_VARIANT+M.VARIANTS then
+  return M.UNOWN,slot-M.FIRST_VARIANT+1
+ end
+ return slot,nil
+end
+return M
diff --git a/src/render/BattleScreenEffect.lua b/src/render/BattleScreenEffect.lua
new file mode 100644
index 000000000..ff45819cf
--- /dev/null
+++ b/src/render/BattleScreenEffect.lua
@@ -0,0 +1,62 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Repeated begin calls reapply an effect within one render seam. Nested seams
+-- each restore their caller's shader, including error paths guarded by Scope.
+local Scope=require('src.render.GraphicsScope')
+local M={};M.__index=M
+local codes={invert=1,fade_white=2,fade_black=3,darken=3,grayscale=4,custom_blend=5}
+local source=[[
+extern number mode;
+extern number amount;
+extern vec3 blendColour;
+vec4 effect(vec4 colour, Image image, vec2 uv, vec2 screen) {
+  vec4 pixel=Texel(image,uv)*colour;
+  vec3 target=pixel.rgb;
+  if(mode<1.5) target=vec3(1.0)-pixel.rgb;
+  else if(mode<2.5) target=vec3(1.0);
+  else if(mode<3.5) target=vec3(0.0);
+  else if(mode<4.5) target=vec3(dot(pixel.rgb,vec3(0.299,0.587,0.114)));
+  else target=blendColour;
+  pixel.rgb=mode<1.5 ? target : mix(pixel.rgb,target,amount);
+  return pixel;
+}
+]]
+function M.new()
+  return setmetatable({value={type='none',coeff=0,targetColor={1,1,1}},
+    bindings=setmetatable({},{__mode='k'}),outside={}},M)
+end
+function M:set(opts)
+  if not opts or opts.type==false or opts.type=='none'then
+    self.value={type='none',coeff=0,targetColor={1,1,1}};return true
+  end
+  local kind=opts.type or'invert'
+  assert(codes[kind],'unsupported battle screen effect')
+  local amount=opts.coeff==nil and 1 or opts.coeff
+  assert(type(amount)=='number'and amount==amount and amount>=0 and amount<=1,'invalid battle effect strength')
+  local colour=opts.targetColor or{1,1,1};local copy={}
+  for i=1,3 do local v=colour[i];assert(type(v)=='number'and v==v and v>=0 and v<=1,'invalid battle effect colour');copy[i]=v end
+  self.value={type=kind,coeff=amount,targetColor=copy};return true
+end
+function M:begin()
+  local value=self.value;local code=codes[value.type]
+  if not code then return false end
+  local g=love.graphics
+  if not self.shader then self.shader=g.newShader(source)end
+  local token=Scope.token()or self.outside
+  local previous=self.bindings[token]
+  if not previous then previous={shader=g.getShader()};self.bindings[token]=previous end
+  self.shader:send('mode',code);self.shader:send('amount',value.coeff)
+  self.shader:send('blendColour',value.targetColor)
+  g.setShader(self.shader);return true
+end
+function M:finish()
+  local token=Scope.token()or self.outside;local previous=self.bindings[token]
+  if not previous then return false end
+  self.bindings[token]=nil;love.graphics.setShader(previous.shader);return true
+end
+function M:release()
+  -- A surrounding render guard restores a shader still in use on an error
+  -- path. Do not destroy a borrowed binding during that unwind.
+  if self.shader and love.graphics.getShader()~=self.shader then self.shader:release();self.shader=nil end
+  self.bindings=setmetatable({},{__mode='k'})
+end
+return M
diff --git a/src/render/FieldFade.lua b/src/render/FieldFade.lua
new file mode 100644
index 000000000..f7d1cfb94
--- /dev/null
+++ b/src/render/FieldFade.lua
@@ -0,0 +1,137 @@
+-- Copyright (c) 2026 Cedric. All rights reserved.
+-- Source-available under the Gen2Recomped License (see LICENSE.md).
+-- Shared native script-fade painter and fixed-step controller. Source callers
+-- use this same controller; native scripts keep their original ramp and wait.
+local Logger=require('src.core.Logger')
+local FadeOverlay = {}
+FadeOverlay.__index = FadeOverlay
+
+function FadeOverlay.new(game, ow, color, opts)
+  return setmetatable({
+    game = game, ow = ow, alpha = 0, color = color or "black",
+    ownedHold = opts and opts.ownedHold or false,
+  }, FadeOverlay)
+end
+
+-- A FADE IS A PALETTE EFFECT, NOT A MODE -- the world keeps running under it.
+--
+-- The state stack only updates the state on TOP, so while this overlay is up
+-- it is the only thing being ticked.  Ticking nothing but the script runner
+-- starves the very thing most scripts do behind a fade: MOVE SOMEBODY.  The
+-- move queue never steps, `waitmovement` never completes, the map's frame
+-- table is never re-asked, and the player is left looking at black with a
+-- script that can no longer finish -- which is exactly what Route 101's
+-- rescue does (fadescreen, removeobject, setobjectxy, applymovement,
+-- waitmovement) three commands after the screen goes dark.
+--
+-- So pump the field itself.  Only while something is actually driving it: with
+-- no script and no queued move there is nothing to advance, and running the
+-- field then would hand the player an input frame behind a black screen.
+function FadeOverlay:update(dt)
+  if self.sourceRetired then return end
+  local ow = self.ow
+  if ow then
+    local runner = ow.runner
+    local busy = (runner and runner.isRunning and runner:isRunning())
+      or (ow.scriptMoves and #ow.scriptMoves > 0)
+      or (ow.pendingScripts and ow.pendingScripts[1] ~= nil)
+    if busy and ow.update then
+      ow:update(dt or 1 / 60)
+    elseif runner then
+      runner:update()
+    end
+    -- THE WATCHDOG, because a screen stuck at black is the one failure a
+    -- player cannot tell from a crash.
+    --
+    -- A fade is always meant to be undone by something: the script's own
+    -- fade back, the `waitstate` that ends the scene, or the runner when the
+    -- script finishes.  If all three miss it, the game is still running --
+    -- input is even accepted -- behind a fully opaque rectangle, and the only
+    -- report anybody can make is "it went black".  Two seconds of full black
+    -- with nothing driving the field is not a beat in either cartridge, so
+    -- bring the picture back and say why once.
+    if not self.ownedHold and not self.ramp and (self.alpha or 0) >= 1 and not busy then
+      self.idleFrames = (self.idleFrames or 0) + 1
+      if self.idleFrames >= 120 then
+        Logger.warn("the screen has been faded out for two seconds with no "
+                      .. "script running -- fading back in; whatever darkened "
+                      .. "it never undid it")
+        self.ramp = { from = self.alpha, to = 0, frames = 12, t = 0 }
+        self.idleFrames = nil
+      end
+    else
+      self.idleFrames = nil
+    end
+  end
+  local ramp = self.ramp
+  if not ramp then return end
+  ramp.t = ramp.t + 1
+  local k = math.min(1, ramp.t / ramp.frames)
+  if ramp.steps then k=math.min(1,math.floor(ramp.t/(ramp.stepFrames or 1))/ramp.steps)end
+  self.alpha = ramp.from + (ramp.to - ramp.from) * k
+  if ramp.t >= ramp.frames then
+    self.ramp = nil
+    if ramp.to <= 0 then
+      -- a box may sit above the overlay; remove in place, not pop
+      local states = self.game.stack.states
+      for i = #states, 1, -1 do
+        if states[i] == self then table.remove(states, i) break end
+      end
+      self:releaseVeil()
+      if ow then ow.fadeOverlay = nil end
+    end
+    if ramp.onDone then ramp.onDone() end
+  end
+end
+
+-- ...AND ON THE WHOLE SURFACE'S ORIGIN.  A state with no uiSize is centred as
+-- Game Boy furniture (Game:draw's classicOffset), which slid the 240x160
+-- rectangle 40 right and 8 down and left an unfaded L down the left and top
+-- through Mom's heal.
+function FadeOverlay:uiSize()
+  return require("src.ui.Theme").uiSize()
+end
+
+function FadeOverlay:releaseVeil()
+  local r = self.game and self.game.renderer
+  if self.ownsVeil and r then r.screenVeil = nil end
+  self.ownsVeil = nil
+end
+
+function FadeOverlay:draw()
+  if self.sourceRetired then return end
+  -- A PALETTE FADE HAS NO OUTSIDE.  When nothing is drawn over the fade it is
+  -- painted as the renderer's whole-window veil, so the world bleeding past
+  -- the 240x160 surface darkens with it; with a box above it, it stays a
+  -- rectangle in the surface so the box remains readable.
+  local r = self.game and self.game.renderer
+  if r and self.game.stack:top() == self then
+    r.screenVeil = { self.color == "white" and 1 or 0, self.alpha or 0 }
+    self.ownsVeil = true
+    return
+  end
+  self:releaseVeil()
+  if self.color == "white" then
+    love.graphics.setColor(1, 1, 1, self.alpha)
+  else
+    love.graphics.setColor(0, 0, 0, self.alpha)
+  end
+  -- THE WHOLE SCREEN, not the Game Boy's.  Fixed at 160x144 this covered the
+  -- top-left five eighths of a GBA surface and left an unfaded L down the
+  -- right and along the bottom, which is worse than no fade at all.
+  local w, h = require("src.ui.Theme").uiSize()
+  love.graphics.rectangle("fill", 0, 0, w, h)
+  love.graphics.setColor(1, 1, 1, 1)
+end
+
+function FadeOverlay:exit()
+  self:releaseVeil()
+  if self.ow and self.ow.fadeOverlay==self then self.ow.fadeOverlay=nil end
+end
+function FadeOverlay.describe(state)
+  if getmetatable(state)~=FadeOverlay then return nil end
+  local ramp=state.ramp
+  local direction=ramp and(ramp.to>=ramp.from and 1 or -1)or state.sourceFadeDirection or 0
+  return state.alpha or 0,state.color=='white',direction,ramp~=nil,true
+end
+return FadeOverlay
diff --git a/src/render/Font.lua b/src/render/Font.lua
index 30b2e4a78..92935c92d 100644
--- a/src/render/Font.lua
+++ b/src/render/Font.lua
@@ -404,6 +404,7 @@ end
 -- cartridge's own `{COLOR n}` does: swap the letter's colour and leave the
 -- shadow where it was.
 local twoToneShader, twoTonePrev, twoToneDepth = nil, nil, 0
+local twoToneColors={}
 
 local function twoTone()
   if twoToneShader == nil then
@@ -432,6 +433,7 @@ function Font.beginTwoTone(ink, shadow)
     love.graphics.setShader(sh)
   end
   twoToneDepth = twoToneDepth + 1
+  twoToneColors[twoToneDepth]={ink={ink[1]or 0,ink[2]or 0,ink[3]or 0,ink[4]or 1},shadow={shadow[1]or 0,shadow[2]or 0,shadow[3]or 0,shadow[4]or 1}}
   pcall(sh.send, sh, "inkColor",
         { ink[1] or 0, ink[2] or 0, ink[3] or 0, ink[4] or 1 })
   pcall(sh.send, sh, "shadowColor",
@@ -441,10 +443,15 @@ end
 
 function Font.endTwoTone()
   if not twoTone() or twoToneDepth == 0 then return end
+  twoToneColors[twoToneDepth]=nil
   twoToneDepth = twoToneDepth - 1
   if twoToneDepth == 0 then
     love.graphics.setShader(twoTonePrev)
     twoTonePrev = nil
+  else
+    local colors=twoToneColors[twoToneDepth]
+    pcall(twoToneShader.send,twoToneShader,'inkColor',colors.ink)
+    pcall(twoToneShader.send,twoToneShader,'shadowColor',colors.shadow)
   end
 end
 
@@ -1087,8 +1094,7 @@ end
 
 -- Dock the full painted ROM frame, including caps beyond the conventional
 -- interior-plus-one-border rectangle. Otherwise only the middle moves.
-function Font.dialogueBoxBounds(tx, ty, tw, th)
-  local rec = Font.hasDialogueFrame() and state.def.dialogueFrame
+local function recordedFrameBounds(rec, tx, ty, tw, th)
   if rec and rec.layout == 'gen4' and tw >= 3 and th >= 3 then
     return (tx-1)*8, ty*8, (tw+3)*8, th*8
   elseif rec and rec.layout ~= 'gen4' and th >= 4 then
@@ -1096,6 +1102,9 @@ function Font.dialogueBoxBounds(tx, ty, tw, th)
   end
   return tx*8, ty*8, tw*8, th*8
 end
+function Font.dialogueBoxBounds(tx, ty, tw, th)
+  return recordedFrameBounds(Font.hasDialogueFrame() and state.def.dialogueFrame,tx,ty,tw,th)
+end
 
 local function prepareFrameStrip(rec)
   if rec and dialogueSheet.path ~= rec.image then
@@ -1176,6 +1185,10 @@ function Font.hasSignpostFrame()
   local def = state and state.def
   return not FALLBACK.enabled and def ~= nil and def.signpostFrame ~= nil
 end
+function Font.signpostBoxBounds(tx, ty, tw, th)
+  if not Font.hasSignpostFrame()then return Font.dialogueBoxBounds(tx,ty,tw,th)end
+  return recordedFrameBounds(state.def.signpostFrame,tx,ty,tw,th)
+end
 
 function Font.drawSignpostBox(tx, ty, tw, th)
   local rec = Font.hasSignpostFrame() and state.def.signpostFrame
@@ -1213,4 +1226,35 @@ function Font.drawStandardBox(tx, ty, tw, th)
   end
 end
 
+-- GBA frame decoration shares the native helper, imported artwork and frame
+-- lifetime. Other generations and frames without a provider take the same
+-- native bodies without constructing presentation contexts.
+local frameUnpack=table.unpack or unpack
+local function framePack(...)return{n=select('#',...),...}end
+for name,style in pairs{drawBox='user',drawStandardBox='standard',drawDialogueBox='dialogue',drawSignpostBox='sign'}do
+  local body=Font[name]
+  Font[name]=function(tx,ty,tw,th,frameOverride)
+    local presentation=package.loaded['src.render.NativePresentation']
+    if not(presentation and presentation._inFrame())then return body(tx,ty,tw,th,frameOverride)end
+    local ctx={style=style,x=tx*8,y=ty*8,width=tw*8,height=th*8,frame=frameOverride}
+    if style=='dialogue'then ctx.x,ctx.y,ctx.width,ctx.height=Font.dialogueBoxBounds(tx,ty,tw,th)
+    elseif style=='sign'then ctx.x,ctx.y,ctx.width,ctx.height=Font.signpostBoxBounds(tx,ty,tw,th)end
+    local postColor,postFont
+    local function paint(...)
+      local result=framePack(body(...))
+      postColor={love.graphics.getColor()}
+      if love.graphics.getFont then postFont=love.graphics.getFont()end
+      return frameUnpack(result,1,result.n)
+    end
+    -- These are the native font helper's documented postconditions, not
+    -- provider state. Subsequent native labels still see its white ink/font.
+    local function restorePost()
+      if postColor then love.graphics.setColor(frameUnpack(postColor))end
+      if postFont then love.graphics.setFont(postFont)end
+    end
+    local result=framePack(presentation._nativeDraw('frame',ctx,paint,restorePost,tx,ty,tw,th,frameOverride))
+    restorePost()
+    return frameUnpack(result,1,result.n)
+  end
+end
 return Font
diff --git a/src/render/Gen3FieldEffectCatalog.lua b/src/render/Gen3FieldEffectCatalog.lua
new file mode 100644
index 000000000..b3dd84993
--- /dev/null
+++ b/src/render/Gen3FieldEffectCatalog.lua
@@ -0,0 +1,33 @@
+-- Imported field artwork, without allocating images or observing an actor.
+-- Names describe identified native records; unavailable effects stay absent.
+local M={}
+local function integer(n,lo,hi)
+  return type(n)=='number'and n==n and n%1==0 and n>=lo and n<=hi
+end
+function M.record(row)
+  if type(row)~='table'then return nil end
+  local path=row.image or row.path
+  local w,h,n=row.frameWidth,row.frameHeight,row.frames
+  if type(path)~='string'or#path==0 or#path>1024 or not integer(w,8,128)
+      or not integer(h,8,128)or not integer(n,1,256)or w*h*n>1048576 then return nil end
+  return {path=path,fw=w,fh=h,frames=n}
+end
+function M.records(data)
+  local c=type(data)=='table'and data.constants or{};local out={}
+  for name,key in pairs({tall_grass='gen3TallGrass',surf_blob='gen3SurfBlob',fly_bird='gen3FRLGFlyBird'})do
+    out[name]=M.record(c[key])
+  end
+  for name,key in pairs({ripple='gen3Ripple',sparkle='gen3Sparkle'})do
+    local set=c[key];local row=set and data.sprites and data.sprites[set.key]
+    if row and row.trueColor==true and not row.big and not row.monIcon then out[name]=M.record(row)end
+  end
+  -- Native emote strips have independent geometry/order. Do not concatenate
+  -- them into an assumed fifteen-frame source strip.
+  for _,name in ipairs({'exclamation','question','heart'})do
+    local row=c.gen3Emotes and c.gen3Emotes[name]
+    if row then out['emote_'..name]=M.record({image=row.image,frameWidth=row.width,
+      frameHeight=row.height,frames=row.frames})end
+  end
+  return out
+end
+return M
diff --git a/src/render/Gen3HelpText.lua b/src/render/Gen3HelpText.lua
new file mode 100644
index 000000000..a32ae5938
--- /dev/null
+++ b/src/render/Gen3HelpText.lua
@@ -0,0 +1,91 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Static Help articles consume the same structured catalog and native font
+-- cells as dialogue. Timing/audio operands do not start another printer.
+local Font=require('src.render.Font')
+local Text=require('src.core.game3.rom_text')
+local M={}
+local placeholders={[0]='UNKNOWN','PLAYER','VAR1','VAR2','VAR3','KUN','RIVAL',
+ 'VERSION','AQUA','MAGMA','ARCHIE','MAXIE','KYOGRE','GROUDON'}
+local faces={[0]='small',[4]='male',[5]='female'}
+local icons={A_BUTTON=0,B_BUTTON=1,L_BUTTON=2,R_BUTTON=3,START_BUTTON=4,SELECT_BUTTON=5,
+ DPAD_UP=6,DPAD_DOWN=7,DPAD_LEFT=8,DPAD_RIGHT=9,DPAD_UPDOWN=10,DPAD_LEFTRIGHT=11,DPAD_ANY=12}
+local function withFace(name,fn)
+ local pushed=name and Font.hasFace(name)
+ if pushed then Font.pushFace(name)end
+ local ok,result=pcall(fn)
+ if pushed then Font.popFace()end
+ if not ok then error(result,0)end
+ return result
+end
+function M.layout(nodes,width,keypad,fill)
+ assert(type(nodes)=='table'and type(width)=='number'and width>0,'invalid native Help text layout')
+ local out,x,y,face,spacing={},0,0,nil,0
+ local ink,shadow=1,2
+ local function newline()x=0;y=y+15 end
+ local function add(code,icon)
+  local advance=icon and assert(keypad.regions[icon+1]).width
+   or withFace(face,function()return Font.advanceOf(code)end)
+  if x>0 and x+advance>width then newline()end
+  out[#out+1]={code=code,icon=icon,x=x,y=y,face=face,ink=ink,shadow=shadow}
+  x=x+math.max(spacing,advance)
+ end
+ local function text(value)
+  local remaining=tostring(value)
+  while true do
+   local at=remaining:find('\n',1,true)
+   local part=at and remaining:sub(1,at-1)or remaining
+   if part:match('^%s+$')then for _,code in ipairs(Font.encode(part))do add(code)end end
+   for word in part:gmatch('%s*%S+%s*')do
+    local codes=Font.encode(word)
+    local length=withFace(face,function()
+     local n=0;for _,code in ipairs(codes)do n=n+math.max(spacing,Font.advanceOf(code))end;return n
+    end)
+    if x>0 and x+length>width then newline()end
+    for _,code in ipairs(codes)do add(code)end
+   end
+   if not at then break end
+   newline();remaining=remaining:sub(at+1)
+  end
+ end
+ for _,node in ipairs(nodes)do
+  if node.t=='text'then text(node.s)
+  elseif node.t=='ph'then text(Text._expand('{'..(placeholders[node.code]or('PH:%02X'):format(node.code))..'}',fill))
+  elseif node.t=='tag'then
+   if node.control==0xF9 then add(256+node.code)
+   elseif node.control==0xF8 then add(nil,node.code)
+   else
+    local icon=icons[node.tag:match('^%{(.-)%}$')]
+    if icon then add(nil,icon)else text(Text._expand(node.tag,fill))end
+   end
+  elseif node.t=='nl'or node.t=='scroll'or node.t=='para'then newline()
+  elseif node.t=='ext'then
+   local cmd,a=node.cmd,node.args or{}
+   if cmd==1 then ink=a[1]elseif cmd==3 then shadow=a[1]
+   elseif cmd==4 then ink,shadow=a[1],a[3]
+   elseif cmd==6 then face=faces[a[1]]elseif cmd==7 then face=nil
+   elseif cmd==12 then text(node.literal or'')
+   elseif cmd==13 or cmd==18 then x=a[1]
+   elseif cmd==14 then y=a[1]
+   elseif cmd==17 then x=x+a[1]
+   elseif cmd==19 then x=math.max(x,a[1])
+   elseif cmd==20 then spacing=a[1]end
+  elseif node.t~='eos'then error('unknown native Help text node: '..tostring(node.t))end
+ end
+ return{glyphs=out,height=y+15}
+end
+function M.draw(layout,x,y,palette,icons,scroll)
+ for _,glyph in ipairs(layout.glyphs)do
+  local yy=y+glyph.y-(scroll or 0)*15
+  if glyph.icon~=nil then
+   local icon=assert(icons[glyph.icon+1],'native keypad icon unavailable')
+   love.graphics.setColor(1,1,1,1);love.graphics.draw(icon,x+glyph.x,yy)
+  else
+   withFace(glyph.face,function()
+    Font.pushStyle({text=assert(palette[glyph.ink+1]),shadow=assert(palette[glyph.shadow+1])})
+    local ok,why=pcall(Font.drawCode,glyph.code,x+glyph.x,yy)
+    Font.popStyle();if not ok then error(why,0)end
+   end)
+  end
+ end
+end
+return M
diff --git a/src/render/Gen3IndexedPalette.lua b/src/render/Gen3IndexedPalette.lua
new file mode 100644
index 000000000..81e87c4be
--- /dev/null
+++ b/src/render/Gen3IndexedPalette.lua
@@ -0,0 +1,68 @@
+-- Native indexed-backdrop lookup follows src/battle/Gen3Battle.lua (Cedric).
+-- Copyright (c) 2026 Cedric. Existing Gen2Recomped licence remains applicable.
+-- Bank factoring and packed-colour helpers: copyright (c) 2026 Roxas2712.
+-- See LICENSE-ROXAS2712.md for those original contributions.
+-- Each consumer owns its bank. Sharing shader uniforms across a native draw
+-- and a source draw would corrupt the caller even after restoring its shader.
+local bit=require('bit')
+local M={}
+local unpack=table.unpack or unpack
+local zero={0,0,0}
+function M.rgb(value)
+ value=tonumber(value)or 0
+ return bit.band(value,31),bit.band(bit.rshift(value,5),31),bit.band(bit.rshift(value,10),31)
+end
+function M.pack(r,g,b)
+ return bit.bor(bit.band(r or 0,31),bit.lshift(bit.band(g or 0,31),5),bit.lshift(bit.band(b or 0,31),10))
+end
+function M.blend5(r,g,b,coefficient,tr,tg,tb)
+ local c=tonumber(coefficient)or 0
+ return r+math.floor((tr-r)*c/16),g+math.floor((tg-g)*c/16),b+math.floor((tb-b)*c/16)
+end
+function M.gray5(r,g,b)local c=math.floor((r+g+b)/3);return c,c,c end
+function M.blendColor(value,coefficient,target)
+ local r,g,b=M.rgb(value);local tr,tg,tb=M.rgb(target)
+ return M.pack(M.blend5(r,g,b,coefficient,tr,tg,tb))
+end
+function M.new(opts)
+ opts=opts or{}
+ local bank={cutout=opts.cutout==true,paletteAlpha=opts.paletteAlpha==true,vectors={}}
+ for i=1,16 do bank.vectors[i]={0,0,0,1}end
+ function bank:shader()
+  if self.program then return self.program end
+  if self.failed then return nil,self.failed end
+  if not(love and love.graphics and love.graphics.newShader)then return nil,'native shader compiler unavailable'end
+  local choices={}
+  for i=0,15 do choices[#choices+1]=(i==0 and 'if'or'else if')..(' (index<%d.5)chosen=pal[%d];'):format(i,i)end
+  local source=[[
+extern vec4 pal[16];
+vec4 effect(vec4 colour, Image tex, vec2 uv, vec2 screen) {
+ vec4 px=Texel(tex,uv);
+]]..(self.cutout and ' if(px.a<0.5)return vec4(0.0);\n'or'')..[[
+ float index=floor(px.r*15.0+0.5);
+ vec4 chosen=pal[0];
+]]..table.concat(choices,'\n')..'\n'..(self.cutout and ''or' chosen.a*=px.a;\n')..[[
+ return chosen*colour;
+}
+]]
+  local ok,shader=pcall(love.graphics.newShader,source)
+  if not ok then self.failed=tostring(shader);return nil,self.failed end
+  self.program=shader;return shader
+ end
+ function bank:sendNormalized(colours)
+  assert(type(colours)=='table','indexed palette requires normalized colours')
+  local shader,why=self:shader();if not shader then return nil,why end
+  for i=1,16 do
+   local c,v=colours[i]or zero,self.vectors[i]
+   v[1],v[2],v[3]=c[1]or 0,c[2]or 0,c[3]or 0
+   v[4]=self.paletteAlpha and(c[4]==nil and 1 or c[4])or 1
+  end
+  shader:send('pal',unpack(self.vectors));return shader
+ end
+ function bank:release()
+  if self.program and self.program.release then self.program:release()end
+  self.program,self.failed=nil,nil
+ end
+ return bank
+end
+return M
diff --git a/src/render/Gen3TextPen.lua b/src/render/Gen3TextPen.lua
new file mode 100644
index 000000000..eff0316bf
--- /dev/null
+++ b/src/render/Gen3TextPen.lua
@@ -0,0 +1,87 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Shared native measurement/paint cursor for embedded GBA positioning codes.
+-- Ordinary UTF-8 strings continue through the existing proportional font path.
+local Font=require('src.render.Font')
+local M={}
+local codes={[0x0d]=true,[0x0e]=true,[0x11]=true,[0x12]=true,[0x13]=true,[0x14]=true}
+local compound='{POKEBLOCK}'
+local firstCompound,lastCompound=0x55,0x59
+function M.isCompound(text)return text==compound end
+function M.compoundWidth(text)
+ if text~=compound then return end
+ local width=0;for code=firstCompound,lastCompound do width=width+Font.advanceOf(code)end
+ return width
+end
+function M.drawCompound(text,x,y)
+ if text~=compound then return end
+ local pen=x
+ for code=firstCompound,lastCompound do Font.drawCode(code,pen,y);pen=pen+Font.advanceOf(code)end
+ return pen-x
+end
+function M.has(text)return type(text)=='string'and(text:find(string.char(0xfc),1,true)~=nil or text:find(compound,1,true)~=nil)end
+function M.layout(text,opts,paint)
+ opts=opts or{}
+ -- Validate the entire stream before paint. A missing operand must never be
+ -- swallowed as a glyph or leave half of a malformed label on the canvas.
+ local at=1
+ while true do
+  local p=text:find(string.char(0xfc),at,true);if not p then break end
+  assert(p+2<=#text,'truncated native text pen control')
+  assert(codes[text:byte(p+1)],'unsupported native text pen control')
+  at=p+3
+ end
+ local x,y,widest,minWidth,count=0,0,0,0,0
+ local spacing=opts.letterSpacing or 0
+ local trailing=0
+ local function lineWidth()return math.max(0,x-trailing)end
+ local function glyph(glyph,code)
+  if opts.limitChars and count>=opts.limitChars then return false end
+  local width=code and Font.advanceOf(code)or Font.width(glyph)
+  if paint and(not opts.maxWidth or x+width<=opts.maxWidth)then paint(glyph,x,y,code)end
+  trailing=minWidth>0 and 0 or spacing
+  x=x+math.max(width,minWidth)+trailing;count=count+1
+  return true
+ end
+ local function ordinary(value)
+  for _,span in ipairs(Font.split(value))do
+   if opts.limitChars and count>=opts.limitChars then return false end
+   local symbol=value:sub(span.from,span.to)
+   if symbol=='\n'or symbol=='\v'or symbol=='\f'then
+    widest=math.max(widest,lineWidth());x=0;y=y+(opts.linePitch or 15);trailing=0
+    count=count+1
+   elseif not glyph(symbol)then return false end
+  end
+  return true
+ end
+ local function segment(value)
+  local start=1
+  while start<=#value do
+   local first,last=value:find(compound,start,true)
+   if not ordinary(value:sub(start,first and first-1 or #value))then return false end
+   if not first then break end
+   -- These five native cartridge glyphs form one 40px action label. Do not
+   -- re-encode its letters through the ordinary proportional Latin charmap.
+   for code=firstCompound,lastCompound do if not glyph(nil,code)then return false end end
+   start=last+1
+  end
+  return true
+ end
+ at=1
+ while at<=#text do
+  local p=text:find(string.char(0xfc),at,true)
+  if not segment(text:sub(at,p and p-1 or #text))then break end
+  if not p then break end
+  local cmd,value=text:byte(p+1,p+2)
+  if cmd==0x14 then minWidth=value
+  elseif cmd==0x0e then y=value
+  else
+   trailing=0
+   if cmd==0x11 then x=x+value
+   elseif cmd==0x13 then x=math.max(x,value)
+   else x=value end
+  end
+  at=p+3
+ end
+ return math.max(widest,lineWidth())
+end
+return M
diff --git a/src/render/GraphicsScope.lua b/src/render/GraphicsScope.lua
new file mode 100644
index 000000000..396978870
--- /dev/null
+++ b/src/render/GraphicsScope.lua
@@ -0,0 +1,56 @@
+-- Fence a native render seam, including leaked pushes and canvas changes.
+local S = {}
+local current
+-- Opaque lifetime for paired helpers inside a guarded render callback.
+function S.token() return current end
+local unpack = table.unpack or unpack
+local function pack(...)
+  return { n = select("#", ...), ... }
+end
+function S.call(fn, ...)
+  local G = love.graphics
+  local canvas = pack(G.getCanvas())
+  local realPush, realPop = G.push, G.pop
+  local before = G.getStackDepth and G.getStackDepth()
+  local pushed, why = pcall(realPush, "all")
+  if not pushed then
+    return false, why
+  end
+  local depth = 0
+  G.push = function(...)
+    local result = pack(realPush(...))
+    depth = depth + 1
+    return unpack(result, 1, result.n)
+  end
+  G.pop = function(...)
+    if depth <= 0 then
+      error("render callback cannot pop caller graphics state", 0)
+    end
+    local result = pack(realPop(...))
+    depth = depth - 1
+    return unpack(result, 1, result.n)
+  end
+  local parent = current
+  current = {}
+  local out = pack(pcall(fn, ...))
+  current = parent
+  G.push, G.pop = realPush, realPop
+  if before and G.getStackDepth then
+    local current = G.getStackDepth()
+    if current < before + 1 then
+      G.setCanvas(unpack(canvas, 1, canvas.n))
+      return false, "render callback removed its graphics guard"
+    end
+    depth = current - before - 1
+  end
+  for _ = 1, depth do
+    pcall(realPop)
+  end
+  local restored, err = pcall(realPop)
+  G.setCanvas(unpack(canvas, 1, canvas.n))
+  if not restored then
+    return false, err
+  end
+  return unpack(out, 1, out.n)
+end
+return S
diff --git a/src/render/NativePresentation.lua b/src/render/NativePresentation.lua
new file mode 100644
index 000000000..8544eaeb1
--- /dev/null
+++ b/src/render/NativePresentation.lua
@@ -0,0 +1,246 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Drawing leases belong to the existing native frame, never to a second loop.
+local Version=require('src.core.GameVersion')
+local Session=require('src.compat.gen1.NativeSession')
+local Scope=require('src.render.GraphicsScope')
+local P={apiVersion=1,features={nativeUiStack=true,windowLayers=true,frameWidgets=true}}
+local entries,order={},{}
+local nativeDraws,drawKinds={},{}
+local frame,revision,checks=nil,0,0
+local callbackDepth=0
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function finite(v)return type(v)=='number'and v==v and math.abs(v)<math.huge end
+local function valid(f)
+ if not f or f.closed or Version.generation()~=3 or Version.get()~=f.edition then return false end
+ local g=f.game
+ local G=package.loaded['src.core.Game3']
+ if not G or G.native(f.view)~=g or Session.game()~=g or g.data~=f.data or g.save~=f.save or g.mods~=f.loader
+  or g.stack~=f.stack or f.stack.states~=f.states or #f.states~=#f.sequence then return false end
+ for i,state in ipairs(f.sequence)do if f.states[i]~=state then return false end end
+ return true
+end
+local function close(f)
+ if not f then return end
+ f.closed=true
+ for _,job in ipairs(f.jobs)do job.close()end
+ f.jobs={};f.selected=nil;f.game=nil;f.view=nil;f.data=nil;f.save=nil
+ f.loader=nil;f.stack=nil;f.states=nil;f.sequence=nil
+end
+local function callback(e,fn,...)
+ local G=require('src.core.Game3')
+ callbackDepth=callbackDepth+1
+ local result=pack(Scope.call(G._withCallbackOwner,e.mod,fn,...))
+ callbackDepth=callbackDepth-1
+ if not result[1]then e.error=tostring(result[2]);return false,result[2]end
+ return unpack(result,1,result.n)
+end
+local function selected(f)
+ if not valid(f)then return end
+ if f.known==revision then
+  local e=f.selected
+  if not e or entries[e.id]==e and not e.error then return e end
+ end
+ -- Snapshot candidates: callbacks can replace or remove their registration.
+ local candidates={};for i=#order,1,-1 do candidates[#candidates+1]=entries[order[i]]end
+ local stamp=revision
+ f.selected=nil
+ for _,e in ipairs(candidates)do
+  if entries[e.id]==e and not e.error then
+   checks=checks+1
+   local ok,on=callback(e,e.provider.enabled,f.view)
+   if not valid(f)then return end
+   if ok and on and entries[e.id]==e and not e.error then f.selected=e;break end
+  end
+ end
+ f.known=stamp
+ return f.selected
+end
+local function lease(f,native)
+ assert(type(native)=='function','native presentation painter must be a function')
+ local open,called,result,failure=true,false
+ local function paint(...)
+  if failure then error(failure,0)end
+  if not open or not valid(f)then return false,'native presentation paint retired'end
+  if called then return unpack(result,1,result.n)end
+  called=true
+  local G=require('src.core.Game3')
+  local out=pack(Scope.call(G._withCallbackOwner,nil,native,...))
+  if not out[1]then failure=out[2];error(failure,0)end
+  result={n=out.n-1};for i=2,out.n do result[i-1]=out[i]end
+  return unpack(result,1,result.n)
+ end
+ return paint,function()open=false;native=nil;f=nil;result=nil end,
+  function()if failure then error(failure,0)end end
+end
+function P.unregister(id)
+ if not entries[id]then return false end
+ entries[id]=nil;revision=revision+1
+ for i=#order,1,-1 do if order[i]==id then table.remove(order,i);break end end
+ return true
+end
+function P.register(id,provider)
+ assert(type(id)=='string'and id~=''and #id<=256,'invalid presentation owner')
+ assert(type(provider)=='table'and type(provider.enabled)=='function'and type(provider.draw)=='function',
+  'presentation provider needs enabled and draw callbacks')
+ for _,name in ipairs{'begin','notify','widget','finishWidgets','defer','present','finishWindow'}do
+  assert(provider[name]==nil or type(provider[name])=='function','invalid presentation callback: '..name)
+ end
+ assert(entries[id]or #order<64,'too many presentation providers')
+ require('src.ui.game3.ui_pass') -- Install only the native modal seam, not Game.
+ P.unregister(id)
+ local copy={};for k,v in pairs(provider)do copy[k]=v end
+ local e={id=id,provider=copy,mod=require('src.core.Game3')._callbackOwner()}
+ entries[id]=e;order[#order+1]=id;revision=revision+1
+ return function()if entries[id]==e then return P.unregister(id)end;return false end
+end
+function P._active()return next(entries)~=nil end
+function P.begin(current,w,h)
+ if callbackDepth>0 or frame and frame.flushing then return false,'presentation callback cannot restart its frame'end
+ close(frame);frame=nil
+ local g=Session.game(current)
+ if not g or not g.stack or type(g.stack.states)~='table'then return false end
+ local view=require('src.core.Game3').forNative(g);if not view then return false end
+ local sequence={};for i,state in ipairs(g.stack.states)do sequence[i]=state end
+ if not finite(w)or w<=0 or not finite(h)or h<=0 then
+  w,h=require('src.render.Renderer'):uiSize()
+ end
+ local f={game=g,view=view,data=g.data,save=g.save,loader=g.mods,stack=g.stack,
+  states=g.stack.states,sequence=sequence,edition=Version.get(),jobs={},width=w,height=h}
+ frame=f
+ local e=selected(f)
+ if e and e.provider.begin then callback(e,e.provider.begin,view)end
+ return valid(f)
+end
+function P._nativeBegin(game,w,h)
+ if not P._active()then close(frame);frame=nil;return false end
+ return P.begin(game,w,h)
+end
+function P.draw(kind,ctx)
+ if kind==nil or drawKinds[kind]then return false end
+ local e=selected(frame);if not e then return false end
+ drawKinds[kind]=true
+ local ok,on=callback(e,e.provider.draw,kind,ctx or{})
+ drawKinds[kind]=nil
+ return ok and on==true
+end
+function P._inFrame()return frame~=nil end
+-- Native frame helpers can fall back into another helper (e.g. a standard
+-- strip missing from an old cache). That internal path remains ordinary
+-- native drawing; a provider asking for the base borrows it only once.
+function P._nativeDraw(kind,ctx,native,after,...)
+ local active=nativeDraws[kind]
+ if active then
+  if active.painting then return native(...)end
+  local result=pack(active.paint())
+  if active.after then active.after()end
+  return unpack(result,1,result.n)
+ end
+ local f=frame
+ if not selected(f)then return native(...)end
+ local args=pack(...);local record={after=after}
+ local paint,done,check=lease(f,function()
+  record.painting=true
+  local out=pack(pcall(native,unpack(args,1,args.n)))
+  record.painting=false
+  if not out[1]then error(out[2],0)end
+  record.result={n=out.n-1};for i=2,out.n do record.result[i-1]=out[i]end
+  return unpack(record.result,1,record.result.n)
+ end)
+ record.paint=paint;nativeDraws[kind]=record
+ local ok,why=pcall(function()
+  local handled=P.draw(kind,ctx);check()
+  if not handled then paint()end
+ end)
+ local result=record.result
+ local afterPaint=record.after
+ nativeDraws[kind]=nil;record.paint=nil;record.result=nil;record.after=nil;args=nil;done()
+ if not ok then error(why,0)end
+ if afterPaint then afterPaint()end
+ if result then return unpack(result,1,result.n)end
+end
+function P.notify(kind,ctx)
+ local e=selected(frame)
+ if e and e.provider.notify then callback(e,e.provider.notify,kind,ctx or{})end
+end
+function P.widget(id,native,ctx)
+ if not valid(frame)then native();return false end
+ local paint,done,check=lease(frame,native)
+ local e=selected(frame);local handled=false
+ local ok,why=pcall(function()
+  if e and e.provider.widget then
+   local success,on=callback(e,e.provider.widget,id,paint,ctx or{});handled=success and on==true
+  end
+  check();if not handled then paint()end
+ end)
+ done();if not ok then error(why,0)end
+ return handled
+end
+function P.finishWidgets()
+ local e=selected(frame)
+ if e and e.provider.finishWidgets then callback(e,e.provider.finishWidgets)end
+end
+function P.layer(kind,native,ui)
+ local f=frame;local e=selected(f)
+ if e and not f.flushing and #f.jobs<128 and e.provider.defer and e.provider.present then
+  local ok,on=callback(e,e.provider.defer,kind)
+  if ok and on and valid(f)and entries[e.id]==e and not e.error then
+   local paint,done,check=lease(f,native)
+   f.jobs[#f.jobs+1]={entry=e,kind=kind,paint=paint,close=done,check=check,ui=ui}
+   return true
+  end
+ end
+ native();return false
+end
+local function fallback(f,job,w,h)
+ local r=require('src.render.Renderer'):surfaceRects(f.width,f.height,w,h)
+ local g=love.graphics
+ local ok,why=Scope.call(function()
+  -- Keep the compositor's current target, including a capture/postprocess canvas.
+  g.origin();g.setShader();g.setScissor();if g.setDepthMode then g.setDepthMode()end;g.setColor(1,1,1,1)
+  g.translate(r.uox,r.uoy);g.scale(r.Ux,r.Uy);job.paint()
+ end)
+ if not ok then error(why,0)end
+end
+function P.flush(current,w,h)
+ local f=frame
+ if not f or f.flushing then return false end
+ if Session.game(current)~=f.game or not valid(f)then close(f);frame=nil;return false end
+ assert(finite(w)and w>0 and finite(h)and h>0,'invalid presentation window size')
+ f.flushing=true;f.known=nil -- Recheck enablement once at the window boundary.
+ local ok,why=pcall(function()
+  for _,job in ipairs(f.jobs)do
+   if not valid(f)then break end
+   local e=selected(f);local handled=false
+   if e==job.entry and e.provider.present then
+    local success,on=callback(e,e.provider.present,job.kind,job.paint,
+     {game=f.view,width=w,height=h,ui=job.ui})
+    handled=success and on==true
+   end
+   job.check()
+   if not handled and valid(f)then fallback(f,job,w,h)end
+   job.close()
+  end
+  local e=selected(f)
+  if e and e.provider.finishWindow then callback(e,e.provider.finishWindow,f.view,w,h)end
+ end)
+ close(f);if frame==f then frame=nil end
+ if not ok then error(why,0)end
+ return true
+end
+function P._nativeFlush(w,h)
+ return frame and P.flush(frame.game,w,h)or false
+end
+function P.health(id)
+ local e=entries[id]
+ return{registered=e~=nil,error=e and e.error,queued=frame and #frame.jobs or 0,enabledChecks=checks}
+end
+P._service={release=function()
+ close(frame);frame=nil;entries={};order={};revision=revision+1
+end,releaseOwner=function(_,owner)
+ local retired={}
+ for id,e in pairs(entries)do if e.mod==owner or id==owner then retired[#retired+1]=id end end
+ for _,id in ipairs(retired)do P.unregister(id)end
+end}
+require('src.core.game3.asset_stream').register(P._service)
+return P
diff --git a/src/render/Playfield.lua b/src/render/Playfield.lua
new file mode 100644
index 000000000..9e20ae21d
--- /dev/null
+++ b/src/render/Playfield.lua
@@ -0,0 +1,22 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe the native frame's reserved game rectangle. Ordinary touch overlays
+-- remain the layout caller's concern; this does not install a skin or viewport.
+local Viewport=require('src.render.GameViewport')
+local P={}
+local function dimension(v)return type(v)=='number'and v==v and v>0 and v<math.huge end
+function P.cutout(w,h)
+ if not(dimension(w)and dimension(h))or not Viewport.inFrame or not Viewport.active()then return nil end
+ local fullW,fullH=Viewport.fullDimensions()
+ local r=Viewport.rect
+ if not r or r.x==0 and r.y==0 and r.width==fullW and r.height==fullH then return nil end
+ local localW,localH=Viewport.dimensions()
+ if w==localW and h==localH then
+  -- The native owner has already entered its local canvas. Do not subtract
+  -- the window-space origin twice or discard the right/bottom edge again.
+  return 0,0,localW,localH
+ end
+ if w==fullW and h==fullH then return r.x,r.y,r.width,r.height end
+ -- A preview/actor capture of another size has no native window cutout.
+ return nil
+end
+return P
diff --git a/src/render/Renderer.lua b/src/render/Renderer.lua
index 7cff87285..f8d07bfce 100644
--- a/src/render/Renderer.lua
+++ b/src/render/Renderer.lua
@@ -144,10 +144,14 @@ end
 -- Integer framebuffer pixels per GB pixel that fit the window.  Zoom /
 -- GBCFX / callers treat this as the crisp scale; endFrame converts to LOVE
 -- units via / dpiX and / dpiY when drawing.
+local function fitSurfaceScale(pw, ph, w, h)
+  return math.max(1, math.floor(math.min(pw / w, ph / h)))
+end
+
 function Renderer:fitScale()
   local _, _, pw, ph = displayMetrics()
   local w, h = self:uiSize()
-  return math.max(1, math.floor(math.min(pw / w, ph / h)))
+  return fitSurfaceScale(pw, ph, w, h)
 end
 
 -- Integer framebuffer pixels per GB pixel for the UI pass.
@@ -162,8 +166,7 @@ end
 -- Zooming IN does not scale the UI up -- a dialogue box larger than the
 -- classic one has no reference to be faithful to, and the letterbox it sits
 -- in does not grow either.
-function Renderer:uiScale()
-  local S = self:fitScale()
+local function uiSurfaceScale(self, S)
   local off = Zoom.offset or 0
   -- UI LAYOUT = CENTERED (uiCentered, set per frame by Game:draw): the UI is
   -- a fixed letterbox at the fit scale and does not follow the survey zoom at
@@ -195,6 +198,10 @@ function Renderer:uiScale()
   return math.max(1, s)
 end
 
+function Renderer:uiScale()
+  return uiSurfaceScale(self, self:fitScale())
+end
+
 -- the native-pixel UI surface in use right now
 function Renderer:uiSize()
   return self.uiWidth or self.WIDTH, self.uiHeight or self.HEIGHT
@@ -320,6 +327,7 @@ end
 
 -- transparent: the world pass shows through (UI pass draws overlays only)
 function Renderer:beginFrame(transparent)
+  self.frameSerial=(self.frameSerial or 0)+1
   -- a frame that ends early -- a state that returns before endFrame, an error
   -- caught upstream -- must not leak a queued native-resolution draw into the
   -- next frame's composite
@@ -826,14 +834,28 @@ end
 -- scissored through the shade-remap shader, later zones on top.
 -- When GBC FX is active the composite is drawn into presentCanvas and
 -- presented through the GBC FX shader as a final pass.
-function Renderer:endFrame(zones, worldZones)
-  love.graphics.setCanvas()
+-- The same resolved viewport serves field producers and final composition.
+-- Logical units and drawable pixels remain distinct on high-DPI displays;
+-- no extra target or resampling is needed for a correctly sized override.
+Renderer.scalesWorldOverride = true
+local nativeFrameRects = setmetatable({}, {__mode="k"})
+local function frameRects(self, r, windowW, windowH, surfaceW, surfaceH)
   local ww, wh, pw, ph, dpiX, dpiY = displayMetrics()
+  local uiw, uih = self:uiSize()
+  local query = windowW ~= nil or windowH ~= nil or surfaceW ~= nil or surfaceH ~= nil
+  if query then
+    ww, wh, uiw, uih = windowW or ww, windowH or wh, surfaceW or uiw, surfaceH or uih
+    for _, value in ipairs{ww, wh, uiw, uih} do
+      assert(type(value) == 'number' and value > 0 and value < math.huge,
+        'surface metrics require positive finite dimensions')
+    end
+    pw, ph = ww * dpiX, wh * dpiY
+    assert(pw < math.huge and ph < math.huge, 'surface metrics exceed finite drawable dimensions')
+  end
   -- Sp = integer framebuffer pixels per GB pixel;
   -- Sx/Sy = LOVE-unit draw scales (may differ when dpiX ≠ dpiY).
-  local Sp = self:fitScale()
+  local Sp = query and fitSurfaceScale(pw, ph, uiw, uih) or self:fitScale()
   local Sx, Sy = Sp / dpiX, Sp / dpiY
-  local uiw, uih = self:uiSize()
   local vpw, vph = uiw * Sx, uih * Sy
   -- Snap the letterbox origin to a framebuffer pixel, then convert to units.
   local ox = math.floor((pw - uiw * Sp) / 2) / dpiX
@@ -841,7 +863,7 @@ function Renderer:endFrame(zones, worldZones)
   -- The UI has its own scale: it steps down as the survey zoom goes out (see
   -- uiScale), so it can be smaller than the world letterbox.  Un-zoomed these
   -- are identical to Sp/ox/oy and every rect below is what it always was.
-  local Up = self:uiScale()
+  local Up = query and uiSurfaceScale(self, Sp) or self:uiScale()
   -- BATTLE SIZE "fill" (Renderer.uiFill, set per frame by Game:draw): scale
   -- the surface to the window rather than to whole GB pixels, so the battle
   -- fills vertically at any zoom or window size.  Fractional by nature -- a
@@ -855,6 +877,37 @@ function Renderer:endFrame(zones, worldZones)
   local uvpw, uvph = uiw * Ux, uih * Uy
   local uox = math.floor((pw - uiw * Up) / 2) / dpiX
   local uoy = math.floor((ph - uih * Up) / 2) / dpiY
+  r = r or {}
+  r.ww,r.wh,r.pw,r.ph,r.dpiX,r.dpiY = ww,wh,pw,ph,dpiX,dpiY
+  r.vx,r.vy,r.cut,r.vux,r.vuy,r.vuw,r.vuh = 0,0,0,0,0,ww,wh
+  r.Sp,r.Sx,r.Sy,r.uiw,r.uih,r.vpw,r.vph,r.ox,r.oy = Sp,Sx,Sy,uiw,uih,vpw,vph,ox,oy
+  r.Up,r.Ux,r.Uy,r.uvpw,r.uvph,r.uox,r.uoy = Up,Ux,Uy,uvpw,uvph,uox,uoy
+  return r
+end
+function Renderer:frameRects()
+  return frameRects(self) -- public snapshots cannot mutate the compositor
+end
+
+-- Detached capture fitting uses the same built-in policy and current DPI.
+-- Active-surface requests retain override-aware native scale methods.
+function Renderer:surfaceRects(surfaceW, surfaceH, windowW, windowH)
+  local w, h = self:uiSize()
+  local ww, wh = displayMetrics()
+  if (surfaceW == nil or surfaceW == w) and (surfaceH == nil or surfaceH == h)
+      and (windowW == nil or windowW == ww) and (windowH == nil or windowH == wh) then
+    return frameRects(self)
+  end
+  return frameRects(self, nil, windowW, windowH, surfaceW, surfaceH)
+end
+
+
+function Renderer:endFrame(zones, worldZones)
+  love.graphics.setCanvas()
+  local r = frameRects(self, nativeFrameRects[self])
+  nativeFrameRects[self] = r
+  local ww,wh,pw,ph,dpiX,dpiY = r.ww,r.wh,r.pw,r.ph,r.dpiX,r.dpiY
+  local Sp,Sx,Sy,uiw,uih,vpw,vph,ox,oy = r.Sp,r.Sx,r.Sy,r.uiw,r.uih,r.vpw,r.vph,r.ox,r.oy
+  local Up,Ux,Uy,uvpw,uvph,uox,uoy = r.Up,r.Ux,r.Uy,r.uvpw,r.uvph,r.uox,r.uoy
   self.uiPresentation = {x=uox,y=uoy,w=uvpw,h=uvph,scaleX=Ux,scaleY=Uy}
   local GBCFX = gbcFX()
   -- Forced mono/Classic modes still need a whole-screen zone when a state
@@ -905,6 +958,8 @@ function Renderer:endFrame(zones, worldZones)
       secondScreen = require("src.render.SecondScreen"),
     }
     if Runtime.call("render.compose", function() return false end, self, ctx) == true then
+      local presentation=package.loaded['src.render.NativePresentation']
+      if presentation then presentation._nativeFlush(ww,wh)end
       self.worldActive = false
       self.uprightActive = false
       self.uiOverride = nil
@@ -1351,6 +1406,8 @@ function Renderer:endFrame(zones, worldZones)
   -- over the finished composite rather than under the UI blit.  On hardware
   -- it is the tilemap being overwritten -- there is nothing it does not cover.
   local battleSource = nil
+  local presentation=package.loaded['src.render.NativePresentation']
+  if presentation then presentation._nativeFlush(ww,wh)end
   if battleNeedsSource and present then
     -- Snapshot the untouched finished frame into a second screen-sized canvas.
     -- `present` is the current render target here, so sampling it directly in
diff --git a/src/render/TextBox.lua b/src/render/TextBox.lua
index 07f605295..89c5d3c3e 100644
--- a/src/render/TextBox.lua
+++ b/src/render/TextBox.lua
@@ -420,7 +420,66 @@ function TextBox:beginLine()
   table.insert(self.shown, {})
 end
 
+-- Only the manual input branches; typing, automatic text and holds still
+-- belong to update(), including the delay after a page/line advance.
+function TextBox:advance()
+  if (self.holdFrames or 0) > 0 or (self.preWait or 0) > 0 then
+    return
+  end
+  if self.done then
+    if self.stay or self.auto or self.choice then
+      return
+    end
+    require("src.core.Sound").play(self.game.data, "Press_AB")
+    self.game.stack:pop()
+    if self.onDone then
+      self.onDone()
+    end
+  elseif self.waiting then
+    require("src.core.Sound").play(self.game.data, "Press_AB")
+    self.waiting = false
+    if self.contAdvance then
+      -- ContText / ManualTextScroll: keep the box, scroll one line
+      self.contAdvance = false
+      self.lineIndex = self.lineIndex + 1
+      self:beginLine()
+      -- ScrollTextUpOneLine is 5 blocking frames and, as its own comment
+      -- says, is "always called twice in a row" (home/text.asm:280-305)
+      self.holdFrames = self.scrollHoldFrames or Timing.TEXT_SCROLL_PAIR
+    else
+      self.shown = {}
+      self.pageIndex = self.pageIndex + 1
+      self.lineIndex = 1
+      self:beginLine()
+      -- ClearScreenArea then DelayFrames 20: the box sits empty before the
+      -- next page starts typing (home/text.asm:236-240)
+      self.holdFrames = Timing.TEXT_PAGE_CLEAR
+    end
+  end
+end
+
+-- Reveal only the current native page; no input, sound or clock is pumped.
+function TextBox:revealPage()
+  while not self.waiting and not self.done do
+    local line=self.shown[#self.shown]
+    for i=self.charIndex+1,#self.codes do line[#line+1]=self.codes[i]end
+    self.charIndex=#self.codes
+    local page=self.pages[self.pageIndex]
+    if self.lineIndex<#page then
+      local nextIdx=self.lineIndex+1
+      local conts=self.pages.contBefore and self.pages.contBefore[self.pageIndex]
+      if conts and conts[nextIdx]then self.waiting=true;self.contAdvance=true
+      else self.lineIndex=nextIdx;self:beginLine()end
+    elseif self.pageIndex<#self.pages then self.waiting=true;self.contAdvance=false
+    else self.done=true end
+  end
+end
 function TextBox:update(dt)
+  local source=package.loaded['src.ui.game3.message']
+  if require('src.core.GameVersion').isGen3()and source then return source._update(self,function()return self:_updateBody(dt)end)end
+  return self:_updateBody(dt)
+end
+function TextBox:_updateBody(dt)
   local input = self.game.input
   self.blink = (self.blink + 1) % 60
   -- A page or CONT advance blocks the whole box while the original's scroll
@@ -618,6 +677,11 @@ function TextBox:uiSize()
 end
 
 function TextBox:draw()
+  local source=package.loaded['src.ui.game3.message']
+  if require('src.core.GameVersion').isGen3()and source then return source._draw(self,function()return self:_drawBody()end)end
+  return self:_drawBody()
+end
+function TextBox:_drawBody()
   -- The dialogue box belongs against the bottom of the screen, not floating
   -- in the middle of a zoomed-out letterbox.  Declared per frame; the
   -- renderer blits this region to the screen edge and the rest of the UI
diff --git a/src/render/Transition.lua b/src/render/Transition.lua
index bf68f5d84..64c33a1f2 100644
--- a/src/render/Transition.lua
+++ b/src/render/Transition.lua
@@ -92,6 +92,10 @@ function Transition:finish()
 end
 
 function Transition:update(dt)
+  if self.nativeFlyArrivalHold then
+    local arrival=package.loaded['src.world.Gen3FlyArrival'];if arrival then arrival.poll()end
+    if self.nativeFlyArrivalHold then return end
+  end
   self.t = self.t + 1
   local len = (self.phase == "out") and self.frames or self.framesIn
   if self.t >= len then
@@ -101,7 +105,7 @@ function Transition:update(dt)
       if self.onMidpoint then self.onMidpoint() end
       -- LoadGBPal restores the palettes in one write, so with no fade in the
       -- map is simply there on the next frame
-      if (self.framesIn or 0) <= 0 then self:finish() end
+      if (self.framesIn or 0) <= 0 and not self.nativeFlyArrivalHold then self:finish() end
     else
       self:finish()
     end
@@ -111,12 +115,17 @@ end
 -- The veil alpha for this frame, exposed the way BattleReturn:alpha is so
 -- the staircase can be asserted without stubbing love.graphics.
 function Transition:alpha()
+  if self.nativeFlyArrivalHold then return 1 end
   local len = (self.phase == "out") and self.frames or self.framesIn
   local a = fadeAlpha(self.t, len)
   if self.phase == "in" then a = 1 - a end
   return a
 end
 
+function Transition:exit()
+  local arrival=package.loaded['src.world.Gen3FlyArrival'];if arrival then arrival.retireState(self)end
+end
+
 function Transition:draw()
   local alpha = self:alpha()
   -- Survey zoom draws the overworld into a window-filling world canvas
@@ -226,4 +235,11 @@ function BattleReturn:draw()
   love.graphics.setColor(1, 1, 1, 1)
 end
 
+-- Scalar observations of the same native states, without advancing a fade.
+function Transition.describe(state)
+  local class=getmetatable(state)
+  if class==Transition then return state:alpha(),false,state.phase=='out'and 1 or -1,true,true end
+  if class==WhiteFlash then return 1,true,0,true,true end
+  if class==BattleReturn then return state:alpha(),true,-1,true,true end
+end
 return Transition
diff --git a/src/script/Commands.lua b/src/script/Commands.lua
index 53cef91fa..25fc9cde5 100644
--- a/src/script/Commands.lua
+++ b/src/script/Commands.lua
@@ -1814,122 +1814,7 @@ end
 -- Color defaults to black (warp-style); "white" matches GBFadeOutToWhite
 -- / GBFadeInFromWhite (Mom heal, Silph Co. nurse).  White defaults to
 -- 24 frames (3 palettes x 8); black defaults to 12 (Transition).
-local FadeOverlay = {}
-FadeOverlay.__index = FadeOverlay
-
-function FadeOverlay.new(game, ow, color)
-  return setmetatable({
-    game = game, ow = ow, alpha = 0, color = color or "black",
-  }, FadeOverlay)
-end
-
--- A FADE IS A PALETTE EFFECT, NOT A MODE -- the world keeps running under it.
---
--- The state stack only updates the state on TOP, so while this overlay is up
--- it is the only thing being ticked.  Ticking nothing but the script runner
--- starves the very thing most scripts do behind a fade: MOVE SOMEBODY.  The
--- move queue never steps, `waitmovement` never completes, the map's frame
--- table is never re-asked, and the player is left looking at black with a
--- script that can no longer finish -- which is exactly what Route 101's
--- rescue does (fadescreen, removeobject, setobjectxy, applymovement,
--- waitmovement) three commands after the screen goes dark.
---
--- So pump the field itself.  Only while something is actually driving it: with
--- no script and no queued move there is nothing to advance, and running the
--- field then would hand the player an input frame behind a black screen.
-function FadeOverlay:update(dt)
-  local ow = self.ow
-  if ow then
-    local runner = ow.runner
-    local busy = (runner and runner.isRunning and runner:isRunning())
-      or (ow.scriptMoves and #ow.scriptMoves > 0)
-      or (ow.pendingScripts and ow.pendingScripts[1] ~= nil)
-    if busy and ow.update then
-      ow:update(dt or 1 / 60)
-    elseif runner then
-      runner:update()
-    end
-    -- THE WATCHDOG, because a screen stuck at black is the one failure a
-    -- player cannot tell from a crash.
-    --
-    -- A fade is always meant to be undone by something: the script's own
-    -- fade back, the `waitstate` that ends the scene, or the runner when the
-    -- script finishes.  If all three miss it, the game is still running --
-    -- input is even accepted -- behind a fully opaque rectangle, and the only
-    -- report anybody can make is "it went black".  Two seconds of full black
-    -- with nothing driving the field is not a beat in either cartridge, so
-    -- bring the picture back and say why once.
-    if not self.ramp and (self.alpha or 0) >= 1 and not busy then
-      self.idleFrames = (self.idleFrames or 0) + 1
-      if self.idleFrames >= 120 then
-        Logger.warn("the screen has been faded out for two seconds with no "
-                      .. "script running -- fading back in; whatever darkened "
-                      .. "it never undid it")
-        self.ramp = { from = self.alpha, to = 0, frames = 12, t = 0 }
-        self.idleFrames = nil
-      end
-    else
-      self.idleFrames = nil
-    end
-  end
-  local ramp = self.ramp
-  if not ramp then return end
-  ramp.t = ramp.t + 1
-  local k = math.min(1, ramp.t / ramp.frames)
-  self.alpha = ramp.from + (ramp.to - ramp.from) * k
-  if ramp.t >= ramp.frames then
-    self.ramp = nil
-    if ramp.to <= 0 then
-      -- a box may sit above the overlay; remove in place, not pop
-      local states = self.game.stack.states
-      for i = #states, 1, -1 do
-        if states[i] == self then table.remove(states, i) break end
-      end
-      self:releaseVeil()
-      if ow then ow.fadeOverlay = nil end
-    end
-    if ramp.onDone then ramp.onDone() end
-  end
-end
-
--- ...AND ON THE WHOLE SURFACE'S ORIGIN.  A state with no uiSize is centred as
--- Game Boy furniture (Game:draw's classicOffset), which slid the 240x160
--- rectangle 40 right and 8 down and left an unfaded L down the left and top
--- through Mom's heal.
-function FadeOverlay:uiSize()
-  return require("src.ui.Theme").uiSize()
-end
-
-function FadeOverlay:releaseVeil()
-  local r = self.game and self.game.renderer
-  if self.ownsVeil and r then r.screenVeil = nil end
-  self.ownsVeil = nil
-end
-
-function FadeOverlay:draw()
-  -- A PALETTE FADE HAS NO OUTSIDE.  When nothing is drawn over the fade it is
-  -- painted as the renderer's whole-window veil, so the world bleeding past
-  -- the 240x160 surface darkens with it; with a box above it, it stays a
-  -- rectangle in the surface so the box remains readable.
-  local r = self.game and self.game.renderer
-  if r and self.game.stack:top() == self then
-    r.screenVeil = { self.color == "white" and 1 or 0, self.alpha or 0 }
-    self.ownsVeil = true
-    return
-  end
-  self:releaseVeil()
-  if self.color == "white" then
-    love.graphics.setColor(1, 1, 1, self.alpha)
-  else
-    love.graphics.setColor(0, 0, 0, self.alpha)
-  end
-  -- THE WHOLE SCREEN, not the Game Boy's.  Fixed at 160x144 this covered the
-  -- top-left five eighths of a GBA surface and left an unfaded L down the
-  -- right and along the bottom, which is worse than no fade at all.
-  local w, h = require("src.ui.Theme").uiSize()
-  love.graphics.rectangle("fill", 0, 0, w, h)
-  love.graphics.setColor(1, 1, 1, 1)
-end
+local FadeOverlay = require('src.render.FieldFade')
 
 local function parseFadeArgs(a, b)
   local frames, color
diff --git a/src/ui/BagMenu.lua b/src/ui/BagMenu.lua
index 4d229471d..eec008c02 100644
--- a/src/ui/BagMenu.lua
+++ b/src/ui/BagMenu.lua
@@ -172,6 +172,21 @@ BagMenu.refreshCount = refreshCount
 -- the stack, so every exit that prints has to close it afterwards.  For
 -- every other item the picker popped itself first and closePicker's identity
 -- check makes it a no-op (#252).
+-- Shared with optional command shortcuts. Validate inventory and battle
+-- before consuming; the native throw owns animation, catch and the turn.
+function BagMenu.throwBall(game,battle,id,close)
+  local def=game.data.items[id]
+  if not battle or(game.save.inventory[id]or 0)<1 or not ItemEffects.isBall(id,def)then return false end
+  if battle.kind=='wild'and battle.wildFoesStanding and battle:wildFoesStanding()>1 then
+    showMessages(game,{(game.data.text and game.data.text.TEXT_B0002_00044)
+      or Strings("It's no good! It's impossible to aim\nwhen there are two POKéMON!")})
+    return false
+  end
+  consume(game,id)
+  if close then close()end
+  battle:throwBall(ItemEffects.alias(id,def))
+  return true
+end
 local function useOn(game, battle, id, target, list, moveIndex, picker)
   -- HGSS: the party screen's own msg_0300 line for the item (src/ui/Gen4PartyText.lua)
   local PartyText = require("src.ui.Gen4PartyText")
@@ -415,16 +430,7 @@ local function useOn(game, battle, id, target, list, moveIndex, picker)
                               game.save.player.name) })
       return
     end
-    -- BattleBag's hasTwoOpponents: no ball while two wild Pokemon stand
-    if battle.kind == "wild" and battle.wildFoesStanding and battle:wildFoesStanding() > 1 then
-      showMessages(game, { (game.data.text and game.data.text.TEXT_B0002_00044)
-        or Strings("It's no good! It's impossible to aim\nwhen there are two POKéMON!") })
-      return
-    end
-    consume(game, id)
-    list:close()
-    -- Catching/AnimPlayer key off the Gen1 ball ids
-    battle:throwBall(ItemEffects.alias(id, game.data.items[id]))
+    BagMenu.throwBall(game,battle,id,function()list:close()end)
     return
   end
 
diff --git a/src/ui/Gen3BagMenu.lua b/src/ui/Gen3BagMenu.lua
index 76565106d..68697a9f0 100644
--- a/src/ui/Gen3BagMenu.lua
+++ b/src/ui/Gen3BagMenu.lua
@@ -186,6 +186,7 @@ function Gen3BagMenu.new(game, opts)
   opts = opts or {}
   local self = setmetatable({}, Gen3BagMenu)
   self.game = game
+  require('src.compat.gen1.NativeModalObservation').capture(self,game)
   self.onCancel = opts.onCancel
   -- opened mid-battle: the pick USES the item there and then, against the
   -- fight, rather than opening the field item flow (see choose())
diff --git a/src/ui/Gen3DexSearch.lua b/src/ui/Gen3DexSearch.lua
index 700e05f58..22dae38ad 100644
--- a/src/ui/Gen3DexSearch.lua
+++ b/src/ui/Gen3DexSearch.lua
@@ -174,6 +174,7 @@ function Gen3DexSearch.new(game, opts)
   self.choice = { nil, nil, nil, nil, 1, 1 }
   if type(opts.mode) == "number" then self.choice[6] = opts.mode end
   if type(opts.order) == "number" then self.choice[5] = opts.order end
+  require('src.compat.gen1.NativeModalObservation').capture(self,game)
   return self
 end
 
diff --git a/src/ui/Gen3HelpMenu.lua b/src/ui/Gen3HelpMenu.lua
new file mode 100644
index 000000000..0d6e7b359
--- /dev/null
+++ b/src/ui/Gen3HelpMenu.lua
@@ -0,0 +1,169 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- A real native stack modal. Original cartridge rows/art and the existing
+-- ListMenu input controller share the game's update and resource lifetime.
+local Font=require('src.render.Font')
+local Text=require('src.core.game3.rom_text')
+local Rich=require('src.render.Gen3HelpText')
+local List=require('src.ui.ListMenu')
+local Progress=require('src.ui.Gen3HelpProgress')
+local Version=require('src.core.GameVersion')
+local Native=require('src.compat.gen1.NativeSession')
+local H={isOpaque=true};H.__index=H
+function H:uiSize()return 240,160 end
+function H:wantsFillScale()return true end
+function H:wantsEdgeBleed()return false end
+function H:sgbPalettes()return{require('src.render.PaletteFX').trueColorZone(0,0,29,19)}end
+function H:valid()
+ if self.closed or Native.game()~=self.game or Version.get()~=self.edition
+  or self.game.data~=self.data or self.game.save~=self.save or self.game.stack~=self.stack
+  or self.game.mods~=self.loader or self.data.constants.gen3Help~=self.facts then return false end
+ if self.owner then
+  local mod=self.loader and self.loader.mods and self.loader.mods[self.owner]
+  if mod~=self.mod or not mod or mod.failed or mod.enabled==false then return false end
+ end
+ for _,state in ipairs(self.stack.states)do if state==self then return true end end
+ return false
+end
+function H.new(game,context,owner)
+ local facts=game.data and game.data.constants and game.data.constants.gen3Help
+ if not(Version.isFRLG()and facts and facts.schema==1 and facts.edition==Version.get()
+  and facts.romSha1==Version.info().sha1 and facts.keypad)then return nil,'native Help resources unavailable'end
+ if type(context)~='number'or context%1~=0 or context<1 or context>34 then return nil,'native Help context unavailable'end
+ local self=setmetatable({game=game,data=game.data,save=game.save,stack=game.stack,loader=game.mods,
+  facts=facts,contextId=context,edition=Version.get(),owner=owner,resources={},level='main',layouts={}},H)
+ self.mod=owner and self.loader and self.loader.mods and self.loader.mods[owner]
+ if owner and(not self.mod or self.mod.enabled==false or self.mod.failed)then return nil,'native Help owner unavailable'end
+ self:main();return self
+end
+function H:layout(key,width)
+ local name=key..':'..width
+ if not self.layouts[name]then self.layouts[name]=Rich.layout(Text.ir(key),width,self.facts.keypad)end
+ return self.layouts[name]
+end
+function H:list(items)
+ local self_=self
+ self.menu=List.new(self.game,'',items,{kind='native_help',rows=7,keyRepeat=true,pageJump=true,noSound=true,
+  onChoose=function(item)self_:choose(item)end})
+ -- A borrowed controller must not pop its owning modal on B.
+ self.menu.cancel=function()self_:back()end
+end
+function H:main()
+ self.level='main';self.topic=nil
+ local rows={}
+ for _,i in ipairs(self.facts.topicOrder)do
+  local topic=self.facts.topics[i]
+  if self.facts.topicFlags[self.contextId][i]then rows[#rows+1]={label=Text.plain(topic.label),key=topic.label,topic=i}end
+ end
+ self:list(rows)
+ self.menu.index=math.min(self.mainIndex or 1,#rows)
+end
+function H:choose(item)
+ if self.level=='main'then
+  if item.topic==6 then return self:close()end
+  self.mainIndex=self.menu.index;self.topic=item.topic;self.level='questions'
+  local rows={}
+  for _,id in ipairs(Progress.items(self.game,self.facts,self.contextId,self.topic))do
+   local entry=self.facts.entries[self.topic][id]
+   rows[#rows+1]={label=Text.plain(entry.question),key=entry.question,id=id}
+  end
+  rows[#rows+1]={label=Text.plain(self.facts.cancel),key=self.facts.cancel,cancel=true}
+  self:list(rows)
+ elseif item.cancel then self:main()
+ else
+  self.level='answer';self.article=self.facts.entries[self.topic][item.id];self.articleScroll=0
+ end
+end
+function H:back()
+ if self.level=='main'then return self:close()end
+ if self.level=='answer'then self.level='questions';self.article=nil else self:main()end
+end
+function H:close()if not self.closed then self.stack:removeAll({self})end end
+function H:exit()
+ if self.closed then return end;self.closed=true
+ for _,resource in ipairs(self.resources)do resource:release()end
+ self.resources={};self.layouts={}
+ self.game,self.data,self.save,self.stack,self.loader,self.mod,self.facts,self.menu=nil,nil,nil,nil,nil,nil,nil,nil
+ self.tiles,self.icons,self.palette,self.article=nil,nil,nil,nil
+end
+function H:update(dt)
+ if not self:valid()then return self:close()end
+ if (self.stack.active and self.stack:active()or self.stack:top())~=self then return end
+ local input=self.game.input
+ if input:wasPressed('l')or input:wasPressed('r')then return self:close()end
+ if self.level=='answer'then
+  if input:wasPressed('a')or input:wasPressed('b')then return self:back()end
+  local lines=math.max(0,math.ceil(self:layout(self.article.answer,208).height/15)-6)
+  if input:wasPressed('down')then self.articleScroll=math.min(lines,self.articleScroll+1)
+  elseif input:wasPressed('up')then self.articleScroll=math.max(0,self.articleScroll-1)end
+ elseif input:wasPressed('b')then return self:back()
+ else self.menu:update(dt)end
+end
+function H:art()
+ if self.tiles then return end
+ local Rom=require('src.import.RomGba');local palette={}
+ for i,value in ipairs(self.facts.frame.palette)do
+  local r,g,b=Rom.bgr555(value);palette[i]={r/255,g/255,b/255,1}
+ end
+ self.palette=palette
+ local function image(raw,start,width,height,columns,transparent)
+  local data=love.image.newImageData(width,height)
+  for y=0,height-1 do for x=0,width-1 do
+   local tile=start+math.floor(y/8)*columns+math.floor(x/8)
+   local value=assert(raw[tile*32+(y%8)*4+math.floor(x%8/2)+1],'native Help artwork truncated')
+   local index=math.floor(value/(x%2==0 and 1 or 16))%16
+   local c=assert(palette[index+1]);data:setPixel(x,y,c[1],c[2],c[3],transparent and index==0 and 0 or 1)
+  end end
+  local ok,result=pcall(love.graphics.newImage,data);data:release()
+  if not ok then error(result,0)end
+  self.resources[#self.resources+1]=result;result:setFilter('nearest','nearest');return result
+ end
+ local tiles,icons={},{}
+ local ok,why=pcall(function()
+  for i=0,8 do tiles[i+1]=image(self.facts.frame.tiles,i,8,8,1,false)end
+  for i,region in ipairs(self.facts.keypad.regions)do
+   icons[i]=image(self.facts.keypad.tiles,region.tile,region.width,region.height,16,true)
+  end
+ end)
+ if not ok then
+  for _,resource in ipairs(self.resources)do resource:release()end
+  self.resources={};self.palette=nil;error(why,0)
+ end
+ self.tiles,self.icons=tiles,icons
+end
+function H:paint()
+ self:art();local G=love.graphics;G.setColor(1,1,1,1)
+ local function tile(id,x,y,w,h)G.draw(self.tiles[id+1],x,y,0,w/8,h/8)end
+ -- help_system_util.c's original 0x1F7..0x1FF decoration tiles.
+ tile(8,0,0,240,160);tile(2,0,0,8,160);tile(2,232,0,8,160)
+ local answer=self.level=='answer'
+ if answer then tile(3,8,24,224,136)end
+ tile(answer and 4 or 0,8,16,224,8);tile(answer and 5 or 1,8,152,224,8)
+ local function text(key,x,y,width,scroll)Rich.draw(self:layout(key,width),x,y,self.palette,self.icons,scroll)end
+ text('gString_Help',14,1,58)
+ local control=answer and'gText_HelpSystemControls_AorBtoCancel'
+  or self.level=='main'and'gText_HelpSystemControls_PickOkEnd'or'gText_HelpSystemControls_PickOkCancel'
+ text(control,80,1,152)
+ G.setScissor(16,24,208,128)
+ if answer then
+  text(self.article.question,16,24,208);tile(5,8,40,224,8)
+  G.setScissor(16,48,208,104);text(self.article.answer,16,48,208,self.articleScroll)
+ else
+  local top=self.level=='main'and 24 or 45
+  if self.topic then text(self.facts.topics[self.topic].label,16,24,208)end
+  for i=self.menu.scroll+1,math.min(#self.menu.items,self.menu.scroll+self.menu.rows)do
+   local y=top+(i-self.menu.scroll-1)*15
+   text(self.menu.items[i].key,24,y,200)
+   if i==self.menu.index then Font.drawCode(256+3,16,y)end
+  end
+  if self.level=='main'then
+   G.setScissor(16,120,208,32)
+   text(self.facts.topics[self.menu.items[self.menu.index].topic].description,16,120,208)
+  end
+ end
+end
+function H:draw()
+ if not self:valid()then return end
+ local facade=require('src.ui.game3.help_system')
+ return facade._nativeDraw(self,function()return self:paint()end)
+end
+return H
diff --git a/src/ui/Gen3HelpProgress.lua b/src/ui/Gen3HelpProgress.lua
new file mode 100644
index 000000000..7683cb042
--- /dev/null
+++ b/src/ui/Gen3HelpProgress.lua
@@ -0,0 +1,65 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Declarative FR/LG Help interface facts from pinned pret/pokefirered
+-- help_system.c and constants/flags.h, ce6406d8c2eaf46d543c8a2606de0c3cb1951982.
+-- Read native save/registry data only; never write progress or run scripts.
+local P={}
+local limits={44,48,43,7,35}
+local groups={
+ [1]={
+  {true,'1 2 3 5 8 34 38 41 42 43'},
+  {0x2CF,'4'},{0x891,'6 10 16 19 22 35 36'},{0x895,'7'},{0x8A4,'11 24'},
+  {0x828,'9 13 14 15 17 18 20 26 29 31 37'},{0x829,'21 23'},
+  {0x820,'12 25 27 30 32 33'},{'hm','28 40'},{0x29B,'39'},{0x892,'44'}},
+ [2]={
+  {true,'6 10 11 12 19 20 21 22 23 24 25 26 27 28 29 31 36 38 39 40 41 42 45 46 47'},
+  {0x829,'1 30 37'},{'map','14'},{0x828,'2 3 5 7 8 9 13 32 33 35 43 44'},
+  {'caught','4 34'},{0x820,'15'},{'hm','16 17'},{0x271,'18'},{0x82C,'48'}},
+ [3]={
+  {0x828,'1 2 4 5 6 7 8 9 10 11 12 13 16 19 20 21'},
+  {0x8A4,'3 15 18 39'},{'hm','36 37'}},
+ [4]={{0x820,'5'},{0x821,'6'}},
+}
+local gates={}
+for topic,rows in pairs(groups)do
+ gates[topic]={}
+ for _,row in ipairs(rows)do for id in row[2]:gmatch('%d+')do
+  id=tonumber(id);assert(not gates[topic][id],'duplicate Help gate');gates[topic][id]=row[1]
+ end end
+end
+function P.flag(game,id)
+ local value=game.save and game.save.flags and game.save.flags[('FLAG_G3_%04X'):format(id)]
+ return value==true or value==1
+end
+function P.allowed(game,topic,id)
+ if not(limits[topic]and type(id)=='number'and id%1==0 and id>=1 and id<=limits[topic])then return false end
+ local gate=gates[topic]and gates[topic][id]
+ if gate==nil then return topic>=3 end
+ if gate==true then return true end
+ if type(gate)=='number'then return P.flag(game,gate)end
+ if gate=='hm'then
+  for _,flag in ipairs{0x237,0x238,0x239,0x23A,0x23B,0x2EF,0x1F1}do if P.flag(game,flag)then return true end end
+ elseif gate=='map'then
+  local key=game.data.constants.itemOrder and game.data.constants.itemOrder[361]
+  return key~=nil and(tonumber((game.save.inventory or{})[key])or 0)>0
+ elseif gate=='caught'then
+  local unique,count={},0
+  for key,owned in pairs(game.save.pokedex and game.save.pokedex.caught or{})do
+   local mon=game.data.pokemon and game.data.pokemon[key];local dex=mon and mon.dex
+   if (owned==true or owned==1)and type(dex)=='number'and dex>=1 and dex<=151 and not unique[dex]then
+    unique[dex]=true;count=count+1;if count>1 then return true end
+   end
+  end
+ end
+ return false
+end
+function P.items(game,facts,context,topic)
+ local out,seen={},{}
+ local basic=topic==3 and P.flag(game,0x4B0)
+ local basics={};if basic then for _,id in ipairs(facts.basicTerms)do basics[id]=true end end
+ for _,id in ipairs(facts.contexts[context][topic])do
+  if not basics[id]and not seen[id]and P.allowed(game,topic,id)then out[#out+1]=id;seen[id]=true end
+ end
+ if basic then for _,id in ipairs(facts.basicTerms)do if not seen[id]then out[#out+1]=id;seen[id]=true end end end
+ return out
+end
+return P
diff --git a/src/ui/Gen3PartyMenu.lua b/src/ui/Gen3PartyMenu.lua
index 4f3f78b39..4500b7b56 100644
--- a/src/ui/Gen3PartyMenu.lua
+++ b/src/ui/Gen3PartyMenu.lua
@@ -130,6 +130,7 @@ function Gen3PartyMenu.new(game, opts)
   opts = opts or {}
   local self = setmetatable({}, Gen3PartyMenu)
   self.game = game
+  require('src.compat.gen1.NativeModalObservation').capture(self,game)
   self.onCancel = opts.onCancel
   -- the battle's three shapes (see the note at the top of this file)
   self.onSwitch = opts.onSwitch
@@ -886,6 +887,9 @@ function Gen3PartyMenu:handOff(mon)
 end
 
 function Gen3PartyMenu:runAction(action, mon, row)
+  if action=='source_field_move'then
+    return require('src.ui.game3.party_menu')._fieldAction(self,mon,row)
+  end
   self.submenu = nil
   -- Handle hook-injected entries with onSelect callbacks
   if not action and row and row.onSelect then
@@ -1016,6 +1020,11 @@ function Gen3PartyMenu:animateTo(mon, fromHP, onDone)
 end
 
 function Gen3PartyMenu:update(dt)
+  local source=package.loaded['src.ui.game3.party_menu']
+  if source then return source._dispatch(self,dt,function()return self:_updateBody(dt)end)end
+  return self:_updateBody(dt)
+end
+function Gen3PartyMenu:_updateBody(dt)
   -- RECONSTRUCTED: every icon bounces, all the time, on the same beat.  On
   -- the cartridge each one is an OBJ with its own callback; here it is one
   -- clock, which is indistinguishable on screen and cannot drift.
@@ -1042,6 +1051,11 @@ function Gen3PartyMenu:update(dt)
   self.scriptTick = (self.scriptTick or 0) + 1
   if self.script then self.script(self) end
   if self.noInput then return end
+  local source=package.loaded['src.ui.game3.party_menu']
+  if source then return source._input(self,function()return self:_inputBody()end)end
+  return self:_inputBody()
+end
+function Gen3PartyMenu:_inputBody()
   local input = self.game.input
 
   -- the pick's own submenu takes the stick while it is up
diff --git a/src/ui/Gen3Pokedex.lua b/src/ui/Gen3Pokedex.lua
index 3afd957ff..917598bcd 100644
--- a/src/ui/Gen3Pokedex.lua
+++ b/src/ui/Gen3Pokedex.lua
@@ -142,6 +142,7 @@ function Gen3Pokedex.new(game, opts)
   local FRLG = require("src.ui.Gen3PokedexFRLG")
   if FRLG.record(game) then return FRLG.new(game, opts) end
   local self = setmetatable({ game = game, opts = opts or {} }, Gen3Pokedex)
+  require('src.compat.gen1.NativeModalObservation').capture(self,game)
   self.dexMode = (game.save and game.save.nationalDex) and 2 or 1
   self.list, self.count = Gen3Pokedex.listing(game, self.dexMode >= 2)
   self.index = 1
diff --git a/src/ui/Gen3PokedexFRLG.lua b/src/ui/Gen3PokedexFRLG.lua
index a185ed6f2..93895cf6e 100644
--- a/src/ui/Gen3PokedexFRLG.lua
+++ b/src/ui/Gen3PokedexFRLG.lua
@@ -55,6 +55,7 @@ end
 
 local function base(game, opts)
   local self = setmetatable({ game = game, opts = opts or {} }, Dex)
+  require('src.compat.gen1.NativeModalObservation').capture(self,game)
   self.rec = Dex.record(game)
   self.prefix = (game.save and game.save.nationalDex) and "national_" or "kanto_"
   self.cache = {}
diff --git a/src/ui/Gen3RegionMap.lua b/src/ui/Gen3RegionMap.lua
index dc6bc08c2..1a859bd79 100644
--- a/src/ui/Gen3RegionMap.lua
+++ b/src/ui/Gen3RegionMap.lua
@@ -117,19 +117,7 @@ end
 -- heal-location stage's, and a destination is offered only once it has been
 -- visited -- which is the same gate every other generation's fly uses.
 local function flyTargets(game)
-  local field = (game.data or {}).field or {}
-  local warps = field.flyWarps or {}
-  local visited = (game.save or {}).visited or {}
-  local maps = (game.data or {}).maps or {}
-  local bySection = {}
-  for _, mapId in ipairs(field.flyOrder or {}) do
-    local def = maps[mapId]
-    local sec = def and tonumber(def.regionMapSection)
-    if sec and visited[mapId] and warps[mapId] and not bySection[sec] then
-      bySection[sec] = mapId
-    end
-  end
-  return bySection
+  return require('src.world.Gen3FlyTargets').bySection(game)
 end
 
 -- ---------------------------------------------------------------------------
@@ -192,6 +180,9 @@ function Gen3RegionMap.new(game, opts)
     blink = 0,
   }, Gen3RegionMap)
 
+  require('src.compat.gen1.NativeModalObservation').capture(self,game)
+  local ow=game.overworld
+  self.here=ow and ow.map and ow.map.def and tonumber(ow.map.def.regionMapSection)
   self.targets = self.fly and flyTargets(game) or nil
 
   -- THE AREA PAGE.  Not a picker: the cartridge's area screen has no cursor
@@ -298,6 +289,29 @@ function Gen3RegionMap:current()
   return self:sectionAt(self.cx, self.cy)
 end
 
+-- Detached logical atlas metadata from this controller's actual cell lookup.
+-- Metadata-only context: no screen construction, image load or cursor state.
+function Gen3RegionMap.manifest(game)
+  local c=constants(game)
+  local layout=c.gen3RegionMapLayout
+  local grid=layout or c.gen3RegionMapGrid or{width=28,height=15}
+  local width,height=grid.width,grid.height
+  for _,n in ipairs{width,height}do
+    assert(type(n)=='number'and n%1==0 and n>0 and n<=256,'invalid native region atlas dimensions')
+  end
+  assert(width and height,'missing native region atlas dimensions')
+  local context={game=game,places=places(game)}
+  local out={game=require('src.core.GameVersion').get(),nativePicker=true,layout={}}
+  for y=0,height-1 do
+    local row={};out.layout[y+1]=row
+    for x=0,width-1 do
+      local place=Gen3RegionMap.sectionAt(context,x,y)
+      row[x+1]=place and place.section or(layout and layout.none)or false
+    end
+  end
+  return out
+end
+
 function Gen3RegionMap:close()
   if self.game.stack then self.game.stack:pop() end
   if self.onCancel then self.onCancel() end
diff --git a/src/ui/Gen3RsMenuCursor.lua b/src/ui/Gen3RsMenuCursor.lua
new file mode 100644
index 000000000..9115a0a56
--- /dev/null
+++ b/src/ui/Gen3RsMenuCursor.lua
@@ -0,0 +1,102 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Outline placement follows the cartridge cursor composition recorded by
+-- the pinned RS common-UI importer. Images belong to the native Assets owner.
+local Assets=require('src.render.Assets')
+local Scope=require('src.render.GraphicsScope')
+local Session=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local M={}
+local manifests=setmetatable({},{__mode='k'})
+local plans,order={},{}
+local function finite(v)return type(v)=='number'and v==v and math.abs(v)<math.huge end
+local function plan(width)
+ assert(finite(width)and width%1==0 and width>=1 and width<=4096,'invalid native RS cursor width')
+ if plans[width]then return plans[width]end
+ -- Interior strips cover 32 pixels at a time. A final partial wide strip
+ -- overlaps the preceding one; the right cap always starts at width-7.
+ local out={{part='left',x=-1}}
+ local wide=math.floor((width-1)/32)
+ for i=0,wide-1 do out[#out+1]={part='wide',x=1+i*32}end
+ local rest=(width-1)%32;local advance=1+wide*32
+ local tiles=math.floor(rest/8)
+ if width>39 and rest>8 then
+  out[#out+1]={part='wide',x=advance-32+tiles*8}
+ else for i=0,tiles-1 do out[#out+1]={part='middle',x=advance+i*8}end end
+ out[#out+1]={part='right',x=width-7}
+ if #order==16 then plans[table.remove(order,1)]=nil end
+ order[#order+1]=width;plans[width]=out
+ return out
+end
+function M.segments(width)
+ local copy={};for i,row in ipairs(plan(width))do copy[i]={part=row.part,x=row.x}end
+ return copy
+end
+function M.available(game)
+ local version=Version.get()
+ if version~='ruby'and version~='sapphire'then return false end
+ local c=game and game.data and game.data.constants
+ local spec=c and c.gen3RsBag
+ return type(spec)=='table'and spec.format==1 and spec.version==version
+  and type(spec.common)=='string'and spec.common=='data/generated/gba/rse/common_ui/manifest.lua'and spec or false
+end
+local function resources(game)
+ local spec=assert(M.available(game),'native RS common UI unavailable')
+ local cached=manifests[spec]
+ if cached and cached.path==spec.common and cached.version==spec.version then return cached.parts end
+ local chunk=assert(love.filesystem.load(spec.common),'native RS common UI manifest missing')
+ setfenv(chunk,{})
+ local manifest=chunk()
+ assert(type(manifest)=='table'and manifest.layout=='rs'and manifest.game==spec.version,
+  'mixed-edition native RS cursor manifest')
+ local cursor=manifest.menuCursor
+ assert(type(cursor)=='table','native RS cursor metadata missing')
+ local parts=cursor.parts or cursor;local paths={}
+ for _,name in ipairs{'left','middle','wide','right'}do
+  local part=parts[name];local width=name=='wide'and 32 or 8
+  assert(type(part)=='table'and type(part.png)=='string'and part.w==width and part.h==16,
+   'invalid native RS cursor part '..name)
+  assert(Assets.exists(part.png),'native RS cursor image missing: '..part.png)
+  paths[name]=part.png
+ end
+ manifests[spec]={path=spec.common,version=spec.version,parts=paths}
+ return paths
+end
+function M.paint(game,x,y,width,fx)
+ assert(finite(x)and finite(y),'invalid native RS cursor position')
+ local rows=plan(width)
+ local current=Session.game()
+ if not current or current~=game or(Version.get()~='ruby'and Version.get()~='sapphire')then
+  return false,'no current native RS cursor owner'
+ end
+ local parts=resources(game)
+ local images={}
+ for _,name in ipairs{'left','middle','wide','right'}do
+  local image=assert(Assets.image(parts[name]),'native RS cursor image unavailable')
+  local w,h=image:getDimensions()
+  -- Native images may have higher texel density while retaining logical size.
+  local logical=name=='wide'and 32 or 8
+  assert(w>=logical and h>=16 and w/logical==h/16,'invalid native RS cursor image density')
+  images[name]={image=image,scale=logical/w}
+ end
+ local ok,why=Scope.call(function()
+  local g=love.graphics;local Fx=require('src.core.game3.gba_fx')
+  for i=#rows,1,-1 do
+   local row=rows[i];local image=images[row.part]
+   Fx.draw(function()
+    g.setColor(1,1,1,1);g.draw(image.image,x+row.x,y,0,image.scale,image.scale)
+   end,fx)
+  end
+ end)
+ if not ok then error(why,0)end
+ return true
+end
+function M.draw(x,y,width,fx)return M.paint(Session.game(),x,y,width,fx)end
+function M.forGame(game)
+ local owner=setmetatable({game},{__mode='v'})
+ return{draw=function(x,y,width,fx)return M.paint(owner[1],x,y,width,fx)end}
+end
+M._service={release=function()manifests=setmetatable({},{__mode='k'});plans,order={},{}end}
+M._service.releaseOwner=M._service.release
+Assets.register(M._service.release)
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/ui/Gen3StartMenu.lua b/src/ui/Gen3StartMenu.lua
index 36f5ded1f..cd24d9483 100644
--- a/src/ui/Gen3StartMenu.lua
+++ b/src/ui/Gen3StartMenu.lua
@@ -47,6 +47,7 @@ local BOX_TW = 9
 local ROW_STEP = 2                    -- tiles between rows
 local TEXT_INSET_X = 8
 local CURSOR_X = 2
+Gen3StartMenu.CURSOR_WIDTH = TEXT_INSET_X
 
 -- HOW FAR DOWN ITS ROW A LINE SITS, which is not a constant either.
 --
@@ -352,6 +353,7 @@ function Gen3StartMenu:buildRows(game, labels, playerName)
   -- calling next() (src/mods/Hooks.lua) -- and the START menu is not a screen
   -- that may refuse to open.  A throwing hook leaves the cartridge's rows and
   -- a line on the console, which is the degradation every other seam here has.
+  for _,row in ipairs(self.rows)do if row.id==nil then row.id=row.key end end
   local ok, hooked = pcall(Runtime.call, "ui.start_menu.items", sameRows,
                            game, self.rows)
   if not ok then
@@ -638,6 +640,24 @@ function Gen3StartMenu:drawSavePanel(inset)
 end
 
 -- FireRed shows a row's explanation once, then remembers it in shared options.
+-- One detached content rectangle feeds the native skin and source wrappers.
+-- Existing row keys still dispatch native actions; source IDs are observations.
+function Gen3StartMenu:nativeContentTemplate()
+  local left,top,width,height=BOX_TX+1,BOX_TY+1,BOX_TW-2,#self.rows*ROW_STEP
+  if isFireRed(self.game)then
+    left,top,width,height=22,1,7,math.ceil(#self.rows*15/8)+1
+    for _,row in ipairs(self.rows)do width=math.max(width,math.ceil((Font.width(row.label)+10)/8))end
+    left=math.min(left,29-width)
+  end
+  return {left=left,top=top,width=width,height=height,
+    tilemapLeft=left,tilemapTop=top,w=width,h=height}
+end
+function Gen3StartMenu:contentTemplate()
+  local source=package.loaded['src.ui.game3.start_menu']
+  if source then return source._contentTemplate(self)end
+  return self:nativeContentTemplate()
+end
+
 function Gen3StartMenu:drawFireRed(record)
   local g = love.graphics
 
@@ -679,20 +699,13 @@ function Gen3StartMenu:drawFireRed(record)
     self.displayedHelpKey = nil
   end
 
-  local n = #self.rows
-  local innerH = math.ceil((n * 15) / 8) + 1
-  local left = 22
-  local width = 7
-  -- widen for the port's own rows (MODS, QUIT GAME) so nothing spills
-  for _, r in ipairs(self.rows) do
-    width = math.max(width, math.ceil((Font.width(r.label) + 10) / 8))
-  end
-  left = math.min(left, 29 - width)
-  Font.drawBox(left - 1, 0, width + 2, innerH + 2)
+  local tpl=self:contentTemplate()
+  local left,top,width,height=tpl.left,tpl.top,tpl.width,tpl.height
+  Font.drawBox(left-1,top-1,width+2,height+2)
   g.setColor(0, 0, 0, 1)
   for i, r in ipairs(self.rows) do
-    local y = 8 + (i - 1) * 15
-    Font.draw(r.label, left * 8 + 8, y)
+    local y = top*8 + (i - 1) * 15
+    Font.draw(r.label, left * 8 + self.CURSOR_WIDTH, y)
     if i == self.index then Font.drawCode(Theme.cursor, left * 8, y) end
   end
   g.setColor(1, 1, 1, 1)
@@ -703,12 +716,12 @@ function Gen3StartMenu:draw()
   if self.savePanel then return self:drawSavePanel(inset) end
   local record = (self.game.data.constants or {}).gen3StartMenu
   if record and record.layout == "frlg" then return self:drawFireRed(record) end
-  local th = #self.rows * ROW_STEP + 2
-  Font.drawBox(BOX_TX, BOX_TY, BOX_TW, th)
+  local tpl=self:contentTemplate()
+  Font.drawBox(tpl.left-1,tpl.top-1,tpl.width+2,tpl.height+2)
   love.graphics.setColor(0, 0, 0, 1)
   for i, row in ipairs(self.rows) do
-    local y = (BOX_TY + 1 + (i - 1) * ROW_STEP) * 8 + inset
-    Font.draw(row.label, BOX_TX * 8 + TEXT_INSET_X, y)
+    local y = (tpl.top + (i - 1) * ROW_STEP) * 8 + inset
+    Font.draw(row.label, (tpl.left-1) * 8 + TEXT_INSET_X, y)
     if i == self.index then
       -- Theme.cursor, not a literal arrow: this cartridge has NO arrow in
       -- its font (Emerald draws the menu cursor as a sprite), so the
@@ -720,10 +733,23 @@ function Gen3StartMenu:draw()
       --
       -- It also does not BLINK.  The Gen 2 list cursor blinks; Emerald's
       -- sits still and the selected row is the only thing that moves.
-      Font.drawCode(Theme.cursor, BOX_TX * 8 + CURSOR_X, y)
+      Font.drawCode(Theme.cursor, (tpl.left-1) * 8 + CURSOR_X, y)
     end
   end
   love.graphics.setColor(1, 1, 1, 1)
 end
 
+-- Source wrappers enter the same native update/draw phase and cannot run a
+-- second input clock by calling their base repeatedly.
+local nativeUpdate,nativeDraw=Gen3StartMenu.update,Gen3StartMenu.draw
+function Gen3StartMenu:update(dt)
+  local source=package.loaded['src.ui.game3.start_menu']
+  if source then return source._update(self,dt,nativeUpdate)end
+  return nativeUpdate(self,dt)
+end
+function Gen3StartMenu:draw()
+  local source=package.loaded['src.ui.game3.start_menu']
+  if source then return source._draw(self,nativeDraw)end
+  return nativeDraw(self)
+end
 return Gen3StartMenu
diff --git a/src/ui/Gen3SummaryMenu.lua b/src/ui/Gen3SummaryMenu.lua
index 9d54ee41b..23d0de904 100644
--- a/src/ui/Gen3SummaryMenu.lua
+++ b/src/ui/Gen3SummaryMenu.lua
@@ -517,6 +517,7 @@ function Gen3SummaryMenu:update(dt)
   if self.monAnim then self.monAnim:update(dt) end
   local input = self.game.input
   if not input then return end
+  if package.loaded['src.mods.FeatureOptions']and require('src.ui.TrainingDetails').input(self,input)then return end
   if type(self.choose) == "table" then
     self:chooseInput(input)
     return
@@ -928,6 +929,7 @@ function Gen3SummaryMenu:drawHeader()
   if not mon then return end
   local name = mon.nickname or (def and def.name) or tostring(mon.species)
   local title = self.pages[self.page] or ""
+  if package.loaded['src.mods.FeatureOptions']then title=require('src.ui.TrainingDetails').title(self,title)end
   if self.hasArt then
     -- THE PANEL, MEASURED.  Its picture box is the striped rectangle in the
     -- art: x 8..71, y 32..95, which is exactly 64 by 64 -- a Gen 3 front pic.
@@ -1281,7 +1283,9 @@ local STAT_ROWS = {
 
 function Gen3SummaryMenu:drawSkills()
   local mon = self.mon
-  local stats = mon and mon.stats or {}
+  local details=package.loaded['src.mods.FeatureOptions']and require('src.ui.TrainingDetails')
+  local training=details and details.stats(self)
+  local stats = training or mon and mon.stats or {}
   local Y = self:rows()
   local labelX, valueX, rightLabelX, rightValueX = self:cols()
   -- the six stat names come off the cartridge in ITS order (HP last); this
@@ -1314,7 +1318,7 @@ function Gen3SummaryMenu:drawSkills()
     local rowY = statY[left and i or (i - 3)] or Y[2]
     local label = romLabel[row.key] or Strings(row.label)
     local value
-    if row.key == "hp" then
+    if row.key == "hp"and not training then
       value = ("%d/%d"):format(mon.hp or 0, stats.hp or 0)
     else
       value = tostring(stats[row.key] or 0)
@@ -1777,7 +1781,9 @@ function Gen3SummaryMenu:drawFireRed(r)
   end
 
   -- header windows: page name (0,0)+4,1; level (0,2)+4,2; nickname +40; gender +105
-  frlgText(self.pages[self.page], 4, 1, header)
+  local title=self.pages[self.page]
+  if package.loaded['src.mods.FeatureOptions']then title=require('src.ui.TrainingDetails').title(self,title)end
+  frlgText(title, 4, 1, header)
   if not mon then return end
   local t = r.text or {}
   if not detail then
@@ -1835,8 +1841,10 @@ function Gen3SummaryMenu:drawFireRed(r)
     end
   elseif self.page == 2 then
     local px, py = 160, 16
-    local stats = mon.stats or {}
-    frlgRight(("%d/%d"):format(mon.hp or 0, stats.hp or 0), px + 77, py + 4, pane)
+    local details=package.loaded['src.mods.FeatureOptions']and require('src.ui.TrainingDetails')
+    local training=details and details.stats(self)
+    local stats = training or mon.stats or {}
+    frlgRight(training and tostring(stats.hp or 0)or("%d/%d"):format(mon.hp or 0, stats.hp or 0), px + 77, py + 4, pane)
     local order = { "attack", "defense", "spatk", "spdef", "speed" }
     for i, key in ipairs(order) do
       frlgRight(tostring(stats[key] or 0), px + 77, py + 22 + (i - 1) * 13, pane)
diff --git a/src/ui/MultiChoice.lua b/src/ui/MultiChoice.lua
new file mode 100644
index 000000000..5cee501a8
--- /dev/null
+++ b/src/ui/MultiChoice.lua
@@ -0,0 +1,39 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Inset choice windows use native input, font, frame and stack ownership.
+local Font=require('src.render.Font')
+local Theme=require('src.ui.Theme')
+local C={};C.__index=C
+function C.new(game,options,index,onChoose,layout)
+ layout=layout or{};assert(type(options)=='table'and#options>0,'choice options required')
+ local rows={};local max=0
+ for i,v in ipairs(options)do assert(type(v)=='string','invalid choice label');rows[i]=v;max=math.max(max,Font.width(v))end
+ local cols=math.max(1,math.min(#rows,math.floor(tonumber(layout.cols)or 1)))
+ local width=math.ceil(max/8)+3
+ local c=setmetatable({game=game,options=rows,index=math.max(1,math.min(#rows,(index or 0)+1)),onChoose=onChoose,
+  cols=cols,colTiles=width,tx=layout.left or Theme.choiceBox.tx,ty=layout.top or Theme.choiceBox.ty,
+  tw=width*cols+1,th=math.ceil(#rows/cols)*2+2,ignoreB=layout.ignoreBPress==true},C)
+ return c
+end
+function C:update()
+ local input=self.game.input;local n=#self.options
+ if input:wasPressed('a')then self.onChoose(self.index-1);return end
+ if input:wasPressed('b')and not self.ignoreB then self.onChoose(127);return end
+ local delta=input:wasPressed('down')and self.cols or input:wasPressed('up')and-self.cols
+  or input:wasPressed('right')and 1 or input:wasPressed('left')and-1
+ if delta then self.index=(self.index-1+delta)%n+1 end
+end
+function C:draw()
+ local ok,err=require('src.render.GraphicsScope').call(function()
+  Font.drawBox(self.tx,self.ty,self.tw,self.th)
+  love.graphics.setColor(0,0,0,1)
+  for i,label in ipairs(self.options)do
+   local x=(self.tx+2+(i-1)%self.cols*self.colTiles)*8
+   local y=(self.ty+1+math.floor((i-1)/self.cols)*2)*8
+   Font.draw(label,x,y)
+   if i==self.index then Font.drawCode(Theme.cursor,x-8,y)end
+  end
+ end)
+ if not ok then error(err,0)end
+end
+function C:uiSize()return Theme.uiSize()end
+return C
diff --git a/src/ui/RepelPrompt.lua b/src/ui/RepelPrompt.lua
new file mode 100644
index 000000000..f58777b17
--- /dev/null
+++ b/src/ui/RepelPrompt.lua
@@ -0,0 +1,30 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Reuse asks through native dialogue and consumes through native item effects.
+local P={}
+local remembered=setmetatable({},{__mode='k'})
+function P.remember(save,id)if type(save)=='table'then remembered[save]=id end end
+function P.item(game)
+ local inventory=game.save.inventory or{}
+ local last=remembered[game.save]
+ if last and(inventory[last]or 0)>0 then return last end
+ for _,id in ipairs{'MAX_REPEL','SUPER_REPEL','REPEL'}do if(inventory[id]or 0)>0 then return id end end
+end
+function P.show(game)
+ local features=package.loaded['src.mods.FeatureOptions'];local provider=features and features.provider('repelPrompt')
+ local id=provider and P.item(game);if not id then return false end
+ local flow= require('src.core.Game3')._withCallbackOwner(provider.who,function()return require('src.compat.gen1.UiFlow').new()end)
+ if not flow then return false end
+ local name=game.data.items[id]and game.data.items[id].name or id
+ local text=features.call(provider,'language')=='de'and('Noch einmal '..name..' verwenden?')or('Use another '..name..'?')
+ local TextBox=require('src.render.TextBox')
+ flow:push(TextBox.new(game,text,nil,{choice=function(yes)
+  if not flow:valid()then flow:retire();return end
+  if not yes or(game.save.inventory[id]or 0)<1 then flow:finish();return end
+  local result,messages=require('src.inventory.ItemEffects').use(game.data,game.save,id)
+  if result~='consumed'then flow:finish();return end
+  require('src.inventory.Bag').remove(game.save,id,1);P.remember(game.save,id)
+  flow:push(TextBox.new(game,table.concat(messages or{},'\f'),function()flow:finish()end))
+ end}))
+ return true
+end
+return P
diff --git a/src/ui/TrainingDetails.lua b/src/ui/TrainingDetails.lua
new file mode 100644
index 000000000..4a8226857
--- /dev/null
+++ b/src/ui/TrainingDetails.lua
@@ -0,0 +1,22 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local D={}
+function D.mode(menu)
+ local features=package.loaded['src.mods.FeatureOptions']
+ if not(features and features.enabled('trainingDetails')and menu.page==2 and not menu.moveSelect and not menu.choose)then return 0 end
+ return menu._trainingDetailMode or 0
+end
+function D.input(menu,input)
+ local features=package.loaded['src.mods.FeatureOptions']
+ if menu.page~=2 or menu.moveSelect or menu.choose or not(features and features.enabled('trainingDetails'))then return false end
+ if input:wasPressed('select')then menu._trainingDetailMode=((menu._trainingDetailMode or 0)+1)%3;return true end
+ return false
+end
+function D.stats(menu)
+ local mode=D.mode(menu)
+ if mode==0 then return nil end
+ return mode==1 and menu.mon.ivs or menu.mon.evs
+end
+function D.title(menu,title)
+ local mode=D.mode(menu);return mode==1 and'IV'or mode==2 and'EV'or title
+end
+return D
diff --git a/src/ui/game3/bag_menu.lua b/src/ui/game3/bag_menu.lua
new file mode 100644
index 000000000..0e059bafa
--- /dev/null
+++ b/src/ui/game3/bag_menu.lua
@@ -0,0 +1,6 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Query the actual native bag, including its nested TM/berry pockets.
+local Modal=require('src.compat.gen1.NativeModalObservation')
+local M={}
+function M.isOpen()return Modal.find({'src.ui.Gen3BagMenu'})~=nil end
+return M
diff --git a/src/ui/game3/battle_chrome.lua b/src/ui/game3/battle_chrome.lua
new file mode 100644
index 000000000..b0e8a9d3b
--- /dev/null
+++ b/src/ui/game3/battle_chrome.lua
@@ -0,0 +1,202 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Cartridge windows and native panel drawing share the admitted battle owner.
+local Native=require('src.battle.Gen3Battle')
+local Battle=require('src.core.game3.battle')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local Scope=require('src.render.GraphicsScope')
+local Version=require('src.core.GameVersion')
+local C={WIN={MSG=0,ACTION_PROMPT=1,ACTION_MENU=2,MOVE_NAME_1=3,MOVE_NAME_2=4,MOVE_NAME_3=5,
+ MOVE_NAME_4=6,PP=7,DUMMY=8,PP_REMAINING=9,MOVE_TYPE=10,SWITCH_PROMPT=11,YESNO=12,LEVEL_UP_BOX=13,LEVEL_UP_BANNER=14}}
+local function owner()
+ local screen=Battle._screen();if screen then return screen end
+ local g=require('src.compat.gen1.NativeSession').game()
+ return g and{game=g,data=g.data}
+end
+function C.layout()
+ local v=Version.get();return(v=='ruby'or v=='sapphire')and'rs'or v=='emerald'and'emerald'or'frlg'
+end
+function C.isHoenn()return C.layout()~='frlg'end
+function C.window(id)
+ assert(type(id)=='number'and id%1==0 and id>=0 and id<=14,'invalid battle window')
+ local s=owner();if not s then return nil,'no native GBA owner'end
+ local c=s.data.constants;local rec=c.gen3BattleWindows
+ local row=rec and rec.templates and rec.templates[id+1]
+ if not row and rec then
+  row=({[0]=rec.message,rec.prompt,rec.action})[id]
+  if id>=3 and id<=6 then row=rec.moves and rec.moves[id-2]end
+ end
+ if not row then return nil,'window not present in imported native templates'end
+ local w,h=row.width or row.w,row.height or row.h
+ if Battle._screen()==s and id<=6 then
+  local windows=Native.windows(s)
+  local frame=({[0]=windows.message,windows.prompt,windows.action})[id]
+  if id>=3 then frame=windows.moves and windows.moves[id-2]end
+  if frame then return{left=frame.textX/8,top=frame.row1/8,w=frame.cols or frame.tw-2,h=frame.th-2,x=frame.textX,y=frame.row1}end
+ end
+ return{left=row.left,top=row.top%20,w=w,h=h,x=row.left*8,y=(row.top%20)*8}
+end
+function C.textOrigin(id)
+ local w,why=C.window(id);if not w then return nil,why end
+ local dx=id==1 and 1 or id==9 and 2 or 0
+ return w.x+dx,w.y+1,w.w*8,id>=3 and id<=7 or id==10 or id==11
+end
+function C.messageOrigin()
+ if C.layout()~='emerald'then return 10,122,224 end
+ return C.textOrigin(C.WIN.MSG)
+end
+local function colorRecord(fg,shadow)
+ -- Numeric aliases retain the earlier foreground/shadow tuple contract.
+ -- Return detached values: presentation callers cannot edit imported data.
+ local a={fg[1],fg[2],fg[3],fg[4]or 1}
+ local b={shadow[1],shadow[2],shadow[3],shadow[4]or 1}
+ return{a[1],a[2],a[3],a[4],fg=a,shadow=b,bg={0,0,0,0}},b
+end
+local function colorIndex(value)
+ assert(type(value)=='number'and value%1==0 and value>=0 and value<16,'invalid native textbox colour index')
+ return value
+end
+local function packedColor(value)
+ local r,g,b=require('src.render.Gen3IndexedPalette').rgb(value)
+ local function channel(n)return(n*8+math.floor(n/4))/255 end
+ return{channel(r),channel(g),channel(b),1}
+end
+local function packedPalette(palette)
+ if type(palette)~='table'or #palette~=16 then return end
+ for i=1,16 do
+  local v=palette[i]
+  if type(v)~='number'or v%1~=0 or v<0 or v>65535 then return end
+ end
+ return palette
+end
+function C.textboxColors(fg,shadow)
+ local explicit=fg~=nil or shadow~=nil
+ fg,shadow=colorIndex(fg==nil and 1 or fg),colorIndex(shadow==nil and 8 or shadow)
+ local s=owner();local version=Version.get()
+ local gba=version=='firered'or version=='leafgreen'or version=='emerald'or version=='ruby'or version=='sapphire'
+ local constants=gba and s and s.data and s.data.constants or{}
+ if not explicit and s and gba then
+  local a,b=Native.textColors(s,'message')
+  if a and b then return colorRecord(a,b)end
+ end
+ local rs=version=='ruby'or version=='sapphire'
+ local record
+ if rs then record=constants.gen3RsBattlePanel else record=constants.gen3BattleTextbox end
+ if rs and not(type(record)=='table'and record.format==1 and record.version==version)then record=nil end
+ local palette=type(record)=='table'and packedPalette(record.palette)
+ if palette then return colorRecord(packedColor(palette[fg+1]),packedColor(palette[shadow+1]))end
+ -- Older native imports retain named role colours. They are authoritative
+ -- only for that role's exact indices (or the legacy no-argument query).
+ local role=not rs and type(record)=='table'and record.text and record.text.message
+ local indices=role and role.indices
+ if s and gba and type(indices)=='table'and indices.fg==fg and indices.shadow==shadow then
+  local a,b=Native.textColors(s,'message')
+  if a and b then return colorRecord(a,b)end
+ end
+ local white=require('src.ui.game3.frlg_font').COLOR.WHITE
+ local colors,second=colorRecord(white.fg,white.shadow)
+ return colors,second,'native textbox palette unavailable'
+end
+function C.manifest()
+ local s=owner();if not s then return nil,'no native GBA owner'end
+ local c=s.data.constants;local text=Native.textbox(s)
+ local copy=require('src.mods.Merge').deepCopy
+ local version=Version.get();local rs=version=='ruby'or version=='sapphire'
+ local textboxPal,windowPal,ppPal
+ if rs then
+  local panel,bag=c.gen3RsBattlePanel,c.gen3RsBag
+  if type(panel)=='table'and panel.format==1 and panel.version==version then textboxPal=packedPalette(panel.palette)end
+  if type(bag)=='table'and bag.format==1 and bag.version==version then windowPal=packedPalette(bag.palette);ppPal=windowPal end
+ elseif Version.generation(version)==3 and text then
+  textboxPal=packedPalette(text.palette);windowPal=packedPalette(text.windowPalette);ppPal=packedPalette(text.ppPalette)
+ end
+ local templates={}
+ for id=0,14 do local row=C.window(id);if row then templates[id+1]={left=row.left,top=row.top,w=row.w,h=row.h}end end
+ return{layout=C.layout()=='frlg'and'frlg'or'rse',assetLayout=C.layout(),
+  windows={normal=templates},
+  text=copy(text and text.text or{}),textboxPal=copy(textboxPal),windowTextPal=copy(windowPal),ppTextPal=copy(ppPal),native=true}
+end
+local function partyPhase(player)return'battle.partySummary.'..(player and'player'or'enemy')end
+function C.drawPartyBar(x,y,balls,ox,opponent,opts)
+ assert(opponent==nil or type(opponent)=='boolean','invalid party summary side')
+ for _,value in pairs{x=x,y=y,ox=ox}do
+  assert(type(value)=='number'and value==value and math.abs(value)<math.huge,'invalid party summary position')
+ end
+ assert(balls==nil or type(balls)=='table','invalid party summary slots')
+ assert(opts==nil or type(opts)=='table','invalid party summary options')
+ local player=not opponent;local phase=partyPhase(player)
+ if Boundary.active(phase)then return Boundary.invoke(phase)end
+ local screen=Battle._screen();if not screen then return false,'no native battle'end
+ opts=opts or{}
+ local ok,drawn=Scope.call(function()
+  return Native.paintPartySummary(screen,player,{x=x,y=y,ox=ox,slots=balls,
+   alpha=opts.alpha,ballHidden=opts.ballHidden,ballOx=opts.ballOx,extended=opts.extended})
+ end)
+ if not ok then error(drawn,0)end
+ return drawn
+end
+local basePartyBar=C.drawPartyBar
+function C._nativePartySummary(screen,player,body)
+ if C.drawPartyBar==basePartyBar then return body()end
+ local phase=partyPhase(player)
+ if Boundary.active(phase)then return Boundary.invoke(phase)end
+ local stage=require('src.core.game3.battle.stage').current(Call.owner(C,'drawPartyBar'))
+ local bar=stage and stage.partyBar[player and'player'or'enemy']
+ if not bar or not bar.visible then return body()end
+ local ok,result=Scope.call(function()
+  return Boundary.dispatch(phase,body,function()
+   return Call.call(C,'drawPartyBar',bar.x,bar.y,bar.balls,bar.ox,not player,bar)
+  end)
+ end)
+ if not ok then error(result,0)end
+ return result
+end
+local modes={none='message',menu='action',moves='moves'}
+local painted
+local function serial()local r=package.loaded['src.render.Renderer'];return r and r.frameSerial end
+function C.drawPanel(mode)
+ assert(modes[mode],'invalid battle panel mode')
+ local screen=Battle._screen();if not screen then painted=nil;return false,'no native battle'end
+ local drawn,included
+ if Boundary.active('battle.panel')then drawn=Boundary.invoke('battle.panel');included=drawn==true
+ else drawn,included=require('src.battle.Gen3BattleFrames').panel(screen,modes[mode])end
+ if drawn then
+  painted={refs=setmetatable({screen},{__mode='v'}),view=Battle.getState(),mode=mode,
+   target=Battle._renderTarget(),token=Scope.token(),serial=serial(),frame=screen.frame,included=included}
+ else painted=nil end
+ return drawn
+end
+function C.drawMenuFrames(mode)
+ assert(modes[mode],'invalid battle panel mode')
+ local screen=Battle._screen();if not screen then painted=nil;return false,'no native battle'end
+ local receipt=painted;painted=nil
+ local same=receipt and receipt.refs[1]==screen and receipt.view==Battle.getState()
+  and receipt.mode==mode and receipt.frame==screen.frame and Battle._sameRenderTarget(receipt.target,Battle._renderTarget())
+ if same then
+  if receipt.serial~=nil then same=receipt.serial==serial()
+  else same=receipt.token~=nil and receipt.token==Scope.token()end
+ end
+ local included=same and receipt.included or false
+ local ok,drawn,count=Scope.call(function()return require('src.battle.Gen3BattleFrames').draw(screen,modes[mode],included)end)
+ if not ok then error(drawn,0)end
+ return drawn,count
+end
+C._service={release=function()painted=nil end,releaseOwner=function()painted=nil end,
+ poll=function()
+  if not painted then return end
+  local screen=painted.refs[1]
+  if not screen or screen~=Battle._screen()or painted.view~=Battle.getState()or painted.frame~=screen.frame then painted=nil end
+ end}
+require('src.core.game3.asset_stream').register(C._service)
+local basePanel=C.drawPanel
+function C._panel(screen,which,body)
+ if C.drawPanel==basePanel then return body()end
+ local mode=which=='action'and'menu'or which=='moves'and'moves'or'none'
+ local ok,result=Scope.call(function()
+  Boundary.dispatch('battle.panel',body,function()return Call.call(C,'drawPanel',mode)end)
+ end)
+ if not ok then error(result,0)end
+ -- A presentation wrapper owns the panel even if its painter returns nil.
+ return true
+end
+return C
diff --git a/src/ui/game3/choice.lua b/src/ui/game3/choice.lua
new file mode 100644
index 000000000..9e611a777
--- /dev/null
+++ b/src/ui/game3/choice.lua
@@ -0,0 +1,12 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local C={}
+local active
+function C.isOpen()return active~=nil and active:valid()end
+function C.multi(options,defaultIdx,callback,layout)
+ if C.isOpen()then return false end
+ local flow,why=require('src.compat.gen1.UiFlow').new(callback)
+ if not flow then return false,why end
+ local state=require('src.ui.MultiChoice').new(flow.game,options,defaultIdx,function(index)flow:finish(index)end,layout)
+ active=flow;flow:push(state);return true
+end
+return C
diff --git a/src/ui/game3/chrome.lua b/src/ui/game3/chrome.lua
new file mode 100644
index 000000000..16f3de04a
--- /dev/null
+++ b/src/ui/game3/chrome.lua
@@ -0,0 +1,7 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local C={}
+function C.dialogueWindow()
+  local b=require('src.ui.Theme').textBox
+  return b.tx,b.ty,b.tw,b.th
+end
+return C
diff --git a/src/ui/game3/evolution_scene.lua b/src/ui/game3/evolution_scene.lua
new file mode 100644
index 000000000..f6125f69f
--- /dev/null
+++ b/src/ui/game3/evolution_scene.lua
@@ -0,0 +1,25 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Flow=require('src.compat.gen1.UiFlow')
+local Source=require('src.compat.gen1.SourcePokemon')
+local Ids=require('src.compat.gen1.BattleIds')
+local E={}
+local active
+function E.isOpen()return active~=nil and active:valid()end
+function E.start(value,target,opts)
+ opts=opts or{};if E.isOpen()then return false end
+ local mon,known,g=Source.resident(value);if not mon then return false,'evolution requires a live party member'end
+ local member=false;for _,m in ipairs(g.save.party or{})do if m==mon then member=true end end
+ if not member then return false,'evolution requires the current party'end
+ local key=Ids.new(g.data):native('pokemon',target);if not key then return false,'unknown evolution species'end
+ local expected,evo=require('src.pokemon.Evolution').pendingFor(g,mon,{kind='levelup'})
+ if key~=expected then return false,'evolution target changed'end
+ local flow,why=Flow.new(function(...)active=nil;if opts.onDone then opts.onDone(...)end end)
+ if not flow then return false,why end
+ active=flow
+ local ok,err=pcall(function()
+  flow:push(require('src.ui.Gen3EvolutionState').new(g,mon,key,function(...)flow:finish(...)end,opts.canStop==false and'ITEM'or'LEVEL',evo))
+ end)
+ if not ok then flow:retire();active=nil;error(err,0)end
+ return true
+end
+return E
diff --git a/src/ui/game3/fade.lua b/src/ui/game3/fade.lua
new file mode 100644
index 000000000..97bceb0d6
--- /dev/null
+++ b/src/ui/game3/fade.lua
@@ -0,0 +1,75 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Current native palette/warp fades and owned field fades share native clocks.
+local Native=require('src.compat.gen1.NativeSession')
+local Layer=require('src.render.FieldFade')
+local Transition=require('src.render.Transition')
+local Flow=require('src.compat.gen1.UiFlow')
+local G=require('src.core.Game3')
+local F={MODE={FROM_BLACK=0,TO_BLACK=1,FROM_WHITE=2,TO_WHITE=3}}
+local current
+local function retire()
+ local c=current;current=nil
+ if c then
+  local state=c.state;state.ramp=nil;state:releaseVeil();c.flow:retire()
+  state.sourceRetired=true;state.game,state.ow=nil,nil;c.state,c.flow=nil,nil
+ end
+end
+local function observed()
+ if current and not current.flow:valid()then retire()end
+ local g=Native.game();if not(g and g.stack)then return end
+ for i=#(g.stack.states or{}),1,-1 do
+  local state=g.stack.states[i]
+  local alpha,white,direction,active,locked=Layer.describe(state)
+  if alpha==nil then alpha,white,direction,active,locked=Transition.describe(state)end
+  if alpha~=nil then return alpha,white,direction,active,locked,state end
+ end
+end
+function F.isActive()local _,_,_,active=observed();return active==true end
+local function owner()
+ local host=package.loaded['src.mods.Runtime'];return host and host.currentMod or G._callbackOwner()
+end
+function F.clear()
+ if not current or current.who~=owner()then return false end
+ retire();return true
+end
+function F.begin(mode,speed,done)
+ assert(type(mode)=='number'and mode%1==0 and mode>=0 and mode<=3,'invalid native fade mode')
+ speed=speed or 1;assert(type(speed)=='number'and speed%1==0 and speed>=1 and speed<=600,'invalid native fade speed')
+ assert(done==nil or type(done)=='function','invalid fade continuation')
+ local g=Native.resolve();if not g then return false,'field fade requires an admitted native world'end
+ observed()
+ if current then
+  if current.who~=owner()then return false,'fade belongs to another mod'end
+  retire()
+ end
+ local _,_,_,_,_,foreign=observed();if foreign then return false,'native fade already owns presentation'end
+ local flow,why=Flow.new();if not flow then return false,why end
+ local outward=mode==1 or mode==3
+ local state=Layer.new(g,nil,mode>=2 and'white'or'black',{ownedHold=true})
+ state.alpha=outward and 0 or 1;state.sourceFadeDirection=outward and 1 or -1
+ local record={game=g,flow=flow,state=state,who=owner()};current=record
+ state.ramp={from=state.alpha,to=outward and 1 or 0,frames=16*speed,steps=16,stepFrames=speed,t=0,
+  onDone=function()
+   if current~=record or not flow:valid()then return end
+   local callback=done;done=nil
+   if not outward then retire()end
+   if callback then G._withCallbackOwner(record.who,callback)end
+  end}
+ flow:push(state);return true
+end
+F._service={release=retire,poll=function()if current then observed()end end,
+ releaseOwner=function(_,who)if current and current.who==who then retire()end end}
+require('src.core.game3.asset_stream').register(F._service)
+return setmetatable(F,{__index=function(_,key)
+ local alpha,white,direction,active,locked=observed()
+ if key=='active'then return active==true end
+ if key=='t'then return math.floor(math.max(0,math.min(1,alpha or 0))*16+.5)end
+ if key=='mode'then return(white and 2 or 0)+(direction==1 and 1 or 0)end
+ if key=='_dir'then return direction or 0 end
+ if key=='lockInput'then return locked==true end
+end,__newindex=function(t,key,value)
+ if key=='t'or key=='mode'or key=='_dir'or key=='active'or key=='lockInput'then
+  error('native fade observation '..tostring(key)..' is read-only',2)
+ end
+ rawset(t,key,value)
+end})
diff --git a/src/ui/game3/frlg_font.lua b/src/ui/game3/frlg_font.lua
new file mode 100644
index 000000000..12e44f8c7
--- /dev/null
+++ b/src/ui/game3/frlg_font.lua
@@ -0,0 +1,79 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source text uses the native imported proportional faces and shaders.
+local Font=require('src.render.Font')
+local Scope=require('src.render.GraphicsScope')
+local Pen=require('src.render.Gen3TextPen')
+local F={LINE_PITCH=15,GLYPH_HEIGHT=14}
+F.COLOR={NORMAL={fg={98/255,98/255,98/255,1},shadow={213/255,213/255,205/255,1}},
+  WHITE={fg={1,1,1,1},shadow={98/255,98/255,98/255,1}}}
+local function face(opts,fn)
+  local name=opts and(opts.font or opts.small and 'small')
+  local pushed=type(name)=='string'and Font.hasFace(name)
+  if pushed then Font.pushFace(name)end
+  local ok,value=pcall(fn)
+  if pushed then Font.popFace()end
+  if not ok then error(value,0)end
+  return value
+end
+-- IDs come from the current native charmap, including relocated/Unicode
+-- glyphs. Faces select the native shape and advance without a second atlas.
+function F.glyphId(text)
+ return Font.encode(tostring(text or''))[1]or Font.encode(' ')[1]or 0x7F
+end
+function F.advance(code,opts)
+ return face(opts,function()return Font.advanceOf(code)end)
+end
+function F.drawGlyph(code,x,y,opts)
+ opts=opts or{}
+ local ok,value=Scope.call(function()return face(opts,function()
+  local colors=opts.colors or F.COLOR.NORMAL
+  local toned=Font.beginTwoTone(opts.color or colors.fg or F.COLOR.NORMAL.fg,colors.shadow or F.COLOR.NORMAL.shadow)
+  local good,advance=pcall(function()Font.drawCode(code,x,y);return Font.advanceOf(code)end)
+  if toned then Font.endTwoTone()end
+  if not good then error(advance,0)end
+  return advance
+ end)end)
+ if not ok then error(value,0)end
+ return value
+end
+function F.measure(text,opts)
+  return face(opts,function()
+    if Pen.isCompound(text)and not(opts and(opts.limitChars or opts.maxWidth or(opts.letterSpacing or 0)~=0))then return Pen.compoundWidth(text)end
+    if Pen.has(text)then return Pen.layout(text,opts)end
+    local max=0
+    for line in(tostring(text or'')..'\n'):gmatch('(.-)\n')do max=math.max(max,Font.width(line)+math.max(0,#Font.split(line)-1)*(opts and opts.letterSpacing or 0))end
+    return max
+  end)
+end
+function F.draw(text,x,y,opts)
+  opts=opts or{}
+  local ok,value=Scope.call(function()return face(opts,function()
+    local colors=opts.colors or F.COLOR.NORMAL
+    local toned=Font.beginTwoTone(opts.color or colors.fg or F.COLOR.NORMAL.fg,colors.shadow or F.COLOR.NORMAL.shadow)
+    local good,width=pcall(function()
+      if Pen.isCompound(text)and not(opts.limitChars or opts.maxWidth or(opts.letterSpacing or 0)~=0)then return Pen.drawCompound(text,x,y)end
+      if Pen.has(text)then return Pen.layout(text,opts,function(glyph,dx,dy,code)
+        if code then Font.drawCode(code,x+dx,y+dy)else Font.draw(glyph,x+dx,y+dy)end
+      end)end
+      local max,lineY,count=0,y,0
+      for line in(tostring(text or'')..'\n'):gmatch('(.-)\n')do
+        local xx=x
+        for _,span in ipairs(Font.split(line))do
+          if opts.limitChars and count>=opts.limitChars then break end
+          local glyph=line:sub(span.from,span.to);local advance=Font.width(glyph)
+          if not opts.maxWidth or xx-x+advance<=opts.maxWidth then Font.draw(glyph,xx,lineY)end
+          xx=xx+advance+(opts.letterSpacing or 0);count=count+1
+        end
+        max=math.max(max,xx-x-(#Font.split(line)>0 and(opts.letterSpacing or 0)or 0));lineY=lineY+(opts.linePitch or F.LINE_PITCH)
+      end
+      return max
+    end)
+    if toned then Font.endTwoTone()end
+    if not good then error(width,0)end
+    return width
+  end)end)
+  if not ok then error(value,0)end
+  return value
+end
+setmetatable(F,{__index=function(_,k)if k=='_spec'then return{nativeLayout=require('src.core.GameVersion').isFRLG()and'frlg'or'rs'}end end})
+return F
diff --git a/src/ui/game3/help_system.lua b/src/ui/game3/help_system.lua
new file mode 100644
index 000000000..14c7d789f
--- /dev/null
+++ b/src/ui/game3/help_system.lua
@@ -0,0 +1,46 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe and borrow the actual native Help modal, including covered draws.
+local Native=require('src.compat.gen1.NativeSession')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local M={}
+local states=setmetatable({},{__mode='k'})
+local function current()
+ local game=Native.game();if not(game and game.stack)then return end
+ for i=#game.stack.states,1,-1 do
+  local state=game.stack.states[i]
+  if states[state]and state:valid()then return state end
+ end
+end
+function M.isOpen()return current()~=nil end
+function M.show(game,context)
+ local owner,why=Native.game(game);if not owner then return false,why end
+ if owner~=Native.game()then return false,'foreign native Help session'end
+ if current()then return false,'native Help is already open'end
+ local who=Call.owner(M,'show')
+ local state;state,why=require('src.ui.Gen3HelpMenu').new(owner,context,who)
+ if not state then return false,why end
+ states[state]=true;owner.stack:push(state);return true
+end
+function M.close()local state=current();if not state then return false end;state:close();return true end
+function M.draw()return Boundary.invoke('help.draw')end
+function M._nativeDraw(state,paint)
+ if not state:valid()then return false,'native Help retired'end
+ local ok,result=require('src.render.GraphicsScope').call(function()
+  return Boundary.dispatch('help.draw',function()
+   if not state:valid()then return false,'native Help admission changed'end
+   return require('src.core.Game3')._withCallbackOwner(nil,paint)
+  end,function()return Call.call(M,'draw')end)
+ end)
+ if not ok then error(result,0)end;return result
+end
+local service={}
+function service:release()for state in pairs(states)do state:close();states[state]=nil end end
+function service:releaseOwner(owner)
+ for state in pairs(states)do if state.owner==owner then state:close();states[state]=nil end end
+end
+function service:poll()
+ for state in pairs(states)do if not state:valid()then state:close();states[state]=nil end end
+end
+require('src.core.game3.asset_stream').register(service);M._service=service
+return M
diff --git a/src/ui/game3/hud.lua b/src/ui/game3/hud.lua
new file mode 100644
index 000000000..f9f662c46
--- /dev/null
+++ b/src/ui/game3/hud.lua
@@ -0,0 +1,5 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local H={}
+function H.isBusy()return require('src.core.game3.runtime').uiBusy()end
+H.busy=H.isBusy
+return H
diff --git a/src/ui/game3/map_preview_screen.lua b/src/ui/game3/map_preview_screen.lua
new file mode 100644
index 000000000..c22cbaf8c
--- /dev/null
+++ b/src/ui/game3/map_preview_screen.lua
@@ -0,0 +1,21 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe the admitted native preview; it owns its input, flags and clock.
+local Native = require('src.compat.gen1.NativeSession')
+local Preview = require('src.world.Gen3MapPreviewFRLG')
+local M = {}
+local function observed()
+ local game = Native.game()
+ local states = game and game.stack and game.stack.states
+ for i = #(states or {}), 1, -1 do
+  local state = states[i]
+  if getmetatable(state) == Preview and state.game == game then return state end
+ end
+end
+function M.isActive() return observed() ~= nil end
+function M.isForestActive()
+ local state = observed()
+ local rec = state and Preview.record(state.game, state.section)
+ return rec ~= nil and rec.type == 'forest'
+end
+function M.mapsec() local state = observed(); return state and state.section end
+return M
diff --git a/src/ui/game3/message.lua b/src/ui/game3/message.lua
new file mode 100644
index 000000000..ea889047f
--- /dev/null
+++ b/src/ui/game3/message.lua
@@ -0,0 +1,67 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Dialogue observations and commands over the native printer/stack owner.
+local Native=require('src.compat.gen1.NativeSession')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local M={}
+local active,drawBox
+local frame='normal'
+local function current()
+ local g=Native.game();if not(g and g.stack)then return end
+ local TextBox=package.loaded['src.render.TextBox'];if not TextBox then return end
+ for i=#g.stack.states,1,-1 do
+  local state=g.stack.states[i]
+  if getmetatable(state)==TextBox then return state end
+  if state.isOpaque then return end
+ end
+end
+function M.isOpen()return current()~=nil end
+function M.isWaiting()local b=current();return b~=nil and(b.waiting or b.done)end
+function M.isTyping()local b=current();return b~=nil and not(b.waiting or b.done)end
+function M.isHeld()local b=current();return b~=nil and b.sourceHeld==true end
+function M.currentPage()local b=current();return b and table.concat(b.pages[b.pageIndex],'\n')end
+function M.setFrame(kind)frame=kind or'normal'end
+function M.frameKind()return frame end
+function M.show(text,opts)
+ opts=opts or{}
+ if active and active:valid()then active:retire()end
+ local flow,why=require('src.compat.gen1.UiFlow').new(opts.done)
+ if not flow then return false,why end
+ local b=require('src.render.TextBox').new(flow.game,text,function()flow:finish()end,
+  {stay=(opts.stay or opts.hold)and{}or nil,signpost=opts.sign or opts.frame=='sign',
+   style=opts.colors,box=opts.box,maxPixels=opts.maxWidth})
+ b.sourceHeld=opts.hold==true;b.sourceMessage=true
+ active=flow;flow:push(b)
+ if tonumber(opts.speed)==0 then b:revealPage()end
+ return true
+end
+function M.showStay(text,opts)
+ local copy={};for k,v in pairs(opts or{})do copy[k]=v end;copy.stay=true;return M.show(text,copy)
+end
+function M.close()
+ local b=current();if not(b and b.sourceMessage and b.nativeUiFlow)then return false end
+ return b.nativeUiFlow:finish()
+end
+function M.closeStay()local b=current();if b and b.stay then return M.close()end;return false end
+function M.skipReveal()local b=current();if b then b:revealPage();return true end;return false end
+function M.advance()
+ local b=current();if not b or b.sourceHeld then return false end
+ if not(b.waiting or b.done)then b:revealPage()else b:advance()end
+ return true
+end
+M.pressAB=M.advance
+function M.reset()if active then active:retire();active=nil end end
+function M.tick()return Boundary.invoke('message.update')end
+function M.draw()return Boundary.invoke('message.draw')end
+M.drawText=M.draw
+function M._draw(box,body)
+ local previous=drawBox;drawBox=box
+ local ok,result=require('src.render.GraphicsScope').call(function()
+  return Boundary.dispatch('message.draw',body,function()return Call.call(M,'draw')end)
+ end)
+ drawBox=previous;if not ok then error(result,0)end;return result
+end
+function M._update(box,body)
+ return Boundary.dispatch('message.update',body,function()return Call.call(M,'tick')end)
+end
+return M
diff --git a/src/ui/game3/move_relearner.lua b/src/ui/game3/move_relearner.lua
new file mode 100644
index 000000000..feebbcdbc
--- /dev/null
+++ b/src/ui/game3/move_relearner.lua
@@ -0,0 +1,42 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Flow=require('src.compat.gen1.UiFlow')
+local Source=require('src.compat.gen1.SourcePokemon')
+local Ids=require('src.compat.gen1.BattleIds')
+local R={}
+local active
+function R.isOpen()return active~=nil and active:valid()end
+function R.show(value,opts)
+ opts=opts or{};if R.isOpen()then return false end
+ local mon,known,g=Source.resident(value);if not mon then return false,'move learning requires a live party member'end
+ local member=false;for _,m in ipairs(g.save.party or{})do if m==mon then member=true end end
+ if not member then return false end
+ local flow,why=Flow.new(function(...)active=nil;if opts.onDone then opts.onDone(...)end end)
+ if not flow then return false,why end
+ active=flow;local ids=Ids.new(g.data)
+ local function choose()
+  if not flow:valid()then flow:retire();return end
+  local entries={}
+  for _,number in ipairs(require('src.core.game3.move_learn').relearnableMoves(value))do
+   local key=ids:native('moves',number)
+   if key then entries[#entries+1]={label=g.data.moves[key].name,value=key}end
+  end
+  if #entries==0 then flow:finish(false);return end
+  local list
+  list=require('src.ui.ListMenu').new(g,'Remember a move',entries,{onCancel=function()flow:finish(false)end,
+   onChoose=function(row)
+    if not flow:valid()then flow:retire();return end
+    g.stack:removeAll({list})
+    flow:admit(function()
+     require('src.pokemon.Evolution').learnMoves(g,mon,{row.value},function()
+      local learned=false;for _,move in ipairs(mon.moves or{})do if move.id==row.value then learned=true end end
+      if learned then flow:finish(true)else choose()end
+     end)
+    end)
+   end})
+  flow:push(list)
+ end
+ local ok,err=pcall(choose)
+ if not ok then flow:retire();active=nil;error(err,0)end
+ return R.isOpen()
+end
+return R
diff --git a/src/ui/game3/party_menu.lua b/src/ui/game3/party_menu.lua
new file mode 100644
index 000000000..8c1cb7dbf
--- /dev/null
+++ b/src/ui/game3/party_menu.lua
@@ -0,0 +1,115 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Source party extensions edit the real native submenu and input phase.
+local Native=require('src.compat.gen1.NativeSession')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local M={}
+local current
+local function retire()
+ local c=current;current=nil
+ if c then
+  c.mons:release();c.game,c.screen,c.save,c.data,c.loader,c.rows,c.nativeList,c.list=nil,nil,nil,nil,nil,nil,nil,nil
+  c.extras,c.party={},{}
+ end
+end
+local function observe(screen)
+ local g=Native.game();if not(g and g.stack)then retire();return end
+ local class=package.loaded['src.ui.Gen3PartyMenu']
+ if not class then retire();return end
+ if not screen then for i=#g.stack.states,1,-1 do if getmetatable(g.stack.states[i])==class then screen=g.stack.states[i];break end end end
+ if not screen or getmetatable(screen)~=class or screen.game~=g then retire();return end
+ if not current or current.screen~=screen or current.save~=g.save or current.data~=g.data then
+  retire()
+  local c={screen=screen,game=g,save=g.save,data=g.data,loader=g.mods,edition=require('src.core.GameVersion').get(),extras={},party={}}
+  current=c
+  function c:valid()
+   if not self.game or Native.game()~=self.game or self.game.save~=self.save or self.game.data~=self.data
+    or self.game.mods~=self.loader or require('src.core.GameVersion').get()~=self.edition then return false end
+   for _,s in ipairs(self.game.stack.states)do if s==self.screen then return true end end
+   return false
+  end
+  c.mons=require('src.compat.gen1.PokemonView').new(g,function()return c:valid()end)
+ end
+ if not current:valid()then retire();return end
+ return current
+end
+local function actions(c)
+ local s=c.screen;if not s.submenu then c.list,c.nativeList=nil,nil;return nil end
+ if s.submenu~=c.nativeList then
+  c.nativeList=s.submenu;c.list={};c.rows={}
+  for i,row in ipairs(s.submenu)do
+   local key=row.move or(type(row.action)=='string'and row.action:upper()or('NATIVE_ACTION_'..i))
+   c.list[i]=key;c.rows[key]=row
+  end
+ end
+ return c.list
+end
+function M.isOpen()return require('src.compat.gen1.NativeModalObservation').find({'src.ui.Gen3PartyMenu'})~=nil end
+local function sync(c)
+ if not c or not c:valid()or not c.screen.submenu then return end
+ local list=actions(c);local rows={}
+ for i,key in ipairs(list or{})do
+  assert(type(key)=='string','invalid party action label')
+  rows[i]=c.rows[key]or{label=key,action='source_field_move',sourceLabel=key,sourceOwner=Call.owner(M,'update')}
+  local texts=c.extras._actionTexts
+  if texts and texts.list==list and texts.texts[i]then
+   local copy={};for k,v in pairs(rows[i])do copy[k]=v end;copy.label=texts.texts[i];rows[i]=copy
+  end
+ end
+ assert(#rows>0,'party action list cannot be empty')
+ c.nativeList=rows;c.screen.submenu=rows
+ c.screen.subIndex=math.max(1,math.min(#rows,c.screen.subIndex or 1))
+end
+function M.update()return Boundary.invoke('party.update')end
+function M.handleInput()return Boundary.invoke('party.input')end
+function M._dispatch(screen,dt,body)
+ local c=observe(screen);if not c then return body()end;actions(c)
+ local result=Boundary.dispatch('party.update',body,function()return Call.call(M,'update',dt)end)
+ sync(c);return result
+end
+function M._input(screen,body)
+ local c=observe(screen);if not c then return body()end;actions(c)
+ return Boundary.dispatch('party.input',function()sync(c);return body()end,function()return Call.call(M,'handleInput',screen.game.input)end)
+end
+function M._fieldAction(screen,mon,row)
+ local c=observe(screen);if not c then return false end
+ local typed=c.mons:view(mon)
+ local result=Call.call(require('src.core.game3.field_moves'),'fromMenu',row.sourceLabel,
+  {mon=typed,session=require('src.core.Game3').forNative(c.game).session})
+ if type(result)=='table'and result.text then screen:say(result.text)end
+ return true
+end
+local service={release=retire,poll=function()if current and not current:valid()then retire()end end,
+ releaseOwner=function(_,who)
+  local c=current;if not c or not c:valid()then retire();return end
+  local list=c.screen.submenu
+  if list then
+   for i=#list,1,-1 do if list[i].action=='source_field_move'and list[i].sourceOwner==who then table.remove(list,i)end end
+   if #list==0 then c.screen.submenu=nil else c.screen.subIndex=math.min(c.screen.subIndex or 1,#list)end
+  end
+  c.nativeList,c.list,c.rows=nil,nil,nil;c.extras={}
+ end}
+require('src.core.game3.asset_stream').register(service)
+M._service=service
+setmetatable(M,{__index=function(_,key)
+ local c=observe();if not c then if key=='open'then return false end;return nil end
+ local s=c.screen
+ if key=='open'then return not s.closed end
+ if key=='mode'then return s.submenu and'action'or'party'end
+ if key=='cursor'then return s.index end
+ if key=='actionCursor'then return s.subIndex or 1 end
+ if key=='ACTIONS'then return actions(c)end
+ if key=='_party'then
+  local party=s:party();for i,m in ipairs(party)do c.party[i]=c.mons:view(m)end
+  for i=#c.party,#party+1,-1 do c.party[i]=nil end;return c.party
+ end
+ if key=='_cursorOptionText'then return function(label)local row=c.rows and c.rows[label];return row and row.label or label end end
+ return c.extras[key]
+end,__newindex=function(t,key,value)
+ if type(value)=='function'and(key=='update'or key=='handleInput')then rawset(t,key,value);return end
+ local c=assert(observe(),'native party menu is not open')
+ if key=='ACTIONS'then assert(type(value)=='table','invalid party actions');actions(c);c.list=value
+ elseif key=='actionCursor'then assert(type(value)=='number'and value%1==0 and value>=1,'invalid party action cursor');c.screen.subIndex=value
+ else c.extras[key]=value end
+end})
+return M
diff --git a/src/ui/game3/pokedex.lua b/src/ui/game3/pokedex.lua
new file mode 100644
index 000000000..ee3ef20d4
--- /dev/null
+++ b/src/ui/game3/pokedex.lua
@@ -0,0 +1,5 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Modal=require('src.compat.gen1.NativeModalObservation')
+local M={}
+function M.isOpen()return Modal.find({'src.ui.Gen3Pokedex','src.ui.Gen3PokedexFRLG','src.ui.Gen3RsPokedex'})~=nil end
+return M
diff --git a/src/ui/game3/presentation.lua b/src/ui/game3/presentation.lua
new file mode 100644
index 000000000..c6a8307cd
--- /dev/null
+++ b/src/ui/game3/presentation.lua
@@ -0,0 +1,3 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- One native presentation owner, shared by the frame compositor and source UI.
+return require('src.render.NativePresentation')
diff --git a/src/ui/game3/region_map.lua b/src/ui/game3/region_map.lua
new file mode 100644
index 000000000..1f01e9c67
--- /dev/null
+++ b/src/ui/game3/region_map.lua
@@ -0,0 +1,12 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Query=require('src.compat.gen1.NativeRegionMap')
+local M={}
+function M.state()return Query.active('frlg')end
+function M.isOpen()return M.state()~=nil end
+function M.inputReady()return M.state()~=nil and Query.ready()end
+function M.currentMapSec()if M.state()then return Query.section()end end
+function M.canFlyToCursor()
+ local s=M.state();return s~=nil and s.mode=='fly'and Query.destination(Query.section())~=nil
+end
+function M.flyBlockedByMapType()return not M.canFlyToCursor()end
+return setmetatable(M,{__index=function(_,key)if key=='mode'then local s=M.state();return s and s.mode end end})
diff --git a/src/ui/game3/rs/menu_cursor.lua b/src/ui/game3/rs/menu_cursor.lua
new file mode 100644
index 000000000..041bcb65f
--- /dev/null
+++ b/src/ui/game3/rs/menu_cursor.lua
@@ -0,0 +1,4 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Public drawing and native battle menus share the same resource owner.
+local Native=require('src.ui.Gen3RsMenuCursor')
+return{draw=Native.draw,segments=Native.segments}
diff --git a/src/ui/game3/rs/move_relearner.lua b/src/ui/game3/rs/move_relearner.lua
new file mode 100644
index 000000000..378cbd1f1
--- /dev/null
+++ b/src/ui/game3/rs/move_relearner.lua
@@ -0,0 +1 @@
+return require('src.ui.game3.move_relearner')
diff --git a/src/ui/game3/rse/move_relearner.lua b/src/ui/game3/rse/move_relearner.lua
new file mode 100644
index 000000000..378cbd1f1
--- /dev/null
+++ b/src/ui/game3/rse/move_relearner.lua
@@ -0,0 +1 @@
+return require('src.ui.game3.move_relearner')
diff --git a/src/ui/game3/rse/pokedex.lua b/src/ui/game3/rse/pokedex.lua
new file mode 100644
index 000000000..f0e051ab0
--- /dev/null
+++ b/src/ui/game3/rse/pokedex.lua
@@ -0,0 +1,99 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Observe the actual Hoenn dex/search owners; no second screen or save model.
+local Native=require('src.compat.gen1.NativeSession')
+local Modal=require('src.compat.gen1.NativeModalObservation')
+local Version=require('src.core.GameVersion')
+local M={}
+local classes={'src.ui.Gen3RsPokedex','src.ui.Gen3Pokedex'}
+local current
+local function hoenn()
+ local v=Version.get();return v=='emerald'or v=='ruby'or v=='sapphire'
+end
+local function screen()
+ if not hoenn()then return end
+ local game=Native.game()
+ if not(game and game.stack and type(game.stack.states)=='table')then return end
+ local state=Modal.find(classes);return state and not state.closed and state or nil
+end
+local function valid(c)
+ local r=c and not c.retired and c.refs
+ if not r or not r[1]or not r[2]or not r[6]then return false end
+ local game,s=r[1],r[2];local G=package.loaded['src.core.Game3']
+ return G and G.native(r[6])==game and Native.game()==game and Version.get()==c.edition
+  and game.data==r[3]and game.save==r[4]and game.mods==r[5]and screen()==s
+  and(not c.rs or type(r[7])=='table'and s.state==r[7])
+end
+local function release()
+ if current then current.retired=true;current.refs=nil;current.view=nil;current.users={}end
+ current=nil
+end
+local function scalarMap(value)
+ if type(value)~='table'then return {}end
+ local out={}
+ for k,v in pairs(value)do
+  if type(k)=='number'and(type(v)=='number'or type(v)=='string'or type(v)=='boolean')then out[k]=v end
+ end
+ return out
+end
+local function scalar(value)
+ local t=type(value);if t=='number'or t=='string'or t=='boolean'then return value end
+end
+local function index(value,max)
+ if type(value)=='number'and value%1==0 and value>=1 and(not max or value<=max)then return value-1 end
+end
+local function search(c)
+ local r=c.refs
+ if c.rs then
+  local q=r[7].searchState;if type(q)~='table'then return end
+  return{phase=scalar(q.phase),topBar=scalar(q.topBar),menuItem=scalar(q.menuItem),message=scalar(q.message),
+   cursor=scalarMap(q.cursor),scroll=scalarMap(q.scroll)}
+ end
+ local s=Modal.find({'src.ui.Gen3DexSearch'})
+ if not s or s.closed then return end
+ local slot=index(s.picking,6)
+ local q={phase=slot~=nil and'param'or s.pane=='topbar'and'topbar'or'menu',
+  topBar=index(s.bar,3),menuItem=index(s.row,7),cursor={},scroll={}}
+ if slot~=nil then
+  local pick=index(s.pick);local top=s.pickTop
+  if pick~=nil and type(top)=='number'and top%1==0 and top>=0 then
+   q.cursor[slot],q.scroll[slot]=pick-top,top
+  end
+ end
+ return q
+end
+function M.active()
+ local s=screen();local game=Native.game()
+ if not s or not game then release();return end
+ if not valid(current)then
+  release()
+  local G=require('src.core.Game3');local view=G.forNative(game)
+  if not view then return end
+  local rs=getmetatable(s)==package.loaded['src.ui.Gen3RsPokedex']
+  if rs and type(s.state)~='table'then return end
+  local c={edition=Version.get(),rs=rs,users={},
+   refs=setmetatable({game,s,game.data,game.save,game.mods,view,s.state},{__mode='v'})}
+  c.view=setmetatable({},{__index=function(_,key)
+   if key=='open'then return valid(c)end
+   if not valid(c)then return end
+   local r=c.refs
+   if key=='edition'then return c.edition end
+   if key=='searchState'then return search(c)end
+   if key=='nationalEnabled'then if c.rs then return scalar(r[7].nationalEnabled)end;return not not r[4].nationalDex end
+   if key=='selected'then if c.rs then return scalar(r[7].selected)end;return index(r[2].index)end
+   if key=='dexMode'then if c.rs then return scalar(r[7].dexMode)end;return index(r[2].dexMode,2)end
+   if c.rs and(key=='fn'or key=='state')then return scalar(r[7][key])end
+  end,__newindex=function()error('native Hoenn dex observations are read-only',2)end})
+  current=c
+ end
+ local host=package.loaded['src.mods.Runtime'];local G=package.loaded['src.core.Game3']
+ local who=host and host.currentMod or G and G._callbackOwner()
+ if who then current.users[who]=true end
+ return current.view
+end
+function M.isOpen()return M.active()~=nil end
+M._service={release=release,poll=function()if current and not valid(current)then release()end end,
+ releaseOwner=function(_,who)
+  if current and current.users[who]then current.users[who]=nil;if not next(current.users)then release()end end
+ end}
+require('src.core.game3.asset_stream').register(M._service)
+return M
diff --git a/src/ui/game3/rse/region_map.lua b/src/ui/game3/rse/region_map.lua
new file mode 100644
index 000000000..23abb3434
--- /dev/null
+++ b/src/ui/game3/rse/region_map.lua
@@ -0,0 +1,17 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Query=require('src.compat.gen1.NativeRegionMap')
+local M={}
+-- Numeric protocol facts; actual RS classification remains with its owner.
+local types={NONE=0,ROUTE=1,CITY_CANFLY=2,CITY_CANTFLY=3,BATTLE_FRONTIER=4}
+M.TYPE=setmetatable({},{__index=types,__newindex=function()error('native region map types are read-only',2)end})
+function M.active()return Query.active('hoenn')end
+function M.isOpen()return M.active()~=nil end
+function M.manifest()return Query.manifest()end
+function M.mapSecType(view,section)return Query.kind(view,section)end
+function M.flyWarpDestination(session,section,pos)
+ local s=M.active();if not s then return end
+ local game=require('src.compat.gen1.NativeSession').game()
+ if session~=require('src.core.Game3').forNative(game).session then return end
+ return Query.destination(section,pos)
+end
+return M
diff --git a/src/ui/game3/start_menu.lua b/src/ui/game3/start_menu.lua
new file mode 100644
index 000000000..96e98aaf1
--- /dev/null
+++ b/src/ui/game3/start_menu.lua
@@ -0,0 +1,102 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- The source menu is the native GBA START state, with its real rows/input.
+local Native=require('src.compat.gen1.NativeSession')
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local Flow=require('src.compat.gen1.UiFlow')
+local Scope=require('src.render.GraphicsScope')
+local M={isMenu=true}
+local flows={}
+local function current()
+ local g=Native.game();local class=package.loaded['src.ui.Gen3StartMenu']
+ if not(g and g.stack and class)then return end
+ for i=#(g.stack.states or{}),1,-1 do
+  local state=g.stack.states[i]
+  if getmetatable(state)==class and state.game==g then return state,g end
+ end
+end
+function M.isOpen()return current()~=nil end
+function M.close()
+ local state=current();if not state then return false end
+ local flow=state.nativeUiFlow;local host=require('src.mods.Runtime')
+ local owner=host.currentMod or require('src.core.Game3')._callbackOwner()
+ if flow and flow.who~=owner then return false,'start menu belongs to another mod'end
+ state:close();if flow then flow:retire()end;return true
+end
+M.cancel=M.close
+function M.show(opts)
+ if opts~=nil and(type(opts)~='table'or getmetatable(opts)~=nil)then return false,'invalid start menu options'end
+ for key,value in pairs(opts or{})do
+  if key~='index'or type(value)~='number'or value%1~=0 or value<1 then return false,'invalid start menu cursor'end
+ end
+ local g,w=Native.resolve();if not g then return false,'no native field menu'end
+ if current()then return false,'native start menu already open'end
+ local ready,why=require('src.world.WorldActions').ready(g,w);if not ready then return false,why end
+ local flow,reason=Flow.new();if not flow then return false,reason end
+ local ok,state=pcall(function()return flow:admit(require('src.ui.Gen3StartMenu').new,g,opts)end)
+ if not ok then flow:retire();error(state,0)end
+ flow:push(state);flows[flow]=true;return state
+end
+-- Layout wrappers read the same live native menu that will be painted.
+local layoutState
+function M.contentTemplate()
+ local state=layoutState or current()
+ return state and state:nativeContentTemplate()or nil
+end
+local nativeTemplate=M.contentTemplate
+local function finite(n)return type(n)=='number'and n==n and math.abs(n)<math.huge and n%1==0 end
+function M._contentTemplate(state)
+ local fallback=state:nativeContentTemplate()
+ if M.contentTemplate==nativeTemplate then return fallback end
+ local prior=layoutState;layoutState=state
+ local ok,value=pcall(Call.call,M,'contentTemplate')
+ layoutState=prior
+ if ok and type(value)=='table'then
+  local l,t,w,h=value.left or value.tilemapLeft,value.top or value.tilemapTop,value.width or value.w,value.height or value.h
+  if finite(l)and finite(t)and finite(w)and finite(h)and l>=0 and t>=0 and w>0 and h>0 and l+w<=30 and t+h<=128 then
+   return{left=l,top=t,width=w,height=h,tilemapLeft=l,tilemapTop=t,w=w,h=h}
+  end
+ end
+ require('src.core.Logger').warn('source START layout unavailable; keeping native content rectangle (%s)',tostring(value))
+ return fallback
+end
+local function update()return Boundary.invoke('start_menu.update')end
+local function draw()return Boundary.invoke('start_menu.draw')end
+M.update,M.draw=update,draw
+function M._update(state,dt,body)
+ if M.update==update then return body(state,dt)end
+ if current()~=state then return body(state,dt)end
+ return Boundary.dispatch('start_menu.update',function()return body(state,dt)end,function()return Call.call(M,'update',dt)end)
+end
+function M._draw(state,body)
+ if M.draw==draw or current()~=state then return body(state)end
+ local ok,why=Scope.call(function()
+  return Boundary.dispatch('start_menu.draw',function()return body(state)end,function()return Call.call(M,'draw')end)
+ end)
+ if not ok then error(why,0)end;return why
+end
+M._service={release=function()
+ for flow in pairs(flows)do flow:retire()end;flows={}
+end,poll=function()
+ for flow in pairs(flows)do
+  local present=false
+  if not flow.retired then
+   for _,state in ipairs(flow.stack.states)do
+    if state.nativeUiFlow==flow then present=true;break end
+   end
+  end
+  if not present then flow:retire();flows[flow]=nil end
+ end
+end}
+require('src.core.game3.asset_stream').register(M._service)
+return setmetatable(M,{__index=function(_,key)
+ local state=current()
+ if key=='open'then return state~=nil end
+ if key=='cursor'then return state and state.index end
+ if key=='_game'then return state and require('src.core.Game3').forNative(state.game)end
+ if key=='ENTRIES'then
+  local out={}
+  for i,row in ipairs(state and state.rows or{})do out[i]={id=row.id or row.key,label=row.label}end
+  return out
+ end
+end})
diff --git a/src/ui/game3/stat_growth.lua b/src/ui/game3/stat_growth.lua
new file mode 100644
index 000000000..9b1989d1f
--- /dev/null
+++ b/src/ui/game3/stat_growth.lua
@@ -0,0 +1,5 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+local Modal=require('src.compat.gen1.NativeModalObservation')
+local M={}
+function M.isOpen()return Modal.find({{'src.battle.BattleState','StatBox'}})~=nil end
+return M
diff --git a/src/ui/game3/summary_chrome.lua b/src/ui/game3/summary_chrome.lua
new file mode 100644
index 000000000..9541d8a52
--- /dev/null
+++ b/src/ui/game3/summary_chrome.lua
@@ -0,0 +1,24 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Read the same imported PP palette as Gen3SummaryLayout. The native summary
+-- controller keeps its art and navigation; this is a detached colour query.
+local M={}
+function M.manifest()
+ local game=require('src.compat.gen1.NativeSession').game()
+ local summary=game and game.data and game.data.constants and game.data.constants.gen3Summary
+ local parts=summary and summary.parts
+ if not(parts and parts.palette and parts.textColors)then
+  return nil,'native summary palette is not present in this cartridge cache'
+ end
+ local rows={}
+ for index=9,12 do
+  local a,b=parts.textColors[index*3+2],parts.textColors[index*3+3]
+  local ink=type(a)=='number'and parts.palette[128+a]
+  local shadow=type(b)=='number'and parts.palette[128+b]
+  if ink and shadow then
+   rows[index]={fg={ink[1]*255,ink[2]*255,ink[3]*255},
+    shadow={shadow[1]*255,shadow[2]*255,shadow[3]*255}}
+  end
+ end
+ return{moveTextColors=rows,native=true}
+end
+return M
diff --git a/src/ui/game3/ui_pass.lua b/src/ui/game3/ui_pass.lua
new file mode 100644
index 000000000..666fac600
--- /dev/null
+++ b/src/ui/game3/ui_pass.lua
@@ -0,0 +1,67 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Borrow the existing native modal drawers; world and battle composition
+-- keep their own passes, surfaces and resource ownership.
+local Boundary=require('src.compat.gen1.ScriptBoundary')
+local Call=require('src.compat.gen1.SourceCall')
+local Scope=require('src.render.GraphicsScope')
+local Version=require('src.core.GameVersion')
+local M={}
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function drawUi()
+ if not Boundary.active('ui.draw')then return false,'UI drawing belongs to its native pass'end
+ return Boundary.invoke('ui.draw')
+end
+M.drawUi=drawUi
+function M._wrapped()return M.drawUi~=drawUi end
+function M._nativeDrawUi(game,paint,...)
+ local presentation=package.loaded['src.render.NativePresentation']
+ if not Version.isGen3()or M.drawUi==drawUi and not(presentation and presentation._active())then return paint(...)end
+ local G=require('src.core.Game3');local view=G.forNative(game)
+ if not view then return paint(...)end
+ local stack=game.stack;local states=stack.states;local sequence={}
+ for i,state in ipairs(states)do sequence[i]=state end
+ local data,save,mods,edition=game.data,game.save,game.mods,Version.get()
+ local args=pack(...)
+ local function admitted()
+  if Version.get()~=edition or game.stack~=stack or stack.states~=states
+   or game.data~=data or game.save~=save or game.mods~=mods or G.native(view)~=game
+   or #states~=#sequence then return false end
+  for i,state in ipairs(sequence)do if states[i]~=state then return false end end
+  return true
+ end
+ local function native()
+  if not admitted()then return false,'native UI pass cohort changed'end
+  return G._withCallbackOwner(nil,paint,unpack(args,1,args.n))
+ end
+ local result=pack(Scope.call(function()
+  return Boundary.dispatch('ui.draw',function()
+   if not admitted()then return false,'native UI pass cohort changed'end
+   if presentation and presentation._active()then
+    return presentation.layer('ui_stack',native,{first=args[1],last=args[2]})
+   end
+   return native()
+  end,function()return Call.call(M,'drawUi')end)
+ end))
+ if not result[1]then error(result[2],0)end
+ return unpack(result,2,result.n)
+end
+function M._nativeStates(game,scene,first,paint)
+ local presentation=package.loaded['src.render.NativePresentation']
+ if not Version.isGen3()or not(M._wrapped()or presentation and presentation._active())then return paint()end
+ local battle=package.loaded['src.core.game3.battle']
+ local nativeBattle=battle and battle._screen()
+ local battleClass=package.loaded['src.battle.BattleState']
+ local begin=first;local last=#scene.states
+ for i=first,last do
+  local state=scene.states[i]
+  if state==game.overworld or state==nativeBattle
+   or state and(state.isOverworld or state.isBattleState)
+   or battleClass and getmetatable(state)==battleClass then
+   if begin<i then M._nativeDrawUi(game,paint,begin,i-1)end
+   paint(i,i);begin=i+1
+  end
+ end
+ if begin<=last then return M._nativeDrawUi(game,paint,begin,last)end
+end
+return M
diff --git a/src/ui/game3/window.lua b/src/ui/game3/window.lua
new file mode 100644
index 000000000..61e480455
--- /dev/null
+++ b/src/ui/game3/window.lua
@@ -0,0 +1,15 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Detached tile rectangles and the native menu's actual label/cursor spacing.
+local W={CURSOR_WIDTH=require('src.ui.Gen3StartMenu').CURSOR_WIDTH}
+function W.cursorPx(x,y,opts)
+ return require('src.ui.game3.frlg_font').drawGlyph(require('src.ui.Theme').cursor,x,y,opts)
+end
+function W.template(left,top,width,height,opts)
+ return{left=left,top=top,width=width,height=height,tilemapLeft=left,tilemapTop=top,
+  w=width,h=height,paletteNum=opts and opts.paletteNum or 15}
+end
+function W.stdFrame(tpl)
+ return require('src.render.Font').drawStandardBox((tpl.left or tpl.tilemapLeft)-1,(tpl.top or tpl.tilemapTop)-1,
+  (tpl.width or tpl.w)+2,(tpl.height or tpl.h)+2)
+end
+return W
diff --git a/src/world/Encounter.lua b/src/world/Encounter.lua
index 1c973b995..d5a86b74a 100644
--- a/src/world/Encounter.lua
+++ b/src/world/Encounter.lua
@@ -338,10 +338,27 @@ local gen4Views = setmetatable({}, { __mode = "k" })
 -- and what shape they arrive in.  Gen 1, 2 and 3 fall through it unchanged:
 -- they have no `map.encounters`, so the id is still `mapId`, and no
 -- `grassRate`, so the table is returned exactly as it was.
+local gen3WildSetVar={firered=0x4024,leafgreen=0x4024,emerald=0x403e}
+-- Alternate GBA wild headers use the live native script variable, not RNG.
+-- Header zero is the base table; an out-of-range script value resets to it.
+function Encounter.gen3Variant(def,save,edition)
+  if not(type(def)=='table'and type(def.alternates)=='table')then return def end
+  local key=gen3WildSetVar[edition]
+  local n=key and save and save.gen3Vars and save.gen3Vars[key]
+  if type(n)=='number'and n%1==0 and n>=1 and n<=#def.alternates then return def.alternates[n]end
+  return def
+end
+
 function Encounter.forMap(data, mapDef, mapId, hour, save)
   local all = data and data.encounters
   if not all then return nil end
   local def = all[(mapDef and mapDef.encounters) or mapId]
+  if data.constants and data.constants.gen3Layout then
+    def=Encounter.gen3Variant(def,save,require('src.core.GameVersion').get())
+    if package.loaded['src.mods.FeatureOptions']then
+      def=require('src.world.EncounterActivity').forMap(data,save,mapDef,mapId,def)
+    end
+  end
   if data.field and data.field.gen2Swarms then
     def=require("src.world.Gen2Swarms").forMap(data,save,mapDef,mapId,def)
   end
@@ -494,4 +511,19 @@ function Encounter.forMap(data, mapDef, mapId, hour, save)
   return view
 end
 
+-- Guaranteed GBA selection used by the native field move and mod callers.
+-- Eligibility remains with the native map; this only consumes its admitted pool.
+function Encounter.sweetScent(data,save,mapDef,mapId,water,eligible,rng)
+  if not eligible then return nil end
+  local def=Encounter.forMap(data,mapDef,mapId,nil,save)
+  local slots=def and def.grass
+  if water then slots=def and def.water end
+  if not slots then return nil end
+  local roam=require('src.world.Gen3Roamers')
+  if roam.check(data,save,mapId,rng)then
+    local enc=roam.encounterFor(data,save)
+    if enc then return enc,'gen3'end
+  end
+  return Encounter.chooseTable(slots,rng)
+end
 return Encounter
diff --git a/src/world/EncounterActivity.lua b/src/world/EncounterActivity.lua
new file mode 100644
index 000000000..d970f4af6
--- /dev/null
+++ b/src/world/EncounterActivity.lua
@@ -0,0 +1,47 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Optional activity preferences move species between existing weighted slots.
+-- No species, level range, water pool or encounter rate is invented.
+local A={}
+local classes={}
+local groups={
+ morning={10,11,12,13,14,15,16,17,18,21,22,165,166,177,178,187,188,189,265,266,267,276,277,278,279,283,284,315},
+ day={23,24,27,28,37,38,46,47,69,70,71,84,85,102,103,114,161,162,179,180,181,191,192,263,264,273,274,275,285,286,309,310,322,323,331,332},
+ night={19,20,41,42,43,44,45,48,49,52,53,92,93,94,163,164,167,168,169,198,200,228,229,261,262,302,353,354,355,356},
+}
+for phase,ids in pairs(groups)do for _,id in ipairs(ids)do classes[id]=phase end end
+function A.phase(time)
+ local n=(tonumber(time)or 300)%1200
+ return n<200 and'morning'or n<650 and'day'or'night'
+end
+function A.reweight(area,phase,national,profiles)
+ if type(area)~='table'or type(area.slots)~='table'or#area.slots==0 then return area end
+ local ranked={}
+ for i,slot in ipairs(area.slots)do
+  local activity=(profiles or classes)[national(slot.species)]
+  local score=activity==phase and 2 or(activity=='night'or phase=='night'and activity~=nil)and 0 or 1
+  ranked[i]={slot=slot,score=score,order=i}
+ end
+ table.sort(ranked,function(a,b)if a.score==b.score then return a.order<b.order end;return a.score>b.score end)
+ local out={};for k,v in pairs(area)do out[k]=v end;out.slots={}
+ for i,r in ipairs(ranked)do
+  local slot={};for k,v in pairs(r.slot)do slot[k]=v end
+  -- The native chooser stores weights on entries, whereas source packs
+  -- assign them by position. Preserve the destination's weight explicitly.
+  slot.chance=area.slots[i].chance;out.slots[i]=slot
+ end
+ return out
+end
+function A.forMap(data,save,mapDef,mapId,source)
+ local service=package.loaded['src.mods.FeatureOptions']
+ local p=service and service.provider('timedEncounters')
+ if not(p and source and source.grass and mapDef and(mapDef.mapType=='ROUTE'or mapDef.mapType=='TOWN'or mapDef.mapType=='CITY'))then return source end
+ local id=mapId
+ local identity=package.loaded['src.compat.gen1.MapIdentity']
+ if identity then id=identity.bind(data.maps,require('src.core.GameVersion').get()):legacyId(mapId)or mapId end
+ if service.call(p,'outdoors',id)~=true then return source end
+ local time=service.call(p,'time');local phase=A.phase(time)
+ local area=A.reweight(source.grass,phase,function(key)local row=data.pokemon[key];return row and row.dex end,
+  data.constants and data.constants.encounterActivity)
+ local out={};for k,v in pairs(source)do out[k]=v end;out.grass=area;return out
+end
+return A
diff --git a/src/world/Gen3FieldMove.lua b/src/world/Gen3FieldMove.lua
index 4d810425a..575f8a4f5 100644
--- a/src/world/Gen3FieldMove.lua
+++ b/src/world/Gen3FieldMove.lua
@@ -25,17 +25,46 @@
 -- (RomExtractorGen3:playerAvatarStates, constants.gen3PlayerSprites).  The
 -- Pokemon's picture is its own front sprite, which the import already rips.
 --
--- RECONSTRUCTED: the BAND.  Emerald's is gFieldMoveStreaksTiles, a tilemap
+-- DEFAULT PRESENTATION: the BAND.  Emerald's is gFieldMoveStreaksTiles, a tilemap
 -- scrolled behind the picture, and the import does not rip it; nothing here
 -- pretends otherwise.  What is drawn instead is the same figure -- a lit band
 -- the height of the cartridge's, streaked with moving lines, sweeping in from
 -- one side and out the other -- in the cartridge's own window colours where
 -- the cache carries them.  The timings below are measured off the scene.
 
+-- Compatible observers may select the independently imported cartridge strips
+-- and presentation program. The native default below remains available.
 local Font = require("src.render.Font")
 
 local Gen3FieldMove = {}
 Gen3FieldMove.__index = Gen3FieldMove
+local Version=require('src.core.GameVersion')
+local Presentation=require('src.world.Gen3FieldMovePresentation')
+local allocations=setmetatable({},{__mode='k'})
+local preparing=setmetatable({},{__mode='k'})
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function release(x)if x and x.release then pcall(x.release,x)end end
+local function source()return Version.isGen3()and package.loaded['src.core.game3.field_move_show_mon']end
+local function nativeWorld(game)
+  local session=Version.isGen3()and package.loaded['src.compat.gen1.NativeSession']
+  if session and session.resolve then
+    local owner,world=session.resolve(game);if owner==game then return world end
+    return nil
+  end
+  return game.overworld
+end
+local function valid(self,top)
+  if self.done then return false end
+  local c=self.cohort;local game=self.game
+  if c and not self:cohortCurrent()then return false end
+  local stack=game.stack;local states=stack and stack.states
+  if type(states)=='table'then
+    local found=false;for _,s in ipairs(states)do if s==self then found=true;break end end
+    if not found or top and states[#states]~=self then return false end
+  end
+  return true
+end
 
 -- RECONSTRUCTED: the beats of the sweep, in frames.
 --
@@ -66,7 +95,7 @@ local BAND_TOP, BAND_HEIGHT = 52, 56
 local STREAKS = 11
 
 function Gen3FieldMove:uiSize()
-  return require("src.ui.Theme").uiSize()
+  return 240,160
 end
 
 -- The two colours the band is drawn in.  The cartridge's own window palette
@@ -84,39 +113,76 @@ local function bandColours(game)
   return shade, ink
 end
 
-local function frontSprite(game, mon)
+local function frontPath(game, mon)
   if not (mon and mon.species) then return nil end
   local ok, path = pcall(function()
     return require("src.pokemon.Sprites").path(
       game.data, mon.species, "front", { mon = mon })
   end)
   if not (ok and type(path) == "string") then return nil end
-  local okImg, img = pcall(love.graphics.newImage, path)
-  return okImg and img or nil
+  return require('src.render.Assets').resolve(path)
+end
+local function frontSprite(game,mon)
+  local path=frontPath(game,mon);if not path then return nil end
+  local ok,img=pcall(love.graphics.newImage,path)
+  return ok and img or nil,path
 end
 
 -- Push the sweep over whatever is on screen and call `onDone` when it has
 -- passed.  Returns false when there is nothing to show -- no Pokemon, or a
 -- dataset with no picture for it -- so the caller can simply get on with the
 -- move rather than waiting on a state that would draw nothing.
-function Gen3FieldMove.show(game, mon, onDone)
-  if not (game and game.stack) then return false end
-  local sprite = frontSprite(game, mon)
+local function create(game, mon, onDone, opts)
+  if not(game and game.stack and game.stack.push)or(onDone~=nil and type(onDone)~='function')then return false end
+  for _,state in ipairs(game.stack.states or{})do if getmetatable(state)==Gen3FieldMove and not state.done then return false,'native field move is busy'end end
+  local world=nativeWorld(game)
+  if Version.isGen3()and not world then return false,'no admitted native field world'end
+  local cohort=setmetatable({data=game.data,save=game.save,mods=game.mods,stack=game.stack,edition=Version.get(),world=world,actor=world and world.player,map=world and world.map},{__mode='v'})
+  local facade=source()
+  opts=opts or(facade and facade._nativeOptions and facade._nativeOptions(game))or{}
+  local sprite,path = frontSprite(game, mon)
   if not sprite then return false end
   local self = setmetatable({}, Gen3FieldMove)
   self.game = game
   self.mon = mon
-  self.sprite = sprite
-  self.onDone = onDone
+  self.sprite = sprite;self.spritePath=path
   self.t = 0
+  self.frame=0;self.options=opts
   self.phase = "raise"
   self.shade, self.ink = bandColours(game)
   -- THE POSE GOES ON HERE and comes off in finish(), so it is on screen for
   -- exactly as long as the window is -- which is what the cartridge does.
-  local player = game.overworld and game.overworld.player
-  if player then
-    self.player = player
+  local player = world and world.player
+  self.actor=player
+  self.cohort=cohort
+  if not self:cohortCurrent()then release(sprite);return false,'native field move preparation cohort retired'end
+  self.sourceOwned=opts.sourceStarted==true or opts.sourceOwned==true;self.sourceOwner=opts.sourceOwner
+  local callback=onDone;local outcome,err,running
+  self.discardContinuation=function()callback=nil;outcome=nil;err=nil end
+  self.onDone=function()
+    if self.cancelled or not self:cohortCurrent()then return false,'native field move admission retired'end
+    if err then error(err,0)end
+    if outcome then return unpack(outcome,1,outcome.n)end
+    if running or not(self.completed and self.callbackReady)then return false,'native field move has not completed'end
+    running=true;local fn=callback;callback=nil
+    local values=pack(pcall(function()if fn then return fn()end end));fn=nil
+    if not values[1]then err=values[2];error(err,0)end
+    outcome={n=values.n-1};for i=2,values.n do outcome[i-1]=values[i]end
+    return unpack(outcome,1,outcome.n)
+  end
+  allocations[self]={front=sprite}
+  if opts.presentation=='cartridge'then
+    self.effect=Presentation.new(mon,opts,game,world)
+    local ok,why=self:reloadArtwork()
+    if not ok then self:exit();return false,why end
+  end
+  if player and(not self.effect and opts.pose~=false or self.effect and self.effect.posed)then
+    self.player=player
     self.hadPose = player.fieldMove
+    self.hadPoseFrame=player.fieldMovePose
+    self.hadPoseOwner=player._gen3FieldMovePoseOwner
+    player._gen3FieldMovePoseOwner=self
+    self.poseInstalled=true
     player.fieldMove = true
     -- the pose's own frame counter.  It lives here rather than on the player
     -- because the overworld does not update while this state is on top, so
@@ -124,29 +190,138 @@ function Gen3FieldMove.show(game, mon, onDone)
     self.age = 0
     player.fieldMovePose = 0
   end
-  game.stack:push(self)
+  local ok,why=pcall(game.stack.push,game.stack,self)
+  if not ok then
+    local stack=cohort.stack
+    if stack and stack.removeAll then stack:removeAll({self})else self:exit()end
+    return false,why
+  end
+  if self.entryRejected then self:retire();return false,'native field move start vetoed'end
+  return true,self
+end
+function Gen3FieldMove.show(game,mon,onDone,opts)
+  if type(game)~='table'or preparing[game]then return false,'native field move preparation is busy'end
+  preparing[game]=true
+  local result=pack(pcall(create,game,mon,onDone,opts));preparing[game]=nil
+  if not result[1]then error(result[2],0)end
+  return unpack(result,2,result.n)
+end
+function Gen3FieldMove:cohortCurrent()
+  local c=self.cohort;local game=self.game
+  return c and game.data==c.data and game.save==c.save and game.mods==c.mods and game.stack==c.stack
+    and Version.get()==c.edition and nativeWorld(game)==c.world
+    and(not c.world or c.world.player==c.actor and c.world.map==c.map)
+end
+function Gen3FieldMove:configurePresentation(opts)
+  if self.frame~=0 then return false,'field move options belong to admission'end
+  local player=self.actor
+  local posed=opts.pose==true
+  if self.poseInstalled and not posed and player._gen3FieldMovePoseOwner==self then
+    player.fieldMove,player.fieldMovePose,player._gen3FieldMovePoseOwner=self.hadPose,self.hadPoseFrame,self.hadPoseOwner
+    self.poseInstalled=false;self.player=nil
+  elseif posed and not self.poseInstalled and player then
+    self.player=player
+    self.hadPose,self.hadPoseFrame,self.hadPoseOwner=player.fieldMove,player.fieldMovePose,player._gen3FieldMovePoseOwner
+    player.fieldMove,player.fieldMovePose,player._gen3FieldMovePoseOwner=true,0,self;self.poseInstalled=true
+  end
+  if self.effect then
+    self.effect.posed=posed;self.effect.phase=posed and'pose'or 1;self.effect.poseWait=24
+    self.effect.noDuck=opts.noDuck==true
+  end
   return true
 end
 
-function Gen3FieldMove:finish()
-  if self.done then return end
-  self.done = true
-  if self.player then
-    self.player.fieldMove = self.hadPose
-    self.player.fieldMovePose = nil
+function Gen3FieldMove:configure(mon,opts,callback)
+  if not valid(self,true)or self.frame~=0 then return false,'native field move start phase retired'end
+  if type(mon)~='table'or type(opts)~='table'or(callback~=nil and type(callback)~='function')then return false,'invalid field move options'end
+  local path=frontPath(self.game,mon);if not path then return false,'native field move picture unavailable'end
+  if path~=self.spritePath then
+    local sprite=frontSprite(self.game,mon);if not sprite then return false,'native field move picture unavailable'end
+    if not valid(self,true)then release(sprite);return false,'native field move admission retired'end
+    local own=allocations[self];release(own.front);own.front=sprite;self.sprite=sprite;self.spritePath=path
+  end
+  self.mon=mon;if self.effect then self.effect.species,self.effect.personality=mon.species,mon.personality end
+  local ok,why=self:configurePresentation(opts);if not ok then return false,why end
+  self.onDone=callback;return true
+end
+function Gen3FieldMove:reloadArtwork()
+  if not self.effect then return true end
+  local parts={}
+  local ok,result=pcall(function()
+    local bytes,why=Presentation.rgba(self.game,self.effect.outdoors and'outdoors'or'indoors');assert(bytes,why)
+    local data=love.image.newImageData(256,80,'rgba8',bytes);parts[#parts+1]=data
+    local image=love.graphics.newImage(data);parts[#parts+1]=image;image:setFilter('nearest','nearest')
+    local q=love.graphics.newQuad(0,0,1,1,256,80);parts[#parts+1]=q
+    local c=self.cohort
+    assert(self.game.data==c.data and self.game.save==c.save and self.game.mods==c.mods and Version.get()==c.edition,'field move artwork cohort retired')
+    return{band=image,quad=q,parts=parts}
+  end)
+  if not ok then for _,x in ipairs(parts)do release(x)end;return false,tostring(result)end
+  local own=allocations[self]
+  if own.presentation then for _,x in ipairs(own.presentation.parts)do release(x)end end
+  own.presentation=result;return true
+end
+function Gen3FieldMove:enter()
+  local facade=source();if facade and facade._nativeStart then
+    local result=facade._nativeStart(self);if result==false then self.entryRejected=true end;return result
+  end
+end
+function Gen3FieldMove:exit()
+  self.onDone=nil
+  if not self.completed and self.discardContinuation then self.discardContinuation()end
+  local own=allocations[self];allocations[self]=nil
+  if self.poseInstalled and self.player and self.player._gen3FieldMovePoseOwner==self then
+    self.player.fieldMove=self.hadPose;self.player.fieldMovePose=self.hadPoseFrame
+    self.player._gen3FieldMovePoseOwner=self.hadPoseOwner
   end
-  if self.game.stack then self.game.stack:pop() end
-  if self.onDone then self.onDone() end
+  self.poseInstalled=false;self.sprite=nil
+  if own then
+    release(own.front)
+    if own.presentation then for _,x in ipairs(own.presentation.parts)do release(x)end end
+  end
+  local facade=source();if facade and facade._nativeExit then facade._nativeExit(self)end
+end
+function Gen3FieldMove:retire()
+  self.done=true;self.cancelled=true;self.completed=false;self.onDone=nil
+  if self.discardContinuation then self.discardContinuation()end
+  local stack=self.cohort and self.cohort.stack
+  if stack and stack.removeAll then stack:removeAll({self})end
+  self:exit()
+end
+function Gen3FieldMove:complete(completed)
+  if not valid(self,true)then return false,'native field move is covered, retired or finished'end
+  self.done = true
+  self.completed=completed==true;self.cancelled=not self.completed
+  local callback=self.onDone;self.onDone=nil
+  local ok,why=true
+  if self.game.stack then ok,why=pcall(self.game.stack.pop,self.game.stack)end
+  self:exit()
+  self.callbackReady=true
+  if completed and callback then callback()end
+  if not ok then error(why,0)end
+  return true
+end
+function Gen3FieldMove:finish()
+  return self:complete(true)
 end
 
-function Gen3FieldMove:update()
+function Gen3FieldMove:updateBody()
+  if not valid(self,true)then return false end
+  self.frame=self.frame+1
   self.t = self.t + 1
-  if self.player then
+  if self.poseInstalled and self.player._gen3FieldMovePoseOwner==self then
     self.age = (self.age or 0) + 1
     -- drawPose clamps, so this simply counts upward and the pose settles on
     -- its last frame -- the ball held up -- and stays there
     self.player.fieldMovePose = math.floor(self.age / POSE_STEP)
   end
+  if self.effect then
+    local done=Presentation.advance(self.effect,function()
+      require('src.core.Sound').playCry(self.game.data,self.mon.species,self.effect.noDuck and{noDuck=true,volume=125}or nil)
+    end)
+    if done then return self:finish()end
+    return
+  end
   if self.phase == "raise" and self.t >= RAISE_FRAMES then
     self.phase, self.t = "in", 0
   elseif self.phase == "in" and self.t >= IN_FRAMES then
@@ -157,6 +332,13 @@ function Gen3FieldMove:update()
     self:finish()
   end
 end
+function Gen3FieldMove:update()
+  if not valid(self,false)then if not self.done then self:retire()end;return false end
+  if not valid(self,true)then return false end
+  local facade=source()
+  if facade and facade._nativeStep then return facade._nativeStep(self,function()return self:updateBody()end)end
+  return self:updateBody()
+end
 
 -- A cutscene swallows the pad: pressing A during the sweep must not reach the
 -- map underneath and start something else.
@@ -176,7 +358,13 @@ function Gen3FieldMove:offset(width)
   return 0
 end
 
-function Gen3FieldMove:draw()
+function Gen3FieldMove:drawBody()
+  if not valid(self,false)then return false end
+  if self.effect then
+    local own=allocations[self]
+    if own and own.presentation then return Presentation.draw(self.effect,own.presentation,self.sprite or own.front)end
+    return false
+  end
   -- nothing at all while the ball goes up: see RAISE_FRAMES
   if self.phase == "raise" then return end
   local w = select(1, self:uiSize())
@@ -189,8 +377,7 @@ function Gen3FieldMove:draw()
   -- ...and the streaks running through it, which are what make it read as a
   -- sweep rather than a bar
   g.setColor(self.ink[1], self.ink[2], self.ink[3], 0.35)
-  local frame = (self.frame or 0)
-  self.frame = frame + 1
+  local frame=self.frame
   for i = 1, STREAKS do
     local y = BAND_TOP + 3 + (i - 1) * math.floor((BAND_HEIGHT - 6) / STREAKS)
     local len = 40 + (i * 37) % 90
@@ -223,5 +410,21 @@ function Gen3FieldMove:draw()
   end
   g.setColor(1, 1, 1, 1)
 end
+function Gen3FieldMove:draw()
+  if not valid(self,false)then return false end
+  local renderer=package.loaded['src.render.Renderer']
+  if self.externalDrawSerial and renderer and self.externalDrawSerial==renderer.frameSerial then return true end
+  local facade=source()
+  if facade and facade._nativeDraw then return facade._nativeDraw(self,function()return self:drawBody()end)end
+  return self:drawBody()
+end
+Gen3FieldMove.valid=valid
+Gen3FieldMove.present=function(self)return valid(self,false)end
+Gen3FieldMove.cancel=Gen3FieldMove.retire
+function Gen3FieldMove:drawExternal()
+  local result=self:drawBody()
+  local renderer=package.loaded['src.render.Renderer'];self.externalDrawSerial=renderer and renderer.frameSerial
+  return result
+end
 
 return Gen3FieldMove
diff --git a/src/world/Gen3FieldMovePresentation.lua b/src/world/Gen3FieldMovePresentation.lua
new file mode 100644
index 000000000..d9667a8b7
--- /dev/null
+++ b/src/world/Gen3FieldMovePresentation.lua
@@ -0,0 +1,102 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- An optional cartridge presentation on the native field-move state. The
+-- StateStack owns its updates; rendering never advances these observations.
+local Art=require('src.import.Gen3FieldMoveArt')
+local M={}
+local OUTDOORS={TOWN=true,CITY=true,ROUTE=true,UNDERWATER=true,OCEAN_ROUTE=true,[1]=true,[2]=true,[3]=true,[5]=true,[6]=true}
+function M.outdoors(game,world)
+  world=world or game.overworld
+  local map=world and world.map
+  return OUTDOORS[map and map.def and map.def.mapType]==true
+end
+function M.new(mon,opts,game,world)
+  return{species=mon.species,personality=mon.personality,noDuck=opts.noDuck==true,
+    outdoors=M.outdoors(game,world),phase=opts.pose and'pose'or 1,posed=opts.pose==true,
+    poseWait=24,hofs=0,winL=240,winT=80,winB=81,revealed=0,cleared=0}
+end
+function M.advance(fx,cry)
+  if fx.phase=='pose'then
+    fx.poseWait=fx.poseWait-1
+    if fx.poseWait>0 then return false end
+    fx.phase=1
+  end
+  local phase=fx.phase
+  if phase<3 then fx.phase=phase+1
+  elseif phase==7 then return true
+  else
+    -- Every active band phase scrolls except the outdoor hide frame.
+    if not(fx.outdoors and phase==6)then fx.hofs=fx.hofs-16 end
+    if phase==3 then
+      local ready
+      if fx.outdoors then
+        fx.winL=math.max(0,fx.winL-16);fx.winT=math.max(40,fx.winT-2);fx.winB=math.min(120,fx.winB+2)
+        ready=fx.winL==0 and fx.winT==40 and fx.winB==120
+      else
+        ready=fx.revealed>=16
+        if not ready then fx.revealed=fx.revealed+1 end
+      end
+      if ready then fx.sprite={x=320,y=80,state='on'};fx.phase=4 end
+    elseif phase==4 then
+      if fx.sprite and fx.sprite.done then fx.phase=5 end
+    elseif phase==5 then
+      if fx.outdoors then
+        fx.winT=math.min(80,fx.winT+6);fx.winB=math.max(81,fx.winB-6)
+        if fx.winT==80 and fx.winB==81 then fx.phase=6 end
+      else fx.phase=6 end
+    elseif phase==6 then
+      if fx.outdoors then fx.hidden=true;fx.phase=7
+      elseif fx.cleared>=16 then fx.phase=7 else fx.cleared=fx.cleared+1 end
+    end
+  end
+  local s=fx.sprite
+  if s and not s.done then
+    if s.state=='on'then
+      s.x=s.x-20
+      if s.x<=120 then s.x=120;s.wait=30;s.state='wait';if cry then cry()end end
+    elseif s.state=='wait'then s.wait=s.wait-1;if s.wait==0 then s.state='off'end
+    elseif s.x < -64 then s.done=true else s.x=s.x-20 end
+  end
+  return false
+end
+function M.rgba(game,kind)
+  local facade=package.loaded['src.core.game3.field_effects']
+  local cache=require('src.compat.gen1.NativeSession').game()==game and facade and facade._cache
+  if cache then
+    local extract=package.loaded['src.import.gba.extract_island1']
+    local path=((extract and extract.CACHE_ROOT)or'data/generated/gba')..'/field_effects/field_move_streaks_'..kind..'.rgba'
+    local bytes=cache:read(path)
+    if bytes~=nil then assert(type(bytes)=='string'and#bytes==256*80*4,'invalid field move streak payload');return bytes end
+    return nil,'installed field move streak artwork is unavailable'
+  end
+  local record=game.data.constants and game.data.constants.gen3FieldMovePresentation
+  local Version=require('src.core.GameVersion');local edition=Version.get()
+  if not(record and record.schema==Art.SCHEMA and record.edition==edition
+      and Version.acceptsSha1(edition,record.romSha1)and record.strips and record.strips[kind])then
+    return nil,'native field move artwork requires a current import'
+  end
+  return Art.rgba(record.strips[kind])
+end
+function M.draw(fx,resources,front)
+  if fx.phase=='pose'then return end
+  local g=love.graphics;g.setColor(1,1,1,1)
+  local x0,x1,y0,y1
+  if fx.outdoors then
+    if not fx.hidden and fx.phase>=3 then x0,x1,y0,y1=fx.winL,240,math.max(fx.winT,40),math.min(fx.winB,120)end
+  elseif fx.phase>=3 and fx.phase<=5 then
+    local revealing=fx.phase==3 and fx.revealed<16
+    x0,x1,y0,y1=revealing and 16 or 0,revealing and math.min(240,16*(fx.revealed+1))or 240,40,120
+  elseif fx.phase==6 then x0,x1,y0,y1=math.min(240,16*fx.cleared),240,40,120 end
+  if x0 and x1>x0 and y1>y0 then
+    local x=x0
+    while x<x1 do
+      local u=(x+fx.hofs)%256;local width=math.min(x1-x,256-u)
+      resources.quad:setViewport(u,y0-40,width,y1-y0,256,80)
+      g.draw(resources.band,resources.quad,x,y0);x=x+width
+    end
+  end
+  local s=fx.sprite
+  if s and not s.done then
+    local w,h=front:getDimensions();g.draw(front,math.floor(s.x-w/2),math.floor(s.y-h/2))
+  end
+end
+return M
diff --git a/src/world/Gen3FlyArrival.lua b/src/world/Gen3FlyArrival.lua
new file mode 100644
index 000000000..950b7b5de
--- /dev/null
+++ b/src/world/Gen3FlyArrival.lua
@@ -0,0 +1,106 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- A deferred start of the actual native arrival, under its existing cover.
+-- The Transition keeps the body; weak service slots cannot retain an old world.
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Source=require('src.compat.gen1.SourceCall')
+local M={}
+local current
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+local function nativeValid(c)
+ local r=c and c.refs;if not(r and r.game and r.world and r.state)then return false end
+ local class=package.loaded['src.render.Transition'];if not class then return false end
+ local game,world,player=Native.resolve()
+ if c.sourceCaptured then
+  local G=package.loaded['src.core.Game3']
+  if not(G and r.view and G.native(r.view)==game)then return false end
+ end
+ if game~=r.game or world~=r.world or player~=r.player or world.map~=r.map
+  or game.data~=r.data or game.save~=r.save or game.mods~=r.loader or game.stack~=r.stack
+  or world.transitioning~=true or world.warpArrivalKind~='fly'
+  or Version.get()~=c.edition or r.state.game~=game or r.state.phase~='in'
+  or getmetatable(r.state)~=class then return false end
+ for _,state in ipairs(game.stack.states or{})do if state==r.state then return true end end
+ return false
+end
+local function ownerValid(c)
+ local r=c.refs;local loader=r and r.loader
+ local mod=loader and loader.mods and loader.mods[c.who]
+ local effects=package.loaded['src.core.game3.field_effects']
+ return c.who~=nil and mod~=nil and mod==r.mod and mod.enabled~=false and not mod.failed
+  and effects and effects.startFlyIn==r.wrapper
+end
+local function clear(c)
+ local state=c.refs and c.refs.state
+ if state and state.nativeFlyArrivalHold==c then state.nativeFlyArrivalHold=nil;state.nativeFlyArrivalBody=nil end
+ c.refs=nil
+ if current==c then current=nil end
+end
+local function complete(c)
+ if c.failure then error(c.failure,0)end
+ if c.done then return unpack(c.result,1,c.result.n)end
+ local state=assert(c.refs.state)
+ local body=assert(state.nativeFlyArrivalBody,'native arrival body retired')
+ -- Consume before calling: even a caught native exception cannot retry it.
+ c.done=true;state.nativeFlyArrivalHold=nil;state.nativeFlyArrivalBody=nil
+ local result=pack(pcall(body))
+ if not result[1]then c.failure=result[2];error(c.failure,0)end
+ c.result={n=result.n-1};for i=2,result.n do c.result[i-1]=result[i]end
+ return unpack(c.result,1,c.result.n)
+end
+function M.resume()
+ local c=current
+ if not nativeValid(c)then if c then clear(c)end;return nil,'no pending native fly arrival'end
+ local G=package.loaded['src.core.Game3'];local host=package.loaded['src.mods.Runtime']
+ local who=host and host.currentMod or G and G._callbackOwner()
+ if not c.dispatching and(not ownerValid(c)or who~=c.who)then return nil,'native fly arrival belongs to its source owner'end
+ return complete(c)
+end
+function M.landing()
+ local c=current
+ return c~=nil and not c.done and nativeValid(c)and(c.dispatching or ownerValid(c))or false
+end
+function M.begin(game,world,state,effects,body)
+ local c={edition=Version.get(),who=Source.owner(effects,'startFlyIn'),dispatching=true,
+  refs=setmetatable({game=game,world=world,player=world.player,map=world.map,data=game.data,
+   save=game.save,loader=game.mods,stack=game.stack,state=state,wrapper=effects.startFlyIn},{__mode='v'})}
+ if not nativeValid(c)then return body()end
+ c.refs.view=require('src.core.Game3').forNative(game);c.sourceCaptured=true
+ M.poll()
+ assert(not current or current.done,'native fly arrival already pending')
+ if current then clear(current)end
+ local loader=game.mods;c.refs.mod=c.who and loader and loader.mods and loader.mods[c.who]
+ current=c;state.nativeFlyArrivalHold=c;state.nativeFlyArrivalBody=body
+ local result=pack(pcall(Source.call,effects,'startFlyIn'))
+ c.dispatching=false
+ if c.failure then error(c.failure,0)end
+ if not result[1]then clear(c);error(result[2],0)end
+ if current~=c or not nativeValid(c)then
+  if current==c then clear(c)end
+  return unpack(result,2,result.n)
+ end
+ -- Anonymous/retired decorators may observe a start, but cannot hold one.
+ if not c.done and not ownerValid(c)then return complete(c)end
+ return unpack(result,2,result.n)
+end
+function M.poll()
+ local c=current;if not c then return end
+ if not nativeValid(c)then return clear(c)end
+ if c.done then return clear(c)end
+ if not ownerValid(c)and not c.dispatching then return complete(c)end
+end
+function M.retireState(state)
+ if current and current.refs and current.refs.state==state then clear(current)end
+end
+function M.release()if current then clear(current)end end
+function M.releaseOwner(_,who)
+ local c=current
+ if c and c.who==who then
+  if not c.done and nativeValid(c)then complete(c)end
+  clear(c)
+ end
+end
+M.update=M.poll
+require('src.core.game3.asset_stream').register(M)
+return M
diff --git a/src/world/Gen3FlyTargets.lua b/src/world/Gen3FlyTargets.lua
new file mode 100644
index 000000000..5aa1fcb39
--- /dev/null
+++ b/src/world/Gen3FlyTargets.lua
@@ -0,0 +1,32 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- The region picker and read-only consumers share its native visited targets.
+local Identity=require('src.core.MapIdentity')
+local M={}
+function M.bySection(game)
+ local data,save=game.data or{},game.save or{}
+ local field=data.field or{};local out={}
+ for _,id in ipairs(field.flyOrder or{})do
+  local def=(data.maps or{})[id];local sec=def and tonumber(def.regionMapSection)
+  if sec and(save.visited or{})[id]and(field.flyWarps or{})[id]and not out[sec]then out[sec]=id end
+ end
+ return out
+end
+function M.spot(game,id)
+ local spot=Identity.lookup(game.data,(game.data.field or{}).flyWarps,id)
+ if type(spot)=='table'then return spot end
+end
+function M.detached(game,id,spot)
+ local maps=game.data and game.data.maps
+ if type(id)~='string'or not(maps and maps[id])or type(spot)~='table'then return end
+ for _,v in ipairs{spot.x,spot.y}do
+  if type(v)~='number'or v~=v or v%1~=0 or v<0 or v==math.huge then return end
+ end
+ if spot.x==nil or spot.y==nil then return end
+ return{map=require('src.core.Gen3MapNames').canonicalId(game.data,id),x=spot.x,y=spot.y}
+end
+function M.destination(game,section,targets)
+ if type(section)~='number'or section%1~=0 or section<0 then return end
+ local id=(targets or M.bySection(game))[section]
+ if id then return M.detached(game,id,M.spot(game,id))end
+end
+return M
diff --git a/src/world/Gen3HealingPresentation.lua b/src/world/Gen3HealingPresentation.lua
new file mode 100644
index 000000000..d98289a16
--- /dev/null
+++ b/src/world/Gen3HealingPresentation.lua
@@ -0,0 +1,38 @@
+-- Copyright (c) 2026 Cedric. All rights reserved.
+-- Source-available under the Gen2Recomped License (see LICENSE.md): you may
+-- read, build and privately modify this file; you may not redistribute it or
+-- use it commercially. Cartridge-derived data is excluded and is not the
+-- copyright holder's to license.
+
+-- Native healing sprite selection extracted from OverworldController;
+-- shared read-only projection by Roxas2712 (LICENSE-ROXAS2712.md).
+local Assets=require('src.render.Assets')
+local M={}
+function M.snapshot(game,world,ha)
+ if not require('src.core.GameVersion').isGen3()or not ha then return nil end
+ local record=game.data.constants and game.data.constants.gen3HealMachine
+ if not(record and record.monitor and record.glow)then return nil end
+ world.gen3HealArt=world.gen3HealArt or{}
+ local art=world.gen3HealArt
+ local function picture(path)
+  if art[path]==nil then
+   local ok,img=pcall(Assets.image,path);art[path]=ok and img or false
+  end
+  return art[path]or nil
+ end
+ local out={}
+ local frames=record.monitor.images or{}
+ local frame=frames[ha.visible==false and 2 or 1]or frames[1]
+ local monitor=frame and picture(frame)
+ if monitor then out[#out+1]={kind='monitor',image=monitor,x=ha.px+record.monitor.x,y=ha.py+record.monitor.y}end
+ local glow=record.glow.image and picture(record.glow.image)
+ if glow then
+  -- Keep the native cartridge offsets, scale and colour, in native order.
+  for i=1,math.min(ha.lit or 0,#(record.glow.offsets or{}))do
+   local at=record.glow.offsets[i]
+   out[#out+1]={kind='ball',image=glow,x=ha.px+record.glow.x+at[1],y=ha.py+record.glow.y+at[2]}
+  end
+ end
+ return out
+end
+return M
diff --git a/src/world/Gen3MapPreviewFRLG.lua b/src/world/Gen3MapPreviewFRLG.lua
index 669bf9e23..322ac01c5 100644
--- a/src/world/Gen3MapPreviewFRLG.lua
+++ b/src/world/Gen3MapPreviewFRLG.lua
@@ -30,7 +30,7 @@ function Preview.new(game, section, name, onDone)
   local ok, img = pcall(require("src.render.Assets").image, rec.image)
   if not (ok and img) then return nil end
   return setmetatable({
-    game = game, image = img, name = name or "", onDone = onDone,
+    game = game, section = section, image = img, name = name or "", onDone = onDone,
     hold = seen and 40 or 120, t = 0, phase = "in",
   }, Preview)
 end
diff --git a/src/world/Gen3WeatherAudio.lua b/src/world/Gen3WeatherAudio.lua
new file mode 100644
index 000000000..1d0be2d86
--- /dev/null
+++ b/src/world/Gen3WeatherAudio.lua
@@ -0,0 +1,46 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Follow the existing native field weather and its own frame counter. No
+-- gameplay RNG, additional weather state machine or save writes are needed.
+local Sound=require('src.core.Sound')
+local Native=require('src.compat.gen1.NativeSession')
+local Version=require('src.core.GameVersion')
+local Weather=require('src.world.Gen3Weather')
+local Host=require('src.mods.Runtime')
+local A={}
+local current
+local sounds={RAIN='SE_RAIN',RAIN_THUNDERSTORM='SE_THUNDERSTORM',DOWNPOUR='SE_DOWNPOUR'}
+local function stop()
+ local c=current;current=nil
+ if c and(type(c.source)=='userdata'or type(c.source)=='table')and c.source.stop then pcall(c.source.stop,c.source)end
+ return c
+end
+local function valid(c)
+ local g,w=Native.resolve()
+ return g==c.game and w==c.world and g.save==c.save and g.data==c.data
+  and Version.get()==c.edition and not w.battleActive
+end
+local function sameHooks(c,chain)
+ if c.hooks~=Host.hooks or #c.chain~=#chain then return false end
+ for i,entry in ipairs(chain)do if c.chain[i]~=entry then return false end end
+ return true
+end
+function A.update(game,world)
+ if not Version.isGen3()then return end
+ local native,live=Native.resolve(game)
+ if native~=game or live~=world or not game.save or world.battleActive then stop();return end
+ if current and not valid(current)then stop()end
+ local name=world:fieldWeather()
+ local resolved=name and Weather.resolve(name,world.weatherFrame or 0,game.save.gen3WeatherStage or 0)
+ local wanted=sounds[resolved]
+ local chain=Host.hooks.chains and Host.hooks.chains['field.weather.sound']or{}
+ if current and current.name==wanted and sameHooks(current,chain)then return end
+ local previous=stop()
+ if previous and previous.name then Sound.playWeatherEffect(game.data,previous.name..'_STOP',false)end
+ if not wanted then return end
+ local source=Sound.playWeatherEffect(game.data,wanted,true)
+ local copied={};for i,entry in ipairs(chain)do copied[i]=entry end
+ current={game=game,world=world,save=game.save,data=game.data,edition=Version.get(),name=wanted,source=source,hooks=Host.hooks,chain=copied}
+end
+A._service={release=stop,poll=function()if current and not valid(current)then stop()end end}
+require('src.core.game3.asset_stream').register(A._service)
+return A
diff --git a/src/world/Ledge.lua b/src/world/Ledge.lua
new file mode 100644
index 000000000..44ea4fad6
--- /dev/null
+++ b/src/world/Ledge.lua
@@ -0,0 +1,37 @@
+-- Copyright (c) 2026 Cedric. All rights reserved.
+-- Source-available under the Gen2Recomped License (see LICENSE.md): you may
+-- read, build and privately modify this file; you may not redistribute it or
+-- use it commercially. Cartridge-derived data is excluded and is not the
+-- copyright holder's to license.
+-- Native classification extracted from OverworldController; original notices retained.
+
+-- Shared native ledge approach classification. No movement or collision hooks.
+-- Existing dataset overrides win, including the later-edition jump distances.
+local M={}
+local directions={north='up',south='down',west='left',east='right',
+  up='up',down='down',left='left',right='right'}
+local gba={[0x38]='right',[0x39]='left',[0x3a]='up',[0x3b]='down',
+  [0x3c]='up',[0x3d]='up',[0x3e]='down',[0x3f]='down'}
+local bw={[0x72]='right',[0x73]='left',[0x74]='up',[0x75]='down'}
+function M.approach(map,data,x,y,dir)
+  local delta=require('src.world.Collision').DELTA[dir]
+  if not(map and delta)then return true end
+  local fx,fy=x+delta[1],y+delta[2]
+  if not map:inBounds(fx,fy)then return true end
+  local ts=map.tileset
+  local rules=ts and ts.ledgeBehaviours or data and data.field and data.field.ledgeBehaviours
+  if map.def and map.def.gen5 then rules=bw end
+  if not rules and ts and tonumber(ts.blockTiles)==2 and tonumber(ts.blockCells)==1 and ts.collision then
+    rules=gba
+  end
+  if not rules then return false end -- older pair/standing-cell rules remain native
+  local behavior=map:cellBehaviour(fx,fy)
+  if behavior and directions[rules[behavior]]==dir then
+    if map.def and map.def.generation==4 and behavior>=0x5a and behavior<=0x5d then
+      return true,fx,fy,3,true
+    end
+    return true,fx,fy
+  end
+  return true
+end
+return M
diff --git a/src/world/Map.lua b/src/world/Map.lua
index f8282c8bd..f21c864a4 100644
--- a/src/world/Map.lua
+++ b/src/world/Map.lua
@@ -801,11 +801,16 @@ end
 -- carries you between levels.  Reported from play: "unable to walk down the
 -- stairs into the beach's low water" -- Mossdeep's stairs are 0 and the
 -- shallow water 3; keeping the upper ground's 4 on the stairs walled it off.
+function Map.elevationTransition(at, there, previous)
+  if there == nil or there == ELEVATION_UNDER_BRIDGE or previous == ELEVATION_UNDER_BRIDGE then
+    return at, nil
+  end
+  return there, there ~= ELEVATION_ANY and there or nil
+end
 function Map:elevationAfter(at, cx, cy, px, py)
-  local there = self:cellElevation(cx, cy)
-  if there == nil or there == ELEVATION_UNDER_BRIDGE then return at end
-  if px and py and self:cellElevation(px, py) == ELEVATION_UNDER_BRIDGE then return at end
-  return there
+  local previous = px and py and self:cellElevation(px, py) or nil
+  local elevation = Map.elevationTransition(at, self:cellElevation(cx, cy), previous)
+  return elevation
 end
 
 -- A CELL A SCRIPT SHUT, as opposed to one the shipped map ships shut.
diff --git a/src/world/NPC.lua b/src/world/NPC.lua
index 28b1a2b3e..54d919a8c 100644
--- a/src/world/NPC.lua
+++ b/src/world/NPC.lua
@@ -988,11 +988,17 @@ function NPC:pose()
     end
     py, hopping = py - lift, true
   end
-  return self.sprite, self.px + (self.shiftPx or 0), py, self.facing,
+  local presentation=package.loaded["src.compat.gen1.SourceActors"]
+  local sprite,overridden
+  if presentation then sprite,overridden=presentation.renderer(self)end
+  if not overridden then sprite=self.sprite end
+  return sprite, self.px + (self.shiftPx or 0), py, self.facing,
          self.sliding and 0 or self:walkPhase(), self.stepFlip, hopping
 end
 
 function NPC:draw(camX, camY)
+  local presentation=package.loaded["src.compat.gen1.SourceActors"]
+  if presentation then local sprite,overridden=presentation.renderer(self);if overridden and not sprite then return end end
   local sprite, px, py, facing, phase, flip = self:pose()
   if self.fixedFrame then
     sprite:drawFixedFrame(px, py, camX, camY, self.fixedFrame)
diff --git a/src/world/OptionalFollower.lua b/src/world/OptionalFollower.lua
new file mode 100644
index 000000000..a00d5c05a
--- /dev/null
+++ b/src/world/OptionalFollower.lua
@@ -0,0 +1,167 @@
+-- Opt-in GB Color/GBA companion. The public predicate selects whether it
+-- exists; the native NPC update/draw lists own movement and rendering.
+local NPC = require("src.world.NPC")
+local Runtime = require("src.mods.Runtime")
+local Version = require("src.core.GameVersion")
+local F = {}
+local DELTA = { up = { 0, -1 }, down = { 0, 1 }, left = { -1, 0 }, right = { 1, 0 } }
+
+-- Keep the predicate on the native module table so ModSeams can restore it
+-- when a legacy mod fails to load or is disabled. A closure-only setter would
+-- leave the unloaded mod's callback alive in subsequent game sessions.
+F._shouldSpawn = function()
+  return false
+end
+function F.setShouldSpawn(fn)
+  local previous = F._shouldSpawn
+  if fn then
+    assert(type(fn) == "function", "follower predicate must be a function")
+    F._shouldSpawn = fn
+  end
+  return previous
+end
+local function nativeDefault(game, world)
+  if Version.generation() == 2 then return F._shouldSpawn(game, world) end
+  return false
+end
+local function current(world)
+  for i, npc in ipairs(world.npcs or {}) do
+    if npc.optionalFollower then
+      return npc, i
+    end
+  end
+end
+function F.current(world)
+  return (current(world))
+end
+local function remove(world)
+  local npc, at = current(world)
+  if not npc then
+    return
+  end
+  table.remove(world.npcs, at)
+  for i, entity in ipairs(world.entities or {}) do
+    if entity == npc then
+      table.remove(world.entities, i)
+      break
+    end
+  end
+  world.follower, world.cast = nil, nil
+end
+function F.reset(world)
+  if not world then return false end
+  remove(world);world.followerTrail,world.pikachuTrail=nil,nil
+  return true
+end
+local function spawn(game, world, opts, viaMapLoad)
+  local keep = opts and (opts.keepFollower or opts.keepPikachu)
+  if keep then
+    table.insert(world.npcs, keep)
+    table.insert(world.entities, keep)
+    world.follower, world.cast = keep, nil
+    return
+  end
+  local p, map = world.player, world.map
+  local x, y = p.cellX, p.cellY
+  if not viaMapLoad and Version.generation() == 2 then
+    local d = DELTA[p.facing] or DELTA.down
+    if map:inBounds(x - d[1], y - d[2]) and map:isWalkableCell(x - d[1], y - d[2]) then
+      x, y = x - d[1], y - d[2]
+    end
+  end
+  -- A missing optional sheet must not mutate the content registry. Give the
+  -- NPC its own renderer over the player definition (then NPC's placeholder
+  -- fallback if neither sheet exists), rather than sharing a renderer.
+  local data = game.data
+  if not (data.sprites and data.sprites.SPRITE_PIKACHU) then
+    local def = p.spriteDef or (p.sprite and p.sprite.def)
+    if def then
+      data = setmetatable({
+        sprites = setmetatable({ SPRITE_PIKACHU = def }, { __index = data.sprites }),
+      }, { __index = data })
+    end
+  end
+  local npc = NPC.new(data, map.id, {
+    index = 250,
+    name = "FOLLOWER",
+    sprite = "SPRITE_PIKACHU",
+    movement = "STAY",
+    range = "NONE",
+    x = x,
+    y = y,
+  })
+  npc.optionalFollower, npc.follower, npc.pikachuFollower, npc.passable = true, true, true, true
+  npc.facing, npc.elevation = p.facing or "down", p.elevation
+  table.insert(world.npcs, npc)
+  table.insert(world.entities, npc)
+  world.follower, world.cast = npc, nil
+  world.followerTrail = { x = p.cellX, y = p.cellY }
+  world.pikachuTrail = world.followerTrail
+end
+
+function F.onMapEntered(game, world, opts, viaMapLoad)
+  if opts and opts.checkpoint then return end
+  if not (world and world.map and world.player) then
+    return
+  end
+  remove(world)
+  if Runtime.call("world.follower.spawn", nativeDefault, game, world) then
+    spawn(game, world, opts, viaMapLoad)
+  end
+end
+
+function F.update(game, world)
+  if not (world and world.map and world.player) then
+    return
+  end
+  -- Lua truthiness is the Gen1 predicate contract, including 0 and "".
+  if not Runtime.call("world.follower.spawn", nativeDefault, game, world) then
+    remove(world)
+    return
+  end
+  local npc, p = current(world), world.player
+  if not npc then
+    spawn(game, world)
+    return
+  end
+  local trail = world.followerTrail
+  if not trail then
+    trail = { x = p.cellX, y = p.cellY }
+    world.followerTrail, world.pikachuTrail = trail, trail
+  end
+  if Version.generation() == 3 and math.abs(p.cellX - trail.x) + math.abs(p.cellY - trail.y) > 6 then
+    remove(world)
+    spawn(game, world)
+    return
+  end
+  local x, y = p.targetX or p.cellX, p.targetY or p.cellY
+  if x ~= trail.x or y ~= trail.y then
+    npc.goalX, npc.goalY = trail.x, trail.y
+    trail.x, trail.y = x, y
+  end
+  npc.elevation = p.elevation
+  if npc.moving or not npc.goalX then
+    return
+  end
+  local dx, dy = npc.goalX - npc.cellX, npc.goalY - npc.cellY
+  local distance = math.abs(dx) + math.abs(dy)
+  if distance == 0 then
+    npc.goalX, npc.goalY = nil, nil
+    return
+  end
+  if distance > 6 then
+    npc.cellX, npc.cellY = npc.goalX, npc.goalY
+    npc.px, npc.py = npc.cellX * 16, npc.cellY * 16
+    npc.goalX, npc.goalY = nil, nil
+    return
+  end
+  npc.facing = dx > 0 and "right" or dx < 0 and "left" or dy > 0 and "down" or "up"
+  local d = DELTA[npc.facing]
+  npc.stepDir, npc.targetX, npc.targetY = npc.facing, npc.cellX + d[1], npc.cellY + d[2]
+  local frames = p.stepFramesCur or p.stepFrames or 16
+  npc.stepFrames = distance > 1 and math.max(1, math.floor(frames / 2)) or frames
+  npc.progress, npc.moving = 0, true
+  -- The world's normal NPC loop precedes this controller, so advance frame 1.
+  npc:update(world.map, world.entities)
+end
+return F
diff --git a/src/world/OverworldController.lua b/src/world/OverworldController.lua
index 54ac1c659..32a238be2 100644
--- a/src/world/OverworldController.lua
+++ b/src/world/OverworldController.lua
@@ -3341,6 +3341,7 @@ function OverworldState:update(dt)
   -- already feeds into draw().
   -- the weather's own clock; see drawFieldWeather
   self.weatherFrame = (self.weatherFrame or 0) + 1
+  if GameVersion.isGen3() then require('src.world.Gen3WeatherAudio').update(Game,self) end
   -- ...and the cracked floor's, which runs on the clock rather than on the
   -- steps because that is what makes a step's length decide the fall
   self:tickCrackedFloor()
@@ -5594,60 +5595,6 @@ function OverworldState:startWaterAnim(cx, cy, onDone)
   self.waterAnim = { x = cx, y = cy, frames = 40, total = 40, onDone = onDone }
 end
 
--- TWO VOCABULARIES FOR THE SAME FOUR DIRECTIONS, and they never met.
---
--- The tileset's ledge table names its directions the way the CARTRIDGE does:
--- MB_JUMP_EAST, MB_JUMP_SOUTH -- so the extracted table reads
--- `[0x3B] = "south"`.  Movement here names them the way the PLAYER'S INPUT
--- does: up, down, left, right.  The test below compared one against the other
--- and, of course, never matched -- and then took the early return that says
--- "a dataset that names its ledges by behaviour has said all it has to say",
--- so it did not fall through to anything either.
---
--- The result was the exact bug the table was added to fix, still standing
--- with the table in place: every ledge in Hoenn a wall, no route down off any
--- terrace in the region.  Both halves were right on their own and the join
--- was never driven.
---
--- So the join is one function, and it accepts either word.  A dataset or a
--- mod may say "north" or "up" and mean the same thing.
-local LEDGE_DIRECTIONS = {
-  north = "up", south = "down", west = "left", east = "right",
-  up = "up", down = "down", left = "left", right = "right",
-}
-
-local function ledgeDirection(word)
-  return word and LEDGE_DIRECTIONS[word] or nil
-end
-
--- The eight Gen 3 ledge behaviours, by the direction you must be walking to
--- take them (metatile_behaviors.h). The four diagonals are listed under the
--- axis a cardinal input can satisfy: Emerald lets a diagonal ledge be entered
--- from either of its two components, and up/down is the one this engine's
--- movement can express.
-local GEN3_LEDGE_BEHAVIOURS = {
-  [0x38] = "right",   -- MB_JUMP_EAST
-  [0x39] = "left",    -- MB_JUMP_WEST
-  [0x3A] = "up",      -- MB_JUMP_NORTH
-  [0x3B] = "down",    -- MB_JUMP_SOUTH
-  [0x3C] = "up",      -- MB_JUMP_NORTHEAST
-  [0x3D] = "up",      -- MB_JUMP_NORTHWEST
-  [0x3E] = "down",    -- MB_JUMP_SOUTHEAST
-  [0x3F] = "down",    -- MB_JUMP_SOUTHWEST
-}
-
--- BLACK / WHITE'S FOUR, from the tile records' behaviour byte (Gen5Field):
--- measured over every zone, 0x72 / 0x73 only ever run in columns and 0x74 /
--- 0x75 only in rows, and Route 2's two ledges (y 16 and 20, facing south) are
--- 0x75 -- Generation IV's east / west / north / south order, carried on.
--- Reported from play: "allow hoppable ledges to work, they currently don't".
-local GEN5_LEDGE_BEHAVIOURS = {
-  [0x72] = "right",
-  [0x73] = "left",
-  [0x74] = "up",
-  [0x75] = "down",
-}
-
 -- Ledge hops (data/tilesets/ledge_tiles.asm): standing tile + ledge tile
 -- in front + matching input direction -> jump two cells.
 function OverworldState:checkLedgeHop(dir)
@@ -5658,60 +5605,13 @@ function OverworldState:checkLedgeHop(dir)
   if not self.map:inBounds(fx, fy) then return false end
   local front = self.map:cellTile(fx, fy)
 
-  -- A GEN 3 LEDGE IS A PROPERTY OF THE TILE IN FRONT, not of a pair.
-  --
-  -- Gen 1 and Gen 2 decide a hop from (tile you stand on, tile in front,
-  -- direction) because their tilesets have no room to say more.  Gen 3 says
-  -- it outright: the metatile's behaviour byte IS "you jump this, eastward".
-  -- Nothing derived a pair table for Hoenn, so field.ledges was empty and
-  -- every ledge in the region was simply a wall -- there was no route down
-  -- off any terrace in the game.
-  --
-  -- cellBehaviour rather than cellTile because a ledge is blocked, and
-  -- cellTile answers $FF for anything blocked.
-  --
-  -- ...AND NOTHING EVER SUPPLIED THE TABLE. `field.ledgeBehaviours` is read
-  -- here and written nowhere: no importer produces it and no dataset ships
-  -- one, so `byBehaviour` was nil on every map in the game and Hoenn fell
-  -- through to the pair tables below -- which are Gen 1 and Gen 2 rows keyed
-  -- by tile id, and match nothing on a Gen 3 pair. Every ledge in Hoenn was
-  -- a wall you could not hop.
-  --
-  -- The cartridge's own answer is a fixed run of eight behaviour bytes
-  -- (metatile_behaviors.h, MB_JUMP_EAST through MB_JUMP_SOUTHWEST), so it is
-  -- stated here rather than derived. A dataset that ships its own table
-  -- still wins; this only fills the gap. Gated on the pair shape -- 2x2
-  -- tiles to a metatile, one collision cell -- because those byte values
-  -- mean something else entirely in Kanto and Johto.
-  local byBehaviour = self.map.tileset and self.map.tileset.ledgeBehaviours
-    or Game.data.field and Game.data.field.ledgeBehaviours
-  -- first on a Black / White zone: its stand-in tileset carries Platinum's
-  -- table, whose codes mean other things here
-  if self.map.def and self.map.def.gen5 then byBehaviour = GEN5_LEDGE_BEHAVIOURS end
-  if not byBehaviour then
-    local ts = self.map.tileset
-    if ts and tonumber(ts.blockTiles) == 2 and tonumber(ts.blockCells) == 1
-       and ts.collision then
-      byBehaviour = GEN3_LEDGE_BEHAVIOURS
-    end
-  end
-  if byBehaviour then
-    local behaviour = self.map:cellBehaviour(fx, fy)
-    if behaviour and ledgeDirection(byBehaviour[behaviour]) == dir then
-      -- PLATINUM'S DOUBLE JUMP, the Distortion World's: `JUMP_*_TWICE`
-      -- (0x5A..0x5D) plays MOVEMENT_ACTION_JUMP_DISTORTION_WORLD_*, which
-      -- moves 2 units a frame for 24 frames -- THREE tiles, against an
-      -- ordinary ledge's 16 frames and two -- and passes SEQ_NONE, so it is
-      -- silent (pokeplatinum src/unk_020655F4.c). All 224 such tiles are in
-      -- the D34 rooms; taken as ordinary ledges they landed a tile short.
-      if (self.map.def and self.map.def.generation) == 4
-         and behaviour >= 0x5A and behaviour <= 0x5D then
-        return self:startLedgeHop(dir, fx, fy, 3, true)
-      end
-      return self:startLedgeHop(dir, fx, fy)
+  local handled, x, y, distance, silent = require("src.world.Ledge").approach(
+    self.map, Game.data, p.cellX, p.cellY, dir)
+  if handled then
+    if x then
+      if distance then return self:startLedgeHop(dir, x, y, distance, silent) end
+      return self:startLedgeHop(dir, x, y)
     end
-    -- a dataset that names its ledges by behaviour has said all it has to
-    -- say; the pair tables below are the older generations' answer
     return false
   end
   if self:gen2LedgeAllows(standing, dir) then
@@ -6841,6 +6741,14 @@ function OverworldState:flyTo(mapId, mon)
   local flyWarps = (Game.data.field or {}).flyWarps or {}
   local spot = flyWarps[mapId]
   if not spot then return end
+  local field=package.loaded['src.core.game3.field']
+  if GameVersion.isGen3()and field then
+    return field._dispatchFly(Game,self,mapId,mon,spot,function()return OverworldState._flyToBody(self,mapId,mon,spot)end)
+  end
+  return OverworldState._flyToBody(self,mapId,mon,spot)
+end
+
+function OverworldState:_flyToBody(mapId,mon,spot)
   require("src.core.Sound").play(Game.data, "Fly")
   Game.save.onBike = false
   self:clearBikeFlags() -- HandleFlyWarpOrDungeonWarp res BIT_ALWAYS_ON_BIKE
@@ -7236,7 +7144,35 @@ function OverworldState:tryPcTile(fx, fy)
   return false
 end
 
+function OverworldState:scriptRunning()
+  return (self.runner and self.runner:isRunning()) and true or false
+end
+
+function OverworldState:busy()
+  local field=package.loaded["src.core.game3.field"]
+  if GameVersion.isGen3()and field and field._locked(Game,self)then return true end
+  -- Gen2's world lives below overlays. A movement wrapper runs after the
+  -- native body, including a START/A press that just opened a screen: it
+  -- must not move behind that new owner on the same tick.
+  if GameVersion.isGen2() then
+    if self.battleActive then return true end
+    local stack = Game and Game.stack
+    local top = stack and stack.top and stack:top()
+    if top and top ~= self then return true end
+  end
+  return (self:scriptRunning() or (self.scriptMoves and #self.scriptMoves > 0)
+    or self.engaging or self.emote or self.teleportOut or self.whirlSpin
+    or self.gen4Waterfall or self.transitioning or self.flyAnim or self.fishing
+    or (self.player and (self.player.stairExit or self.player.inputLocked or self.player.fieldMove))
+    or (self.pendingScripts and self.pendingScripts[1])) and true or false
+end
+
 function OverworldState:interact()
+  local field=package.loaded["src.core.game3.field"]
+  if GameVersion.isGen3()and field then return field._dispatch(Game,self,function()return self:_interactBody()end)end
+  return self:_interactBody()
+end
+function OverworldState:_interactBody()
   local p = self.player
   local fx, fy = p:facingCell()
 
@@ -8857,6 +8793,7 @@ function OverworldState:weatherName(value)
     return require("src.import.Gen4Weather").nameFor(value)
   end
   local names = (Game.data.constants or {}).gen3WeatherNames
+    or require("src.core.Gen3WeatherIds").names
   local n = tonumber(value)
   return (names and n and names[n]) or nil
 end
@@ -10235,13 +10172,8 @@ function OverworldState:gen2SweetScentEncounter(deferFailure)
     if contest then enc = BugContest.rollEncounter(Game)
     elseif slots and (GameVersion.isGen3() or (slots.rate or 0) > 0) then
       if GameVersion.isGen3() then
-        local Roam=require("src.world.Gen3Roamers")
-        if Roam.check(Game.data,Game.save,self.map.id,love.math.random) then
-          enc=Roam.encounterFor(Game.data,Game.save)
-          if enc then roamer="gen3" end
-        end
-      end
-      if not enc then enc = Encounter.chooseTable(slots) end
+        enc,roamer=Encounter.sweetScent(Game.data,Game.save,self.map.def,self.map.id,water,true,love.math.random)
+      else enc = Encounter.chooseTable(slots) end
     end
   end
   if not enc then
@@ -13547,7 +13479,10 @@ function OverworldState:onStepComplete()
         local okT, T = pcall(require, "src.import.Gen4Text")
         g4line = okT and T.resolve(Game.data, hgss and 40 or 213, hgss and 65 or 79, Game) or nil
       end
-      Game.stack:push(TextBox.new(Game, g4line or Strings("REPEL's effect\nwore off.")))
+      local again=GameVersion.isGen3()and package.loaded['src.mods.FeatureOptions']and function()
+        require('src.ui.RepelPrompt').show(Game)
+      end or nil
+      Game.stack:push(TextBox.new(Game, g4line or Strings("REPEL's effect\nwore off."),again))
       return
     end
   end
@@ -15003,9 +14938,11 @@ function OverworldState:startWarpTo(mapId, x, y, facing, onDone, opts)
   self.doorWarp = nil
   local arriveWarp = self.arriveWarp
   self.arriveWarp = nil
+  self.warpArrivalKind = arriveWarp
   local fromId = self.map.id
   local fromSection = self.map.def and self.map.def.regionMapSection
-  Game.stack:push(Transition.new(Game, function()
+  local transition
+  transition = Transition.new(Game, function()
     self:setMap(mapId, x, y, facing or "down", opts)
     self:noteGen2Spawn(fromId)
     -- FIRERED'S SIDE STAIRS (ExitStairsMovement): you land ON the stair tile
@@ -15050,7 +14987,14 @@ function OverworldState:startWarpTo(mapId, x, y, facing, onDone, opts)
     -- (player_animations.asm EnterMapAnim).  Blackouts and ordinary
     -- door warps never take this branch.
     if arriveWarp == "fly" then
-      require("src.core.Sound").play(Game.data, "Fly")
+      local effects=package.loaded['src.core.game3.field_effects']
+      if GameVersion.isGen3()and effects then
+        require('src.world.Gen3FlyArrival').begin(Game,self,transition,effects,function()
+          return require('src.core.Sound').play(Game.data,"Fly")
+        end)
+      else
+        require("src.core.Sound").play(Game.data, "Fly")
+      end
     elseif arriveWarp == "teleport" then
       require("src.core.Sound").play(Game.data, "Teleport_Enter1")
       -- ENTER_2 caps the spin-down a moment later
@@ -15160,6 +15104,7 @@ function OverworldState:startWarpTo(mapId, x, y, facing, onDone, opts)
     end
   end, function()
     self.transitioning = false
+    self.warpArrivalKind = nil
     -- THE ARRIVAL IS WHAT GIVES THE CONTROLS BACK.
     --
     -- Reported from play: "Fix the lavaridge gym its bugged When you go
@@ -15195,7 +15140,8 @@ function OverworldState:startWarpTo(mapId, x, y, facing, onDone, opts)
     -- side, which is what the scripts already do.
     if self.player then self.player.inputLocked = false end
     if onDone then onDone() end
-  end))
+  end)
+  Game.stack:push(transition)
 end
 
 -- Re-read a map record after its data changed (WorldAPI:invalidateMap,
@@ -16854,7 +16800,7 @@ function OverworldState:poseBerryTrees()
   end
 end
 
-function OverworldState:drawWorld()
+local function drawWorldBody(self)
   -- Dark-map BG shade shift, armed for the whole frame before anything draws.
   -- home/fade.asm's LoadGBPal writes ONE rBGP for the screen, so terrain, the
   -- characters standing on it and any dialog over them darken together (#322);
@@ -17923,7 +17869,7 @@ function OverworldState:drawWorld()
           e.spriteOffset and e.spriteOffset.lift, e.spriteOffset and e.spriteOffset.oz)
         -- UNDER the sprite, and lifted by the same terrain rise it is, so a
         -- character on a slope keeps their feet on it.
-        if shadows then
+        if shadows and not e.customSourceActor then
           if depth then
             spriteDepthGround:withSpriteDepth(depth, function()
               shadows:draw(self.map, e, cam.x, cam.y, e == self.player, riseOf(e))
@@ -18433,48 +18379,14 @@ end
 -- is the same beat the Game Boy path uses to swap the machine's shades, so the
 -- two generations blink together off one clock.
 function OverworldState:drawGen3Heal(ha, cam)
-  if not GameVersion.isGen3() then return false end
-  local record = (Game.data.constants or {}).gen3HealMachine
-  if not (record and record.monitor and record.glow) then return false end
-  self.gen3HealArt = self.gen3HealArt or {}
-  local art = self.gen3HealArt
-  local function picture(path)
-    if art[path] == nil then
-      local ok, img = pcall(require("src.render.Assets").image, path)
-      art[path] = (ok and img) or false
-    end
-    return art[path] or nil
-  end
-  local ox = math.floor(ha.px - cam.x)
-  local oy = math.floor(ha.py - cam.y)
+  local sprites = require("src.world.Gen3HealingPresentation").snapshot(Game, self, ha)
+  if not sprites then return false end
   love.graphics.setColor(1, 1, 1, 1)
-  local frames = record.monitor.images or {}
-  local frame = frames[(ha.visible == false) and 2 or 1] or frames[1]
-  local monitor = frame and picture(frame)
-  if monitor then
-    love.graphics.draw(monitor, ox + record.monitor.x, oy + record.monitor.y)
-  end
-  -- Reported from play: the healing machine's layout looks wrong -- what was
-  -- actually wrong is that a lit ball was invisible rather than misplaced.
-  -- The console art the map tileset already draws bakes in its own row of
-  -- (unlit-looking) LED dots, and this glow sprite is the ROM's own tiny
-  -- 4x4 dot meant to sit exactly over one -- at native size, one more red
-  -- pixel-cluster on top of art that is already mostly red LEDs, it could
-  -- not be told apart from the backdrop it was drawn on. 2x scale and a
-  -- bright gold tint (a lit Poke Ball, not a red LED) makes each one land.
-  local glow = record.glow.image and picture(record.glow.image)
-  if glow then
-    -- NATIVE SIZE AND COLOURS.  An enlarged, gold-tinted ball read better in
-    -- the voxel view but dwarfed the machine in the plain game; the sprite and
-    -- sPokeballCoordOffsets are the cartridge's own and are drawn as such.
-    for i = 1, math.min(ha.lit or 0, #(record.glow.offsets or {})) do
-      local at = record.glow.offsets[i]
-      love.graphics.draw(glow, ox + record.glow.x + at[1],
-                         oy + record.glow.y + at[2])
-    end
-    love.graphics.setColor(1, 1, 1, 1)
+  for _, sprite in ipairs(sprites) do
+    love.graphics.draw(sprite.image, math.floor(ha.px - cam.x) + sprite.x - ha.px,
+                       math.floor(ha.py - cam.y) + sprite.y - ha.py)
   end
-  return (monitor or glow) ~= nil
+  return #sprites > 0
 end
 
 -- screen-space overlays: drawn to the UI canvas at normal scale
@@ -18862,4 +18774,18 @@ function OverworldState:captureSave(save)
   end
 end
 
+function OverworldState:drawWorld()
+  local field=package.loaded["src.core.game3.field_view"]
+  if not GameVersion.isGen3()then return drawWorldBody(self)end
+  local effects=package.loaded["src.core.game3.field_effects"]
+  if effects and effects._hasActorExtensions and effects._hasActorExtensions()then
+    return require('src.compat.gen1.SourceActors').withActors(Game,self,function()
+      if field then return field._nativeDraw(Game,self,drawWorldBody)end
+      return drawWorldBody(self)
+    end)
+  end
+  if field then return field._nativeDraw(Game,self,drawWorldBody)end
+  return drawWorldBody(self)
+end
+
 return OverworldState
diff --git a/src/world/PikachuFollower.lua b/src/world/PikachuFollower.lua
index 708f386b6..9bb668233 100644
--- a/src/world/PikachuFollower.lua
+++ b/src/world/PikachuFollower.lua
@@ -189,6 +189,9 @@ function PikachuFollower.current(ow)
 end
 
 function PikachuFollower.onMapEntered(game, ow, opts)
+  if require('src.core.GameVersion').isGen3()then
+    return require('src.world.OptionalFollower').onMapEntered(game,ow,opts,true)
+  end
   -- Bill's House owns a short scripted scene that deliberately keeps
   -- Pikachu off the normal trailing loop.  A new map instance ends it.
   ow.pikachuBillsScene = nil
@@ -395,6 +398,11 @@ end
 -- one follow step per frame: chase the cell the player last vacated
 -- (pikachu_follow.asm keeps it one walk step behind)
 function PikachuFollower.update(game, ow)
+  if require('src.core.GameVersion').isGen3()then
+    local source=package.loaded['src.compat.game3.Follower']or package.loaded['src.world.game3.Follower']
+    if source and source._dispatch then return source._dispatch(game,ow,function()return require('src.world.OptionalFollower').update(game,ow)end)end
+    return require('src.world.OptionalFollower').update(game,ow)
+  end
   if ow.pikaHop then return end -- the counter hop owns the follower (#417)
   if ow.pikachuBillsScene then return end
   local npc = findFollower(ow)
diff --git a/src/world/Player.lua b/src/world/Player.lua
index 8e6b6f0fa..852ee4914 100644
--- a/src/world/Player.lua
+++ b/src/world/Player.lua
@@ -725,6 +725,7 @@ function Player:freeWalk(vx, vy, map, entities)
 end
 
 function Player:update()
+  local pose=package.loaded["src.compat.gen1.PlayerPose"];if pose then pose.tick(self)end
   -- A PENDING FREE-WALK IS THIS FRAME'S STEP.
   --
   -- Consumed here rather than driven from the input handler so that the
diff --git a/src/world/Warp.lua b/src/world/Warp.lua
index d959a1e55..3d394aed7 100644
--- a/src/world/Warp.lua
+++ b/src/world/Warp.lua
@@ -430,4 +430,16 @@ function Warp.destination(data, warpDef, lastMap, backupWarp, save)
                       { warp = warpDef, lastMap = lastMap, data = data })
 end
 
+-- Presentation forecasts use the same native landing rules without invoking
+-- the committing warp hook or admitting a map, script or player transition.
+function Warp.peekDestination(data, warpDef, lastMap, backupWarp, save)
+  if type(warpDef) ~= "table" or not (data and data.maps) then return nil end
+  local dest = warpDef.destMap
+  if dest == "LAST_MAP" and not lastMap then return nil end
+  if dest == "LAST_WARP" and not backupWarp and not lastMap then return nil end
+  if not (data.maps[dest] or dest == "LAST_MAP" or dest == "LAST_WARP"
+      or dest == GEN3_DYNAMIC_MAP or dest == GEN4_DYNAMIC_MAP) then return nil end
+  return resolve(data, warpDef, lastMap, backupWarp, save)
+end
+
 return Warp
diff --git a/src/world/WorldActions.lua b/src/world/WorldActions.lua
new file mode 100644
index 000000000..9648fd6a0
--- /dev/null
+++ b/src/world/WorldActions.lua
@@ -0,0 +1,480 @@
+-- Supported mutations go through the existing gameplay entry points. Shared
+-- guards keep companion UIs out of screens/scripts/transitions that own input.
+local GameVersion = require("src.core.GameVersion")
+local Map = require("src.world.Map")
+local MapIdentity = require("src.core.MapIdentity")
+local FieldDefaults = require("src.world.FieldDefaults")
+local Party = require("src.pokemon.Party")
+local A = {}
+
+local function activeTop(stack)
+  return stack.active and stack:active() or stack:top()
+end
+
+local METHODS = {
+  canReorderParty = true,
+  reorderParty = true,
+  availableFieldActions = true,
+  useFieldAction = true,
+  canFly = true,
+  flyTo = true,
+}
+local LOCKS = {
+  "transitioning",
+  "flyAnim",
+  "teleportOut",
+  "engaging",
+  "emote",
+  "pikaHop",
+  "healAnim",
+  "whirlSpin",
+  "gen4Waterfall",
+  "gen5SeamPending",
+  "gen3Decorate",
+  "frameScriptThisTick",
+  "_modScriptLock",
+}
+local pending = setmetatable({}, { __mode = "k" })
+local planning = setmetatable({}, { __mode = "k" })
+local function integer(v, lo, hi)
+  return type(v) == "number" and v == v and v % 1 == 0 and v >= lo and v <= hi
+end
+function A.supports(name)
+  return type(name) == "string" and METHODS[name] == true
+end
+
+local function ready(game, ow)
+  if not (game and game.save) then
+    return nil, "no save"
+  end
+  if not (ow and ow.map and ow.player) then
+    return nil, "no overworld"
+  end
+  local token = pending[game]
+  if token and token.state then
+    local held = false
+    for _, state in ipairs(game.stack and game.stack.states or {}) do
+      if state == token.state then
+        held = true
+      end
+    end
+    if game.stack and game.stack.top and game.stack:top() == token.state then
+      held = true
+    end
+    if
+      not held
+      or game.save ~= token.save
+      or game.data ~= token.data
+      or ow.map ~= token.map
+      or ow.player ~= token.player
+    then
+      pending[game] = nil
+    end
+  end
+  if not (game.stack and game.stack.top and activeTop(game.stack) == ow) then
+    return nil, "world is busy"
+  end
+  if
+    pending[game]
+    or planning[game]
+    or (game.overworld and game.overworld ~= ow)
+    or game.linkSession
+    or (game.linkNet and not game.linkNet.closed)
+  then
+    return nil, "world is busy"
+  end
+  for _, key in ipairs(LOCKS) do
+    if ow[key] then
+      return nil, "world is busy"
+    end
+  end
+  local field=package.loaded["src.core.game3.field"]
+  if GameVersion.isGen3()and field and field._locked(game,ow)then return nil,"world is busy"end
+  local player = ow.player
+  if player.moving or player.inputLocked or player.stairExit or player.spinning or player.fieldMove then
+    return nil, "world is busy"
+  end
+  if not (ow.runner and type(ow.runner.isRunning) == "function") then
+    return nil, "world is busy"
+  end
+  if ow.runner:isRunning() or #(ow.scriptMoves or {}) > 0 or #(ow.pendingScripts or {}) > 0 then
+    return nil, "world is busy"
+  end
+  return true
+end
+-- Shared admission guard for the API-3 warp adapter.
+A.ready = ready
+local function guardedCall(game, fn, ...)
+  planning[game] = true
+  local result = { pcall(fn, game, ...) }
+  planning[game] = nil
+  if not result[1] then
+    error(result[2], 0)
+  end
+  return result[2], result[3]
+end
+local function party(game)
+  return game and game.save and game.save.party or {}
+end
+local function member(game, mon)
+  if type(mon) ~= "table" or Party.isEgg(mon) then
+    return nil
+  end
+  for _, p in ipairs(party(game)) do
+    if p == mon then
+      return mon
+    end
+  end
+end
+local function user(game, ow, move)
+  if type(ow.partyKnows) ~= "function" then
+    return nil
+  end
+  return member(game, ow:partyKnows(move))
+end
+local function context(game, ow)
+  local p = ow.player
+  return {
+    save = game.save,
+    data = game.data,
+    map = ow.map,
+    player = p,
+    x = p.cellX,
+    y = p.cellY,
+    facing = p.facing,
+    version = GameVersion.get(),
+  }
+end
+local function same(game, ow, c)
+  return game.save == c.save
+    and game.data == c.data
+    and ow.map == c.map
+    and ow.player == c.player
+    and ow.player.cellX == c.x
+    and ow.player.cellY == c.y
+    and ow.player.facing == c.facing
+    and GameVersion.get() == c.version
+end
+local function currentWorld(game, ow)
+  -- A state replaced while a cut-in was active must not receive its effect.
+  return game.stack and game.stack.top and activeTop(game.stack) == ow
+end
+local function present(game, ow, mon, check, run)
+  local c = context(game, ow)
+  local called = false
+  local token = { save = game.save, data = game.data, map = ow.map, player = ow.player }
+  pending[game] = token
+  local result, reason
+  local function finish()
+    if called then
+      return
+    end
+    called = true
+    if pending[game] ~= token then
+      return
+    end
+    pending[game] = nil
+    if
+      not currentWorld(game, ow)
+      or not same(game, ow, c)
+      or not ready(game, ow)
+      or not member(game, mon)
+    then
+      result, reason = nil, "world changed"
+      return
+    end
+    if not check() then
+      result, reason = nil, "action unavailable"
+      return
+    end
+    -- A capability hook invoked by check() may have changed the session.
+    if not same(game, ow, c) or not ready(game, ow) then
+      result, reason = nil, "world changed"
+      return
+    end
+    local answer = guardedCall(game, run)
+    if answer == false then
+      result, reason = nil, "action unavailable"
+    else
+      result = true
+    end
+  end
+  if GameVersion.generation() == 3 then
+    -- Never retry an engine callback that threw after invoking finish().
+    local ok, shown = pcall(function()
+      return require("src.world.Gen3FieldMove").show(game, mon, finish)
+    end)
+    if not ok then
+      pending[game] = nil
+      error(shown, 0)
+    end
+    if shown then
+      token.state = game.stack:top()
+      return true
+    end
+  end
+  finish()
+  return result, reason
+end
+
+function A.canReorderParty(game, ow)
+  return #party(game) > 1 and ready(game, ow) == true
+end
+function A.reorderParty(game, ow, from, to)
+  local ok, reason = ready(game, ow)
+  if not ok then
+    return nil, reason
+  end
+  local p = party(game)
+  if
+    not integer(from, 1, Party.MAX)
+    or not integer(to, 1, Party.MAX)
+    or type(p[from]) ~= "table"
+    or type(p[to]) ~= "table"
+  then
+    return nil, "invalid party slot"
+  end
+  -- Match the native party menus: swap references, never reconstruct mons.
+  if from ~= to then
+    p[from], p[to] = p[to], p[from]
+  end
+  return true
+end
+
+local function outside(game, ow)
+  return Map.isOutside(ow.map.def, FieldDefaults.field(game.data, "outsideTilesets"))
+end
+local function validSpot(data, id, x, y, gen)
+  local def = data and data.maps and data.maps[id]
+  if not def or not integer(def.width, 1, 1000000) or not integer(def.height, 1, 1000000) then
+    return false
+  end
+  local tileset = data.tilesets and data.tilesets[def.tileset]
+  local cells = tileset and tileset.blockCells or (gen >= 3 and 1 or 2)
+  return integer(cells, 1, 1000000)
+    and integer(x, 0, def.width * cells - 1)
+    and integer(y, 0, def.height * cells - 1)
+end
+local function flyPlan(game, ow, mapId)
+  local gen = GameVersion.generation()
+  local data, save = game.data or {}, game.save
+  local mon
+  if gen >= 4 then
+    local F = require("src.world.Gen4FieldMoves")
+    for _, p in ipairs(party(game)) do
+      if not Party.isEgg(p) and F.knows(p, "FLY") then
+        mon = p
+        break
+      end
+    end
+    if not mon then
+      return nil, "fly unavailable"
+    end
+    if gen == 5 then
+      local Fly = require("src.world.Gen5Fly")
+      if not Fly.allowed(ow.map.def) or type(ow.gen4FlyTo) ~= "function" then
+        return nil, "fly unavailable"
+      end
+      for _, loc in ipairs(Fly.destinations(data, save)) do
+        local dest = Fly.destination(data, loc)
+        if dest and (not mapId or dest.map == mapId) and validSpot(data, dest.map, dest.x, dest.y, gen) then
+          return { mon = mon, dest = dest, ds = true }
+        end
+      end
+    else
+      local Fly = require("src.world.Gen4Fly")
+      local costume = require("src.inventory.Gen4FieldChecks").inCostume(data, save)
+      if costume or not Fly.check(data, save, ow.map.def) or type(ow.gen4FlyTo) ~= "function" then
+        return nil, "fly unavailable"
+      end
+      for _, dest in ipairs(Fly.destinations(data, save)) do
+        if (not mapId or dest.map == mapId) and validSpot(data, dest.map, dest.x, dest.y, gen) then
+          return { mon = mon, dest = { map = dest.map, x = dest.x, y = dest.y }, ds = true }
+        end
+      end
+    end
+  else
+    mon = user(game, ow, "FLY")
+    local travel = gen == 3 and require("src.world.Gen3FieldRules").allowsTravel(ow.map.def)
+      or (gen < 3 and outside(game, ow))
+    if not mon or not travel or type(ow.flyTo) ~= "function" then
+      return nil, "fly unavailable"
+    end
+    local field = data.field or {}
+    for _, id in ipairs(field.flyOrder or {}) do
+      local def = data.maps and data.maps[id]
+      local spot = field.flyWarps and field.flyWarps[id]
+      if
+        (not mapId or MapIdentity.same(data, mapId, id))
+        and save.visited
+        and MapIdentity.savedValue(data, save.visited, id)
+        and spot
+        and def
+        and (Map.isOutdoor(def) or def.tileset == "PLATEAU")
+        and validSpot(data, id, spot.x, spot.y, gen)
+      then
+        return { mon = mon, dest = { map = id, x = spot.x, y = spot.y } }
+      end
+    end
+  end
+  return nil, "destination unavailable"
+end
+function A.canFly(game, ow)
+  if not ready(game, ow) then
+    return false
+  end
+  local c = context(game, ow)
+  return guardedCall(game, flyPlan, ow) ~= nil and same(game, ow, c) and ready(game, ow) == true
+end
+function A.flyTo(game, ow, mapId)
+  local ok, reason = ready(game, ow)
+  if not ok then
+    return nil, reason
+  end
+  if type(mapId) ~= "string" or mapId == "" then
+    return nil, "invalid destination"
+  end
+  local c = context(game, ow)
+  local plan, why = guardedCall(game, flyPlan, ow, mapId)
+  if not plan then
+    return nil, why
+  end
+  if not same(game, ow, c) or not ready(game, ow) then
+    return nil, "world changed"
+  end
+  return present(game, ow, plan.mon, function()
+    local fresh = guardedCall(game, flyPlan, ow, mapId)
+    return fresh and fresh.mon == plan.mon and fresh.dest.x == plan.dest.x and fresh.dest.y == plan.dest.y
+  end, function()
+    if plan.ds then
+      return ow:gen4FlyTo(plan.dest, plan.mon)
+    end
+    return ow:flyTo(plan.dest.map, plan.mon)
+  end)
+end
+
+local ORDER = { "cut", "surf", "dig", "teleport" }
+local function fieldPlan(game, ow, id)
+  local gen = GameVersion.generation()
+  if gen >= 4 then
+    return nil, "DS field actions require a native script adapter"
+  end
+  if id == "cut" then
+    if gen == 3 then
+      return nil, "Gen 3 Cut requires an object-script adapter"
+    end
+    local mon = user(game, ow, "CUT")
+    if
+      mon
+      and type(ow.useCutFieldMove) == "function"
+      and ow:useCutFieldMove() == "ok"
+      and type(ow.tryCut) == "function"
+    then
+      return {
+        mon = mon,
+        run = function()
+          local x, y = ow.player:facingCell()
+          return ow:tryCut(x, y)
+        end,
+      }
+    end
+  elseif id == "surf" then
+    local mon = user(game, ow, "SURF")
+    if
+      mon
+      and not ow.player.surfing
+      and type(ow.useSurfFieldMove) == "function"
+      and ow:useSurfFieldMove() == "ok"
+      and type(ow.trySurf) == "function"
+    then
+      return {
+        mon = mon,
+        run = function()
+          local x, y = ow.player:facingCell()
+          return ow:trySurf(x, y, nil, mon)
+        end,
+      }
+    end
+  elseif id == "dig" or id == "teleport" then
+    local mon = user(game, ow, id:upper())
+    if not mon or type(ow.beginTeleportOut) ~= "function" then
+      return nil, "field action unavailable"
+    end
+    local escape = false
+    if id == "teleport" then
+      local travel = gen == 3 and require("src.world.Gen3FieldRules").allowsTravel(ow.map.def)
+        or (gen < 3 and outside(game, ow))
+      if not travel or not game.save.lastHeal then
+        return nil, "field action unavailable"
+      end
+    elseif gen == 1 then
+      local tiles = { FOREST = true, CEMETERY = true, CAVERN = true, FACILITY = true, INTERIOR = true }
+      if not tiles[ow.map.def.tileset] or ow.map.id == "AGATHAS_ROOM" or not game.save.lastHeal then
+        return nil, "field action unavailable"
+      end
+    else
+      local point = type(ow.escapePoint) == "function" and ow:escapePoint()
+      if not point then
+        return nil, "field action unavailable"
+      end
+      if gen == 3 then
+        if not require("src.world.Gen3FieldRules").allowsEscape(ow.map.def, point) then
+          return nil, "field action unavailable"
+        end
+      elseif require("src.core.Gen2Environment").id(ow.map.def) ~= 4
+         and require("src.core.Gen2Environment").id(ow.map.def) ~= 7 then
+        return nil, "field action unavailable"
+      end
+      escape = true
+    end
+    return {
+      mon = mon,
+      run = function()
+        return ow:beginTeleportOut(nil, { escape = escape or nil })
+      end,
+    }
+  end
+  return nil, "field action unavailable"
+end
+function A.availableFieldActions(game, ow)
+  local ok, reason = ready(game, ow)
+  if not ok then
+    return {}, reason
+  end
+  local c = context(game, ow)
+  local out = {}
+  for _, id in ipairs(ORDER) do
+    if guardedCall(game, fieldPlan, ow, id) then
+      out[#out + 1] = { id = id, label = id:upper() }
+    end
+    if not same(game, ow, c) or not ready(game, ow) then
+      return {}, "world changed"
+    end
+  end
+  return out
+end
+function A.useFieldAction(game, ow, id, opts)
+  local ok, reason = ready(game, ow)
+  if not ok then
+    return nil, reason
+  end
+  if type(id) ~= "string" then
+    return nil, "invalid field action"
+  end
+  if opts ~= nil and (type(opts) ~= "table" or next(opts) ~= nil or getmetatable(opts) ~= nil) then
+    return nil, "unsupported field action options"
+  end
+  local c = context(game, ow)
+  local plan, why = guardedCall(game, fieldPlan, ow, id)
+  if not plan then
+    return nil, why
+  end
+  if not same(game, ow, c) or not ready(game, ow) then
+    return nil, "world changed"
+  end
+  return present(game, ow, plan.mon, function()
+    local fresh = guardedCall(game, fieldPlan, ow, id)
+    return fresh and fresh.mon == plan.mon
+  end, plan.run)
+end
+return A
diff --git a/tests/engine/compatibility_cell_semantics.lua b/tests/engine/compatibility_cell_semantics.lua
new file mode 100644
index 000000000..5468cb850
--- /dev/null
+++ b/tests/engine/compatibility_cell_semantics.lua
@@ -0,0 +1,55 @@
+package.path = './?.lua;./?/init.lua;' .. package.path
+local T = require('tests.modkit')
+local MB = require('src.core.game3.mb')
+local Class = require('src.compat.gen1.CollisionClass')
+local fr, em = Class.impl('frlg'), Class.impl('rse')
+T.eq(MB.fromRaw('firered', 17), 17, 'Kanto raw byte retains meaning')
+T.eq(MB.fromRaw('emerald', 17), MB.INTERIOR_DEEP_WATER, 'Hoenn byte 17 is not Kanto fast water')
+T.check(MB.fromRaw('emerald', 17) ~= MB.FAST_WATER, 'families do not share behavior byte meanings')
+for _, game in ipairs({'emerald', 'ruby', 'sapphire'}) do
+ local translator = MB.translator(game)
+ for raw = 0, 255 do T.eq(translator.canon(translator.raw(translator.canon(raw))), translator.canon(raw)) end
+ T.eq(translator.canon(.5), nil, 'fractional input is not silently truncated')
+ T.eq(MB.fromRaw(game, .5), nil, 'failed conversion does not fall back to raw')
+ local copy = translator.table(); copy[0] = -1
+ T.check(translator.table()[0] ~= -1, 'conversion snapshots cannot corrupt shared metadata')
+end
+local copy = MB.all(); copy.NORMAL = -1
+T.eq(MB.id('MB_NORMAL'), 0, 'name snapshots cannot corrupt IDs')
+T.eq(fr.fromCell(0, 0, MB.POND_WATER, 'route'), 0x29, 'water is classified, not raw collision zero')
+T.eq(fr.fromCell(0, 1, MB.POND_WATER, 'route'), 7, 'blocked water stays blocked')
+T.eq(fr.fromCell(0, 0, MB.TALL_GRASS, 'route'), 0x18)
+T.eq(fr.fromCell(0, 0, MB.JUMP_NORTH, 'route'), 0xa2)
+T.eq(fr.fromCell(0, 0, MB.WARP_DOOR, 'indoor'), 0x72, 'indoor warp retains facing')
+T.eq(fr.fromCell(0, 0, MB.WARP_DOOR, 'town'), 0x71, 'outdoor door retains original arrival contract')
+T.eq(fr.fromCell(10, nil, nil, 'route'), 7, 'nil collision differs from zero in Kanto terrain fallback')
+T.eq(fr.fromCell(10, 0, nil, 'route'), 0)
+T.eq(fr.fromCell(10, 1, nil, 'indoor'), 7, 'indoor reused metatile is not an outdoor tree')
+T.eq(fr.fromCell(646, 0, 0, 'route'), 0, 'dead shrub guard does not become new foliage')
+local bits = {[MB.POND_WATER] = 2, [MB.TALL_GRASS] = 2}
+em.setTileBits(bits)
+T.eq(em.fromCell(0, 0, MB.POND_WATER, 'route'), 0x29)
+T.eq(em.fromCell(0, 1, MB.POND_WATER, 'route'), 7)
+T.eq(em.fromCell(0, 0, MB.TALL_GRASS, 'route'), 0x29, 'actual surf flag precedes static category')
+bits[MB.TALL_GRASS] = 0
+T.eq(em.fromCell(0, 0, MB.TALL_GRASS, 'route'), 0x18, 'borrowed flag mutation is visible immediately')
+bits[MB.POND_WATER] = nil
+T.eq(em.fromCell(0, nil, MB.POND_WATER, 'route'), 0, 'Hoenn fallback accepts nil collision')
+T.eq(fr.fromCell(0, 0, MB.POND_WATER, 'route'), 0x29, 'Hoenn flags do not change Kanto classification')
+em.setTileBits(nil)
+T.eq(em._tileBits, nil, 'flag owner can retire its source')
+T.eq(em.fromCell(0, 0, MB.POND_WATER, 'route'), 0, 'no invented surfability without source flags')
+local classify, seed = em.classify, em.seed
+em.classify = function() return 'LEDGE', 'W' end
+T.eq(em.fromCell(0, 0, 0, 'route'), 0xa1, 'replacement classifier bypasses fixed rows')
+em.classify = classify
+em.seed = function(category) return category == 'TALL_GRASS' and 123 or 456 end
+T.eq(em.fromCell(0, 0, MB.TALL_GRASS, 'route'), 123, 'replacement seed bypasses fixed rows')
+em.seed = seed
+T.eq(em.fromCell(0, 0, MB.TALL_GRASS, 'route'), 0x18, 'restoring extension functions restores dispatch')
+local Class=require('src.compat.gen1.CollisionClass')
+local a=Class.new('rse',{[16]=2});local b=Class.new('rse',{})
+T.eq(a.fromCell(0,0,16,'route'),0x29);T.eq(b.fromCell(0,0,16,'route'),0)
+b.setTileBits({[16]=2});T.eq(b.fromCell(0,0,16,'route'),0x29)
+a.setTileBits(nil);T.eq(a.fromCell(0,0,16,'route'),0);T.eq(b.fromCell(0,0,16,'route'),0x29,'contexts do not share flag state')
+T.finish('compatibility cell semantics')
diff --git a/tests/engine/gen3_safari_label.lua b/tests/engine/gen3_safari_label.lua
new file mode 100644
index 000000000..a733d25ee
--- /dev/null
+++ b/tests/engine/gen3_safari_label.lua
@@ -0,0 +1,12 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit');local B=require('src.battle.Gen3Battle');local F=require('src.render.Font')
+local draw,code,advance,width=F.draw,F.drawCode,F.advanceOf,F.width
+local glyphs={};F.draw=function(value)T.eq(value,'BAIT')end
+F.drawCode=function(n,x,y)glyphs[#glyphs+1]={n,x,y}end
+F.advanceOf=function()return 8 end;F.width=function()return 24 end
+T.eq(B.drawSafariLabel('{POKEBLOCK}',192,120),40,'native word fits the 48px action cell')
+T.same(glyphs,{{0x55,192,120},{0x56,200,120},{0x57,208,120},{0x58,216,120},{0x59,224,120}},
+  'original joined cartridge glyphs retain their order and advances')
+T.eq(B.drawSafariLabel('BAIT',192,120),24,'ordinary edition labels retain the host font path')
+F.draw,F.drawCode,F.advanceOf,F.width=draw,code,advance,width
+T.finish('Native Safari Pokeblock compound glyph width and ordinary label forwarding')
diff --git a/tests/engine/gen3_startup_map_aliases.lua b/tests/engine/gen3_startup_map_aliases.lua
new file mode 100644
index 000000000..8938ed6c8
--- /dev/null
+++ b/tests/engine/gen3_startup_map_aliases.lua
@@ -0,0 +1,38 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Version=require('src.core.GameVersion')
+local Data=require('src.core.Data')
+local Identity=require('src.compat.gen1.MapIdentity')
+local original=Version.get()
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Version.set(edition)
+ local data=T.fixtures.fresh()
+ data.maps={}
+ local frlg=Version.isFRLG()
+ local slots=frlg and{{4,1},{1,75}}or{{1,0},{0,0}}
+ for _,slot in ipairs(slots)do
+  local g,n=slot[1],slot[2];local id=('MAP_G%02d_N%02d'):format(g,n)
+  data.maps[id]={id=id,group=g,number=n,width=4,height=4,tileset='FIX_OUT',blocks={0},objects={}}
+ end
+ Data.seedDefaults(data)
+ local binding=Identity.bind(data.maps,edition)
+ for _,slot in ipairs(slots)do
+  local g,n=slot[1],slot[2];local id=('MAP_G%02d_N%02d'):format(g,n)
+  local canonical=assert(Identity.lookup(edition,g,n))
+  T.eq(binding:legacyId(id),canonical,'actual startup retains unambiguous ROM header')
+  T.eq(binding:nativeId(canonical),id,'source observations reach original native address')
+  local alias=id:gsub('([A-Z])(%d)','%1_%2')
+  T.eq(data.maps[alias],data.maps[id],'automatic normalized spelling shares actual header')
+  T.eq(data.maps[alias].id,id,'automatic alias preserves native storage identity')
+ end
+ if frlg then
+  T.eq(data.maps.LORELEIS_ROOM,data.maps.MAP_G01_N75,'story spelling shares physical header')
+  T.eq(data.maps.LORELEIS_ROOM.id,'MAP_G01_N75','story alias cannot change native address')
+ end
+ local id=('MAP_G%02d_N%02d'):format(slots[1][1],slots[1][2])
+ data.maps.FOREIGN=require('src.mods.Merge').deepCopy(data.maps[id])
+ T.eq(Identity.bind(data.maps,edition):legacyId(id),nil,'authored duplicate slots remain rejected')
+end
+Version.set(original)
+T.finish('GBA automatic startup aliases retain one physical map header')
diff --git a/tests/engine/native_action_observations.lua b/tests/engine/native_action_observations.lua
new file mode 100644
index 000000000..44a406e3d
--- /dev/null
+++ b/tests/engine/native_action_observations.lua
@@ -0,0 +1,149 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local B=require('src.core.game3.battle')
+local Plan=require('src.battle.Gen3ActionPlan')
+local Json=require('src.link.Json')
+local Version=require('src.core.GameVersion')
+local Probe=dofile('tests/native_action_plan/turn.lua')
+local open,close=Probe.open,Probe.close
+local function runNativeAction(b,row)
+ if b.runQueueAction then return b:runQueueAction(row)end
+ -- Earlier native owners invoke the same row in updateQueue itself.
+ table.insert(b.queue,1,row)
+ return b:updateQueue()
+end
+T.eq(B._actions,nil,'there is no invented action owner before battle admission')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f,b=open(edition)
+ local rolls={};b.rng=function(lo,hi)rolls[#rolls+1]={lo,hi};return lo or 0 end
+ b:resolveTurn(b.player.mon.moves[1])
+ local native=b._sourceActionPlan
+ local actions=assert(B._actions)
+ T.eq(#actions,#native.order,'observations follow the actual native turn order')
+ T.eq(#actions,2,'ordinary singles observe two actual action rows')
+ local first=actions[1]
+ T.eq(B._actions[1],first,'repeated queries retain action identity')
+ T.eq(first.kind,'move');T.eq(first.meta,false)
+ T.eq(first.move,'MOVE_033')
+ T.eq(require('src.core.game3.battle.moves').get(first.move).numId,33,'move identity uses the native imported catalog')
+ T.eq(first.user,native.order[1][1]==b.player and'player'or'enemy')
+ T.eq(first.target,native.order[1][2]==b.player and'player'or'enemy')
+ T.eq(first.order,1);T.eq(B._actionI,1,'cursor identifies the real first queue row')
+ local facts={};for key,value in pairs(first)do facts[key]=value end
+ T.same(facts,{kind='move',meta=false,move='MOVE_033',user=first.user,target=first.target,
+   userId=native.order[1][1].position,targetId=native.order[1][2].position,order=1},
+   'shared typed iteration exposes genuine action facts, including false values')
+ T.eq(next(first)~=nil,true,'shared typed next sees action records')
+ T.eq(native.rows[1],b.queue[1],'observation records reference the actual queued native fn')
+ T.eq(B._phase,b.phase,'observations do not advertise an unimplemented action phase')
+ local save=Json.encode(f.game.save);local frame,rollCount,queue=b.frame,#rolls,{}
+ for i,row in ipairs(b.queue)do queue[i]=row end
+ for _=1,40 do
+  T.eq(B._actionI,1);T.eq(B._actions[1],first);T.eq(first.move,'MOVE_033')
+ end
+ T.eq(Json.encode(f.game.save),save,'action queries do not write saves or party data')
+ T.eq(b.frame,frame,'action queries do not tick a battle')
+ T.eq(#rolls,rollCount,'action queries do not consume RNG')
+ T.same(b.queue,queue,'action queries preserve every native queue row')
+ actions[1]=nil
+ T.eq(B._actions[1],first,'mutating a detached order array cannot change native planning')
+ T.raises(function()first.move='OTHER'end,'read-only')
+ local row=table.remove(b.queue,1)
+ local Runtime=require('src.mods.Runtime');local emit=Runtime.emit;local observed=false
+ Runtime.emit=function(name,payload,...)
+  if name=='battle.move_used'and payload.battle==b then
+   observed=true
+   T.eq(B._actionI,1,'a removed but executing native fn still owns its action cursor')
+   T.eq(B._actions[1],first)
+  end
+  return emit(name,payload,...)
+ end
+ local ran,why=pcall(runNativeAction,b,row);Runtime.emit=emit;assert(ran,why)
+ T.eq(observed,true,'cursor is observed at the real native move-used producer')
+ T.eq(B._actionI,0,'presentation rows are not reported as an executing action')
+ local nextAction=native.rows[2]
+ table.insert(b.queue,1,{text='owned presentation row'})
+ T.eq(B._actionI,0,'an unrelated presentation row cannot invent action readiness')
+ b.queue={nextAction};T.eq(first.kind,nil,'replacing the native queue retires old observations')
+ b.queue=queue;T.eq(first.kind,nil,'restoring a queue cannot revive its retired observation')
+ close(f)
+ T.eq(first.kind,nil,'an exited native battle cannot retain action access')
+ T.same(require('src.compat.gen1.TableIteration').snapshot(first),{},'retired action iteration retains no native facts')
+end
+
+-- Compare complete native turns with and without observer registration.
+-- Actual HP, PP, every RNG call, frame count and phase sequence must agree.
+local plain,observed=Probe.turn('firered',false),Probe.turn('firered',true)
+if Json.encode(plain)~=Json.encode(observed)then
+ print('ACTION_TURN_LENGTHS',#plain.trace,#observed.trace,#plain.rolls,#observed.rolls)
+ for i=1,math.max(#plain.trace,#observed.trace)do
+  if Json.encode(plain.trace[i])~=Json.encode(observed.trace[i])then
+   print('FIRST_NATIVE_TURN_DIFFERENCE',i,Json.encode(plain.trace[i]),Json.encode(observed.trace[i]));break
+  end
+ end
+ for i=1,math.max(#plain.rolls,#observed.rolls)do
+  if Json.encode(plain.rolls[i])~=Json.encode(observed.rolls[i])then
+   print('FIRST_NATIVE_RNG_DIFFERENCE',i,Json.encode(plain.rolls[i]),Json.encode(observed.rolls[i]));break
+  end
+ end
+end
+T.same(plain,observed,'observation registration preserves complete native HP/PP/RNG/order/frame behavior')
+for _,edition in ipairs{'leafgreen','ruby','sapphire','emerald'}do
+ T.same(Probe.turn(edition,false),Probe.turn(edition,true),edition..' preserves complete native HP/PP/RNG/order/frame behavior')
+end
+
+for _,key in ipairs{'data','save','mods','stack','edition'}do
+ local f,b=open('emerald');b:resolveTurn(b.player.mon.moves[1]);local view=B._actions[1]
+ local old
+ if key=='edition'then old=Version.get();Version.set('firered')
+ else old=f.game[key];f.game[key]={}end
+ T.eq(view.kind,nil,key..' replacement retires action observations')
+ if key=='edition'then Version.set(old)else f.game[key]=old end
+ T.eq(view.kind,nil,key..' restoration cannot resurrect the old action owner')
+ close(f)
+end
+do
+ local f,b=open('emerald');f.game.mods=nil
+ b:resolveTurn(b.player.mon.moves[1]);local view=B._actions[1]
+ f.game.mods=false
+ T.eq(view.kind,nil,'an absent loader and a false loader are distinct cohorts')
+ f.game.mods=nil
+ T.eq(view.kind,nil,'an absent loader cannot revive the previous cohort')
+ close(f)
+end
+do
+ local f,b=open('emerald');b:resolveTurn(b.player.mon.moves[1]);local old=B._actions[1]
+ B._service.release()
+ T.eq(old.kind,nil,'source admission retirement invalidates the old action record')
+ T.neq(B._actions[1],old,'a new source admission owns fresh action views')
+ local row=table.remove(b.queue,1);local calls=0
+ row.fn=function()calls=calls+1;error('owned native action failure')end
+ T.raises(function()runNativeAction(b,row)end,'owned native action failure')
+ T.eq(calls,1);T.eq(B._actions,nil,'a failed native action leaves no executing observation')
+ close(f)
+end
+do
+ local f,b=open('firered');b:resolveTurn(b.player.mon.moves[1]);local view=B._actions[1]
+ local row=b.queue[1];local fn=row.fn
+ row.fn=function()end
+ T.eq(view.kind,nil,'replacing a pending native callback retires its provenance')
+ row.fn=fn
+ T.eq(view.kind,nil,'restoring a callback cannot revive its retired provenance')
+ close(f)
+end
+do
+ local f,b=open('firered');local act=b.act
+ b.act=function(self,fn)act(self,function()return fn()end)end
+ b:resolveTurn(b.player.mon.moves[1])
+ T.eq(#b.queue,3,'a native act wrapper retains both action rows and end-of-turn')
+ T.eq(B._actions,nil,'a replaced native callback cannot be mislabelled as a verified action')
+ T.eq(B._actionI,0,'unknown callback provenance cannot invent an action cursor')
+ close(f)
+end
+Version.set('gold')
+local sentinel={};local other={_sourceActionPlan=sentinel}
+T.eq(Plan.begin(other,{}),nil,'Gen2 never constructs a GBA action ledger')
+T.eq(other._sourceActionPlan,sentinel,'Gen2 native state remains untouched')
+T.eq(package.loaded['src.core.game3.battle.engine'],nil,'read-only facts do not install a resolver stub')
+T.eq(package.loaded['src.core.game3.battle.anim_seq'],nil,'read-only facts do not install a sequence stub')
+T.finish('Native action order, queue identity, pure observations and unchanged default turn execution')
diff --git a/tests/engine/native_action_presentation.lua b/tests/engine/native_action_presentation.lua
new file mode 100644
index 000000000..29dc884d4
--- /dev/null
+++ b/tests/engine/native_action_presentation.lua
@@ -0,0 +1,133 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Battle=require('src.core.game3.battle')
+local Seq=require('src.core.game3.battle.anim_seq')
+local Plan=require('src.battle.Gen3ActionPlan')
+local Probe=dofile('tests/native_action_plan/turn.lua')
+local Json=require('src.link.Json')
+local base=Seq.begin
+local function run(b)
+ local row=table.remove(b.queue,1)
+ if b.runQueueAction then return b:runQueueAction(row)end
+ table.insert(b.queue,1,row);return b:updateQueue()
+end
+local function prepared(edition)
+ local f,b=Probe.open(edition);b:resolveTurn(b.player.mon.moves[1]);return f,b
+end
+T.eq(base({events={}}),false,'no native action can be invented between phases')
+for _,edition in ipairs{'firered','leafgreen','ruby','sapphire','emerald'}do
+ local f,b=prepared(edition)
+ local before,after,kept,seen,retired,rows
+ Seq.begin=function(meta)
+  seen=meta.events;rows={};for i,row in ipairs(b.queue)do rows[i]=row end
+  before={hp=b.enemy.mon.hp,pp=b.player.mon.moves[1].pp,frame=b.frame}
+  local copy={events={}};kept={}
+  local used,moves=0,0
+  for _,e in ipairs(meta.events)do
+   if e.kind=='move'then moves=moves+1;T.eq(e.move,'MOVE_033')
+   elseif e.kind=='msg'and Seq.isMoveUsedId(e.id)then used=used+1;T.neq(e.text,nil)
+   else copy.events[#copy.events+1]=e;kept[#kept+1]=e end
+  end
+  T.eq(used,1,'actual native used-message producer is typed once')
+  T.eq(moves,1,'actual native animation row is typed once')
+  T.raises(function()meta.events[1].kind='move'end,'read-only')
+  T.eq(base(copy),true);T.eq(base({events={}}),true,'duplicate base call cannot amend its first request')
+  T.same(b.queue,rows,'no filtering commits before decorators finish')
+  after={hp=b.enemy.mon.hp,pp=b.player.mon.moves[1].pp,frame=b.frame}
+  retired=meta.events[1]
+ end
+ run(b)
+ T.same(before,after,'presentation filtering cannot resolve damage, PP or frames')
+ local remaining={};for _,row in ipairs(b.queue)do remaining[row]=true end
+ for _,row in ipairs(rows)do
+  local removed=not remaining[row]
+  if removed then T.eq(row.fn,nil);T.eq(row.ui,nil);T.eq(row.drain,nil);T.eq(row.exp,nil)end
+ end
+ T.eq(#rows-#b.queue,2,'only native move animation and used-message rows are removed')
+ T.eq(retired.kind,nil,'events cannot retain an expired native action admission')
+ T.same(require('src.compat.gen1.TableIteration').snapshot(retired),{})
+ T.eq(base({events=seen}),false,'retained events cannot request another presentation')
+ Seq.begin=base;Probe.close(f)
+end
+
+-- Real complete native turns compare observation-only/no-op sequence behavior.
+for _,edition in ipairs{'firered','leafgreen','ruby','sapphire','emerald'}do
+ package.loaded['src.core.game3.battle.anim_seq']=nil
+ local expected=Probe.turn(edition,true)
+ package.loaded['src.core.game3.battle.anim_seq']=Seq
+ Seq.begin=base;T.same(Probe.turn(edition,true),expected,'default sequence preserves native full-turn HP/PP/RNG/frame trace')
+ Seq.begin=function(meta)return base(meta)end
+ T.same(Probe.turn(edition,true),expected,'no-op sequence decorator preserves native full-turn HP/PP/RNG/frame trace')
+ Seq.begin=base
+end
+
+for _,mode in ipairs{'foreign','reorder','duplicate','mandatory','throw-before','throw-after','row-change','covered','save-change'}do
+ local f,b=prepared('emerald');local original,events
+ Seq.begin=function(meta)
+  original={};for i,row in ipairs(b.queue)do original[i]=row end;events=meta.events
+  if mode=='foreign'then return base({events={{kind='move'}}})
+  elseif mode=='reorder'then local a={};for i=#meta.events,1,-1 do a[#a+1]=meta.events[i]end;return base({events=a})
+  elseif mode=='duplicate'then return base({events={meta.events[1],meta.events[1]}})
+  elseif mode=='mandatory'then return base({events={}})
+  elseif mode=='throw-before'then error('before animation request')
+  elseif mode=='throw-after'then base(meta);error('after animation request')
+  elseif mode=='row-change'then b.queue[1].fn=function()end;return base(meta)
+  elseif mode=='covered'then f.game.stack:push({});return base(meta)
+  elseif mode=='save-change'then f.game.save={};return base(meta)end
+ end
+ local ok=pcall(run,b);T.eq(ok,false,mode..' rejects invalid presentation admission')
+ T.same(b.queue,original,mode..' cannot delete native queue rows')
+ T.eq(events[1].kind,nil,mode..' retires retained event permissions')
+ T.eq(b._sourceActionPlan,nil,mode..' cannot leave an executing action observation')
+ Seq.begin=base;Probe.close(f)
+end
+
+-- Rows carrying another native protocol keep their place even if tagged.
+do
+ local f,b=prepared('emerald');local observed
+ Seq.begin=function(meta)
+  observed=meta.events
+  for _,event in ipairs(meta.events)do T.eq(event.kind,'native','foreign gameplay payload cannot become a removable move')end
+  return base(meta)
+ end
+ local row={anim='MOVE_033',fn=function()end};Seq._nativeMove(row)
+ local count=0;Seq._nativeAction(b,{},function()count=count+1;table.insert(b.queue,1,row)end)
+ T.eq(count,1);T.eq(b.queue[1],row);T.eq(observed[1].kind,nil)
+ Seq.begin=base;Probe.close(f)
+end
+-- Localization/lookalike text does not grant native announcement provenance.
+do
+ local f,b=prepared('emerald');local observed
+ Seq.begin=function(meta)
+  observed=meta.events;T.eq(meta.events[1].kind,'native')
+  T.raises(function()base({events={}})end,'cannot be removed')
+  return base(meta)
+ end
+ local text='CHARMANDER\nused TACKLE!'
+ Seq._nativeAction(b,{},function()b:sayNext(text)end)
+ T.eq(b.queue[1].text,text);T.eq(observed[1].kind,nil)
+ Seq.begin=base;Probe.close(f)
+end
+-- Callback attribution is restored; native failures never replay a move.
+do
+ local f,b=prepared('emerald');local G=require('src.core.Game3')
+ local seams=require('src.mods.ModSeams');local owner=G._callbackOwner()
+ Seq.begin=function(meta)T.eq(G._callbackOwner(),'animation_owner');return base(meta)end
+ seams._journal[#seams._journal+1]={tbl=Seq,key='begin',after=Seq.begin,owner='animation_owner'}
+ run(b);T.eq(G._callbackOwner(),owner);table.remove(seams._journal)
+ local calls=0
+ T.raises(function()Seq._nativeAction(b,{},function()calls=calls+1;error('native action failure')end)end,'native action failure')
+ T.eq(calls,1);T.eq(G._callbackOwner(),owner)
+ Seq.begin=base;Probe.close(f)
+end
+-- Another generation keeps its direct action call and never borrows this API.
+do
+ require('src.core.GameVersion').set('gold')
+ local called,decorated=0,0
+ Seq.begin=function()decorated=decorated+1 end
+ Plan.run({}, {fn=function()called=called+1 end})
+ T.eq(called,1);T.eq(decorated,0)
+ Seq.begin=base
+end
+T.eq(Plan.cursor(nil),0)
+T.finish('Actual native animation row provenance, restricted presentation filtering and default combat invariance')
diff --git a/tests/engine/native_actor_presentation_gc.lua b/tests/engine/native_actor_presentation_gc.lua
new file mode 100644
index 000000000..7e038054c
--- /dev/null
+++ b/tests/engine/native_actor_presentation_gc.lua
@@ -0,0 +1,57 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Objects=require('src.core.game3.objects')
+local Actors=require('src.compat.gen1.SourceActors')
+local Optional=require('src.world.OptionalFollower')
+local Host=require('src.mods.Runtime')
+local Stream=require('src.core.game3.asset_stream')
+local G=require('src.core.Game3')
+local previousHooks=Host.hooks
+local function gc()collectgarbage('collect');collectgarbage('collect')end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Objects.release();G.release();Actors.release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g,w,p=f.game,f.world,f.player
+ w.npcs={};w.entities={p};g.mods.mods={gc_owner={enabled=true},peer={enabled=true}}
+ Host.hooks=require('src.mods.Hooks').new()
+ Host.hooks:wrap('world.follower.spawn',function()return true end,0,'gc_owner')
+ Optional.onMapEntered(g,w,nil,true)
+ local npc=assert(Optional.current(w),'native follower admission failed');local nativeDraws,customDraws=0,0
+ npc.sprite={draw=function()nativeDraws=nativeDraws+1 end}
+ Host.currentMod='gc_owner'
+ do local view=Objects.find(250);view.sprite=nil end
+ Host.currentMod=nil;gc()
+ local sprite,overridden=Actors.renderer(npc)
+ T.eq(sprite,nil);T.eq(overridden,true,'an owned absent renderer survives view collection')
+ npc:draw(0,0);T.eq(nativeDraws,0,'native fallback artwork cannot reappear after GC')
+ local watched=setmetatable({},{__mode='v'})
+ Host.currentMod='gc_owner'
+ do
+  local view=Objects.find(250);local renderer={draw=function()customDraws=customDraws+1 end}
+  watched[1]=renderer;view.sprite=renderer
+ end
+ Host.currentMod=nil;gc()
+ T.check(watched[1]~=nil,'an installed renderer remains owned without a retained view')
+ npc:draw(0,0);T.eq(customDraws,1)
+ Stream.cancelOwner('peer');gc();npc:draw(0,0);T.eq(customDraws,2,'foreign teardown cannot retire the renderer')
+ Stream.cancelOwner('gc_owner');gc()
+ T.eq(watched[1],nil,'owner teardown releases installed artwork')
+ npc:draw(0,0);T.eq(nativeDraws,1,'owner teardown restores native artwork')
+ -- Removing a native actor or retiring its dataset releases its lease too.
+ Host.currentMod='gc_owner'
+ do local v=Objects.find(250);local r={draw=function()end};watched[1]=r;v.sprite=r end
+ Host.currentMod=nil;gc()
+ w.npcs={};w.entities={p}
+ T.eq(type(Actors.poll),'function')
+ if Actors.poll then Actors.poll()end
+ gc();T.eq(watched[1],nil,'removed native actors release presentation without a draw')
+ local _,active=Actors.renderer(npc);T.eq(active,false)
+ w.npcs={npc};w.entities={p,npc};Host.currentMod='gc_owner'
+ do local v=Objects.find(250);local r={draw=function()end};watched[1]=r;v.sprite=r end
+ Host.currentMod=nil;gc();g.save={player={}}
+ if Actors.poll then Actors.poll()end
+ gc();T.eq(watched[1],nil,'a replaced save retires the previous presentation cohort')
+ Objects.release();Actors.release();G.release()
+end
+Host.hooks=previousHooks
+T.finish('owned native actor presentation survives GC and retires with its cohort')
diff --git a/tests/engine/native_animation_update_hooks.lua b/tests/engine/native_animation_update_hooks.lua
new file mode 100644
index 000000000..c9fa4eb7c
--- /dev/null
+++ b/tests/engine/native_animation_update_hooks.lua
@@ -0,0 +1,63 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local A=require('src.core.game3.battle.anim')
+local Battle=require('src.core.game3.battle')
+local Clock=require('src.battle.PresentationClock')
+local G=require('src.core.Game3')
+local Seams=require('src.mods.ModSeams')
+local baseAnimation,baseBattle=A.update,Battle.update
+local original=package.loaded['src.core.Game']
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local function run(mode)
+  A.update=baseAnimation;Battle.update=baseBattle
+  local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+  package.loaded['src.core.Game']=game
+  local b=f.fresh('TACKLE').battle;b.enter=false;b:syncSides();game.stack:push(b)
+  b.phase='messages';b.queue={};b.current=nil;b.waitFrames=0
+  local commands,callbacks,age,rolls=0,0,0,0;b.rng=function()rolls=rolls+1;return 1 end
+  b:act(function()commands=commands+1 end);b.queue[#b.queue+1]={wait=3};b:act(function()commands=commands+1 end)
+  local decorator=function(dt)
+   callbacks=callbacks+1;age=age+dt
+   T.eq(dt,1/60,'native delta reaches decorations');T.eq(G._callbackOwner(),'qa_animation_owner')
+   T.eq(baseAnimation(999),true);T.eq(baseAnimation(-999),true)
+   return nil,7,nil
+  end
+  if mode~='baseline'then
+   A.update=decorator
+   Seams._journal[#Seams._journal+1]={tbl=A,key='update',after=decorator,owner='qa_animation_owner'}
+  end
+  if mode=='explicit'then
+   Battle.update=function(dt)A.update(dt);return baseBattle(dt)end
+   Seams._journal[#Seams._journal+1]={tbl=Battle,key='update',after=Battle.update,owner='qa_animation_owner'}
+  end
+  local trace={}
+  for i=1,12 do
+   b:update(1/60)
+   trace[i]={frame=b.frame,phase=b.phase,wait=b.waitFrames,queue=#b.queue,commands=commands,
+    hp=b.player.mon.hp,shown=b.player.shownHP,enemyHP=b.enemy.mon.hp}
+   T.eq(Clock.active(b),false,'the native phase closes after every update')
+  end
+  if mode~='baseline'then
+   T.eq(callbacks,12,'one decoration per native update, including explicit source calls')
+   T.check(math.abs(age-12/60)<1e-9,'presentation age follows the actual native delta')
+   local frame=b.frame;local cover={};game.stack:push(cover);b:update(1/60)
+   T.eq(callbacks,12,'a covered native battle cannot notify decorations');T.eq(b.frame,frame);game.stack:pop()
+   -- Failure poisons the phase even if another caller catches the same base
+   -- failure. Another native tick is never consumed for a retry.
+   A.update=function()error('animation decoration failed')end
+   T.raises(function()b:update(1/60)end,'animation decoration failed')
+   T.eq(Clock.active(b),false);T.eq(b.frame,frame+(mode=='explicit'and 0 or 1))
+   if mode=='explicit'then table.remove(Seams._journal)end
+   table.remove(Seams._journal)
+  end
+  T.eq(rolls,0);A.update=baseAnimation;Battle.update=baseBattle
+  game.stack:pop();f.close();A.reset();Battle._service.release();G.release()
+  return trace
+ end
+ local baseline=run('baseline')
+ T.same(run('decoration'),baseline,'native commands/HP/timers match the undecorated owner')
+ T.same(run('explicit'),baseline,'an explicit source update cannot add another native step')
+end
+A.update=baseAnimation;Battle.update=baseBattle;package.loaded['src.core.Game']=original
+T.finish('native animation update decorators, native delta, once-only holds and failure/coverage fencing')
diff --git a/tests/engine/native_audio_source.lua b/tests/engine/native_audio_source.lua
new file mode 100644
index 000000000..fb026b4a4
--- /dev/null
+++ b/tests/engine/native_audio_source.lua
@@ -0,0 +1,57 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Audio=require('src.core.game3.audio')
+local Sound=require('src.core.Sound')
+local Stream=require('src.core.game3.asset_stream')
+local Host=require('src.mods.Runtime')
+local function nativePlay(data,id)
+ if Sound.waitSe then return Sound.playSe(data,id)end
+ return Sound.playNamedEffect(data,id)
+end
+local previous=love.audio
+love.audio={newSource=function()
+ local s={playing=false,volume=.8}
+ function s:play()self.playing=true end
+ function s:stop()self.playing=false end
+ function s:isPlaying()return self.playing end
+ function s:setVolume(v)self.volume=v end
+ function s:getVolume()return self.volume end
+ return s
+end}
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();Sound.invalidate();require('src.core.Game3').release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g=f.game
+ g.data.audio={sfx={SE_OWNED='synthetic.wav'},songs={SONG_001={index=1,sfxName='SE_OWNED',file='synthetic.wav',player=1}}}
+ g.save.options.sfxVol=7;Sound.setVolumeLevel(7)
+ Host.currentMod='audio_owner';T.eq(Audio.isReady(),true)
+ T.eq(Audio.playSe('SE_OWNED',{sourceVolume=.25}),true)
+ local src=Audio._seSources[1];T.eq(src:getVolume(),.25);T.eq(Audio._seMeta[src].id,1)
+ T.eq(Audio.isSePlaying(1),true);T.eq(Audio.playSe(1,{sourceVolume=2}),false)
+ Host.currentMod='peer';T.eq(Audio.stopSe(1),0);Stream.cancelOwner('peer');T.eq(src:isPlaying(),true)
+ Host.currentMod='audio_owner'
+ local foreign=nativePlay(g.data,1);T.neq(foreign,src,'borrowed effects use a native cache variant instead of changing a foreign voice')
+ T.eq(foreign:getVolume(),.8,'foreign playback keeps the native gain')
+ T.eq(Audio.stopSe(1),1);T.eq(foreign:isPlaying(),true,'ending a borrowed effect cannot stop a native voice')
+ T.eq(Audio.playSe(1),true);T.eq(src:getVolume(),.8,'a fresh borrowed playback restores native gain');T.eq(Audio.stopSe('UNKNOWN'),0);T.eq(src:isPlaying(),true)
+ Host.currentMod='peer';T.eq(Audio.playSe(1),true)
+ local peer=Audio._seSources[1];for _,v in ipairs(Audio._seSources)do if v~=src then peer=v end end
+ collectgarbage('collect');Stream.cancelOwner('audio_owner');T.eq(peer:isPlaying(),true,'foreign playback survives the previous owner unload')
+ Stream.cancelOwner('peer');T.eq(peer:isPlaying(),false);T.eq(#Audio._seSources,0)
+ Host.currentMod='audio_owner';T.eq(Audio.playSe(1),true)
+ local update=Sound.update;local clocks=0;Sound.update=function()clocks=clocks+1 end
+ Audio.update(1/60);Audio.update(1/60);T.eq(clocks,0,'source update does not advance the native audio clock twice');Sound.update=update
+ g.save={};Stream.poll();T.eq(src:isPlaying(),false,'replacing the session retires its borrowed playback')
+ T.eq(#Audio._seSources,0)
+ local first,later,laterSource
+ first=select(2,Sound.borrowEffect('same_owner',function()
+  local v=nativePlay(g.data,1)
+  laterSource,later=Sound.borrowEffect('same_owner',nativePlay,g.data,1)
+  return v
+ end))
+ T.eq(first.valid(),false,'a reentrant replay revokes the earlier borrowed playback')
+ T.eq(first.stop(),false);T.eq(later.valid(),true);T.eq(laterSource:isPlaying(),true);T.eq(later.stop(),true)
+ Sound.invalidate();Stream.shutdown();require('src.core.Game3').release();Host.currentMod=nil
+end
+love.audio=previous
+T.finish('source audio uses revocable native playback leases without a second sound clock')
diff --git a/tests/engine/native_ball_presentation.lua b/tests/engine/native_ball_presentation.lua
new file mode 100644
index 000000000..616fda47a
--- /dev/null
+++ b/tests/engine/native_ball_presentation.lua
@@ -0,0 +1,64 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Battle=require('src.core.game3.battle')
+local Ball=require('src.core.game3.battle.ball_open')
+local Native=require('src.battle.Gen3Battle')
+local Timeline=require('src.battle.Gen3BallAnim')
+local originalGame=package.loaded['src.core.Game']
+local G=require('src.core.Game3');local base=Ball.draw
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local c=game.data.constants;c.itemOrder={[4]='BALL_KEY'};game.data.items.BALL_KEY={index=4}
+ c.gen3BallAnim={timing={},balls={[4]={colour={255,66,0}}},itemToBall={[4]=3}}
+ T.eq(Ball.ballIdForItem(4),3);T.eq(Ball.ballIdForItem('BALL_KEY'),3)
+ T.eq(Ball.ballIdForItem(9),nil,'unknown cartridge items cannot choose a guessed ball')
+ T.eq(base(),false,'a source painter cannot invent a battle')
+ local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b)
+ local anim=Timeline.new(game.data,{ball=3,battler=b.player,sendOut='player'})
+ b.gen3Ball=anim;b.gen3BallPlaying=true;anim.monBlend=.5
+ local t,r,g,blue=Ball.monBlend('player');T.eq(t,8);T.eq(r,31);T.eq(g,66*31/255);T.eq(blue,0)
+ T.eq(Ball.monBlend(1),0,'the native send-out never tints the other actor')
+ local frame,ballFrame=b.frame,anim.frame
+ for i=1,8 do Ball.monBlend(0);Ball.bgCoeff()end
+ T.eq(b.frame,frame);T.eq(anim.frame,ballFrame,'observation cannot advance the native ball clock')
+ T.eq(Ball.bgCoeff(),0)
+ local move=require('src.battle.Gen3MoveAnim')
+ b.gen3Anim=setmetatable({whiteout={at=0},frame=0},{__index=move});b.gen3AnimPlaying=true
+ T.eq(Ball.bgCoeff(),16,'background coefficient reads the existing native flash timeline')
+ b.gen3Anim.frame=10;local white=b.gen3Anim:flashState();T.eq(Ball.bgCoeff(),white*16)
+ b.gen3AnimPlaying=false;T.eq(Ball.bgCoeff(),0)
+ local calls,wrappers=0,0
+ Ball.draw=function()wrappers=wrappers+1;base();base();return false,nil,'native ball result'end
+ local a,middle,z=Ball._nativeDraw(b,function(owner)T.eq(owner,b);calls=calls+1;return true end)
+ T.eq(calls,1);T.eq(wrappers,1);T.eq(a,false);T.eq(middle,nil);T.eq(z,'native ball result')
+ T.eq(anim.frame,ballFrame);T.eq(b.frame,frame)
+ local depth=love.graphics.getStackDepth and love.graphics.getStackDepth()
+ Ball.draw=function()love.graphics.push();error('ball source error')end
+ T.raises(function()Ball._nativeDraw(b,function()end)end,'ball source error')
+ if depth then T.eq(love.graphics.getStackDepth(),depth)end
+ Ball.draw=function()local ok=pcall(base);T.eq(ok,false);return true end
+ T.raises(function()Ball._nativeDraw(b,function()error('ball native error')end)end,'ball native error')
+ local paints=0
+ Ball.draw=function()game.stack:push({});local a,why=base();game.stack:pop();return a,why end
+ local painted,why=Ball._nativeDraw(b,function()paints=paints+1 end)
+ T.eq(painted,false);T.eq(why,'native ball presentation admission changed');T.eq(paints,0,'a new covering owner cannot consume the old resolved painter')
+ local seams=require('src.mods.ModSeams');local previous=G._callbackOwner()
+ Ball.draw=function()T.eq(G._callbackOwner(),'ball_owner');return base()end
+ seams._journal[#seams._journal+1]={tbl=Ball,key='draw',after=Ball.draw,owner='ball_owner'}
+ Ball._nativeDraw(b,function()return true end);T.eq(G._callbackOwner(),previous);table.remove(seams._journal)
+ Ball.draw=base
+ -- Exercise the real native dispatch, including ordinary callers retaining
+ -- the actual painter when no source replacement is installed.
+ anim.whiteout=1;anim.shinyStars=nil;anim.particles=nil;anim.stars=nil
+ Native.drawBall(b);T.eq(anim.frame,ballFrame)
+ b.gen3Ball=nil;T.eq(Ball.monBlend(0),0);b.gen3Anim=nil
+ game.stack:pop();Battle._service.release();f.close();G.release();Ball._service.release()
+end
+local graphics=love.graphics;local before=graphics.getShader()
+T.eq(Ball.setBlendShader(nil),false);T.eq(Ball.setBlendShader(0),false);T.eq(graphics.getShader(),before)
+T.raises(function()Ball.setBlendShader(0/0,0,0,0)end,'invalid native palette blend coefficient')
+T.raises(function()Ball.setBlendShader(1,math.huge,0,0)end,'invalid native palette blend color')
+package.loaded['src.core.Game']=originalGame
+T.finish('native ball timeline observations, once-only painter, callback scope and item identities')
diff --git a/tests/engine/native_battle_animation.lua b/tests/engine/native_battle_animation.lua
new file mode 100644
index 000000000..f7d3c2172
--- /dev/null
+++ b/tests/engine/native_battle_animation.lua
@@ -0,0 +1,137 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Battle=require('src.core.game3.battle')
+local A=require('src.core.game3.battle.anim')
+local C=A.Coords
+local Clock=require('src.battle.PresentationClock')
+local base=Battle.update
+T.eq(A.update(1/60),false,'standalone callers cannot start an animation clock')
+T.eq(A.launchMove(33),false);T.eq(A.present(0),nil)
+local unpack=table.unpack or unpack
+local function pack(...)return{n=select('#',...),...}end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  A.reset();Battle._service.release()
+  local f=require('tools.battle-source-runtime.fixture').new(edition)
+  local game=f.game;package.loaded['src.core.Game']=game
+  game.data.constants.gen3BattleAnimGfx={}
+  game.data.moves.MOVE_033.anim={duration=4,shakes={{at=0,duration=4,x=2,y=1}}}
+  local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b);b.phase='QA_IDLE'
+  local st=Battle.getState();local p=A.present(0)
+  T.eq(A.present('player'),p);T.eq(p.displayHp,400);T.eq(p.displayMaxHp,400)
+  T.eq(p.id,0);T.eq(p.side,'player');T.eq(A.present(2),nil)
+  T.raises(function()p.id=1 end,'read-only')
+  T.raises(function()p.alpha=0/0 end,'invalid presentation')
+  C.setDouble(true);T.eq(C.isDouble(),true);C.setDouble(nil);T.eq(C.isDouble(),false)
+  C.bind(2,3);T.eq(C.idOf('player'),2);T.eq(C.idOf('enemy'),3)
+  local got=pack(C.withBattler(0,function(side,a,z)T.eq(side,'player');T.eq(C.idOf(side),0);return a,z,nil end,7,8))
+  T.eq(got.n,3);T.eq(got[1],7);T.eq(got[2],8)
+  T.eq(C.idOf('player'),2,'nested binding is restored including trailing nils')
+  T.raises(function()C.withBattler(0,function()error('binding failure')end)end,'binding failure')
+  T.eq(C.idOf('player'),2)
+  local arg=C.sideArg(function(a,side,z)T.eq(a,4);T.eq(side,'enemy');T.eq(C.idOf(side),3);T.eq(z,nil);return true,nil end,2)
+  T.eq(pack(arg(4,3,nil)).n,2);C.bind(nil)
+  T.same(C.monDrawOrder(st),{1,0});T.eq(C.subpriority(0),30)
+  T.eq(C.bgPriorityRank(3),2);T.eq(C.monBehindZ(0),195)
+  T.same(pack(C.particleBand(2)),{n=2,201,999})
+  game.data.constants.gen3BattlerCoords={singles={{x=73,y=81},{x=177,y=41}}}
+  local x,y=A.battlerCenter(0);T.eq(x,73);T.eq(y,81,'authored anchors use the admitted cartridge table')
+  local override={[0]={x=25,y=27}}
+  T.eq(C.setCoordinateOverrides(override),nil);T.eq(C.coords(nil,0),override[0]);C.setCoordinateOverrides(nil)
+  local poseFrames,poseDt=0
+  b.player.picAnim={update=function(_,dt)poseFrames=poseFrames+1;poseDt=dt end}
+  local done=0
+  T.eq(A.launchMove(33,{attackerId=0,targetId=1,onEnd=function()done=done+1 end}),true)
+  T.eq(A.launchMove(33),false,'an active native clip cannot be overwritten')
+  T.eq(b.gen3Anim.attackerPosition,0);T.eq(b.gen3Anim.targetPosition,1)
+  local ball=require('src.battle.Gen3BallAnim').new(game.data,{sendOut='opponent',battler=b.enemy})
+  b.gen3Ball,b.gen3BallPlaying=ball,true
+  b.waitFrames=3;b.queue={{fn=function()error('held battle command executed')end}}
+  local frames=b.frame
+  local stepped,completed=0,0
+  A.tweenStage(2,function(u,t)stepped=stepped+1;p.ox=12*u;T.eq(t.frames,stepped)end,function()completed=completed+1 end)
+  Battle.update=function(dt)
+    T.eq(A.update(999),true);T.eq(A.update(-999),true)
+    base(dt);return base(dt)
+  end
+  b:update(1/60)
+  T.eq(b.frame,frames+1);T.eq(b.gen3Anim.frame,1);T.eq(ball.frame,1)
+  T.eq(poseFrames,1);T.eq(poseDt,1/60,'a source argument cannot replace the native dt')
+  T.eq(b.waitFrames,3,'a source clip owns its own hold');T.eq(#b.queue,1);T.eq(stepped,1);T.eq(completed,0)
+  T.eq(p.ox,6);T.eq(A.battlerCenter(0),79)
+  Battle.update=function()return A.update(0)end
+  b:update(1/60)
+  T.eq(b.frame,frames+2);T.eq(b.gen3Anim.frame,2);T.eq(b.waitFrames,3)
+  T.eq(stepped,2);T.eq(completed,1);T.eq(#b.queue,1,'a source ending hold advances display without combat')
+  for i=1,300 do if not b.gen3AnimPlaying then break end;b:update(1/60)end
+  T.eq(b.gen3AnimPlaying,false);T.eq(done,1,'source completion follows the real native clip')
+  for i=1,3 do b:update(1/60)end;T.eq(b.waitFrames,0)
+  b.player.mon.hp=380;b.player.shownHP=400;b.draining=true
+  b:update(1/60)
+  local shown=b.player.shownHP;T.check(shown<400);T.eq(b.player.mon.hp,380,'display never applies damage')
+  T.eq(A.displayHpRatio(0),shown/400);T.eq(A.hpTweening(),true)
+  local heldFrame=b.frame;local overlay={};game.stack:push(overlay)
+  T.eq(A.update(1/60),false);T.eq(b:update(1/60),false)
+  T.eq(b.frame,heldFrame);T.eq(b.player.shownHP,shown);game.stack:pop()
+  -- Retire through a real session replacement; neither old poses nor queued
+  -- callbacks may write to the new admission, even if a save is restored.
+  local stale=p;local cancelled=0
+  A.tweenStage(1,function()cancelled=cancelled+1 end)
+  local save=game.save;game.save={};T.neq(A.present(0),stale,'a replacement save creates a new presentation identity');game.save=save
+  T.raises(function()stale.ox=10 end,'retired')
+  b:update(1/60);T.eq(cancelled,0);T.neq(A.present(0),stale)
+  b.player.picAnim=nil;Battle.update=base
+  game.stack.states={};f.close();A._service.poll()
+  local function nativeTrace(enabled)
+    package.loaded['src.core.game3.battle.anim']=enabled and A or nil
+    local fixture=require('tools.battle-source-runtime.fixture').new(edition)
+    local g=fixture.game;package.loaded['src.core.Game']=g
+    g.data.constants.gen3BattleAnimGfx={}
+    g.data.moves.MOVE_033.anim={duration=4,shakes={{at=0,duration=4,x=2,y=1}}}
+    local state=fixture.fresh('TACKLE').battle;state.enter=false;g.stack:push(state)
+    state.player.shownHP,state.enemy.shownHP=400,400
+    state.phase='messages';state.current=nil
+    state.queue={{fn=function()
+      local s=state
+      s.gen3Anim:start('MOVE_033',true,0,1,nil,s);s.gen3AnimPlaying=true
+      s.waitFrames=s.gen3Anim.total
+    end},{fn=function()
+      local s=state
+      s.enemy.mon.hp=370;s.enemy.shownHP=400;s.draining=true
+    end},{fn=function()
+      local s=state
+      s.gen3Ball=require('src.battle.Gen3BallAnim').new(g.data,{sendOut='opponent',battler=s.enemy})
+      s.gen3BallPlaying=true;s.waitFrames=80
+    end}}
+    local trace={}
+    for frame=1,180 do
+      state:update(1/60)
+      trace[frame]={frame=state.frame,phase=state.phase,queue=#state.queue,wait=state.waitFrames,
+        hp=state.enemy.mon.hp,shown=state.enemy.shownHP,draining=state.draining,
+        anim=state.gen3Anim.frame,playing=state.gen3AnimPlaying,
+        ball=state.gen3Ball and state.gen3Ball.frame,ballPlaying=state.gen3BallPlaying}
+    end
+    g.stack.states={};fixture.close();Battle._service.release();A.reset()
+    return trace
+  end
+  local baseline=nativeTrace(false);local adapted=nativeTrace(true)
+  for frame=1,#baseline do
+    local different=false
+    for key,value in pairs(baseline[frame])do if adapted[frame][key]~=value then different=true end end
+    for key,value in pairs(adapted[frame])do if baseline[frame][key]~=value then different=true end end
+    if different then print('FIRST_NATIVE_TRACE_DIFFERENCE',edition,frame,
+      require('src.link.Json').encode(baseline[frame]),require('src.link.Json').encode(adapted[frame]));break end
+  end
+  T.same(adapted,baseline,'an imported animation namespace preserves native queue timing '..edition)
+end
+Battle.update=base;A.reset();Battle._service.release()
+-- Failed native work remains failed throughout its phase; a source wrapper
+-- cannot swallow it and retry. The next real frame can recover normally.
+local screen={};local attempts=0
+T.raises(function()Clock.run(screen,1/60,function()
+  local function fail()attempts=attempts+1;error('display failure')end
+  pcall(Clock.once,screen,'fx',fail);pcall(Clock.once,screen,'fx',fail)
+end)end,'display failure')
+T.eq(attempts,1);T.eq(Clock.active(screen),false)
+T.eq(Clock.run(screen,1/60,function()return Clock.once(screen,'fx',function()return true,nil,4 end)end),true)
+T.finish('native battle animation ownership')
diff --git a/tests/engine/native_battle_ball_art.lua b/tests/engine/native_battle_ball_art.lua
new file mode 100644
index 000000000..054a5edfe
--- /dev/null
+++ b/tests/engine/native_battle_ball_art.lua
@@ -0,0 +1,62 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Ui=require('src.core.game3.battle.ui')
+local Art=require('src.core.game3.battle.ui_ball_art')
+local Battle=require('src.core.game3.battle')
+local G=require('src.core.Game3')
+local originalGame=package.loaded['src.core.Game']
+local graphics=love.graphics;local image,quad=graphics.newImage,graphics.newQuad
+local images,quads={},{}
+graphics.newImage=function(path)
+ local value={path=path,releases=0,getDimensions=function()return 48,192 end}
+ function value:release()self.releases=self.releases+1 end
+ images[#images+1]=value;return value
+end
+graphics.newQuad=function(...)
+ local value={cell={...},releases=0}
+ function value:release()self.releases=self.releases+1 end
+ quads[#quads+1]=value;return value
+end
+T.eq(Ui.ballQuad(0,0),nil,'no artwork without an admitted battle')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ package.loaded['src.core.Game']=f.game
+ local b=f.fresh('TACKLE').battle;b.enter=false;f.game.stack:push(b)
+ f.game.data.constants.gen3BallAnim={size=16,frames=3,images={balls='assets/generated/battle/gen3/balls.png'}}
+ local beforeImage,beforeQuad=#images,#quads
+ local frame=b.frame;local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ local first,firstQuad
+ for ball=0,11 do for cell=0,2 do
+  local img,q=Ui.ballQuad(ball,cell)
+  T.neq(img,nil);T.eq(img.path,require('src.render.Assets').resolve(f.game.data.constants.gen3BallAnim.images.balls))
+  T.eq(q.cell[1],cell*16);T.eq(q.cell[2],ball*16);T.eq(q.cell[3],16);T.eq(q.cell[4],16)
+  T.eq(q.cell[5],48);T.eq(q.cell[6],192)
+  local sameImage,sameQuad=Ui.ballQuad(ball,cell);T.eq(sameImage,img);T.eq(sameQuad,q)
+  first,firstQuad=first or img,firstQuad or q
+ end end
+ T.eq(#images-beforeImage,1,'one owned image serves all twelve ball styles')
+ T.eq(#quads-beforeQuad,36);T.eq(b.frame,frame);T.eq(rolls,0,'art queries consume neither battle ticks nor RNG')
+ for _,args in ipairs{{-1,0},{12,0},{0,3},{0,-1},{0,0/0},{0,math.huge},{'0',0},{.5,0}}do
+  T.eq(Ui.ballQuad(unpack(args)),nil,'malformed cell cannot alias another ball')
+ end
+ T.eq(#quads-beforeQuad,36,'invalid requests allocate no quads')
+ f.game.stack:push({});T.eq(Ui.ballQuad(0,0),first,'covered battle can observe existing art');f.game.stack:pop()
+ G._withCallbackOwner('ball_art_A',Ui.ballQuad,1,0)
+ G._withCallbackOwner('ball_art_B',Ui.ballQuad,1,0)
+ Art._service.releaseOwner(nil,'ball_art_A');T.eq(first.releases,0,'another reader retains art')
+ -- The unowned engine reader above also retains this resource.
+ Art._service.releaseOwner(nil,'ball_art_B');T.eq(first.releases,0)
+ local old=f.game.save;f.game.save={};local changed=Ui.ballQuad(0,0)
+ T.neq(changed,first,'new admission cannot lend a retired image')
+ T.eq(first.releases,1);T.eq(firstQuad.releases,1)
+ f.game.save=old;local replacement=Ui.ballQuad(0,0);T.neq(replacement,first,'retired admission cannot revive old GPU art')
+ T.eq(changed.releases,1,'restoring an old save does not revive the intervening image')
+ f.game.stack:pop();Art._service.poll();T.eq(replacement.releases,1)
+ Art._service.release();T.eq(replacement.releases,1,'release is idempotent')
+ f.close();G.release()
+end
+graphics.newImage,graphics.newQuad=image,quad
+package.loaded['src.core.Game']=originalGame
+T.eq(Ui.presentationApiVersion,nil,'art cells do not advertise the unfinished drawing protocol')
+T.finish('native imported ball cells, owned resource sharing, validation and lifetime')
diff --git a/tests/engine/native_battle_chrome.lua b/tests/engine/native_battle_chrome.lua
new file mode 100644
index 000000000..a9582115e
--- /dev/null
+++ b/tests/engine/native_battle_chrome.lua
@@ -0,0 +1,74 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Battle=require('src.core.game3.battle')
+local Chrome=require('src.ui.game3.battle_chrome')
+local Health=require('src.core.game3.battle.healthbox')
+local Native=require('src.battle.Gen3Battle')
+local originalGame=package.loaded['src.core.Game']
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Battle._service.release()
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local g=f.game;package.loaded['src.core.Game']=g
+ local c=g.data.constants
+ c.gen3BattleWindows={message={left=2,top=15,width=26,height=4},prompt={left=1,top=15,width=14,height=4},action={left=16,top=15,width=13,height=4},moves={}}
+ for i=1,4 do c.gen3BattleWindows.moves[i]={left=1+(i-1)%2*9,top=15+math.floor((i-1)/2)*2,width=8,height=2}end
+ c.gen3BattleTextbox={images={},text={message={foreground={12,34,56},shadow={90,80,70}}}}
+ c.gen3BattleAnimGfx={PROBE={image='tests/fixture_data/assets/fixmon_a_front.png',frameWidth=8,frameHeight=8,frames=1}}
+ g.data.moves.MOVE_033.anim={duration=8,events={{at=0,sheet='PROBE',x=3,y=5,target=true,subpriority=40}}}
+ local b=f.fresh('TACKLE').battle;b.enter=false;g.stack:push(b)
+ local st=Battle.getState()
+ local present=require('src.core.game3.battle.anim').present(0)
+ b.player.mon.status='PAR';b.player.shownStatus=nil;T.eq(present.displayStatus,false,'a queued future ailment is not shown early')
+ b.player.shownStatus='PSN';T.eq(present.displayStatus,8);b.player.mon.status=nil;T.eq(present.displayStatus,8,'shown ailment survives logical cure until the native queue displays it')
+ b.player.shownStatus=false;T.eq(present.displayStatus,false)
+ T.eq(Chrome.layout(),(edition=='ruby'or edition=='sapphire')and'rs'or edition=='emerald'and'emerald'or'frlg')
+ local w=Chrome.window(0);T.eq(w.x,16);T.eq(w.y,120);T.eq(w.w,26);w.left=999;T.eq(c.gen3BattleWindows.message.left,2)
+ local x,y,width,narrow=Chrome.textOrigin(3);T.eq(x,8);T.eq(y,121);T.eq(width,64);T.eq(narrow,true)
+ T.eq(Chrome.window(14),nil,'unimported windows are not fabricated')
+ local originalWidth=b.gen3SurfaceWidth;b.gen3SurfaceWidth=function()return 320 end
+ T.eq(Chrome.window(2).x,16*8+80,'action text follows the native right edge')
+ T.eq(Chrome.window(0).w,36,'message width follows the actual native surface')
+ T.eq(Chrome.window(3).x,8,'move names retain the native left edge');b.gen3SurfaceWidth=originalWidth
+ T.raises(function()Chrome.window(0/0)end,'invalid battle window')
+ local fg,shadow=Chrome.textboxColors();T.eq(fg[1],12/255);T.eq(shadow[3],70/255)
+ local base=Chrome.drawPanel;local native=Native.drawPanel;local draws=0
+ Native.drawPanel=function(screen,mode)T.eq(screen,b);T.eq(mode,'action');draws=draws+1;return true end
+ T.eq(base('menu'),true);T.eq(draws,1)
+ Chrome.drawPanel=function(mode)T.eq(mode,'menu');base(mode);return base(mode)end
+ local body=0;T.eq(Chrome._panel(b,'action',function()body=body+1;return true end),true);T.eq(body,1,'nested bases consume one native panel phase')
+ Chrome.drawPanel=function()love.graphics.push();error('owned panel failure')end
+ T.raises(function()Chrome._panel(b,'action',function()end)end,'owned panel failure')
+ Chrome.drawPanel=base;Native.drawPanel=native
+ local geometry=Health.center(st,0);T.check(geometry~=nil);local realGeometry=Native.healthboxGeometry
+ local hx,hy=Native.healthboxGeometry(b,0);T.eq(geometry.x,hx+32);T.eq(geometry.y,hy+16)
+ T.eq(Health.center({},0),nil);T.eq(Health.draw(0,{}),false,'a foreign battler cannot paint the resident')
+ local healthBase=Health.draw;local count,wrappers=0,0
+ Health.draw=function(id,view,opts)wrappers=wrappers+1;T.eq(id,0);T.eq(view,st.player);T.eq(opts.st,st);healthBase(id,view,opts);return healthBase(id,view,opts)end
+ Health._nativeDraw(b,b.player,hx,hy,true,function()count=count+1;return true end);T.eq(count,1,'healthbox bases consume one native painter');T.eq(wrappers,1,'native HUD dispatch actually enters the source wrapper')
+ Health.draw=healthBase
+ local Pic=require('src.core.game3.battle.pic_coords')
+ g.data.pokemon.CHARMANDER.frontPicCoords={yOffset=13};g.data.pokemon.CHARMANDER.backPicCoords={yOffset=7};c.gen3Elevation={CHARMANDER=4}
+ T.eq(Pic.front[4],13);T.eq(Pic.back[4],7);T.eq(Pic.elev[4],4)
+ g.data.pokemon.CHARMANDER.frontPicCoords.yOffset=2;T.eq(Pic.front[4],2,'native metadata changes are live')
+ T.raises(function()Pic.front[4]=20 end,'read-only')
+ local Sprites=require('src.core.game3.battle.anim_sprites');local Anim=require('src.core.game3.battle.anim')
+ T.eq(Anim.launchMove(33),true)
+ local pool=Sprites._pool;T.eq(#pool,1);T.eq(Sprites._pool,pool)
+ local row=pool[1];local anim=b.gen3Anim;local event=anim.events[1]
+ local pose=anim:eventPose(event,b,Native);T.eq(row.x,pose.centreX+pose.dx);T.eq(row.y,pose.centreY+pose.dy)
+ T.eq(row.active,true);T.eq(row.tag,'PROBE');T.eq(row.subpriority,40)
+ local frame=anim.frame;Sprites.forEachActive(function(p)T.eq(p,row)end);T.eq(anim.frame,frame,'particle inspection cannot advance its native clock')
+ local paints=0;local painter=anim.drawEventBody
+ anim.drawEventBody=function()paints=paints+1;return 'native particle'end
+ row.visible=false;T.eq(anim:drawEvent(event,b,Native,{}),true);T.eq(paints,0)
+ row.visible=true;row.x=row.x+9;T.eq(anim:drawEvent(event,b,Native,{}),'native particle');T.eq(paints,1)
+ row.x=0/0;T.raises(function()anim:drawEvent(event,b,Native,{})end,'invalid particle presentation')
+ row.x=pose.centreX+pose.dx
+ local host=require('src.mods.Runtime');host.currentMod='particle_owner';T.eq(Sprites._pool,pool);host.currentMod=nil
+ require('src.core.game3.asset_stream').cancelOwner('particle_owner');T.eq(row.active,false);T.eq(anim.frame,frame,'view retirement preserves native playback')
+ anim.drawEventBody=painter;b.gen3AnimPlaying=false;T.eq(#Sprites._pool,0)
+ b.result='run';b:finish();Battle._service.release();T.eq(Health.draw(0,st.player),false,'a retired capture cannot draw its old resident')
+ f.close();require('src.core.Game3').release()
+end
+package.loaded['src.core.Game']=originalGame
+T.finish('native battle windows, panel phases, healthbox geometry and imported picture metadata')
diff --git a/tests/engine/native_battle_command_phase.lua b/tests/engine/native_battle_command_phase.lua
new file mode 100644
index 000000000..a96fc336c
--- /dev/null
+++ b/tests/engine/native_battle_command_phase.lua
@@ -0,0 +1,114 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Battle=require('src.core.game3.battle')
+local Ui=require('src.core.game3.battle.ui')
+local Phase=require('src.compat.game3.BattleCommandPhase')
+local base=Ui.takeCommand
+local oldGame=package.loaded['src.core.Game']
+local G=require('src.core.Game3')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ local game=f.game;package.loaded['src.core.Game']=game
+ local second=require('src.mods.Merge').deepCopy(game.data.moves.MOVE_033)
+ second.id,second.index,second.name='MOVE_034',34,'SECOND'
+ game.data.moves.MOVE_034=second;game.data.constants.moveOrder[34]='MOVE_034'
+ local function fresh()
+  Ui.takeCommand=base;Battle._service.release()
+  while game.stack:top()do game.stack:pop()end
+  local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b)
+  b.phase='moveSelect';b.queue={};b.current=nil;b.afterQueue=nil
+  b.player.curMoves[2]={id='MOVE_034',pp=7}
+  b.player.mon.moves=b.player.curMoves
+  local count,chosen=0,nil;local turn=b.resolveTurn
+  b.resolveTurn=function(self,action)count=count+1;chosen=action;return turn(self,action)end
+  return b,function()return count,chosen end
+ end
+ T.eq(type(base),'function');T.eq(base(),nil,'no command exists outside its native selection')
+ local q=fresh();T.eq(Ui._st,Battle.getState());T.eq(Ui._mode,'moves');T.eq(Ui._active,0)
+ local qframe=q.frame;Ui._moveIndex=2;T.eq(q.moveIndex,2);T.eq(Ui._moveIndex,2);T.eq(rawget(Ui,'_moveIndex'),nil,'cursor assignment cannot shadow the live native observation')
+ T.eq(q.frame,qframe);T.eq(Ui.waitingForCommand(),true);T.eq(Ui.busy(),false);T.eq(Ui.dialogPending(),false)
+ T.raises(function()Ui._moveIndex=3 end,'invalid native battle cursor')
+ T.raises(function()Ui._mode='menu'end,'read-only');T.raises(function()Ui._st={}end,'read-only')
+ q.phase='menu';Ui._menuIndex=4;T.eq(q.menuIndex,4);T.eq(rawget(Ui,'_menuIndex'),nil)
+ T.raises(function()Ui._moveIndex=1 end,'cursor is not active')
+ q.moveSwapIndex=1;T.same(Ui._swap,{cursor=0});T.eq(Ui._swapIndex,1);q.moveSwapIndex=nil
+ q:act(function()end);T.eq(Ui.busy(),true);T.eq(Ui.waitingForCommand(),false);T.eq(Ui.dialogPending(),false)
+ q:say('Native queued message');T.eq(Ui.dialogPending(),true);q.queue={};q:startMessage({text='Native current message'})
+ T.eq(Ui.dialogPending(),true);T.eq(Ui.busy(),true);q.current=nil
+ game.stack:push({});T.eq(Ui.waitingForCommand(),false);T.eq(Ui.busy(),true)
+ T.raises(function()Ui._menuIndex=1 end,'does not own the cursor');game.stack:pop()
+
+ local b,seen=fresh();local frame=b.frame
+ Ui.takeCommand=function()
+  local c=base();T.eq(c.kind,'move');T.eq(c.slot,1);T.eq(c.move,33);T.eq(c.battler,0);T.eq(c.user,'player')
+  T.eq(base(),nil,'the pending native selection can be taken only once')
+  return c
+ end
+ b:chooseMove(1);local n,action=seen();T.eq(n,1);T.eq(action,b.player.curMoves[1]);T.eq(b.frame,frame,'taking a command does not advance a combat frame')
+ T.eq(base(),nil)
+ b,seen=fresh();local secondMove=b.player.curMoves[2]
+ Ui.takeCommand=function()local c=base();c.slot,c.move=2,34;return c end
+ b:chooseMove(1);n,action=seen();T.eq(n,1);T.eq(action,secondMove,'replacement uses an actual native move slot');T.eq(b.moveIndex,2)
+ b,seen=fresh();local pp=b.player.curMoves[1].pp
+ Ui.takeCommand=function()base();return nil end
+ T.eq(b:chooseMove(1),true);n=seen();T.eq(n,0);T.eq(b.phase,'moveSelect');T.eq(b.player.curMoves[1].pp,pp,'cancelled selection cannot spend PP');T.eq(base(),nil)
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();Battle.getState().player.mon.pp[1]=0;return c end
+ b:chooseMove(1);n=seen();T.eq(n,0,'native selection refusal is reevaluated after the callback');T.eq(b.phase,'messages')
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();c.slot=0/0;return c end
+ T.raises(function()b:chooseMove(1)end,'invalid native move command slot');n=seen();T.eq(n,0);T.eq(base(),nil,'an error cannot strand a pending command')
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();c.move=34;return c end
+ T.raises(function()b:chooseMove(1)end,'does not match its slot');n=seen();T.eq(n,0)
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();game.stack:push({});return c end
+ b:chooseMove(1);n=seen();T.eq(n,0,'a covering state invalidates the borrowed native command');T.eq(base(),nil);game.stack:pop()
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();b.phase='messages';return c end
+ b:chooseMove(1);n=seen();T.eq(n,0,'changed native input ownership prevents a stale commit')
+ b,seen=fresh()
+ local calls=0;Ui.takeCommand=function()calls=calls+1;return base()end
+ b:chooseAction({id='STRUGGLE',pp=1,struggle=true});n=seen();T.eq(n,1);T.eq(calls,0,'forced commands stay with their native sequencer')
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();Battle._service.release();Battle.getState();return c end
+ b:chooseMove(1);n=seen();T.eq(n,0,'retired source admission cannot commit through a new view of the same native battle')
+ b,seen=fresh()
+ Ui.takeCommand=function()local c=base();b.player.mon.hp=0;return c end
+ b:chooseMove(1);n=seen();T.eq(n,0,'fainted actors cannot commit after a source callback')
+ b,seen=fresh()
+ local Native=require('src.battle.BattleState')
+ local Pokemon=require('src.pokemon.Pokemon')
+ local function extra(pos,player)
+  local mon=Pokemon.new(game.data,'CHARMANDER',30,function(lo)return lo or 0 end)
+  mon.hp,mon.stats.hp,mon.moves=400,400,{{id='MOVE_033',pp=10}}
+  if player then game.save.party[#game.save.party+1]=mon else b.enemyParty=b.enemyParty or{b.enemy.mon};b.enemyParty[#b.enemyParty+1]=mon end
+  b:placeBattler(pos,Native.makeBattler(game.data,mon,player,player and game.save or nil,b))
+ end
+ b.double=true;extra(2,true);extra(3,false);b:syncSides()
+ Ui.takeCommand=function()local c=base();T.eq(c.target,1);c.target=3;return c end
+ b:chooseMove(1);T.eq(b.phase,'targetSelect')
+ local first;for i,candidate in ipairs(b.targetChoices)do if candidate.position==1 then first=i end end
+ T.check(first~=nil);b:chooseTarget(first)
+ n=seen();T.eq(n,0,'first double selection waits for its native partner')
+ T.eq(b.pendingActions[0],b.player.curMoves[1]);T.eq(b.chosenTargets[0],b:battlerAt(3),'replacement target uses the real native selector')
+ T.eq(b:choosingSlotNow(),2)
+ Ui.takeCommand=function()local c=base();T.eq(c.battler,2);return c end
+ b:chooseMenu('fight');b:chooseMove(1)
+ local nextTarget;for i,candidate in ipairs(b.targetChoices or{})do if candidate.position==1 then nextTarget=i end end
+ T.check(nextTarget~=nil);b:chooseTarget(nextTarget);n=seen();T.eq(n,1,'both native selections produce one double turn')
+ b,seen=fresh()
+ b.resolveTurn=function()return false,nil,'native commit result'end
+ Ui.takeCommand=function()return base()end
+ local firstResult,secondResult,thirdResult=b:chooseAction(b.player.curMoves[1])
+ T.eq(firstResult,false);T.eq(secondResult,nil);T.eq(thirdResult,'native commit result','native command phase preserves multiple and nil return values')
+ b,seen=fresh();local owner=G._callbackOwner()
+ Ui.takeCommand=function()T.eq(G._callbackOwner(),'command_owner');error('command source failure')end
+ local seams=require('src.mods.ModSeams');seams._journal[#seams._journal+1]={tbl=Ui,key='takeCommand',after=Ui.takeCommand,owner='command_owner'}
+ T.raises(function()b:chooseMove(1)end,'command source failure');T.eq(G._callbackOwner(),owner);T.eq(base(),nil);n=seen();T.eq(n,0)
+ table.remove(seams._journal)
+ Ui.takeCommand=base;f.close();Battle._service.release();G.release()
+end
+Ui.takeCommand=base;package.loaded['src.core.Game']=oldGame
+T.finish('native move command borrowing, selection validation and once-only commit')
diff --git a/tests/engine/native_battle_menu_continuity.lua b/tests/engine/native_battle_menu_continuity.lua
new file mode 100644
index 000000000..4a93d30cd
--- /dev/null
+++ b/tests/engine/native_battle_menu_continuity.lua
@@ -0,0 +1,95 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Chrome=require('src.ui.game3.battle_chrome')
+local Native=require('src.battle.Gen3Battle')
+local Battle=require('src.core.game3.battle')
+local Ui=require('src.core.game3.battle.ui')
+local Stage=require('src.core.game3.battle.stage')
+local Assets=require('src.render.Assets')
+local G=require('src.core.Game3')
+local original=package.loaded['src.core.Game']
+local image,draw=Assets.image,love.graphics.draw
+local bar=love.graphics.newCanvas(128,8);local balls=love.graphics.newCanvas(32,8)
+Assets.image=function(path)if path=='qa-native-party-bar'then return bar elseif path=='qa-native-party-balls'then return balls else return image(path)end end
+local trace={}
+love.graphics.draw=function(...)trace[#trace+1]={...}end
+T.eq(Chrome.drawPartyBar(),false,'no invented battle or party owner')
+local function record()
+ return{bar='qa-native-party-bar',balls='qa-native-party-balls',count=6,barWidth=128,barHeight=8,ballSide=8,step=10,
+  icons={empty=0,alive=1,status=2,fainted=3},
+  player={barX=136,barY=96,ballX=160,ballY=88,packFrom=1,packStep=1},
+  opponent={barX=-24,barY=40,ballX=30,ballY=33,packFrom=6,packStep=-1,flip=true}}
+end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game;package.loaded['src.core.Game']=game
+ local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b)
+ local summary=record();game.data.constants.gen3BattleHud={partySummary=summary}
+ b.kind='trainer';b.introBalls=true;b.introBallsFrom=nil;b.frame=40
+ b.enemyParty={{species='CHARMANDER',hp=20},{species='CHARMANDER',hp=0},{species='CHARMANDER',hp=10,status='PAR'}}
+ local frame,queue=b.frame,#b.queue;local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ local stage=Stage.current();T.eq(stage.partyBar.player.visible,true);T.eq(stage.partyBar.enemy.visible,true)
+ T.eq(b.introBallsFrom,nil,'observations do not start the paint clock')
+ -- Both the native HUD entry point and public drawing borrow one renderer.
+ for _,player in ipairs{true,false}do
+  for _,age in ipairs{0,1,7,14,17,18,33,40}do
+   b.introBallsFrom=40;b.frame=40+age;trace={}
+   T.eq(Native.drawPartySummary(b,player),true);local expected=trace;trace={}
+   local row=stage.partyBar[player and'player'or'enemy']
+   T.eq(Chrome.drawPartyBar(row.x,row.y,row.balls,row.ox,not player,row),true)
+   T.same(trace,expected,'same native bar/packed icons at age '..age)
+  end
+ end
+ b.frame=40;b.introBallsFrom=nil;trace={}
+ local row=stage.partyBar.player
+ T.eq(Chrome.drawPartyBar(row.x,row.y,row.balls,row.ox,false,row),true)
+ T.eq(b.introBallsFrom,40,'first real public paint starts the same native stamp')
+ T.eq(#trace,1,'icons wait for the native landing time')
+ b.frame=80;trace={};love.graphics.setColor(.2,.3,.4,.5)
+ T.eq(Chrome.drawPartyBar(141,103,row.balls,2,false,{alpha=.5,ballHidden={true,false,true,true,true,true},ballOx={[2]=7}}),true)
+ T.eq(#trace,2);T.same({trace[1][2],trace[1][3]},{143,103})
+ T.same({trace[2][3],trace[2][4]},{182,95},'native icon geometry plus per-icon offset')
+ T.same({love.graphics.getColor()},{.2,.3,.4,.5})
+ local nativeBar,nativeBalls=bar,balls
+ bar=love.graphics.newCanvas(256,16);balls=love.graphics.newCanvas(96,24);trace={}
+ T.eq(Chrome.drawPartyBar(136,96,row.balls,0,false,{ballHidden={}}),true)
+ T.same({trace[1][4],trace[1][5],trace[1][6]},{0,.5,.5},'bar texel density preserves its logical size')
+ T.same({trace[2][5],trace[2][6],trace[2][7]},{0,1/3,1/3},'icons may have a different texel density')
+ T.eq(trace[2][2].w,24,'icon quad uses physical texels')
+ bar,nativeBar=nativeBar,bar;balls,nativeBalls=nativeBalls,balls
+ T.eq(b.frame,80);T.eq(#b.queue,queue);T.eq(rolls,0,'painting never consumes battle RNG')
+ local base=Chrome.drawPartyBar;local wrappers=0
+ Chrome.drawPartyBar=function(...)wrappers=wrappers+1;base(...);return base(...)end
+ trace={};T.eq(Native.drawPartySummary(b,true),true);T.eq(wrappers,1);T.eq(#trace,7,'nested bases borrow the native row once')
+ Chrome.drawPartyBar=function()return false end;b.introBallsFrom=nil;trace={}
+ T.eq(Native.drawPartySummary(b,true),false);T.eq(#trace,0);T.eq(b.introBallsFrom,nil,'held drawing does not start a clock')
+ Chrome.drawPartyBar=base
+ local function bad(opts)
+  b.introBallsFrom=nil
+  T.raises(function()Chrome.drawPartyBar(nil,nil,nil,nil,false,opts)end,'party summary')
+  T.eq(b.introBallsFrom,nil,'invalid options cannot stamp presentation')
+ end
+ for _,opts in ipairs{{alpha=0/0},{alpha=2},{ballHidden={1}},{ballOx={math.huge}},{extended=true}}do bad(opts)end
+ T.raises(function()Chrome.drawPartyBar(0/0,1)end,'invalid party summary position')
+ T.raises(function()Chrome.drawPartyBar(1,1,{'invalid-icon'})end,'invalid party summary icon')
+ local actualDraw=love.graphics.draw;local failedDraws=0
+ love.graphics.draw=function()failedDraws=failedDraws+1;love.graphics.push();error('native party draw failed')end
+ Chrome.drawPartyBar=function(...)
+  local args={...};pcall(base,unpack(args));pcall(base,unpack(args));return true
+ end
+ T.raises(function()Native.drawPartySummary(b,true)end,'native party draw failed')
+ T.eq(failedDraws,1,'a swallowed native failure cannot replay the body')
+ T.same({love.graphics.getColor()},{.2,.3,.4,.5},'failed wrappers restore graphics state')
+ Chrome.drawPartyBar=base;love.graphics.draw=actualDraw
+ -- Cursor records are zero-based detached observations. The native numeric
+ -- selection remains one-based and is still available through _swapIndex.
+ b.moveSwapIndex=1;local swap=Ui._swap;T.same(swap,{cursor=0});T.eq(Ui._swapIndex,1)
+ swap.cursor=3;T.eq(b.moveSwapIndex,1);T.eq(Ui._swap.cursor,0)
+ b.moveSwapIndex=2;T.eq(Ui._swap.cursor,1);T.eq(Ui._swapIndex,2)
+ T.raises(function()Ui._swap={}end,'read-only');T.raises(function()Ui._swapIndex=1 end,'read-only')
+ b.moveSwapIndex=nil;T.eq(Ui._swap,nil);T.eq(Ui._swapIndex,nil)
+ game.stack:pop();T.eq(Chrome.drawPartyBar(),false,'retired battle cannot paint')
+ f.close();Battle._service.release();G.release()
+end
+Assets.image,love.graphics.draw=image,draw;package.loaded['src.core.Game']=original
+T.finish('native trainer party rows, once-only paint clocks, source swap cursor shape and owner retirement')
diff --git a/tests/engine/native_battle_menu_frames.lua b/tests/engine/native_battle_menu_frames.lua
new file mode 100644
index 000000000..244024864
--- /dev/null
+++ b/tests/engine/native_battle_menu_frames.lua
@@ -0,0 +1,103 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Ui=require('src.core.game3.battle.ui')
+local Chrome=require('src.ui.game3.battle_chrome')
+local Frames=require('src.battle.Gen3BattleFrames')
+local Native=require('src.battle.Gen3Battle')
+local Battle=require('src.core.game3.battle')
+local Scope=require('src.render.GraphicsScope')
+local Font=require('src.render.Font')
+local Assets=require('src.render.Assets')
+local Renderer=require('src.render.Renderer')
+local G=require('src.core.Game3')
+local g=love.graphics
+local oldGame=package.loaded['src.core.Game']
+local oldBox,oldImage,oldDraw,oldSerial=Font.drawBox,Assets.image,g.draw,Renderer.frameSerial
+local boxes,images={},{}
+Font.drawBox=function(...)boxes[#boxes+1]={...}end
+local image=g.newCanvas(240,48)
+Assets.image=function(path)if path=='native-frame-2'then return image end;return oldImage(path)end
+g.draw=function(img,...)images[#images+1]={img,...}end
+T.eq(Ui.drawMenuFrames('menu'),false,'no invented battle or window owner')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local b=f.fresh('TACKLE').battle;b.enter=false;b:syncSides();game.stack:push(b)
+ b.phase='menu';b.queue={};b.current=nil
+ game.save.options.gen3Frame=2
+ game.data.constants.gen3BattleTextbox={images={action='native-frame-2',moves='native-frame-2',message='native-frame-2'},
+  frames={count=2},frameImages={[2]={action='native-frame-2',moves='native-frame-2',message='native-frame-2'}}}
+ local target=g.newCanvas(240,160);local other=g.newCanvas(240,160)
+ g.setCanvas(target);Renderer.frameSerial=20;boxes={};images={}
+ local frame,queue=b.frame,#b.queue;local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ local function pair(mode)
+  local ok=Scope.call(function()
+   T.eq(Chrome.drawPanel(mode),true)
+   local drawn,count=Ui.drawMenuFrames(mode);T.eq(drawn,true);T.eq(count,0)
+  end);T.eq(ok,true)
+ end
+ pair('menu');pair('moves');pair('none')
+ T.eq(#images,3);T.eq(#boxes,0,'packed native panels are not painted over')
+ -- A receipt is one-use and bound to the actual target, admission and frame.
+ local drawn,count=Ui.drawMenuFrames('menu');T.eq(drawn,true);T.eq(count,2)
+ T.eq(#boxes,2);local w=Native.windows(b)
+ T.same(boxes[1],{w.prompt.tx,w.prompt.ty,w.prompt.tw,w.prompt.th})
+ T.same(boxes[2],{w.action.tx,w.action.ty,w.action.tw,w.action.th})
+ boxes={};Chrome.drawPanel('menu');g.setCanvas(other)
+ T.eq(select(2,Ui.drawMenuFrames('menu')),2,'same-size canvases retain their own identity')
+ T.eq(#boxes,2);T.eq(g.getCanvas(),other)
+ boxes={};g.setCanvas(target);Chrome.drawPanel('menu');Renderer.frameSerial=21
+ T.eq(select(2,Ui.drawMenuFrames('menu')),2,'a later compositor frame cannot reuse a packed receipt')
+ boxes={};Chrome.drawPanel('menu');b.frame=b.frame+1
+ T.eq(select(2,Ui.drawMenuFrames('menu')),2,'native frame drift retires the receipt')
+ boxes={};Chrome.drawPanel('menu');Chrome._service.releaseOwner('anything')
+ T.eq(select(2,Ui.drawMenuFrames('menu')),2,'owner release retires painted state')
+ boxes={};Chrome.drawPanel('menu');local save=game.save;game.save={options={}}
+ T.eq(select(2,Ui.drawMenuFrames('menu')),2,'a changed save cannot inherit an older receipt');game.save=save
+ boxes={};T.raises(function()Ui.drawMenuFrames('bad')end,'invalid battle panel mode');T.eq(#boxes,0)
+ -- MRT descriptions may be structural; their canvas handles remain opaque.
+ local a={target,other,depthstencil=target};local copy={target,other,depthstencil=target}
+ T.eq(Battle._sameRenderTarget(a,copy),true)
+ T.eq(Battle._sameRenderTarget(a,{other,target,depthstencil=target}),false)
+ T.eq(Battle._sameRenderTarget(a,{target,other,depthstencil=other}),false)
+ T.eq(Battle._sameRenderTarget(target,other),false)
+ -- Without the compositor serial, only a single active graphics scope pairs.
+ Renderer.frameSerial=nil;boxes={};pair('menu');T.eq(#boxes,0)
+ Chrome.drawPanel('menu');T.eq(select(2,Ui.drawMenuFrames('menu')),2)
+ Renderer.frameSerial=22;boxes={}
+ game.data.constants.gen3BattleTextbox=nil
+ T.eq(Chrome.drawPanel('moves'),false);T.eq(select(2,Ui.drawMenuFrames('moves')),2)
+ local s=Native.strip(b);T.same(boxes[1],{s.tx,s.ty,20,s.th})
+ T.eq(select(2,Ui.drawMenuFrames('none')),0)
+ -- RS draws the existing native panel and its separate selected frame.
+ if edition=='ruby'or edition=='sapphire'then
+  local trace={};local chrome={_frameType=0}
+  chrome.setFrameType=function(n)chrome._frameType=n end
+  chrome.userFrame=function(...)trace[#trace+1]={...}end
+  local panel={images={action=image,moves=image,message=image},chrome=chrome}
+  b.rsBattlePanel=panel
+  T.eq(Chrome.drawPanel('menu'),true);T.eq(select(2,Ui.drawMenuFrames('menu')),1)
+  T.same(trace[1],{1,18,15,11,4})
+  trace={};T.eq(Frames.rsFrames(b,'action'),true);T.same(trace[1],{1,18,15,11,4})
+  trace={};T.eq(Frames.rsFrames(b,'moves'),true)
+  T.same(trace[1],{1,1,15,20,4});T.same(trace[2],{1,23,15,6,4})
+  b.safari=true;trace={}
+  T.eq(select(2,Ui.drawMenuFrames('menu')),1);T.eq(#trace,0,'Safari retains its native fallback')
+  b.safari=nil;b.rsBattlePanel=nil
+ end
+ -- The graphics fence restores target and stack even if the native painter fails.
+ local depth=g.getStackDepth and g.getStackDepth()
+ Font.drawBox=function()g.push('all');g.setCanvas(other);error('native window failure')end
+ T.raises(function()Ui.drawMenuFrames('menu')end,'native window failure')
+ T.eq(g.getCanvas(),target);if depth then T.eq(g.getStackDepth(),depth)end
+ Font.drawBox=function(...)boxes[#boxes+1]={...}end
+ T.eq(b.frame,frame+1);T.eq(#b.queue,queue);T.eq(rolls,0,'window presentation cannot run battle rules')
+ Chrome.drawPanel('menu');game.stack:pop();Chrome._service.poll()
+ T.eq(Ui.drawMenuFrames('menu'),false)
+ Chrome._service.release();Battle._service.release();g.setCanvas();f.close();G.release()
+ if target.release then target:release();other:release()end
+end
+Font.drawBox,Assets.image,g.draw,Renderer.frameSerial=oldBox,oldImage,oldDraw,oldSerial
+package.loaded['src.core.Game']=oldGame
+T.finish('native battle frames, packed-panel reuse, RS ownership, targets and retirement')
diff --git a/tests/engine/native_battle_ownership.lua b/tests/engine/native_battle_ownership.lua
new file mode 100644
index 000000000..b52cc9d8f
--- /dev/null
+++ b/tests/engine/native_battle_ownership.lua
@@ -0,0 +1 @@
+dofile('tools/battle-source-runtime/ownership-check.lua')
diff --git a/tests/engine/native_battle_palette_manifests.lua b/tests/engine/native_battle_palette_manifests.lua
new file mode 100644
index 000000000..8bac922bd
--- /dev/null
+++ b/tests/engine/native_battle_palette_manifests.lua
@@ -0,0 +1,41 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Chrome=require('src.ui.game3.battle_chrome')
+local Battle=require('src.core.game3.battle')
+local V=require('src.core.GameVersion')
+local original,version=package.loaded['src.core.Game'],V.get()
+local function palette(seed)local out={};for i=1,16 do out[i]=(seed+i*99)%32768 end;return out end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);package.loaded['src.core.Game']=f.game
+ local c=f.data.constants;local a,b,d=palette(1),palette(3),palette(5)
+ local rs=edition=='ruby'or edition=='sapphire'
+ if rs then
+  c.gen3RsBattlePanel={format=1,version=edition,palette=a}
+  c.gen3RsBag={format=1,version=edition,palette=b}
+ else c.gen3BattleTextbox={images={},palette=a,windowPalette=b,ppPalette=d}end
+ local snapshot=Chrome.manifest()
+ T.same(snapshot.textboxPal,a);T.same(snapshot.windowTextPal,b);T.same(snapshot.ppTextPal,rs and b or d)
+ T.eq(snapshot.native,true);T.eq(snapshot.layout,(edition=='firered'or edition=='leafgreen')and'frlg'or'rse')
+ snapshot.textboxPal[1]=999;snapshot.windowTextPal[1]=999;snapshot.ppTextPal[1]=999
+ T.same(Chrome.manifest().textboxPal,a);T.same(Chrome.manifest().windowTextPal,b)
+ a[1]=32767;b[1]=0;d[1]=12345
+ T.eq(Chrome.manifest().textboxPal[1],32767);T.eq(Chrome.manifest().windowTextPal[1],0)
+ T.eq(Chrome.manifest().ppTextPal[1],rs and 0 or 12345)
+ for _,bad in ipairs{-1,65536,0/0,math.huge,'0',false}do
+  local saved=a[16];a[16]=bad;T.eq(Chrome.manifest().textboxPal,nil,'malformed palette is not exposed');a[16]=saved
+ end
+ if rs then
+  c.gen3RsBattlePanel.version='emerald';c.gen3RsBag.version='emerald'
+  local mixed=Chrome.manifest();T.eq(mixed.textboxPal,nil);T.eq(mixed.windowTextPal,nil);T.eq(mixed.ppTextPal,nil)
+ else
+  c.gen3BattleTextbox.windowPalette=palette(10);T.same(Chrome.manifest().windowTextPal,c.gen3BattleTextbox.windowPalette)
+  c.gen3BattleTextbox.ppPalette=nil;T.eq(Chrome.manifest().ppTextPal,nil,'missing native PP table is not fabricated')
+ end
+ package.loaded['src.core.Game']={data={constants={}}}
+ local empty=Chrome.manifest();T.eq(empty.textboxPal,nil);T.eq(empty.windowTextPal,nil);T.eq(empty.ppTextPal,nil)
+ f.close();Battle._service.release()
+end
+V.set('crystal');T.eq(Chrome.manifest(),nil,'no GBA manifest bootstrapping for Gen2')
+package.loaded['src.core.Game']=original;V.set(version)
+T.finish('native palette manifest shapes, PP/window separation and detached edition ownership')
diff --git a/tests/engine/native_battle_selection.lua b/tests/engine/native_battle_selection.lua
new file mode 100644
index 000000000..a3c0c15cd
--- /dev/null
+++ b/tests/engine/native_battle_selection.lua
@@ -0,0 +1,66 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Ui=require('src.core.game3.battle.ui')
+local Selection=require('src.battle.Gen3SelectionPresentation')
+local Battle=require('src.core.game3.battle')
+local G=require('src.core.Game3')
+local C=require('src.core.game3.battle.anim_coords')
+local original=package.loaded['src.core.Game']
+T.eq(Ui.targetHidden(0),false);T.eq(Ui.bounceOffset('mon',0),0);T.eq(Ui.previewCoeff(0),0)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local b=f.fresh('TACKLE').battle;b.enter=false;b:syncSides();game.stack:push(b)
+ b.phase='menu';b.queue={};b.current=nil;b.waitFrames=0
+ -- Sparse imported integer values deliberately distinguish signed ASR from
+ -- truncation and from an invented floating-point sine fallback.
+ game.data.constants.gen3BattleAnimSine={[128]=0,[135]=-43,[192]=-256,[199]=-252,[143]=256}
+ local frame=b.frame;local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ T.eq(Selection._snapshot(b),nil)
+ for _=1,8 do T.eq(Ui.bounceOffset('mon',0),0);T.eq(Ui.targetHidden(1),false)end
+ T.eq(Selection._snapshot(b),nil,'queries cannot create a native controller')
+ b:tickFx();T.eq(b.frame,frame+1);T.eq(Ui.bounceOffset('hb',0),1);T.eq(Ui.bounceOffset('mon',0),0)
+ local born=Selection._snapshot(b).monFrom
+ for _=1,8 do T.eq(Ui.bounceOffset('hb','player'),1);T.eq(Ui.bounceOffset('hb','enemy'),0)end
+ T.eq(b.frame,frame+1);T.eq(Selection._snapshot(b).monFrom,born);T.eq(rolls,0)
+ b:tickFx();T.eq(Ui.bounceOffset('hb',0),0,'negative fixed-point sine rounds down')
+ T.eq(Selection._snapshot(b).monFrom,born,'repeated controller input cannot restart the bounce')
+ b.phase='moveSelect';b:tickFx();T.eq(Selection._snapshot(b).monFrom,born,'the actor keeps one bounce through move selection')
+ b.phase='targetSelect';b.targetChoices={b.enemy,b.player};b.targetIndex=1
+ T.eq(Ui.targetHidden(1),false,'a query cannot start a target blink')
+ b:tickFx();local targetFrom=Selection._snapshot(b).targetFrom;T.eq(Ui.targetHidden(1),false);T.eq(Ui.bounceOffset('hb',1),1)
+ T.eq(Selection._snapshot(b).healthboxDelta,15);T.eq(Selection._snapshot(b).monFrom,born)
+ b:tickFx();T.eq(Ui.bounceOffset('hb',1),2,'target healthbox uses its own native delta')
+ for i=2,24 do
+  b:tickFx();local hidden=i>=8 and i<16 or i>=24
+  T.eq(Ui.targetHidden(1),hidden);T.eq(Ui.targetHidden(0),false)
+  T.eq(Selection._snapshot(b).targetFrom,targetFrom)
+ end
+ b.targetIndex=2;T.eq(Ui.targetHidden(1),false);T.eq(Ui.targetHidden(0),false)
+ b:tickFx();T.eq(Ui.targetHidden(0),false);T.eq(Selection._snapshot(b).targetPosition,0);T.eq(Selection._snapshot(b).healthboxPosition,0)
+ -- Actual additional native battlers and side binding, not cloned UI actors.
+ local Native=require('src.battle.BattleState');local Pokemon=require('src.pokemon.Pokemon')
+ for id=2,3 do
+  local mon=Pokemon.new(game.data,'CHARMANDER',30,function(lo)return lo or 0 end)
+  b:placeBattler(id,Native.makeBattler(game.data,mon,id%2==0,id%2==0 and game.save or nil,b))
+ end
+ b.double=true;b:syncSides();b.targetChoices={b:battlerAt(3)};b.targetIndex=1;b:tickFx()
+ C.bind(2,3);T.eq(Ui.bounceOffset('hb','enemy'),Ui.bounceOffset('hb',3));C.bind(nil)
+ for _=1,8 do b:tickFx()end
+ T.eq(Ui.targetHidden(3),true);T.eq(Ui.targetHidden(1),false)
+ for _,key in ipairs{-1,0.5,4,math.huge,'missing'}do T.eq(Ui.targetHidden(key),false);T.eq(Ui.bounceOffset('hb',key),0)end
+ T.eq(Ui.targetHidden(0/0),false);T.eq(Ui.bounceOffset('unknown',0),0)
+ b:battlerAt(3).gen3TransformWhite=0.5;T.eq(Ui.previewCoeff(3),8)
+ b:battlerAt(3).gen3TransformWhite=2;T.eq(Ui.previewCoeff(3),16)
+ b:battlerAt(3).gen3TransformWhite=nil;T.eq(Ui.previewCoeff(3),0)
+ local save=game.save;game.save={};T.eq(Ui.targetHidden(3),false);T.eq(Ui.bounceOffset('hb',3),0)
+ game.save=save;b.phase='messages';T.eq(Ui.targetHidden(3),false);T.eq(Ui.bounceOffset('mon',0),0)
+ b:tickFx();T.eq(Selection._snapshot(b),nil)
+ b.phase='menu';game.data.constants.gen3BattleAnimSine=nil;b:tickFx();T.eq(Ui.bounceOffset('hb',0),0)
+ T.eq(rolls,0);T.eq(#b.queue,0,'selection presentation never executes battle commands')
+ game.stack:pop();T.eq(Ui.targetHidden(3),false);T.eq(Ui.bounceOffset('hb',0),0)
+ Battle._service.release();C._service.release();f.close();G.release()
+end
+package.loaded['src.core.Game']=original
+T.finish('native selection frame, target blink, integer bounce, white coefficient and cohort lifetime')
diff --git a/tests/engine/native_battle_session.lua b/tests/engine/native_battle_session.lua
new file mode 100644
index 000000000..6b5ccf7c8
--- /dev/null
+++ b/tests/engine/native_battle_session.lua
@@ -0,0 +1,139 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Battle=require('src.core.game3.battle')
+local Background=require('src.core.game3.battle.bg')
+local Ui=require('src.core.game3.battle.ui')
+local baseUpdate,baseDraw=Battle.update,Battle.draw
+local originalGame=package.loaded['src.core.Game']
+local retained,weak
+T.eq(Battle.isActive(),false)
+T.eq(baseUpdate(),nil,'a source call cannot manufacture a native tick')
+T.eq(baseDraw(),false)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  local f=require('tools.battle-source-runtime.fixture').new(edition)
+  local game=f.game;
+  package.loaded['src.core.Game']=game
+  game.data.constants=game.data.constants or{}
+  game.data.constants.speciesOrder={[4]='CHARMANDER'}
+  game.data.constants.moveOrder={[33]=f.ids.TACKLE}
+  game.data.constants.typeOrder={'NORMAL'}
+  game.data.constants.abilityOrder={'NONE','PROBE_ABILITY'}
+  game.data.constants.abilities={NONE={index=0},PROBE_ABILITY={index=1}}
+  game.data.constants.types={NORMAL={index=0}}
+  game.data.constants.itemOrder={[7]='PROBE_ITEM'}
+  game.data.items.PROBE_ITEM={index=7}
+  local b=f.fresh('TACKLE').battle
+  b.player.ability='PROBE_ABILITY';b.player.mon.item='PROBE_ITEM'
+  local starts=0;local start=Battle.start
+  Battle.start=function(opts)starts=starts+1;T.eq(opts.wild,true);return start(opts)end
+  game.stack:push(b);Battle.start=start;T.eq(starts,1,'real native entry notifies source start once')
+  local st=assert(Battle.getState())
+  T.eq(Battle.isActive(),true)
+  T.eq(baseDraw({data=game.data,save=game.save,stack=game.stack}),false,'foreign capture cannot retire the active view')
+  T.eq(Ui.bindState(nil),false)
+  T.eq(st,Battle.getState(),'one identity for the native admission')
+  T.eq(st.player.id,0);T.eq(st.enemy.id,1)
+  T.eq(st.player.side,'player');T.eq(st.enemy.side,'enemy')
+  T.eq(st.player.mon.species,4);T.eq(st.player.mon.moves[1],33)
+  T.eq(st.player.mon.item,7);T.eq(st.player.ability,1);T.eq(st.player.type1,0)
+  T.eq(st.player.mon.maxHp,400);T.eq(st.party[1],st.player.mon)
+  T.neq(st.player.mon,b.player.mon);T.neq(st, b)
+  st.player.mon.hp=399;T.eq(b.player.mon.hp,399)
+  st.player.mon.status=128;T.eq(b.player.mon.status,'PSN');T.eq(b.player.mon.toxic,true)
+  st.player.mon.status=0;T.eq(b.player.mon.status,nil)
+  T.raises(function()st.player.mon.hp=-1 end,'invalid native HP')
+  T.raises(function()st.weather='SUN'end,'not directly writable')
+  T.raises(function()st.player={}end,'not directly writable')
+  st.paperPresentation={enabled=true};T.eq(st.paperPresentation.enabled,true)
+  local ticks=0;local tickFx=b.tickFx
+  b.tickFx=function(self,...)ticks=ticks+1;return tickFx(self,...)end
+  b.phase='menu';b.queue={};b.current=nil
+  local pp=st.player.mon.pp
+  pp[1]=9
+  Battle.update=function(dt,view)
+    T.eq(require('src.core.Game3').native(view),game)
+    baseUpdate(dt,view);return baseUpdate(dt,view)
+  end
+  local pump=Ui.pump
+  Ui.pump=function()pump();return pump()end
+  b:update(1/60);Ui.pump=pump
+  T.eq(pump(),nil,'UI calls outside the native input phase cannot tick combat')
+  T.eq(Ui.bindState(st),true);T.eq(Ui.bindState({}),false)
+  for _,method in ipairs{'statusHUDVisible','bottomUIVisible','moveGridNavigation'}do
+    if type(b[method])=='function'then T.eq(Ui[method](),b[method](b))
+    else local value,why=Ui[method]();T.eq(value,nil);T.check(why:find('native UI query unavailable',1,true)~=nil)end
+  end
+  T.eq(ticks,1,'two wrapper base calls consume the native tick once')
+  T.eq(b.player.mon.moves[1].pp,9,'validated source PP edit reaches the actual native move')
+  T.eq(baseUpdate(1/60),nil);T.eq(ticks,1,'direct source update outside native scope has no clock')
+  local overlay={};game.stack:push(overlay)
+  T.eq(Battle.getState(),st,'covered combat remains observable')
+  T.eq(Battle.abort('run'),false,'abort cannot pop a foreign overlay')
+  T.eq(b:update(1/60),false);T.eq(ticks,1)
+  game.stack:pop()
+  Battle.update=baseUpdate
+  T.eq(Battle.statWindowPhase(),false)
+  game.stack:push(b.StatBox.new(game,b.player.mon))
+  T.eq(Battle.statWindowPhase(),true,'the actual native level-up window is observed')
+  game.stack:pop()
+  local Host=require('src.mods.Runtime');Host.currentMod='battle_owner'
+  T.eq(Battle.getState(),st);Host.currentMod=nil
+  require('src.core.game3.asset_stream').cancelOwner('other_owner');T.eq(Battle.getState(),st)
+  require('src.core.game3.asset_stream').cancelOwner('battle_owner')
+  T.raises(function()st.player.mon.hp=1 end,'retired')
+  T.eq(Battle.isActive(),true,'mod teardown retires views while native combat continues')
+  local fresh=Battle.getState();T.neq(fresh,st);st=fresh
+  local draws,fields=0,0
+  local NativeDraw=require('src.battle.Gen3Battle');local draw,field=NativeDraw.draw,NativeDraw.drawField
+  NativeDraw.draw=function(screen)draws=draws+1;screen:drawBattleField()end
+  NativeDraw.drawField=function()fields=fields+1 end
+  local uiDraw=Ui.draw;local uiDraws=0
+  Ui.draw=function(w,h)uiDraws=uiDraws+1;uiDraw(w,h);return uiDraw(w,h)end
+  Battle.draw=function(view,w,h)T.eq(w,240);T.eq(h,160);baseDraw(view,w,h);return baseDraw(view,w,h)end
+  b:draw();T.eq(uiDraws,1);T.eq(draws,1);T.eq(fields,1,'base draw consumes the field and native UI once')
+  local bgDraw=Background.draw
+  Background.draw=function()return true end
+  b:draw();T.eq(draws,2);T.eq(fields,1,'background replacement leaves the native UI draw admitted')
+  Background.draw=bgDraw
+  Battle.draw=function()love.graphics.push();error('battle presentation error')end
+  local push,pop=love.graphics.push,love.graphics.pop
+  T.raises(function()b:draw()end,'battle presentation error')
+  T.eq(love.graphics.push,push);T.eq(love.graphics.pop,pop)
+  Battle.draw=baseDraw;Ui.draw=uiDraw;NativeDraw.draw,NativeDraw.drawField=draw,field
+  local bad=st.player.mon.moves;bad[1]=99
+  T.raises(function()b:update(1/60)end,'source move replacement')
+  bad[1]=33;b:update(1/60)
+  local rng=st.rng
+  local nativeHp=b.player.mon.hp
+  local callbacks=0;b.onFinish=function(result)T.eq(result,'lose');callbacks=callbacks+1 end
+  b.result='lose';b:finish()
+  T.eq(Battle.isActive(),false);T.eq(Battle.getState(),st)
+  T.eq(st.result,'lose');T.eq(st.over,true);T.eq(callbacks,1)
+  T.eq(st.player.mon.hp,nativeHp,'retired state has a detached final observation')
+  T.raises(function()st.player.mon.hp=10 end,'retired')
+  T.raises(function()rng(1,2)end,'retired')
+  T.eq(Battle.abort('run'),false,'completion cannot pop a subsequent native screen')
+  T.eq(Battle.reset(),true);T.eq(Battle.getState(),nil)
+  retained={st,st.player,st.player.mon,rng}
+  weak=setmetatable({game,game.save,b},{__mode='v'})
+  f.close();require('src.core.Game3').release()
+end
+package.loaded['src.core.Game']=originalGame
+for _=1,4 do collectgarbage('collect')end
+T.eq(weak[3],nil,'retained completed views do not keep the native controller alive')
+T.eq(retained[1].result,'lose');T.raises(function()retained[4](1,2)end,'retired')
+-- Isolate this view's ownership from the host's process-wide Game3 facade cache.
+local function retiredViews()
+ local data={pokemon={},moves={},constants={}}
+ local game={data=data,save={party={}}}
+ local screen={kind='wild',result='run',rng=function(lo)return lo end}
+ local weak=setmetatable({game,game.save,data,screen},{__mode='v'})
+ local e=require('src.compat.gen1.BattleView').new(game,screen,function()return true end)
+ local view,rng=e.view,e.rng;e:retire();return view,rng,weak
+end
+local view,rng,refs=retiredViews()
+for _=1,4 do collectgarbage('collect')end
+for i=1,4 do T.eq(refs[i],nil,'retired battle views release native owner '..i)end
+T.eq(view.result,'run');T.raises(function()rng(1,2)end,'retired')
+T.finish('native GBA battle admission, numeric views, once-only phases and teardown')
diff --git a/tests/engine/native_battle_source_lifecycle.lua b/tests/engine/native_battle_source_lifecycle.lua
new file mode 100644
index 000000000..230905d08
--- /dev/null
+++ b/tests/engine/native_battle_source_lifecycle.lua
@@ -0,0 +1 @@
+dofile('tools/battle-source-runtime/lifecycle-check.lua')
diff --git a/tests/engine/native_battle_stage.lua b/tests/engine/native_battle_stage.lua
new file mode 100644
index 000000000..4ad88450f
--- /dev/null
+++ b/tests/engine/native_battle_stage.lua
@@ -0,0 +1,84 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local A=require('src.core.game3.battle.anim')
+local Stage=require('src.core.game3.battle.stage')
+local Battle=require('src.core.game3.battle')
+local Native=require('src.battle.Gen3Battle')
+local Ball=require('src.battle.Gen3BallAnim')
+local G=require('src.core.Game3')
+local original=package.loaded['src.core.Game']
+T.eq(A.stage(),nil,'a stage cannot invent a native battle')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b)
+ b.introSlide=8;b.frlgIntro={t=0,hold=2};b.showPlayerBack=true;b.showEnemyTrainer=true
+ b.introBalls=true;b.introBallsFrom=nil
+ local stage=A.stage();T.eq(stage,A.stage(),'one stage identity per native admission')
+ T.eq(stage.slideDone,false);T.eq(stage.win0[1],80);T.eq(stage.win0[2],80)
+ T.eq(stage.trainer.player.visible,true);T.eq(stage.trainer.enemy.visible,true)
+ local frame=b.frame;local queue=#b.queue;local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ local mask=stage.win0;local trainer=stage.trainer.player;local box=stage.healthbox.player
+ for _=1,8 do
+  T.eq(stage.healthbox[0],box);T.eq(box.visible,false)
+  T.eq(stage.healthbox[1].visible,false);T.eq(stage.healthbox[2].visible,false)
+  T.eq(stage.bgSlide.playerOx,-stage.bgSlide.enemyOx)
+ end
+ T.eq(b.frame,frame);T.eq(#b.queue,queue);T.eq(rolls,0)
+ T.eq(b.introBallsFrom,nil,'queries cannot stamp the party-bar clock')
+ local copied={};for key,value in pairs(stage)do copied[key]=value end
+ T.eq(copied.trainer,stage.trainer);T.eq(copied.win0,mask)
+ T.raises(function()stage.slide=1 end,'read-only');T.raises(function()trainer.visible=false end,'read-only')
+ for _,t in ipairs{0,1,32,33,43,44,60}do
+  b.frlgIntro.t=t;local top,bottom=Native.introWindow(b)
+  if t<44 then T.eq(stage.win0[1],top);T.eq(stage.win0[2],bottom)
+  else T.eq(stage.win0,nil);T.eq(mask[1],nil)end
+ end
+ b.frlgIntro.hold=0;b.introSlide=0;b.showPlayerBack=false;b.showEnemyTrainer=false;b.introBalls=nil
+ T.eq(stage.slideDone,true);T.eq(box.visible,true);T.eq(stage.healthbox.enemy.visible,true)
+ b.player.fainted=true;T.eq(box.visible,true,'native single player panel remains during completion')
+ b.enemy.fainted=true;T.eq(stage.healthbox.enemy.visible,false)
+ b.player.fainted=false;b.enemy.fainted=false
+ b.demo=true;T.eq(box.visible,false);b.demo=nil;b.safari=true;T.eq(box.visible,false);b.safari=nil
+ game.data.field=game.data.field or{};game.data.field.playerForms={boy={},girl={}}
+ game.save.player.gender='girl';T.eq(trainer.gender,1)
+ game.save.player.gender='boy';T.eq(trainer.gender,0)
+ b.picOff={back={x=-12},foe={x=7}};T.eq(trainer.ox,-12);T.eq(stage.trainer.enemy.ox,7)
+ game.data.constants.gen3BallAnim={timing={},sounds={}}
+ local a=Ball.new(game.data,{ball=3,battler=b.player,sendOut='player',to={x=72,y=80}})
+ b.gen3Ball=a;b.gen3BallPlaying=true
+ local ball=stage.ball;T.eq(ball,stage.balls[0]);T.eq(stage.balls[1],nil);T.eq(ball.ballId,3)
+ T.eq(ball.battler,0);T.eq(ball.side,'player');T.eq(ball.frame,0);T.eq(ball.visible,true)
+ for i=1,3 do a:update();T.eq(ball.x,a.x+(a.shakeOffset or 0));T.eq(ball.y,a.y);T.eq(ball.frame,a.ballFrame-1)end
+ T.eq(b.frame,frame);T.eq(rolls,0);T.eq(a.frame,3)
+ b.gen3Ball=Ball.new(game.data,{ball=1,battler=b.enemy,sendOut='opponent'})
+ T.eq(ball.visible,false,'an old ball cannot project a replacement timeline')
+ T.neq(stage.ball,ball);T.eq(stage.ball,stage.balls[1]);T.eq(stage.ball.side,'enemy')
+ b.gen3Ball=nil;T.eq(stage.ball,nil)
+ local cover={};game.stack:push(cover);T.eq(A.stage(),stage,'covered native stages remain observable');game.stack:pop()
+ local previous=game.save;game.save={};local replacement=A.stage();T.neq(replacement,stage)
+ T.eq(trainer.visible,false);T.eq(box.visible,false);T.eq(stage.slideDone,nil)
+ game.save=previous;T.neq(A.stage(),stage,'restoring an old cohort cannot revive a retained stage')
+ game.stack:pop();T.eq(A.stage(),nil);T.eq(mask[1],nil)
+ Stage._service.release();f.close();G.release()
+end
+-- Preserve capture identity: the catch observer and full stage must point
+-- at the same actual ball, including its post-catch resting frame.
+do
+ local f=require('tools.battle-source-runtime.fixture').new('firered');local game=f.game
+ package.loaded['src.core.Game']=game
+ game.data.constants.itemOrder={[4]='POKE_BALL'};game.data.items.POKE_BALL={index=4,name='POKE BALL'}
+ game.data.constants.gen3BallAnim={timing={},sounds={},itemToBall={[4]=0}}
+ local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b)
+ b.phase='messages';b.queue={};b.current=nil;b.nextInsert=nil;b.rng=function(lo)return lo or 0 end
+ local Catch=require('src.core.game3.battle.catch_seq')
+ b:throwBall('POKE_BALL');local entry=b.queue[#b.queue];b.queue={entry};b:updateQueue()
+ local native=b.gen3Ball
+ T.neq(native,nil);T.eq(A.stage().ball,Catch._ball.stage)
+ T.eq(A.stage().ball.ballId,native.ball);T.eq(A.stage().ball.battler,1)
+ local held=A.stage().ball;game.stack:pop();T.eq(held.visible,false)
+ Catch._service.release();Stage._service.release();f.close();G.release()
+end
+package.loaded['src.core.Game']=original
+T.finish('native battle stage, actual entry/HUD/ball/window state, capture identity and retirement')
diff --git a/tests/engine/native_battle_text_colors.lua b/tests/engine/native_battle_text_colors.lua
new file mode 100644
index 000000000..3e7d9f4a9
--- /dev/null
+++ b/tests/engine/native_battle_text_colors.lua
@@ -0,0 +1,73 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Chrome=require('src.ui.game3.battle_chrome')
+local Battle=require('src.core.game3.battle')
+local Font=require('src.ui.game3.frlg_font')
+local NativeFont=require('src.render.Font')
+local V=require('src.core.GameVersion')
+local original,version=package.loaded['src.core.Game'],V.get()
+local function rgb(word)
+ local out={}
+ for i=1,3 do local n=math.floor(word/32^(i-1))%32;out[i]=(n*8+math.floor(n/4))/255 end
+ out[4]=1;return out
+end
+local function expect(colors,a,b)
+ T.same(colors.fg,a);T.same(colors.shadow,b);T.same(colors.bg,{0,0,0,0})
+ T.same({colors[1],colors[2],colors[3],colors[4]},a)
+end
+local begin,finish=NativeFont.beginTwoTone,NativeFont.endTwoTone
+local observed
+NativeFont.beginTwoTone=function(a,b)observed={a,b};return false end
+for index,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ package.loaded['src.core.Game']=f.game
+ local constants=f.data.constants;local palette={}
+ for i=1,16 do palette[i]=((i*2131+index*1777)%32768)end
+ local rs=edition=='ruby'or edition=='sapphire'
+ local record={palette=palette,images={},format=1,version=edition}
+ constants[rs and 'gen3RsBattlePanel'or'gen3BattleTextbox']=record
+ constants.gen3BattleTextbox=constants.gen3BattleTextbox or{images={}}
+ constants.gen3BattleTextbox.text={message={foreground={12,34,56},shadow={78,90,12},indices={fg=1,shadow=6}}}
+ expect(Chrome.textboxColors(),{12/255,34/255,56/255,1},{78/255,90/255,12/255,1})
+ for fg=0,15 do for sh=0,15 do
+  local colors,second,why=Chrome.textboxColors(fg,sh)
+  expect(colors,rgb(palette[fg+1]),rgb(palette[sh+1]));T.same(second,colors.shadow);T.eq(why,nil)
+  T.eq(Font.draw('PAIR',0,0,{colors=colors}),Font.measure('PAIR'))
+  T.same(observed,{colors.fg,colors.shadow},'the real font receives both indexed tones')
+ end end
+ local c=Chrome.textboxColors(1,8);c.fg[1]=999;c.shadow[1]=999;c.bg[4]=1;c[1]=999
+ expect(Chrome.textboxColors(1,8),rgb(palette[2]),rgb(palette[9]))
+ palette[2]=32767;expect(Chrome.textboxColors(1,8),rgb(32767),rgb(palette[9]))
+ record.palette={};for i=1,16 do record.palette[i]=0 end
+ expect(Chrome.textboxColors(1,8),rgb(0),rgb(0))
+ record.palette[16]=nil
+ local unavailable,_,why=Chrome.textboxColors(1,8)
+ expect(unavailable,Font.COLOR.WHITE.fg,Font.COLOR.WHITE.shadow);T.eq(why,'native textbox palette unavailable')
+ record.palette=palette
+ for _,bad in ipairs{-1,16,0.5,0/0,math.huge,'1',false,{}}do
+  T.raises(function()Chrome.textboxColors(bad,8)end,'invalid native textbox colour index')
+  T.raises(function()Chrome.textboxColors(1,bad)end,'invalid native textbox colour index')
+ end
+ for _,bad in ipairs{-1,65536,0/0,math.huge,'1',false}do
+  local saved=palette[16];palette[16]=bad
+  T.eq(select(3,Chrome.textboxColors(1,8)),'native textbox palette unavailable');palette[16]=saved
+ end
+ if rs then
+  record.version=edition=='ruby'and'sapphire'or'ruby'
+  T.eq(select(3,Chrome.textboxColors(1,8)),'native textbox palette unavailable','edition-bound RS data')
+ else
+  record.palette=nil;record.text={message={foreground={12,34,56},shadow={78,90,12},indices={fg=1,shadow=8}}}
+  local legacy={12/255,34/255,56/255,1};local shade={78/255,90/255,12/255,1}
+  expect(Chrome.textboxColors(1,8),legacy,shade);expect(Chrome.textboxColors(),legacy,shade)
+  T.eq(select(3,Chrome.textboxColors(2,8)),'native textbox palette unavailable','old role data cannot invent other indices')
+ end
+ package.loaded['src.core.Game']={data={constants={}}}
+ T.eq(select(3,Chrome.textboxColors(1,8)),'native textbox palette unavailable','no retained prior game palette')
+ f.close();Battle._service.release()
+end
+NativeFont.beginTwoTone,NativeFont.endTwoTone=begin,finish
+V.set('crystal');package.loaded['src.core.Game']={data={constants={gen3BattleTextbox={images={},palette={}}}}}
+T.eq(select(3,Chrome.textboxColors()),'native textbox palette unavailable','Gen2 cannot select a GBA palette')
+package.loaded['src.core.Game']=original;V.set(version)
+T.finish('native indexed battle text records, proportional font consumption and edition/data isolation')
diff --git a/tests/engine/native_battle_text_palette_import.lua b/tests/engine/native_battle_text_palette_import.lua
new file mode 100644
index 000000000..8ad68baef
--- /dev/null
+++ b/tests/engine/native_battle_text_palette_import.lua
@@ -0,0 +1,55 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local X=require('src.import.RomExtractorGen3')
+local Image=require('src.import.ImageWriter')
+local Import=require('src.import.RomImporter')
+-- Older public importers expose readiness, before the pure cache descriptor
+-- was added. Exercise their actual marker closure without adding a new API.
+local function cacheMarker(edition)
+ if Import.cacheContract then return Import.cacheContract(edition).marker end
+ for i=1,100 do
+  local name,value=debug.getupvalue(Import.readyReport,i)
+  if not name then break end
+  if name=='markerFor'then return value(edition)end
+ end
+ error('native importer marker owner unavailable')
+end
+local spec=X.BATTLE_TEXTBOX
+local lz,blank=X.lz77ok,Image.blank
+local function zeros(n)local out={};for i=1,n do out[i]=0 end;return out end
+for _,edition in ipairs{'firered','leafgreen','emerald'}do
+ local tiles,map,pal,menu=zeros(spec.TILES_BYTES),zeros(spec.TILEMAP_BYTES),zeros(spec.PALETTE_BYTES),zeros(spec.MENU_PALETTE_BYTES)
+ for _,panel in ipairs(spec.PANELS)do for i=0,spec.PANEL_ROWS-1 do map[(panel.row+i)*spec.COLS*2+1]=1 end end
+ for i=1,#pal do pal[i]=(i*73)%256 end
+ local blobs={[spec.TILES]=tiles,[spec.TILEMAP]=map,[spec.PALETTE]=pal,[spec.MENU_PALETTE]=menu}
+ X.lz77ok=function(_,at)return true,blobs[at]end
+ Image.blank=function()error('synthetic reader does not bake GPU artwork')end
+ local writes,ppReads=0,0
+ local rom={size=spec.PP_TEXT_PALETTE+32,pointer=function()return nil end,
+  u16=function(_,at)ppReads=ppReads+1;return 1024+(at-spec.PP_TEXT_PALETTE)/2 end}
+ local x=setmetatable({rom=rom,version=edition,symbols={},_constants={retained=true},beginStage=function()end,
+  write=function(_,name,value)T.eq(name,'constants');T.eq(value.retained,true);writes=writes+1 end},X)
+ x:extractBattleTextbox();T.eq(writes,1)
+ local result=x._constants.gen3BattleTextbox.palette;T.eq(#result,16)
+ for i=1,16 do T.eq(result[i],pal[i*2-1]+pal[i*2]*256)end
+ local imported=x._constants.gen3BattleTextbox
+ T.eq(#imported.windowPalette,16)
+ for i=1,16 do T.eq(imported.windowPalette[i],menu[i*2-1]+menu[i*2]*256)end
+ if edition=='emerald'then
+  T.eq(ppReads,16);T.eq(#imported.ppPalette,16);T.eq(imported.ppSource,'ROM:gPPTextPalette 0D85620')
+  for i=1,16 do T.eq(imported.ppPalette[i],1023+i)end
+  x.rom.size=spec.PP_TEXT_PALETTE+31;x:extractBattleTextbox()
+  T.eq(x._constants.gen3BattleTextbox.ppPalette,nil,'bounded raw PP table read')
+  T.eq(ppReads,16,'out-of-bounds table reads no bytes')
+ else T.eq(ppReads,0);T.eq(imported.ppPalette,nil,'no Emerald raw addresses in another edition')end
+ local first=result[1];pal[1]=0;T.eq(result[1],first,'raw bytes are detached from the serialized palette')
+ pal[#pal]=nil;x._constants={};writes=0;x:extractBattleTextbox()
+ T.eq(writes,0,'truncated palette cannot publish indexed metadata');T.eq(x._constants.gen3BattleTextbox,nil)
+ T.check(cacheMarker(edition):find('gba-textbox-palette-v2:',1,true)~=nil)
+end
+for _,edition in ipairs{'red','crystal','ruby','sapphire','platinum','black'}do
+ T.eq(cacheMarker(edition):find('gba-textbox-palette-v2:',1,true),nil,'unaffected edition cache marker')
+end
+X.lz77ok,Image.blank=lz,blank
+T.finish('validated native textbox extraction retains the full raw palette and narrows cache revision')
diff --git a/tests/engine/native_battle_type_names.lua b/tests/engine/native_battle_type_names.lua
new file mode 100644
index 000000000..4ac37edd1
--- /dev/null
+++ b/tests/engine/native_battle_type_names.lua
@@ -0,0 +1,40 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local before=package.loaded['src.core.Game']
+local service=package.loaded['src.translation.Service']
+local Version=require('src.core.GameVersion');local version=Version.get()
+local Types=require('src.core.game3.battle.types')
+T.eq(package.loaded['src.core.Game'],before,'type names cannot bootstrap a game')
+package.loaded['src.core.Game']=nil;T.eq(Types.name(0),nil)
+for _,edition in ipairs{'firered','leafgreen','ruby','sapphire','emerald'}do
+ Version.set(edition)
+ local constants={typeOrder={'NORMAL','FIGHT','PSYCHC','ELECTR'},types={}}
+ for i,key in ipairs(constants.typeOrder)do constants.types[key]={index=i-1,name=key}end
+ local data={constants=constants,type_chart={types={PSYCHC={name='Native psychic'}}}}
+ package.loaded['src.core.Game']={data=data}
+ package.loaded['src.translation.Service']=nil
+ T.eq(Types.name(0),'NORMAL','cartridge type zero is a real type')
+ T.eq(Types.name(1),'FIGHT');T.eq(Types.name(2),'Native psychic');T.eq(Types.name('PSYCHC'),'Native psychic')
+ T.eq(Types.name(3),'ELECTR');T.eq(Types.name(4),nil);T.eq(Types.name(-1),nil)
+ T.eq(Types.name(.5),nil);T.eq(Types.name(0/0),nil);T.eq(Types.name(nil),nil)
+ T.eq(Types.name('PSYCHIC'),nil,'do not substitute another edition\'s keys')
+ package.loaded['src.translation.Service']={name=function(name)return 'translated '..name end}
+ T.eq(Types.name(2),'translated Native psychic')
+ package.loaded['src.translation.Service']=nil
+ data.type_chart.types.PSYCHC.name='Changed registry name'
+ T.eq(Types.name(2),'Changed registry name','native registry edits are visible immediately')
+ constants.typeOrder={'CUSTOM','NORMAL'};constants.types={CUSTOM={name='Custom type'},NORMAL={name='New normal'}}
+ T.eq(Types.name(0),'Custom type','replaced cartridge order invalidates the identifier cache')
+ T.eq(Types.name(1),'New normal');T.eq(Types.name(2),nil)
+ data.types={CUSTOM={name='Mod catalogue'},NORMAL={name='Mod normal'}}
+ T.eq(Types.name(0),'Mod catalogue','merged native catalogue is authoritative')
+ package.loaded['src.core.Game']={data={constants={typeOrder={'OTHER'},types={OTHER={name='Other dataset'}}}}}
+ T.eq(Types.name(0),'Other dataset','a new session cannot reuse retired names')
+ Types._service:releaseOwner('retired_owner');T.eq(Types.name(0),'Other dataset','owner retirement drops only the soft metadata cache')
+ Types._service:release();T.eq(Types.name(0),'Other dataset','native session teardown permits fresh metadata admission')
+ Version.set('gold');T.eq(Types.name(0),nil,'another generation keeps its own native service')
+end
+package.loaded['src.core.Game']=before;package.loaded['src.translation.Service']=service
+Version.set(version)
+T.finish('native GBA type names, cartridge order, translation and dataset replacement')
diff --git a/tests/engine/native_battler_coordinate_queries.lua b/tests/engine/native_battler_coordinate_queries.lua
new file mode 100644
index 000000000..75782d742
--- /dev/null
+++ b/tests/engine/native_battler_coordinate_queries.lua
@@ -0,0 +1,66 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local P=require('src.core.game3.battle.pic_coords')
+local C=require('src.core.game3.battle.anim_coords')
+local G=require('src.core.Game3')
+local Version=require('src.core.GameVersion')
+local previous=package.loaded['src.core.Game']
+local function point(p,x,y)
+ T.eq(p.x,x);T.eq(p.y,y);T.eq(p[1],x);T.eq(p[2],y)
+end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ package.loaded['src.core.Game']=f.game
+ local b=f.fresh('TACKLE').battle;b.enter=false;f.game.stack:push(b)
+ local constants=f.data.constants
+ local defaultsSingle={{72,80},{176,40},{48,40},{112,80}}
+ local defaultsDouble={{32,80},{200,40},{90,88},{152,32}}
+ for i=0,3 do
+  point(P.battlerCoords(false,i),unpack(defaultsSingle[i+1]))
+  point(P.battlerCoords(true,i),unpack(defaultsDouble[i+1]))
+ end
+ point(P.battlerCoords(),72,80)
+ point(P.battlerCoords(false,'1'),176,40)
+ local rows={singles={},doubles={}}
+ for i=1,4 do rows.singles[i]={x=i*13,y=i*17};rows.doubles[i]={i*19,i*23}end
+ constants.gen3BattlerCoords=rows
+ local frame,queue=b.frame,#b.queue
+ local hp,ap=b.player.mon.hp,b.player.mon.moves[1].pp
+ local rolls=0;b.rng=function()rolls=rolls+1;return 0 end
+ C.setDouble(true);C.setCoordinateOverrides({[0]={x=999,y=998,[1]=999,[2]=998}})
+ for _=1,3 do for i=0,3 do
+  point(P.battlerCoords(false,i),(i+1)*13,(i+1)*17)
+  point(P.battlerCoords(true,i),(i+1)*19,(i+1)*23)
+ end end
+ local held=P.battlerCoords(false,0);held.x,held[1]=500,501
+ point(P.battlerCoords(false,0),13,17)
+ point(C.coords(nil,0),999,998)
+ rows.singles[1].x=31;point(P.battlerCoords(false,0),31,17)
+ constants.gen3BattlerCoords={singles={{x=7,y=9}}}
+ point(P.battlerCoords(false,0),7,9)
+ point(P.battlerCoords(true,0),32,80)
+ for _,id in ipairs{-1,4,1.5,'invalid',math.huge,-math.huge}do
+  local value,why=P.battlerCoords(false,id);T.eq(value,nil);T.check(type(why)=='string')
+ end
+ T.eq(P.battlerCoords(false,0/0),nil)
+ T.eq(P.battlerCoords('double',0),nil)
+ for _,bad in ipairs{{x=math.huge,y=2},{x=2,y=0/0},{x='3',y=2},{},true,9,'bad',false}do
+  constants.gen3BattlerCoords.singles[1]=bad
+  local value,why=P.battlerCoords(false,0);T.eq(value,nil);T.eq(why,'invalid native battler coordinates')
+ end
+ constants.gen3BattlerCoords.doubles='invalid';T.eq(P.battlerCoords(true,0),nil)
+ constants.gen3BattlerCoords=false;T.eq(P.battlerCoords(false,0),nil)
+ T.eq(b.frame,frame);T.eq(#b.queue,queue);T.eq(rolls,0)
+ T.eq(b.player.mon.hp,hp);T.eq(b.player.mon.moves[1].pp,ap)
+ C._service.release();f.game.stack:pop();f.close();G.release()
+ -- Existing detached points survive retirement as plain values, and cannot
+ -- retain the previous game's native objects or affect a replacement owner.
+ T.eq(held.y,17)
+ local nextGame={data={constants={gen3BattlerCoords={singles={{x=61,y=63}}}}}}
+ package.loaded['src.core.Game']=nextGame
+ point(P.battlerCoords(false,0),61,63)
+ Version.set('gold');T.eq(P.battlerCoords(false,0),nil)
+end
+package.loaded['src.core.Game']=previous
+T.finish('native base battler coordinates, current cartridge records and render-override isolation')
diff --git a/tests/engine/native_companion_runtime.lua b/tests/engine/native_companion_runtime.lua
new file mode 100644
index 000000000..83954d73c
--- /dev/null
+++ b/tests/engine/native_companion_runtime.lua
@@ -0,0 +1,276 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local G=require('src.core.Game3')
+local Host=require('src.mods.Runtime')
+local Views=require('src.compat.gen1.SessionView')
+local PViews=require('src.compat.gen1.PokemonView')
+local Bag=require('src.core.game3.bag')
+local Field=require('src.core.game3.field')
+local Source=require('src.compat.gen1.SourcePokemon')
+local Scope=require('src.compat.gen1.ScriptBoundary')
+local Message=require('src.ui.game3.message')
+local Choice=require('src.ui.game3.choice')
+local Stream=require('src.core.game3.asset_stream')
+T.eq(require('src.core.game3.player').running,false,'no admitted player is not running')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();G.release()
+ local bf=require('tools.battle-source-runtime.fixture').new(edition)
+ local nativeMon=bf.fresh('TACKLE').battle.player.mon
+ local f=require('tools.session-runtime.fixture').new(edition)
+ local g,w,p=f.game,f.world,f.player
+ local maps=g.data.maps;g.data=bf.data;g.data.maps=maps
+ g.data.constants.types={NORMAL={index=0}};g.data.constants.typeOrder={'NORMAL'}
+ local pair=require('src.compat.gen1.PairNames')[edition][1]
+ g.data.tilesets={PAIR={id='PAIR',primaryKey='P',secondaryKey='S',blockCells=1,blockTiles=2}}
+ g.data.map_tilesets={P={address=pair[1],secondary=false},S={address=pair[2],secondary=true}}
+ w.map.def.tileset='PAIR'
+ g.data.constants.gen3Layout={};g.data.constants.itemOrder={[7]='PROBE_ITEM'}
+ local evolved=require('src.mods.Merge').deepCopy(g.data.pokemon.CHARMANDER)
+ evolved.id,evolved.name,evolved.index,evolved.dex='CHARMELEON','CHARMELEON',5,5
+ g.data.pokemon.CHARMELEON=evolved;g.data.constants.speciesOrder[5]='CHARMELEON'
+ for number,name in pairs{[34]='GROWL',[35]='TAIL_WHIP',[36]='SPLASH',[37]='LEER'}do
+  g.data.constants.moveOrder[number]=name
+  g.data.moves[name]={id=name,index=number,name=name,pp=40,power=0,type='NORMAL',category='status',accuracy=100}
+ end
+ g.data.items.PROBE_ITEM={id='PROBE_ITEM',name='PROBE',index=7,pocket='ITEM',price=1}
+ g.save.party={nativeMon};g.save.inventory={PROBE_ITEM=2};g.save.bagOrder={'PROBE_ITEM'}
+ g.save.pokedex={seen={},owned={},caught={}}
+ g.mods={mods={runtime_probe={enabled=true},other={enabled=true}},exports={},hooks={wrap=function()end}}
+ Host.currentMod='runtime_probe'
+ local view=assert(G.forNative(g));local session=view.session;local mon=session.party[1]
+ T.check(mon~=nativeMon);T.eq(mon.species,4);T.eq(mon.moves[1],33);T.eq(mon.pp[1],10)
+ local snapshot={};for k,v in pairs(mon)do snapshot[k]=v end
+ T.eq(snapshot.species,4);T.neq(snapshot.moves,mon.moves)
+ local pp=mon.pp;pp[1]=7;G._withCallbackOwner('runtime_probe',function()end);T.eq(nativeMon.moves[1].pp,7)
+ local invalid=mon.pp;invalid[1]=-1;T.raises(function()PViews.flush()end,'invalid native PP')
+ T.eq(nativeMon.moves[1].pp,7);invalid[1]=7;PViews.flush()
+ local numericMoves=mon.moves;numericMoves[1]=34;T.raises(function()PViews.flush()end,'native moves changed')
+ numericMoves[1]=33;PViews.flush()
+ require('src.core.game3.pokemon').setFriendship(mon,200);T.eq(nativeMon.happiness,200)
+ mon.hp=12;T.eq(nativeMon.hp,12);mon.status=128;T.eq(nativeMon.status,'PSN');T.eq(nativeMon.toxic,true)
+ mon.status=0;T.eq(nativeMon.status,nil)
+ T.eq(Bag.count(session.bag,7),2)
+ local inventory,order=g.save.inventory,g.save.bagOrder
+ T.eq(Bag.canAdd(session.bag,7,2),true);T.eq(g.save.inventory,inventory);T.eq(g.save.bagOrder,order);T.eq(inventory.PROBE_ITEM,2)
+ T.eq(Bag.add(session.bag,7,2),true);T.eq(inventory.PROBE_ITEM,4)
+ T.eq(Bag.remove(session.bag,7,-2),false);T.eq(inventory.PROBE_ITEM,4)
+ T.eq(Bag.add(session.bag,7,0/0),false);T.eq(Bag.add(session.bag,9999,1),false)
+ T.eq(Bag.remove(session.bag,7,2),true);T.eq(inventory.PROBE_ITEM,2)
+ local Dex=require('src.core.game3.dex');T.eq(Dex.isCaught(session.dex,4),false)
+ g.save.pokedex.owned.CHARMANDER=true;T.eq(Dex.isCaught(session.dex,4),true)
+ local Safari=require('src.core.game3.safari');T.eq(Safari.isActive(session),false)
+ g.save.safari={balls=30};T.eq(Safari.isActive(session),true);g.save.safari=nil
+ T.eq(Field.lock('same'),true);T.eq(Field.locked,true);T.eq(w:busy(),true)
+ Host.currentMod='other';Field.lock('same');Field.unlock('same');T.eq(Field.locked,true,'one mod cannot release another lock')
+ Stream.cancelOwner('other');T.eq(Field.locked,true)
+ Host.currentMod='runtime_probe';Field.unlock('same');T.eq(Field.locked,false)
+ local interactions=0;local base=Field.interact
+ Field.interact=function()base();return base()end
+ Field._dispatch(g,w,function()interactions=interactions+1;return'handled'end)
+ T.eq(interactions,1);T.eq(base(),nil,'no manufactured interaction between native phases');Field.interact=base
+ local Player=require('src.core.game3.player');T.eq(Player.startFieldMove(3,'test'),true)
+ T.eq(p.fieldMove,true);T.eq(w:busy(),true);T.eq(Player.startFieldMove(2),false)
+ p:update();p:update();T.eq(Player.fieldMoveAnim,1);p:update();T.eq(Player.fieldMoveAnim,0);T.eq(p._gen3FieldMovePoseOwner,nil)
+ Player.startFieldMove(3);Stream.cancelOwner('runtime_probe');T.eq(p.fieldMove,nil)
+ local moves=require('src.core.game3.field_moves')
+ g.data.constants.gen3FieldMoves={SURF={badgeFlag=0x820}}
+ T.eq(moves.hasBadge(session,'SURF'),false);g.save.flags.FLAG_G3_0820=true;T.eq(moves.hasBadge(session,'SURF'),true)
+ w.partyKnows=function(_,key)return key=='SURF'and nativeMon end
+ local user,slot=moves.partyMoveUser(session.party,'SURF');T.eq(user,mon);T.eq(slot,0)
+ local none,missing=moves.partyMoveUser(session.party,'CUT');T.eq(none,nil);T.eq(missing,6)
+ local fighter={species=4,level=30,personality=9,ivs={hp=31,atk=20,def=10,spe=8,spa=7,spd=6},moves={33},pp={10}}
+ require('src.core.game3.battle.damage').ensureStats(fighter)
+ T.check(fighter.maxHp>1);T.eq(fighter.hp,fighter.maxHp)
+ local raw,owner=Source.resolve(fighter);T.eq(owner,g);T.eq(raw.species,'CHARMANDER');T.eq(raw.ivs.attack,20)
+ local def=g.data.moves.MOVE_033;local row=require('src.core.game3.battle.moves').get(33)
+ T.eq(row.power,def.power);T.eq(row.type,0);row.power=900;T.eq(def.power,35)
+ local damage,info=require('src.core.game3.battle.damage').calc({mon=fighter},{mon=fighter},33,{noCrit=true,rng=function(lo,hi)return hi or lo end})
+ T.check(damage>0);T.eq(info.critical,false);T.eq(info.effectiveness,1)
+ local NativeDamage=require('src.battle.Damage');local rules=require('src.battle.Rulesets').gen3_emerald
+ local b={mon=raw,def=g.data.pokemon.CHARMANDER,curStats=raw.stats,curTypes={'NORMAL'},stages={},items=g.data.items,statuses=g.data.statuses}
+ local expected=NativeDamage.compute(rules,b,b,def,{forceCrit=false,rng=function(lo,hi)return hi or lo end,data=g.data})
+ T.eq(damage,expected,'field damage shares the native formula')
+ nativeMon.stats=require('src.pokemon.Stats').calcGen3(g.data.pokemon.CHARMANDER,30,nativeMon.ivs,nativeMon.evs,nativeMon.nature);nativeMon.hp=nativeMon.stats.hp
+ nativeMon.level=30;nativeMon.exp=require('src.pokemon.Growth').expForLevel(g.data.pokemon.CHARMANDER.growthRate,30,g.data.growth_rates)
+ local exp=require('src.core.game3.battle.experience');local before=nativeMon.exp
+ local threshold=require('src.pokemon.Growth').expForLevel(g.data.pokemon.CHARMANDER.growthRate,31,g.data.growth_rates)
+ local award=exp.apply(mon,threshold-before+1)
+ T.eq(nativeMon.level,31);T.eq(award.fromLevel,30);T.eq(award.toLevel,31);T.eq(award.gained,threshold-before+1);T.eq(award.levels[1],31)
+ T.check(#award.steps>=1)
+ local sfx=require('src.core.game3.se_ids');T.eq(sfx.SE_SUCCESS,(edition=='firered'or edition=='leafgreen')and 25 or 31)
+ local catalogue=require('src.core.game3.items_data');T.eq(catalogue.info(7).pocket,'ITEMS');T.eq(catalogue.isTm(7),false)
+ local r=require('src.core.game3.rng');local random=r.Random32();T.check(random>=0 and random<4294967296 and random%1==0)
+ T.eq(r.mulU32(0xffffffff,0xffffffff),1)
+ T.eq(Message.show('Hello',{speed=0}),true);T.eq(Message.isOpen(),true);T.eq(Message.isWaiting(),true)
+ local box=g.stack:top();T.eq(box.done,true);T.eq(Message.currentPage(),'Hello')
+ local count,update=0,Message.tick
+ Message.tick=function()count=count+1;update();return update()end
+ box:update(1/60);T.eq(count,1);T.eq(g.stack:top(),box);Message.tick=update
+ T.eq(Message.close(),true);T.eq(g.stack:top(),w);T.eq(Message.isOpen(),false)
+ local chosen,calls=nil,0
+ T.eq(Choice.multi({'A','B','C'},1,function(index)chosen=index;calls=calls+1 end),true)
+ local choice=g.stack:top();f.input.edges.a=true;choice:update();f.input.edges.a=nil
+ T.eq(chosen,1);T.eq(calls,1);choice.onChoose(0);T.eq(calls,1,'one continuation per choice')
+ T.eq(g.stack:top(),w)
+ Message.showStay('Held',{speed=0});local held=g.stack:top()
+ local foreign={modOwnedScreen=true};g.stack:push(foreign)
+ Stream.cancelOwner('runtime_probe');T.eq(g.stack:top(),foreign,'teardown leaves foreign overlays intact')
+ for _,s in ipairs(g.stack.states)do T.neq(s,held)end
+ g.stack:pop()
+ -- Admission carries the visible individual into the actual native constructor.
+ local battle,cleanup,done=nil,0,0
+ function w:pushBattle(value)battle=value;g.stack:push(value);return true end
+ function w:afterBattle()cleanup=cleanup+1 end
+ Host.currentMod='runtime_probe'
+ local ok,why=require('src.core.game3.battle_bridge').startWild(nil,view,
+  {species=4,level=17,personality=0x12345678,ivs={hp=31,atk=30,def=29,spe=28,spa=27,spd=26},moves={33},pp={4},hp=12,status=64,item=7},
+  {done=function()done=done+1 end})
+ T.eq(ok,true,tostring(why));T.check(battle~=nil)
+ if battle then
+  T.eq(battle.enemy.mon.personality,0x12345678);T.eq(battle.enemy.mon.ivs.spdef,26)
+  T.eq(battle.enemy.mon.moves[1].pp,4);T.eq(battle.enemy.mon.hp,12);T.eq(battle.enemy.mon.status,'PAR');T.eq(battle.enemy.mon.item,'PROBE_ITEM')
+  battle.onFinish('run');battle.onFinish('run');T.eq(cleanup,1);T.eq(done,1)
+  g.stack:removeAll({battle})
+ end
+ -- Source collectors and follower renderers are presentation-only.
+ local Actors=require('src.compat.gen1.SourceActors')
+ local effects=require('src.core.game3.field_effects');local collect=effects.collectActors
+ local rendered,collectorCalls=0,0
+ local originalEntities=w.entities
+ effects.collectActors=function(rows,cx,cy)
+  collectorCalls=collectorCalls+1;collect(rows,cx,cy);collect(rows,cx,cy)
+  rows[#rows+1]={kind='test',x=32,y=48,sortY=48,elevation=3,draw=function()rendered=rendered+1 end}
+ end
+ local retainedActor
+ Actors.withActors(g,w,function()
+  T.neq(w.entities,originalEntities);T.eq(#w.entities,#originalEntities+1)
+  retainedActor=w.entities[#w.entities];retainedActor:draw(0,0)
+  T.eq(require('src.world.Collision').occupied(w.entities,retainedActor.cellX,retainedActor.cellY),nil,'a draw-only actor cannot enter the collision cast')
+ end)
+ T.eq(w.entities,originalEntities);T.eq(collectorCalls,1);T.eq(rendered,1)
+ T.eq(retainedActor:draw(0,0),false,'draw-only proxies retire after their frame')
+ T.raises(function()Actors.withActors(g,w,function()error('actor failure')end)end,'actor failure')
+ T.eq(w.entities,originalEntities,'failed custom rendering restores the logical actor collection')
+ effects.collectActors=collect
+ local Follower=require('src.compat.game3.Follower');local baseFollow=Follower.update;local updates=0
+ Follower.update=function()baseFollow();return baseFollow()end
+ Follower._dispatch(g,w,function()updates=updates+1 end);T.eq(updates,1);Follower.update=baseFollow
+ local menuSource=require('src.ui.game3.party_menu')
+ local menu=require('src.ui.Gen3PartyMenu').new(g)
+ g.stack:push(menu)
+ menu.submenu={{label='SUMMARY',action='summary'},{label='ITEM',action='item'},{label='CANCEL',action='cancel'}};menu.subIndex=1
+ local mu,mi=menuSource.update,menuSource.handleInput
+ menuSource.update=function(dt)
+  mu(dt);local a=menuSource.ACTIONS;if a and a[1]=='SUMMARY'and a[2]~='ROLE'then table.insert(a,2,'ROLE')end
+ end
+ menuSource.handleInput=function(input)
+  if input:wasPressed('a')and menuSource.ACTIONS[menuSource.actionCursor]=='ROLE'then
+   menuSource.ACTIONS={'FOLLOW','BACK'};menuSource.actionCursor=1;return true
+  end
+  return mi(input)
+ end
+ menu:update(1/60);T.eq(menu.submenu[2].sourceLabel,'ROLE');T.eq(menuSource._party[1].species,4)
+ menu.subIndex=2;f.input.edges.a=true;menu:update(1/60);f.input.edges.a=nil
+ T.eq(menu.submenu[1].sourceLabel,'FOLLOW','source submenu edits reach native navigation')
+ T.eq(menu.submenu[2].sourceLabel,'BACK');T.eq(menuSource.actionCursor,1)
+ menuSource.update,menuSource.handleInput=mu,mi
+ local peerSelected=0
+ menu.submenu={{label='PEER',onSelect=function()peerSelected=peerSelected+1 end},{label='CANCEL',action='cancel'}};menu.subIndex=1
+ menu:update(1/60)
+ local peerKey=menuSource.ACTIONS[1]
+ menuSource.ACTIONS={'ROLE',peerKey,'CANCEL'};menu:update(1/60)
+ Stream.cancelOwner('runtime_probe')
+ T.eq(#menu.submenu,2,'unloading removes only owned source action rows')
+ T.eq(menu.submenu[1].label,'PEER','native peer actions survive source teardown')
+ f.input.edges.a=true;menu:update(1/60);f.input.edges.a=nil
+ T.eq(peerSelected,1,'native callback-only submenu actions keep functioning')
+ g.stack:removeAll({menu})
+ -- Native evolution cancellation/completion and reminder windows remain owned.
+ local Evo=require('src.ui.game3.evolution_scene');local Relearn=require('src.ui.game3.move_relearner')
+ local row=g.data.pokemon.CHARMANDER
+ row.evolutions={{method='LEVEL',level=31,species='CHARMELEON'}}
+ T.eq(require('src.core.game3.evolution').levelTarget(mon,session),5)
+ local evoDone=0
+ local function closeText()
+  local class=require('src.render.TextBox')
+  for _=1,40 do
+   local top=g.stack:top();if getmetatable(top)~=class then return end
+   top:revealPage();top.holdFrames=0;top.preWait=0;top:advance()
+  end
+  error('native dialogue did not finish')
+ end
+ T.eq(Evo.start(mon,5,{onDone=function()evoDone=evoDone+1 end}),true)
+ local scene=g.stack.states[#g.stack.states-1];closeText();scene:stop();closeText()
+ T.eq(nativeMon.species,'CHARMANDER');T.eq(evoDone,1);T.eq(Evo.isOpen(),false);T.eq(g.stack:top(),w)
+ T.eq(Evo.start(mon,5,{onDone=function()evoDone=evoDone+1 end}),true)
+ scene=g.stack.states[#g.stack.states-1];closeText();scene:finish();closeText()
+ T.eq(nativeMon.species,'CHARMELEON');T.eq(mon.species,5);T.eq(evoDone,2);T.eq(g.stack:top(),w)
+ local movesRow=g.data.pokemon.CHARMELEON;movesRow.learnset={{level=1,move='GROWL'}}
+ T.eq(require('src.core.game3.move_learn').relearnableMoves(mon)[1],34)
+ local learned,learnDone=nil,0
+ local function chooseTop()
+  local input=g.input;local pressed=input.wasPressed
+  input.wasPressed=function(_,key)return key=='a'end
+  g.stack:update(1/60);input.wasPressed=pressed
+ end
+ T.eq(Relearn.show(mon,{onDone=function(ok)learned=ok;learnDone=learnDone+1 end}),true)
+ chooseTop();closeText()
+ T.eq(nativeMon.moves[2].id,'GROWL');T.eq(nativeMon.moves[2].pp,40)
+ T.eq(learned,true);T.eq(learnDone,1);T.eq(Relearn.isOpen(),false);T.eq(g.stack:top(),w)
+ nativeMon.moves[3]={id='TAIL_WHIP',pp=40};nativeMon.moves[4]={id='SPLASH',pp=40}
+ movesRow.learnset={{level=1,move='LEER'}}
+ T.eq(Relearn.show(mon,{onDone=function()learnDone=learnDone+1 end}),true)
+ chooseTop();T.eq(getmetatable(g.stack:top()),require('src.render.TextBox'))
+ Stream.cancelOwner('runtime_probe');T.eq(g.stack:top(),w);T.eq(learnDone,1)
+ T.eq(nativeMon.moves[4].id,'SPLASH','unloading a reminder cannot replace a native move')
+ -- Optional features retain native pools, input guards and consumption.
+ local Features=require('src.core.game3.enhancements')
+ local flags={timedEncounters=true,trainingDetails=true,repelPrompt=true,quickBall=true}
+ local release=Features.attach{active=function()return true end,option=function(key)return flags[key]end,
+  time=function()return 100 end,outdoors=function()return true end,language=function()return'en'end}
+ T.eq(Features.enabled('quickBall'),true)
+ g.mods.mods.runtime_probe.enabled=false;T.eq(Features.enabled('quickBall'),false,'disabled owner cannot enable native conveniences')
+ g.mods.mods.runtime_probe.enabled=true;T.eq(Features.enabled('quickBall'),true)
+ local sourcePool={grass={rate=100,buckets={60,100},bucketSpan=100,slots={{species='LARV',level=3,chance=60},{species='SEED',level=5,chance=40}}}}
+ g.data.pokemon.LARV={dex=19};g.data.pokemon.SEED={dex=10}
+ g.data.constants.speciesOrder[19]='LARV';g.data.constants.speciesOrder[10]='SEED'
+ g.data.encounters={TEST=sourcePool}
+ local nativePool=require('src.world.Encounter').forMap(g.data,w.map.def,'TEST',nil,g.save)
+ T.neq(nativePool,sourcePool);T.eq(nativePool.grass.slots[1].species,'SEED')
+ T.eq(nativePool.grass.slots[1].chance,60);T.eq(nativePool.grass.slots[2].chance,40)
+ T.eq(sourcePool.grass.slots[1].species,'LARV','timed frequencies do not rewrite imported pools')
+ local encounters=require('src.core.game3.encounters')
+ T.eq(encounters.tableFor(f.canonical).land.slots[1].species,10)
+ T.check(encounters.rollSweetScent(f.canonical,'land')~=nil,'guaranteed selection uses a native weighted pool')
+ T.eq(encounters.rollSweetScent(f.canonical,'water'),nil,'missing water never falls back to land')
+ local details=require('src.ui.TrainingDetails');local summary={game=g,page=2,mon=nativeMon,pages={'Info','Skills','Moves'}}
+ f.input.edges.select=true;require('src.ui.Gen3SummaryMenu').update(summary,1/60);f.input.edges.select=nil
+ T.eq(details.mode(summary),1);T.eq(details.stats(summary),nativeMon.ivs);T.eq(details.title(summary,'Skills'),'IV')
+ f.input.edges.select=true;require('src.ui.Gen3SummaryMenu').update(summary,1/60);f.input.edges.select=nil
+ T.eq(details.mode(summary),2);T.eq(details.stats(summary),nativeMon.evs)
+ flags.trainingDetails=false;T.eq(details.mode(summary),0);T.eq(details.stats(summary),nil)
+ g.data.items.MAX_REPEL={id='MAX_REPEL',name='MAX REPEL',index=88,pocket='ITEM'};g.save.inventory.MAX_REPEL=1
+ local prompt=require('src.ui.RepelPrompt');T.eq(prompt.show(g),true)
+ g.stack:top().choice(false);T.eq(g.save.inventory.MAX_REPEL,1);T.eq(g.save.repelSteps,nil)
+ T.eq(prompt.show(g),true);g.stack:top().choice(true)
+ T.eq(g.save.inventory.MAX_REPEL,nil);T.eq(g.save.repelSteps,250)
+ local nativeText=g.stack:top();nativeText:revealPage();nativeText:advance();T.eq(g.stack:top(),w)
+ g.data.items.POKE_BALL={id='POKE_BALL',name='POKE BALL',index=4,pocket='BALL'};g.save.inventory.POKE_BALL=2
+ local qb=require('src.battle.BattleState').newWild(g,'CHARMANDER',17);g.stack:push(qb)
+ qb.phase='menu';qb.queue={};qb.current=nil;qb.introSlide=0;qb.showEnemyTrainer=nil;qb.showPlayerBack=nil;qb.enemySendingOut=nil
+ local Q=require('src.battle.QuickItem');local thrown=0
+ qb.throwBall=function()thrown=thrown+1 end
+ f.input.edges.r=true;local request=Q.request(qb);f.input.edges.r=nil
+ T.check(request~=nil,'quick item uses the native idle-menu admission')
+ if request then T.eq(Q.dispatch(qb,request),true);T.eq(thrown,1);T.eq(g.save.inventory.POKE_BALL,1)end
+ qb.queue={{wait=1}};f.input.edges.r=true;T.eq(Q.request(qb),nil);f.input.edges.r=nil
+ T.eq(g.save.inventory.POKE_BALL,1,'busy combat cannot spend another ball')
+ g.stack:removeAll({qb});release();T.eq(Features.enabled('quickBall'),false)
+ T.eq(require('src.world.Encounter').forMap(g.data,w.map.def,'TEST',nil,g.save),sourcePool)
+ local prior=g.save;g.save={player=prior.player,options={}}
+ T.eq(session.party,nil);T.raises(function()mon.hp=1 end,'retired')
+ T.eq(Bag.add(session.bag or{},7,1),false)
+ Host.currentMod=nil;Stream.shutdown();G.release();bf.close()
+end
+T.finish('native companion commands, typed residents, UI and encounter lifecycle')
diff --git a/tests/engine/native_companion_terrain.lua b/tests/engine/native_companion_terrain.lua
new file mode 100644
index 000000000..f6603db48
--- /dev/null
+++ b/tests/engine/native_companion_terrain.lua
@@ -0,0 +1,164 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+love=require('tests.love_stub')
+local T=require('tests.harness')
+local C=require('src.core.game3.collision')
+local E=require('src.core.game3.encounters')
+local Map=require('src.core.game3.map')
+local Ledge=require('src.world.Ledge')
+local NativeMap=require('src.world.Map')
+local previous=package.loaded['src.core.Game']
+T.eq(previous,nil,'imports do not create a game')
+T.eq(E.ensureLoaded(),false);T.eq(E.tableFor('unknown'),nil);T.eq(E.terrainAt(0,0),nil)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  local f=require('tools.map-runtime.fixture').new(edition)
+  local g,w,m=f.game,f.world,f.map
+  w.player={cellX=0,cellY=0,elevation=6};w.entities={w.player}
+  g.save={player={},flags={},gen3Vars={}}
+  package.loaded['src.core.Game']=g
+  local def=assert(Map.currentDef())
+  for _,from in ipairs{0,3,6,15}do for _,to in ipairs{0,1,3,6,15}do
+    m.elevationPatch[1]=from;m.elevationPatch[2]=to;m:noteGridChange()
+    local first,second=C.nextElevation(def,6,1,0,0,0)
+    local keep=from==15 or to==15
+    T.eq(first,keep and 6 or to,'height follows stairs and bridge transitions')
+    local expected
+    if not keep and to~=0 then expected=to end
+    T.eq(second,expected,'secondary sprite elevation omits zero and bridge markers')
+    T.eq(select('#',C.nextElevation(def,6,1,0,0,0)),2,'source query keeps both return slots')
+    T.eq(m:elevationAfter(6,1,0,0,0),first,'native mover shares the transition')
+    T.eq(select('#',m:elevationAfter(6,1,0,0,0)),1,'native method keeps its return arity')
+  end end
+  m.elevationPatch[2]=3;m:noteGridChange()
+  T.eq(C.nextElevation(def,6,1,0),3,'an omitted previous cell still accepts the destination height')
+  T.eq(C.nextElevation({},6,1,0,0,0),6,'foreign map is not admitted')
+  T.eq(C.nextElevation(def,6,0/0,0,0,0),6)
+  local directions={'right','left','up','down','up','up','down','down'}
+  m.tileset.collision={};m.def.behaviorCells=nil
+  local W=require('src.world.OverworldController')
+  local gameSlot,oldGame
+  for i=1,100 do
+    local name,value=debug.getupvalue(W.checkLedgeHop,i)
+    if name=='Game'then gameSlot,oldGame=i,value;break end
+  end
+  assert(gameSlot);debug.setupvalue(W.checkLedgeHop,gameSlot,g)
+  local call
+  w.startLedgeHop=function(_,...)call={n=select('#',...),...};return true end
+  w.gen2LedgeAllows=function()return false end
+  for n=1,8 do
+    for _,dir in ipairs{'up','down','left','right'}do
+      -- Center is (1,0); only horizontal hops fit this tiny real map.
+      m.tileset.collision[m:blockAt(1,0)+1]=0x37+n
+      local originX=dir=='left'and 2 or 0
+      local lx,ly=C.ledgeLanding(g,originX,0,dir)
+      local matching=(dir=='right'or dir=='left')and directions[n]==dir
+      T.eq(lx,matching and (dir=='right'and 2 or 0)or nil,'ledge facing and landing bounds')
+      T.eq(ly,matching and 0 or nil)
+      w.player.cellX,w.player.cellY=originX,0
+      call=nil
+      T.eq(W.checkLedgeHop(w,dir),matching==true,'actual native input dispatch keeps its hop decision')
+      if matching then
+        T.eq(call[1],dir);T.eq(call[2],1);T.eq(call[3],0)
+        T.eq(call.n,3,'ordinary native hop callback preserves its argument count')
+      else T.eq(call,nil)end
+    end
+  end
+  debug.setupvalue(W.checkLedgeHop,gameSlot,oldGame)
+  m.tileset.ledgeBehaviours={[0x38]='west'}
+  m.tileset.collision[m:blockAt(1,0)+1]=0x38
+  T.eq(C.ledgeLanding(g,0,0,'right'),nil,'native dataset direction override wins')
+  T.eq(C.ledgeLanding(g,2,0,'left'),0)
+  T.eq(C.ledgeLanding(g,0,0,'bad'),nil)
+  T.eq(C.ledgeLanding(g,0/0,0,'right'),nil)
+  T.eq(C.ledgeLanding(g,1,0,'right'),nil,'never returns an off-map landing')
+  -- Pure source observations include current native patches and grass differs
+  -- from cave/desert encounter terrain. They do not execute movement hooks.
+  m.tileset.ledgeBehaviours=nil
+  m.grassTiles={[0]=true};m.encounterTiles={[0]=true,[1]=true}
+  m.collisionPatch={};m.elevationPatch={}
+  for y=0,1 do for x=0,2 do
+    T.eq(C.isGrass(x,y),m:isGrassCell(x,y))
+    local water=m:isWaterCell(x,y)
+    local expected=water and 'water'or m:isEncounterCell(x,y)and 'land'or nil
+    T.eq(E.terrainAt(x,y),expected)
+  end end
+  T.eq(C.isGrass(3,0),false);T.eq(E.terrainAt(3,0),nil)
+  T.eq(E.terrainAt(math.huge,0),nil);T.eq(E.terrainAt(1.5,0),nil)
+  m.tileset.collision[1],m.tileset.collision[2],m.tileset.collision[3]=2,3,0x15
+  m.grassTiles={[2]=true};m.encounterTiles={[2]=true,[3]=true}
+  m:setGen3Cells({{x=0,y=0,mid=0,coll=0,elev=3},{x=1,y=0,mid=1,coll=0,elev=3},
+    {x=2,y=0,mid=2,coll=0,elev=1}})
+  T.eq(C.isGrass(0,0),true);T.eq(C.isGrass(1,0),false)
+  T.eq(E.terrainAt(0,0),'land');T.eq(E.terrainAt(1,0),'land','caves need encounters without grass cover')
+  T.eq(E.terrainAt(2,0),'water')
+  m:setGen3Cells({{x=0,y=0,coll=1}})
+  T.eq(E.terrainAt(0,0),nil,'blocked grass is not encounter ground')
+  m.def.mapType='UNDERWATER';m.tileset.collision[1]=0x2a
+  m:setGen3Cells({{x=0,y=0,coll=0}})
+  T.eq(E.terrainAt(0,0),'water','seaweed uses native underwater rules, even without surfing')
+  m.tileset.collision[1]=0
+  T.eq(E.terrainAt(0,0),nil,'bare sea floor has no encounter terrain')
+  m.def.mapType='ROUTE'
+  g.data.pokemon={COMMON={index=1},SPARSE={index=277,dex=252}}
+  g.data.constants.speciesOrder={[1]='COMMON',[277]='SPARSE'}
+  local base={grass={rate=21,slots={{species='SPARSE',min=2,max=9}}},
+    water={rate=15,slots={{species='COMMON',level=12}}},
+    rock={rate=10,slots={{species='COMMON',min=3,max=4}}},
+    fish={rate=25,slots={{species='SPARSE',min=5,max=6}}}}
+  local alternate={grass={rate=9,slots={{species='COMMON',min=7,max=8}}}}
+  base.alternates={alternate}
+  g.data.encounters={NATIVE_A=base}
+  T.eq(E.ensureLoaded(),true)
+  local view=assert(E.tableFor(f.mapId))
+  T.eq(view.land.slots[1].species,277,'species uses cartridge slot, never National Dex')
+  T.eq(view.land.slots[1].minLevel,2);T.eq(view.land.slots[1].maxLevel,9)
+  T.eq(view.water.slots[1].level,12);T.eq(view.rocks.slots[1].minLevel,3)
+  T.eq(view.fishing.slots[1].species,277)
+  T.eq(E.tableFor('NATIVE_A').land.rate,21,'native map names resolve to the same owned map')
+  T.eq(E.tableFor(m.def.group..':'..m.def.number).land.rate,21,'ROM map slot aliases resolve')
+  T.eq(E.tableFor('unknown'),nil)
+  view.land.slots[1].species=1;view.land.rate=0
+  T.eq(base.grass.slots[1].species,'SPARSE');T.eq(base.grass.rate,21)
+  local variable=({firered=0x4024,leafgreen=0x4024,emerald=0x403e})[edition]
+  if variable then
+    g.save.gen3Vars[variable]=1
+    T.eq(E.tableFor(f.mapId).land.rate,9,'live script state selects alternate header')
+    T.eq(require('src.world.Encounter').forMap(g.data,m.def,m.id,nil,g.save),alternate,
+      'native wild encounters use the same effective table')
+    for _,invalid in ipairs{-1,2,65535,0/0,math.huge,1.5}do
+      g.save.gen3Vars[variable]=invalid
+      T.eq(E.tableFor(f.mapId).land.rate,21,'invalid alternate resets to base')
+    end
+    g.save.gen3Vars[variable]=0
+  end
+  local oldRandom=love.math.random
+  love.math.random=function()error('observation consumed native RNG')end
+  T.check(pcall(function()E.ensureLoaded();E.tableFor(f.mapId);E.terrainAt(0,0)end))
+  love.math.random=oldRandom
+  base.grass.slots[1].species='MISSING'
+  local missing,why=E.tableFor(f.mapId)
+  T.eq(missing,nil);T.check(why and why:find('cartridge index',1,true)~=nil)
+  g.data.encounters={NATIVE_A={grass={rate=3,slots={{species='COMMON',min=1,max=1}}}}}
+  T.eq(E.tableFor(f.mapId).land.rate,3,'native table replacement is observed immediately')
+  local raw=g.data.maps.NATIVE_A;g.data.maps.NATIVE_A={}
+  T.eq(E.tableFor(f.mapId),nil,'retired map identity cannot expose old encounters')
+  T.eq(C.nextElevation(def,6,1,0,0,0),6)
+  g.data.maps.NATIVE_A=raw
+  g.stack.states={{isTitle=true}}
+  T.eq(C.isGrass(0,0),false);T.eq(E.terrainAt(0,0),nil)
+  C.release();Map.release();f.views:release()
+end
+-- The native classifier still preserves pair rules, explicit overrides and
+-- the later-edition Distortion World and BW behavior spaces.
+do
+  local map={def={},tileset={},inBounds=function()return true end,cellBehaviour=function()return 0x5a end}
+  T.eq(Ledge.approach(map,{},0,0,'right'),false,'older pair rules retain native fallback')
+  map.def.generation=4;map.tileset.ledgeBehaviours={[0x5a]='east'}
+  local handled,x,y,distance,silent=Ledge.approach(map,{},0,0,'right')
+  T.eq(handled,true);T.eq(x,1);T.eq(y,0);T.eq(distance,3);T.eq(silent,true)
+  map.def.gen5=true;map.cellBehaviour=function()return 0x75 end
+  local _,bx,by=Ledge.approach(map,{},0,0,'down')
+  T.eq(bx,0);T.eq(by,1,'BW rules take precedence over imported stand-in tileset')
+end
+package.loaded['src.core.Game']=previous
+T.finish('native companion terrain and encounter observations')
diff --git a/tests/engine/native_companion_terrain_lifecycle.lua b/tests/engine/native_companion_terrain_lifecycle.lua
new file mode 100644
index 000000000..cddcc7019
--- /dev/null
+++ b/tests/engine/native_companion_terrain_lifecycle.lua
@@ -0,0 +1 @@
+dofile('tools/companion-terrain/lifecycle-check.lua')
diff --git a/tests/engine/native_constant_queries.lua b/tests/engine/native_constant_queries.lua
new file mode 100644
index 000000000..a1aa2aed1
--- /dev/null
+++ b/tests/engine/native_constant_queries.lua
@@ -0,0 +1,42 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local loaded=package.loaded['src.core.Game']
+local C=require('src.core.game3.constants');local G=require('src.core.Game3');local V=require('src.core.GameVersion')
+T.eq(package.loaded['src.core.Game'],loaded,'constant queries cannot construct Game')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+ game.data.field.playerForms={boy={picIndex=9},girl={picIndex=10}}
+ local view=G.forNative(game);local session=view.session
+ local out=C.active(session);T.eq(out.game,edition)
+ T.eq(out:require('trainer_classes','TRAINER_PIC_'..(V.isFRLG()and'RED'or'BRENDAN')),9)
+ local before=require('src.link.Json').encode(game.save)
+ local hoenn=not V.isFRLG()
+ if hoenn then
+  T.eq(out:require('metatile_labels','METATILE_Building_TV_Off'),2)
+  T.eq(out:require('metatile_labels','METATILE_Building_TV_On'),3)
+  local copy=out:raw('metatile_labels');copy.byName.METATILE_Building_TV_On=999
+  T.eq(out:require('metatile_labels','METATILE_Building_TV_On'),3,'raw enum leaves query detached')
+  out.metatile_labels.byName.METATILE_Building_TV_On=777
+  T.eq(C.of(edition):require('metatile_labels','METATILE_Building_TV_On'),3,'caller snapshot cannot edit shared facts')
+ else
+  T.eq(out.metatile_labels,nil,'another tileset namespace is not guessed from Hoenn IDs')
+  T.raises(function()out:require('metatile_labels','METATILE_Building_TV_On')end,'missing native constant')
+ end
+ T.eq(out:id('missing','missing'),nil,'legacy optional query behavior remains')
+ T.raises(function()out:require('missing','missing')end,'missing native constant')
+ T.raises(function()out:require({},'missing')end,'invalid native constant name')
+ T.raises(function()C.active({})end,'foreign or retired')
+ T.eq(require('src.link.Json').encode(game.save),before,'queries preserve native save and visit data')
+ for _,key in ipairs{'data','save','mods'}do
+  out=C.active(session);local old=game[key];game[key]={}
+  T.raises(function()out:require('trainer_classes','absent')end,'retired')
+  T.raises(function()C.active(session)end,'foreign or retired')
+  game[key]=old;session=G.forNative(game).session
+ end
+ out=C.active(session);V.set('crystal')
+ T.raises(function()out:require('trainer_classes','absent')end,'retired')
+ T.raises(function()C.active(session)end,'foreign or retired');V.set(edition)
+ G.release()
+end
+V.set('firered');T.finish('native required constants, detached numeric field facts and session boundaries')
diff --git a/tests/engine/native_coroutine_phase_scopes.lua b/tests/engine/native_coroutine_phase_scopes.lua
new file mode 100644
index 000000000..be7af3324
--- /dev/null
+++ b/tests/engine/native_coroutine_phase_scopes.lua
@@ -0,0 +1,117 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.harness')
+local B=require('src.compat.gen1.ScriptBoundary')
+local function pack(...)return {n=select('#',...),...}end
+local function resume(co,...)
+  local result=pack(coroutine.resume(co,...))
+  T.eq(result[1],true,'owned coroutine resumes without a native error')
+  return unpack(result,2,result.n)
+end
+local calls=0
+local result=pack(B.dispatch('once',function()calls=calls+1;return nil,'native',nil end,function()
+  T.same(pack(B.invoke('once')),{n=3,[2]='native'},'native nil tuple survives first consumption')
+  return B.invoke('once')
+end))
+T.same(result,{n=3,[2]='native'},'dispatch preserves source return arity')
+T.eq(calls,1,'repeated base calls execute the native body once')
+T.eq(B.active('once'),false,'return retires the native phase')
+
+local child,innerCalls= nil,0
+B.dispatch('parent',function()calls=calls+1;return 42 end,function()
+  child=coroutine.create(function()
+    T.eq(B.invoke('parent'),42,'a directly resumed child borrows its active parent body')
+    return B.dispatch('child',function()innerCalls=innerCalls+1 end,function()
+      coroutine.yield('held')
+      T.eq(B.invoke('replacement'),nil,'retired child cannot consume a newer native phase')
+      T.raises(function()B.dispatch('revived',function()end,function()error('must not run')end)end,
+        'retired','retired child cannot open a new attributed callback')
+      B.invoke('child')
+    end)
+  end)
+  T.eq(resume(child),'held')
+  T.eq(B.active('child'),false,'suspended child scope is invisible on its parent thread')
+  T.eq(B.invoke('child'),nil,'parent cannot consume a suspended child body')
+  resume(coroutine.create(function()
+    T.eq(B.active('child'),false,'another child cannot borrow the suspended sibling')
+    T.eq(B.invoke('parent'),42,'another direct child shares the same consumed parent tuple')
+  end))
+end)
+T.eq(innerCalls,0,'returning parent never executes a held nested body')
+local ok,why
+B.dispatch('replacement',function()return 'new native body'end,function()
+    ok,why=coroutine.resume(child)
+    T.eq(B.invoke('replacement'),'new native body','new native phase remains available to its actual caller')
+end)
+T.eq(ok,false,'resuming a retired nested dispatch fails closed')
+T.check(tostring(why):find('retired',1,true)~=nil,'retirement is reported explicitly')
+T.eq(innerCalls,0,'retired nested body cannot execute after resume')
+T.eq(B.active('parent'),false);T.eq(B.active('child'),false)
+
+local borrowed,borrowedCalls
+borrowedCalls=0
+B.dispatch('borrowed-body',function()
+  borrowedCalls=borrowedCalls+1
+  coroutine.yield('body held')
+  return 'old result'
+end,function()
+  borrowed=coroutine.create(function()
+    local consumed,errorValue=pcall(B.invoke,'borrowed-body')
+    T.eq(consumed,false,'a borrowed native body cannot publish after its parent retired')
+    T.check(tostring(errorValue):find('retired',1,true)~=nil)
+    T.eq(B.invoke('replacement-body'),nil,'catching retirement cannot consume a new native body')
+  end)
+  T.eq(resume(borrowed),'body held')
+end)
+B.dispatch('replacement-body',function()return 'fresh'end,function()
+  resume(borrowed)
+  T.eq(B.invoke('replacement-body'),'fresh','retired native body cannot consume replacement phase')
+end)
+T.eq(borrowedCalls,1,'retirement never retries a borrowed native body')
+
+local first=coroutine.create(function()
+  return B.dispatch('separate',function()return 'first' end,function()
+    coroutine.yield('old root')
+    T.eq(B.invoke('separate'),'first','resumed root consumes its own body, not a newer caller')
+  end)
+end)
+T.eq(resume(first),'old root')
+T.eq(B.active('separate'),false,'an independently suspended root is invisible')
+B.dispatch('separate',function()return 'second' end,function()
+  resume(first)
+  T.eq(B.invoke('separate'),'second','old root cleanup retains the newer root')
+end)
+T.eq(B.active('separate'),false,'neither root resurrects after completion')
+
+local ambiguous=coroutine.create(function()
+  return B.dispatch('ambiguous',function()error('old native body must not run')end,function()
+    coroutine.yield()
+    resume(coroutine.create(function()
+      T.eq(B.invoke('ambiguous'),nil,'independent resumer roots cannot lend an ambiguous phase')
+    end))
+  end)
+end)
+resume(ambiguous)
+B.dispatch('ambiguous',function()error('new native body must not run')end,function()resume(ambiguous)end)
+
+local failures=0
+ok,why=pcall(B.dispatch,'failed',function()failures=failures+1;error('owned native failure')end,function()
+  pcall(B.invoke,'failed');pcall(B.invoke,'failed')
+end)
+T.eq(ok,false);T.check(tostring(why):find('owned native failure',1,true)~=nil)
+T.eq(failures,1,'swallowing an exception cannot replay the native body')
+ok,why=pcall(B.dispatch,'false failure',function()error(false)end,function()pcall(B.invoke,'false failure')end)
+T.eq(ok,false,'false-valued native errors also cannot be swallowed');T.eq(why,false)
+
+-- Weak scope heads must not keep an abandoned independent coroutine alive.
+local weak=setmetatable({},{__mode='v'})
+do
+  local co=coroutine.create(function()
+    B.dispatch('abandoned',function()end,function()coroutine.yield()end)
+  end)
+  weak[1]=co;resume(co)
+end
+collectgarbage('collect');collectgarbage('collect')
+T.eq(weak[1],nil,'abandoned native scope does not pin its coroutine')
+T.eq(B.active('abandoned'),false)
+
+T.finish('Native coroutine phase borrowing, retirement and once-only native bodies')
diff --git a/tests/engine/native_dataset_source.lua b/tests/engine/native_dataset_source.lua
new file mode 100644
index 000000000..29e6ca1fa
--- /dev/null
+++ b/tests/engine/native_dataset_source.lua
@@ -0,0 +1,36 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Dataset=require('src.core.game3.dataset')
+local Fs=require('src.import.CacheFs')
+local Version=require('src.core.GameVersion')
+local Stream=require('src.core.game3.asset_stream')
+local root,fs=Fs.root,Fs.dataFs
+local seen,files={},{}
+Fs.root=function()return nil end
+Fs.dataFs=function()return{
+ read=function(name)seen[#seen+1]=name;return files[name]end,
+ getInfo=function(name)seen[#seen+1]=name;return files[name]and{type='file'}or nil end,
+}end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();require('src.core.Game3').release()
+ local f=require('tools.session-runtime.fixture').new(edition)
+ local prefix=Version.cachePrefix();local rel='data/generated/gba/native/test/palettes.bin'
+ files[prefix..rel]='exact-raw-'..edition..'\0\255';files[rel]='wrong-unversioned-artifact'
+ local cache=Dataset.cache();T.eq(Dataset.cache(),cache,'same native dataset retains its reader identity')
+ T.eq(cache:read(rel),files[prefix..rel]);T.eq(cache:exists(rel),true)
+ T.eq(seen[#seen],prefix..rel,'reader uses the current cartridge prefix without changing CacheFs.prefix')
+ T.eq(cache:read('data/generated/missing.bin'),nil);T.eq(cache:exists('data/generated/missing.bin'),false)
+ local count=#seen
+ for _,bad in ipairs{'../save.lua','saves/player.sav','data/generated/../save.lua','/data/generated/x','data/generated/C:\\save','data/generated//x'}do
+  T.eq(cache:read(bad),nil);T.eq(cache:exists(bad),false)
+ end
+ T.eq(#seen,count,'non-artifact paths never reach a filesystem')
+ local data=f.game.data;f.game.data={};Stream.poll()
+ T.eq(cache:read(rel),nil,'replacement import retires the old reader');T.eq(cache:exists(rel),false)
+ f.game.data=data;T.neq(Dataset.cache(),cache,'retired reader cannot revive')
+ local nextCache=Dataset.cache();Stream.shutdown();T.eq(nextCache:read(rel),nil,'shutdown revokes retained readers')
+ files={}
+end
+Fs.root,Fs.dataFs=root,fs
+T.finish('native imported artifact readers, edition isolation and session revocation')
diff --git a/tests/engine/native_display_presentation.lua b/tests/engine/native_display_presentation.lua
new file mode 100644
index 000000000..ac166cb2f
--- /dev/null
+++ b/tests/engine/native_display_presentation.lua
@@ -0,0 +1,97 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local initialGame=package.loaded['src.core.Game']
+local Display=require('src.core.game3.display')
+local R=require('src.render.Renderer')
+T.eq(package.loaded['src.core.Game'],initialGame,'display import cannot bootstrap another game')
+local g=love.graphics
+local dimensions,pixels,draw,newCanvas=g.getDimensions,g.getPixelDimensions,g.draw,g.newCanvas
+local ww,wh,pw,ph=1024,768,1024,768
+g.getDimensions=function()return ww,wh end;g.getPixelDimensions=function()return pw,ph end
+R:init()
+local zoom=require('src.render.Zoom');local oldZoom=zoom.offset;zoom.offset=0
+for _,size in ipairs{{1024,768,1024,768},{900,600,1800,1200},{640,480,1280,1440},{400,800,1100,2200}}do
+ ww,wh,pw,ph=unpack(size)
+ for _,surface in ipairs{{240,160},{304,144}}do
+  R:setUISize(unpack(surface));R:beginFrame()
+  local before=R:frameRects()
+  local cx,cy,sx,sy
+  g.draw=function(image,x,y,rotation,scaleX,scaleY)
+   if image==R.canvas then cx,cy,sx,sy=x,y,scaleX,scaleY end
+  end
+  R:endFrame()
+  local active=R:surfaceRects(unpack(surface))
+  T.eq(active.uox,cx);T.eq(active.uoy,cy);T.eq(active.Ux,sx);T.eq(active.Uy,sy,'active fitting matches the actual native UI blit')
+  g.newCanvas=function()error('fitting must not allocate a GPU target')end
+  local x,ox,oy,width,height,y=Display.fit()
+  T.eq(width,240*x);T.eq(height,160*y);T.eq(x*before.dpiX,y*before.dpiY,'detached fit retains square framebuffer pixels')
+  local capture=R:surfaceRects(240,160,700,500)
+  T.eq(capture.ww,700);T.eq(capture.wh,500);T.eq(capture.pw,700*before.dpiX);T.eq(capture.ph,500*before.dpiY)
+  T.eq(capture.uiw,240);T.eq(capture.uih,160)
+  T.eq(R:uiSize(),surface[1]);T.eq(select(2,R:uiSize()),surface[2],'capture fitting cannot resize the native controller surface')
+  capture.uiw=1;T.eq(R:surfaceRects(240,160,700,500).uiw,240)
+  local after=R:frameRects();T.eq(after.Ux,before.Ux);T.eq(after.uox,before.uox);T.eq(after.uiw,before.uiw)
+  g.newCanvas=newCanvas
+ end
+end
+T.raises(function()Display.fit(0,500)end,'positive finite dimensions')
+T.raises(function()Display.fit(0/0,500)end,'positive finite dimensions')
+T.raises(function()R:surfaceRects(-1,160)end,'positive finite dimensions')
+R:setUISize(240,160)
+local fit,uiScale=R.fitScale,R.uiScale
+R.fitScale=function()return 3 end;R.uiScale=function()return 2 end
+local x,ox,oy,width,height,y=Display.fit();T.eq(x*R:frameRects().dpiX,2,'active surface observes native scale overrides');T.eq(width,240*x)
+R.fitScale,R.uiScale=fit,uiScale
+R.uiCentered=false;R.worldActive=true;zoom.offset=-2
+local q=R:surfaceRects(240,160,1200,800);T.check(q.Up<=q.Sp);T.check(q.Up>=math.ceil(q.Sp/2))
+R.uiFill=true;q=R:surfaceRects(240,160,713,481);T.eq(q.Up,math.min(q.pw/240,q.ph/160))
+R.uiFill=false;R.uiCentered=true;zoom.offset=0
+ww,wh,pw,ph=1024,768,1024,768;g.draw=draw
+local NativeGame=require('src.core.Game')
+local G=require('src.core.Game3')
+local f=require('tools.battle-source-runtime.fixture').new('firered')
+-- Retain the real class helpers used by the current native compositor while
+-- exposing this synthetic session through the normal singleton binding.
+local game=setmetatable(f.game,{__index=NativeGame});package.loaded['src.core.Game']=game
+local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b)
+local base=Display.present
+T.eq(base(G.forNative(game)),nil,'a source present call outside its native phase cannot draw')
+local callbacks,serial,frame=0,R.frameSerial,b.frame
+Display.present=function(view)
+ callbacks=callbacks+1;T.eq(G.native(view),game)
+ local depth=g.getStackDepth and g.getStackDepth()
+ base(view);base(view)
+ return false,nil,'native display return'
+end
+local a,middle,c=NativeGame._draw(game)
+T.eq(a,false);T.eq(middle,nil);T.eq(c,'native display return');T.eq(callbacks,1)
+T.eq(R.frameSerial,serial+1,'two source base calls paint one actual native frame');T.eq(b.frame,frame,'presentation cannot update the combat clock')
+T.eq(base(G.forNative(game)),nil)
+local depth=g.getStackDepth and g.getStackDepth()
+Display.present=function()g.push();error('source display failure')end
+T.raises(function()NativeGame._draw(game)end,'source display failure')
+if depth then T.eq(g.getStackDepth(),depth,'source graphics pushes cannot escape the native frame')end
+Display.present=function(view)
+ local ok=pcall(base,view);T.eq(ok,false);return true
+end
+local begin=R.beginFrame;R.beginFrame=function()error('native frame failure')end
+T.raises(function()NativeGame._draw(game)end,'native frame failure');R.beginFrame=begin
+Display.present=function(view)local saved=game.save;game.save={options={}};local value,why=base(view);game.save=saved;return value,why end
+serial=R.frameSerial;a,c=NativeGame._draw(game);T.eq(a,false);T.eq(c,'native display cohort changed');T.eq(R.frameSerial,serial)
+Display.present=function(view)game.stack:push({});local value,why=base(view);game.stack:pop();return value,why end
+serial=R.frameSerial;a,c=NativeGame._draw(game);T.eq(a,false);T.eq(R.frameSerial,serial,'a changed stack cannot paint the previously resolved frame')
+local seams=require('src.mods.ModSeams');local priorOwner=G._callbackOwner()
+Display.present=function(view)T.eq(G._callbackOwner(),'display_owner');return base(view)end
+seams._journal[#seams._journal+1]={tbl=Display,key='present',after=Display.present,owner='display_owner'}
+serial=R.frameSerial;NativeGame._draw(game);T.eq(R.frameSerial,serial+1);T.eq(G._callbackOwner(),priorOwner);table.remove(seams._journal)
+Display.present=base;serial=R.frameSerial;NativeGame._draw(game);T.eq(R.frameSerial,serial+1,'unmodified display keeps direct native painting')
+-- Merely importing this module cannot redirect an ordinary non-GBA frame.
+game.stack:pop();game.stack:push({uiSize=function()return 160,144 end,draw=function()g.rectangle('fill',0,0,8,8)end,isOpaque=function()return true end})
+require('src.core.GameVersion').set('red')
+Display.present=function()error('source GBA presentation reached another generation')end
+serial=R.frameSerial;NativeGame._draw(game);T.eq(R.frameSerial,serial+1)
+Display.present=base;require('src.core.GameVersion').set('firered');f.close();G.release()
+package.loaded['src.core.Game']=initialGame
+g.getDimensions,g.getPixelDimensions,g.draw,g.newCanvas=dimensions,pixels,draw,newCanvas;zoom.offset=oldZoom
+T.finish('native display surface fitting, frame ownership and once-only presentation')
diff --git a/tests/engine/native_door_observations.lua b/tests/engine/native_door_observations.lua
new file mode 100644
index 000000000..d09d72c81
--- /dev/null
+++ b/tests/engine/native_door_observations.lua
@@ -0,0 +1,19 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local G=require('src.core.Game3')
+local Doors=require('src.core.game3.doors')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ G.release();local f=require('tools.session-runtime.fixture').new(edition)
+ T.eq(Doors.getActiveAnim(),nil);T.eq(Doors.isBusy(),false);T.eq(Doors.draw(),false)
+ local slide={mapId=f.world.map.id,room=1,step=3,timer=1};f.world.gymDoorSlide=slide
+ local a=assert(Doors.getActiveAnim());T.eq(a.x,1);T.eq(a.y,104);T.eq(a.frame,1);T.eq(a.nativeFrame,2)
+ T.eq(Doors.getActiveAnim(f.canonical,7,104).x,7,'both native simultaneously animated cells can be observed')
+ T.eq(Doors.getActiveAnim('OTHER'),nil);T.eq(Doors.getActiveAnim(nil,2,104),nil)
+ a.frame=99;T.eq(Doors.getActiveAnim().frame,1,'source pose cannot rewrite native animation')
+ T.eq(slide.step,3);T.eq(slide.timer,1,'observation cannot advance the native task')
+ f.world.gymDoorSlide.mapId='RETIRED';T.eq(Doors.getActiveAnim(),nil)
+ f.world.gymDoorSlide=nil;T.eq(Doors.isBusy(),false)
+ G.release()
+end
+T.finish('native door slide observations and map retirement')
diff --git a/tests/engine/native_fade_source.lua b/tests/engine/native_fade_source.lua
new file mode 100644
index 000000000..4c00024e3
--- /dev/null
+++ b/tests/engine/native_fade_source.lua
@@ -0,0 +1,53 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Fade=require('src.ui.game3.fade')
+local Layer=require('src.render.FieldFade')
+local Transition=require('src.render.Transition')
+local Host=require('src.mods.Runtime')
+local Stream=require('src.core.game3.asset_stream')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();require('src.core.Game3').release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g,w=f.game,f.world
+ g.mods.mods={fade_owner={enabled=true},peer={enabled=true}}
+ local gameUpdate=w.update;w.update=function()error('source fade cannot pump a second field clock')end
+ Host.currentMod='fade_owner'
+ T.eq(Fade.isActive(),false);T.eq(Fade.t,0)
+ local done=0
+ T.eq(Fade.begin(Fade.MODE.TO_BLACK,2,function()done=done+1 end),true)
+ local owned=g.stack:top();T.eq(getmetatable(owned),Layer)
+ T.eq(Fade.lockInput,true);T.eq(Fade._dir,1)
+ for step=1,32 do
+  g.stack:update(1/60);T.eq(Fade.t,math.floor(step/2),'source palette step follows native fixed ticks')
+ end
+ T.eq(done,1);T.eq(Fade.t,16);T.eq(Fade.isActive(),false);T.eq(g.stack:top(),owned,'covered palette remains until its owner clears it')
+ for _=1,130 do g.stack:update(1/60)end
+ T.eq(Fade.t,16,'an owned hold does not trigger the native abandoned-script watchdog')
+ Host.currentMod='peer';T.eq(Fade.clear(),false);T.eq(Fade.begin(0,1),false);T.eq(g.stack:top(),owned)
+ Host.currentMod='fade_owner';T.eq(Fade.begin(Fade.MODE.FROM_BLACK,1,function()done=done+1 end),true)
+ for _=1,16 do g.stack:update(1/60)end
+ T.eq(done,2);T.eq(Fade.t,0);T.eq(g.stack:top(),w);T.eq(owned.sourceRetired,true)
+ T.eq(Fade.begin(Fade.MODE.TO_WHITE,1,function()done=done+100 end),true)
+ local old=g.stack:top();g.renderer={};old:draw();T.check(g.renderer.screenVeil~=nil)
+ collectgarbage('collect');Stream.cancelOwner('fade_owner')
+ T.eq(g.stack:top(),w);T.eq(g.renderer.screenVeil,nil,'unload releases the owned window veil')
+ T.eq(old.sourceRetired,true);T.eq(old.game,nil);old:update(1/60);old:draw();T.eq(done,2)
+ -- Native fades remain native, including script runner progress and cleanup.
+ w.update=gameUpdate
+ local script=Layer.new(g,w,'white');w.fadeOverlay=script
+ script.ramp={from=0,to=1,frames=4,t=0}
+ g.stack:push(script)
+ T.eq(Fade.isActive(),true);T.eq(Fade.mode,3);T.eq(Fade._dir,1)
+ T.eq(Fade.clear(),false);T.eq(Fade.begin(0,1),false,'a source request cannot replace a native script fade')
+ script.ramp.t=2;script.alpha=.5;T.eq(Fade.t,8)
+ g.stack:removeAll({script});T.eq(w.fadeOverlay,nil)
+ local warp=Transition.new(g);g.stack:push(warp);warp.t=math.floor(warp.frames/2)
+ T.eq(Fade.isActive(),true);T.eq(Fade.t,math.floor(warp:alpha()*16+.5));T.eq(Fade.mode,1)
+ warp.phase='in';T.eq(Fade._dir,-1);T.eq(Fade.mode,0)
+ g.stack:removeAll({warp});T.eq(Fade.lockInput,false)
+ local flash=Transition.whiteFlash(g);g.stack:push(flash);T.eq(Fade.t,16);T.eq(Fade.mode,2);g.stack:removeAll({flash})
+ local back=Transition.battleReturn(g);g.stack:push(back);T.eq(Fade.mode,2);T.eq(Fade._dir,-1);g.stack:removeAll({back})
+ T.raises(function()Fade.t=10 end,'read-only');T.raises(function()Fade.begin(1,0)end,'invalid native fade speed')
+ Host.currentMod=nil;Stream.shutdown();require('src.core.Game3').release()
+end
+T.finish('native fade observations, owned palette steps and foreign-owner isolation')
diff --git a/tests/engine/native_field_collision.lua b/tests/engine/native_field_collision.lua
new file mode 100644
index 000000000..86c6f0863
--- /dev/null
+++ b/tests/engine/native_field_collision.lua
@@ -0,0 +1 @@
+dofile('tools/field-collision/check.lua')
diff --git a/tests/engine/native_field_effect_sheets.lua b/tests/engine/native_field_effect_sheets.lua
new file mode 100644
index 000000000..4da051d23
--- /dev/null
+++ b/tests/engine/native_field_effect_sheets.lua
@@ -0,0 +1 @@
+dofile('tools/field-effect-sheets/check.lua')
diff --git a/tests/engine/native_field_move_audio.lua b/tests/engine/native_field_move_audio.lua
new file mode 100644
index 000000000..d03055026
--- /dev/null
+++ b/tests/engine/native_field_move_audio.lua
@@ -0,0 +1 @@
+dofile('tools/field-move-runtime/audio-check.lua')
diff --git a/tests/engine/native_field_move_lifecycle.lua b/tests/engine/native_field_move_lifecycle.lua
new file mode 100644
index 000000000..c8a81da29
--- /dev/null
+++ b/tests/engine/native_field_move_lifecycle.lua
@@ -0,0 +1 @@
+dofile('tools/field-move-runtime/lifecycle-check.lua')
diff --git a/tests/engine/native_field_move_presentation.lua b/tests/engine/native_field_move_presentation.lua
new file mode 100644
index 000000000..731649605
--- /dev/null
+++ b/tests/engine/native_field_move_presentation.lua
@@ -0,0 +1,133 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local _,imageFile=require('tools.sprite-runtime.cpu-gpu').install(love)
+local Source=require('src.core.game3.field_move_show_mon')
+local Native=require('src.world.Gen3FieldMove')
+local Host=require('src.mods.Runtime')
+local Renderer=require('src.render.Renderer')
+T.eq(Source.isActive(),false,'requiring the bridge does not invent a native admission')
+local saved={start=Source.start,step=Source.step,draw=Source.draw}
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  Source.release()
+  local fixture=require('tools.session-runtime.fixture').new(edition)
+  local game=fixture.game;local stack=game.stack
+  game.data.pokemon={[1]={name='TEST',spriteFront='assets/generated/field-mon.png'}}
+  imageFile('assets/generated/field-mon.png',16,16,string.rep(string.char(17,31,47,255),256))
+  local strip={width=256,height=80,indexed=string.rep('\1',256*80),palette={}}
+  for i=1,16 do strip.palette[i]=i end
+  game.data.constants.gen3FieldMovePresentation={schema=1,edition=edition,romSha1=require('src.core.GameVersion').info(edition).sha1,strips={outdoors=strip,indoors=strip}}
+  local completions=0
+  local mon={species=1}
+  local starts,steps,draws=0,0,0
+  Source.start=function(...)starts=starts+1;return saved.start(...)end
+  Source.step=function(...)steps=steps+1;local a,b=saved.step(...);saved.step(...);return a,b end
+  Source.draw=function(...)draws=draws+1;local a,b=saved.draw(...);saved.draw(...);return a,b end
+  local shown,state=Native.show(game,mon,function()completions=completions+1;return 'continued',nil,7 end)
+  T.eq(shown,true);T.eq(starts,1,'native entry reaches the existing public start wrapper once')
+  local theme=require('src.ui.Theme');local previousBox=theme.textBox
+  for _,box in ipairs{{tx=0,ty=0,tw=20,th=18},{tx=0,ty=0,tw=32,th=24}}do
+    theme.textBox=box
+    local width,height=state:uiSize();T.eq(width,240,'dialogue themes cannot resize a native field cut-in');T.eq(height,160)
+  end
+  theme.textBox=previousBox
+  T.eq(Source.isActive(),true);T.eq(fixture.player.fieldMove,true)
+  T.eq(Native.show(game,mon),false,'one native field-move admission cannot overlap another')
+  Source.release();T.eq(Source.isActive(),true,'observer teardown preserves an engine-owned field move')
+  local retained=state.onDone
+  T.eq(retained(),false,'a retained callback cannot finish before its native admission')
+  T.eq(completions,0)
+  local before=state.t;saved.step();T.eq(state.t,before,'source calls outside the phase cannot advance native logic')
+  stack:update(1/60);T.eq(state.t,before+1,'duplicate base calls advance the real native tick once')
+  T.eq(steps,1)
+  local age=state.frame
+  Renderer.frameSerial=(Renderer.frameSerial or 0)+1
+  state:draw();T.eq(state.frame,age,'native drawing cannot advance animation')
+  T.eq(draws,1)
+  local cover={};stack:push(cover)
+  T.eq(state:finish(),false,'covered field moves cannot pop another native screen')
+  state:update();T.eq(state.t,before+1,'direct updates cannot advance a covered admission')
+  T.eq(stack:top(),cover);stack:pop()
+  for i=1,100 do stack:update(1/60)end
+  T.eq(completions,1,'real native completion calls the pending callback once')
+  T.eq(Source.isActive(),false);T.eq(state.sprite,nil,'native exit releases its owned image')
+  T.eq(fixture.player.fieldMove,nil);T.eq(fixture.player.fieldMovePose,nil)
+  local a,b,c=retained();T.eq(a,'continued');T.eq(b,nil);T.eq(c,7);T.eq(completions,1,'retained callbacks cannot replay')
+  Source.start=saved.start;Source.step=saved.step;Source.draw=saved.draw
+  Host.currentMod='source-owner'
+  T.eq(Source.start(1,{pose=false},function()completions=completions+1 end),true)
+  Host.currentMod=nil
+  state=stack:top();T.eq(state.player,nil,'source pose=false does not change the native player')
+  local cancelCallback=state.onDone
+  local payload=setmetatable({},{__mode='v'})
+  do
+    local held={};payload[1]=held
+    Source.reset()
+    Host.currentMod='source-owner'
+    Source.start(1,{pose=true},(function(value)return function()return value end end)(held))
+    Host.currentMod=nil
+  end
+  state=stack:top();local heldCallback=state.onDone
+  stack:push(cover);Source.cancelOwner('source-owner')
+  T.eq(stack:top(),cover,'owner retirement preserves a covering native screen')
+  T.eq(Source.isActive(),false);T.eq(fixture.player.fieldMove,nil)
+  collectgarbage('collect');collectgarbage('collect')
+  T.eq(payload[1],nil,'even peer-held wrappers release cancelled callback captures')
+  T.eq(heldCallback(),false);T.eq(cancelCallback(),false)
+  stack:pop();stack:update(1/60);T.eq(stack:top(),fixture.world,'cancelled covered admission retires when uncovered')
+  local count=completions
+  Native.show(game,mon,function()completions=completions+1 end)
+  state=stack:top();local stale=state.onDone
+  local oldSave=setmetatable({game.save},{__mode='v'})
+  game.save={};state:update()
+  T.eq(stack:top(),fixture.world,'save replacement retires the exact native admission')
+  T.eq(stale(),false);T.eq(completions,count)
+  collectgarbage('collect');collectgarbage('collect')
+  T.eq(oldSave[1],nil,'peer-held callbacks cannot retain an entire retired save cohort')
+  Native.show(game,mon,function()error('deliberate continuation error')end)
+  state=stack:top();local failed=state.onDone
+  T.raises(function()state:finish()end,'deliberate continuation error','callback failure remains observable')
+  T.raises(failed,'deliberate continuation error','retained callback preserves error without replay')
+  T.eq(stack:top(),fixture.world);T.eq(state.sprite,nil)
+  -- The normal draw and an explicit source draw share one render admission.
+  Native.show(game,mon,nil,{pose=false});state=stack:top()
+  state.phase='in';state.t=1
+  local rectangles=0;local rectangle=love.graphics.rectangle
+  love.graphics.rectangle=function(...)rectangles=rectangles+1;return rectangle(...)end
+  Renderer.frameSerial=(Renderer.frameSerial or 0)+1
+  saved.draw();local external=rectangles
+  T.check(external>0,'explicit source draw paints the actual native effect')
+  state:draw();T.eq(rectangles,external,'native UI does not paint the same externally drawn cut-in again')
+  Renderer.frameSerial=Renderer.frameSerial+1
+  state:draw();T.check(rectangles>external,'a following frame retains the ordinary native draw')
+  love.graphics.rectangle=rectangle
+  state:cancel()
+  local nested,again,invocations
+  invocations=0
+  Native.show(game,mon,function()invocations=invocations+1;nested=again();return 'native-result'end)
+  state=stack:top()
+  again=state.onDone
+  -- Reentrant continuations retain the already-executing guard, not a new
+  -- native admission or a second callback execution.
+  state:finish();T.eq(nested,false);T.eq(invocations,1);T.eq(again(),'native-result')
+  game.data.pokemon[2]={name='REPLACEMENT',spriteFront='assets/generated/field-mon-two.png'}
+  imageFile('assets/generated/field-mon-two.png',16,16,string.rep(string.char(91,73,53,255),256))
+  Source.start=function(_,_,callback)return saved.start({species=2},{pose=false},callback)end
+  local changed
+  Native.show(game,mon,function()changed=true end)
+  state=stack:top();T.eq(state.mon.species,2,'native start wrappers configure the actual admitted Pokemon')
+  T.eq(state.player,nil,'native start wrappers can disable their native pose')
+  T.eq(state.spritePath,'assets/generated/field-mon-two.png','configured picture uses the native art resolver')
+  state:finish();T.eq(changed,true)
+  Source.start=function()return false end
+  T.eq(Native.show(game,mon,function()error('vetoed field move continued')end),false,'explicit native start veto retires its provisional admission')
+  T.eq(stack:top(),fixture.world);T.eq(fixture.player.fieldMove,nil)
+  Source.start=saved.start
+  Host.currentMod='completed-owner';Source.start(1,{},function()return {}end);Host.currentMod=nil
+  state=stack:top();local completedCallback=state.onDone
+  state:finish();T.eq(type(completedCallback()),'table')
+  Source.cancelOwner('completed-owner');T.eq(completedCallback(),false,'retired source callbacks cannot replay cached results')
+  T.eq(Source.start(1,{noDuck=true}),true,'cry options use the authenticated native profile');Source.reset()
+  T.eq(Source.start({},{}),false,'missing real picture cannot create a fake successful effect')
+end
+Source.release();T.finish('native field-move admission, one clock, explicit draw and continuation lifetime')
diff --git a/tests/engine/native_field_move_runtime.lua b/tests/engine/native_field_move_runtime.lua
new file mode 100644
index 000000000..08b110242
--- /dev/null
+++ b/tests/engine/native_field_move_runtime.lua
@@ -0,0 +1 @@
+dofile('tools/field-move-runtime/check.lua')
diff --git a/tests/engine/native_field_observations.lua b/tests/engine/native_field_observations.lua
new file mode 100644
index 000000000..5abf3c68a
--- /dev/null
+++ b/tests/engine/native_field_observations.lua
@@ -0,0 +1,53 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local G=require('src.core.Game3')
+local Collision=require('src.core.game3.collision')
+local Weather=require('src.core.game3.field_weather')
+local Warp=require('src.world.Warp')
+local Host=require('src.mods.Runtime')
+local Identity=require('src.compat.gen1.MapIdentity')
+local previousHooks=Host.hooks
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ G.release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g,w=f.game,f.world
+ f.map.def.warps={{x=3,y=4},{x=5,y=6}}
+ g.data.constants.gen3WeatherNames={[0]='NONE',[3]='RAIN',[5]='RAIN_THUNDERSTORM',[13]='DOWNPOUR',[20]='ROUTE119_CYCLE'}
+ local calls=0
+ Host.hooks={chains={['warp.destination']={{}}},call=function()calls=calls+1;error('forecast invoked committing hook')end}
+ local before=require('src.link.Json').encode(g.save)
+ local id,x,y=Collision.resolveWarpDestination(g,{destMap=f.canonical,destWarp=2})
+ T.eq(id,f.canonical);T.eq(x,5);T.eq(y,6)
+ local raw=Warp.peekDestination(g.data,{destMap='TEST',destWarp=2},nil,nil,g.save)
+ T.eq(raw,'TEST');T.eq(calls,0)
+ T.eq(Collision.resolveWarpDestination(g,{destMap='UNIMPORTED'}),nil)
+ T.eq(Collision.resolveWarpDestination(g,{destMap=f.canonical,destWarp=-1}),nil)
+ local canon,xx,yy=Collision.resolveWarpDestination(g,{destMap='TEST',destWarp=1})
+ T.eq(canon,f.canonical);T.eq(xx,3);T.eq(yy,4)
+ T.eq(Collision.resolveWarpDestination(g,{mapGroup=f.map.def.group,mapNum=f.map.def.number,destWarp=2}),f.canonical)
+ T.eq(Warp.peekDestination(g.data,{destMap='LAST_MAP',destWarp=1}),nil)
+ T.eq(require('src.link.Json').encode(g.save),before,'ordinary forecasts never write native state')
+ g.save.gen3DynamicWarp={map='TEST',warp=1,x=17,y=18}
+ canon,xx,yy=Collision.resolveWarpDestination(g,{nativeDestination='MAP_G127_N127',mapGroup=127,mapNum=127})
+ T.eq(canon,f.canonical);T.eq(xx,5);T.eq(yy,6,'dynamic warp uses native zero-based landing index')
+ g.save.gen3DynamicWarp.warp=255
+ canon,xx,yy=Collision.resolveWarpDestination(g,{mapGroup=127,mapNum=127})
+ T.eq(xx,17);T.eq(yy,18,'native coordinate sentinel is preserved')
+ g.save.gen3WeatherActive=3;T.eq(Weather.getWeather(),3)
+ g.save.gen3WeatherActive=20;g.save.gen3WeatherStage=2;w.weatherFrame=91
+ T.eq(Weather.getWeather(),5,'weather uses the native resolved cycle stage')
+ T.eq(w.weatherFrame,91,'weather observation cannot advance native clock')
+ g.save.gen3WeatherStage=3;T.eq(Weather.getWeather(),3)
+ g.save.gen3WeatherActive=99;T.eq(Weather.getWeather(),nil,'unknown weather is not invented')
+ local SourceWeather=require('src.core.game3.weather')
+ T.eq(SourceWeather.SUNNY,2);T.eq(SourceWeather.RAIN,3)
+ g.data.constants.gen3WeatherNames=nil;g.save.gen3WeatherActive=0
+ T.eq(SourceWeather.get(),0,'editions without extracted cycle records share native enum')
+ T.eq(SourceWeather.isActive(),false)
+ g.save.gen3WeatherActive=5;T.eq(SourceWeather.get(),5);T.eq(SourceWeather.isActive(),true)
+ g.stack.states={};g.stack.worldState=nil;T.eq(Weather.getWeather(),nil,'retired world has no active weather')
+ T.eq(Collision.resolveWarpDestination(g,{destMap='TEST'}),nil,'retired world cannot forecast a warp')
+ Collision.release();G.release()
+end
+Host.hooks=previousHooks
+T.finish('native read-only warp forecasts and resolved weather observations')
diff --git a/tests/engine/native_file_picker.lua b/tests/engine/native_file_picker.lua
new file mode 100644
index 000000000..010bf08a2
--- /dev/null
+++ b/tests/engine/native_file_picker.lua
@@ -0,0 +1,68 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit');local Host=require('src.core.HostShell')
+local oldSystem=love.system;love.system=love.system or{}
+local osName='UWP';local osGet=love.system.getOS;love.system.getOS=function()return osName end
+local oldGame=package.loaded['src.core.Game'];local F=require('src.core.FilePicker')
+T.eq(package.loaded['src.core.Game'],oldGame,'import cannot bootstrap Game')
+local oldPop,oldHas=Host.popen,Host.hasCommand
+local probes,closed={},0
+Host.popen=function(cmd)probes[#probes+1]=cmd;return{read=function()return '/usr/bin/zenity\n'end,close=function()closed=closed+1 end}end
+for _,os in ipairs{'UWP','NX','Android','iOS','Web','Unknown'}do
+ osName=os;T.eq(Host.hasCommand('zenity'),false);T.eq(F.available(),false)
+ T.eq(F.commands('Choose',F.IMAGE),nil);T.eq(F.open('Choose',F.IMAGE),nil)
+end
+T.eq(#probes,0,'unsupported hosts never probe or spawn')
+osName='Linux'
+for _,name in ipairs{'zenity;touch nope','a b','../tool','-bad','$(bad)','x\nfoo','x%PATH%'}do T.eq(Host.hasCommand(name),false)end
+T.eq(#probes,0);T.eq(Host.hasCommand('zenity'),true);T.eq(closed,1)
+Host.popen=function()return{read=function()error('owned probe read failure')end,close=function()closed=closed+1 end}end
+T.eq(Host.hasCommand('zenity'),false);T.eq(closed,2,'failed probe closes pipe')
+local available={zenity=true,kdialog=true};Host.hasCommand=function(n)return available[n]or false end
+local kind={label='QA sprite package',exts={'SPRITEPACK','spritepack'}}
+local prompt='QA \' " $(do-not-run) `literal` %PATH% ü'
+for _,os in ipairs{'OS X','Windows','Linux'}do
+ osName=os;T.eq(F.available(),true);local cmds=assert(F.commands(prompt,kind));T.eq(#cmds,1)
+ if os=='OS X'then
+  T.check(cmds[1]:find('osascript -e ',1,true)==1);T.check(cmds[1]:find("'\\''",1,true)~=nil)
+ elseif os=='Windows'then
+  T.eq(cmds[1]:find('do-not-run',1,true),nil,'untrusted UTF-8 is data')
+  T.check(cmds[1]:find('[Text.Encoding]::UTF8.GetString([byte[]]@(',1,true)~=nil)
+  T.check(cmds[1]:find('if($ascii){[Console]::Write($p)}else{',1,true)~=nil,'large ASCII file fast path')
+  T.check(cmds[1]:find('[Guid]::NewGuid()',1,true)~=nil,'unique non-ASCII staging')
+  T.check(cmds[1]:find('-ErrorAction Stop',1,true)~=nil,'failed staging cannot return stale data')
+ else T.check(cmds[1]:find('zenity ',1,true)==1)end
+end
+osName='Linux';available.zenity=false;T.check(F.commands('QA',kind)[1]:find('kdialog ',1,true)==1)
+available.kdialog=false;T.eq(F.available(),false);T.eq(F.commands('QA',kind),nil);available.zenity=true
+T.eq(F.matches('C:\\QA\\FILE.SPRITEPACK',kind),true);T.eq(F.matches('file.spritepack.exe',kind),false)
+T.eq(F.matches('image.JPEG'),true);T.eq(F.basename('C:\\QA\\image.png'),'image.png');T.eq(F.basename('/qa/a.spritepack'),'a.spritepack')
+for _,bad in ipairs{{exts={}},{exts={'bad;cmd'}},{exts={'bad"x'}},{exts={'bad x'}},{exts={'png'},label='x|*.sav'}}do
+ T.eq(F.commands('QA',bad),nil);T.eq(F.open('QA',bad),nil)
+end
+T.eq(F.commands('bad\0title',kind),nil);T.eq(F.open(nil,kind),nil);T.eq(F.open(string.rep('x',513),kind),nil)
+local mouse,event,timer=love.mouse,love.event,love.timer;local held,pumps,launches=true,0,0
+love.mouse={isDown=function()return held end};love.event={pump=function()pumps=pumps+1;held=false end}
+love.timer={getTime=function()return 0 end,sleep=function()end}
+Host.popen=function()
+ T.eq(held,false,'pointer released before native dialog');launches=launches+1
+ return{read=function()return ' /owned-qa/a.spritepack\n'end,close=function()closed=closed+1 end}
+end
+T.eq(F.open('QA pick',kind),'/owned-qa/a.spritepack');T.eq(launches,1);T.eq(pumps,1)
+Host.popen=function()launches=launches+1;return{read=function()return ''end,close=function()closed=closed+1 end}end
+T.eq(F.open('QA cancel',kind),nil);T.eq(launches,2,'cancel cannot launch another chooser')
+local beforeClose=closed
+Host.popen=function()return{read=function()error('owned dialog read failure')end,close=function()closed=closed+1 end}end
+T.eq(F.open('QA failure',kind),nil);T.eq(closed,beforeClose+1)
+love.mouse,love.event,love.timer=mouse,event,timer
+local oldOpen=io.open;local reads,closes=0,0
+io.open=function(path,mode)
+ T.eq(path,'owned-qa-byte-probe');T.eq(mode,'rb')
+ return{read=function()reads=reads+1;return '\0binary\255'end,close=function()closes=closes+1 end}
+end
+T.eq(F.read('owned-qa-byte-probe'),'\0binary\255');T.eq(reads,1);T.eq(closes,1)
+io.open=function()return{read=function()error('owned read failure')end,close=function()closes=closes+1 end}end
+local bytes,err=F.read('owned-qa-byte-probe');T.eq(bytes,nil);T.check(err:find('owned read failure',1,true)~=nil);T.eq(closes,2)
+io.open=oldOpen;Host.popen,Host.hasCommand=oldPop,oldHas;love.system.getOS=osGet;love.system=oldSystem
+T.eq(package.loaded['src.core.Game'],oldGame,'no session/save owner introduced')
+T.finish('native picker commands, one-backend cancellation, shared pointer release and readonly bytes')
diff --git a/tests/engine/native_fly_arrival.lua b/tests/engine/native_fly_arrival.lua
new file mode 100644
index 000000000..59ad1967f
--- /dev/null
+++ b/tests/engine/native_fly_arrival.lua
@@ -0,0 +1,104 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Arrival=require('src.world.Gen3FlyArrival')
+local Effects=require('src.core.game3.field_effects');local Field=require('src.core.game3.field')
+local Fade=require('src.ui.game3.fade');local Transition=require('src.render.Transition')
+local OW=require('src.world.OverworldController');local G=require('src.core.Game3')
+local Seams=require('src.mods.ModSeams');local Host=require('src.mods.Runtime')
+local Stream=require('src.core.game3.asset_stream');local Sound=require('src.core.Sound')
+local savedGame=package.loaded['src.core.Game'];local play=Sound.play;local base=Effects.startFlyIn
+local count,fail=0,false
+Sound.play=function(_,name)T.eq(name,'Fly');count=count+1;if fail then error('native arrival sound failed')end end
+local function fixture(edition,wrapper)
+ Arrival.release();G.release();Host.currentMod=nil
+ local f=require('tools.native-field.warp-fixture').new(edition);local game,world=f.game,f.ow
+ package.loaded['src.core.Game']=game;game.mods=f.loader
+ local restore
+ for i=1,100 do
+  local key,value=debug.getupvalue(OW.startWarpTo,i);if not key then break end
+  if key=='Game'then debug.setupvalue(OW.startWarpTo,i,game);restore=function()debug.setupvalue(OW.startWarpTo,i,value)end;break end
+ end
+ assert(restore)
+ setmetatable(game.stack,{__index=require('src.core.StateStack')})
+ world.startWarpTo=OW.startWarpTo
+ function world:frlgBehaviours()return false end
+ function world:noteGen2Spawn()end
+ function world:setMap(id,x,y,facing)f.destination={id,x,y,facing};f:arrive()end
+ game.data.transitions={warp_fade={frames=1,framesIn=0}}
+ Effects.startFlyIn=base
+ if wrapper then Seams.run('warp',function()Effects.startFlyIn=wrapper end)end
+ local done=0;world.arriveWarp='fly';world:startWarpTo(f.dest,1,2,'down',function()done=done+1 end)
+ local state=game.stack:top();T.eq(getmetatable(state),Transition)
+ f.state=state;f.done=function()return done end
+ function f:closeCase()
+  Arrival.release();Effects.startFlyIn=base;restore();self:close();G.release();Host.currentMod=nil
+ end
+ return f
+end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=fixture(edition);local before=count
+ f.state:update(1/60)
+ T.eq(count,before+1);T.eq(f.done(),1);T.eq(f.game.stack:top(),f.ow,'unwrapped zero-frame arrival still finishes in its native tick')
+ T.eq(Field._flyLanding,false);f:closeCase()
+ local callbacks=0
+ f=fixture(edition,function(...)callbacks=callbacks+1;base(...);base(...)end);before=count
+ f.state:update(1/60);T.eq(callbacks,1);T.eq(count,before+1);T.eq(f.done(),1)
+ T.eq(f.game.stack:top(),f.ow,'synchronous source base preserves default native timing');f:closeCase()
+ -- A real loader-attributed wrapper retains only this actual arrival start.
+ f=fixture(edition,function()callbacks=callbacks+1 end);before=count
+ f.state:update(1/60)
+ T.eq(f.game.stack:top(),f.state);T.eq(f.state.phase,'in');T.eq(f.state.t,0)
+ T.eq(Field._flyLanding,true);T.eq(f.state:alpha(),1);T.eq(Fade.t,16,'held native cover stays opaque')
+ T.eq(f.ow.transitioning,true);T.eq(f.done(),0);T.eq(count,before)
+ local save=require('src.link.Json').encode(f.game.save)
+ for i=1,12 do f.state:update(1/60);T.eq(f.state.t,0,'no second arrival/fade clock while deferred')end
+ T.eq(count,before);T.eq(require('src.link.Json').encode(f.game.save),save)
+ T.eq(base(),nil,'outside caller cannot acquire the deferred source phase');T.eq(count,before)
+ G._withCallbackOwner('peer',base);T.eq(count,before,'another owner cannot start the landing')
+ G._withCallbackOwner('warp',base);G._withCallbackOwner('warp',base)
+ T.eq(count,before+1);T.eq(Field._flyLanding,false);T.eq(f.state.nativeFlyArrivalHold,nil)
+ f.state:update(1/60);T.eq(f.done(),1);T.eq(f.ow.transitioning,false);T.eq(f.game.stack:top(),f.ow)
+ T.eq(base(),nil,'retired native phase cannot start another effect');f:closeCase()
+ -- Owner removal releases this native cover through its original body once.
+ f=fixture(edition,function()end);before=count;f.state:update(1/60)
+ Arrival:releaseOwner('peer');T.eq(count,before);T.eq(Field._flyLanding,true)
+ Arrival:releaseOwner('warp');T.eq(count,before+1);T.eq(Field._flyLanding,false)
+ f.state:update(1/60);T.eq(f.done(),1);f:closeCase()
+ f=fixture(edition,function()end);before=count;f.state:update(1/60)
+ f.loader.mods.warp.enabled=false
+ T.eq(Field._flyLanding,false);T.eq(count,before,'a landing observation cannot play a native effect')
+ f.state:update(1/60);T.eq(count,before+1);T.eq(f.done(),1,'native update falls back after owner retirement');f:closeCase()
+ for _,key in ipairs{'data','save','mods','stack'}do
+  f=fixture(edition,function()end);before=count;f.state:update(1/60)
+  local old=f.game[key];f.game[key]={}
+  T.eq(Field._flyLanding,false);Arrival.poll();T.eq(f.state.nativeFlyArrivalHold,nil)
+  f.game[key]=old;G._withCallbackOwner('warp',base);T.eq(count,before,key..' replacement cannot execute stale arrival')
+  f:closeCase()
+ end
+ f=fixture(edition,function()end);before=count;f.state:update(1/60)
+ G.release();T.eq(Field._flyLanding,false);Arrival.poll();T.eq(f.state.nativeFlyArrivalHold,nil)
+ T.eq(count,before,'retired source facade cannot start an effect');f:closeCase()
+ f=fixture(edition,function()end);before=count;f.state:update(1/60)
+ f.game.stack:pop();T.eq(Field._flyLanding,false);T.eq(f.state.nativeFlyArrivalHold,nil)
+ G._withCallbackOwner('warp',base);T.eq(count,before,'actual stack cancellation drops its body');f:closeCase()
+ f=fixture(edition,function()Stream.shutdown()end);before=count;f.state:update(1/60)
+ T.eq(count,before);T.eq(f.done(),1,'reentrant service reset cannot retain or revive the arrival')
+ T.eq(f.state.nativeFlyArrivalHold,nil);f:closeCase()
+ f=fixture(edition,function()G.release()end);before=count;f.state:update(1/60)
+ T.eq(count,before);T.eq(f.done(),1,'source facade reset during a start cancels its old body');f:closeCase()
+ f=fixture(edition,function()pcall(base);pcall(base)end);before=count;fail=true
+ T.raises(function()f.state:update(1/60)end,'native arrival sound failed')
+ fail=false;T.eq(count,before+1,'caught native error is never retried');T.eq(f.state.nativeFlyArrivalHold,nil)
+ f:closeCase()
+end
+-- Anonymous callbacks cannot leave a native phase held after their call.
+local f=fixture('emerald');local before=count
+Effects.startFlyIn=function()end
+f.state:update(1/60);T.eq(count,before+1);T.eq(f.done(),1);f:closeCase()
+-- An ordinary Gen2 flight never invokes the source-facing arrival API.
+f=fixture('crystal');before=count
+Effects.startFlyIn=function()error('foreign arrival callback')end
+f.state:update(1/60);T.eq(count,before+1);T.eq(f.done(),1);f:closeCase()
+Effects.startFlyIn=base;Sound.play=play;package.loaded['src.core.Game']=savedGame
+T.finish('native fly arrival deferral, opaque cover, once-only body and cohort retirement')
diff --git a/tests/engine/native_fly_boundary.lua b/tests/engine/native_fly_boundary.lua
new file mode 100644
index 000000000..2f4727dc5
--- /dev/null
+++ b/tests/engine/native_fly_boundary.lua
@@ -0,0 +1,47 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local G=require('src.core.Game3');local Field=require('src.core.game3.field')
+local Actions=require('src.world.WorldActions');local Boundary=require('src.compat.gen1.ScriptBoundary')
+local original=Field.flyTo;local admission=Actions.flyTo
+local Sound=require('src.core.Sound');local play=Sound.play;local sounds=0
+Sound.play=function(_,id)T.eq(id,'Fly');sounds=sounds+1 end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.session-runtime.fixture').new(edition);local game,world=f.game,f.world
+ game.data.field={flyOrder={'TEST'},flyWarps={TEST={x=4,y=5}}};f.map.def.regionMapSection=7
+ game.save.visited={TEST=true};local clears,surf=0,0
+ world.clearBikeFlags=function()clears=clears+1 end
+ world.syncSurfingPikachu=function()surf=surf+1 end
+ world.hasFlyBird=function()return false end
+ local wrappers=0
+ Field.flyTo=function(section,mon,info)
+  wrappers=wrappers+1;T.eq(section,7);T.eq(info.dest.x,4);T.eq(info.dest.y,5)
+  T.eq(Field._game,G.forNative(game));T.eq(Boundary.active('field.flyTo'),true)
+  info.dest.x=999
+  local a,b,c=original(section,mon,info);local d=original(section,mon,info)
+  T.eq(a,nil);T.eq(b,nil);T.eq(c,nil);T.eq(d,nil)
+ end
+ local start=sounds;world:flyTo('TEST')
+ T.eq(wrappers,1);T.eq(sounds,start+1);T.eq(clears,1);T.eq(surf,1)
+ T.eq(world.flyDest.x,4,'detached wrapper metadata cannot redirect native destination')
+ T.eq(world.flyAnim.frames,48);T.eq(world.player.inputLocked,true)
+ T.eq(Boundary.active('field.flyTo'),false)
+ Field.flyTo=original;world.flyAnim=nil;world.player.inputLocked=false
+ local requests=0
+ Actions.flyTo=function(g,w,id)requests=requests+1;T.eq(g,game);T.eq(w,world);T.eq(id,Field.flyDestination(7).map);return false,'native admission refused'end
+ local ok,why=Field.flyTo(7);T.eq(ok,false);T.eq(why,'native admission refused');T.eq(requests,1)
+ T.eq(Field.flyTo(99),nil);T.eq(requests,1,'unknown section cannot call travel owner')
+ Actions.flyTo=admission
+ -- A native failure remains once-only even if a wrapper catches and retries it.
+ local OW=require('src.world.OverworldController');local body=OW._flyToBody;local attempts=0
+ OW._flyToBody=function()attempts=attempts+1;error('native fly failure')end
+ Field.flyTo=function(...)pcall(original,...);pcall(original,...)end
+ T.raises(function()world:flyTo('TEST')end,'native fly failure');T.eq(attempts,1)
+ T.eq(Boundary.active('field.flyTo'),false);OW._flyToBody=body;Field.flyTo=original
+ -- Native callers in another generation never enter the source boundary.
+ require('src.core.GameVersion').set('crystal');Field.flyTo=function()error('foreign source fly')end
+ world:flyTo('TEST');T.eq(clears,2);Field.flyTo=original
+ G.release()
+end
+Sound.play=play;Field.flyTo=original;Actions.flyTo=admission
+T.finish('native flight continuation, once-only forwarding and standalone admission')
diff --git a/tests/engine/native_forced_tile_observation.lua b/tests/engine/native_forced_tile_observation.lua
new file mode 100644
index 000000000..42995ee30
--- /dev/null
+++ b/tests/engine/native_forced_tile_observation.lua
@@ -0,0 +1,33 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local V=require('src.core.GameVersion')
+local MB=require('src.compat.gen1.MetatileBehavior')
+local before=package.loaded['src.core.Game']
+local F=require('src.core.game3.forced_movement')
+T.eq(package.loaded['src.core.Game'],before,'a pure terrain query cannot bootstrap a game')
+local original=V.get()
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ V.set(edition);local rse=edition~='firered'and edition~='leafgreen'
+ T.eq(F.isRse(),rse)
+ for raw=0,255 do
+  -- Independent cartridge-byte oracle. Hoenn uses ICE at $20 and has
+  -- secret-base mats, muddy slope and cracked floor; FRLG has spin arrows.
+  local expected=raw==0x13 or raw==(rse and 0x20 or 0x23)
+   or raw>=0x40 and raw<=0x48 or raw>=0x50 and raw<=0x53
+   or not rse and raw>=0x54 and raw<=0x57
+   or rse and(raw==0xBB or raw==0xBC or raw==0xD0 or raw==0xD2)
+  T.eq(F.isForcedMovementTile(MB.fromRaw(edition,raw)),expected,edition..' raw terrain '..raw)
+ end
+ for _,value in ipairs{false,true,'64',{},.5,-1,math.huge,0/0}do T.eq(F.isForcedMovementTile(value),false)end
+ T.eq(F.isForcedMovementTile(nil),false)
+ for _,name in ipairs{'MUDDY_SLOPE','CRACKED_FLOOR','SECRET_BASE_JUMP_MAT','SECRET_BASE_SPIN_MAT'}do
+  T.eq(F.isForcedMovementTile(MB.require(name)),rse,'edition-specific semantic IDs are not raw FRLG bytes')
+ end
+end
+for _,edition in ipairs{'red','gold','platinum'}do
+ V.set(edition);T.eq(F.isRse(),false)
+ for _,name in ipairs{'ICE','WALK_SOUTH','SPIN_LEFT','MUDDY_SLOPE'}do T.eq(F.isForcedMovementTile(MB.require(name)),false)end
+end
+V.set(original);T.eq(package.loaded['src.core.Game'],before,'queries never construct a native simulation')
+T.finish('native semantic forced terrain observation across GBA editions')
diff --git a/tests/engine/native_frame_rects.lua b/tests/engine/native_frame_rects.lua
new file mode 100644
index 000000000..6146ce6f0
--- /dev/null
+++ b/tests/engine/native_frame_rects.lua
@@ -0,0 +1,41 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local R=require('src.render.Renderer')
+local major=love.getVersion
+love.getVersion=function()return 12,0,0 end
+local g=love.graphics
+local dims,pixels,draw=g.getDimensions,g.getPixelDimensions,g.draw
+local ww,wh,pw,ph
+local rows={}
+g.getDimensions=function()return ww,wh end
+g.getPixelDimensions=function()return pw,ph end
+g.draw=function(image,x,y,rotation,sx,sy)rows[#rows+1]={image=image,x=x,y=y,sx=sx,sy=sy}end
+R:init()
+T.eq(R.scalesWorldOverride,true)
+for _,size in ipairs{{1024,768,1024,768},{900,600,1800,1200},{640,480,1280,1440},{400,800,1100,2200}}do
+ ww,wh,pw,ph=unpack(size)
+ for _,surface in ipairs{{240,160},{304,144}}do
+  R:setUISize(unpack(surface))
+  R:beginFrame()
+  local r=R:frameRects()
+  T.eq(r.ww,ww);T.eq(r.wh,wh);T.eq(r.pw,pw);T.eq(r.ph,ph)
+  T.eq(r.vuw*r.dpiX,pw,'world producer receives actual drawable width')
+  T.eq(r.vuh*r.dpiY,ph,'world producer receives actual drawable height')
+  T.eq(r.uiw,surface[1]);T.eq(r.uih,surface[2])
+  r.pw=1;T.eq(R:frameRects().pw,pw,'caller cannot change the next viewport')
+  local image=g.newCanvas(pw,ph)
+  R:setWorldOverride(image);rows={};R:endFrame()
+  local world,ui
+  for _,row in ipairs(rows)do
+   if row.image==image then world=row end
+   if row.image==R.canvas then ui=row end
+  end
+  T.check(world~=nil);T.eq(world.x,0);T.eq(world.y,0)
+  T.eq(world.sx,ww/pw);T.eq(world.sy,wh/ph,'HD world is composed once without reflection')
+  T.check(ui and ui.sx>0 and ui.sy>0,'native UI remains upright')
+ end
+end
+g.getDimensions,g.getPixelDimensions,g.draw=dims,pixels,draw
+love.getVersion=major
+T.finish('native field viewport metrics and HD override composition')
diff --git a/tests/engine/native_frame_widget_presentation.lua b/tests/engine/native_frame_widget_presentation.lua
new file mode 100644
index 000000000..186d8d9fa
--- /dev/null
+++ b/tests/engine/native_frame_widget_presentation.lua
@@ -0,0 +1,86 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local P=require('src.ui.game3.presentation');local Font=require('src.render.Font')
+local Window=require('src.ui.game3.window');local G=require('src.core.Game3')
+local V=require('src.core.GameVersion');local original=package.loaded['src.core.Game']
+local g=love.graphics;local rectangle,code=g.rectangle,Font.drawCode
+local trace={};local function log(kind,...)
+ trace[#trace+1]={kind,...}
+end
+g.rectangle=function(...)log('rect',...)end;Font.drawCode=function(...)log('glyph',...)end
+local function provider(draw)return{enabled=function()return true end,draw=draw}end
+local function pack(...)return{n=select('#',...),...}end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game;game.stack:push({});Font.load(game.data)
+ for _,sample in ipairs{
+  {'drawBox','user',{1,2,8,6},{8,16,64,48}},
+  {'drawStandardBox','standard',{1,2,8,6},{8,16,64,48}},
+  {'drawDialogueBox','dialogue',{1,14,28,6},{8,112,224,48}},
+  {'drawSignpostBox','sign',{1,14,28,6},{8,112,224,48}}}do
+  local method,style,args,bounds=unpack(sample)
+  P._service.release();trace={};g.setColor(.2,.3,.4,.5);Font[method](unpack(args));local expected=trace
+  local nativeColor={g.getColor()}
+  T.check(#expected>0,'native fallback frame is actually painted')
+  local calls=0;local mode='false';local seen
+  G._withCallbackOwner('frame-owner',function()P.register('frames',provider(function(kind,ctx)
+   calls=calls+1;seen=ctx
+   T.eq(kind,'frame');T.eq(ctx.style,style);T.eq(G._callbackOwner(),'frame-owner')
+   T.same({ctx.x,ctx.y,ctx.width,ctx.height},bounds)
+   if mode=='handled'then return true end
+   if mode=='error'then g.push();g.setColor(.1,.2,.3,.4);error('provider frame failed')end
+   if mode=='borrow'or mode=='native-error'then
+    local a=pack(pcall(Font[method],unpack(args)))
+    if mode=='borrow'then T.same({g.getColor()},nativeColor,'base callers see native font postconditions')end
+    Font[method](unpack(args))
+    if mode=='borrow'then T.eq(a[1],true)end
+   end
+   return false
+  end))end)
+  local function draw()
+   P.begin(game,240,160);trace={};g.setColor(.2,.3,.4,.5);local color={g.getColor()}
+   Font[method](unpack(args));T.same({g.getColor()},mode=='handled'and color or nativeColor,
+    'native colour postconditions survive provider isolation')
+   return trace
+  end
+  T.same(draw(),expected,'false preserves native frame and fallback chain');T.eq(calls,1)
+  mode='borrow';T.same(draw(),expected,'multiple base calls plus false paint once');T.eq(calls,2)
+  mode='handled';T.eq(#draw(),0,'handled provider owns only the frame')
+  mode='error';T.same(draw(),expected,'provider error restores native frame')
+  T.check(P.health('frames').error:find('provider frame failed',1,true)~=nil)
+  P._service.release()
+ end
+ -- The public tile-template helper uses the native standard frame owner.
+ local style
+ P.register('template',provider(function(_,ctx)style=ctx.style;return true end));P.begin(game,240,160)
+ Window.stdFrame(Window.template(2,3,6,4));T.eq(style,'standard')
+ -- Direct source draws may ask the native font for their fallback without
+ -- recursively re-entering the same provider.
+ local loops=0
+ P.register('direct',provider(function()loops=loops+1;Font.drawBox(1,2,8,6);return true end))
+ P.begin(game,240,160);trace={};T.eq(P.draw('frame',{}),true);T.eq(loops,1);T.check(#trace>0)
+ -- Once-only body tuples and native failures survive nested provider calls.
+ local calls=0
+ P.register('tuple',provider(function()
+  local values=pack(P._nativeDraw('frame',{},function()error('wrong recursive body')end))
+  T.same(values,{n=3,[2]=4});return false
+ end));P.begin(game,240,160)
+ T.same(pack(P._nativeDraw('frame',{},function()calls=calls+1;return nil,4,nil end)),{n=3,[2]=4})
+ T.eq(calls,1)
+ P.register('failed',provider(function()
+  pcall(Font.drawBox,1,2,8,6);pcall(Font.drawBox,1,2,8,6);return true
+ end));P.begin(game,240,160);calls=0
+ g.rectangle=function()calls=calls+1;g.push();error('native frame body failed')end
+ T.raises(function()Font.drawBox(1,2,8,6)end,'native frame body failed');T.eq(calls,1)
+ g.rectangle=function(...)log('rect',...)end
+ P._service.release();game.stack:pop();f.close();G.release()
+end
+for _,edition in ipairs{'red','crystal','platinum','black'}do
+ local f=require('tools.battle-source-runtime.fixture').new('firered');package.loaded['src.core.Game']=f.game
+ V.set(edition);P.register('other',provider(function()error('GBA frame provider reached another generation')end))
+ T.eq(P._nativeBegin(f.game,160,144),false);trace={};Font.drawBox(1,2,8,6);T.check(#trace>0)
+ T.eq(P.health('other').error,nil);P._service.release();f.close();G.release()
+end
+g.rectangle,Font.drawCode=rectangle,code;package.loaded['src.core.Game']=original;V.set('firered')
+T.finish('native user/standard/dialogue/sign frames, provider recursion, base leases and generation routing')
diff --git a/tests/engine/native_game_coroutine_scopes.lua b/tests/engine/native_game_coroutine_scopes.lua
new file mode 100644
index 000000000..0cbd299db
--- /dev/null
+++ b/tests/engine/native_game_coroutine_scopes.lua
@@ -0,0 +1,88 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local B=require('src.compat.gen1.ScriptBoundary')
+local G=require('src.core.Game3')
+local function pack(...)return {n=select('#',...),...}end
+local function resume(co,...)
+ local result=pack(coroutine.resume(co,...));T.eq(result[1],true,'owned coroutine resumes')
+ return unpack(result,2,result.n)
+end
+local ok,why
+local savedViews=package.loaded['src.compat.gen1.PokemonView']
+local flushes=0
+package.loaded['src.compat.gen1.PokemonView']={flush=function()flushes=flushes+1 end}
+local ownerChild
+G._withCallbackOwner('parent-owner',function()
+  T.eq(G._callbackOwner(),'parent-owner')
+  ownerChild=coroutine.create(function()
+    T.eq(G._callbackOwner(),'parent-owner','direct child inherits active callback attribution')
+    G._withCallbackOwner('child-owner',function()
+      T.eq(G._callbackOwner(),'child-owner')
+      coroutine.yield('owner held')
+    end)
+  end)
+  T.eq(resume(ownerChild),'owner held')
+  T.eq(G._callbackOwner(),'parent-owner','suspended child cannot replace caller attribution')
+  G._withCallbackOwner(nil,function()T.eq(G._callbackOwner(),nil,'explicit nil shadows caller ownership')end)
+  T.eq(G._callbackOwner(),'parent-owner','nil scope restores active parent ownership')
+end)
+local after=flushes
+ok,why=coroutine.resume(ownerChild)
+T.eq(ok,false,'retired callback source cannot return as an active owner')
+T.check(tostring(why):find('retired',1,true)~=nil)
+T.eq(flushes,after,'retired callback cannot flush pending Pokemon writes')
+T.eq(G._callbackOwner(),nil,'retired child cannot restore expired parent attribution')
+T.same(pack(G._withCallbackOwner('tuple',function()return nil,2,nil end)),{n=3,[2]=2})
+ok=pcall(G._withCallbackOwner,'throws',function()error('owned callback failure')end)
+T.eq(ok,false);T.eq(G._callbackOwner(),nil,'callback errors restore attribution')
+-- A borrowed script body may retire a coroutine whose callback scope was
+-- independently opened. Attribution and pending writes must also retire.
+local cross
+B.dispatch('cross-registry',function()coroutine.yield('cross held')end,function()
+ cross=coroutine.create(function()
+  G._withCallbackOwner('cross-owner',function()
+   pcall(B.invoke,'cross-registry')
+   T.eq(G._callbackOwner(),nil,'retired script borrower cannot retain callback attribution')
+  end)
+ end)
+ T.eq(resume(cross),'cross held')
+end)
+after=flushes
+G._withCallbackOwner('new-owner',function()
+ local success,errorValue=coroutine.resume(cross)
+ T.eq(success,false,'script retirement also retires the pending callback')
+ T.check(tostring(errorValue):find('retired',1,true)~=nil)
+ T.eq(G._callbackOwner(),'new-owner','a retired borrower cannot overwrite the new owner')
+ T.eq(flushes,after,'cross-registry retirement cannot flush pending Pokemon writes')
+end)
+package.loaded['src.compat.gen1.PokemonView']=savedViews
+local Version=require('src.core.GameVersion');local oldVersion=Version.get();Version.set('emerald')
+local native={data=T.fixtures.fresh(),save={options={},player={}},stack={states={}}};local view=assert(G.forNative(native));local base=G.update
+local oldGameChild,gameBodies
+gameBodies=0
+G.update=function(g)
+  -- Retain the genuine options-write dispatch in a source-created child.
+  oldGameChild=coroutine.create(function()
+    return G._dispatch('writeOptions',native,function()gameBodies=gameBodies+1 end)
+  end)
+  resume(oldGameChild)
+  return base(g,.25)
+end
+local optionsBase=G.writeOptions
+G.writeOptions=function(g)coroutine.yield('game phase held');return optionsBase(g)end
+local firstUpdates=0
+T.eq(G._dispatch('update',native,function()firstUpdates=firstUpdates+1;return 9 end),9)
+T.eq(firstUpdates,1,'native game update still executes once through its source wrapper')
+local replacements=0
+G.update=function(g)return base(g,.5)end
+T.eq(G._dispatch('update',native,function()
+  local resumed,errorValue=coroutine.resume(oldGameChild)
+  T.eq(resumed,false,'old source game coroutine is retired with its parent dispatch')
+  T.check(tostring(errorValue):find('retired',1,true)~=nil)
+  replacements=replacements+1;return 10
+end),10)
+T.eq(replacements,1,'retired source game cleanup retains replacement native dispatch')
+T.eq(gameBodies,0,'retired source game cannot perform its delayed options write')
+G.update,G.writeOptions=base,optionsBase
+G.release();Version.set(oldVersion)
+T.finish('Native coroutine phase and callback ownership without suspended-scope leaks')
diff --git a/tests/engine/native_gba_color_effects.lua b/tests/engine/native_gba_color_effects.lua
new file mode 100644
index 000000000..dc18de077
--- /dev/null
+++ b/tests/engine/native_gba_color_effects.lua
@@ -0,0 +1,103 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Fx=require('src.core.game3.gba_fx')
+local Alpha=require('src.render.NativeGbaAlpha')
+local g=love.graphics;local saved={}
+for _,key in ipairs{'newShader','newCanvas','getScissor','setScissor','intersectScissor','clear'}do saved[key]=g[key]end
+local shaders,canvases={},{}
+g.newShader=function(source)
+ local sh={source=source,uniforms={}}
+ function sh:send(key,value)
+  assert(not self.released,'released shader')
+  if type(value)=='table'and not value.getDimensions then local c={};for k,v in pairs(value)do c[k]=v end;value=c end
+  self.uniforms[key]=value
+ end
+ function sh:release()T.eq(self.released,nil,'owned shader released once');self.released=true end
+ shaders[#shaders+1]=sh;return sh
+end
+g.newCanvas=function(w,h,options)
+ local c={width=w,height=h,dpi=options and options.dpiscale or 1}
+ function c:getDimensions()return self.width,self.height end
+ function c:getDPIScale()return self.dpi end
+ function c:setFilter()end
+ function c:release()T.eq(self.released,nil,'owned canvas released once');self.released=true end
+ canvases[#canvases+1]=c;return c
+end
+local scissor={1,2,30,40}
+g.getScissor=function()return unpack(scissor)end
+g.setScissor=function(...)scissor={...}end
+g.intersectScissor=function(x,y,w,h)
+ local sx,sy,sw,sh=unpack(scissor)
+ if sx then local right,bottom=math.min(sx+sw,x+w),math.min(sy+sh,y+h);x,y=math.max(sx,x),math.max(sy,y);w,h=math.max(0,right-x),math.max(0,bottom-y)end
+ scissor={x,y,w,h}
+end
+g.clear=function()end
+local target=g.newCanvas(32,24,{dpiscale=2});local mask=g.newCanvas(8,8,{dpiscale=1})
+local beforeShader={};g.setShader(beforeShader);g.setCanvas(target);g.setColor(.2,.3,.4,.5)
+local function restored()
+ T.eq(g.getCanvas(),target);T.eq(g.getShader(),beforeShader)
+ T.same(scissor,{1,2,30,40});local r,gg,b,a=g.getColor();T.same({r,gg,b,a},{.2,.3,.4,.5})
+end
+T.eq(Fx.active(),false);T.eq(Fx.active({y=0}),false);T.eq(Fx.active({band=0}),true)
+local created=#shaders
+local a,b,c=Fx.draw(function()return 7,nil,9 end)
+T.eq(a,7);T.eq(b,nil);T.eq(c,9);T.eq(#shaders,created,'inactive effects allocate no shader')
+local calls=0;local outer
+Fx.draw(function()
+ calls=calls+1;outer=g.getShader();T.neq(outer,beforeShader)
+ T.same(outer.uniforms.gbaFxFade,{31,0,12,.5})
+ T.same(outer.uniforms.gbaFxControls,{1,.25,0,2})
+ local fade=outer.uniforms.gbaFxFade
+ Fx.draw(function()calls=calls+1;T.neq(g.getShader(),outer)end,{y=16,color=Fx.WHITE})
+ T.eq(g.getShader(),outer);T.same(outer.uniforms.gbaFxFade,fade,'nested effects cannot change their caller uniforms')
+end,{y=8,color={31,0,12},gray=true,bldy=4})
+T.eq(calls,2);restored()
+local alphaShader
+a,b,c=Fx.draw(function()
+ calls=calls+1;alphaShader=g.getShader()
+ T.same(alphaShader.uniforms.nativeGbaCoefficients,{9,7})
+ T.same(alphaShader.uniforms.nativeGbaSurfacePixels,{64,48})
+ T.eq(alphaShader.uniforms.gbaFxMask,mask)
+ T.same(alphaShader.uniforms.gbaFxWindow,{2,3,8,9})
+ T.same(alphaShader.uniforms.gbaFxWindowControl,{1,.75})
+ return 'native',nil,23
+end,{objWin={image=mask,x=2,y=3,w=8,h=9,bldy=12},band=0},{eva=9,evb=7})
+T.eq(a,'native');T.eq(b,nil);T.eq(c,23);T.eq(calls,3,'alpha executes the native painter once')
+T.neq(alphaShader.uniforms.gbaFxMask,mask,'borrowed mask detached after painting');T.eq(mask.released,nil);restored()
+local warmed=#shaders
+Fx.draw(function()calls=calls+1 end,{y=2})
+T.eq(#shaders,warmed,'normal repeated calls reuse a compiled depth bank');restored()
+local beforeCalls=calls
+for _,fx in ipairs{{y=0/0},{y='bad'},{color={32,0,0}},{gray=1},{band=math.huge},
+ {objWin={image=mask,x=0,y=0,w=0,h=8}}}do
+ T.raises(function()Fx.draw(function()calls=calls+1 end,fx)end,'GBA')
+end
+T.raises(function()Fx.draw(function()calls=calls+1 end,{y=2},{eva=math.huge})end,'coefficient')
+T.eq(calls,beforeCalls,'invalid parameters cannot partially paint');restored()
+T.raises(function()Fx.draw(function()
+ g.push('all');g.setCanvas(mask);g.setColor(1,1,1,1);error('intentional colour painter error')
+end,{objWin={image=mask,x=0,y=0,w=8,h=8}})end,'intentional colour painter error')
+restored();T.eq(mask.released,nil)
+local clip=Fx.withClip({x=4,y=5,w=8,h=9},function()T.same(scissor,{4,5,8,9});return 'clip'end)
+T.eq(clip,'clip');restored()
+T.raises(function()Fx.withClip({x=4,y=5,w=8,h=9},function()error('clip failure')end)end,'clip failure');restored()
+-- Existing native-alpha users keep the same default program and owned target.
+local native=Alpha.new();local configured=false
+local painted=native:paint(16,0,function()calls=calls+1 end,function(shader)
+ configured=true;T.eq(shader.source,Alpha.SOURCE)
+end)
+T.eq(painted,true);T.eq(configured,true);native:release();restored()
+-- A teardown during a nested painter retires owned resources after the last
+-- draw exits; it must not invalidate the currently executing program.
+local active
+Fx.draw(function()
+ active=g.getShader();Fx._service.release()
+ T.eq(active.released,nil);T.eq(mask.released,nil)
+end,{y=3})
+T.eq(active.released,true);restored()
+Fx.draw(function()T.neq(g.getShader(),active)end,{y=1});Fx._service.release()
+T.eq(mask.released,nil);T.eq(target.released,nil)
+for key,value in pairs(saved)do g[key]=value end
+g.setCanvas();g.setShader()
+T.finish('native GBA colour effects, once-only alpha, nested ownership and release')
diff --git a/tests/engine/native_healing_source.lua b/tests/engine/native_healing_source.lua
new file mode 100644
index 000000000..01ad62450
--- /dev/null
+++ b/tests/engine/native_healing_source.lua
@@ -0,0 +1,30 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local G=require('src.core.Game3')
+local Heal=require('src.core.game3.pokecenter_heal')
+local Presentation=require('src.world.Gen3HealingPresentation')
+local Assets=require('src.render.Assets');local image=Assets.image
+local pictures={A={},B={},glow={}};local loads=0
+Assets.image=function(path)loads=loads+1;return assert(pictures[path])end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ G.release();local f=require('tools.session-runtime.fixture').new(edition);local g,w=f.game,f.world
+ T.eq(Heal.isActive(),false);T.eq(#Heal.spriteSnapshot(),0)
+ g.data.constants.gen3HealMachine={monitor={images={'A','B'},x=-8,y=-20},glow={image='glow',x=2,y=3,offsets={{0,0},{4,0},{0,4}}}}
+ local ha={px=80,py=96,visible=true,lit=2,timer=11};w.healAnim=ha
+ T.eq(Heal.isActive(),true)
+ local native=Presentation.snapshot(g,w,ha);local source=Heal.spriteSnapshot()
+ T.eq(#native,3);T.eq(#source,3);T.eq(source[1].image,pictures.A)
+ for i,s in ipairs(source)do
+  T.eq(s.image,native[i].image);T.eq(s.kind,native[i].kind)
+  T.eq(s.x+f.player.px-112,native[i].x);T.eq(s.y+f.player.py-72,native[i].y)
+ end
+ local count=loads;Heal.spriteSnapshot();T.eq(loads,count,'native borrowed art is reused')
+ source[1].x=999;T.eq(ha.px,80);T.eq(ha.timer,11,'snapshot cannot step native healing')
+ ha.visible=false;T.eq(Heal.spriteSnapshot()[1].image,pictures.B)
+ ha.lit=8;T.eq(#Heal.spriteSnapshot(),4,'ball list follows the actual cartridge offset count')
+ w.healAnim=nil;T.eq(Heal.isActive(),false);T.eq(#Heal.spriteSnapshot(),0)
+ G.release()
+end
+Assets.image=image
+T.finish('native healing sprite snapshots retain anchors, art and one clock')
diff --git a/tests/engine/native_help_facts.lua b/tests/engine/native_help_facts.lua
new file mode 100644
index 000000000..cc620bb2e
--- /dev/null
+++ b/tests/engine/native_help_facts.lua
@@ -0,0 +1,93 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Facts=require('src.import.Gen3HelpFacts')
+local Rom=require('src.import.RomGba')
+local tables={{0x30,0xE4,44},{0x198,0x25C,48},{0x320,0x3D0,43},{0x480,0x4A0,7},{0x4C0,0x550,35}}
+local function fixture()
+ local size,base=65536,0x1000;local bytes,labels={},{}
+ for i=1,size do bytes[i]=0 end
+ local function put(at,value)
+  for i=0,3 do bytes[at+i+1]=value%256;value=math.floor(value/256)end
+ end
+ local nextText=0xB400
+ local function text(name,address)
+  address=address or nextText;if address==nextText then nextText=nextText+4 end
+  labels[name]=address;bytes[address+1],bytes[address+2]=0,255
+  return 0x08000000+address
+ end
+ local names={'WhatShouldIDo','HowDoIDoThis','WhatDoesThisTermMean','AboutThisGame','TypeMatchupList','Exit'}
+ for i,name in ipairs(names)do
+  put(base+(i-1)*4,text('Help_Text_'..name,i==1 and 0xB000 or nil))
+  put(base+24+(i-1)*4,text('Help_Text_Desc'..name))
+ end
+ text('Help_Text_NativeGreeting',0xB000+0x1D1);text('Help_Text_Cancel',0xB000+0x77)
+ text('Help_Text_TheHelpSystem')
+ for topic,row in ipairs(tables)do
+  for id=1,row[3]do
+   put(base+row[1]+id*4,text(('Help_Text_Q%d_%d'):format(topic,id)))
+   put(base+row[2]+id*4,text(('Help_Text_A%d_%d'):format(topic,id)))
+  end
+ end
+ bytes[base+0x93E+1],bytes[base+0x93E+2],bytes[base+0x93E+3]=1,43,255
+ local order={3,0,1,2,4,5}
+ for i,value in ipairs(order)do bytes[base+0xC40+i]=value end
+ for context=0,35 do for topic=1,6 do
+  bytes[base+0xC40+6+context*6+topic]=(topic==6 or context>0 and topic==4)and 1 or 0
+ end end
+ for context=0,35 do for topic,row in ipairs(tables)do
+  local list=base+0x2000+(context*5+topic-1)*4
+  bytes[list+1],bytes[list+2],bytes[list+3]=1,row[3],255
+  put(base+0x960+(context*5+topic-1)*4,0x08000000+list)
+ end end
+ for i=0,287 do bytes[base+0x8F88+i+1]=i%256 end
+ for i=0,31 do bytes[base+0x90A8+i+1]=i end
+ local function reader()
+  local chars={};for i,value in ipairs(bytes)do chars[i]=string.char(value)end
+  return Rom.new(table.concat(chars))
+ end
+ return reader,put,bytes,labels,base
+end
+for _,edition in ipairs{'firered','leafgreen'}do
+ local reader,put,bytes,labels,base=fixture()
+ local rom=reader();local data=Facts.decode(rom,edition,labels,'synthetic reader')
+ T.eq(data.schema,1);T.eq(data.edition,edition);T.eq(data.romSha1,'synthetic reader')
+ T.eq(data.greeting,'Help_Text_NativeGreeting');T.eq(data.cancel,'Help_Text_Cancel')
+ T.eq(#data.topics,6);T.eq(#data.entries,5)
+ T.same(data.topicOrder,{4,1,2,3,5,6});T.same(data.topicFlags[0],{false,false,false,false,false,true})
+ for topic,row in ipairs(tables)do
+  T.eq(#data.entries[topic],row[3])
+  for id,entry in ipairs(data.entries[topic])do
+   T.eq(entry.question,('Help_Text_Q%d_%d'):format(topic,id))
+   T.eq(entry.answer,('Help_Text_A%d_%d'):format(topic,id))
+  end
+ end
+ for context=0,35 do for topic,row in ipairs(tables)do
+  T.same(data.contexts[context][topic],{1,row[3]},'actual native context/topic indexing')
+ end end
+ T.same(data.basicTerms,{1,43});T.eq(data.frame.format,'4bpp');T.eq(#data.frame.tiles,288)
+ for i,value in ipairs(data.frame.tiles)do T.eq(value,(i-1)%256)end
+ for i,value in ipairs(data.frame.palette)do T.eq(value,(i-1)*2+i*2*256-256)end
+ T.eq(data.rom,nil);T.eq(data.labels,nil,'descriptor retains no reader/profile')
+ labels.Help_Text_Q1_1=7;T.eq(data.entries[1][1].question,'Help_Text_Q1_1','names are detached')
+ -- Real import admission cannot be forged by the pure decoder fixture.
+ local extractor={rom=rom,version=edition,manifest={romSha1=require('src.core.GameVersion').info(edition).sha1}}
+ local value,why=Facts.extract(extractor);T.eq(value,nil);T.check(why:find('verified',1,true)~=nil)
+ -- Corrupt pointer, unknown label, list ID and termination are independent
+ -- rejected controls over the real native RomGba reader.
+ local pointerAt=base+tables[1][1]+4
+ put(pointerAt,0xFFFFFFFF);T.raises(function()Facts.decode(reader(),edition,labels,'x')end,'pointer exceeds')
+ put(pointerAt,0x08000007);labels.Help_Text_Q1_1=nil
+ T.raises(function()Facts.decode(reader(),edition,labels,'x')end,'catalog label')
+ local _,_,_,fresh=fixture();labels=fresh
+ put(pointerAt,0x08000000+labels.Help_Text_Q1_1)
+ local list=base+0x2000;bytes[list+1]=45
+ T.raises(function()Facts.decode(reader(),edition,labels,'x')end,'entry ID')
+ bytes[list+1]=1;for i=1,64 do bytes[list+i]=1 end
+ T.raises(function()Facts.decode(reader(),edition,labels,'x')end,'unterminated')
+end
+for _,edition in ipairs{'red','crystal','emerald','ruby','sapphire','platinum','black'}do
+ T.eq(Facts.supports(edition),false)
+ T.eq(Facts.extract({version=edition}),nil,'other editions have no invented Help resource')
+end
+T.finish('native Help pointer metadata, shared catalog names, context bounds and original frame bytes')
diff --git a/tests/engine/native_help_presentation.lua b/tests/engine/native_help_presentation.lua
new file mode 100644
index 000000000..f8664dea5
--- /dev/null
+++ b/tests/engine/native_help_presentation.lua
@@ -0,0 +1,120 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Help=require('src.ui.game3.help_system')
+local Text=require('src.render.Gen3HelpText')
+local Version=require('src.core.GameVersion')
+local original=package.loaded['src.core.Game'];local base=Help.draw
+local function fixture(edition)
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ game.save.flags.FLAG_G3_0820=true;game.save.flags.FLAG_G3_0821=true
+ for _,id in ipairs{0x2CF,0x891,0x895,0x828}do game.save.flags[('FLAG_G3_%04X'):format(id)]=true end
+ package.loaded['src.core.Game']=game
+ local facts={schema=1,edition=edition,romSha1=Version.info().sha1,
+  topics={},entries={},contexts={},topicOrder={4,1,2,3,5,6},topicFlags={},cancel='HelpCancel',
+  frame={tiles={},palette={}},keypad={tiles={},regions={}}}
+ for i=1,6 do facts.topics[i]={label='Topic'..i,description='Description'..i}end
+ for i=1,5 do facts.entries[i]={};for n=1,10 do facts.entries[i][n]={question='Question'..n,answer='Answer'..n}end end
+ for context=0,35 do
+  facts.contexts[context]={};facts.topicFlags[context]={true,true,true,true,true,true}
+  for topic=1,5 do facts.contexts[context][topic]={1,2,3,4,5,6,7,8,9,10}end
+ end
+ for i,tile in ipairs{0,1,2,4,6,9,12,13,14,15,32,33,34}do
+  facts.keypad.regions[i]={tile=tile,width=(i==3 or i==4)and 16 or(i==5 or i==6)and 24 or 8,height=12}
+ end
+ for i=1,288 do facts.frame.tiles[i]=0x21 end
+ for i=1,16 do facts.frame.palette[i]=i-1 end
+ for i=1,2048 do facts.keypad.tiles[i]=0x21 end
+ facts.keypad.tiles[513]=0x43 -- second tile row, sixteen tiles per row
+ game.data.constants.gen3Help=facts
+ game.data.text={HelpCancel='CANCEL'}
+ for i=1,6 do game.data.text['Topic'..i]='TOPIC '..i;game.data.text['Description'..i]='DESCRIPTION '..i end
+ for i=1,10 do game.data.text['Question'..i]='QUESTION '..i;game.data.text['Answer'..i]=('LONG ANSWER\n'):rep(12)end
+ local pressed={}
+ game.input={wasPressed=function(_,key)return pressed[key]==true end,isDown=function()return false end}
+ local world={ticks=0,update=function(self)self.ticks=self.ticks+1 end};game.stack:push(world)
+ local function key(name)
+  pressed[name]=true;game.stack:update(1/60);pressed[name]=nil
+ end
+ return f,game,facts,world,key
+end
+T.eq(Help.isOpen(),false);T.eq(base(),nil);T.eq(Help.close(),false)
+for _,edition in ipairs{'firered','leafgreen'}do
+ local f,game,facts,world,key=fixture(edition)
+ for _,invalid in ipairs{0,35,-1,36,1.5,'23'}do T.eq(Help.show(game,invalid),false)end
+ T.eq(#game.stack.states,1)
+ T.eq(Help.show(game,23),true);T.eq(Help.isOpen(),true);T.eq(Help.show(game,23),false)
+ local state=game.stack:top();T.eq(state.level,'main');T.eq(state.menu.items[1].topic,4)
+ key('down');key('a');T.eq(state.level,'questions');T.eq(state.topic,1);T.eq(#state.menu.items,11)
+ for _=1,8 do key('down')end
+ T.eq(state.menu.index,9);T.eq(state.menu.scroll,2,'native ListMenu scrolls its actual rows')
+ key('a');T.eq(state.level,'answer');key('down');T.eq(state.articleScroll,1)
+ key('b');T.eq(state.level,'questions');T.eq(state.menu.index,9);T.eq(world.ticks,0,'Help never updates the field')
+ key('b');T.eq(state.level,'main');T.eq(state.menu.index,2)
+ local paints=0;state.paint=function()paints=paints+1;return 9 end
+ Help.draw=function()base();return base()end
+ T.eq(state:draw(),9);T.eq(paints,1,'repeated source bases paint one native modal')
+ T.eq(base(),nil,'outside-phase draw cannot repaint')
+ local cover={};game.stack:push(cover);state:update(1/60);T.eq(state.menu.index,2)
+ state:draw();T.eq(paints,2,'covered native Help can still be drawn')
+ Help.draw=function()game.save={};return base()end
+ local before=game.save;T.eq(state:draw(),false);T.eq(paints,2,'replaced save denies native paint')
+ Help.draw=base;Help._service:poll();T.eq(Help.isOpen(),false);T.eq(game.stack:top(),cover)
+ T.eq(state.game,nil);T.eq(state.menu,nil);game.stack:pop();game.save=before
+ T.eq(Help.show(game,24),true);state=game.stack:top()
+ local released=0;state.resources={{release=function()released=released+1 end}}
+ Help._service:releaseOwner('unrelated');T.eq(Help.isOpen(),true)
+ key('r');T.eq(Help.isOpen(),false);T.eq(released,1);T.eq(game.stack:top(),world)
+ state:exit();T.eq(released,1,'resource release is idempotent')
+ T.eq(Help.show(game,24),true);state=game.stack:top()
+ local oldImageModule=love.image;love.image=love.image or{}
+ local oldImage,oldData=love.graphics.newImage,love.image.newImageData
+ local images,releases={},0
+ love.image.newImageData=function(w,h)
+  return{w=w,h=h,pixels={},setPixel=function(self,x,y,r,g,b,a)self.pixels[y*w+x+1]={r,g,b,a}end,release=function()end}
+ end
+ love.graphics.newImage=function(data)
+  local image={data=data,setFilter=function()end,release=function()releases=releases+1 end}
+  images[#images+1]=image;return image
+ end
+ state:art();T.eq(#state.resources,22);T.eq(#state.icons,13)
+ local first,second=images[1].data.pixels[1],images[1].data.pixels[2]
+ T.check(first[1]<second[1],'low nibble is the left original pixel')
+ local icon=state.icons[1].data
+ T.check(icon.pixels[65][1]>icon.pixels[1][1],'keypad second row uses the original sixteen-tile pitch')
+ state:art();T.eq(#images,22,'no frame-time resource recreation')
+ Help.close();T.eq(releases,22)
+ T.eq(Help.show(game,24),true);state=game.stack:top()
+ -- Use owned synthetic images for failure cleanup as well.
+ local made=0
+ love.graphics.newImage=function(data)
+  made=made+1;if made==3 then error('injected Help upload failure')end
+  return{setFilter=function()end,release=function()releases=releases+1 end}
+ end
+ T.raises(function()state:art()end,'injected Help upload failure')
+ T.eq(releases,24);T.eq(#state.resources,0);T.eq(state.tiles,nil)
+ Help.close();love.graphics.newImage,love.image.newImageData=oldImage,oldData
+ love.image=oldImageModule
+ -- Static IR preserves bank cell identity, icon width, placeholders and
+ -- explicit cursor operands instead of flattening the original controls.
+ local layout=Text.layout({{t='tag',control=0xF9,code=3},{t='tag',control=0xF8,code=2},
+  {t='ext',cmd=18,args={72}},{t='ph',code=1},{t='nl'},{t='text',s='A\n\nB'},{t='eos'}},208,facts.keypad)
+ T.eq(layout.glyphs[1].code,259);T.eq(layout.glyphs[2].icon,2)
+ T.eq(layout.glyphs[3].x,72);T.eq(layout.height,60,'explicit blank lines retain their original rows')
+ local translated=Text.layout({{t='tag',tag='{A_BUTTON}'},{t='text',s=' NEXT'}},208,facts.keypad)
+ T.eq(translated.glyphs[1].icon,0,'translated tags retain actual keypad art')
+ local other={data=game.data,save=game.save,stack=game.stack};T.eq(Help.show(other,23),false)
+ -- Mod shutdown removes only its own Help, even under an unrelated screen.
+ game.mods.mods={help_owner={enabled=true}}
+ local G=require('src.core.Game3')
+ T.eq(G._withCallbackOwner('help_owner',Help.show,game,25),true)
+ state=game.stack:top();local unrelated={};game.stack:push(unrelated)
+ Help._service:releaseOwner('help_owner');T.eq(game.stack:top(),unrelated)
+ T.eq(Help.isOpen(),false);T.eq(state.game,nil);game.stack:pop()
+ Help.draw=base;f.close();require('src.core.Game3').release()
+end
+for _,edition in ipairs{'emerald','ruby','sapphire'}do
+ local f,game=fixture(edition);T.eq(Help.show(game,23),false);T.eq(Help.isOpen(),false);f.close()
+end
+Help._service:release();Help.draw=base;package.loaded['src.core.Game']=original;Version.set('firered')
+T.finish('native Help modal, shared list input, structured text and owner retirement')
diff --git a/tests/engine/native_help_progress.lua b/tests/engine/native_help_progress.lua
new file mode 100644
index 000000000..e36dd0c64
--- /dev/null
+++ b/tests/engine/native_help_progress.lua
@@ -0,0 +1,30 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit');local P=require('src.ui.Gen3HelpProgress')
+local game={save={flags={},inventory={},pokedex={caught={}}},data={constants={itemOrder={[361]='TOWN_MAP'}},
+ pokemon={A={dex=4},ALIAS={dex=4},B={dex=7},HOENN={dex=252}}}}
+local function flag(id,value)game.save.flags[('FLAG_G3_%04X'):format(id)]=value end
+local baseline={10,25,21,5,35}
+for topic,limit in ipairs{44,48,43,7,35}do
+ local count=0;for id=1,limit do if P.allowed(game,topic,id)then count=count+1 end end
+ T.eq(count,baseline[topic],'retail fresh-progress question count for topic '..topic)
+ T.eq(P.allowed(game,topic,0),false);T.eq(P.allowed(game,topic,limit+1),false)
+end
+T.eq(P.allowed(game,1,21),false);flag(0x829,0);T.eq(P.allowed(game,1,21),false)
+flag(0x829,true);T.eq(P.allowed(game,1,21),true);T.eq(P.allowed(game,1,12),false)
+for _,id in ipairs{0x237,0x238,0x239,0x23A,0x23B,0x2EF,0x1F1}do
+ T.eq(P.allowed(game,1,28),false);flag(id,true)
+ for _,pair in ipairs{{1,28},{1,40},{2,16},{2,17},{3,36},{3,37}}do T.eq(P.allowed(game,pair[1],pair[2]),true)end
+ flag(id,nil)
+end
+T.eq(P.allowed(game,2,14),false);game.save.inventory.TOWN_MAP=1;T.eq(P.allowed(game,2,14),true)
+game.save.inventory.TOWN_MAP=0;T.eq(P.allowed(game,2,14),false)
+game.save.pokedex.caught={A=true,ALIAS=true,HOENN=true};T.eq(P.allowed(game,2,4),false,'duplicate/Hoenn dex IDs do not unlock Kanto switch help')
+game.save.pokedex.caught.B=true;T.eq(P.allowed(game,2,4),true);T.eq(P.allowed(game,2,34),true)
+local facts={basicTerms={1,3},contexts={[23]={{},{},{1,4,3,4,14}}}}
+T.same(P.items(game,facts,23,3),{14})
+flag(0x4B0,true);T.same(P.items(game,facts,23,3),{14,1,3},'Brock adds basic terms exactly once at the original end')
+for _,id in ipairs{0x2CF,0x891,0x895,0x8A4,0x828,0x829,0x820,0x29B,0x892,0x271,0x82C,0x821,0x237}do flag(id,true)end
+game.save.inventory.TOWN_MAP=1
+for topic,limit in ipairs{44,48,43,7,35}do for id=1,limit do T.eq(P.allowed(game,topic,id),true,'fully unlocked original Help row')end end
+T.finish('native Help progress, all question families, actual flag/item/dex identity and basic-term ordering')
diff --git a/tests/engine/native_hoenn_dex_observations.lua b/tests/engine/native_hoenn_dex_observations.lua
new file mode 100644
index 000000000..6de60c55b
--- /dev/null
+++ b/tests/engine/native_hoenn_dex_observations.lua
@@ -0,0 +1,84 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local original=package.loaded['src.core.Game']
+local Dex=require('src.ui.game3.rse.pokedex');local Common=require('src.ui.game3.pokedex')
+local Native=require('src.ui.Gen3Pokedex');local Search=require('src.ui.Gen3DexSearch')
+local Observation=require('src.compat.gen1.NativeModalObservation');local G=require('src.core.Game3')
+local V=require('src.core.GameVersion')
+T.eq(package.loaded['src.core.Game'],original,'Hoenn query import does not construct Game')
+T.eq(Dex.active(),nil);T.eq(Dex.isOpen(),false)
+for _,edition in ipairs{'emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game;f.fresh('TACKLE')
+ game.save.pokedex={seen={},owned={}};game.save.nationalDex=false
+ game.data.constants.gen3HoennDex={native=2,numbers={CHARMANDER=1,QA_EXTRA=2}}
+ game.data.pokemon.QA_EXTRA={index=277,dex=252,name='QA EXTRA'}
+ local before=game.save.party[1].hp
+ local fake=setmetatable({game=game},Native);table.insert(game.stack.states,fake)
+ T.eq(Dex.active(),nil,'class identity alone cannot admit a dex');table.remove(game.stack.states)
+ local state=Native.new(game);T.eq(Dex.active(),nil,'construction is not an open screen')
+ game.stack:push(state);local view=assert(Dex.active())
+ T.eq(Common.isOpen(),true);T.eq(Dex.active(),view);T.eq(view.open,true)
+ T.eq(view.edition,edition);T.eq(view.nationalEnabled,false);T.eq(view.selected,0);T.eq(view.dexMode,0)
+ state:move(1);T.eq(view.selected,1,'native movement owns the zero-based observation')
+ game.save.nationalDex=true;T.eq(view.nationalEnabled,true)
+ T.eq(view.searchState,nil,'no invented search while the native list is open')
+ local child=Search.new(game,{pane='form'});T.eq(view.searchState,nil,'search constructor also waits for stack admission')
+ game.stack:push(child);local q=view.searchState
+ T.eq(q.phase,'menu');T.eq(q.menuItem,0);T.eq(q.topBar,0)
+ child.row=4;child.picking=4;child.pick=5;child.pickTop=2
+ q=view.searchState;T.eq(q.phase,'param');T.eq(q.menuItem,3);T.eq(q.cursor[3],2);T.eq(q.scroll[3],2)
+ q.cursor[3]=999;q.scroll[3]=999;T.eq(child.pick,5);T.eq(child.pickTop,2)
+ T.eq(view.searchState.cursor[3],2,'nested search data is detached')
+ child.picking=nil;child.pane='topbar';child.bar=3
+ T.eq(view.searchState.phase,'topbar');T.eq(view.searchState.topBar,2)
+ T.raises(function()view.selected=4 end,'read-only')
+ T.eq(state.index,2,'observations do not change selection')
+ local cover={};game.stack:push(cover);T.eq(Dex.active(),view,'covered modal remains the actual owner')
+ game.stack:pop();game.stack:pop();T.eq(view.searchState,nil)
+ for _,key in ipairs{'data','save','mods','stack'}do
+  local old=game[key];game[key]={};T.eq(Dex.active(),nil,key..' replacement retires observation')
+  T.eq(view.open,false);T.eq(view.selected,nil);game[key]=old
+  local nextView=assert(Dex.active());T.neq(nextView,view);view=nextView
+ end
+ V.set('firered');T.eq(Dex.active(),nil);T.eq(view.open,false);V.set(edition);view=assert(Dex.active())
+ G.release();T.eq(view.open,false,'facade reset retires retained views');view=assert(Dex.active())
+ local owned=G._withCallbackOwner('dex-owner',Dex.active)
+ Dex._service:releaseOwner('unrelated');T.eq(owned.open,true)
+ Dex._service:releaseOwner('dex-owner');T.eq(owned.open,false,'owner cleanup releases only observations')
+ T.eq(game.stack:top(),state,'cleanup cannot close a native menu')
+ T.eq(game.save.party[1].hp,before,'metadata does not consume HP')
+ game.stack:pop();T.eq(Dex.active(),nil);f.close();G.release();Dex._service.release()
+end
+-- The fork's RS owner stores its real search state inside its isolated native
+-- controller. This fixture stamps a typed state explicitly; real constructor/
+-- artwork qualification is performed separately against the actual ROM.
+local rsFile=io.open('src/ui/Gen3RsPokedex.lua','rb')
+if rsFile then
+ rsFile:close();local RS=require('src.ui.Gen3RsPokedex')
+ for _,edition in ipairs{'ruby','sapphire'}do
+  local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+  package.loaded['src.core.Game']=game
+  local raw={nationalEnabled=false,selected=0,dexMode=0,fn='Search',state=3,
+   searchState={phase='param',topBar=1,menuItem=2,message='native',cursor={[2]=4},scroll={[2]=8}}}
+  local state=setmetatable({game=game,state=raw,exit=function(s)s.closed=true end},RS)
+  game.stack:push(state);T.eq(Dex.active(),nil)
+  Observation.capture(state,game);local view=assert(Dex.active())
+  T.eq(Common.isOpen(),true);T.eq(view.nationalEnabled,false);T.eq(view.selected,0);T.eq(view.dexMode,0)
+  T.eq(view.fn,'Search');T.eq(view.state,3)
+  local q=view.searchState;T.eq(q.phase,'param');T.eq(q.menuItem,2);T.eq(q.topBar,1)
+  T.eq(q.cursor[2],4);T.eq(q.scroll[2],8);q.cursor[2]=0;T.eq(raw.searchState.cursor[2],4)
+  raw.selected=9;T.eq(view.selected,9);raw.searchState.phase='menu';T.eq(view.searchState.phase,'menu')
+  state.state={nationalEnabled=true};T.eq(view.open,false,'replacement RS state retires its old view')
+  local nextView=assert(Dex.active());T.eq(nextView.nationalEnabled,true)
+  T.eq(nextView.selected,nil,'unavailable fields are not fabricated sentinels')
+  game.stack:pop();T.eq(nextView.open,false);T.eq(Dex.active(),nil)
+  f.close();G.release();Dex._service.release()
+ end
+end
+for _,edition in ipairs{'firered','leafgreen','red','crystal','platinum','black'}do
+ V.set(edition);T.eq(Dex.active(),nil);T.eq(Dex.isOpen(),false)
+end
+package.loaded['src.core.Game']=original;V.set('firered')
+T.finish('native Hoenn dex/search observations, detached cursors and constructor-bound retirement')
diff --git a/tests/engine/native_indexed_palette.lua b/tests/engine/native_indexed_palette.lua
new file mode 100644
index 000000000..e08b249db
--- /dev/null
+++ b/tests/engine/native_indexed_palette.lua
@@ -0,0 +1,50 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local before=package.loaded['src.core.Game']
+local Core=require('src.render.Gen3IndexedPalette')
+local Pal=require('src.core.game3.battle.anim_pal')
+T.eq(package.loaded['src.core.Game'],before,'palette math cannot bootstrap a game')
+local native=require('src.battle.Gen3MoveAnim')
+for value=0,32767,17 do
+ local r,g,b=Core.rgb(value);local nr,ng,nb=native.blendColour(value)
+ T.eq(Core.pack(r,g,b),value);T.check(math.abs(r/31-nr)<1e-12);T.check(math.abs(g/31-ng)<1e-12);T.check(math.abs(b/31-nb)<1e-12)
+end
+T.eq(Core.pack(Core.rgb(65535)),32767)
+for _,c in ipairs{-1,0,.5,1,7.5,15,16,17}do
+ local r,g,b=Core.blend5(3,17,31,c,29,1,4)
+ T.eq(r,math.floor((3*(16-c)+29*c)/16));T.eq(g,math.floor((17*(16-c)+c)/16));T.eq(b,math.floor((31*(16-c)+4*c)/16))
+end
+local colours={[0]=Core.pack(31,0,0),Core.pack(0,31,0),Core.pack(0,0,31)}
+local out=Pal.resolve(colours,{coeff=16,color=Core.pack(3,9,21)})
+for i=0,15 do T.eq(out[i],Core.pack(3,9,21))end
+T.eq(Pal.resolve(colours,{coeff=-1})[0],colours[0],'negative resolve coefficients leave the original buffer unchanged')
+T.eq(Pal.resolve(colours,{gray=true})[0],Core.pack(10,10,10))
+T.eq(Pal.resolve(colours,{affine={m=-1,r=1,g=1,b=1}})[0],Core.pack(0,31,31))
+local sourceCompiler=love.graphics.newShader;local compiled={}
+love.graphics.newShader=function(source)
+ local s={source=source,uploads={}}
+ function s:send(name,...)
+  local values={};for i=1,select('#',...)do local v=select(i,...);values[i]={unpack(v)}end
+  self.uploads[#self.uploads+1]={name=name,values=values}
+ end
+ function s:release()self.released=true end
+ compiled[#compiled+1]=s;return s
+end
+local Host=require('src.mods.Runtime');Host.currentMod='palette_a'
+local old={};love.graphics.setShader(old)
+local source=assert(Pal.send(colours));T.eq(love.graphics.getShader(),old,'send does not bind a caller shader')
+local sent=source.uploads[#source.uploads];T.eq(sent.name,'pal');T.eq(#sent.values,16)
+T.eq(sent.values[1][1],1);T.eq(sent.values[1][4],0);T.eq(sent.values[2][2],1)
+Pal.send(colours,{opaque0=true});T.eq(source.uploads[#source.uploads].values[1][4],1)
+local n=Core.new();local a={};for i=1,16 do a[i]={.1,.2,.3,0}end
+local shader=assert(n:sendNormalized(a));T.neq(shader,source,'source and native callers do not share mutable uniforms')
+T.eq(shader.uploads[1].values[1][4],1,'native RGB backdrop ignores caller alpha as before')
+T.eq(#shader.uploads,1,'one native palette upload replaces sixteen scalar sends')
+Host.currentMod='palette_b';Pal.shader();require('src.core.game3.asset_stream').cancelOwner('palette_a')
+T.eq(source.released,nil,'another source owner keeps the bank alive')
+require('src.core.game3.asset_stream').cancelOwner('palette_b');T.eq(source.released,true)
+T.eq(shader.released,nil,'source retirement cannot release native backdrop resources')
+n:release();T.eq(shader.released,true)
+Host.currentMod=nil;love.graphics.newShader=sourceCompiler
+T.finish('native indexed palettes, packed arithmetic and independent owned banks')
diff --git a/tests/engine/native_modal_observations.lua b/tests/engine/native_modal_observations.lua
new file mode 100644
index 000000000..6cf7d0085
--- /dev/null
+++ b/tests/engine/native_modal_observations.lua
@@ -0,0 +1,72 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Version=require('src.core.GameVersion');local G=require('src.core.Game3')
+local Bag=require('src.ui.game3.bag_menu');local Dex=require('src.ui.game3.pokedex')
+local Growth=require('src.ui.game3.stat_growth');local Party=require('src.ui.game3.party_menu')
+local Observation=require('src.compat.gen1.NativeModalObservation')
+local original=package.loaded['src.core.Game']
+local function fresh(edition)
+ local f=require('tools.battle-source-runtime.fixture').new(edition);package.loaded['src.core.Game']=f.game
+ f.fresh('TACKLE');return f
+end
+local function collect()for _=1,5 do collectgarbage('collect')end end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=fresh(edition);local game=f.game;local before=game.save.party[1].hp
+ local types={
+  {require('src.ui.Gen3BagMenu'),Bag,function()return require('src.ui.Gen3BagMenu').new(game)end},
+  {require('src.ui.Gen3Pokedex'),Dex,function()return require('src.ui.Gen3Pokedex').new(game)end},
+  {require('src.ui.Gen3PartyMenu'),Party,function()return require('src.ui.Gen3PartyMenu').new(game,{})end},
+  {require('src.battle.BattleState').StatBox,Growth,function()return require('src.battle.BattleState').StatBox.new(game,game.save.party[1])end},
+ }
+ for _,entry in ipairs(types)do
+  local class,api,construct=unpack(entry)
+  T.eq(api.isOpen(),false)
+  local unstamped=setmetatable({game=game},class);table.insert(game.stack.states,unstamped)
+  T.eq(api.isOpen(),false,'class identity alone cannot adopt an unbound screen');table.remove(game.stack.states)
+  local screen=construct();T.eq(api.isOpen(),false,'construction does not mean open')
+  game.stack:push(screen);T.eq(api.isOpen(),true)
+  local cover={};game.stack:push(cover);T.eq(api.isOpen(),true,'covered modal is still native/open')
+  local save,data,loader=game.save,game.data,game.mods
+  game.save={};T.eq(api.isOpen(),false);game.save=save
+  game.data={};T.eq(api.isOpen(),false);game.data=data
+  game.mods={};T.eq(api.isOpen(),false);game.mods=loader
+  Version.set(edition=='firered'and'leafgreen'or'firered');T.eq(api.isOpen(),false);Version.set(edition)
+  T.eq(api.isOpen(),true);T.eq(game.stack:top(),cover,'observation never removes unrelated UI')
+  game.stack:pop();game.stack:pop();T.eq(api.isOpen(),false)
+ end
+ -- Missing nested StatBox cannot accidentally match the battle class itself.
+ local Battle=require('src.battle.BattleState');local stat=Battle.StatBox
+ local battle=f.fresh('TACKLE').battle;Observation.capture(battle,game);game.stack:push(battle)
+ Battle.StatBox=nil;T.eq(Growth.isOpen(),false);Battle.StatBox=stat;game.stack:pop()
+ T.eq(game.save.party[1].hp,before,'queries never consume HP')
+ f.close();G.release()
+end
+-- FR/LG registration uses its own real native class and constructor.
+do
+ local f=fresh('firered');local game=f.game
+ local class=require('src.ui.Gen3PokedexFRLG')
+ game.data.constants.gen3FRLGPokedex={images={kanto_field='synthetic-unused-field'}}
+ -- base/newEntry reads native pokemon data; no scripted registration is run.
+ local state=class.newEntry(game,'CHARMANDER',true);game.stack:push(state)
+ T.eq(Dex.isOpen(),true);game.stack:pop();T.eq(Dex.isOpen(),false);f.close();G.release()
+end
+-- A weak observation must not retain a removed state, native world, save or
+-- dataset through the LuaJIT weak-key/value-to-stack cycle.
+local weak=setmetatable({},{__mode='v'})
+do
+ local f=fresh('firered');local game=f.game
+ local state=require('src.ui.Gen3BagMenu').new(game);game.stack:push(state);T.eq(Bag.isOpen(),true)
+ weak[1],weak[2],weak[3],weak[4]=state,game,game.save,game.data
+ game.stack:pop();f.close();G.release();package.loaded['src.core.Game']=original
+end
+-- The fixture intentionally installs global font/type registries. Replace
+-- those independent native owners before attributing retained data to the
+-- weak modal registry under test.
+require('src.render.Font').load(T.fixtures.fresh());require('src.battle.TypeChart').load(T.fixtures.fresh())
+collect();for i=1,4 do T.eq(weak[i],nil,'retired modal observation is collectable')end
+for _,edition in ipairs{'gold','silver','crystal','red'}do
+ Version.set(edition);T.eq(Bag.isOpen(),false);T.eq(Dex.isOpen(),false);T.eq(Party.isOpen(),false);T.eq(Growth.isOpen(),false)
+end
+Version.set('firered');package.loaded['src.core.Game']=original
+T.finish('constructor-bound native bag, dex, party and stat-window observations without retained owners')
diff --git a/tests/engine/native_mon_animation_source.lua b/tests/engine/native_mon_animation_source.lua
new file mode 100644
index 000000000..787eca455
--- /dev/null
+++ b/tests/engine/native_mon_animation_source.lua
@@ -0,0 +1,47 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Source=require('src.core.game3.mon_anim')
+local Native=require('src.pokemon.MonAnim')
+local Pictures=require('src.pokemon.PicAnim')
+local Host=require('src.mods.Runtime')
+local original=package.loaded['src.core.Game']
+T.eq(Source.enabled(),false)
+T.eq(Source.newSprite(4),nil)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ local game=f.game;package.loaded['src.core.Game']=game
+ game.data.constants=game.data.constants or{}
+ game.data.constants.speciesOrder={[4]='CHARMANDER'}
+ game.data.constants.gen3MonAnim={anims={CHARMANDER={anim='H_SHAKE',delay=3}}}
+ local rec={sheet='unused-synthetic-strip.png',width=64,height=64,count=2,
+   play={{frame=1,dur=2},{frame=2,dur=3}},idle={{frame=0,dur=1}}}
+ game.data.pokemon.CHARMANDER.picAnim=rec
+ T.eq(Source.enabled(),true)
+ Host.currentMod='motion_owner';local sprite=assert(Source.newSprite(4));Host.currentMod=nil
+ T.eq(Source.summary(sprite,4,false),sprite)
+ local motion=assert(Native.new(game.data,'CHARMANDER'));motion:restart()
+ local frames=assert(Pictures.new(game.data,'CHARMANDER'));frames:start()
+ for tick=0,70 do
+  local native=motion:transform();local source=Source.transform(sprite)
+  T.eq(source.x2,native.dx);T.eq(source.y2,native.dy)
+  T.eq(source.sx,native.sx);T.eq(source.sy,native.sy);T.eq(source.rotation,native.rot)
+  T.eq(source.frame,frames:frame());T.eq(sprite.frames,tick)
+  Source.step(sprite);motion:update(1/60);frames:update(1/60)
+ end
+ T.eq(Source.done(sprite),true)
+ T.eq(Source.framePic(4,1,true),nil,'a missing shiny strip cannot flash the normal palette')
+ T.eq(Source.summary(sprite,4,true),sprite)
+ require('src.core.game3.asset_stream').cancelOwner('other_owner');T.eq(Source.step(sprite),true)
+ require('src.core.game3.asset_stream').cancelOwner('motion_owner');T.eq(Source.step(sprite),false)
+ T.eq(Source.done(sprite),true)
+ local swapped=assert(Source.newSprite(4));Source.summary(swapped,4)
+ require('src.core.GameVersion').set(edition=='firered'and'emerald'or'firered')
+ T.eq(Source.step(swapped),false,'edition replacement retires the presentation lease')
+ require('src.core.GameVersion').set(edition)
+ local retired=assert(Source.newSprite(4));Source.summary(retired,4)
+ game.data={pokemon={}};T.eq(Source.step(retired),false,'dataset replacement retires the presentation lease')
+ f.close()
+end
+Source._service.release();package.loaded['src.core.Game']=original
+T.finish('native motion and frame-player presentation adapter; native timing only')
diff --git a/tests/engine/native_move_effect_symbols.lua b/tests/engine/native_move_effect_symbols.lua
new file mode 100644
index 000000000..5a2240723
--- /dev/null
+++ b/tests/engine/native_move_effect_symbols.lua
@@ -0,0 +1,47 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local original=package.loaded['src.core.Game']
+local Catalog=require('src.battle.Gen3EffectCatalog')
+local E=require('src.core.game3.battle.effect_ids')
+T.eq(package.loaded['src.core.Game'],original,'constant import cannot bootstrap a game')
+local file=assert(io.open('tests/fixtures/gba_move_effects.h','rb'))
+local header=file:read('*a');file:close()
+-- Parse the separately retained pinned C header, rather than deriving expected
+-- positions from the runtime's compact name list. Keep unused slots too.
+local reference,seen,count={},{},0
+for name,value in header:gmatch('#define%s+EFFECT_([A-Z0-9_]+)%s+(%d+)')do
+ local id=tonumber(value);reference[name]=id;count=count+1
+ T.eq(seen[id],nil,'canonical IDs are unique');seen[id]=true
+ T.eq(Catalog.id(name),id,'native ID matches public header: '..name)
+ T.eq(Catalog.name(id),name,'native symbol matches public header: '..name)
+ T.eq(E[name],id,'source constant matches the canonical native ID')
+end
+T.eq(count,214);T.eq(Catalog.count(),214)
+for id=0,213 do T.eq(seen[id],true,'canonical dispatch retains slot '..id)end
+local keys=0;for name,id in pairs(E)do keys=keys+1;T.eq(reference[name],id)end;T.eq(keys,214)
+T.eq(E.HIT,0);T.check(E.HIT,'zero effect remains a real Lua constant')
+for _,invalid in ipairs{-1,214,.5,0/0,math.huge,'0',false,{}}do T.eq(Catalog.name(invalid),nil)end
+for _,invalid in ipairs{'hit','EFFECT_HIT','UNKNOWN',0,false,{}}do T.eq(Catalog.id(invalid),nil)end
+local copy=Catalog.snapshot();copy.HIT=213;E.HIT=213
+T.eq(Catalog.id('HIT'),0,'source/snapshot edits cannot change native authority')
+T.eq(Catalog.snapshot().HIT,0);E.HIT=0
+local Moves=require('src.core.game3.battle.moves')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ package.loaded['src.core.Game']=f.game
+ local key=f.ids.TACKLE;f.game.data.constants.moveOrder={[33]=key}
+ local row=f.game.data.moves[key];row.effect='NATIVE_DISPATCH_NAME'
+ for name,id in pairs(reference)do
+  row.gen3Effect=id;local move=assert(Moves.get(33))
+  T.eq(move.effect,E[name]);T.eq(move.effectSymbol,name)
+  T.eq(move.nativeEffect,'NATIVE_DISPATCH_NAME','symbol observations do not rewrite native dispatch')
+ end
+ -- Unknown custom bytes remain usable metadata; a canonical name must not
+ -- invent support or reinterpret a caller's native extension.
+ row.gen3Effect=255;T.eq(Moves.get(33).effect,255);T.eq(Moves.get(33).effectSymbol,nil)
+ row.gen3Effect=nil;T.eq(Moves.get(33).effectSymbol,nil)
+ f.close()
+end
+package.loaded['src.core.Game']=original
+T.finish('canonical native move-effect IDs, source snapshot isolation and live imported symbols')
diff --git a/tests/engine/native_move_rule_metadata.lua b/tests/engine/native_move_rule_metadata.lua
new file mode 100644
index 000000000..0d3b79271
--- /dev/null
+++ b/tests/engine/native_move_rule_metadata.lua
@@ -0,0 +1,62 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Moves=require('src.core.game3.battle.moves');local Rules=require('src.core.game3.battle.rules')
+local Damage=require('src.battle.Damage');local V=require('src.core.GameVersion')
+local original=package.loaded['src.core.Game']
+T.eq(Rules.crit.CHANCE,nil,'no fabricated GBA session')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ package.loaded['src.core.Game']=f.game
+ local key=f.ids.TACKLE;local row=f.game.data.moves[key]
+ f.game.data.constants.moveOrder={[33]=key};f.game.data.constants.typeOrder={'NORMAL'}
+ f.game.data.constants.types={NORMAL={index=0}}
+ row.gen3Effect=0;row.effect='NO_ADDITIONAL_EFFECT';row.secondaryChance=10;row.effectChance=26
+ row.flags={contact=true,nested={owner='native'}};row.hits={min=2,max=5}
+ row.highCrit=false;row.makesContact=true;row.protectAffected=true
+ for _,value in ipairs{33,'33',key,{id=key},{move=33}}do
+  local out=assert(Moves.get(value))
+  T.eq(out.id,33);T.eq(out.numId,33);T.eq(out.nativeId,key);T.eq(out.effect,0)
+  T.eq(out.gen3Effect,0);T.eq(out.nativeEffect,'NO_ADDITIONAL_EFFECT')
+  T.eq(out.type,0);T.eq(out.secondaryChance,10);T.eq(out.effectChance,26)
+  T.eq(out.makesContact,true);T.eq(out.protectAffected,true)
+  out.flags.nested.owner='source';out.hits.min=9;out.name='SOURCE'
+  T.eq(row.flags.nested.owner,'native');T.eq(row.hits.min,2);T.eq(row.name,'TACKLE')
+ end
+ for _,byte in ipairs{2,4,6,17,31,36,43,103,200,209,255}do
+  row.gen3Effect=byte;T.eq(Moves.get(33).effect,byte,'live imported byte, no name reverse-guess')
+ end
+ for _,invalid in ipairs{-1,256,.5,0/0,math.huge,'0'}do
+  row.gen3Effect=invalid;local out,why=Moves.get(33);T.eq(out,nil);T.eq(why,'invalid imported native move-effect byte')
+ end
+ row.gen3Effect=nil;T.eq(Moves.get(33).effect,'NO_ADDITIONAL_EFFECT','older metadata stays explicit')
+ T.eq(Moves.get(33).gen3Effect,nil);row.gen3Effect=0
+ row.flags={contact=false};row.hits=false;T.eq(Moves.get(33).flags.contact,false);T.eq(Moves.get(33).hits,false)
+ row.hits=function()error('metadata must never execute a hit producer')end;T.eq(Moves.get(33).hits,true)
+ row.flags=51;row.hits=nil;T.eq(Moves.get(33).flags,51)
+ T.eq(Moves.get(999999),nil);T.eq(Moves.get({}),nil)
+ local replacement={};for k,v in pairs(row)do replacement[k]=v end
+ replacement.name='LIVE';f.game.data.moves[key]=replacement;T.eq(Moves.get(33).name,'LIVE')
+ local chance=Rules.crit.CHANCE;T.same(chance,{[0]=16,8,4,3,2})
+ chance[0]=1;T.eq(Rules.crit.CHANCE[0],16,'returned rule rows are detached')
+ T.raises(function()Rules.crit.CHANCE={}end,'read-only')
+ local battle=f.fresh('TACKLE').battle
+ -- The older public calculation owns a one-based RNG and legacy stage inputs;
+ -- the current native command owns physical items and a zero-based draw.
+ local modern=debug.getinfo(Damage.critRoll,'u').nparams>=7
+ for stage=0,4 do
+  local user=battle.player;user.focusEnergy=stage>=2
+  local extra=(stage==1 or stage==3 or stage==4)and 1 or 0
+  user.item=modern and extra*198 or 0;user.critStage=modern and 0 or extra
+  local high=stage==4;local calls=0;local lo,hi
+  local function rng(a,b)calls=calls+1;lo,hi=a,b;return a end
+  T.eq(Damage.critRoll({critStages=true},user,key,rng,high,battle.data,battle),true)
+  T.eq(calls,1);T.eq(lo,modern and 0 or 1);T.eq(hi-lo+1,Rules.crit.CHANCE[stage],'metadata matches native RNG denominator')
+ end
+ f.close()
+end
+for _,edition in ipairs{'red','crystal','platinum','black'}do
+ V.set(edition);T.eq(Rules.crit.CHANCE,nil,'GBA rules do not replace other generations')
+end
+package.loaded['src.core.Game']=original;V.set('firered')
+T.finish('native move bytes, detached metadata and shared critical-rule observations')
diff --git a/tests/engine/native_particle_pass.lua b/tests/engine/native_particle_pass.lua
new file mode 100644
index 000000000..61ef1e3fb
--- /dev/null
+++ b/tests/engine/native_particle_pass.lua
@@ -0,0 +1,112 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local A=require('src.core.game3.battle.anim')
+local P=require('src.core.game3.battle.particle_pass')
+local Native=require('src.battle.Gen3Battle')
+local Battle=require('src.core.game3.battle')
+local G=require('src.core.Game3')
+local Scope=require('src.render.GraphicsScope')
+local Assets=require('src.render.Assets')
+local Sprites=require('src.core.game3.battle.anim_sprites')
+local image,draw=Assets.image,love.graphics.draw
+local original=package.loaded['src.core.Game']
+T.eq(A.drawParticles(0,999),false)
+T.raises(function()A.drawParticles(0/0,99)end,'finite','invalid particle bands are rejected')
+T.eq(A.drawParticles(200,0),false)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local gfx={};local events={}
+ for _,spec in ipairs{{'rear',3,30},{'back',2,50},{'middle',2,35},{'front',2,20},{'near',1,30}}do
+  local tag,priority,sub=spec[1],spec[2],spec[3]
+  gfx[tag]={image=tag,frameWidth=16,frameHeight=16,frames=1,held={{0,60}}}
+  events[#events+1]={sheet=tag,at=0,explicitLife=32,target=true,priority=priority,subpriority=sub,x=0,y=0}
+ end
+ game.data.constants.gen3BattleAnimGfx=gfx
+ game.data.constants.gen3BattlerCoords={singles={{x=72,y=80},{x=176,y=40},{x=48,y=40},{x=112,y=80}},doubles={{x=32,y=80},{x=200,y=40},{x=90,y=88},{x=152,y=32}}}
+ game.data.moves.MOVE_033.anim={duration=40,events=events}
+ local b=f.fresh('TACKLE').battle;b.enter=false;b:syncSides();game.stack:push(b);b.phase='menu'
+ local monImage=love.graphics.newCanvas(64,64)
+ b.picImage=function()return monImage end
+ b.player.sprite='qa-player';b.enemy.sprite='qa-enemy'
+ local images={}
+ Assets.image=function(path)
+  if not images[path]then local img=love.graphics.newCanvas(16,16);img.tag=path;images[path]=img end
+  return images[path]
+ end
+ local trace={};love.graphics.draw=function(img)table.insert(trace,img.tag or'unknown-image')end
+ local anim=assert(b.gen3Anim);T.eq(anim:start('MOVE_033',true,0,1,nil,b),true);b.gen3AnimPlaying=true
+ local nativePics=b.drawPicsLayer
+ b.drawPicsLayer=function(_,_,_,_,side)table.insert(trace,side)end
+ local frame,scriptFrame=b.frame,anim.frame;local hp=b.enemy.mon.hp;local queue=#b.queue
+ local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ local composed,residual=Native.drawMoveOamObjects(b,0,0,0);T.eq(composed,true,'native compositor: '..tostring(residual))
+ T.same(trace,{'rear','back','enemy','middle','player','front','near'},'native hardware painter establishes the order')
+ local expected=trace;trace={}
+ local descriptors=anim.oamEventDescriptors;local samples=0
+ anim.oamEventDescriptors=function(self,...)samples=samples+1;return descriptors(self,...)end
+ local function bands()
+  T.eq(A.drawParticles(0,99),true);table.insert(trace,'enemy')
+  T.eq(A.drawParticles(101,199),true);table.insert(trace,'player')
+  T.eq(A.drawParticles(201,999),true)
+ end
+ local ok=Scope.call(bands);T.eq(ok,true);T.same(trace,expected);T.eq(samples,1,'three UI bands share one native ordering sample')
+ trace={};T.eq(Scope.call(bands),true);T.same(trace,expected);T.eq(samples,2,'a separate capture paints again at the same native frame')
+ T.eq(b.frame,frame);T.eq(anim.frame,scriptFrame);T.eq(b.enemy.mon.hp,hp);T.eq(#b.queue,queue);T.eq(rolls,0)
+ local middle
+ for _,row in ipairs(Sprites.pool())do if row.tag=='middle'then middle=row end end
+ T.neq(middle,nil);middle.customDraw=function()table.insert(trace,'custom-middle')end
+ trace={};T.eq(Scope.call(bands),true)
+ T.same(trace,{'rear','back','enemy','custom-middle','player','front','near'},'source particle decorators keep the native event slot')
+ local canvas=love.graphics.newCanvas(80,80);love.graphics.setCanvas(canvas)
+ middle.customDraw=function()love.graphics.push('all');love.graphics.setCanvas(monImage);error('native particle decorator failure')end
+ T.raises(function()A.drawParticles(101,199)end,'native particle decorator failure','decorator errors remain visible')
+ T.eq(love.graphics.getCanvas(),canvas,'failed decorators restore the caller target');middle.customDraw=nil
+ local save=game.save
+ middle.customDraw=function()game.save={};return true end
+ local accepted,why=A.drawParticles(101,199);T.eq(accepted,false);T.eq(why,'native particle admission changed')
+ game.save=save;Sprites._service.release();P._service.release()
+ -- The native copied BG stays below its own OBJ priority and suppresses the
+ -- transferred battler through the existing native monbg predicate.
+ local drawCopy=b.drawGen3MonBgState
+ b.drawGen3MonBgState=function(_,copy)T.eq(copy.battler,b.player);T.eq(copy.bg,2);table.insert(trace,'copy-player')end
+ anim.monBgTimeline={{at=0,op='monbg',selector=0}};trace={}
+ T.eq(Native.drawMoveOamObjects(b,0,0,0),true)
+ T.same(trace,{'rear','copy-player','back','enemy','middle','front','near'})
+ trace={};T.eq(Scope.call(function()
+  T.eq(A.drawParticles(0,99),true);table.insert(trace,'enemy')
+  T.eq(A.drawParticles(101,199),true)
+  T.eq(b:gen3AnimMonBgHidden(b.player),true)
+  T.eq(A.drawParticles(201,999),true)
+ end),true)
+ T.same(trace,{'rear','copy-player','back','enemy','middle','front','near'})
+ anim.monBgTimeline=nil;b.drawGen3MonBgState=drawCopy;P._service.release()
+ -- Exact unknown-key fallback still uses native event order and painter.
+ events[3].subpriority=nil;anim.oamRanks={};trace={}
+ T.eq(A.drawParticles(0,99),true);T.eq(#trace,0)
+ T.eq(A.drawParticles(201,999),true);T.eq(#trace,5);events[3].subpriority=35
+ -- Default native doubles retain their established fallback; the explicit
+ -- source particle pass can observe all four actual native battler slots.
+ local State=require('src.battle.BattleState');local Pokemon=require('src.pokemon.Pokemon')
+ for id=2,3 do local mon=Pokemon.new(game.data,'CHARMANDER',30,function(lo)return lo or 0 end)
+  b:placeBattler(id,State.makeBattler(game.data,mon,id%2==0,id%2==0 and game.save or nil,b))
+  b:battlerAt(id).sprite='qa-slot-'..id
+ end
+ b.double=true;b:syncSides();P._service.release()
+ local accepted,why=Native.drawMoveOamObjects(b,0,0,0);T.eq(accepted,false);T.eq(why,'double-battler-slot')
+ local objects=Native.moveOamObjects(b,true);T.check(type(objects)=='table')
+ trace={};T.eq(Scope.call(function()
+  T.eq(A.drawParticles(0,99),true);table.insert(trace,'enemy-right')
+  T.eq(A.drawParticles(101,199),true);table.insert(trace,'enemy-left')
+  T.eq(A.drawParticles(201,299),true);table.insert(trace,'player-left')
+  T.eq(A.drawParticles(301,399),true);table.insert(trace,'player-right')
+  T.eq(A.drawParticles(401,999),true)
+ end),true)
+ T.same(trace,{'rear','enemy-right','back','enemy-left','middle','player-left','front','player-right','near'})
+ b.drawPicsLayer=nativePics;love.graphics.setCanvas();Assets.image=image;love.graphics.draw=draw
+ game.stack:pop();T.eq(A.drawParticles(0,999),false)
+ Sprites._service.release();P._service.release();A._service.release();Battle._service.release();f.close();G.release()
+end
+Assets.image=image;love.graphics.draw=draw;package.loaded['src.core.Game']=original
+T.finish('native particle order, borrowed painters, capture scope, callbacks, doubles and retirement')
diff --git a/tests/engine/native_picture_identity.lua b/tests/engine/native_picture_identity.lua
new file mode 100644
index 000000000..ac2687d36
--- /dev/null
+++ b/tests/engine/native_picture_identity.lua
@@ -0,0 +1,48 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local P=require('src.core.game3.pokemon')
+local Id=require('src.pokemon.Gen3PictureIdentity')
+local original=package.loaded['src.core.Game']
+T.eq(P.picSpecies(4),nil);T.eq(P.picBaseSpecies(413),nil)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local data=game.data;local copy=require('src.mods.Merge').deepCopy
+ local unown=copy(data.pokemon.CHARMANDER);unown.index,unown.dex,unown.id,unown.name=201,201,'UNOWN','UNOWN'
+ data.pokemon.UNOWN=unown;data.constants.speciesOrder[201]='UNOWN'
+ data.pokemon.SPARSE={index=277,dex=252,name='SPARSE'};data.constants.speciesOrder[277]='SPARSE'
+ T.eq(P.picSpecies(4),4);T.eq(P.picSpecies('4'),4);T.eq(P.picSpecies('CHARMANDER'),4)
+ T.eq(P.picSpecies(277),277);T.eq(P.picSpecies(252),nil,'National Dex numbers cannot replace cartridge slots')
+ T.eq(P.picSpecies(8888),nil);T.eq(P.picBaseSpecies(8888),nil)
+ for _,row in ipairs{{0,0},{1,1},{4,0},{256,4},{65536,16},{16777216,8},{4294967295,3},{-1,3}}do
+  local personality,letter=row[1],row[2]
+  T.eq(P.unownLetter(personality),letter)
+  local slot=letter==0 and 201 or 412+letter
+  T.eq(P.picSpecies(201,personality),slot)
+  local base,form=P.picBaseSpecies(slot);T.eq(base,201);T.eq(form,letter)
+ end
+ for letter=1,27 do
+  local base,form=P.picBaseSpecies(412+letter);T.eq(base,201);T.eq(form,letter)
+ end
+ T.eq(P.picSpecies(413),413,'picture-slot normalization is idempotent');T.eq(P.picBaseSpecies(440),nil);T.eq(P.picSpecies(201,0/0),nil)
+ T.eq(P.picSpecies(201,math.huge),nil);T.eq(P.picSpecies(201,1.5),nil)
+ local entry=assert(P.frontPic(4));T.eq(P.frontPic(P.picSpecies(4)),entry)
+ T.eq(P.frontPic(413),nil,'unavailable variants cannot silently show Unown A')
+ T.eq(P.frontPic(201,0,false,1),nil,'direct personality requests retain the same missing-art boundary')
+ T.eq(P.backPic(413),nil)
+ local previous=data.constants.speciesOrder
+ data.pokemon.EXTRA={index=413,dex=600,name='EXTRA'};data.constants.speciesOrder=setmetatable({[413]='EXTRA'},{__index=previous})
+ -- Copy actual entries: identity indices read the imported table, not its
+ -- metatable, so both records are made explicit for this collision case.
+ for n,k in pairs(previous)do data.constants.speciesOrder[n]=k end
+ T.eq(P.picSpecies(201,1),nil,'art aliases cannot replace a registered logical species')
+ T.eq(P.picBaseSpecies(413),413,'explicit native content keeps its existing identity')
+ T.eq(P.picSpecies(413),413)
+ local count=0;for _ in pairs(data.pokemon)do count=count+1 end
+ for _=1,8 do P.picSpecies(4);P.picBaseSpecies(413)end
+ local after=0;for _ in pairs(data.pokemon)do after=after+1 end;T.eq(after,count,'picture queries never create logical species')
+ P.invalidate();f.close()
+end
+package.loaded['src.core.Game']=original
+T.finish('native picture-slot identity, registered species, Unown bit selection and explicit missing-art boundaries')
diff --git a/tests/engine/native_player_boot.lua b/tests/engine/native_player_boot.lua
new file mode 100644
index 000000000..fe1a9136d
--- /dev/null
+++ b/tests/engine/native_player_boot.lua
@@ -0,0 +1,21 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Player=require('src.core.game3.player')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ require('src.core.Game3').release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g=f.game
+ f.map.def.width,f.map.def.height=20,20
+ g.stack.states={{isIntro=true}};g.save.player.x,g.save.player.y=7,9
+ T.eq(Player.px,112);T.eq(Player.py,144);T.eq(Player.cellX,7);T.eq(Player.cellY,9)
+ T.eq(Player.facing,g.save.player.facing);T.eq(Player.running,false)
+ T.raises(function()Player.px=0 end,'no active native player')
+ T.eq(g.save.player.x,7,'boot reads cannot change the native spawn')
+ g.stack.states={f.world};T.eq(Player.px,f.player.px);T.eq(Player.py,f.player.py)
+ T.neq(Player.px,112,'live actor takes precedence over saved spawn cells')
+ g.stack.states={{isIntro=true}};g.save.player.map='UNIMPORTED';T.eq(Player.px,nil)
+ g.save.player.map='TEST'
+ for _,bad in ipairs{-1,20,math.huge,0/0,.5,'7'}do g.save.player.x=bad;T.eq(Player.px,nil)end
+ Player.release();require('src.core.Game3').release()
+end
+T.finish('native pending spawn observation before actor admission')
diff --git a/tests/engine/native_playfield_query.lua b/tests/engine/native_playfield_query.lua
new file mode 100644
index 000000000..969872fbe
--- /dev/null
+++ b/tests/engine/native_playfield_query.lua
@@ -0,0 +1,50 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Playfield=require('src.render.Playfield')
+local V=require('src.render.GameViewport')
+local R=require('src.mods.Runtime')
+local G=love.graphics
+local old={G.getDimensions,G.getPixelDimensions,R.wantsHook,R.call}
+local windowW,windowH,dpi=1280,720,1
+G.getDimensions=function()return windowW,windowH end
+G.getPixelDimensions=function()return windowW*dpi,windowH*dpi end
+local requested
+R.wantsHook=function(name)return name=='render.viewport'and requested~=nil end
+R.call=function(name,next,...)
+ if name=='render.viewport'then return requested end
+ return next(...)
+end
+local function check(w,h,x,y,rw,rh)
+ local a,b,c,d=Playfield.cutout(w,h)
+ T.eq(a,x);T.eq(b,y);T.eq(c,rw);T.eq(d,rh)
+end
+local originalTarget=G.getCanvas()
+for _,size in ipairs{{1280,720},{600,900},{1016,708},{1400,600}}do
+ windowW,windowH=size[1],size[2]
+ for _,scale in ipairs{1,2,3}do
+  dpi=scale;requested=nil;V.reset()
+  check(windowW,windowH,nil,nil,nil,nil)
+  V.begin(3);check(windowW,windowH,nil,nil,nil,nil);V.finish({})
+  requested={x=24,y=32,width=windowW-76,height=windowH-120,capture=true}
+  local r=V.begin(3)
+  check(windowW,windowH,24,32,r.width,r.height)
+  check(r.width,r.height,0,0,r.width,r.height)
+  check(240,160,nil,nil,nil,nil)
+  check(windowW*dpi+1,windowH*dpi+1,nil,nil,nil,nil)
+  T.eq(G.getCanvas(),originalTarget,'query cannot change the native render target')
+  local canvas=V.target();local inFrame=V.inFrame
+  for i=1,3 do check(r.width,r.height,0,0,r.width,r.height)end
+  T.eq(V.target(),canvas);T.eq(V.inFrame,inFrame,'repeated queries do not consume a frame')
+  V.finish({});check(windowW,windowH,nil,nil,nil,nil)
+  requested={capture=true};V.begin(3)
+  check(windowW,windowH,nil,nil,nil,nil,'full-size captures reserve no cutout')
+  V.finish({})
+ end
+end
+for _,size in ipairs{{0,720},{1280,0},{0/0,720},{1280,math.huge},{'1280',720}}do
+ check(size[1],size[2],nil,nil,nil,nil)
+end
+V.reset();G.getDimensions,G.getPixelDimensions,R.wantsHook,R.call=unpack(old)
+T.eq(Playfield.push,nil,'a query does not invent a second rendering owner')
+T.finish('native frame cutout coordinates, local/window spaces, DPI, previews and retirement')
diff --git a/tests/engine/native_pokemon_source.lua b/tests/engine/native_pokemon_source.lua
new file mode 100644
index 000000000..f3c767ce5
--- /dev/null
+++ b/tests/engine/native_pokemon_source.lua
@@ -0,0 +1,65 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local P=require('src.core.game3.pokemon')
+local Moves=require('src.core.game3.battle.moves')
+local original=package.loaded['src.core.Game']
+local Host=require('src.mods.Runtime')
+T.eq(P.ready(),false)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ local game=f.game;package.loaded['src.core.Game']=game
+ local data=game.data
+ data.constants=data.constants or{}
+ data.constants.speciesOrder={[4]='CHARMANDER',[277]='SPARSE_SPECIES'}
+ data.pokemon.SPARSE_SPECIES={index=277,dex=252,name='SPARSE',id='SPARSE_SPECIES'}
+ data.constants.typeOrder={'NORMAL'};data.constants.types={NORMAL={index=0}}
+ data.constants.abilityOrder={'NONE','PROBE'};data.constants.abilities={NONE={index=0},PROBE={index=1}}
+ data.constants.moveOrder={[33]=f.ids.TACKLE}
+ local row=data.pokemon.CHARMANDER
+ row.height,row.weight,row.genderRatio,row.abilities=.7,6.9,127,{'PROBE','PROBE'}
+ row.level1Moves={f.ids.TACKLE};row.learnset={{level=7,move=f.ids.TACKLE}}
+ T.eq(P.ready(),true);T.eq(P.speciesOf{species='CHARMANDER'},4)
+ T.eq(P.speciesOf{species=277},277);T.eq(P.national(277),252)
+ T.eq(P.speciesFromNational(252),277,'cartridge slots and National Dex are distinct')
+ T.eq(P.speciesFromName('CHARMANDER'),4);T.eq(P.keyName(4),'CHARMANDER')
+ T.eq(P.name(4),'CHARMANDER');T.eq(P.name(8888),nil)
+ T.eq(P.types(4)[1],0);T.eq(P.types(4)[2],0)
+ T.eq(P.stats(4).atk,row.baseStats.attack)
+ local dex=P.dexEntry(4);T.eq(dex.height,7,'metres become source decimetres');T.eq(dex.weight,69)
+ local meta=P.speciesMeta(4);meta.genderRatio=0;T.eq(row.genderRatio,127,'observations do not lend native records')
+ T.eq(P.gender(4,0),'F');T.eq(P.gender(4,255),'M')
+ T.eq(P.abilities(4)[1],1);T.eq(P.abilityId(4,2),1)
+ T.eq(P.isShiny{species=4,personality=0,otId=0,otSecretId=0},true)
+ T.eq(P.isShiny(setmetatable({},{__index={species=4,personality=0,otId=0,otSecretId=0}})),true,'typed mon views use their declared identity fields')
+ T.eq(P.isShiny{species=4,personality=12,otId=0,otSecretId=0},false)
+ T.eq(P.isEgg{isEgg=true},true);T.eq(P.isEgg{species=4},false)
+ T.eq(P.displayName{species=4,nickname='NAMED'},'NAMED')
+ T.eq(P.displayName{species=4},'CHARMANDER')
+ local moves,pp,max=P.movesAtLevel(4,10)
+ T.eq(moves[1],33);T.eq(pp[1],10);T.eq(max[1],10)
+ T.eq(P.moveName(33),'TACKLE');T.eq(P.movePp(33),10)
+ T.eq(Moves.displayName(33),'TACKLE');T.eq(Moves.displayName('33'),'TACKLE')
+ T.eq(Moves.displayName({id=f.ids.TACKLE}),'TACKLE')
+ T.eq(Moves.displayName({move=33}),'TACKLE')
+ for _,empty in ipairs{false,0,'','-------'}do T.eq(Moves.displayName(empty),'-------')end
+ T.eq(Moves.displayName(nil),'-------');T.eq(Moves.displayName(999999),nil)
+ data.moves[f.ids.TACKLE].name='CURRENT LABEL'
+ T.eq(Moves.displayName(33),'CURRENT LABEL','current native labels are never copied into a second registry')
+ data.moves[f.ids.TACKLE].name='TACKLE'
+
+ T.eq(P.movesLearnedAt(4,7)[1],33)
+ T.eq(P.moveIdAt({moves={33}},1),33);T.eq(P.moveIdAt({moves={{id=f.ids.TACKLE}}},1),33)
+ T.eq(P.knowsMove({moves={33}},33),true);T.eq(P.knowsMove({moves={33}},34),false)
+ Host.currentMod='sprite_owner'
+ local image=assert(P.frontPic(4))
+ T.eq(P.frontPic(4),image,'native source picture is cached within its dataset')
+ T.check(image.image~=nil and image.w>0 and image.h>0)
+ T.eq(P.frontPic(4,2),nil,'unsupported forms cannot silently show the base sprite')
+ require('src.core.game3.asset_stream').cancelOwner('other_owner')
+ T.eq(P.frontPic(4),image)
+ P.invalidate();T.neq(P.frontPic(4),image,'owned picture invalidation never reuses its released image')
+ Host.currentMod=nil;P.invalidate();f.close()
+end
+package.loaded['src.core.Game']=original
+T.finish('native source Pokemon identity, metadata units and picture ownership')
diff --git a/tests/engine/native_presentation_profiles.lua b/tests/engine/native_presentation_profiles.lua
new file mode 100644
index 000000000..cb2e5d176
--- /dev/null
+++ b/tests/engine/native_presentation_profiles.lua
@@ -0,0 +1,59 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local V=require('src.core.GameVersion')
+local P=require('src.core.game3.profile')
+local Font=require('src.render.Font')
+local Assets=require('src.render.Assets');local previousImage=Assets.image
+local previousGame=package.loaded['src.core.Game'];package.loaded['src.core.Game']=nil
+Assets.image=function()return{getDimensions=function()return 128,128 end}end
+local records={}
+for _,id in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ V.set(id)
+ local row=P.active();records[id]=row
+ T.eq(P.isGame3Version(id),true);T.eq(P.resolveId(),id)
+ T.eq(row.id,id);T.eq(row.label,V.info(id).label);T.eq(row.generation,3)
+ T.eq(P.family(),V.layout(id));T.eq(row.family,V.layout(id))
+ T.eq(P.forSession(),row);T.eq(P.forSession({}),row);T.eq(P.forSession({version=''}),row)
+ T.eq(P.forSession({version=id}),row);T.eq(P.sessionVersion({version=id}),id)
+ T.eq(row.font.module,'src.ui.game3.frlg_font')
+ T.eq(row.ui.battleSpriteLayout,(id=='ruby'or id=='sapphire')and'rs'or nil)
+ T.eq(row.capabilities,nil,'metadata does not invent a gameplay capability registry')
+ T.eq(row.save,nil);T.eq(row.extractors,nil)
+ for _,target in ipairs{row,row.ui,row.font}do
+  T.raises(function()target.changed=true end,'read-only')
+ end
+ T.eq(P.active(),row,'unchanged version facts reuse a stable immutable record')
+ T.eq(package.loaded['src.core.Game'],nil,'queries cannot bootstrap a game')
+ local session={version=id,party={hp=23},options={battleScene=0}}
+ for _=1,20 do T.eq(P.forSession(session),row)end
+ T.eq(session.party.hp,23);T.eq(session.options.battleScene,0)
+ -- The selected font really is the native proportional font, not merely a
+ -- module-name string that bypasses its glyph/face resources.
+ Font.load({font={pages={main={image='NATIVE',base=0,glyphWidth=8,glyphHeight=8,advance=7}},
+  faces={small={image='SMALL',base=0,glyphWidth=8,glyphHeight=8,advance=4}},
+  charmap={{seq='A',code=13},{seq=' ',code=0}}}})
+ local F=require(row.font.module)
+ T.eq(F.measure('AAA'),21);T.eq(F.measure('AAA',{small=true}),12)
+ T.eq(Font.advanceOf(13),7)
+end
+V.set('gold')
+for _,id in ipairs{'red','gold','crystal','missing'}do
+ T.eq(P.isGame3Version(id),false);T.eq(P.of(id),nil);T.eq(P.resolveId(id),nil)
+ T.eq(P.forSession({version=id}),nil)
+end
+T.eq(P.active(),nil);T.eq(P.family(),nil)
+T.eq(P.forSession(2),nil);T.eq(P.forSession({version=2}),nil)
+T.eq(P.isGame3Version(nil),false);T.eq(P.isGame3Version({}),false)
+T.eq(P.forSession({version='ruby'}).id,'ruby','an explicit metadata query does not switch the active native edition')
+T.eq(V.get(),'gold')
+local original=V.VERSIONS.ruby
+V.VERSIONS.ruby={id='ruby',generation=3,label='NATIVE RUBY',layout='rse'}
+local replacement=P.of('ruby');T.neq(replacement,records.ruby);T.eq(replacement.label,'NATIVE RUBY')
+V.VERSIONS.ruby.label='UPDATED';T.eq(P.of('ruby').label,'UPDATED')
+V.VERSIONS.ruby.layout='custom';T.eq(P.of('ruby').family,'custom')
+V.VERSIONS.ruby=original;T.eq(P.of('ruby').label,original.label)
+local before=P.of('ruby');P.reset();T.neq(P.of('ruby'),before)
+T.eq(before.id,'ruby','immutable metadata can be retained without a game/save owner')
+Assets.image=previousImage;package.loaded['src.core.Game']=previousGame
+T.finish('native edition/font/layout profiles, immutable cache and non-GBA isolation')
diff --git a/tests/engine/native_presentation_providers.lua b/tests/engine/native_presentation_providers.lua
new file mode 100644
index 000000000..5f3927972
--- /dev/null
+++ b/tests/engine/native_presentation_providers.lua
@@ -0,0 +1,148 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local original=package.loaded['src.core.Game']
+local P=require('src.ui.game3.presentation')
+T.eq(P,require('src.render.NativePresentation'))
+T.eq(package.loaded['src.core.Game'],original,'presentation import does not start Game')
+T.eq(P.apiVersion,1)
+for _,name in ipairs{'pcWorkflow','paperDevices','paperMotion','battlePaper','hoennPaper','bagPaperCases','actionPaper','recordsLearningPaper','smartPaperAtlas'}do
+ T.eq(P.features[name],nil,'unfinished family is not advertised: '..name)
+end
+local G=require('src.core.Game3')
+local R=require('src.render.Renderer');R:init()
+local NativeGame=require('src.core.Game')
+local g=love.graphics
+local function provider(extra)
+ local p={enabled=function()return true end,draw=function()return false end}
+ for k,v in pairs(extra or{})do p[k]=v end
+ return p
+end
+local function tuple(...)return{n=select('#',...),...}end
+T.raises(function()P.register('',provider())end,'owner')
+T.raises(function()P.register('bad',{})end,'enabled and draw')
+T.raises(function()P.register('bad',provider{present=true})end,'callback')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ local game=setmetatable(f.game,{__index=NativeGame});package.loaded['src.core.Game']=game
+ local marks={};local function mark(name)marks[#marks+1]={name=name,target=g.getCanvas(),owner=G._callbackOwner()}end
+ local world={isOverworld=true,isOpaque=true,uiSize=function()return 240,160 end,draw=function()mark('world')end}
+ game.overworld=world;game.stack:push(world)
+ local modal={isOpaque=false,uiSize=function()return 240,160 end,draw=function()mark('modal')end}
+ game.stack:push(modal)
+ local enabled,paints,notes,begins=0,0,0,0
+ G._withCallbackOwner('qa-mod',function()
+  P.register('qa-provider',provider{
+   enabled=function(view)enabled=enabled+1;T.eq(G.native(view),game);T.eq(G._callbackOwner(),'qa-mod');return true end,
+   begin=function(view)begins=begins+1;T.eq(G.native(view),game);T.eq(P.begin(view),false,'begin callback cannot restart the frame')end,
+   draw=function(kind,ctx)T.eq(kind,'frame');T.eq(ctx.x,4);g.setColor(.9,.8,.7,.6);g.push();return true end,
+   notify=function(kind)T.eq(kind,'launched');notes=notes+1 end,
+   widget=function(_,native)paints=paints+1;local v=tuple(native());T.same(v,{n=3,[2]=4});native();return false end})
+ end)
+ local start={g.getColor()};local depth=g.getStackDepth and g.getStackDepth()
+ T.eq(P.begin(G.forNative(game),240,160),true);T.eq(begins,1)
+ for i=1,5 do T.eq(P.draw('frame',{x=4}),true)end
+ T.same({g.getColor()},start);if depth then T.eq(g.getStackDepth(),depth)end
+ T.eq(enabled,1,'selection checks are cached within a native frame')
+ P.notify('launched');T.eq(notes,1)
+ local calls=0;local retained
+ local function native()calls=calls+1;T.eq(G._callbackOwner(),nil);return nil,4,nil end
+ T.eq(P.widget('card',native),false);T.eq(calls,1,'false after native paint cannot double paint')
+ P.register('qa-widget',provider{widget=function(_,paint)retained=paint;paint();return true end})
+ P.widget('card',native);T.eq(calls,2);T.eq(retained(),false,'retained immediate lease expires')
+ local stale=P.register('same',provider());local fresh=P.register('same',provider())
+ T.eq(stale(),false);T.eq(P.health('same').registered,true);T.eq(fresh(),true)
+ P.unregister('qa-widget');P.unregister('same')
+ P.flush(game,960,640);T.eq(P.health('qa-provider').queued,0)
+ T.eq(P.draw('frame',{x=4}),false,'no independent painting outside the native frame')
+ P._service.release()
+ -- Queued painting is FIFO and stays on the compositor's current target.
+ local target=g.newCanvas(960,640);local saved=g.getCanvas()
+ local on=true;local presented=0;local frames=game.frame
+ local p=provider{enabled=function()return on end,defer=function()return true end,
+  present=function(kind,paint,ctx)
+   presented=presented+1;T.eq(ctx.width,960);T.eq(ctx.height,640);T.eq(G.native(ctx.game),game)
+   T.eq(g.getCanvas(),target);paint();paint();return false
+  end}
+ P.register('queue',p);P.begin(game,320,160)
+ local seq={};local savedLease
+ P.layer('one',function()seq[#seq+1]='one';T.eq(g.getCanvas(),target)end)
+ P.layer('two',function()seq[#seq+1]='two' end)
+ g.setCanvas(target);P.flush(game,960,640)
+ T.same(seq,{'one','two'});T.eq(presented,2);T.eq(g.getCanvas(),target);T.eq(game.frame,frames)
+ for _,mode in ipairs{'disable','unregister','owner-release','replacement','error'}do
+  local draws=0
+  G._withCallbackOwner('queue-mod',function()P.register('queue',provider{
+   enabled=function()return on end,defer=function()return true end,
+   present=function(_,paint)if mode=='error'then g.push();error('provider paint failed')end;return true end})end)
+  on=true;P.begin(game,240,160);P.layer('recover',function()draws=draws+1;T.eq(g.getCanvas(),target)end)
+  if mode=='disable'then on=false
+  elseif mode=='unregister'then P.unregister('queue')
+  elseif mode=='owner-release'then P._service:releaseOwner('queue-mod')
+  elseif mode=='replacement'then P.register('queue',provider{defer=function()return true end,present=function()error('new provider must not receive old work')end})end
+  P.flush(game,960,640);T.eq(draws,1,mode..' preserves admitted native fallback')
+  if mode=='error'then T.eq(P.health('queue').error:find('provider paint failed',1,true)~=nil,true)end
+ end
+ -- Errors in native painters remain fatal even when provider catches them.
+ local attempts=0
+ P.register('queue',provider{defer=function()return true end,present=function(_,paint)
+  savedLease=paint;pcall(paint);pcall(paint);return true end})
+ P.begin(game,240,160);P.layer('bad',function()attempts=attempts+1;error('native painter failed')end)
+ T.raises(function()P.flush(game,960,640)end,'native painter failed');T.eq(attempts,1)
+ T.raises(savedLease,'native painter failed');T.eq(P.health('queue').queued,0)
+ if depth then T.eq(g.getStackDepth(),depth)end
+ P.register('widget-error',provider{widget=function(_,paint)pcall(paint);return true end})
+ P.begin(game,240,160);attempts=0
+ T.raises(function()P.widget('bad',function()attempts=attempts+1;error('native widget failed')end)end,'native widget failed')
+ T.eq(attempts,1);P._service.release()
+ -- Reentrant layers during a window callback paint inline; none are lost
+ -- into a second deferred queue or a second native frame.
+ local recursive=0
+ P.register('queue',provider{defer=function()return true end,present=function(_,paint)
+  T.eq(P.begin(game),false);P.layer('nested',function()recursive=recursive+1;paint()end);return true end})
+ P.begin(game,240,160);calls=0;P.layer('outer',function()calls=calls+1 end);P.flush(game,960,640)
+ T.eq(calls,1);T.eq(recursive,1);T.eq(P.health('queue').queued,0)
+ -- Do not call retained painters after any session/stack/edition retirement.
+ for _,mutation in ipairs{'data','save','mods','stack','middle','edition','view-retirement','release'}do
+  P.register('queue',provider{defer=function()return true end,present=function()return false end})
+  P.begin(game,240,160);calls=0;P.layer('retired',function()calls=calls+1 end)
+  local restore
+  if mutation=='middle'then local prior=game.stack.states[1];game.stack.states[1]={};restore=function()game.stack.states[1]=prior end
+  elseif mutation=='edition'then require('src.core.GameVersion').set('crystal');restore=function()require('src.core.GameVersion').set(edition)end
+  elseif mutation=='release'then P._service.release();restore=function()end
+  elseif mutation=='view-retirement'then G.release();restore=function()end
+  else local prior=game[mutation];game[mutation]={};restore=function()game[mutation]=prior end end
+  T.eq(P.flush(game,960,640),false);T.eq(calls,0,mutation..' retires queued work');restore()
+ end
+ P._service.release();g.setCanvas(saved);if target.release then target:release()end
+ -- Registry and per-frame queue growth are bounded without losing painters.
+ for i=1,64 do P.register('bounded-'..i,provider())end
+ T.raises(function()P.register('overflow',provider())end,'too many')
+ P._service.release()
+ P.register('bounded-queue',provider{defer=function()return true end,present=function()return false end})
+ P.begin(game,240,160);calls=0
+ for i=1,129 do P.layer('bounded',function()calls=calls+1 end)end
+ T.eq(P.health('bounded-queue').queued,128);T.eq(calls,1,'overflow paints inline')
+ P.flush(game,960,640);T.eq(calls,129);P._service.release()
+ -- Drive the actual Game -> modal seam -> Renderer path. The world remains
+ -- on its native surface; deferred UI reaches the current window composite.
+ local callbackTarget;local deferCount=0
+ P.register('integration',provider{defer=function(kind)T.eq(kind,'ui_stack');deferCount=deferCount+1;return true end,
+  present=function(kind,paint,ctx)callbackTarget=g.getCanvas();T.eq(ctx.ui.first,2);paint();paint();return true end})
+ marks={};NativeGame._draw(game)
+ T.eq(#marks,2);T.eq(marks[1].name,'world');T.eq(marks[1].target,R.canvas)
+ T.eq(marks[2].name,'modal');T.eq(marks[2].target,callbackTarget);T.eq(deferCount,1)
+ T.eq(P.health('integration').queued,0);T.eq(g.getCanvas(),nil)
+ P._service.release();game.stack:pop();game.stack:pop();f.close();G.release()
+end
+for _,edition in ipairs{'red','crystal','platinum','black'}do
+ local f=require('tools.battle-source-runtime.fixture').new('firered')
+ local game=setmetatable(f.game,{__index=NativeGame});package.loaded['src.core.Game']=game
+ require('src.core.GameVersion').set(edition)
+ P.register('gba-only',provider{enabled=function()error('GBA presentation reached another generation')end})
+ local paints=0;game.stack:push({isOpaque=true,draw=function()paints=paints+1 end})
+ NativeGame._draw(game);T.eq(paints,1);T.eq(P.health('gba-only').error,nil)
+ P._service.release();game.stack:pop();f.close();G.release()
+end
+package.loaded['src.core.Game']=original;require('src.core.GameVersion').set('firered')
+T.finish('native presentation providers, frame leases, window fallback and lifecycle routing')
diff --git a/tests/engine/native_preview_source.lua b/tests/engine/native_preview_source.lua
new file mode 100644
index 000000000..e042eb5f7
--- /dev/null
+++ b/tests/engine/native_preview_source.lua
@@ -0,0 +1,23 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local M=require('src.ui.game3.map_preview_screen')
+local Preview=require('src.world.Gen3MapPreviewFRLG')
+local G=require('src.core.Game3')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ G.release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g=f.game
+ g.data.constants.gen3FRLGMapPreviews={bySection={[8]={type='forest'},[9]={type='cave'}}}
+ T.eq(M.isActive(),false);T.eq(M.mapsec(),nil)
+ local state=setmetatable({game=g,section=8,t=15,phase='in',hold=40},Preview)
+ g.stack:push(state)
+ T.eq(M.isActive(),true);T.eq(M.isForestActive(),true);T.eq(M.mapsec(),8)
+ Preview.update(state);T.eq(state.phase,'hold');T.eq(state.t,0,'one native clock advances the preview')
+ state.section=9;T.eq(M.isForestActive(),false);T.eq(M.isActive(),true)
+ g.stack:push({});T.eq(M.isActive(),true,'overlay does not hide an admitted preview')
+ state.game={};T.eq(M.isActive(),false,'foreign preview is not admitted');state.game=g
+ g.stack.states={f.world};T.eq(M.isActive(),false);T.eq(M.mapsec(),nil)
+ g.stack.states={{game=g,section=8}};T.eq(M.isActive(),false,'lookalike states cannot claim a native preview')
+ G.release()
+end
+T.finish('native preview admission and source observations')
diff --git a/tests/engine/native_region_map_observations.lua b/tests/engine/native_region_map_observations.lua
new file mode 100644
index 000000000..0b0d13485
--- /dev/null
+++ b/tests/engine/native_region_map_observations.lua
@@ -0,0 +1,90 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local original=package.loaded['src.core.Game']
+local Q=require('src.compat.gen1.NativeRegionMap')
+local FR=require('src.ui.game3.region_map');local RS=require('src.ui.game3.rse.region_map')
+local Field=require('src.core.game3.field');local Map=require('src.ui.Gen3RegionMap')
+local G=require('src.core.Game3');local V=require('src.core.GameVersion')
+local Obs=require('src.compat.gen1.NativeModalObservation')
+T.eq(package.loaded['src.core.Game'],original,'queries cannot construct Game')
+T.eq(FR.isOpen(),false);T.eq(RS.active(),nil)
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+ local c=game.data.constants
+ c.gen3MapSectionRects={[7]={x=0,y=0,w=1,h=1},[8]={x=1,y=0,w=1,h=1}}
+ c.gen3MapSections={[7]='CURRENT',[8]='NEXT'};c.gen3RegionMapPlaces={[7]=true,[8]=true}
+ f.map.def.regionMapSection=7
+ game.data.maps.NEXT={regionMapSection=8};game.data.field={flyOrder={'TEST','NEXT'},flyWarps={TEST={x=4,y=5},NEXT={x=6,y=7}}}
+ game.save.visited={TEST=true}
+ local before=require('src.link.Json').encode(game.save)
+ local fake=setmetatable({game=game},Map);game.stack:push(fake)
+ T.eq(Q.active(),nil,'a class-shaped table has no constructor admission');game.stack:pop()
+ local s=Map.new(game,{fly=true});T.eq(Q.active(),nil,'constructor alone is not an open picker')
+ game.stack:push(s);local view=assert(Q.active())
+ T.eq(view.open,true);T.eq(view.mode,'fly');T.eq(view.mapSecId,7);T.eq(view.state,12)
+ T.eq(Q.ready(),true);T.eq(Q.active(),view);T.eq(Q.kind(view,7),2);T.eq(Q.kind(view,8),0)
+ local dest=assert(Field.flyDestination(7));T.eq(dest.x,4);T.eq(dest.y,5)
+ dest.x=999;T.eq(Field.flyDestination(7).x,4,'destination leaves native warp untouched')
+ T.eq(Field.flyDestination(8),nil,'another section is not the current cursor')
+ T.raises(function()view.mode='wall'end,'read-only')
+ local cursor=view.cursor;cursor.x=999;T.eq(view.cursor.x,s.cx)
+ local cover={};game.stack:push(cover);T.eq(Q.active(),view);T.eq(Q.ready(),false,'nested modal owns input');game.stack:pop()
+ s.zoomFrame=0;T.eq(Q.ready(),false);s.zoomFrame=Map.ZOOM_FRAMES
+ s.cx,s.cy=1,0;T.eq(view.mapSecId,8);T.eq(Q.kind(view,8),0);T.eq(Field.flyDestination(8),nil,'unvisited target is absent')
+ T.eq(require('src.link.Json').encode(game.save),before,'queries preserve visits, party and flags')
+ for _,key in ipairs{'data','save','mods','stack'}do
+  local old=game[key];game[key]={};T.eq(Q.active(),nil);T.eq(view.open,false,key..' replacement retires view');game[key]=old
+  local nextView=assert(Q.active());T.neq(view,nextView);view=nextView
+ end
+ G.release();T.eq(view.open,false);view=assert(Q.active())
+ local owned=G._withCallbackOwner('map-owner',Q.active)
+ Q._service:releaseOwner('unrelated');T.eq(owned.open,true)
+ Q._service:releaseOwner('map-owner');T.eq(owned.open,false);view=assert(Q.active())
+ s:close();T.eq(view.open,false);T.eq(Q.active(),nil)
+ -- A known off-screen native target is queryable without committing travel.
+ T.eq(Field.flyDestination(7).x,4);T.eq(Field.flyDestination(8),nil)
+ if V.isFRLG()then
+  -- Constructor locates the player's actual page before the FRLG early return.
+  c.gen3FRLGRegionMap={sections={kanto={{{7,8}}}},names={[7]='HERE',[8]='NEXT'},none=99}
+  local picked;local map=Map.new(game,{fly=true,onFly=function(id)picked=id end});game.stack:push(map)
+  T.eq(map.here,7);T.eq(map.playerPage,'kanto');T.eq(FR.isOpen(),true);T.eq(RS.active(),nil)
+  T.eq(FR.currentMapSec(),7);T.eq(FR.mode,'fly');T.eq(FR.canFlyToCursor(),true);T.eq(FR.inputReady(),true)
+  T.eq(FR.state().selectedRegion,FR.state().playersRegion)
+  map.page='sevii123';T.eq(FR.canFlyToCursor(),false);map.page='kanto'
+  map:pick();T.eq(picked,'TEST','actual native pick retains its own target identity');T.eq(FR.isOpen(),false)
+ else
+  local atlas=RS.manifest()
+  T.eq(atlas.layout[1][1],7);T.eq(atlas.layout[1][2],8);T.eq(atlas.layout[1][3],false)
+  atlas.layout[1][1]=999;T.eq(RS.manifest().layout[1][1],7,'atlas metadata is detached without opening a screen')
+  c.gen3RegionMapLayout={width=2,height=1,none=99,cells={8,7}}
+  atlas=RS.manifest();T.eq(atlas.layout[1][1],8);T.eq(atlas.layout[1][2],7,'real cell bank wins over rectangle approximations')
+  c.gen3RegionMapLayout=nil
+  local map=Map.new(game,{fly=true});game.stack:push(map);local live=assert(RS.active())
+  T.eq(RS.isOpen(),true)
+  T.eq(FR.isOpen(),false);T.eq(live.state,12);T.eq(RS.mapSecType(live,7),RS.TYPE.CITY_CANFLY)
+  T.eq(RS.flyWarpDestination(G.forNative(game).session,7).x,4)
+  T.eq(RS.flyWarpDestination({},7),nil,'foreign session cannot resolve native destination')
+  map:close();T.eq(live.open,false);T.eq(RS.isOpen(),false)
+ end
+ V.set('crystal');T.eq(Q.active(),nil);T.eq(Field._game,nil);V.set(edition)
+ Q._service.release();G.release()
+end
+-- The actual RS task's phase/cursor/classification is read without advancing it.
+local f=require('tools.session-runtime.fixture').new('ruby');local game=f.game
+game.data.field={};game.data.maps.TEST.regionMapSection=0
+local raw={state=12,mode='fly',inputFn='full',mapSecId=0,posWithinMapSec=1,moveCounter=0}
+local calls=0
+local rs={state=raw,native={TYPE={CITY_CANFLY=2,BATTLE_FRONTIER=4},mapSecType=function(s,id)
+ T.eq(s,raw);T.eq(id,0);return 4 end},destination=function(_,sec,pos)
+ calls=calls+1;T.eq(sec,0);T.eq(pos,1);return{map='TEST',x=5,y=6}end}
+local s=setmetatable({game=game,fly=true,rsNative=rs},Map);Obs.capture(s,game);game.stack:push(s)
+local view=assert(RS.active());T.eq(view.state,12);T.eq(RS.mapSecType(view,0),4)
+T.eq(RS.flyWarpDestination(G.forNative(game).session,0,1).y,6)
+T.eq(RS.flyWarpDestination(G.forNative(game).session,0,0),nil)
+raw.inputFn='move';raw.moveCounter=3;T.eq(Q.ready(),false);T.eq(view.cursor.moveCounter,3)
+raw.inputFn='full';raw.state=13;raw.chose=true;T.eq(view.state,13);T.eq(view.chose,true)
+T.eq(Q.ready(),false,'exit phase is observed, not advanced or relabelled')
+rs.state={};T.eq(view.open,false,'replaced inner native task retires view')
+Q._service.release();G.release();package.loaded['src.core.Game']=original;V.set('firered')
+T.finish('native region picker admission, cursor/target queries and cohort retirement')
diff --git a/tests/engine/native_rs_menu_cursor.lua b/tests/engine/native_rs_menu_cursor.lua
new file mode 100644
index 000000000..680c6ac63
--- /dev/null
+++ b/tests/engine/native_rs_menu_cursor.lua
@@ -0,0 +1,97 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Cursor=require('src.ui.Gen3RsMenuCursor')
+local Public=require('src.ui.game3.rs.menu_cursor')
+local Assets=require('src.render.Assets')
+local Writer=require('src.import.LuaWriter')
+local Version=require('src.core.GameVersion')
+local Fx=require('src.core.game3.gba_fx')
+local original,version=package.loaded['src.core.Game'],Version.get()
+local fs=love.filesystem;local load,exists,image,draw,fxdraw=fs.load,Assets.exists,Assets.image,love.graphics.draw,Fx.draw
+-- Compare the independent constant-time strip construction with the pinned
+-- public native reference, rather than maintaining a second expected formula.
+local golden={
+ [1]={{part='left',x=-1},{part='right',x=-6}},
+ [8]={{part='left',x=-1},{part='right',x=1}},
+ [9]={{part='left',x=-1},{part='middle',x=1},{part='right',x=2}},
+ [33]={{part='left',x=-1},{part='wide',x=1},{part='right',x=26}},
+ [40]={{part='left',x=-1},{part='wide',x=1},{part='right',x=33}},
+ [41]={{part='left',x=-1},{part='wide',x=1},{part='middle',x=33},{part='right',x=34}},
+ [42]={{part='left',x=-1},{part='wide',x=1},{part='wide',x=9},{part='right',x=35}},
+ [72]={{part='left',x=-1},{part='wide',x=1},{part='wide',x=33},{part='right',x=65}},
+}
+for width,rows in pairs(golden)do T.same(Cursor.segments(width),rows,'native strip boundary '..width)end
+local chunk=loadfile('compat/gen1-rs/reference/src/ui/game3/rs/menu_cursor.lua')
+if chunk then
+ local environment=setmetatable({require=function()return{}end},{__index=_G});setfenv(chunk,environment)
+ local Reference=chunk()
+ for width=1,512 do T.same(Cursor.segments(width),Reference.segments(width),'pinned native strip overlap width '..width)end
+ T.same(Cursor.segments(4096),Reference.segments(4096))
+end
+local edited=Cursor.segments(42);edited[1].x=1000;T.eq(Cursor.segments(42)[1].x,-1,'detached segment descriptions')
+for _,bad in ipairs{0,-1,4097,1.5,0/0,math.huge,'42',false}do
+ T.raises(function()Cursor.segments(bad)end,'invalid native RS cursor width')
+end
+local manifest,files,reads,paints
+fs.load=function(path)
+ T.eq(path,'data/generated/gba/rse/common_ui/manifest.lua');reads=reads+1
+ return assert(loadstring(Writer.encode(manifest)))
+end
+Assets.exists=function(path)return files[path]~=nil end
+Assets.image=function(path)return files[path]end
+for _,edition in ipairs{'ruby','sapphire'}do
+ Version.set(edition);Cursor._service.release();reads=0;paints={}
+ local game={data={constants={gen3RsBag={format=1,version=edition,common='data/generated/gba/rse/common_ui/manifest.lua'}}}}
+ package.loaded['src.core.Game']=game
+ manifest={layout='rs',game=edition,menuCursor={}};files={}
+ for _,part in ipairs{'left','middle','wide','right'}do
+  local width=part=='wide'and 32 or 8
+  manifest.menuCursor[part]={png=part,w=width,h=16}
+  files[part]={getDimensions=function()return width*2,32 end}
+ end
+ local calls=0
+ Fx.draw=function(fn,options)calls=calls+1;T.eq(options,'borrowed effects');return fn()end
+ love.graphics.draw=function(img,x,y,r,sx,sy)paints[#paints+1]={img,x,y,r,sx,sy}end
+ local before={love.graphics.getColor()};love.graphics.setColor(.2,.3,.4,.5)
+ local borrowed=Cursor.forGame(game)
+ T.eq(Public.draw(144,120,42,'borrowed effects'),true);T.eq(reads,1);T.eq(calls,4)
+ T.same({love.graphics.getColor()},{.2,.3,.4,.5},'white cursor colour is scoped')
+ local rows=golden[42]
+ for i,row in ipairs(paints)do
+  local ref=rows[#rows-i+1];T.eq(row[1],files[ref.part]);T.same({row[2],row[3],row[4],row[5],row[6]}, {144+ref.x,120,0,.5,.5})
+ end
+ paints={};T.eq(borrowed.draw(8,120,72,'borrowed effects'),true);T.eq(reads,1,'reuses the native manifest')
+ T.eq(#paints,#golden[72])
+ Cursor._service.releaseOwner('retired-mod');borrowed.draw(8,120,72,'borrowed effects');T.eq(reads,2)
+ Assets.invalidate();borrowed.draw(8,120,72,'borrowed effects');T.eq(reads,3,'asset changes retire manifest data')
+ local actualDraw=love.graphics.draw
+ love.graphics.draw=function()love.graphics.push();error('native cursor painter failed')end
+ T.raises(function()borrowed.draw(1,2,42,'borrowed effects')end,'native cursor painter failed')
+ T.same({love.graphics.getColor()},{.2,.3,.4,.5},'failing painter restores graphics state')
+ love.graphics.draw=actualDraw
+ for _,bad in ipairs{0/0,math.huge,'8',false}do
+  T.raises(function()borrowed.draw(bad,1,42,'borrowed effects')end,'invalid native RS cursor position')
+  T.raises(function()borrowed.draw(1,bad,42,'borrowed effects')end,'invalid native RS cursor position')
+ end
+ Cursor._service.release();manifest.game=edition=='ruby'and'sapphire'or'ruby'
+ T.raises(function()Public.draw(1,2,42)end,'mixed-edition native RS cursor manifest');manifest.game=edition
+ Cursor._service.release();manifest.menuCursor.left.h=15
+ T.raises(function()Public.draw(1,2,42)end,'invalid native RS cursor part');manifest.menuCursor.left.h=16
+ Cursor._service.release();local saved=files.right;files.right=nil
+ T.raises(function()Public.draw(1,2,42)end,'native RS cursor image missing');files.right=saved
+ Cursor._service.release();files.right={getDimensions=function()return 8,32 end}
+ T.raises(function()Public.draw(1,2,42)end,'invalid native RS cursor image density');files.right=saved
+ Cursor._service.release();fs.load=function()return assert(loadstring('return os.execute("invalid cache")'))end
+ T.raises(function()Public.draw(1,2,42)end,'os');fs.load=function()reads=reads+1;return assert(loadstring(Writer.encode(manifest)))end
+ package.loaded['src.core.Game']={data={constants={}}}
+ T.eq(borrowed.draw(1,2,42),false,'retired native game cannot paint')
+ T.raises(function()Public.draw(1,2,42)end,'native RS common UI unavailable')
+ love.graphics.setColor(unpack(before))
+end
+for _,edition in ipairs{'firered','leafgreen','emerald','red','crystal'}do
+ Version.set(edition);T.eq(Public.draw(1,2,42),false,'other editions retain their own cursor')
+end
+fs.load,Assets.exists,Assets.image,love.graphics.draw,Fx.draw=load,exists,image,draw,fxdraw
+Cursor._service.release();package.loaded['src.core.Game']=original;Version.set(version)
+T.finish('native RS cursor composition, high-density images, shared graphics state and owner retirement')
diff --git a/tests/engine/native_safari_text_views.lua b/tests/engine/native_safari_text_views.lua
new file mode 100644
index 000000000..c9a372563
--- /dev/null
+++ b/tests/engine/native_safari_text_views.lua
@@ -0,0 +1,87 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit');local V=require('src.core.GameVersion')
+local Native=require('src.battle.Gen3SafariText');local Profile=require('src.core.game3.battle.profile')
+local Text=require('src.core.game3.rom_text');local BattleText=require('src.core.game3.battle.battle_text')
+local Battle=require('src.core.game3.battle');local G=require('src.core.Game3')
+local oldGame,oldVersion=package.loaded['src.core.Game'],V.get()
+local oldLoad=love.filesystem.load;love.filesystem.load=loadfile
+T.eq(Profile.of({}),nil);T.eq(package.loaded['src.core.Game'],oldGame,'metadata import cannot bootstrap Game')
+local nativeFile=io.open('src/import/Gen3SafariAssets.lua','rb')
+if nativeFile then
+ nativeFile:close();local Assets=require('src.import.Gen3SafariAssets')
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+  package.loaded['src.core.Game']=game;local b=f.fresh('TACKLE').battle
+  local catalog={schema=1,edition=edition,romSha1=V.info().sha1,named={},records={}}
+  game.data.text_pointers={namedIR=catalog}
+  local hoenn=edition~='firered'and edition~='leafgreen'
+  local spec={format=1,version=edition,dialect=(edition=='ruby'or edition=='sapphire')and'rs'or hoenn and'rse'or'frlg',
+   labels={'QA BALL','QA SECOND','QA THIRD','QA RUN'},textIR={}}
+  for _,key in ipairs{'menu','prompt','balls','left','gotAway','wildFled','watching','used','outOfBalls','boxFull',
+   'goNear','tooNear','pokeblock','curious','enthralled','ignored','rock','bait','angry','eating'}do
+   spec.textIR[key]={{t='text',s='QA '..key},{t='eos'}}
+  end
+  if hoenn then
+   spec.escapeFactor=3;spec.tables={format=1,goNearCounterToCatchFactor={4,3,2,0},goNearCounterToEscapeFactor={4,3,2,0},pkblToEscapeFactor={},flavorCompatibility={}}
+   for n=0,4 do spec.tables.pkblToEscapeFactor[n]={0,1,0}end
+   for n=0,124 do spec.tables.flavorCompatibility[n]=0 end
+  end
+  game.data.constants.gen3SafariNative=spec;T.check(Assets.valid(spec,edition))
+  local profile=require('src.import.Gen3BattleTextCatalog').profile(edition)
+  local playerCode;for code,name in pairs(profile.placeholders)do if name=='B_PLAYER_NAME'then playerCode=code end end
+  spec.textIR.prompt={{t='ext',cmd=1,args={2}},{t='text',s='QA '},{t='bph',code=assert(playerCode)},{t='nl'},{t='text',s='prompt'},{t='eos'}}
+  local hp,pp=b.player.mon.hp,b.player.curMoves[1].pp
+  local count=0;b.rng=function()count=count+1;return 0 end
+  T.eq(Profile.of({}),nil);b:makeSafari({balls=30,steps=400})
+  game.stack:push(b);local state=assert(Battle.getState());local view=assert(Profile.of(state))
+  T.eq(view.id,edition);T.eq(view.open,true);T.eq(view.rules,nil,'query does not advertise action/rule capabilities')
+  local key=view.strings.safariPrompt;T.eq(Text.has(key),true)
+  T.eq(BattleText.get(key),'QA PROBE\nprompt','native player placeholder keeps the edition-specific battle namespace')
+  local ir=Text.ir(key);T.eq(ir[1].cmd,1);T.eq(ir[3].t,'ph');T.eq(ir[3].code,playerCode)
+  ir[1].args[1]=99;T.eq(spec.textIR.prompt[1].args[1],2,'native Safari IR stays private')
+  T.eq(spec.textIR.prompt[3].t,'bph','metadata cannot rewrite native interpreter operands')
+  spec.textIR.menu={{t='text',s='QA BALL'},{t='ext',cmd=19,args={46}},
+   {t='tag',tag='{POKEBLOCK}'},{t='nl'},{t='text',s='QA NEAR'},
+   {t='ext',cmd=19,args={46}},{t='text',s='QA RUN'},{t='eos'}}
+  catalog.named.gText_SafariZoneMenu='MENU';catalog.named.BattleText_MenuOptionsSafari='MENU'
+  catalog.records.MENU={plain='flattened old word',nativePlain='old menu',ir={{t='text',s='flattened old word'},{t='eos'}}}
+  game.data.text=game.data.text or{};game.data.text.MENU='old menu'
+  local menu=Text.ir('gText_SafariZoneMenu');T.eq(menu[3].tag,'{POKEBLOCK}','native menu keeps the original compound glyph identity')
+  menu[3].tag='edited';T.eq(spec.textIR.menu[3].tag,'{POKEBLOCK}')
+  game.data.text.MENU='Explicit menu edit';T.eq(Text.plain('gText_SafariZoneMenu'),'Explicit menu edit');game.data.text.MENU='old menu'
+  local Hud=require('src.core.game3.battle.healthbox');local Painter=require('src.battle.Gen3Battle')
+  local safariPaint,statusPaint=Painter.drawSafariPanel,Painter.drawStatusPanel
+  local safariCalls,statusCalls=0,0;local hx,hy=Painter.healthboxGeometry(b,0)
+  Painter.drawSafariPanel=function(screen,x,y)
+   T.eq(screen,b);T.eq(x,hx+3);T.eq(y,hy-2);safariCalls=safariCalls+1;return true
+  end
+  Painter.drawStatusPanel=function(screen,who,x,y,player)
+   T.eq(screen,b);T.eq(who,b.enemy);T.eq(player,false);statusCalls=statusCalls+1;return true
+  end
+  T.eq(Hud.draw(0,state.player,{st=state,ox=3,oy=-2}),true)
+  T.eq(safariCalls,1);T.eq(statusCalls,0,'Safari player uses the native ball counter, not a Pokemon HP panel')
+  T.eq(Hud.draw(1,state.enemy,{st=state}),true);T.eq(statusCalls,1,'native opponent panel remains visible')
+  Painter.drawSafariPanel,Painter.drawStatusPanel=safariPaint,statusPaint
+  T.raises(function()view.strings.safariPrompt='bad'end,'read-only')
+  game.data.text=game.data.text or{};game.data.text[key]='Explicit native label'
+  T.eq(BattleText.get(key),'Explicit native label');game.data.text[key]=nil
+  game.data._romTextGeneration=3;game.data.romText={};game.data._romTextTouched={[key]=true}
+  T.eq(Text.has(key),false,'explicit prose tombstone cannot be resurrected');game.data._romTextTouched={}
+  local source=Text.plain(key);game.data.strings={[source]='Translated {B_PLAYER_NAME}'}
+  T.eq(BattleText.get(key),'Translated PROBE');game.data.strings=nil
+  local strings=view.strings;local old=game.data;game.data={}
+  T.eq(view.open,false);T.eq(strings.safariPrompt,nil);game.data=old
+  catalog.romSha1='wrong';T.eq(Text.has(key),false);T.eq(view.open,false);catalog.romSha1=V.info().sha1
+  T.eq(count,0);T.eq(b.player.mon.hp,hp);T.eq(b.player.curMoves[1].pp,pp)
+  T.eq(b.safari.balls,30,'metadata cannot spend Safari resources')
+  game.stack:pop();T.eq(view.open,false);T.eq(strings.safariPrompt,nil);T.eq(Profile.of(state),nil)
+  f.close();G.release()
+ end
+else
+ V.set('firered');package.loaded['src.core.Game']={data={constants={}}}
+ T.eq(Profile.of({}),nil);T.eq(Text.has('native.safari.prompt'),false,'older native owners do not fabricate Safari metadata')
+end
+for _,edition in ipairs{'red','crystal','platinum','black'}do V.set(edition);T.eq(Text.has('native.safari.prompt'),false)end
+package.loaded['src.core.Game']=oldGame;V.set(oldVersion);love.filesystem.load=oldLoad
+T.finish('native Safari text namespace, current admission, readonly profile and resource neutrality')
diff --git a/tests/engine/native_source_follower_default.lua b/tests/engine/native_source_follower_default.lua
new file mode 100644
index 000000000..d5c3cd58d
--- /dev/null
+++ b/tests/engine/native_source_follower_default.lua
@@ -0,0 +1,49 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Objects=require('src.core.game3.objects')
+local Actors=require('src.compat.gen1.SourceActors')
+local Follower=require('src.compat.game3.Follower')
+local Optional=require('src.world.OptionalFollower')
+local Host=require('src.mods.Runtime')
+local Stream=require('src.core.game3.asset_stream')
+local G=require('src.core.Game3')
+local base,previousHooks=Follower.update,Host.hooks
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Objects.release();G.release();Actors.release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g,w,p=f.game,f.world,f.player
+ w.npcs={};w.entities={p};g.mods.mods={source_owner={enabled=true},peer={enabled=true}}
+ Host.hooks=require('src.mods.Hooks').new();Host.hooks:wrap('world.follower.spawn',function()return true end)
+ Optional.onMapEntered(g,w,nil,true);local npc=assert(Optional.current(w))
+ local nativeDraws,customDraws,calls=0,0,0
+ npc.sprite={draw=function()nativeDraws=nativeDraws+1 end}
+ Follower.current();local _,assigned=Actors.renderer(npc)
+ T.eq(assigned,false,'mere source observation preserves native follower art')
+ npc:draw(0,0);T.eq(nativeDraws,1)
+ Host.currentMod='source_owner'
+ local expectedRenderer
+ Follower.update=function(game)
+  local a,b,c=base(game);base(game) -- native phase remains single-use
+  -- Consumers compare against a cached nil renderer and may make no write.
+  T.eq(Follower.current().sprite,expectedRenderer)
+  return a,b,c
+ end
+ local a,b,c=Follower._dispatch(g,w,function()calls=calls+1;return 'native',nil,37 end)
+ T.eq(a,'native');T.eq(b,nil);T.eq(c,37);T.eq(calls,1)
+ local sprite,overridden=Actors.renderer(npc)
+ T.eq(sprite,nil);T.eq(overridden,true,'wrapped source follower starts without fallback artwork')
+ collectgarbage('collect');collectgarbage('collect');npc:draw(0,0);T.eq(nativeDraws,1)
+ T.eq(w.follower,npc);T.eq(w.entities[2],npc,'native simulation membership is preserved')
+ Host.currentMod='peer';local view=Objects.find(250)
+ local custom={draw=function()customDraws=customDraws+1 end};expectedRenderer=custom;view.sprite=custom
+ Host.currentMod='source_owner';Follower._dispatch(g,w,function()calls=calls+1 end)
+ T.eq(select(1,Actors.renderer(npc)),custom,'default admission preserves an existing owned renderer')
+ Stream.cancelOwner('source_owner');npc:draw(0,0);T.eq(customDraws,1)
+ Stream.cancelOwner('peer');T.eq(select(2,Actors.renderer(npc)),false)
+ Follower.update=base
+ Follower._dispatch(g,w,function()calls=calls+1 end)
+ T.eq(select(2,Actors.renderer(npc)),false,'ordinary native update retains native artwork')
+ Host.currentMod=nil;Objects.release();Actors.release();G.release()
+end
+Follower.update=base;Host.hooks=previousHooks
+T.finish('source follower default artwork admission preserves native actors and owners')
diff --git a/tests/engine/native_source_glyphs.lua b/tests/engine/native_source_glyphs.lua
new file mode 100644
index 000000000..ad51bab34
--- /dev/null
+++ b/tests/engine/native_source_glyphs.lua
@@ -0,0 +1,44 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Font=require('src.render.Font')
+local Source=require('src.ui.game3.frlg_font')
+local V=require('src.core.GameVersion')
+local Window=require('src.ui.game3.window')
+local Theme=require('src.ui.Theme');local originalCursor=Theme.cursor
+local Assets=require('src.render.Assets');local savedImage=Assets.image
+local image={getDimensions=function()return 128,128 end}
+Assets.image=function()return image end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ V.set(edition)
+ local data={font={pages={main={image='OWNED_FONT',base=0,glyphWidth=8,glyphHeight=8,advance=9}},
+  faces={small={image='OWNED_SMALL',base=0,glyphWidth=8,glyphHeight=8,advance=5}},
+  charmap={{seq='A',code=13},{seq='é',code=42},{seq=' ',code=0},{seq='<PK>',code=57}}}}
+ Font.load(data)
+ T.eq(Source.glyphId('A'),13);T.eq(Source.glyphId('é'),42);T.eq(Source.glyphId('<PK>'),57)
+ T.eq(Source.glyphId(''),0);T.eq(Source.glyphId(nil),0)
+ T.eq(Source.advance(13),9);T.eq(Source.advance(13,{small=true}),5)
+ T.eq(Font.advanceOf(13),9,'source measurement restores the current native face')
+ local painted;local draw=Font.drawCode
+ Font.drawCode=function(code,x,y)painted={code,x,y,Font.advanceOf(code)}end
+ local shader={name='native previous'};love.graphics.setShader(shader);love.graphics.setColor(.2,.3,.4,.5)
+ T.eq(Source.drawGlyph(42,17,23,{small=true}),5)
+ T.eq(painted[1],42);T.eq(painted[2],17);T.eq(painted[3],23);T.eq(painted[4],5)
+ T.eq(Font.advanceOf(42),9);T.eq(love.graphics.getShader(),shader)
+ Theme.cursor=173
+ T.eq(Window.cursorPx(128,122,{small=true,colors=Source.COLOR.WHITE}),5)
+ T.same(painted,{173,128,122,5},'pixel cursor borrows the current native symbol and selected face')
+ Theme.cursor=174;Window.cursorPx(184,138)
+ T.same(painted,{174,184,138,9},'no cached arrow survives a native theme change')
+ T.eq(Font.advanceOf(42),9);T.eq(love.graphics.getShader(),shader)
+
+ local r,g,b,a=love.graphics.getColor();T.eq(r,.2);T.eq(g,.3);T.eq(b,.4);T.eq(a,.5)
+ Font.drawCode=function()error('glyph painter failure')end
+ T.raises(function()Source.drawGlyph(13,0,0,{small=true})end,'glyph painter failure')
+ T.raises(function()Window.cursorPx(0,0,{small=true})end,'glyph painter failure')
+ T.eq(Font.advanceOf(13),9);T.eq(love.graphics.getShader(),shader,'errors restore native shader')
+ Font.drawCode=draw
+ data.font.charmap[1].code=71;Font.load(data);T.eq(Source.glyphId('A'),71,'no stale glyph cache after native reload')
+end
+Assets.image=savedImage;Theme.cursor=originalCursor
+T.finish('native source glyph IDs, proportional faces and draw ownership')
diff --git a/tests/engine/native_start_layout.lua b/tests/engine/native_start_layout.lua
new file mode 100644
index 000000000..eb6ed3b1a
--- /dev/null
+++ b/tests/engine/native_start_layout.lua
@@ -0,0 +1,57 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Menu=require('src.ui.game3.start_menu')
+local Window=require('src.ui.game3.window')
+local Native=require('src.ui.Gen3StartMenu')
+local Host=require('src.mods.Runtime')
+local Font=require('src.render.Font')
+local G=require('src.core.Game3')
+local Stream=require('src.core.game3.asset_stream')
+local template=Menu.contentTemplate
+T.eq(Menu._game,nil);T.eq(#Menu.ENTRIES,0);T.eq(Menu.contentTemplate(),nil)
+T.eq(Window.CURSOR_WIDTH,Native.CURSOR_WIDTH)
+local rect=Window.template(3,2,8,5);T.eq(rect.tilemapLeft,3);T.eq(rect.w,8)
+local box,labels,cursor
+local saved={Font.drawBox,Font.draw,Font.drawCode}
+Font.drawBox=function(...)box={...}end
+Font.draw=function(text,x,y)labels[#labels+1]={text,x,y}end
+Font.drawCode=function(code,x,y)cursor={x,y}end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();G.release();Host.currentMod='menu_owner'
+ local f=require('tools.session-runtime.fixture').new(edition);local g,w=f.game,f.world
+ g.mods.mods={menu_owner={enabled=true}}
+ local frlg=edition=='firered'or edition=='leafgreen'
+ g.data.constants=g.data.constants or{};g.data.constants.gen3StartMenu={layout=frlg and'frlg'or'rs'}
+ local menu=assert(Menu.show());labels={}
+ local base=menu:nativeContentTemplate()
+ T.eq(G.native(Menu._game),g);T.eq(#Menu.ENTRIES,#menu.rows)
+ for i,row in ipairs(menu.rows)do T.eq(Menu.ENTRIES[i].id,row.id or row.key);T.eq(row.id,row.key)end
+ local detached=Menu.ENTRIES;detached[1].label='CHANGED';T.eq(menu.rows[1].label~='CHANGED',true)
+ local layout=Menu.contentTemplate();layout.width=100;T.eq(Menu.contentTemplate().width,base.width)
+ menu:draw()
+ T.eq(box[1],base.left-1);T.eq(box[2],base.top-1);T.eq(box[3],base.width+2);T.eq(box[4],base.height+2)
+ T.eq(labels[1][2],frlg and base.left*8+Window.CURSOR_WIDTH or base.left*8)
+ T.eq(cursor[1],frlg and base.left*8 or(base.left-1)*8+2)
+ -- An installed source wrapper changes the rectangle the native painter uses.
+ Menu.contentTemplate=function()
+  local t=template();T.eq(G.native(Menu._game),g);T.eq(t.left,base.left)
+  return Window.template(2,2,12,base.height)
+ end
+ labels={};menu:draw();T.eq(box[1],1);T.eq(box[2],1);T.eq(box[3],14)
+ T.eq(labels[1][2],frlg and 24 or 16);T.eq(labels[1][3]>=16,true)
+ -- Invalid returns and wrapper errors preserve the real native geometry.
+ for _,value in ipairs{{left=-1,top=1,width=12,height=3},{left=0,top=1,width=0/0,height=3},{left=1,top=1,width=31,height=3},false}do
+  Menu.contentTemplate=function()return value end
+  local t=menu:contentTemplate();T.eq(t.left,base.left);T.eq(t.width,base.width)
+ end
+ Menu.contentTemplate=function()error('layout failure')end
+ T.eq(menu:contentTemplate().width,base.width)
+ local chosen=0;local key=menu.rows[1].key
+ menu.rows[#menu.rows+1]={id='source_action',label='ACTION',onSelect=function(game,row)T.eq(game,g);T.eq(row.id,'source_action');chosen=chosen+1 end}
+ menu:choose(menu.rows[#menu.rows]);T.eq(chosen,1);T.eq(menu.rows[1].key,key,'source IDs preserve native action keys')
+ Menu.contentTemplate=template;Menu.close();T.eq(Menu._game,nil);T.eq(#Menu.ENTRIES,0)
+ Stream.shutdown();G.release();Host.currentMod=nil
+end
+Font.drawBox,Font.draw,Font.drawCode=unpack(saved)
+T.finish('native START content geometry and source observations')
diff --git a/tests/engine/native_start_menu_source.lua b/tests/engine/native_start_menu_source.lua
new file mode 100644
index 000000000..f4c87df6a
--- /dev/null
+++ b/tests/engine/native_start_menu_source.lua
@@ -0,0 +1,34 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Menu=require('src.ui.game3.start_menu')
+local Host=require('src.mods.Runtime')
+local Stream=require('src.core.game3.asset_stream')
+local G=require('src.core.Game3')
+local nativeUpdate,nativeDraw=Menu.update,Menu.draw
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();G.release()
+ local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+ game.mods.mods={menu_owner={enabled=true},peer={enabled=true}}
+ Host.currentMod='menu_owner'
+ T.eq(Menu.isOpen(),false);T.eq(Menu.show({index=-1}),false)
+ local menu=assert(Menu.show());T.eq(getmetatable(menu),require('src.ui.Gen3StartMenu'))
+ T.eq(Menu.isOpen(),true);T.eq(Menu.open,true);T.eq(Menu.cursor,menu.index)
+ T.eq(Menu.show(),false,'duplicate native menu refused')
+ local before=menu.index;f.input.edges.down=true
+ Menu.update=function()nativeUpdate();nativeUpdate()end
+ game.stack:update(1/60)
+ T.eq(menu.index,before%#menu.rows+1,'wrapped update consumes native input once')
+ f.input.edges={};local draws=0
+ Menu.draw=function()nativeDraw();nativeDraw()end
+ Menu._draw(menu,function()draws=draws+1 end);T.eq(draws,1)
+ nativeDraw();nativeUpdate();T.eq(draws,1,'out-of-phase calls cannot rerun a menu')
+ Host.currentMod='peer';T.eq(Menu.close(),false);T.eq(game.stack:top(),menu)
+ Stream.cancelOwner('peer');T.eq(game.stack:top(),menu,'foreign cleanup preserves the admitted menu')
+ Host.currentMod='menu_owner';T.eq(Menu.close(),true);T.eq(Menu.isOpen(),false);T.eq(game.stack:top(),f.world)
+ local second=assert(Menu.show());local flow=second.nativeUiFlow
+ game.stack:pop();Stream.poll();T.eq(flow.retired,true,'native close releases an exhausted menu flow')
+ T.eq(Menu.close(),false,'closing an absent menu cannot pop the world')
+ Menu.update,Menu.draw=nativeUpdate,nativeDraw;Stream.shutdown();G.release();Host.currentMod=nil
+end
+T.finish('native START menu ownership, input/draw phases and exact close')
diff --git a/tests/engine/native_state_selection.lua b/tests/engine/native_state_selection.lua
new file mode 100644
index 000000000..f9b1d8639
--- /dev/null
+++ b/tests/engine/native_state_selection.lua
@@ -0,0 +1,16 @@
+-- Removing exact owners under a screen must preserve screens opened on exit.
+package.path='./?.lua;./?/init.lua;'..package.path
+love=require('tests.love_stub')
+local T=require('tests.harness');local Stack=require('src.core.StateStack')
+local world,cover,replacement={name='world'},{name='cover'},{name='replacement'}
+local stack=setmetatable({states={}},{__index=Stack});local exits={}
+local a={name='a',exit=function()exits[#exits+1]='a'end}
+local b={name='b',exit=function()exits[#exits+1]='b';stack:push(replacement)end}
+stack.states={world,a,cover,b}
+T.eq(stack:removeAll({a,b,a}),2);T.eq(#stack.states,3);T.eq(stack.states[1],world);T.eq(stack.states[2],cover);T.eq(stack:top(),replacement)
+T.eq(table.concat(exits,','),'b,a');T.eq(stack:removeAll({a,b}),0);T.eq(#exits,2)
+-- A failing exit cannot leave the remaining selected states installed.
+local bad={name='bad',exit=function()error('selected exit failure')end};local good={name='good',exit=function()exits[#exits+1]='good'end}
+stack.states={world,good,cover,bad};T.raises(function()stack:removeAll({good,bad})end,'selected exit failure','propagate failure after retiring all selected owners')
+T.eq(#stack.states,2);T.eq(stack:top(),cover);T.eq(exits[#exits],'good')
+T.finish('native exact-state retirement preserves covering and replacement screens')
diff --git a/tests/engine/native_step_event_observation.lua b/tests/engine/native_step_event_observation.lua
new file mode 100644
index 000000000..3e46e4a7f
--- /dev/null
+++ b/tests/engine/native_step_event_observation.lua
@@ -0,0 +1,45 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+love=require('tests.love_stub')
+local T=require('tests.harness')
+local V=require('src.core.GameVersion')
+local loaded=package.loaded['src.core.Game']
+local E=require('src.core.game3.step_events')
+T.eq(package.loaded['src.core.Game'],loaded,'observation does not bootstrap a game')
+T.eq(E.busy(),false)
+local F=require('tools.player-runtime.fixture')
+local P=require('src.core.game3.player');local original=P.update
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=F.new(edition);local g,w,p=f.game,f.world,f.player
+ T.eq(E.busy(),false)
+ p.moving=true;T.eq(E.busy(),false,'ordinary native movement is not a queued step event');p.moving=false
+ w.transitioning=true;T.eq(E.busy(),true);w.transitioning=nil
+ w.battleActive=true;T.eq(E.busy(),true);w.battleActive=nil
+ w.scriptMoves={{}};T.eq(E.busy(),true);w.scriptMoves={}
+ w.pendingScripts={{}};T.eq(E.busy(),true);w.pendingScripts=nil
+ w.runner.isRunning=function()return true end;T.eq(E.busy(),true)
+ w.runner.isRunning=function()return false end
+ -- The actual native arrival phase acquires the screen before tick returns.
+ local overlay={isMenu=true};local arrivals=w.arrivals
+ w.onArrival=function()g.stack.states[2]=overlay end
+ P.update=function(game,input)
+  T.eq(E.busy(),false)
+  original(game,{isDown=function()return false end,wasPressed=function()return false end})
+  T.eq(P.forcedStep('right',1),true);T.eq(P.tick(game),true)
+  T.eq(E.busy(),true,'same-tick native overlay stops free movement')
+  T.eq(P.forcedStep('right',1),false,'overlay cannot be bypassed by another arrival')
+ end
+ w:stepBody(false);P.update=original
+ T.eq(w.arrivals,arrivals+1);T.eq(p.cellX,5)
+ local clock=p.animClock;local x=p.px;g.save.repelSteps=17;g.save.poisonSteps=3
+ for i=1,100 do T.eq(E.busy(),true)end
+ T.eq(w.arrivals,arrivals+1);T.eq(p.animClock,clock);T.eq(p.px,x)
+ T.eq(g.save.repelSteps,17);T.eq(g.save.poisonSteps,3,'queries never consume step counters')
+ g.stack.states[2]=nil;T.eq(E.busy(),false,'native screen retirement releases ownership')
+ local def=g.data.maps.TEST;g.data.maps.TEST={}
+ T.eq(E.busy(),false,'retired dataset has no live step owner');g.data.maps.TEST=def
+ V.set('gold');T.eq(E.busy(),false,'query cannot acquire another generation');V.set(edition)
+ g.stack.states={};g.overworld=nil;T.eq(E.busy(),false,'no retained step state after world retirement')
+end
+P.update=original
+T.finish('native step ownership observation')
diff --git a/tests/engine/native_summary_palette.lua b/tests/engine/native_summary_palette.lua
new file mode 100644
index 000000000..eea02a54f
--- /dev/null
+++ b/tests/engine/native_summary_palette.lua
@@ -0,0 +1,31 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Version=require('src.core.GameVersion')
+local Colors=require('src.ui.game3.summary_chrome')
+local Ui=require('src.core.game3.battle.ui')
+local previous,edition=package.loaded['src.core.Game'],Version.get()
+for _,version in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Version.set(version)
+ local data={constants={}};package.loaded['src.core.Game']={data=data}
+ T.eq(Colors.manifest(),nil,'missing imported resources stay absent')
+ local parts={palette={},textColors={}}
+ for index=9,12 do
+  parts.textColors[index*3+2]=index;parts.textColors[index*3+3]=index+4
+  parts.palette[128+index]={index/31,.25,.75,1}
+  parts.palette[132+index]={.125,index/31,.5,1}
+ end
+ data.constants.gen3Summary={parts=parts}
+ for _,row in ipairs{{0,30,11},{1,30,10},{7,30,10},{8,30,9},{15,30,9},{16,30,12},{30,30,12},{1,5,10},{2,5,9},{3,5,12}}do
+  local index=Ui.ppColorIndex(row[1],row[2]);T.eq(index,row[3])
+  local color=Colors.manifest().moveTextColors[index]
+  T.check(math.abs(color.fg[1]/255-parts.palette[128+index][1])<1e-12);T.check(math.abs(color.shadow[2]/255-parts.palette[132+index][2])<1e-12)
+ end
+ local colors=Colors.manifest();colors.moveTextColors[9].fg[1]=0
+ T.eq(Colors.manifest().moveTextColors[9].fg[1],9/31*255,'a consumer cannot mutate the native palette')
+ parts.palette[137][1]=.5;T.eq(Colors.manifest().moveTextColors[9].fg[1],127.5,'live native palette edits are observable')
+ data.constants.gen3Summary=nil;T.eq(Colors.manifest(),nil,'retired resource tables are not cached')
+ Version.set('gold');T.eq(Colors.manifest(),nil,'Gen2 retains its native summary owner')
+end
+package.loaded['src.core.Game']=previous;Version.set(edition)
+T.finish('native PP thresholds and detached current summary palette')
diff --git a/tests/engine/native_text_pen.lua b/tests/engine/native_text_pen.lua
new file mode 100644
index 000000000..deef8d8a3
--- /dev/null
+++ b/tests/engine/native_text_pen.lua
@@ -0,0 +1,57 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Font=require('src.render.Font');local F=require('src.ui.game3.frlg_font')
+local V=require('src.core.GameVersion');local Assets=require('src.render.Assets')
+local oldImage,oldDraw,oldVersion=Assets.image,Font.draw,V.get()
+Assets.image=function()return{getDimensions=function()return 128,128 end}end
+local function code(cmd,n)return string.char(0xfc,cmd,n)end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ V.set(edition)
+ Font.load({font={pages={main={image='QA_FONT',base=0,glyphWidth=8,glyphHeight=8,advance=4}},
+  faces={small={image='QA_SMALL',base=0,glyphWidth=8,glyphHeight=8,advance=3}},
+  charmap={{seq='A',code=1},{seq='é',code=2},{seq='<PK>',code=3}}}})
+ local rows={};Font.draw=function(g,x,y)rows[#rows+1]={g,x,y};return Font.width(g)end
+ local pp=code(0x11,2)..code(0x14,6)..'Aé<PK>'
+ T.eq(F.measure(pp),20,'padding and fixed minimum cells include complete Unicode/ligature glyphs')
+ T.eq(F.draw(pp,10,20),20);T.same(rows,{{'A',12,20},{'é',18,20},{'<PK>',24,20}})
+ rows={};T.eq(F.measure(pp,{small=true}),20);T.eq(F.draw(pp,0,0,{small=true,maxWidth=10}),20)
+ T.same(rows,{{'A',2,0}},'width clipping excludes ink, not the native cursor advance')
+ rows={};local moved='A'..code(0x13,20)..'é'..code(0x13,2)..'<PK>'
+ T.eq(F.measure(moved),28);T.eq(F.draw(moved,0,0),28)
+ T.same(rows,{{'A',0,0},{'é',20,0},{'<PK>',24,0}},'CLEAR_TO never moves the pen backwards')
+ rows={};local shifts='A'..code(0x0d,12)..code(0x0e,7)..'é'..code(0x12,2)..'A'
+ T.eq(F.draw(shifts,3,4),6);T.same(rows,{{'A',3,4},{'é',15,11},{'A',5,11}})
+ rows={};local lines=code(0x14,6)..'A\né'
+ T.eq(F.measure(lines,{linePitch=16}),6);T.eq(F.draw(lines,1,2,{linePitch=16}),6)
+ T.same(rows,{{'A',1,2},{'é',1,18}})
+ rows={};T.eq(F.draw(pp,0,0,{limitChars=1}),8);T.same(rows,{{'A',2,0}})
+ rows={};T.eq(F.measure('Aé',{letterSpacing=2}),10);T.eq(F.draw('Aé',0,0,{letterSpacing=2}),10)
+ T.same(rows,{{'A',0,0},{'é',6,0}},'ordinary proportional labels keep their spacing')
+ local drawCode=Font.drawCode;rows={}
+ Font.drawCode=function(code,x,y)rows[#rows+1]={code,x,y}end
+ T.eq(F.measure('{POKEBLOCK}'),20,'compound word uses five native glyph advances')
+ T.eq(F.draw('{POKEBLOCK}',10,20),20)
+ T.same(rows,{{0x55,10,20},{0x56,14,20},{0x57,18,20},{0x58,22,20},{0x59,26,20}})
+ T.eq(F.measure('{POKEBLOCK}',{small=true}),15,'selected native face owns compound metrics')
+ rows={};T.eq(F.draw('{POKEBLOCK}',0,0,{maxWidth=8}),20)
+ T.same(rows,{{0x55,0,0},{0x56,4,0}},'clipped compound keeps native glyph widths and skips excess ink')
+ T.eq(F.measure('{POKEBLOCK}',{letterSpacing=1}),24)
+ rows={};T.eq(F.draw('A{POKEBLOCK}é',0,0),28)
+ T.same(rows,{{'A',0,0},{0x55,4,0},{0x56,8,0},{0x57,12,0},{0x58,16,0},{0x59,20,0},{'é',24,0}})
+ Font.drawCode=drawCode
+ rows={};T.eq(F.measure(pp,{letterSpacing=3}),20,'native fixed-width control owns cell spacing')
+ local shader={};love.graphics.setShader(shader);love.graphics.setColor(.2,.3,.4,.5)
+ for _,bad in ipairs{'A'..string.char(0xfc),'A'..string.char(0xfc,0x11),'A'..code(0x99,1)}do
+  T.raises(function()F.measure(bad)end,'native text pen control')
+  T.raises(function()F.draw(bad,0,0,{small=true})end,'native text pen control')
+ end
+ T.eq(#rows,0,'malformed controls are rejected before any draw')
+ T.eq(Font.advanceOf(1),4);T.eq(love.graphics.getShader(),shader)
+ local r,g,b,a=love.graphics.getColor();T.eq(r,.2);T.eq(g,.3);T.eq(b,.4);T.eq(a,.5)
+ Font.draw=function()error('owned pen paint failure')end
+ T.raises(function()F.draw(pp,0,0,{small=true})end,'owned pen paint failure')
+ T.eq(Font.advanceOf(1),4);T.eq(love.graphics.getShader(),shader)
+end
+Assets.image=oldImage;Font.draw=oldDraw;V.set(oldVersion)
+T.finish('shared native pen measurement and rendering, complete glyphs, bounds and error restoration')
diff --git a/tests/engine/native_ui_pass.lua b/tests/engine/native_ui_pass.lua
new file mode 100644
index 000000000..6ff241de0
--- /dev/null
+++ b/tests/engine/native_ui_pass.lua
@@ -0,0 +1,119 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local initial=package.loaded['src.core.Game']
+local Pass=require('src.ui.game3.ui_pass');local base=Pass.drawUi
+T.eq(package.loaded['src.core.Game'],initial,'import cannot bootstrap another game')
+T.eq(base(),false,'there is no independent UI draw loop')
+local NativeGame=require('src.core.Game')
+local R=require('src.render.Renderer');local G=require('src.core.Game3')
+local g=love.graphics;R:init()
+local function pack(...)return{n=select('#',...),...}end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition)
+ local game=setmetatable(f.game,{__index=NativeGame});package.loaded['src.core.Game']=game
+ local records={};local function mark(kind)
+  records[#records+1]={kind=kind,target=g.getCanvas(),owner=G._callbackOwner()}
+ end
+ local world={isOverworld=true,isOpaque=true,uiSize=function()return 240,160 end,
+  draw=function()mark('world')end}
+ game.overworld=world;game.stack:push(world)
+ local b=f.fresh('TACKLE').battle;b.enter=false;b.isOpaque=false
+ b.draw=function()mark('battle')end;game.stack:push(b)
+ local box=require('src.render.TextBox').new(game,'Native overlay')
+ box.isOpaque=false
+ local boxDraw=box.draw
+ box.draw=function(self)mark('message');return boxDraw(self)end
+ game.stack:push(box)
+ local top={isOpaque=false,uiSize=function()return 240,160 end,
+  draw=function()mark('top')end};game.stack:push(top)
+ local function frame()
+  records={};NativeGame._draw(game)
+  local names={};for _,row in ipairs(records)do names[#names+1]=row.kind end
+  return table.concat(names,',')
+ end
+ local before=b.frame;local expected='world,battle,message,top'
+ package.loaded['src.ui.game3.ui_pass']=nil
+ T.eq(frame(),expected,'module-absent native ordering')
+ package.loaded['src.ui.game3.ui_pass']=Pass;Pass.drawUi=base
+ T.eq(frame(),expected,'default module preserves native ordering')
+ local callbacks=0
+ Pass.drawUi=function()
+  callbacks=callbacks+1;T.eq(select('#',base()),0);base()
+  return false,nil,'borrowed UI return'
+ end
+ T.eq(frame(),expected);T.eq(callbacks,1,'contiguous native overlays share one UI pass')
+ T.eq(b.frame,before,'UI drawing cannot advance battle rules')
+ local hud=g.newCanvas(240,160)
+ Pass.drawUi=function()g.setCanvas(hud);return base()end
+ T.eq(frame(),expected)
+ for i,row in ipairs(records)do T.eq(row.target,i<=2 and R.canvas or hud,
+  row.kind..' retains the correct native or borrowed surface')end
+ T.eq(g.getCanvas(),nil,'the ordinary native compositor still presents its frame')
+ -- Explicit native scene-owner flags also protect custom battle/world
+ -- states. Keep interleaved UI groups in their original draw order.
+ game.stack:pop()
+ local custom={isBattleState=true,isOpaque=false,uiSize=function()return 240,160 end,
+  draw=function()mark('custom battle')end}
+ game.stack:push(custom);game.stack:push(top);callbacks=0
+ Pass.drawUi=function()callbacks=callbacks+1;g.setCanvas(hud);return base()end
+ T.eq(frame(),'world,battle,message,custom battle,top');T.eq(callbacks,2)
+ T.eq(records[3].target,hud);T.eq(records[4].target,R.canvas);T.eq(records[5].target,hud)
+ game.stack:pop();game.stack:pop();game.stack:push(top)
+ Pass.drawUi=function()return false end
+ T.eq(frame(),'world,battle','holding UI cannot suppress world/battle painting')
+ local depth=g.getStackDepth and g.getStackDepth()
+ Pass.drawUi=function()g.push('all');g.setCanvas(hud);error('source UI failed')end
+ T.raises(function()frame()end,'source UI failed')
+ if depth then T.eq(g.getStackDepth(),depth,'leaked callback pushes are fenced')end
+ T.eq(g.getCanvas(),R.canvas,'error returns to the native UI target')
+ local nativeCalls=0;box.draw=function()nativeCalls=nativeCalls+1;error('native UI failed')end
+ Pass.drawUi=function()pcall(base);return true end
+ T.raises(function()frame()end,'native UI failed');T.eq(nativeCalls,1,'a swallowed native error cannot replay')
+ box.draw=function(self)mark('message');return boxDraw(self)end
+ local rejected
+ Pass.drawUi=function()
+  local saved=game.save;game.save={options={}}
+  local a,why=base();rejected=why;game.save=saved;return a,why
+ end
+ T.eq(frame(),'world,battle');T.eq(rejected,'native UI pass cohort changed')
+ Pass.drawUi=function()
+  local index=#game.stack.states-1;local saved=game.stack.states[index]
+  game.stack.states[index]={};local a,why=base();rejected=why;game.stack.states[index]=saved
+  return a,why
+ end
+ T.eq(frame(),'world,battle');T.eq(rejected,'native UI pass cohort changed',
+  'middle-state replacement is rejected even with unchanged depth/top')
+ Pass.drawUi=function()
+  game.stack:push({});local a,why=base();rejected=why;game.stack:pop();return a,why
+ end
+ T.eq(frame(),'world,battle');T.eq(rejected,'native UI pass cohort changed')
+ local seams=require('src.mods.ModSeams');local owner=G._callbackOwner()
+ Pass.drawUi=function()T.eq(G._callbackOwner(),'ui_pass_owner');return base()end
+ seams._journal[#seams._journal+1]={tbl=Pass,key='drawUi',after=Pass.drawUi,owner='ui_pass_owner'}
+ T.eq(frame(),expected)
+ T.eq(records[1].owner,owner);T.eq(records[2].owner,owner)
+ T.eq(records[3].owner,nil,'native drawers do not inherit the source callback owner')
+ T.eq(records[4].owner,nil);T.eq(G._callbackOwner(),owner);table.remove(seams._journal)
+ Pass.drawUi=function()base();return base()end
+ local values=pack(Pass._nativeDrawUi(game,function()return nil,4,nil end))
+ T.eq(values.n,3);T.eq(values[1],nil);T.eq(values[2],4);T.eq(values[3],nil)
+ T.eq(base(),false,'retained base has no drawing phase after return')
+ Pass.drawUi=base;game.stack:pop();game.stack:pop();game.stack:pop();game.stack:pop()
+ if hud.release then hud:release()end;f.close();G.release()
+end
+-- Generation routing must not depend on whether the GBA UI module has been
+-- imported or patched. Keep ordinary native frames in their own pipeline.
+for _,edition in ipairs{'red','crystal','platinum','black'}do
+ local f=require('tools.battle-source-runtime.fixture').new('firered')
+ local game=setmetatable(f.game,{__index=NativeGame});package.loaded['src.core.Game']=game
+ require('src.core.GameVersion').set(edition)
+ local paints=0;game.stack:push({isOpaque=true,uiSize=function()return 160,144 end,
+  draw=function()paints=paints+1 end})
+ Pass.drawUi=function()error('GBA UI wrapper reached another generation')end
+ NativeGame._draw(game);T.eq(paints,1,edition..' native frame')
+ Pass._nativeDrawUi(game,function()paints=paints+1 end);T.eq(paints,2)
+ Pass.drawUi=base;game.stack:pop();f.close();G.release()
+end
+package.loaded['src.core.Game']=initial;require('src.core.GameVersion').set('firered')
+T.finish('native UI-only drawing, modal order, target borrowing and frame admission')
diff --git a/tests/engine/native_unloaded_admission.lua b/tests/engine/native_unloaded_admission.lua
new file mode 100644
index 000000000..0178e0df1
--- /dev/null
+++ b/tests/engine/native_unloaded_admission.lua
@@ -0,0 +1,22 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local G=require('src.core.Game3')
+local Field=require('src.core.game3.field_move_show_mon')
+local Transition=require('src.compat.gen1.TransitionRuntime').new()
+local Party=require('src.ui.game3.party_menu')
+local modules={'src.world.Gen3FieldMove','src.render.BattleTransition','src.ui.Gen3PartyMenu'}
+local saved={};for _,name in ipairs(modules)do saved[name]=package.loaded[name];package.loaded[name]=nil end
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ G.release();local f=require('tools.session-runtime.fixture').new(edition);local g=f.game
+ local plain={game=g,isMenu=true,subIndex=4}
+ g.stack.states={f.world,plain}
+ T.eq(Field.isActive(),false,'an unloaded native class cannot match a plain mod screen')
+ T.eq(Field._fx,nil);T.eq(Field.draw(),false);T.eq(Field.reset(),false)
+ T.eq(Transition:current(),nil);T.eq(Transition:observed(),nil)
+ T.eq(Party.open,false);T.eq(Party._party,nil);T.eq(Party.ACTIONS,nil)
+ T.eq(g.stack:top(),plain);T.eq(plain.subIndex,4,'observation cannot adopt or mutate a foreign screen')
+end
+for _,name in ipairs(modules)do package.loaded[name]=saved[name]end
+Transition:release();G.release()
+T.finish('unloaded native classes never admit plain mod or world states')
diff --git a/tests/engine/native_version_layout.lua b/tests/engine/native_version_layout.lua
new file mode 100644
index 000000000..c2a5fcee9
--- /dev/null
+++ b/tests/engine/native_version_layout.lua
@@ -0,0 +1,19 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.harness')
+local Version=require('src.core.GameVersion')
+local layouts={firered='frlg',leafgreen='frlg',emerald='rse',ruby='rse',sapphire='rse'}
+local original=Version.get()
+for id,info in pairs(Version.VERSIONS)do
+  local prefix,suffix,manifest=info.cachePrefix,info.saveSuffix,info.manifest
+  T.eq(Version.layout(id),info.layout or layouts[id],id..' metadata layout')
+  T.eq(Version:layout(id),info.layout or layouts[id],id..' colon query')
+  Version.set(id);T.eq(Version.layout(),info.layout or layouts[id],id..' current query')
+  T.eq(Version.get(),id);T.eq(info.cachePrefix,prefix);T.eq(info.saveSuffix,suffix);T.eq(info.manifest,manifest)
+end
+Version.VERSIONS.QA_LAYOUT={id='QA_LAYOUT',generation=3,layout='custom'}
+T.eq(Version.layout('QA_LAYOUT'),'custom','an explicit registered layout takes precedence')
+Version.VERSIONS.QA_LAYOUT=nil
+T.eq(Version.layout('UNKNOWN'),nil,'unknown IDs cannot inherit the current cartridge layout')
+Version.set(original)
+T.finish('native registered version layout queries')
diff --git a/tests/engine/native_voiceover_observations.lua b/tests/engine/native_voiceover_observations.lua
new file mode 100644
index 000000000..1bf31e3ed
--- /dev/null
+++ b/tests/engine/native_voiceover_observations.lua
@@ -0,0 +1,85 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Ui=require('src.core.game3.battle.ui')
+local Voice=require('src.battle.Gen3VoiceoverPresentation')
+local Battle=require('src.core.game3.battle')
+local G=require('src.core.Game3')
+local Summary=require('src.ui.Gen3SummaryLayout')
+local original,features=package.loaded['src.core.Game'],package.loaded['src.mods.FeatureOptions']
+T.eq(Ui.voiceoverDim(),0);T.eq(Ui.litHealthboxShown(),false);T.eq(Ui.quickBallPrompt(),nil)
+local inverse={[9]=0,[10]=1,[11]=2,[12]=3}
+for max=1,64 do for pp=0,max do
+ T.eq(Ui.ppColorState(pp,max),inverse[Summary.ppColor(pp,max)])
+ T.eq(Ui.ppColorIndex(pp,max),Summary.ppColor(pp,max),'existing palette-index ABI remains unchanged')
+end end
+T.eq(Ui.ppColorState('0','10'),2);T.eq(Ui.ppColorState(0,0),3)
+T.eq(Ui.ppColorState(0/0,10),nil);T.eq(Ui.ppColorState(1,math.huge),nil)
+T.eq(Ui.moveTypeOf(nil,1,{type=0}),0);T.eq(Ui.moveTypeOf({moveTypes={[2]=7}},2,{type=0}),7)
+T.eq(Ui.moveTypeOf({moveTypes={[2]=0}},2,{type=7}),0,'numeric zero is a real type identity')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ local f=require('tools.battle-source-runtime.fixture').new(edition);local game=f.game
+ package.loaded['src.core.Game']=game
+ local b=f.fresh('TACKLE').battle;b.enter=false;b:syncSides();game.stack:push(b)
+ b.phase='messages';b.queue={};b.current=nil;b.waitFrames=0;b.introSlide=0
+ local rolls=0;b.rng=function()rolls=rolls+1;return 1 end
+ local frame=b.frame;for _=1,12 do T.eq(Ui.voiceoverDim(),0);T.eq(Ui.litHealthboxShown(),false)end
+ T.eq(b.gen3Voiceover,nil);T.eq(b.frame,frame)
+ if edition=='firered'or edition=='leafgreen'then
+  game.data.constants.gen3TeachyTV={voiceovers={status={[2]='Native voice'}}}
+  b.pokedudeDemo={lesson='status',voiceDone={}}
+  T.eq(b:queuePokedudeVoices({2}),true)
+  local cue=b.queue[1];T.eq(cue.gen3Voiceover,true);T.eq(cue.gen3VoiceoverHealthbox,true)
+  T.eq(b:updateQueue(),true);T.eq(b.current,nil,'native queue holds the caption until its fade finishes')
+  for tick=1,80 do
+   b:tickFx();T.eq(Ui.voiceoverDim(),math.min(8,math.floor(tick/5))/16)
+   T.eq(Ui.litHealthboxShown(),tick==80)
+   T.eq(b:updateQueue(),true)
+   if tick<80 then T.eq(b.current,nil)end
+  end
+  T.eq(b.current,cue);T.eq(b.gen3Voiceover.phase,'message');T.eq(Ui.voiceoverDim(),.5)
+  local state=b.gen3Voiceover;local clock=state.clock;local nativeFrame=b.frame
+  for _=1,10 do T.eq(Ui.voiceoverDim(),.5);T.eq(Ui.litHealthboxShown(),true)end
+  T.eq(b.gen3Voiceover,state);T.eq(state.clock,clock);T.eq(b.frame,nativeFrame)
+  -- Finish the caption through the actual native typer/input owner.
+  game.input.wasPressed=function(_,key)return key=='a'or key=='b'end
+  local ticks=0
+  while b.current and ticks<500 do b:tickFx();b:updateQueue();ticks=ticks+1 end
+  T.check(ticks<500,'native input releases the typed voiceover')
+  game.input.wasPressed=function()return false end
+  local actions=0;b:act(function()actions=actions+1 end)
+  T.eq(b:updateQueue(),true);T.eq(b.gen3Voiceover.phase,'unhighlight')
+  for tick=1,79 do b:tickFx();b:updateQueue();T.eq(actions,0,'native action waits for both return fades')end
+  b:tickFx();b:updateQueue();T.eq(actions,1);T.eq(b.gen3Voiceover,nil)
+  T.eq(Ui.voiceoverDim(),0);T.eq(Ui.litHealthboxShown(),false)
+  -- Ordinary native narration has only one fade in/out, without spotlight.
+  b.pokedudeDemo=nil;b.current=nil;b.queue={};Voice.queue(b,'Native caption',false)
+  b:updateQueue()
+  for _=1,40 do b:tickFx();b:updateQueue()end
+  T.eq(b.current,b.gen3Voiceover.cue);T.eq(Ui.voiceoverDim(),.5);T.eq(Ui.litHealthboxShown(),false)
+  local saved=game.save;game.save={};T.eq(Ui.voiceoverDim(),.5,'the native controller remains the actual owner')
+  game.save=saved
+ else
+  b:say('Ordinary native text');b:updateQueue()
+  T.neq(b.current,nil);T.eq(b.gen3Voiceover,nil,'Hoenn narration does not enter a FR/LG controller')
+ end
+ -- Quick-item labels come from the same native availability and inventory owner.
+ -- A separate native admission keeps older caption wait/cursor state out of this menu test.
+ game.stack:pop();b=f.fresh('TACKLE').battle;b.enter=false;b:syncSides();game.stack:push(b)
+ b.rng=function()rolls=rolls+1;return 1 end
+ b.introSlide=0;b.waitFrames=0
+ b.current=nil;b.queue={};b.gen3Voiceover=nil;b.pokedudeDemo=nil;b.phase='menu';b.afterQueue='menu'
+ b.showPlayerBack=false;b.showEnemyTrainer=false;b.enemySendingOut=nil
+ for _,who in ipairs{b.player,b.enemy}do who.shownHP=who.mon.hp;who.shownStatus=who.mon.status end
+ package.loaded['src.mods.FeatureOptions']={enabled=function(key)return key=='quickBall'end}
+ game.data.items.POKE_BALL={index=4,name='NATIVE BALL',effect='BALL'}
+ game.save.inventory.POKE_BALL=2
+ T.eq(Ui.quickBallPrompt(),'NATIVE BALL\nL: NEXT R: THROW')
+ game.save.inventory.POKE_BALL=0;T.eq(Ui.quickBallPrompt(),nil)
+ game.save.inventory.POKE_BALL=2;game.stack:push({});T.eq(Ui.quickBallPrompt(),nil);game.stack:pop()
+ T.eq(rolls,0,'presentation cannot roll combat RNG')
+ game.stack:pop();T.eq(Ui.voiceoverDim(),0);T.eq(Ui.litHealthboxShown(),false)
+ Battle._service.release();f.close();G.release()
+end
+package.loaded['src.core.Game']=original;package.loaded['src.mods.FeatureOptions']=features
+T.finish('native tutorial cue clock/queue, observational UI, PP/type and quick-item contracts')
diff --git a/tests/engine/native_warp_source.lua b/tests/engine/native_warp_source.lua
new file mode 100644
index 000000000..f18564f76
--- /dev/null
+++ b/tests/engine/native_warp_source.lua
@@ -0,0 +1,68 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Contract=require('tools.native-field.warp-fixture')
+local Warp=require('src.core.game3.warp')
+local Host=require('src.mods.Runtime')
+local Stream=require('src.core.game3.asset_stream')
+local Game3=require('src.core.Game3')
+local saved=package.loaded['src.core.Game']
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Game3.release();Stream.shutdown()
+ local f=Contract.new(edition)
+ package.loaded['src.core.Game']=f.game;f.game.mods=f.loader
+ Host.currentMod='warp'
+ T.eq(Warp.isBusy(),false)
+ for _,key in ipairs{'transitioning','flyAnim','teleportOut','whirlSpin','gen4Waterfall'}do
+  f.ow[key]=true;T.eq(Warp.isBusy(),true,key..' is a native warp owner');f.ow[key]=nil
+ end
+ f.ow.emote={};T.eq(Warp.isBusy(),false,'ordinary field activity is not an invented warp');f.ow.emote=nil
+ T.eq(Warp.request(nil,f.game,f.dest,-1,0),nil);T.eq(#f.trace,0,'bad destination is side-effect free')
+ local called=0;local seenOwner
+ T.eq(Warp.request(nil,f.game,f.dest,1,2,'up',{onDone=function(a,b,c)
+  called=called+1;seenOwner=Host.currentMod;T.eq(a,'native');T.eq(b,nil);T.eq(c,'tail')
+ end}),true)
+ T.eq(#f.trace,1);T.eq(f.trace[1].mapId,f.dest);T.eq(f.trace[1].x,1);T.eq(f.trace[1].y,2)
+ T.eq(Warp.isBusy(),true)
+ Host.currentMod='peer';T.eq(Warp.clear(),false);T.eq(called,0)
+ f:arrive();f:complete('native',nil,'tail');f:complete('again')
+ T.eq(called,1);T.eq(seenOwner,'warp');T.eq(Host.currentMod,'peer')
+ f.busy=false;f.ow.transitioning=false
+ Host.currentMod='warp'
+ T.eq(Warp.request(nil,f.game,f.dest,0,0,'down',{onDone=function()called=called+1 end}),true)
+ local finish=f.callback
+ collectgarbage('collect');Stream.cancelOwner('peer');Stream.cancelOwner('warp')
+ T.eq(f.ow.transitioning,true,'revocation leaves the admitted native transition alone')
+ f:arrive();finish();T.eq(called,1,'revoked continuation never fires')
+ f.busy=false;f.ow.transitioning=false
+ T.eq(Warp.request(nil,f.game,f.dest,0,0,'down',{onDone=function()called=called+1 end}),true)
+ finish=f.callback;f.game.save={};f:arrive();finish();T.eq(called,1,'save replacement retires callback')
+ Stream.shutdown();Game3.release();Host.currentMod=nil
+ f:close()
+ -- Observe the actual native transition, with map materialization isolated.
+ local n=Contract.new(edition)
+ package.loaded['src.core.Game']=n.game;n.game.mods=n.loader;Host.currentMod='warp'
+ local OW=require('src.world.OverworldController');local restore
+ for i=1,100 do
+  local key,previous=debug.getupvalue(OW.startWarpTo,i);if not key then break end
+  if key=='Game'then debug.setupvalue(OW.startWarpTo,i,n.game);restore=function()debug.setupvalue(OW.startWarpTo,i,previous)end;break end
+ end
+ assert(restore,'native warp Game upvalue')
+ setmetatable(n.game.stack,{__index=require('src.core.StateStack')})
+ n.ow.startWarpTo=OW.startWarpTo
+ function n.ow:frlgBehaviours()return false end
+ function n.ow:noteGen2Spawn()end
+ function n.ow:setMap(id,x,y,facing)n.destination={id,x,y,facing};n:arrive()end
+ n.ow.arriveWarp='escalator'
+ T.eq(Warp.request(nil,n.game,n.dest,1,1),true)
+ local transition=n.game.stack:top();T.eq(getmetatable(transition),require('src.render.Transition'))
+ T.eq(n.ow.arriveWarp,nil);T.eq(n.ow.warpArrivalKind,'escalator')
+ T.eq(Warp.isEscalatorActive(),true,'native departure retains its admitted arrival kind')
+ for _=1,transition.frames+transition.framesIn+2 do
+  if n.game.stack:top()==transition then transition:update(1/60)end
+ end
+ T.eq(Warp.isEscalatorActive(),false);T.eq(Warp.isBusy(),false);T.eq(n.ow.warpArrivalKind,nil)
+ restore();Stream.shutdown();Game3.release();Host.currentMod=nil;n:close()
+end
+package.loaded['src.core.Game']=saved
+T.finish('source warp requests use native admission and owner callback lifetime')
diff --git a/tests/engine/native_weather_sound.lua b/tests/engine/native_weather_sound.lua
new file mode 100644
index 000000000..ac5278692
--- /dev/null
+++ b/tests/engine/native_weather_sound.lua
@@ -0,0 +1,67 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Sound=require('src.core.Sound')
+local Weather=require('src.world.Gen3WeatherAudio')
+local Stream=require('src.core.game3.asset_stream')
+local G=require('src.core.Game3')
+local oldAudio=love.audio
+local voices={}
+love.audio={newSource=function(file)
+ local s={file=file,starts=0,stops=0}
+ function s:setVolume(v)self.volume=v end
+ function s:setLooping(v)self.loop=v end
+ function s:play()self.starts=self.starts+1;self.playing=true end
+ function s:stop()self.stops=self.stops+1;self.playing=false end
+ function s:isPlaying()return self.playing end
+ voices[#voices+1]=s;return s
+end}
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ Stream.shutdown();G.release();Sound.invalidate();voices={}
+ local f=require('tools.session-runtime.fixture').new(edition);local game,w=f.game,f.world
+ local data=T.fixtures.fresh();data.maps=game.data.maps
+ data.constants.gen3WeatherNames={[0]='NONE',[3]='RAIN',[5]='RAIN_THUNDERSTORM',[13]='DOWNPOUR'}
+ data.audio={songs={}}
+ for i,name in ipairs{'SE_RAIN','SE_THUNDERSTORM','SE_DOWNPOUR','SE_RAIN_STOP','SE_THUNDERSTORM_STOP','SE_DOWNPOUR_STOP'}do
+  data.audio.songs[i]={sfxName=name,index=i,file='synthetic-'..name..'.wav'}
+ end
+ local run=T.sdk.loadMods({'mods/weather_probe'},{data=data,fs=T.sdk.memfs({
+  ['mods/weather_probe/manifest.json']=[[{"id":"weather_probe","name":"Weather probe","version":"1.0.0","api":2,"entry":"main.lua"}]],
+  ['mods/weather_probe/main.lua']=[[
+   local mod=...;mod.exports.seen={};mod.exports.claimed=false
+   mod.hooks:wrap("field.weather.sound",function(nextFn,name)
+    local e=mod.exports;e.seen[#e.seen+1]=name
+    if e.claimed then return true end
+    return nextFn(name)
+   end)
+  ]],
+ })})
+ T.eq(#run.errors,0,'native weather sound callback is accepted through API 2')
+ local e=run.loader.exports.weather_probe
+ game.mods=run.loader;game.data=run.data;game.save.gen3WeatherActive=3
+ local before=require('src.link.Json').encode(game.save)
+ local random=math.random;math.random=function()error('weather audio cannot consume gameplay RNG')end
+ Weather.update(game,w)
+ T.eq(e.seen[1],'SE_RAIN');T.eq(#voices,1);local rain=voices[1];T.eq(rain.loop,true)
+ for _=1,50 do Weather.update(game,w)end
+ T.eq(#e.seen,1,'unchanged weather does not restart the native loop');T.eq(rain.starts,1)
+ T.eq(require('src.link.Json').encode(game.save),before,'sound observation never writes the save')
+ local foreign=Sound.playNamedEffect(game.data,'SE_RAIN');T.neq(foreign,rain,'weather has a distinct native cache voice')
+ game.save.gen3WeatherActive=5;Weather.update(game,w)
+ T.eq(rain.playing,false);T.eq(foreign.playing,true,'ambient change preserves a simultaneous scripted effect')
+ T.eq(e.seen[2],'SE_RAIN_STOP');T.eq(e.seen[3],'SE_THUNDERSTORM')
+ e.claimed=true;game.save.gen3WeatherActive=13;local count=#voices;Weather.update(game,w)
+ T.eq(#voices,count,'claim suppresses only native weather playback requests')
+ T.eq(e.seen[#e.seen],'SE_DOWNPOUR')
+ game.save.gen3WeatherActive=0;Weather.update(game,w);T.eq(e.seen[#e.seen],'SE_DOWNPOUR_STOP')
+ game.save.gen3WeatherActive=3;Weather.update(game,w);T.eq(rain.playing,false)
+ run.loader.hooks:removeOwner('weather_probe');Weather.update(game,w)
+ T.eq(rain.playing,true,'removing a claiming wrapper resumes native rain on the next field tick')
+ T.eq(foreign.playing,true,'removing a wrapper preserves foreign SE playback')
+ e.claimed=false;game.save.gen3WeatherActive=3;Weather.update(game,w)
+ local live=voices[1];T.eq(live.playing,true);game.save={};Stream.poll();T.eq(live.playing,false,'retired native save stops only its weather voice')
+ T.eq(foreign.playing,true)
+ math.random=random;Stream.shutdown();run.release();Sound.invalidate();G.release()
+end
+love.audio=oldAudio
+T.finish('native weather sound requests, source suppression and independent voice lifetime')
diff --git a/tests/fixtures/gba_move_effects.h b/tests/fixtures/gba_move_effects.h
new file mode 100644
index 000000000..5555eecb9
--- /dev/null
+++ b/tests/fixtures/gba_move_effects.h
@@ -0,0 +1,219 @@
+#ifndef GUARD_CONSTANTS_BATTLE_MOVE_EFFECTS_H
+#define GUARD_CONSTANTS_BATTLE_MOVE_EFFECTS_H
+
+#define EFFECT_HIT 0
+#define EFFECT_SLEEP 1
+#define EFFECT_POISON_HIT 2
+#define EFFECT_ABSORB 3
+#define EFFECT_BURN_HIT 4
+#define EFFECT_FREEZE_HIT 5
+#define EFFECT_PARALYZE_HIT 6
+#define EFFECT_EXPLOSION 7
+#define EFFECT_DREAM_EATER 8
+#define EFFECT_MIRROR_MOVE 9
+#define EFFECT_ATTACK_UP 10
+#define EFFECT_DEFENSE_UP 11
+#define EFFECT_SPEED_UP 12
+#define EFFECT_SPECIAL_ATTACK_UP 13
+#define EFFECT_SPECIAL_DEFENSE_UP 14
+#define EFFECT_ACCURACY_UP 15
+#define EFFECT_EVASION_UP 16
+#define EFFECT_ALWAYS_HIT 17
+#define EFFECT_ATTACK_DOWN 18
+#define EFFECT_DEFENSE_DOWN 19
+#define EFFECT_SPEED_DOWN 20
+#define EFFECT_SPECIAL_ATTACK_DOWN 21  // unused
+#define EFFECT_SPECIAL_DEFENSE_DOWN 22  // unused
+#define EFFECT_ACCURACY_DOWN 23
+#define EFFECT_EVASION_DOWN 24
+#define EFFECT_HAZE 25
+#define EFFECT_BIDE 26
+#define EFFECT_RAMPAGE 27
+#define EFFECT_ROAR 28
+#define EFFECT_MULTI_HIT 29
+#define EFFECT_CONVERSION 30
+#define EFFECT_FLINCH_HIT 31
+#define EFFECT_RESTORE_HP 32
+#define EFFECT_TOXIC 33
+#define EFFECT_PAY_DAY 34
+#define EFFECT_LIGHT_SCREEN 35
+#define EFFECT_TRI_ATTACK 36
+#define EFFECT_REST 37
+#define EFFECT_OHKO 38
+#define EFFECT_RAZOR_WIND 39
+#define EFFECT_SUPER_FANG 40
+#define EFFECT_DRAGON_RAGE 41
+#define EFFECT_TRAP 42
+#define EFFECT_HIGH_CRITICAL 43
+#define EFFECT_DOUBLE_HIT 44
+#define EFFECT_RECOIL_IF_MISS 45
+#define EFFECT_MIST 46
+#define EFFECT_FOCUS_ENERGY 47
+#define EFFECT_RECOIL 48
+#define EFFECT_CONFUSE 49
+#define EFFECT_ATTACK_UP_2 50
+#define EFFECT_DEFENSE_UP_2 51
+#define EFFECT_SPEED_UP_2 52
+#define EFFECT_SPECIAL_ATTACK_UP_2 53
+#define EFFECT_SPECIAL_DEFENSE_UP_2 54
+#define EFFECT_ACCURACY_UP_2 55
+#define EFFECT_EVASION_UP_2 56
+#define EFFECT_TRANSFORM 57
+#define EFFECT_ATTACK_DOWN_2 58
+#define EFFECT_DEFENSE_DOWN_2 59
+#define EFFECT_SPEED_DOWN_2 60
+#define EFFECT_SPECIAL_ATTACK_DOWN_2 61
+#define EFFECT_SPECIAL_DEFENSE_DOWN_2 62
+#define EFFECT_ACCURACY_DOWN_2 63
+#define EFFECT_EVASION_DOWN_2 64
+#define EFFECT_REFLECT 65
+#define EFFECT_POISON 66
+#define EFFECT_PARALYZE 67
+#define EFFECT_ATTACK_DOWN_HIT 68
+#define EFFECT_DEFENSE_DOWN_HIT 69
+#define EFFECT_SPEED_DOWN_HIT 70
+#define EFFECT_SPECIAL_ATTACK_DOWN_HIT 71
+#define EFFECT_SPECIAL_DEFENSE_DOWN_HIT 72
+#define EFFECT_ACCURACY_DOWN_HIT 73
+#define EFFECT_EVASION_DOWN_HIT 74
+#define EFFECT_SKY_ATTACK 75
+#define EFFECT_CONFUSE_HIT 76
+#define EFFECT_TWINEEDLE 77
+#define EFFECT_VITAL_THROW 78
+#define EFFECT_SUBSTITUTE 79
+#define EFFECT_RECHARGE 80
+#define EFFECT_RAGE 81
+#define EFFECT_MIMIC 82
+#define EFFECT_METRONOME 83
+#define EFFECT_LEECH_SEED 84
+#define EFFECT_SPLASH 85
+#define EFFECT_DISABLE 86
+#define EFFECT_LEVEL_DAMAGE 87
+#define EFFECT_PSYWAVE 88
+#define EFFECT_COUNTER 89
+#define EFFECT_ENCORE 90
+#define EFFECT_PAIN_SPLIT 91
+#define EFFECT_SNORE 92
+#define EFFECT_CONVERSION_2 93
+#define EFFECT_LOCK_ON 94
+#define EFFECT_SKETCH 95
+#define EFFECT_UNUSED_60 96  // thaw
+#define EFFECT_SLEEP_TALK 97
+#define EFFECT_DESTINY_BOND 98
+#define EFFECT_FLAIL 99
+#define EFFECT_SPITE 100
+#define EFFECT_FALSE_SWIPE 101
+#define EFFECT_HEAL_BELL 102
+#define EFFECT_QUICK_ATTACK 103
+#define EFFECT_TRIPLE_KICK 104
+#define EFFECT_THIEF 105
+#define EFFECT_MEAN_LOOK 106
+#define EFFECT_NIGHTMARE 107
+#define EFFECT_MINIMIZE 108
+#define EFFECT_CURSE 109
+#define EFFECT_UNUSED_6E 110
+#define EFFECT_PROTECT 111
+#define EFFECT_SPIKES 112
+#define EFFECT_FORESIGHT 113
+#define EFFECT_PERISH_SONG 114
+#define EFFECT_SANDSTORM 115
+#define EFFECT_ENDURE 116
+#define EFFECT_ROLLOUT 117
+#define EFFECT_SWAGGER 118
+#define EFFECT_FURY_CUTTER 119
+#define EFFECT_ATTRACT 120
+#define EFFECT_RETURN 121
+#define EFFECT_PRESENT 122
+#define EFFECT_FRUSTRATION 123
+#define EFFECT_SAFEGUARD 124
+#define EFFECT_THAW_HIT 125
+#define EFFECT_MAGNITUDE 126
+#define EFFECT_BATON_PASS 127
+#define EFFECT_PURSUIT 128
+#define EFFECT_RAPID_SPIN 129
+#define EFFECT_SONICBOOM 130
+#define EFFECT_UNUSED_83 131
+#define EFFECT_MORNING_SUN 132
+#define EFFECT_SYNTHESIS 133
+#define EFFECT_MOONLIGHT 134
+#define EFFECT_HIDDEN_POWER 135
+#define EFFECT_RAIN_DANCE 136
+#define EFFECT_SUNNY_DAY 137
+#define EFFECT_DEFENSE_UP_HIT 138
+#define EFFECT_ATTACK_UP_HIT 139
+#define EFFECT_ALL_STATS_UP_HIT 140
+#define EFFECT_UNUSED_8D 141  // incomplete fake out in gen 2
+#define EFFECT_BELLY_DRUM 142
+#define EFFECT_PSYCH_UP 143
+#define EFFECT_MIRROR_COAT 144
+#define EFFECT_SKULL_BASH 145
+#define EFFECT_TWISTER 146
+#define EFFECT_EARTHQUAKE 147
+#define EFFECT_FUTURE_SIGHT 148
+#define EFFECT_GUST 149
+#define EFFECT_FLINCH_MINIMIZE_HIT 150  // STOMP ASTONISH EXTRASENSORY NEEDLE_ARM
+#define EFFECT_SOLAR_BEAM 151
+#define EFFECT_THUNDER 152
+#define EFFECT_TELEPORT 153
+#define EFFECT_BEAT_UP 154
+#define EFFECT_SEMI_INVULNERABLE 155
+#define EFFECT_DEFENSE_CURL 156
+#define EFFECT_SOFTBOILED 157
+#define EFFECT_FAKE_OUT 158
+#define EFFECT_UPROAR 159
+#define EFFECT_STOCKPILE 160
+#define EFFECT_SPIT_UP 161
+#define EFFECT_SWALLOW 162
+#define EFFECT_UNUSED_A3 163
+#define EFFECT_HAIL 164
+#define EFFECT_TORMENT 165
+#define EFFECT_FLATTER 166
+#define EFFECT_WILL_O_WISP 167
+#define EFFECT_MEMENTO 168
+#define EFFECT_FACADE 169
+#define EFFECT_FOCUS_PUNCH 170
+#define EFFECT_SMELLINGSALT 171
+#define EFFECT_FOLLOW_ME 172
+#define EFFECT_NATURE_POWER 173
+#define EFFECT_CHARGE 174
+#define EFFECT_TAUNT 175
+#define EFFECT_HELPING_HAND 176
+#define EFFECT_TRICK 177
+#define EFFECT_ROLE_PLAY 178
+#define EFFECT_WISH 179
+#define EFFECT_ASSIST 180
+#define EFFECT_INGRAIN 181
+#define EFFECT_SUPERPOWER 182
+#define EFFECT_MAGIC_COAT 183
+#define EFFECT_RECYCLE 184
+#define EFFECT_REVENGE 185
+#define EFFECT_BRICK_BREAK 186
+#define EFFECT_YAWN 187
+#define EFFECT_KNOCK_OFF 188
+#define EFFECT_ENDEAVOR 189
+#define EFFECT_ERUPTION 190
+#define EFFECT_SKILL_SWAP 191
+#define EFFECT_IMPRISON 192
+#define EFFECT_REFRESH 193
+#define EFFECT_GRUDGE 194
+#define EFFECT_SNATCH 195
+#define EFFECT_LOW_KICK 196
+#define EFFECT_SECRET_POWER 197
+#define EFFECT_DOUBLE_EDGE 198
+#define EFFECT_TEETER_DANCE 199
+#define EFFECT_BLAZE_KICK 200
+#define EFFECT_MUD_SPORT 201
+#define EFFECT_POISON_FANG 202
+#define EFFECT_WEATHER_BALL 203
+#define EFFECT_OVERHEAT 204
+#define EFFECT_TICKLE 205
+#define EFFECT_COSMIC_POWER 206
+#define EFFECT_SKY_UPPERCUT 207
+#define EFFECT_BULK_UP 208
+#define EFFECT_POISON_TAIL 209
+#define EFFECT_WATER_SPORT 210
+#define EFFECT_CALM_MIND 211
+#define EFFECT_DRAGON_DANCE 212
+#define EFFECT_CAMOUFLAGE 213
+
+#endif  // GUARD_CONSTANTS_BATTLE_MOVE_EFFECTS_H
diff --git a/tests/native_action_plan/turn.lua b/tests/native_action_plan/turn.lua
new file mode 100644
index 000000000..6a9df3b05
--- /dev/null
+++ b/tests/native_action_plan/turn.lua
@@ -0,0 +1,46 @@
+-- Deterministic owned native turn probe, shared by CPU regressions and an
+-- exact predecessor comparison. No ROM, player profile or simulated combat.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local B=require('src.core.game3.battle')
+local Fixture=require('tools.battle-source-runtime.fixture')
+local function open(edition)
+ local f=Fixture.new(edition);local b=f.fresh('TACKLE').battle
+ -- Wild construction uses random personality/IVs before this fixture binds
+ -- its battle RNG. Hold both actual mon records constant for the A/B turn.
+ local enemy=b.enemy.mon
+ for key in pairs(enemy)do enemy[key]=nil end
+ for key,value in pairs(require('src.mods.Merge').deepCopy(b.player.mon))do enemy[key]=value end
+ b.enemy.curStats,b.enemy.curMoves=enemy.stats,enemy.moves
+ b.player.shownHP,b.enemy.shownHP=b.player.mon.hp,enemy.hp
+ package.loaded['src.core.Game']=f.game
+ b.enter=false;f.game.stack:push(b)
+ b.queue={};b.current=nil;b.introSlide=0;b.introBalls=nil;b.phase='menu'
+ return f,b
+end
+local function close(f)
+ while f.game.stack:top()do f.game.stack:pop()end
+ f.close();B._service.release();require('src.core.Game3').release()
+end
+local function turn(edition,observe,prepare)
+ local f,b=open(edition);local rolls={}
+ b.rng=function(lo,hi)rolls[#rolls+1]={lo,hi};return lo or 0 end
+ if prepare then prepare(f,b)end
+ if not observe then package.loaded['src.core.game3.battle']=nil end
+ b:resolveTurn(b.player.mon.moves[1])
+ package.loaded['src.core.game3.battle']=B
+ f.game.input.wasPressed=function(_,key)return key=='a'end
+ local trace={}
+ for i=1,1200 do
+  b:update(1/60)
+  if observe then local actions,cursor=B._actions,B._actionI;assert(not actions or cursor==nil or cursor>=0)end
+  trace[i]={phase=b.phase,frame=b.frame,playerHP=b.player.mon.hp,enemyHP=b.enemy.mon.hp,
+   playerPP=b.player.mon.moves[1].pp,enemyPP=b.enemy.mon.moves[1]and b.enemy.mon.moves[1].pp}
+  if b.phase=='menu'and #b.queue==0 and not b.current then break end
+  assert(i<1200,'owned native action turn did not finish')
+ end
+ local result={trace=trace,rolls=rolls,turn=b.turnCount,phase=b.phase}
+ close(f)
+ return result
+end
+return {open=open,close=close,turn=turn}
diff --git a/tests/parity_picker_pointer_grab.lua b/tests/parity_picker_pointer_grab.lua
index 6b5e56bcb..abb35380b 100644
--- a/tests/parity_picker_pointer_grab.lua
+++ b/tests/parity_picker_pointer_grab.lua
@@ -69,7 +69,8 @@ do
     -- the punctuation is the point: `io.popen(` or `io.popen,` is a CALL,
     -- and the prose above it in that file mentions the name twice
     local calls = 0
-    for _ in host:gmatch("io%.popen[,(]") do calls = calls + 1 end
+    local code = host:gsub("%-%-[^\n]*", "")
+    for _ in code:gmatch("io%.popen[,(]") do calls = calls + 1 end
     eq(calls, 1, "and the whole engine holds exactly one io.popen, in "
       .. "HostShell -- which is what makes 'every picker funnels through "
       .. "commandOutput' a statement about all of them")
diff --git a/tools/battle-animation-runtime/coords-check.lua b/tools/battle-animation-runtime/coords-check.lua
new file mode 100644
index 000000000..9401a88d9
--- /dev/null
+++ b/tools/battle-animation-runtime/coords-check.lua
@@ -0,0 +1,42 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Optional local contract comparison. The oracle is supplied by the caller;
+-- no external engine, private package or cartridge is distributed here.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local C=require('src.core.game3.battle.anim_coords')
+local reference=assert(loadfile(assert(os.getenv('BATTLE_COORDS_ORACLE'))))()
+for _,double in ipairs{false,true}do
+  local st={double=double,battlers={}}
+  C.setDouble(double);reference.setDouble(double)
+  T.same(C.monDrawOrder(st),reference.monDrawOrder(st))
+  T.same(C.ids(st),reference.ids(st))
+  for id=0,3 do
+    T.same(C.coords(st,id),reference.coords(st,id))
+    T.eq(C.subpriority(id),reference.subpriority(id))
+    T.eq(C.bgPriorityRank(id),reference.bgPriorityRank(id))
+    T.eq(C.monBehindZ(id,st),reference.monBehindZ(id,st))
+    T.eq(C.partner(id),reference.partner(id))
+    for _,hp in ipairs{0,1}do
+      st.battlers[id]={mon={hp=hp}}
+      T.eq(C.spritePresent(st,id),reference.spritePresent(st,id))
+    end
+  end
+  for k=0,5 do
+    local a,b=C.particleBand(k,st);local x,y=reference.particleBand(k,st)
+    T.eq(a,x);T.eq(b,y)
+  end
+  for sub=0,255 do
+    for pri=0,3 do
+      for _,vm in ipairs{{},{_monbg={[0]=true,[3]=true},_bgPrio={[1]=1,[2]=3}}}do
+        T.eq(C.zFor(pri,sub,vm,st),reference.zFor(pri,sub,vm,st))
+      end
+    end
+  end
+end
+C.setDouble(nil);reference.setDouble(nil)
+for attacker=0,3 do for target=0,3 do
+  C.bind(attacker,target);reference.bind(attacker,target)
+  for _,side in ipairs{'player','enemy'}do T.eq(C.idOf(side),reference.idOf(side))end
+end end
+C.bind(nil);reference.bind(nil)
+T.finish('authored battler coordinate contract')
diff --git a/tools/battle-animation-runtime/host/conf.lua b/tools/battle-animation-runtime/host/conf.lua
new file mode 100644
index 000000000..7aea1d29a
--- /dev/null
+++ b/tools/battle-animation-runtime/host/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+  t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+  t.window.width,t.window.height=480,320;t.window.vsync=0;t.window.highdpi=false
+  t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+  t.graphics=t.graphics or{};t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/battle-animation-runtime/host/main.lua b/tools/battle-animation-runtime/host/main.lua
new file mode 100644
index 000000000..a6381f06b
--- /dev/null
+++ b/tools/battle-animation-runtime/host/main.lua
@@ -0,0 +1,159 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('BATTLE_SOURCE_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;./?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+function love.load()
+  local T=require('tests.harness').suite('native battle animation GPU')
+  local A=require('src.core.game3.battle.anim')
+  local Battle=require('src.core.game3.battle')
+  local Scope=require('src.render.GraphicsScope')
+  local g=love.graphics
+  local nativeSource=debug.getinfo(require('src.battle.BattleState').update,'S').source
+  T.eq(nativeSource,'@'..root..'/src/battle/BattleState.lua')
+  local renderer,version,vendor,device=g.getRendererInfo()
+  local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))
+  T.check(renderer:lower():find(backend,1,true)~=nil,'actual requested GPU backend')
+  T.eq(love.filesystem.getIdentity(),os.getenv('POKEPORT_IDENTITY'))
+  love.filesystem.createDirectory('tests/fixture_data/assets')
+  local pixels=love.image.newImageData(64,64)
+  pixels:mapPixel(function(x,y)
+    if x<7 or y<5 or x>56 or y>57 then return 0,0,0,0 end
+    if y<20 and x<37 then return 1,0,91/255,1 end
+    if x>40 and y>35 then return 0,1,125/255,1 end
+    return .2,.3,.9,1
+  end)
+  for _,side in ipairs{'back','front'}do pixels:encode('png','tests/fixture_data/assets/fixmon_a_'..side..'.png')end
+  pixels:release()
+  local comparisons,readbacks=0,0
+  local function read(canvas)
+    local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData()
+    local bytes=data:getString();data:release();readbacks=readbacks+1;return bytes
+  end
+  local function frame(canvas,draw)
+    local ok,why=Scope.call(function()
+      g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.clear(0,0,0,0);g.setColor(1,1,1,1);draw()
+    end)
+    assert(ok,why);return read(canvas)
+  end
+  local function same(a,b,label,tolerance)
+    comparisons=comparisons+1
+    if not tolerance then return T.eq(a,b,label)end
+    local error=0
+    for i=1,#a do error=math.max(error,math.abs(a:byte(i)-b:byte(i)))end
+    if error>tolerance then
+      local count=0
+      for i=1,#a,4 do
+        local bad=false;for c=0,3 do if math.abs(a:byte(i+c)-b:byte(i+c))>tolerance then bad=true end end
+        if bad then
+          print('PIXEL_ORACLE_DIFFERENCE',label,((i-1)/4)%160,math.floor((i-1)/4/160),
+            string.format('%d,%d,%d,%d',a:byte(i,i+3)),string.format('%d,%d,%d,%d',b:byte(i,i+3)));count=count+1;if count==4 then break end
+        end
+      end
+      print('MAX_PIXEL_ERROR',error)
+    end
+    T.check(#a==#b and error<=tolerance,label)
+  end
+  -- Independent pixel oracle: inverse-map output pixel centres into the
+  -- already rendered native image, without using graphics transforms.
+  local function remap(bytes,width,height,map,alpha)
+    local rows={}
+    for y=0,height-1 do
+      local row={}
+      for x=0,width-1 do
+        local sx,sy=map(x+.5,y+.5);sx,sy=math.floor(sx),math.floor(sy)
+        local value='\0\0\0\0'
+        if sx>=0 and sx<width and sy>=0 and sy<height then
+          local at=(sy*width+sx)*4+1
+          if alpha then
+            local values={};for c=0,3 do values[c+1]=math.floor(bytes:byte(at+c)*alpha+.5)end
+            value=string.char(unpack(values))
+          else value=bytes:sub(at,at+3)end
+        end
+        row[#row+1]=value
+      end
+      rows[#rows+1]=table.concat(row)
+    end
+    return table.concat(rows)
+  end
+  local outerShader=g.newShader('vec4 effect(vec4 c, Image t, vec2 uv, vec2 p) { return Texel(t,uv)*c; }')
+  for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+    A.reset();Battle._service.release()
+    local f=require('tools.battle-source-runtime.fixture').new(edition)
+    local game=f.game;package.loaded['src.core.Game']=game
+    local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b);b.phase='QA_IDLE'
+    b.introSlide=0;b.frlgIntro=nil
+    local canvas=g.newCanvas(160,144,{format='rgba8',dpiscale=1,msaa=0})
+    local preview=g.newCanvas(160,144,{format='rgba8',dpiscale=1,msaa=0})
+    -- This host bypasses the application's pixel-art graphics setup. Set
+    -- the owned fixture texture explicitly so the independent nearest-pixel
+    -- oracle does not compare against LOVE's default linear interpolation.
+    b:battlerPic(b.player):setFilter('nearest','nearest')
+    local function draw()return b:drawBattlerPic(b.player,20,20,1)end
+    local baseline=frame(canvas,draw)
+    T.check(baseline:find(string.char(255,0,91,255),1,true)~=nil,'real asymmetric art reaches the native draw')
+    local p=A.present(0)
+    same(frame(canvas,draw),baseline,'observing a pose preserves native pixels '..edition)
+    local expected=remap(baseline,160,144,function(x,y)return x-13,y-5 end)
+    p.ox,p.oy=13,5
+    same(frame(canvas,draw),expected,'source offsets compose with native sprite draw '..edition)
+    T.check(expected~=baseline);p.ox,p.oy=nil,nil
+    local img=b:battlerPic(b.player);local w,h=img:getDimensions();local cx,cy=20+w/2,20+h/2
+    expected=remap(baseline,160,144,function(x,y)
+      -- A clockwise quarter turn exchanges axes; the horizontal reflection
+      -- then reverses the vertical axis in output space.
+      return cx-(y-cy),cy-(x-cx)/2
+    end,.5)
+    p.hFlip,p.rotation,p.scale,p.sx,p.sy,p.alpha=true,math.pi/2,.5,2,4,.5
+    same(frame(canvas,draw),expected,'flip, rotation, scale and alpha preserve authored orientation '..edition,1)
+    p.hFlip,p.rotation,p.scale,p.sx,p.sy,p.alpha=nil,nil,nil,nil,nil,nil
+    same(frame(canvas,draw),baseline,'clearing source overrides restores native pixels '..edition)
+    p.visible=false;local hidden=frame(canvas,draw);T.check(hidden~=baseline);T.eq(hidden,string.rep('\0',160*144*4))
+    p.visible=nil
+    local old=b.drawBattlerPicAt;p.ox=1
+    local ok,why=Scope.call(function()
+      g.setCanvas(canvas);g.setShader(outerShader)
+      local depth=g.getStackDepth()
+      b.drawBattlerPicAt=function()g.push();g.setCanvas(preview);error('native sprite draw failure')end
+      local success,err=pcall(draw);T.eq(success,false);T.check(tostring(err):find('native sprite draw failure',1,true)~=nil)
+      T.eq(g.getCanvas(),canvas);T.eq(g.getShader(),outerShader);T.eq(g.getStackDepth(),depth)
+    end)
+    assert(ok,why);b.drawBattlerPicAt=old;p.ox=nil
+    local base={.8,.2,.35}
+    for _,effect in ipairs{'invert','fade_white','fade_black','darken','grayscale','custom_blend'}do
+      A.setScreenEffect({type=effect,coeff=.5,targetColor={.2,.4,.6}})
+      frame(canvas,function()
+        g.setShader(outerShader);T.eq(A.beginScreenEffect(),true)
+        local active=g.getShader();T.neq(active,outerShader)
+        T.eq(A.beginScreenEffect(),true);T.eq(g.getShader(),active,'repeated begin does not nest')
+        local nested=Scope.call(function()
+          T.eq(A.beginScreenEffect(),true);T.eq(A.endScreenEffect(),true);T.eq(g.getShader(),active)
+        end);T.eq(nested,true)
+        g.setColor(base[1],base[2],base[3],1);g.rectangle('fill',0,0,160,144)
+        T.eq(A.endScreenEffect(),true);T.eq(g.getShader(),outerShader)
+      end)
+      local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData();readbacks=readbacks+1
+      local actual={data:getPixel(10,10)};data:release()
+      local luma=base[1]*.299+base[2]*.587+base[3]*.114
+      for channel=1,3 do
+        local target=effect=='fade_white'and 1 or(effect=='grayscale'and luma or(effect=='custom_blend'and({.2,.4,.6})[channel]or 0))
+        local value=effect=='invert'and 1-base[channel]or(base[channel]+target)/2
+        T.check(math.abs(actual[channel]-value)<2/255,'screen effect GPU colour '..effect..' '..edition)
+      end
+      T.eq(actual[4],1)
+    end
+    local priorShader=g.getShader();local depth=g.getStackDepth();local priorCanvas=g.getCanvas()
+    ok,why=Scope.call(function()A.beginScreenEffect();g.push();g.setCanvas(preview);error('effect failure')end)
+    T.eq(ok,false);T.check(tostring(why):find('effect failure',1,true)~=nil)
+    T.eq(g.getShader(),priorShader);T.eq(g.getStackDepth(),depth);T.eq(g.getCanvas(),priorCanvas)
+    A.setScreenEffect(nil);T.eq(A.beginScreenEffect(),false)
+    canvas:release();preview:release();game.stack.states={};f.close();A.reset();Battle._service.release()
+  end
+  outerShader:release();T.finish()
+  local report={passed=true,checks=T.checks,comparisons=comparisons,readbacks=readbacks,
+    backend=backend,renderer=renderer,version=version,vendor=vendor,device=device,
+    nativeBattleSource=nativeSource,engineRoot=root,syntheticBattlerArt=true,
+    playerProfilesUsed=false,originalModLoaded=false,gameplayProven=false}
+  local file=assert(io.open(assert(os.getenv('BATTLE_SOURCE_REPORT')),'w'))
+  file:write(require('src.link.Json').encode(report));file:close();love.event.quit(0)
+end
diff --git a/tools/battle-animation-runtime/lifecycle-check.lua b/tools/battle-animation-runtime/lifecycle-check.lua
new file mode 100644
index 000000000..4b02a426d
--- /dev/null
+++ b/tools/battle-animation-runtime/lifecycle-check.lua
@@ -0,0 +1,45 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Json=require('src.link.Json')
+require('src.core.GameVersion').set('emerald')
+local api=tonumber(os.getenv('SESSION_RUNTIME_API'))or require('src.core.Version').modApi
+local files={}
+for _,id in ipairs{'animation_owner','native_peer','failed_animation_owner'}do
+  files['mods/'..id..'/manifest.json']=Json.encode({id=id,name=id,version='1.0.0',api=api,
+    entry='main.lua',games={'gen3'},permissions={'engine_internals'}})
+end
+files['mods/animation_owner/main.lua']=[[
+ local mod=...;local A=require('src.core.game3.battle.anim')
+ mod.exports.begin=function()
+  mod.exports.pose=A.present(0)
+  A.tweenStage(2,function()mod.exports.ticks=(mod.exports.ticks or 0)+1 end)
+ end
+]]
+files['mods/native_peer/main.lua']=[[
+ local mod=...;mod.events:on('game.ready',function(p)mod.exports.game=p.game end)
+]]
+files['mods/failed_animation_owner/main.lua']=[[
+ local A=require('src.core.game3.battle.anim');A.present=function()error('failed pose survived')end
+ error('intentional animation entry failure')
+]]
+local run=T.sdk.loadMods({'mods/animation_owner','mods/native_peer','mods/failed_animation_owner'},
+  {fs=T.sdk.memfs(files),data=T.fixtures.fresh()})
+T.eq(#run.errors,1)
+local G=require('src.core.Game3');local Host=require('src.mods.Runtime')
+T.eq(G._usesCallbacks('animation_owner'),true,'animation namespace selects source callbacks')
+T.eq(G._usesCallbacks('native_peer'),false);T.eq(G._usesCallbacks('failed_animation_owner'),false)
+local f=require('tools.battle-source-runtime.fixture').new('emerald')
+local game=f.game;game.mods=run.loader;run.loader.game=game;package.loaded['src.core.Game']=game
+local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b);b.phase='QA_IDLE'
+local Battle=require('src.core.game3.battle');local A=require('src.core.game3.battle.anim')
+local owner=run.loader.exports.animation_owner
+Host.currentMod='animation_owner';owner.begin();Host.currentMod=nil
+run.loader.events:emit('game.ready',{game=game});T.eq(run.loader.exports.native_peer.game,game)
+b:update(1/60);T.eq(owner.ticks,1)
+require('src.mods.Loader').teardown()
+T.raises(function()owner.pose.ox=1 end,'retired')
+b:update(1/60);T.eq(owner.ticks,1,'teardown cancels source tweens without aborting native combat')
+T.eq(game.stack:top(),b);T.eq(G._usesCallbacks('animation_owner'),false)
+game.stack.states={};f.close();run.release();A.reset();Battle._service.release()
+T.finish('animation SDK retirement and native peer API '..api)
diff --git a/tools/battle-chrome/host/conf.lua b/tools/battle-chrome/host/conf.lua
new file mode 100644
index 000000000..7aea1d29a
--- /dev/null
+++ b/tools/battle-chrome/host/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+  t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+  t.window.width,t.window.height=480,320;t.window.vsync=0;t.window.highdpi=false
+  t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+  t.graphics=t.graphics or{};t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/battle-chrome/host/main.lua b/tools/battle-chrome/host/main.lua
new file mode 100644
index 000000000..48288d317
--- /dev/null
+++ b/tools/battle-chrome/host/main.lua
@@ -0,0 +1,273 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('BATTLE_SOURCE_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;./?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+function love.load()
+  local T=require('tests.harness').suite('native battle chrome rendering GPU')
+  local A=require('src.core.game3.battle.anim')
+  local Battle=require('src.core.game3.battle')
+  local Scope=require('src.render.GraphicsScope')
+  local g=love.graphics
+  local nativeSource=debug.getinfo(require('src.battle.BattleState').update,'S').source
+  T.eq(nativeSource,'@'..root..'/src/battle/BattleState.lua')
+  local renderer,version,vendor,device=g.getRendererInfo()
+  local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))
+  T.check(renderer:lower():find(backend,1,true)~=nil,'actual requested GPU backend')
+  T.eq(love.filesystem.getIdentity(),os.getenv('POKEPORT_IDENTITY'))
+  love.filesystem.createDirectory('tests/fixture_data/assets')
+  local pixels=love.image.newImageData(64,64)
+  pixels:mapPixel(function(x,y)
+    if x<7 or y<5 or x>56 or y>57 then return 0,0,0,0 end
+    if y<20 and x<37 then return 1,0,91/255,1 end
+    if x>40 and y>35 then return 0,1,125/255,1 end
+    return .2,.3,.9,1
+  end)
+  for _,side in ipairs{'back','front'}do pixels:encode('png','tests/fixture_data/assets/fixmon_a_'..side..'.png')end
+  pixels:release()
+  local fontPixels=love.image.newImageData(128,64)
+  fontPixels:mapPixel(function(x,y)
+    local xx,yy=x%8,y%8
+    if xx==1 or yy==2 and xx<6 then return 0,0,0,1 end
+    if xx==2 or yy==3 and xx>1 and xx<7 then return 1,1,1,1 end
+    return 0,0,0,0
+  end)
+  fontPixels:encode('png','tests/fixture_data/assets/fix_font.png');fontPixels:release()
+  local comparisons,readbacks=0,0
+  local function read(canvas)
+    local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData()
+    local bytes=data:getString();data:release();readbacks=readbacks+1;return bytes
+  end
+  local function frame(canvas,draw)
+    local ok,why=Scope.call(function()
+      g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.clear(0,0,0,0);g.setColor(1,1,1,1);draw()
+    end)
+    assert(ok,why);return read(canvas)
+  end
+  local function same(a,b,label,tolerance)
+    comparisons=comparisons+1
+    if not tolerance then return T.eq(a,b,label)end
+    local error=0
+    for i=1,#a do error=math.max(error,math.abs(a:byte(i)-b:byte(i)))end
+    if error>tolerance then
+      local count=0
+      for i=1,#a,4 do
+        local bad=false;for c=0,3 do if math.abs(a:byte(i+c)-b:byte(i+c))>tolerance then bad=true end end
+        if bad then
+          print('PIXEL_ORACLE_DIFFERENCE',label,((i-1)/4)%160,math.floor((i-1)/4/160),
+            string.format('%d,%d,%d,%d',a:byte(i,i+3)),string.format('%d,%d,%d,%d',b:byte(i,i+3)));count=count+1;if count==4 then break end
+        end
+      end
+      print('MAX_PIXEL_ERROR',error)
+    end
+    T.check(#a==#b and error<=tolerance,label)
+  end
+  -- Independent pixel oracle: inverse-map output pixel centres into the
+  -- already rendered native image, without using graphics transforms.
+  local function remap(bytes,width,height,map,alpha)
+    local rows={}
+    for y=0,height-1 do
+      local row={}
+      for x=0,width-1 do
+        local sx,sy=map(x+.5,y+.5);sx,sy=math.floor(sx),math.floor(sy)
+        local value='\0\0\0\0'
+        if sx>=0 and sx<width and sy>=0 and sy<height then
+          local at=(sy*width+sx)*4+1
+          if alpha then
+            local values={};for c=0,3 do values[c+1]=math.floor(bytes:byte(at+c)*alpha+.5)end
+            value=string.char(unpack(values))
+          else value=bytes:sub(at,at+3)end
+        end
+        row[#row+1]=value
+      end
+      rows[#rows+1]=table.concat(row)
+    end
+    return table.concat(rows)
+  end
+  local outerShader=g.newShader('vec4 effect(vec4 c, Image t, vec2 uv, vec2 p) { return Texel(t,uv)*c; }')
+  for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+    A.reset();Battle._service.release()
+    local f=require('tools.battle-source-runtime.fixture').new(edition)
+    local game=f.game;package.loaded['src.core.Game']=game
+    local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b);b.phase='QA_IDLE'
+    b.introSlide=0;b.frlgIntro=nil
+    local canvas=g.newCanvas(160,144,{format='rgba8',dpiscale=1,msaa=0})
+    local preview=g.newCanvas(160,144,{format='rgba8',dpiscale=1,msaa=0})
+    -- This host bypasses the application's pixel-art graphics setup. Set
+    -- the owned fixture texture explicitly so the independent nearest-pixel
+    -- oracle does not compare against LOVE's default linear interpolation.
+    b:battlerPic(b.player):setFilter('nearest','nearest')
+    local function draw()return b:drawBattlerPic(b.player,20,20,1)end
+    local baseline=frame(canvas,draw)
+    T.check(baseline:find(string.char(255,0,91,255),1,true)~=nil,'real asymmetric art reaches the native draw')
+    local p=A.present(0)
+    same(frame(canvas,draw),baseline,'observing a pose preserves native pixels '..edition)
+    local expected=remap(baseline,160,144,function(x,y)return x-13,y-5 end)
+    p.ox,p.oy=13,5
+    same(frame(canvas,draw),expected,'source offsets compose with native sprite draw '..edition)
+    T.check(expected~=baseline);p.ox,p.oy=nil,nil
+    local img=b:battlerPic(b.player);local w,h=img:getDimensions();local cx,cy=20+w/2,20+h/2
+    expected=remap(baseline,160,144,function(x,y)
+      -- A clockwise quarter turn exchanges axes; the horizontal reflection
+      -- then reverses the vertical axis in output space.
+      return cx-(y-cy),cy-(x-cx)/2
+    end,.5)
+    p.hFlip,p.rotation,p.scale,p.sx,p.sy,p.alpha=true,math.pi/2,.5,2,4,.5
+    same(frame(canvas,draw),expected,'flip, rotation, scale and alpha preserve authored orientation '..edition,1)
+    p.hFlip,p.rotation,p.scale,p.sx,p.sy,p.alpha=nil,nil,nil,nil,nil,nil
+    same(frame(canvas,draw),baseline,'clearing source overrides restores native pixels '..edition)
+    p.visible=false;local hidden=frame(canvas,draw);T.check(hidden~=baseline);T.eq(hidden,string.rep('\0',160*144*4))
+    p.visible=nil
+    local old=b.drawBattlerPicAt;p.ox=1
+    local ok,why=Scope.call(function()
+      g.setCanvas(canvas);g.setShader(outerShader)
+      local depth=g.getStackDepth()
+      b.drawBattlerPicAt=function()g.push();g.setCanvas(preview);error('native sprite draw failure')end
+      local success,err=pcall(draw);T.eq(success,false);T.check(tostring(err):find('native sprite draw failure',1,true)~=nil)
+      T.eq(g.getCanvas(),canvas);T.eq(g.getShader(),outerShader);T.eq(g.getStackDepth(),depth)
+    end)
+    assert(ok,why);b.drawBattlerPicAt=old;p.ox=nil
+    local base={.8,.2,.35}
+    for _,effect in ipairs{'invert','fade_white','fade_black','darken','grayscale','custom_blend'}do
+      A.setScreenEffect({type=effect,coeff=.5,targetColor={.2,.4,.6}})
+      frame(canvas,function()
+        g.setShader(outerShader);T.eq(A.beginScreenEffect(),true)
+        local active=g.getShader();T.neq(active,outerShader)
+        T.eq(A.beginScreenEffect(),true);T.eq(g.getShader(),active,'repeated begin does not nest')
+        local nested=Scope.call(function()
+          T.eq(A.beginScreenEffect(),true);T.eq(A.endScreenEffect(),true);T.eq(g.getShader(),active)
+        end);T.eq(nested,true)
+        g.setColor(base[1],base[2],base[3],1);g.rectangle('fill',0,0,160,144)
+        T.eq(A.endScreenEffect(),true);T.eq(g.getShader(),outerShader)
+      end)
+      local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData();readbacks=readbacks+1
+      local actual={data:getPixel(10,10)};data:release()
+      local luma=base[1]*.299+base[2]*.587+base[3]*.114
+      for channel=1,3 do
+        local target=effect=='fade_white'and 1 or(effect=='grayscale'and luma or(effect=='custom_blend'and({.2,.4,.6})[channel]or 0))
+        local value=effect=='invert'and 1-base[channel]or(base[channel]+target)/2
+        T.check(math.abs(actual[channel]-value)<2/255,'screen effect GPU colour '..effect..' '..edition)
+      end
+      T.eq(actual[4],1)
+    end
+    local priorShader=g.getShader();local depth=g.getStackDepth();local priorCanvas=g.getCanvas()
+    ok,why=Scope.call(function()A.beginScreenEffect();g.push();g.setCanvas(preview);error('effect failure')end)
+    T.eq(ok,false);T.check(tostring(why):find('effect failure',1,true)~=nil)
+    T.eq(g.getShader(),priorShader);T.eq(g.getStackDepth(),depth);T.eq(g.getCanvas(),priorCanvas)
+    A.setScreenEffect(nil);T.eq(A.beginScreenEffect(),false)
+    -- Nested source text must restore the outer native two-tone uniforms.
+    local Font=require('src.render.Font');local SourceFont=require('src.ui.game3.frlg_font')
+    game.data.font.pages={main={image='tests/fixture_data/assets/fix_font.png',base=0x80,
+      glyphWidth=8,glyphHeight=8,glyphsPerRow=16,preTinted=true}}
+    Font.load(game.data)
+    local sample=love.image.newImageData(1,1);sample:setPixel(0,0,0,0,0,1)
+    local texture=g.newImage(sample);sample:release();texture:setFilter('nearest','nearest')
+    local function pixelAt(x)return function()g.draw(texture,x,100)end end
+    local expectedText=frame(canvas,function()
+      Font.beginTwoTone({1,0,0,1},{0,1,0,1});pixelAt(5)();pixelAt(10)();Font.endTwoTone()
+    end)
+    T.eq(expectedText:sub((100*160+5)*4+1,(100*160+5)*4+4),string.char(255,0,0,255),'native outer shader produces red ink')
+    local actualText=frame(canvas,function()
+      Font.beginTwoTone({1,0,0,1},{0,1,0,1});pixelAt(5)()
+      T.eq(SourceFont.measure('AB',{letterSpacing=2}),Font.width('AB')+2)
+      local oldCanvas,oldShader,depth=g.getCanvas(),g.getShader(),g.getStackDepth()
+      SourceFont.draw('AB',5,5,{colors={fg={0,0,1,1},shadow={1,1,0,1}},letterSpacing=2})
+      T.eq(g.getCanvas(),oldCanvas);T.eq(g.getShader(),oldShader);T.eq(g.getStackDepth(),depth)
+      pixelAt(10)();Font.endTwoTone()
+    end)
+    -- Compare only the two independent sample pixels; text occupies other rows.
+    local function pixel(bytes,x,y)local at=(y*160+x)*4+1;return bytes:sub(at,at+3)end
+    same(pixel(actualText,5,100),pixel(expectedText,5,100),'outer ink before nested text '..edition)
+    same(pixel(actualText,10,100),pixel(expectedText,10,100),'outer ink after nested text '..edition)
+    T.eq(pixel(actualText,6,5),string.char(0,0,255,255),'real source text paints native ink '..edition)
+    T.eq(pixel(actualText,7,5),string.char(255,255,0,255),'real source text retains native shadow '..edition)
+    T.eq(SourceFont._spec.nativeLayout,(edition=='firered'or edition=='leafgreen')and'frlg'or'rs')
+    local Chrome=require('src.ui.game3.battle_chrome');local Native=require('src.battle.Gen3Battle')
+    local Health=require('src.core.game3.battle.healthbox')
+    local panel=love.image.newImageData(240,48)
+    panel:mapPixel(function(x,y)
+      if x<4 then return 1,0,0,.5 end
+      if y<3 then return 0,1,0,1 end
+      if x>235 then return 0,0,1,1 end
+      return .2,.3,.4,.5
+    end)
+    panel:encode('png','tests/fixture_data/assets/native_panel.png');panel:release()
+    game.data.constants.gen3BattleTextbox={images={action='tests/fixture_data/assets/native_panel.png'},y=112}
+    require('src.render.Assets').image('tests/fixture_data/assets/native_panel.png'):setFilter('nearest','nearest')
+    for _,width in ipairs{240,320,480}do
+      b.gen3SurfaceWidth=function()return width end
+      local wide=g.newCanvas(width,160,{format='rgba8',dpiscale=1,msaa=0})
+      local expectedPanel=frame(wide,function()Native.drawPanel(b,'action')end)
+      same(frame(wide,function()Chrome.drawPanel('menu')end),expectedPanel,'source panel retains native pixels at width '..width..' '..edition)
+      local base=Chrome.drawPanel;local wrappers,paints=0,0
+      Chrome.drawPanel=function(mode)wrappers=wrappers+1;base(mode);return base(mode)end
+      local actual=frame(wide,function()
+        Chrome._panel(b,'action',function()paints=paints+1;return Native.drawPanel(b,'action')end)
+      end)
+      same(actual,expectedPanel,'native panel scope paints alpha pixels once at width '..width..' '..edition)
+      T.eq(wrappers,1);T.eq(paints,1);Chrome.drawPanel=base
+      -- A pixel oracle independent of either painter proves the asymmetric top.
+      local at=(113*width+10)*4+1;T.eq(actual:sub(at,at+3),string.char(0,255,0,255))
+      local st=Battle.getState();local x,y=Native.healthboxGeometry(b,0);local center=Health.center(st,0)
+      T.eq(center.x,x+32);T.eq(center.y,y+16)
+      wide:release()
+    end
+    b.gen3SurfaceWidth=nil
+    local old=Health.draw;local wrappers,paints=0,0
+    Health.draw=function(side,mon,opts)wrappers=wrappers+1;opts.ox,opts.oy=7,3;old(side,mon,opts);return old(side,mon,opts)end
+    local moved=frame(canvas,function()
+      Health._nativeDraw(b,b.player,0,0,true,function()paints=paints+1;g.setColor(1,0,0,1);g.rectangle('fill',20,20,4,4)end)
+    end)
+    local expectedMoved=frame(preview,function()g.setColor(1,0,0,1);g.rectangle('fill',27,23,4,4)end)
+    same(moved,expectedMoved,'native healthbox wrapper applies owned offsets once '..edition)
+    T.eq(wrappers,1);T.eq(paints,1);Health.draw=old
+    -- Actual native particle draw, with a separate inverse-pixel oracle.
+    local Sprites=require('src.core.game3.battle.anim_sprites')
+    game.data.constants.gen3BattleAnimGfx={PROBE={image='tests/fixture_data/assets/fixmon_a_front.png',frameWidth=64,frameHeight=64,frames=1}}
+    game.data.moves.MOVE_033.anim={duration=8,events={{at=0,sheet='PROBE',x=-30,y=20,target=true,subpriority=40,priority=2}}}
+    b.gen3Anim=require('src.battle.Gen3MoveAnim').new(game.data)
+    T.eq(A.launchMove(33),true)
+    local particles=g.newCanvas(240,160,{format='rgba8',dpiscale=1,msaa=0})
+    local nativePool=Sprites._pool;T.eq(#nativePool,1)
+    local particle=nativePool[1];local event=b.gen3Anim.events[1]
+    require('src.render.Assets').image(game.data.constants.gen3BattleAnimGfx.PROBE.image):setFilter('nearest','nearest')
+    local function drawParticle()return b.gen3Anim:drawEvent(event,b,Native,require('src.render.Assets'))end
+    local nativeParticle=frame(particles,drawParticle)
+    T.check(nativeParticle:find(string.char(255,0,91,255),1,true)~=nil,'actual native particle uses the asymmetric imported sheet')
+    particle.x,particle.y=particle.x+13,particle.y+5
+    local translated=remap(nativeParticle,240,160,function(x,y)return x-13,y-5 end)
+    same(frame(particles,drawParticle),translated,'particle projection retains native pixels '..edition)
+    particle.x,particle.y=particle.x-13,particle.y-5
+    local cx=particle.x;particle.scaleX=-1
+    local flipped=remap(nativeParticle,240,160,function(x,y)return 2*cx-x,y end)
+    same(frame(particles,drawParticle),flipped,'particle reflection preserves authored orientation '..edition)
+    particle.scaleX=1;same(frame(particles,drawParticle),nativeParticle,'clearing particle projection restores native pixels '..edition)
+    b.gen3AnimPlaying=false;T.eq(#Sprites._pool,0);T.eq(particle.active,false,'retired native events leave no visible source rows')
+    particles:release()
+    local Trainer=require('src.core.game3.trainer_pic');local Host=require('src.mods.Runtime')
+    game.data.constants.gen3TrainerFront={[135]='tests/fixture_data/assets/fixmon_a_front.png'}
+    game.data.constants.gen3TrainerBack={player={boy=2},images={[2]='tests/fixture_data/assets/fixmon_a_front.png'},anims={[2]={throw={{1,2}}}}}
+    Host.currentMod='portrait_owner';local portrait=assert(Trainer.front(135));Host.currentMod=nil
+    T.eq(portrait.w,64);T.eq(portrait.h,64);T.eq(Trainer.front(135),portrait);T.eq(Trainer.front(136),nil)
+    local portraitPixels=frame(canvas,function()g.draw(portrait.image,20,20)end)
+    same(portraitPixels,baseline,'owned trainer artwork retains native source pixels '..edition)
+    local back=assert(Trainer.back(0));T.eq(back.frames,1)
+    local program=Trainer.backAnims(0);program.throw[1][2]=9
+    T.eq(game.data.constants.gen3TrainerBack.anims[2].throw[1][2],2,'trainer animation queries detach native records')
+    require('src.core.game3.asset_stream').cancelOwner('unrelated_portrait_owner')
+    T.eq(pcall(portrait.image.getDimensions,portrait.image),true,'foreign owner cleanup retains the live trainer texture')
+    collectgarbage('collect')
+    require('src.core.game3.asset_stream').cancelOwner('portrait_owner')
+    T.eq(pcall(portrait.image.getDimensions,portrait.image),false,'unloading releases only the owned trainer image')
+    same(frame(canvas,draw),baseline,'retiring trainer artwork preserves the native battler texture '..edition)
+    texture:release()
+    canvas:release();preview:release();game.stack.states={};f.close();A.reset();Battle._service.release()
+  end
+  outerShader:release();T.finish()
+  local report={passed=true,checks=T.checks,comparisons=comparisons,readbacks=readbacks,
+    backend=backend,renderer=renderer,version=version,vendor=vendor,device=device,
+    nativeBattleSource=nativeSource,engineRoot=root,syntheticBattlerArt=true,nestedNativeText=true,nativePanels=true,nativeParticleProjection=true,nativeTrainerOwnership=true,nativeHealthboxOffsets=true,
+    playerProfilesUsed=false,originalModLoaded=false,gameplayProven=false}
+  local file=assert(io.open(assert(os.getenv('BATTLE_SOURCE_REPORT')),'w'))
+  file:write(require('src.link.Json').encode(report));file:close();love.event.quit(0)
+end
diff --git a/tools/battle-source-runtime/fixture.lua b/tools/battle-source-runtime/fixture.lua
new file mode 100644
index 000000000..c3f08ff7a
--- /dev/null
+++ b/tools/battle-source-runtime/fixture.lua
@@ -0,0 +1,47 @@
+-- Synthetic imported GBA records over the real native constructors. No
+-- external pack, portable encounter API, player profile or ROM is required.
+local F={}
+function F.new(edition)
+  local T=require('tests.modkit')
+  require('src.core.GameVersion').set(edition)
+  local data=T.fixtures.fresh()
+  local row=require('src.mods.Merge').deepCopy(data.pokemon.FIXMON_A)
+  row.id,row.name,row.dex,row.index='CHARMANDER','CHARMANDER',4,4
+  row.types,row.level1Moves,row.learnset,row.evolutions={'NORMAL'},{'MOVE_033'},{},{}
+  row.baseStats.spatk,row.baseStats.spdef=row.baseStats.special,row.baseStats.special
+  row.trueColor=true
+  data.pokemon.CHARMANDER=row
+  data.moves.MOVE_033={id='MOVE_033',index=33,name='TACKLE',power=35,type='NORMAL',accuracy=100,
+    accuracyRaw=255,pp=10,effect='NO_ADDITIONAL_EFFECT',effectChance=0,effectChanceRaw=0}
+  data.constants=data.constants or{}
+  data.constants.gen=3
+  data.constants.speciesOrder={[4]='CHARMANDER'}
+  data.constants.moveOrder={[33]='MOVE_033'}
+  local game={data=data,mods={exports={}},save={party={},options={},player={name='PROBE',id=1000},
+    flags={},inventory={},pokedex={seen={},caught={}},defeatedTrainers={},money=0},
+    stack=setmetatable({},{__index=require('src.core.StateStack')}),
+    input={wasPressed=function()return false end,isDown=function()return false end}}
+  game.stack:init()
+  require('src.render.Font').load(data);require('src.battle.TypeChart').load(data)
+  local original=package.loaded['src.core.Game']
+  local f={game=game,data=data,ids={TACKLE='MOVE_033'}}
+  function f.fresh(name)
+    assert(name=='TACKLE')
+    local player=require('src.pokemon.Pokemon').new(data,'CHARMANDER',30,function(lo)return lo or 0 end)
+    player.hp,player.stats.hp,player.moves=400,400,{{id='MOVE_033',pp=10}}
+    game.save.party={player}
+    local battle=require('src.battle.BattleState').newWild(game,'CHARMANDER',30)
+    battle.enemy.mon.hp,battle.enemy.mon.stats.hp=400,400
+    battle.rng=function(lo)return lo or 0 end
+    return{battle=battle}
+  end
+  function f.close()
+    for _,name in ipairs{'src.core.game3.battle','src.core.game3.pokemon','src.core.game3.mon_anim'}do
+      local module=package.loaded[name]
+      if module and module._service and module._service.release then module._service.release()end
+    end
+    if package.loaded['src.core.Game']==game then package.loaded['src.core.Game']=original end
+  end
+  return f
+end
+return F
diff --git a/tools/battle-source-runtime/host/conf.lua b/tools/battle-source-runtime/host/conf.lua
new file mode 100644
index 000000000..7aea1d29a
--- /dev/null
+++ b/tools/battle-source-runtime/host/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+  t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+  t.window.width,t.window.height=480,320;t.window.vsync=0;t.window.highdpi=false
+  t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+  t.graphics=t.graphics or{};t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/battle-source-runtime/host/main.lua b/tools/battle-source-runtime/host/main.lua
new file mode 100644
index 000000000..1aba9934d
--- /dev/null
+++ b/tools/battle-source-runtime/host/main.lua
@@ -0,0 +1,106 @@
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('BATTLE_SOURCE_ENGINE'))
+-- Keep the absolute frozen engine first when the SDK checks for its Lua
+-- package-path sentinel. Relative fixture IO runs from that same engine.
+package.path=root..'/?.lua;'..root..'/?/init.lua;./?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+function love.load()
+  local T=require('tests.harness').suite('native battle source GPU')
+  local g=love.graphics
+  local Battle=require('src.core.game3.battle')
+  local Ui=require('src.core.game3.battle.ui')
+  local Bg=require('src.core.game3.battle.bg')
+  local baseDraw,uiDraw,bgDraw=Battle.draw,Ui.draw,Bg.draw
+  local nativeBattleSource=debug.getinfo(require('src.battle.BattleState').update,'S').source
+  T.eq(nativeBattleSource,'@'..root..'/src/battle/BattleState.lua','native battle code comes from the frozen engine')
+  local renderer,version,vendor,device=g.getRendererInfo()
+  local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))
+  T.check(renderer:lower():find(backend,1,true)~=nil,'requested actual GPU backend')
+  T.eq(love.filesystem.getIdentity(),os.getenv('POKEPORT_IDENTITY'),'owned QA profile')
+  -- Owned asymmetric art makes battler draws visible; no missing-image
+  -- fallback may stand in for either Pokemon picture in this test.
+  love.filesystem.createDirectory('tests/fixture_data/assets')
+  for side,name in ipairs{'back','front'}do
+    local pixels=love.image.newImageData(64,64)
+    pixels:mapPixel(function(x,y)
+      if x<7 or y<5 or x>56 or y>57 then return 0,0,0,0 end
+      if y<20 and x<37 then return 1,0,91/255,1 end
+      if x>40 and y>35 then return 0,1,125/255,1 end
+      return side==1 and .2 or .7,.3,side==1 and .9 or .1,1
+    end)
+    pixels:encode('png','tests/fixture_data/assets/fixmon_a_'..name..'.png');pixels:release()
+  end
+  local readbacks,comparisons=0,0
+  local function read(canvas)
+    local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData()
+    local bytes=data:getString();data:release();readbacks=readbacks+1;return bytes
+  end
+  local function frame(canvas,fn)
+    g.push('all');g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.clear(0,0,0,0)
+    g.setColor(1,1,1,1);fn();g.pop();return read(canvas)
+  end
+  local function same(a,b,label)comparisons=comparisons+1;T.eq(a,b,label)end
+  for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+    local f=require('tools.battle-source-runtime.fixture').new(edition)
+    local game=f.game;package.loaded['src.core.Game']=game
+    game.data.constants=game.data.constants or{}
+    game.data.constants.speciesOrder={[4]='CHARMANDER'}
+    game.data.constants.moveOrder={[33]=f.ids.TACKLE}
+    local b=f.fresh('TACKLE').battle
+    game.stack:push(b);b.phase='menu';b.queue={};b.current=nil
+    b.showPlayerBack,b.showEnemyTrainer=false,false;b.frlgIntro=nil;b.introSlide=0
+    local canvas=g.newCanvas(240,160,{format='rgba8',dpiscale=1,msaa=0})
+    local baseline=frame(canvas,function()b:_drawNative()end)
+    T.check(baseline:find(string.char(255,0,91,255),1,true)~=nil,'asymmetric fixture pixels reach the native GPU frame')
+    local sourceCalls,uiCalls,backgroundCalls=0,0,0
+    Battle.draw=function(view,w,h)sourceCalls=sourceCalls+1;T.eq(w,240);T.eq(h,160);return baseDraw(view,w,h)end
+    Ui.draw=function(w,h)uiCalls=uiCalls+1;return uiDraw(w,h)end
+    Bg.draw=function(...)backgroundCalls=backgroundCalls+1;return bgDraw(...)end
+    same(frame(canvas,function()b:draw()end),baseline,'wrapped native battle pixels match native rendering '..edition)
+    T.eq(sourceCalls,1);T.eq(uiCalls,1);T.eq(backgroundCalls,1)
+    Bg.draw=function()
+      g.setColor(.4,.1,.7,1);g.rectangle('fill',0,0,240,160);return true
+    end
+    local replaced=frame(canvas,function()b:draw()end)
+    T.check(replaced~=baseline,'background replacement reaches actual GPU pixels')
+    -- Native text/menu pass still owns the opaque bottom rows.
+    same(replaced:sub(240*128*4+1),baseline:sub(240*128*4+1),'native command UI survives background replacement '..edition)
+    local before=Battle.getState();T.eq(before,Battle.getState())
+    T.eq(before.player.mon.hp,b.player.mon.hp)
+    local bound=g.getCanvas();local depth=g.getStackDepth and g.getStackDepth()
+    Battle.draw=function()g.push();g.setCanvas(canvas);error('owned GPU callback failure')end
+    local ok,why=pcall(b.draw,b);T.eq(ok,false);T.check(tostring(why):find('owned GPU callback failure',1,true)~=nil)
+    T.eq(g.getCanvas(),bound);if depth then T.eq(g.getStackDepth(),depth)end
+    Battle.draw,Ui.draw,Bg.draw=baseDraw,uiDraw,bgDraw
+    local rendererState=require('src.render.Renderer')
+    local captures=0
+    Bg.draw=function(...)captures=captures+1;return bgDraw(...)end
+    rendererState.frameSerial=(rendererState.frameSerial or 0)+1
+    same(frame(canvas,function()baseDraw(game);b:draw()end),baseline,'captured battle keeps native pixels '..edition)
+    T.eq(captures,1,'capture and screen share one native field draw')
+    rendererState.frameSerial=rendererState.frameSerial+1
+    same(frame(canvas,function()uiDraw();b:draw()end),baseline,'UI capture keeps native pixels '..edition)
+    T.eq(captures,2,'UI capture and screen share one native field draw')
+    rendererState.frameSerial=rendererState.frameSerial+1
+    same(frame(canvas,function()b:draw()end),baseline,'next frame draws the native battle again '..edition)
+    T.eq(captures,3,'capture suppression ends at the next renderer frame')
+    rendererState.frameSerial=rendererState.frameSerial+1
+    local preview=g.newCanvas(240,160,{format='rgba8',dpiscale=1,msaa=0})
+    same(frame(canvas,function()
+      g.setCanvas(preview);baseDraw(game);g.setCanvas(canvas);b:draw()
+    end),baseline,'offscreen capture cannot suppress the main battle surface '..edition)
+    T.eq(captures,5,'different render targets each receive their own native field pass')
+    preview:release();Bg.draw=bgDraw
+    game.stack:pop();Battle.reset();canvas:release();f.close();require('src.core.Game3').release()
+  end
+  T.finish()
+  local report={passed=true,checks=T.checks,readbacks=readbacks,comparisons=comparisons,
+    backend=backend,renderer=renderer,version=version,vendor=vendor,device=device,
+    playerProfilesUsed=false,gameplayProven=false,originalModLoaded=false,
+    syntheticBattlerArt=true,
+    engineRoot=root,nativeBattleSource=nativeBattleSource,
+    scope='Actual native BattleState and Gen3Battle draws over synthetic imported Pokemon; five GBA editions. Source/UI/background wrappers and GPU error restoration; no original-mod boot or gameplay claim.'}
+  local file=assert(io.open(assert(os.getenv('BATTLE_SOURCE_REPORT')),'w'))
+  file:write(require('src.link.Json').encode(report));file:close()
+  print('NATIVE_BATTLE_SOURCE_GPU_PASS',readbacks,comparisons);love.event.quit(0)
+end
diff --git a/tools/battle-source-runtime/lifecycle-check.lua b/tools/battle-source-runtime/lifecycle-check.lua
new file mode 100644
index 000000000..cdeed1911
--- /dev/null
+++ b/tools/battle-source-runtime/lifecycle-check.lua
@@ -0,0 +1,56 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local fixture=require('tools.battle-source-runtime.fixture').new('emerald')
+local native=fixture.game;package.loaded['src.core.Game']=native
+local state=fixture.fresh('TACKLE').battle;state.enter=false;native.stack:push(state)
+local Json=require('src.link.Json')
+local api=tonumber(os.getenv('SESSION_RUNTIME_API'))or require('src.core.Version').modApi
+local files={};local function mod(id,priority,body)
+ files['mods/'..id..'/manifest.json']=Json.encode({id=id,name=id,version='1.0.0',api=api,
+  entry='main.lua',games={'gen3'},priority=priority,permissions={'engine_internals'}})
+ files['mods/'..id..'/main.lua']=body
+end
+mod('battle_owner',100,[[local mod=...;local S=require('src.core.game3.battle')
+ local update,draw=S.update,S.draw;mod.exports.baseUpdate=update;mod.exports.baseDraw=draw
+ mod.exports.ticks=0;mod.exports.draws=0
+ S.update=function(dt,game)
+  mod.exports.game=game;mod.exports.ticks=mod.exports.ticks+1
+  update(dt,game);return update(dt,game)
+ end
+ S.draw=function(game)mod.exports.draws=mod.exports.draws+1;draw(game);return draw(game)end
+]])
+mod('battle_bad',200,[[local S=require('src.core.game3.battle')
+ S.update=function()error('failed battle update survived')end
+ S.draw=function()error('failed battle draw survived')end
+ error('intentional battle entry failure')
+]])
+mod('battle_native_peer',0,[[local mod=...;mod.events:on('game.ready',function(p)mod.exports.game=p.game end)]])
+local run=T.sdk.loadMods({'mods/battle_owner','mods/battle_bad','mods/battle_native_peer'},
+ {fs=T.sdk.memfs(files),data=T.fixtures.fresh()})
+T.eq(#run.errors,1);local owner=assert(run.loader.exports.battle_owner)
+native.mods=run.loader;run.loader.game=native
+local S=require('src.core.game3.battle');local G=require('src.core.Game3')
+T.eq(G._usesCallbacks('battle_owner'),true,'the battle namespace selects source game callback identities')
+T.eq(G._usesCallbacks('battle_bad'),false,'failed entry retires callback identity selection')
+T.eq(G._usesCallbacks('battle_native_peer'),false)
+run.loader.events:emit('game.ready',{game=native})
+T.eq(run.loader.exports.battle_native_peer.game,native)
+local ticks=0;state.phase='QA_IDLE';state.tickFx=function()
+ ticks=ticks+1;T.eq(G._callbackOwner(),nil,'native method bodies do not inherit source callback ownership')
+end
+state:update(1/60);T.eq(ticks,1);T.eq(owner.ticks,1);T.eq(owner.game,G.forNative(native))
+T.eq(G._callbackOwner(),nil,'phase completion restores the caller owner')
+local old=S.getState();local rawParty=native.save.party
+local Gen3=require('src.battle.Gen3Battle');local originalDraw=Gen3.draw;local draws=0
+state.wideLayout=function()return false end;state.gen3Layout=function()return true end
+Gen3.draw=function()draws=draws+1;T.eq(G._callbackOwner(),nil)end
+require('src.render.Renderer').frameSerial=51
+state:draw();T.eq(draws,1);T.eq(owner.draws,1)
+require('src.mods.Loader').teardown()
+T.eq(S.update,owner.baseUpdate);T.eq(S.draw,owner.baseDraw)
+T.eq(G._usesCallbacks('battle_owner'),false);T.raises(function()old.player.mon.hp=1 end,'retired','loader teardown retires held battle observations')
+T.eq(native.stack:top(),state,'observer teardown cannot abort a native admission')
+T.eq(native.save.party,rawParty,'observer teardown leaves native party ownership intact')
+state:update(1/60);T.eq(ticks,2);T.eq(owner.ticks,1,'unwound wrapper is no longer driven')
+Gen3.draw=originalDraw;run.release()
+T.finish('native battle phase SDK retirement and native peer API '..api)
diff --git a/tools/battle-source-runtime/ownership-check.lua b/tools/battle-source-runtime/ownership-check.lua
new file mode 100644
index 000000000..f90fa4e3b
--- /dev/null
+++ b/tools/battle-source-runtime/ownership-check.lua
@@ -0,0 +1,99 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local S=require('src.core.game3.battle');local Ui=require('src.core.game3.battle.ui')
+local Background=require('src.core.game3.battle.bg')
+T.eq(package.loaded['src.core.Game'],nil);T.eq(S.isActive(),false)
+local base={update=S.update,draw=S.draw,pump=Ui.pump,uiDraw=Ui.draw,bg=Background.draw}
+local Gen3=require('src.battle.Gen3Battle');local originalDraw,originalField=Gen3.draw,Gen3.drawField
+local Renderer=require('src.render.Renderer')
+local G=require('src.core.Game3')
+for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+ S._service.release();local f=require('tools.battle-source-runtime.fixture').new(edition)
+ local game=f.game;package.loaded['src.core.Game']=game
+ local state=f.fresh('TACKLE').battle;state.enter=false;game.stack:push(state)
+ state.phase='QA_IDLE';local ticks,draws,fields,sourceTicks=0,0,0,0
+ state.tickFx=function()ticks=ticks+1;T.eq(G._callbackOwner(),nil)end
+ Gen3.draw=function(screen)draws=draws+1;T.eq(G._callbackOwner(),nil);screen:drawBattleField()end
+ Gen3.drawField=function()fields=fields+1;T.eq(G._callbackOwner(),nil)end
+ local model=S.getState();T.eq(S.getState(),model)
+ S.update=function(dt,view)
+  sourceTicks=sourceTicks+1;T.eq(G.native(view),game)
+  state:update(dt);base.update(dt,view);return base.update(dt,view)
+ end
+ state:update(1/60);T.eq(ticks,1);T.eq(sourceTicks,1)
+ S.update=base.update
+ local tick=state.tickFx;state.tickFx=function()error('native phase body failure')end
+ S.update=function()pcall(base.update);return base.update()end
+ T.raises(function()state:update(1/60)end,'native phase body failure')
+ state.tickFx=tick;S.update=base.update;state:update(1/60);T.eq(ticks,2)
+ local save=game.save
+ S.update=function()game.save={};return base.update()end
+ state:update(1/60);T.eq(ticks,2,'a changed save cancels the already queued native step')
+ game.save=save;T.eq(S.isActive(),true)
+ T.raises(function()model.player.mon.hp=1 end,'retired','restoring a prior save cannot revive a retired view')
+ local overlay={}
+ S.update=function()game.stack:push(overlay);return base.update()end
+ state:update(1/60);T.eq(ticks,2);game.stack:pop();S.update=base.update
+ Ui.pump=function()game.stack:push(overlay);return base.pump()end
+ state:update(1/60);T.eq(ticks,2,'UI hooks must recheck the admission at the inner native body')
+ game.stack:pop();Ui.pump=base.pump
+ Ui.pump=function()game.save={};return base.pump()end
+ state:update(1/60);T.eq(ticks,2,'UI hooks cannot retain a native step through save replacement')
+ game.save=save;Ui.pump=base.pump
+ local current=S.getState();local snap=require('src.compat.gen1.TableIteration').snapshot(current)
+ T.eq(snap.player,current.player);T.eq(snap.player.mon,current.player.mon)
+ local monSnap=require('src.compat.gen1.TableIteration').snapshot(current.player.mon)
+ T.eq(monSnap.species,4);T.eq(monSnap.hp,state.player.mon.hp)
+ monSnap.hp=1;T.neq(state.player.mon.hp,1)
+ local P=require('src.core.game3.pokemon');local Motion=require('src.core.game3.mon_anim')
+ T.eq(P.speciesFromName('CHARMANDER'),4)
+ local moving=assert(Motion.newSprite(4))
+ local order=game.data.constants.speciesOrder
+ S.update=function()game.data.constants.speciesOrder={};return base.update()end
+ state:update(1/60);T.eq(ticks,2,'replaced cartridge identity tables retire a pending native command')
+ T.eq(Motion.step(moving),false,'a presentation player cannot retain a retired cartridge identity')
+ game.data.pokemon.QA_SPARSE={index=277,name='QA_SPARSE'}
+ game.data.constants.speciesOrder={[4]='CHARMANDER',[277]='QA_SPARSE'}
+ T.eq(P.speciesFromName('QA_SPARSE'),277,'new Pokemon queries rebuild from the current cartridge order')
+ game.data.constants.speciesOrder=order;game.data.pokemon.QA_SPARSE=nil;S.update=base.update
+ T.eq(P.speciesFromName('CHARMANDER'),4)
+ T.raises(function()current.player.mon.hp=1 end,'retired')
+ Renderer.frameSerial=(Renderer.frameSerial or 0)+1
+ T.eq(base.draw(game),true);T.eq(draws,1);T.eq(fields,1)
+ state:draw();state:draw();T.eq(draws,1,'capturing a native frame suppresses its repeated screen pass')
+ Renderer.frameSerial=Renderer.frameSerial+1;state:draw();T.eq(draws,2)
+ Renderer.frameSerial=Renderer.frameSerial+1;T.eq(Ui.draw(),true);state:draw();T.eq(draws,3,'UI capture shares native frame ownership')
+ Renderer.frameSerial=Renderer.frameSerial+1
+ S.draw=function()game.save={};return base.draw()end
+ state:draw();T.eq(draws,3,'a stale outer draw cannot reach the native UI')
+ game.save=save;S.draw=base.draw
+ Renderer.frameSerial=Renderer.frameSerial+1
+ Ui.draw=function()game.save={};return base.uiDraw()end
+ state:draw();T.eq(draws,3,'a stale inner UI draw cannot reach the native renderer')
+ game.save=save;Ui.draw=base.uiDraw
+ Renderer.frameSerial=Renderer.frameSerial+1
+ Background.draw=function()game.save={};return base.bg()end
+ state:draw();T.eq(fields,3,'a stale background hook cannot consume the native field pass')
+ game.save=save;Background.draw=base.bg
+ local live=S.getState();S._service.release()
+ T.eq(game.stack:top(),state);T.raises(function()live.player.mon.hp=1 end,'retired')
+ local final=S.getState();state.result='lose';game.stack:pop()
+ T.eq(S.getResult(),'lose');T.eq(S.getState(),final)
+ local finalSnapshot=require('src.compat.gen1.TableIteration').snapshot(final)
+ T.eq(finalSnapshot.result,'lose');T.eq(finalSnapshot.player,final.player)
+ f.close();G.release()
+end
+Gen3.draw,Gen3.drawField=originalDraw,originalField
+-- A typed iterator registration cannot retain its own weak key through a
+-- closure that reaches the environment's public view.
+local weak=setmetatable({},{__mode='v'})
+do
+ local data={constants={},pokemon={},moves={}}
+ local game={data=data,save={party={}}};local screen={kind='wild'}
+ local e=require('src.compat.gen1.BattleView').new(game,screen,function()return true end)
+ weak[1],weak[2],weak[3],weak[4]=e.view,game,data,screen
+end
+for _=1,4 do collectgarbage('collect')end
+for i=1,4 do T.eq(weak[i],nil,'unused typed observations remain collectible: '..i)end
+T.finish('native battle admission guards, capture ownership and typed iteration')
diff --git a/tools/companion-runtime/host/conf.lua b/tools/companion-runtime/host/conf.lua
new file mode 100644
index 000000000..7aea1d29a
--- /dev/null
+++ b/tools/companion-runtime/host/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+  t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+  t.window.width,t.window.height=480,320;t.window.vsync=0;t.window.highdpi=false
+  t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+  t.graphics=t.graphics or{};t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/companion-runtime/host/main.lua b/tools/companion-runtime/host/main.lua
new file mode 100644
index 000000000..eb878d344
--- /dev/null
+++ b/tools/companion-runtime/host/main.lua
@@ -0,0 +1,195 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('BATTLE_SOURCE_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;./?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+function love.load()
+  local T=require('tests.harness').suite('native companion rendering GPU')
+  local A=require('src.core.game3.battle.anim')
+  local Battle=require('src.core.game3.battle')
+  local Scope=require('src.render.GraphicsScope')
+  local g=love.graphics
+  local nativeSource=debug.getinfo(require('src.battle.BattleState').update,'S').source
+  T.eq(nativeSource,'@'..root..'/src/battle/BattleState.lua')
+  local renderer,version,vendor,device=g.getRendererInfo()
+  local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))
+  T.check(renderer:lower():find(backend,1,true)~=nil,'actual requested GPU backend')
+  T.eq(love.filesystem.getIdentity(),os.getenv('POKEPORT_IDENTITY'))
+  love.filesystem.createDirectory('tests/fixture_data/assets')
+  local pixels=love.image.newImageData(64,64)
+  pixels:mapPixel(function(x,y)
+    if x<7 or y<5 or x>56 or y>57 then return 0,0,0,0 end
+    if y<20 and x<37 then return 1,0,91/255,1 end
+    if x>40 and y>35 then return 0,1,125/255,1 end
+    return .2,.3,.9,1
+  end)
+  for _,side in ipairs{'back','front'}do pixels:encode('png','tests/fixture_data/assets/fixmon_a_'..side..'.png')end
+  pixels:release()
+  local fontPixels=love.image.newImageData(128,64)
+  fontPixels:mapPixel(function(x,y)
+    local xx,yy=x%8,y%8
+    if xx==1 or yy==2 and xx<6 then return 0,0,0,1 end
+    if xx==2 or yy==3 and xx>1 and xx<7 then return 1,1,1,1 end
+    return 0,0,0,0
+  end)
+  fontPixels:encode('png','tests/fixture_data/assets/fix_font.png');fontPixels:release()
+  local comparisons,readbacks=0,0
+  local function read(canvas)
+    local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData()
+    local bytes=data:getString();data:release();readbacks=readbacks+1;return bytes
+  end
+  local function frame(canvas,draw)
+    local ok,why=Scope.call(function()
+      g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.clear(0,0,0,0);g.setColor(1,1,1,1);draw()
+    end)
+    assert(ok,why);return read(canvas)
+  end
+  local function same(a,b,label,tolerance)
+    comparisons=comparisons+1
+    if not tolerance then return T.eq(a,b,label)end
+    local error=0
+    for i=1,#a do error=math.max(error,math.abs(a:byte(i)-b:byte(i)))end
+    if error>tolerance then
+      local count=0
+      for i=1,#a,4 do
+        local bad=false;for c=0,3 do if math.abs(a:byte(i+c)-b:byte(i+c))>tolerance then bad=true end end
+        if bad then
+          print('PIXEL_ORACLE_DIFFERENCE',label,((i-1)/4)%160,math.floor((i-1)/4/160),
+            string.format('%d,%d,%d,%d',a:byte(i,i+3)),string.format('%d,%d,%d,%d',b:byte(i,i+3)));count=count+1;if count==4 then break end
+        end
+      end
+      print('MAX_PIXEL_ERROR',error)
+    end
+    T.check(#a==#b and error<=tolerance,label)
+  end
+  -- Independent pixel oracle: inverse-map output pixel centres into the
+  -- already rendered native image, without using graphics transforms.
+  local function remap(bytes,width,height,map,alpha)
+    local rows={}
+    for y=0,height-1 do
+      local row={}
+      for x=0,width-1 do
+        local sx,sy=map(x+.5,y+.5);sx,sy=math.floor(sx),math.floor(sy)
+        local value='\0\0\0\0'
+        if sx>=0 and sx<width and sy>=0 and sy<height then
+          local at=(sy*width+sx)*4+1
+          if alpha then
+            local values={};for c=0,3 do values[c+1]=math.floor(bytes:byte(at+c)*alpha+.5)end
+            value=string.char(unpack(values))
+          else value=bytes:sub(at,at+3)end
+        end
+        row[#row+1]=value
+      end
+      rows[#rows+1]=table.concat(row)
+    end
+    return table.concat(rows)
+  end
+  local outerShader=g.newShader('vec4 effect(vec4 c, Image t, vec2 uv, vec2 p) { return Texel(t,uv)*c; }')
+  for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+    A.reset();Battle._service.release()
+    local f=require('tools.battle-source-runtime.fixture').new(edition)
+    local game=f.game;package.loaded['src.core.Game']=game
+    local b=f.fresh('TACKLE').battle;b.enter=false;game.stack:push(b);b.phase='QA_IDLE'
+    b.introSlide=0;b.frlgIntro=nil
+    local canvas=g.newCanvas(160,144,{format='rgba8',dpiscale=1,msaa=0})
+    local preview=g.newCanvas(160,144,{format='rgba8',dpiscale=1,msaa=0})
+    -- This host bypasses the application's pixel-art graphics setup. Set
+    -- the owned fixture texture explicitly so the independent nearest-pixel
+    -- oracle does not compare against LOVE's default linear interpolation.
+    b:battlerPic(b.player):setFilter('nearest','nearest')
+    local function draw()return b:drawBattlerPic(b.player,20,20,1)end
+    local baseline=frame(canvas,draw)
+    T.check(baseline:find(string.char(255,0,91,255),1,true)~=nil,'real asymmetric art reaches the native draw')
+    local p=A.present(0)
+    same(frame(canvas,draw),baseline,'observing a pose preserves native pixels '..edition)
+    local expected=remap(baseline,160,144,function(x,y)return x-13,y-5 end)
+    p.ox,p.oy=13,5
+    same(frame(canvas,draw),expected,'source offsets compose with native sprite draw '..edition)
+    T.check(expected~=baseline);p.ox,p.oy=nil,nil
+    local img=b:battlerPic(b.player);local w,h=img:getDimensions();local cx,cy=20+w/2,20+h/2
+    expected=remap(baseline,160,144,function(x,y)
+      -- A clockwise quarter turn exchanges axes; the horizontal reflection
+      -- then reverses the vertical axis in output space.
+      return cx-(y-cy),cy-(x-cx)/2
+    end,.5)
+    p.hFlip,p.rotation,p.scale,p.sx,p.sy,p.alpha=true,math.pi/2,.5,2,4,.5
+    same(frame(canvas,draw),expected,'flip, rotation, scale and alpha preserve authored orientation '..edition,1)
+    p.hFlip,p.rotation,p.scale,p.sx,p.sy,p.alpha=nil,nil,nil,nil,nil,nil
+    same(frame(canvas,draw),baseline,'clearing source overrides restores native pixels '..edition)
+    p.visible=false;local hidden=frame(canvas,draw);T.check(hidden~=baseline);T.eq(hidden,string.rep('\0',160*144*4))
+    p.visible=nil
+    local old=b.drawBattlerPicAt;p.ox=1
+    local ok,why=Scope.call(function()
+      g.setCanvas(canvas);g.setShader(outerShader)
+      local depth=g.getStackDepth()
+      b.drawBattlerPicAt=function()g.push();g.setCanvas(preview);error('native sprite draw failure')end
+      local success,err=pcall(draw);T.eq(success,false);T.check(tostring(err):find('native sprite draw failure',1,true)~=nil)
+      T.eq(g.getCanvas(),canvas);T.eq(g.getShader(),outerShader);T.eq(g.getStackDepth(),depth)
+    end)
+    assert(ok,why);b.drawBattlerPicAt=old;p.ox=nil
+    local base={.8,.2,.35}
+    for _,effect in ipairs{'invert','fade_white','fade_black','darken','grayscale','custom_blend'}do
+      A.setScreenEffect({type=effect,coeff=.5,targetColor={.2,.4,.6}})
+      frame(canvas,function()
+        g.setShader(outerShader);T.eq(A.beginScreenEffect(),true)
+        local active=g.getShader();T.neq(active,outerShader)
+        T.eq(A.beginScreenEffect(),true);T.eq(g.getShader(),active,'repeated begin does not nest')
+        local nested=Scope.call(function()
+          T.eq(A.beginScreenEffect(),true);T.eq(A.endScreenEffect(),true);T.eq(g.getShader(),active)
+        end);T.eq(nested,true)
+        g.setColor(base[1],base[2],base[3],1);g.rectangle('fill',0,0,160,144)
+        T.eq(A.endScreenEffect(),true);T.eq(g.getShader(),outerShader)
+      end)
+      local data=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData();readbacks=readbacks+1
+      local actual={data:getPixel(10,10)};data:release()
+      local luma=base[1]*.299+base[2]*.587+base[3]*.114
+      for channel=1,3 do
+        local target=effect=='fade_white'and 1 or(effect=='grayscale'and luma or(effect=='custom_blend'and({.2,.4,.6})[channel]or 0))
+        local value=effect=='invert'and 1-base[channel]or(base[channel]+target)/2
+        T.check(math.abs(actual[channel]-value)<2/255,'screen effect GPU colour '..effect..' '..edition)
+      end
+      T.eq(actual[4],1)
+    end
+    local priorShader=g.getShader();local depth=g.getStackDepth();local priorCanvas=g.getCanvas()
+    ok,why=Scope.call(function()A.beginScreenEffect();g.push();g.setCanvas(preview);error('effect failure')end)
+    T.eq(ok,false);T.check(tostring(why):find('effect failure',1,true)~=nil)
+    T.eq(g.getShader(),priorShader);T.eq(g.getStackDepth(),depth);T.eq(g.getCanvas(),priorCanvas)
+    A.setScreenEffect(nil);T.eq(A.beginScreenEffect(),false)
+    -- Nested source text must restore the outer native two-tone uniforms.
+    local Font=require('src.render.Font');local SourceFont=require('src.ui.game3.frlg_font')
+    game.data.font.pages={main={image='tests/fixture_data/assets/fix_font.png',base=0x80,
+      glyphWidth=8,glyphHeight=8,glyphsPerRow=16,preTinted=true}}
+    Font.load(game.data)
+    local sample=love.image.newImageData(1,1);sample:setPixel(0,0,0,0,0,1)
+    local texture=g.newImage(sample);sample:release();texture:setFilter('nearest','nearest')
+    local function pixelAt(x)return function()g.draw(texture,x,100)end end
+    local expectedText=frame(canvas,function()
+      Font.beginTwoTone({1,0,0,1},{0,1,0,1});pixelAt(5)();pixelAt(10)();Font.endTwoTone()
+    end)
+    T.eq(expectedText:sub((100*160+5)*4+1,(100*160+5)*4+4),string.char(255,0,0,255),'native outer shader produces red ink')
+    local actualText=frame(canvas,function()
+      Font.beginTwoTone({1,0,0,1},{0,1,0,1});pixelAt(5)()
+      T.eq(SourceFont.measure('AB',{letterSpacing=2}),Font.width('AB')+2)
+      local oldCanvas,oldShader,depth=g.getCanvas(),g.getShader(),g.getStackDepth()
+      SourceFont.draw('AB',5,5,{colors={fg={0,0,1,1},shadow={1,1,0,1}},letterSpacing=2})
+      T.eq(g.getCanvas(),oldCanvas);T.eq(g.getShader(),oldShader);T.eq(g.getStackDepth(),depth)
+      pixelAt(10)();Font.endTwoTone()
+    end)
+    -- Compare only the two independent sample pixels; text occupies other rows.
+    local function pixel(bytes,x,y)local at=(y*160+x)*4+1;return bytes:sub(at,at+3)end
+    same(pixel(actualText,5,100),pixel(expectedText,5,100),'outer ink before nested text '..edition)
+    same(pixel(actualText,10,100),pixel(expectedText,10,100),'outer ink after nested text '..edition)
+    T.eq(pixel(actualText,6,5),string.char(0,0,255,255),'real source text paints native ink '..edition)
+    T.eq(pixel(actualText,7,5),string.char(255,255,0,255),'real source text retains native shadow '..edition)
+    T.eq(SourceFont._spec.nativeLayout,(edition=='firered'or edition=='leafgreen')and'frlg'or'rs')
+    texture:release()
+    canvas:release();preview:release();game.stack.states={};f.close();A.reset();Battle._service.release()
+  end
+  outerShader:release();T.finish()
+  local report={passed=true,checks=T.checks,comparisons=comparisons,readbacks=readbacks,
+    backend=backend,renderer=renderer,version=version,vendor=vendor,device=device,
+    nativeBattleSource=nativeSource,engineRoot=root,syntheticBattlerArt=true,nestedNativeText=true,
+    playerProfilesUsed=false,originalModLoaded=false,gameplayProven=false}
+  local file=assert(io.open(assert(os.getenv('BATTLE_SOURCE_REPORT')),'w'))
+  file:write(require('src.link.Json').encode(report));file:close();love.event.quit(0)
+end
diff --git a/tools/companion-terrain/lifecycle-check.lua b/tools/companion-terrain/lifecycle-check.lua
new file mode 100644
index 000000000..fe5331eaf
--- /dev/null
+++ b/tools/companion-terrain/lifecycle-check.lua
@@ -0,0 +1,47 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local Json=require('src.link.Json')
+local api=tonumber(os.getenv('SESSION_RUNTIME_API'))or require('src.core.Version').modApi
+require('src.core.GameVersion').set('emerald')
+local files={}
+for _,id in ipairs{'terrain_owner','native_peer','failed_terrain_owner'}do
+  files['mods/'..id..'/manifest.json']=Json.encode({id=id,name=id,version='1.0.0',api=api,
+    entry='main.lua',games={'gen3'},permissions={'engine_internals'}})
+end
+files['mods/terrain_owner/main.lua']=[[
+  local mod=...;local C=require('src.core.game3.collision');local E=require('src.core.game3.encounters')
+  mod.exports.grass=C.isGrass;mod.exports.tableFor=E.tableFor
+  C.isGrass=function(...)return mod.exports.grass(...)end
+]]
+files['mods/native_peer/main.lua']=[[
+  local mod=...;mod.events:on('game.ready',function(p)mod.exports.game=p.game end)
+]]
+files['mods/failed_terrain_owner/main.lua']=[[
+  local E=require('src.core.game3.encounters')
+  E.tableFor=function()error('failed owner survived')end
+  error('intentional terrain entry failure')
+]]
+local run=T.sdk.loadMods({'mods/terrain_owner','mods/native_peer','mods/failed_terrain_owner'},
+  {fs=T.sdk.memfs(files),data=T.fixtures.fresh()})
+T.eq(#run.errors,1)
+local f=require('tools.map-runtime.fixture').new('emerald')
+local g,w=f.game,f.world;g.save={player={},flags={}};g.mods=run.loader
+w.player={cellX=0,cellY=0,elevation=6};w.entities={w.player}
+g.data.pokemon={COMMON={index=1}};g.data.constants.speciesOrder={[1]='COMMON'}
+g.data.encounters={NATIVE_A={grass={rate=21,slots={{species='COMMON',min=3,max=5}}}}}
+package.loaded['src.core.Game']=g;run.loader.game=g
+local E=require('src.core.game3.encounters');local C=require('src.core.game3.collision')
+local owner=run.loader.exports.terrain_owner
+T.eq(E.tableFor,owner.tableFor,'failed entry rolls back the query it replaced')
+T.eq(E.tableFor(f.mapId).land.slots[1].species,1)
+T.eq(C.isGrass(0,0),f.map:isGrassCell(0,0))
+run.loader.events:emit('game.ready',{game=g})
+T.eq(run.loader.exports.native_peer.game,g,'native peer retains the actual game identity')
+require('src.mods.Loader').teardown()
+T.eq(C.isGrass,owner.grass,'teardown restores the successful owner wrapper')
+T.eq(E.tableFor(f.mapId).land.rate,21,'native encounter data outlives source wrapper retirement')
+T.eq(g.overworld,w);T.eq(g.data.maps.NATIVE_A,f.map.def)
+require('src.core.game3.map').release();C.release();f.views:release();run.release()
+package.loaded['src.core.Game']=nil
+T.finish('terrain SDK rollback and native peer API '..api)
diff --git a/tools/field-collision/check.lua b/tools/field-collision/check.lua
new file mode 100644
index 000000000..8d0d4cfbe
--- /dev/null
+++ b/tools/field-collision/check.lua
@@ -0,0 +1,101 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+love=require('tests.love_stub')
+local T=require('tests.harness')
+local C=require('src.core.game3.collision')
+local Map=require('src.core.game3.map')
+local Native=require('src.world.Collision')
+local Tiles=require('src.render.Gen3Tiles')
+local Behavior=require('src.compat.gen1.MetatileBehavior')
+T.eq(package.loaded['src.core.Game'],nil,'collision import does not bootstrap a game')
+T.eq(C.behavior(0,0),nil);T.eq(C.canEnter(nil,0,0),false)
+local previous=package.loaded['src.core.Game']
+for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+  local f=require('tools.map-runtime.fixture').new(edition)
+  local g,w,field=f.game,f.world,f.map
+  w.player={cellX=0,cellY=0,px=0,py=0,elevation=6,surfing=false}
+  w.entities={w.player};g.save={player={},flags={}}
+  package.loaded['src.core.Game']=g
+  local def=assert(Map.currentDef())
+  T.eq(C._mapId,def.id);T.eq(C._mapDef,def);T.eq(C._widthCells,4);T.eq(C._heightCells,2)
+  T.eq(C.inBounds(3,0),false,'art padding is not native walkable space')
+  T.eq(C.cell(3,0),255);T.eq(C.elevationAt(3,0),nil)
+  T.eq(C._grid,C._grid,'classified array is cached by owned layout revision')
+  local sets=g.data.map_tilesets;local pair=g.data.tilesets[field.def.tileset]
+  local tiles=Tiles.new({primary=sets[pair.primaryKey],secondary=sets[pair.secondaryKey]},g.data.constants.gen3Layout)
+  for y=0,1 do for x=0,2 do
+    local raw=tiles:sourceBehavior(field:blockAt(x,y))
+    T.eq(C.behavior(x,y),Behavior.fromRaw(edition,raw),'source behavior stays distinct from native numbering')
+    T.eq(C.elevationAt(x,y),field:cellElevation(x,y))
+    for _,dir in ipairs({'up','down','left','right'})do
+      local actual,why=C.canEnter(g,x,y,{dir=dir})
+      local expected,reason=Native.mayEnter(field,w.entities,w.player,x,y,dir)
+      T.eq(actual,expected);T.eq(why,reason)
+    end
+  end end
+  T.eq(C.warpAt(0,1),nil,'header-only warps on ordinary ground remain inactive')
+  local bank=sets[pair.primaryKey]
+  local key=bank.sourceAttributeBytes==4 and 'sourceAttributes'or'attributes'
+  local originalBytes=bank[key];local offset=bank.sourceAttributeBytes*2
+  bank[key]=originalBytes:sub(1,offset)..string.char(105)..originalBytes:sub(offset+2)
+  local warp=assert(C.warpAt(0,1))
+  T.eq(warp.destMap,f.neighborId,'active observations preserve canonical warp destinations')
+  T.eq(C._warps[1024],warp)
+  bank[key]=originalBytes;T.eq(C.warpAt(0,1),nil,'behavior changes retire a formerly live warp observation')
+  local old=C._grid;field:setGen3Cells({{x=0,y=0,mid=1,coll=0,elev=3}})
+  T.eq(C.elevationAt(0,0),3);T.check(C._grid~=old,'native terrain edits invalidate classified observations')
+  T.eq(C.behavior(0,0),Behavior.fromRaw(edition,tiles:sourceBehavior(1)))
+  local mid,pairId=Map.worldMidAt(3,0,def)
+  local neighbor=Map.neighborList[1].def
+  T.eq(pairId,neighbor.pair)
+  T.eq(C.worldBehavior(3,0),C.behaviorOn(neighbor,0,1),'connected behavior follows native extent and offset')
+  T.eq(C.worldBehavior(-1,-1),C.behaviorOn(def,-1,-1)or C.behaviorOn(def,0,1),
+    'border observations use the current source bank')
+  local actor=w.player;local x,y,elev,surf=actor.cellX,actor.cellY,actor.elevation,actor.surfing
+  C.canEnter(g,0,1,{fromX=1,fromY=1,elevation=3,surfing=true,dir='left'})
+  T.eq(actor.cellX,x);T.eq(actor.cellY,y);T.eq(actor.elevation,elev);T.eq(actor.surfing,surf)
+  T.eq(C.canEnter(g,0/0,0),false);T.eq(C.canEnter(g,1.5,0),false)
+  T.eq(C.behavior(0/0,0),nil)
+  -- Observed layout edits remain detached from native collision permissions.
+  local layout=Map.currentDef().midLayout
+  local nativeAllowed=Native.mayEnter(field,w.entities,actor,0,1,'down')
+  layout:applyOverride(0,1,0,7,0)
+  T.eq(C.cell(0,1),7)
+  T.eq(C.canEnter(g,0,1,{dir='down'}),nativeAllowed,'observational overrides cannot rewrite native permissions')
+  T.eq(C._grid[5],7,'classified array tracks owned override revisions')
+  -- A live native actor must not collide with itself when the request asks
+  -- about a hypothetical origin/surf/elevation instead of its current one.
+  local allowed,reason=C.canEnter(g,0,1,{fromX=1,fromY=1,elevation=6,surfing=true,dir='left'})
+  local hypothetical={cellX=1,cellY=1,elevation=6,surfing=true}
+  local expected,why=Native.mayEnter(field,{},hypothetical,0,1,'left')
+  T.eq(allowed,expected);T.eq(reason,why)
+  -- Source readers see replaced bank records, not old renderer/cached bytes.
+  local original=sets[pair.primaryKey];local replacement={}
+  for k,v in pairs(original)do replacement[k]=v end
+  replacement.attributes=string.rep('\0',#original.attributes)
+  if replacement.sourceAttributes then replacement.sourceAttributes=string.rep('\0',#replacement.sourceAttributes)end
+  sets[pair.primaryKey]=replacement
+  T.eq(C.behavior(0,0),Behavior.fromRaw(edition,0))
+  local activeDef=g.data.maps[field.id];g.data.maps[field.id]={}
+  T.eq(C.canEnter(g,0,1),false,'a world from a retired dataset cannot grant movement')
+  T.eq(C.elevationAt(0,0),nil)
+  g.data.maps[field.id]=activeDef
+  w.player={cellX=0,cellY=0,elevation=3};w.entities={w.player}
+  g.stack.states={{isTitle=true}}
+  T.eq(C._mapDef,nil);T.eq(C.behavior(0,0),nil);T.eq(C.canEnter(g,0,1),false)
+  C.release();Map.release();f.views:release()
+end
+do
+ local f=require('tools.map-runtime.fixture').new('firered')
+ f.world.player={cellX=0,cellY=0,elevation=6};f.world.entities={f.world.player}
+ package.loaded['src.core.Game']=f.game
+ local held=C._grid;C.behavior(0,0)
+ local weak=setmetatable({f.map,f.game.data.map_tilesets.P},{__mode='v'})
+ require('src.mods.Loader').teardown()
+ f.views:release();f=nil;package.loaded['src.core.Game']=nil
+ collectgarbage('collect');collectgarbage('collect')
+ T.eq(weak[1],nil,'held classified cells cannot retain a native map after teardown')
+ T.eq(weak[2],nil,'retired behavior readers cannot retain a native source bank')
+ T.check(type(held[1])=='number','detached observations remain readable after retirement')
+end
+package.loaded['src.core.Game']=previous
+T.finish('native field collision interface')
diff --git a/tools/field-effect-sheets/check.lua b/tools/field-effect-sheets/check.lua
new file mode 100644
index 000000000..473c92e81
--- /dev/null
+++ b/tools/field-effect-sheets/check.lua
@@ -0,0 +1,110 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.harness')
+local F=require('src.core.game3.field_effects')
+T.eq(package.loaded['src.core.Game'],nil,'resource require cannot bootstrap a game')
+T.eq(F.loadSheet('tall_grass'),nil,'no dataset cannot invent an image')
+love=require('tests.love_stub')
+local read,imageFile,created=require('tools.sprite-runtime.cpu-gpu').install(love)
+local Runtime=require('src.compat.gen1.FieldEffectRuntime')
+local Host=require('src.mods.Runtime')
+local Assets=require('src.render.Assets')
+local Version=require('src.core.GameVersion')
+local decode=require('src.compat.gen1.FieldEffectCache')
+local function pixel(seed,w,h)
+  local out={};for y=0,h-1 do for x=0,w-1 do out[#out+1]=string.char((x*31+seed)%256,(y*17+seed)%256,(x+y*7)%256,255)end end
+  return table.concat(out)
+end
+local manifests={}
+local function cache(text,rgba)
+  local out={reads={}}
+  function out:read(path)
+    self.reads[#self.reads+1]=path
+    T.check(path:find('data/generated/gba/field_effects/',1,true)==1,'only the explicit effect cache root is read')
+    if path:sub(-11)=='objects.lua'then return text end
+    if path:sub(-10)=='grass.rgba'then return rgba end
+  end
+  return out
+end
+for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+  F.release();local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+  local c=game.data.constants;game.data.sprites={}
+  local expected={}
+  for i,key in ipairs({'tall_grass','surf_blob','fly_bird','ripple','sparkle','emote_heart'})do
+    local path='assets/generated/field-test/'..key..'.png';local bytes=pixel(i,16,32)
+    imageFile(path,16,32,bytes);expected[key]=bytes
+    local row={image=path,frameWidth=16,frameHeight=16,frames=2,trueColor=true}
+    if key=='tall_grass'then c.gen3TallGrass=row
+    elseif key=='surf_blob'then c.gen3SurfBlob=row
+    elseif key=='fly_bird'then c.gen3FRLGFlyBird={path=path,frameWidth=16,frameHeight=16,frames=2}
+    elseif key=='emote_heart'then c.gen3Emotes={heart={image=path,width=16,height=16,frames=2}}
+    else c[key=='ripple'and'gen3Ripple'or'gen3Sparkle']={key=key};game.data.sprites[key]=row end
+  end
+  local original=game.data.constants.gen3TallGrass
+  for name,bytes in pairs(expected)do
+    Host.currentMod='effects-a';local sheet=assert(F.loadSheet(name,128,128,256));Host.currentMod=nil
+    T.eq(sheet.fw,16);T.eq(sheet.fh,16);T.eq(sheet.frames,2,'supplied geometry cannot reinterpret native images')
+    T.eq(read(sheet.image),bytes,'native source pixels remain in their original order')
+    local x,y,w,h=sheet.quadsFront[1]:getViewport();T.eq(x,0);T.eq(y,24);T.eq(w,16);T.eq(h,8)
+  end
+  local view=F.manifest();view._byName.tall_grass.fw=88
+  T.eq(F.manifestObject('tall_grass').fw,16,'metadata readers receive detached records')
+  T.eq(F.loadSheet('emoticons'),nil,'separate native bubbles cannot masquerade as a combined source strip')
+  T.eq(F.loadSheet('../tall_grass'),nil)
+  local native=assert(F.loadSheet('tall_grass'));local nativeImage=native.image
+  local borrowed=love.graphics.newImage(love.image.newImageData(original.image))
+  Host.currentMod='effects-b';T.eq(F.loadSheet('tall_grass'),native);Host.currentMod=nil
+  F.cancelOwner('effects-a');T.eq(native._retired,nil,'a peer lease keeps the shared owned sheet alive')
+  F.cancelOwner('effects-b');T.eq(native._retired,nil,'an engine request still owns this sheet')
+  native.image=borrowed
+  native.quads={external={release=function()error('borrowed quad must never be released')end}}
+  F.invalidate();T.eq(native._retired,true);T.eq(read(borrowed),expected.tall_grass,'public table mutation cannot transfer ownership of a borrowed image')
+  T.eq(game.data.constants.gen3TallGrass,original);T.check(not pcall(nativeImage.getWidth,nativeImage))
+  borrowed:release()
+  local family=Version.isFRLG(edition)and'frlg'or'rse'
+  local bytes=pixel(93,8,16)
+  local text="return {family='"..family.."',objects={[0]={name='tall_grass',fw=8,fh=8,frames=2,rgba='grass.rgba',anims={{{'frame',0,3},{'frame',1,4}}}}},extras={}}"
+  local source=cache(text,bytes)
+  Host.currentMod='provider-owner';T.check(F.install(source)~=nil)
+  local sheet=assert(F.loadSheet('tall_grass',16,16,5));Host.currentMod=nil
+  T.eq(sheet.fw,8);T.eq(sheet.fh,8);T.eq(sheet.frames,2);T.eq(read(sheet.image),bytes,'explicit source RGBA remains exact')
+  T.eq(F.loadSheet('surf_blob'),nil,'an explicit authored manifest remains authoritative')
+  local copy=F.manifestObject('tall_grass');copy.anims[1][1][2]=99
+  T.eq(F.manifestObject('tall_grass').anims[1][1][2],0)
+  F.cancelOwner('provider-owner');T.eq(sheet._retired,true);T.eq(F._cache,nil)
+  T.eq(assert(F.loadSheet('tall_grass')).fw,16,'native resources resume after provider retirement')
+  Host.currentMod='provider-owner';assert(F.install(source));local previous=assert(F.loadSheet('tall_grass'));Host.currentMod=nil
+  game.save={};T.eq(assert(F.loadSheet('tall_grass')).fw,16,'a save cohort switch cannot replay an old cache lease')
+  T.eq(previous._retired,true);T.eq(F._cache,nil)
+  local runtime=Runtime.new();runtime.maxBytes=1
+  local missing,why=runtime:get('tall_grass');T.eq(missing,nil);T.check(why:find('budget',1,true)~=nil)
+  runtime.maxBytes=1024*1024
+  local before=#created;local quad=love.graphics.newQuad
+  love.graphics.newQuad=function(...)if#created>=before+1 then error('injected second quad failure')end;return quad(...)end
+  T.eq(runtime:get('tall_grass'),nil);love.graphics.newQuad=quad
+  T.eq(runtime.bytes,0);T.eq(next(runtime.loaded),nil)
+  for i=before+1,#created do T.eq(created[i].dead,true,'failed preparation releases every partial allocation')end
+  T.check(runtime:get('tall_grass')~=nil,'a failed upload is retryable');runtime:release()
+  local wrong=cache(text:gsub(family,family=='frlg'and'rse'or'frlg'),bytes)
+  local m,err=decode.manifest(wrong,'data/generated/gba/field_effects',family)
+  T.eq(m,nil);T.check(err:find('family',1,true)~=nil)
+  for _,bad in ipairs({text:gsub('grass.rgba','../grass.rgba'),text:gsub('frames=2','frames=999'),
+      text:gsub('extras={}',"extras={{name='tall_grass',fw=8,fh=8,frames=2,rgba='grass.rgba'}}"),
+      'return {objects=function()end}','while true do end',string.char(27)..'bytecode'})do
+    T.eq(decode.manifest(cache(bad,bytes),'data/generated/gba/field_effects',family),nil,'malformed source metadata is rejected')
+  end
+  local sentinel=function()end;debug.sethook(sentinel,'',1000000)
+  T.eq(decode.manifest(cache('error()'), 'data/generated/gba/field_effects',family),nil)
+  local restored=debug.gethook();debug.sethook();T.eq(restored,sentinel,'manifest execution restores the host debug hook')
+  local changing=cache(text,bytes);local reader=changing.read
+  function changing:read(path)
+    if path:sub(-10)=='grass.rgba'then F.release()end
+    return reader(self,path)
+  end
+  Host.currentMod='stale-owner';assert(F.install(changing));local stale=F.loadSheet('tall_grass');Host.currentMod=nil
+  T.eq(stale,nil,'a reentrant cache reader cannot publish retired resources')
+  T.eq(assert(F.loadSheet('tall_grass')).fw,16)
+  F.release();T.eq(F._cache,nil)
+end
+F.release();package.loaded['src.core.Game']=nil
+T.eq(F.manifest(),nil)
+T.finish('owned field-effect artwork and cache leases')
diff --git a/tools/field-effect-sheets/host/conf.lua b/tools/field-effect-sheets/host/conf.lua
new file mode 100644
index 000000000..11ea0ed0f
--- /dev/null
+++ b/tools/field-effect-sheets/host/conf.lua
@@ -0,0 +1,8 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ assert(t.identity:match('^oasc%-gen2recomp%-qa%-field%-sheets%-gpu%-'))
+ t.version='12.0';t.gammacorrect=false
+ t.window.width,t.window.height=320,240;t.window.vsync=0;t.window.highdpi=false
+ t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/field-effect-sheets/host/main.lua b/tools/field-effect-sheets/host/main.lua
new file mode 100644
index 000000000..8e089ebe0
--- /dev/null
+++ b/tools/field-effect-sheets/host/main.lua
@@ -0,0 +1,95 @@
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('FIELD_SHEETS_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+function love.load()
+ local g=love.graphics;local T=require('tests.harness').suite('owned field-effect sheet GPU resources')
+ local renderer,version,vendor,device=g.getRendererInfo()
+ local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'));assert(renderer:lower():find(backend,1,true))
+ local identity=assert(os.getenv('POKEPORT_IDENTITY'));assert(love.filesystem.getIdentity()==identity)
+ local F=require('src.core.game3.field_effects');local V=require('src.core.GameVersion')
+ local Assets=require('src.render.Assets');local Host=require('src.mods.Runtime')
+ local readbacks,comparisons=0,0
+ local function read(texture)
+  -- Some native backends cannot read an uploaded Image directly. Stage its
+  -- actual GPU pixels through a render target, preserving all draw state.
+  local w,h=texture:getDimensions()
+  local target=g.newCanvas(w,h,{format='rgba8',dpiscale=1,msaa=0})
+  g.push('all');g.origin();g.setCanvas(target);g.setShader();g.setScissor()
+  g.clear(0,0,0,0);g.setColor(1,1,1,1);g.setBlendMode('replace','premultiplied')
+  g.draw(texture,0,0);g.pop()
+  local data=g.readbackTexture and g.readbackTexture(target)or target:newImageData()
+  local bytes=data:getString();data:release();target:release()
+  readbacks=readbacks+1;return bytes
+ end
+ local function pixels(w,h,seed)
+  local rows={}
+  for y=0,h-1 do for x=0,w-1 do
+   if(x+y)%7==0 then rows[#rows+1]=string.char(0,0,0,0)
+   else rows[#rows+1]=string.char((x*7+seed)%256,(y*13+seed)%256,(x+y*3+seed)%256,255)end
+  end end
+  return table.concat(rows)
+ end
+ local function crop(bytes,w,y,h)return bytes:sub(y*w*4+1,(y+h)*w*4)end
+ love.filesystem.createDirectory('assets/generated/qa-field')
+ local sizes={tall_grass={16,16,5},surf_blob={32,32,6},fly_bird={64,64,5},ripple={16,16,5},sparkle={16,16,5},emote_heart={16,16,3}}
+ for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+  F.release();V.set(edition);local data={constants={},sprites={}}
+  local game={data=data,save={},mods={}};package.loaded['src.core.Game']=game
+  local source={}
+  for name,size in pairs(sizes)do
+   local w,h,n=size[1],size[2],size[3];local bytes=pixels(w,h*n,n)
+   local path='assets/generated/qa-field/'..name..'.png'
+   local image=love.image.newImageData(w,h*n,'rgba8',bytes);image:encode('png',path);image:release()
+   source[name]={path=path,bytes=bytes,w=w,h=h,n=n}
+   local row={image=path,frameWidth=w,frameHeight=h,frames=n,trueColor=true}
+   if name=='tall_grass'then data.constants.gen3TallGrass=row
+   elseif name=='surf_blob'then data.constants.gen3SurfBlob=row
+   elseif name=='fly_bird'then data.constants.gen3FRLGFlyBird={path=path,frameWidth=w,frameHeight=h,frames=n}
+   elseif name=='emote_heart'then data.constants.gen3Emotes={heart={image=path,width=w,height=h,frames=n}}
+   else data.constants[name=='ripple'and'gen3Ripple'or'gen3Sparkle']={key=name};data.sprites[name]=row end
+  end
+  for name,s in pairs(source)do
+   local borrowed=Assets.image(s.path);local nativeBefore=read(borrowed)
+   Host.currentMod='gpu-a';local sheet=assert(F.loadSheet(name));Host.currentMod=nil
+   T.eq(read(sheet.image),s.bytes,edition..' '..name..' complete image matches its actual PNG')
+   T.check(sheet.image~=borrowed,'native asset-cache images are never lent')
+   for frame=0,s.n-1 do
+    for _,front in ipairs({false,true})do
+     local h=front and 8 or s.h;local target=g.newCanvas(s.w,h,{format='rgba8',dpiscale=1,msaa=0})
+     g.push('all');g.origin();g.setCanvas(target);g.setShader();g.setScissor();g.setColor(1,1,1,1)
+     g.clear(0,0,0,0);g.setBlendMode('replace','premultiplied')
+     g.draw(sheet.image,(front and sheet.quadsFront or sheet.quads)[frame],0,0);g.pop()
+     T.eq(read(target),crop(s.bytes,s.w,frame*s.h+(front and s.h-8 or 0),h),'original frame/crop pixels')
+     comparisons=comparisons+1;target:release()
+    end
+   end
+   Host.currentMod='gpu-b';T.eq(F.loadSheet(name),sheet);Host.currentMod=nil
+   F.cancelOwner('gpu-a');T.eq(sheet._retired,nil)
+   sheet.image=borrowed
+   F.cancelOwner('gpu-b');T.eq(sheet._retired,true)
+   T.eq(read(borrowed),nativeBefore,'native cached images survive peer retirement')
+  end
+  -- Native generated-asset overrides remain authoritative, with exact geometry.
+  local base=source.tall_grass;local path='assets/generated/qa-field/override.png'
+  local changed=pixels(base.w,base.h*base.n,193)
+  local image=love.image.newImageData(base.w,base.h*base.n,'rgba8',changed);image:encode('png',path);image:release()
+  local old=Assets.resolve
+  Assets.resolve=function(p)return p==base.path and path or old(p)end
+  local override=assert(F.loadSheet('tall_grass'));T.eq(read(override.image),changed)
+  Assets.resolve=old
+  local restored=assert(F.loadSheet('tall_grass'));T.eq(read(restored.image),base.bytes);T.eq(override._retired,true)
+  local raw=pixels(8,32,73);local manifest="return {family='"..(V.isFRLG(edition)and'frlg'or'rse').."',objects={{name='custom',fw=8,fh=8,frames=4,rgba='custom.rgba'}}}"
+  local provider={read=function(_,p)if p:sub(-11)=='objects.lua'then return manifest end;if p:sub(-11)=='custom.rgba'then return raw end end}
+  Host.currentMod='gpu-cache';assert(F.install(provider));local custom=assert(F.loadSheet('custom'));Host.currentMod=nil
+  T.eq(read(custom.image),raw,'explicit source RGBA requires no conversion file')
+  Assets.invalidate();T.eq(custom._retired,true)
+  local again=assert(F.loadSheet('custom'));T.eq(read(again.image),raw)
+  F.release();T.eq(again._retired,true);T.eq(F._cache,nil)
+ end
+ T.finish()
+ local result={status='pass',checks=T.checks,frameComparisons=comparisons,readbacks=readbacks,backend=backend,renderer=renderer,
+  version=version,vendor=vendor,device=device,identity=identity,playerProfilesUsed=false,fullFieldEffectApi=false,fullRendererAcceptance=false}
+ local f=assert(io.open(assert(os.getenv('FIELD_SHEETS_OUT'))..'/result.json','w'));f:write(require('src.link.Json').encode(result));f:close()
+ print('Field sheet GPU pass',comparisons,readbacks);love.event.quit(0)
+end
diff --git a/tools/field-effect-sheets/lifecycle-check.lua b/tools/field-effect-sheets/lifecycle-check.lua
new file mode 100644
index 000000000..c5e1b31d6
--- /dev/null
+++ b/tools/field-effect-sheets/lifecycle-check.lua
@@ -0,0 +1,60 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+require('tools.sprite-runtime.cpu-gpu').install(love)
+local native=require('tools.session-runtime.fixture').new('emerald').game
+local Json=require('src.link.Json')
+local api=tonumber(os.getenv('SESSION_RUNTIME_API'))or require('src.core.Version').modApi
+assert(api==2 or api==3)
+local files={}
+local function mod(id,priority,body)
+ files['mods/'..id..'/manifest.json']=Json.encode({id=id,name=id,version='1.0.0',api=api,entry='main.lua',games={'gen3'},
+   priority=priority,permissions={'engine_internals'}})
+ files['mods/'..id..'/main.lua']=body
+end
+local function entry(seed)
+ return ([[local F=require('src.core.game3.field_effects')
+ local metadata="return {family='rse',objects={{name='tall_grass',fw=8,fh=8,frames=1,rgba='grass.rgba'}}}"
+ assert(F.install({read=function(_,path)
+  if path:sub(-11)=='objects.lua'then return metadata end
+  if path:sub(-10)=='grass.rgba'then return string.rep(string.char(%d,0,0,255),64)end
+ end}))
+ local view=assert(F.loadSheet('tall_grass'))
+ ]]):format(seed)
+end
+mod('field_owner',100,[[local mod=...;]]..entry(17)..[[
+ local previous=F.loadSheet;mod.exports.base=previous
+ F.loadSheet=function(...)return previous(...)end
+ mod.exports.observe=function()return F.loadSheet('tall_grass')end
+]])
+mod('field_bad',200,entry(29)..[[
+ F.loadSheet=function()error('failed field wrapper survived')end
+ error('intentional field entry failure')
+]])
+mod('field_late',300,[[local mod=...;]]..entry(31)..[[
+ F.loadSheet=function()error('late field wrapper survived')end
+ mod.content.map_scripts:register('FIELD_VALIDATION',{scripts={invalid={{'field_intentionally_unknown_command'}}}})
+]])
+local run=T.sdk.loadMods({'mods/field_owner','mods/field_bad','mods/field_late'},
+ {fs=T.sdk.memfs(files),data=T.fixtures.fresh()})
+T.eq(#run.errors,2)
+local F=require('src.core.game3.field_effects')
+T.check(F._cache~=nil,'failed owners leave the successful provider installed')
+local peer=run.loader.exports.field_owner
+local sheet=assert(peer.observe());local bytes=sheet.imageData:getString()
+T.eq(bytes,string.rep(string.char(17,0,0,255),64),'failed and late-rejected providers cannot shadow the successful one')
+native.mods=run.loader;run.loader.game=native
+local fallback,why=F.loadSheet('tall_grass');T.eq(fallback,nil,'changing the mod-set cohort retires stale provider leases')
+T.eq(sheet._retired,true)
+-- A fresh callback in the active cohort can establish a new owned lease.
+local Host=require('src.mods.Runtime');Host.currentMod='field_owner'
+local cache={read=function(_,path)
+ if path:sub(-11)=='objects.lua'then return "return {family='rse',objects={{name='tall_grass',fw=8,fh=8,frames=1,rgba='grass.rgba'}}}"end
+ return string.rep(string.char(17,0,0,255),64)
+end}
+assert(F.install(cache));local current=assert(F.loadSheet('tall_grass'));Host.currentMod=nil
+local image=current.image
+require('src.mods.Loader').teardown()
+T.eq(current._retired,true);T.check(not pcall(image.getWidth,image))
+T.eq(F._cache,nil);T.eq(F.loadSheet,peer.base,'successful field wrappers unwind on teardown')
+run.release()
+T.finish('field-effect resources through SDK lifecycle API '..api)
diff --git a/tools/field-move-runtime/art-oracle.lua b/tools/field-move-runtime/art-oracle.lua
new file mode 100644
index 000000000..0a1e0b2b4
--- /dev/null
+++ b/tools/field-move-runtime/art-oracle.lua
@@ -0,0 +1,40 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+love=require('tests.love_stub')
+local T=require('tests.harness')
+local J=require('src.link.Json')
+local function read(path)local f=assert(io.open(path,'rb'));local s=f:read('*a');f:close();return s end
+local inputs=J.decode(read(assert(arg[1])));local profiles=J.decode(read(assert(arg[2])))
+local original=assert(arg[3]);local bytesCompared=0
+for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+ local manifest=J.decode(read('tools/rom_manifest_'..edition..'.json'))
+ local input=inputs[edition];local raw=read(input.path);T.eq(input.sha1,manifest.romSha1)
+ local Rom=require('src.import.RomGba');local nativeRom=Rom.new(raw)
+ local sourceRom={get=function(_,at)return raw:byte(at+1)end,u16=function(_,at)return nativeRom:u16(at)end}
+ local values={};local cache={write=function(_,path,value)values[path]=value end}
+ local versions={FIELD_EFFECTS={},FIELD_MOVE_STREAKS=profiles[edition]}
+ local env=setmetatable({require=function(name)T.eq(name,'src.import.gba.versions');return versions end},{__index=_G})
+ local fn=assert(loadfile(original));setfenv(fn,env);fn().writeExtract(sourceRom,cache,'fx')
+ local Art=require('src.import.Gen3FieldMoveArt');local slices=0
+ local artwork=assert(Art.extract(nativeRom,manifest,input.sha1,edition,function()slices=slices+1 end));T.eq(slices,20)
+ for _,kind in ipairs({'outdoors','indoors'})do
+  local source=assert(values['fx/field_effects/field_move_streaks_'..kind..'.rgba'])
+  local native=Art.rgba(artwork.strips[kind]);T.eq(native,source,edition..' '..kind..' exact independently decoded RGBA')
+  T.eq(#native,81920);bytesCompared=bytesCompared+#native
+ end
+ local text=require('src.import.LuaWriter').encodeSplit(artwork)
+ local decoded=assert(loadstring(text))();T.eq(Art.rgba(decoded.strips.outdoors),Art.rgba(artwork.strips.outdoors),'native cache round trip')
+ T.eq(Art.extract(nativeRom,manifest,string.rep('0',40),edition),nil,'foreign bytes cannot use a declared profile')
+ local bad={romSha1=manifest.romSha1,fieldMoveStreaks={schema=1,romSha1=manifest.romSha1,strips={outdoors={tiles=-1,palette=0,tilemap=0,tileCount=16}}}}
+ T.eq(Art.extract(nativeRom,bad,input.sha1,edition),nil,'out-of-bounds profiles do not emit partial art')
+ local Verify=require('src.import.RomVerification');local hash=Verify.sha1;local hashCalls=0
+ Verify.sha1=function(bytes)T.eq(bytes,raw);hashCalls=hashCalls+1;return input.sha1 end
+ local ex=require('src.import.RomExtractorGen3').new(raw,{id=edition},manifest);local generated={}
+ ex._constants={sentinel='retain'};ex.write=function(_,name,value)generated[name]=value end
+ ex.fieldEffectRoles=function()return nil,0,0 end
+ ex:extractFieldEffects();Verify.sha1=hash
+ T.eq(hashCalls,1);T.eq(generated.constants.sentinel,'retain')
+ T.eq(Art.rgba(generated.constants.gen3FieldMovePresentation.strips.indoors),Art.rgba(artwork.strips.indoors),'actual import stage emits the same compact artwork')
+ print('FIELD_MOVE_ART_EDITION',edition,#text)
+end
+print('FIELD_MOVE_ART_RGBA_BYTES',bytesCompared)
+T.finish('independent five-edition field-move artwork oracle')
diff --git a/tools/field-move-runtime/audio-check.lua b/tools/field-move-runtime/audio-check.lua
new file mode 100644
index 000000000..783550e24
--- /dev/null
+++ b/tools/field-move-runtime/audio-check.lua
@@ -0,0 +1,27 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.harness')
+love=require('tests.love_stub')
+local sources={};local Source={};Source.__index=Source
+function Source:play()self.playing=true end
+function Source:stop()self.playing=false end
+function Source:pause()self.playing=false end
+function Source:isPlaying()return self.playing end
+function Source:setLooping(v)self.looping=v end
+function Source:setVolume(v)self.volume=v end
+function Source:setFilter()end
+love.audio={newSource=function(file)local s=setmetatable({file=file},Source);sources[file]=s;return s end}
+local Sound=require('src.core.Sound');local Music=require('src.core.Music')
+local data={constants={gen3Cry={scale=256,volume=90,duckBgm=85}},audio={songs={TEST={file='song.ogg'}},cries={A='a.ogg',B='b.ogg'}}}
+local function near(a,b)T.check(type(a)=='number'and math.abs(a-b)<1e-10,tostring(a)..' matches '..b)end
+Music.play(data,'TEST');local song=assert(sources['song.ogg']);near(song.volume,0.7)
+local a=assert(Sound.playCry(data,'A'));near(a.volume,0.8*90/256);near(song.volume,0.7*85/256)
+local b=assert(Sound.playCry(data,'B',{noDuck=true,volume=125}));near(b.volume,0.8*125/256)
+near(song.volume,0.7*85/256) -- another active cry retains its attenuation
+T.eq(Sound.playCry(data,'A',{noDuck=true,volume=125}),a);near(song.volume,0.7);near(a.volume,0.8*125/256)
+T.eq(Sound.playCry(data,'A'),a);near(a.volume,0.8*90/256);near(song.volume,0.7*85/256)
+a:stop();Music.update(data);near(song.volume,0.7)
+Sound.playCry(data,'B',{volume=0,noDuck=true});near(b.volume,0);near(song.volume,0.7)
+Sound.playCry(data,'B',{volume=0/0,noDuck=true});near(b.volume,0.8*90/256)
+Sound.playCry(data,'B',{volume=257,noDuck=true});near(b.volume,0.8*90/256)
+Sound.invalidate();Music.stop()
+T.finish('field-move cry options preserve native cached audio and music ownership')
diff --git a/tools/field-move-runtime/check.lua b/tools/field-move-runtime/check.lua
new file mode 100644
index 000000000..0ed541ebb
--- /dev/null
+++ b/tools/field-move-runtime/check.lua
@@ -0,0 +1,109 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.harness')
+local Source=require('src.core.game3.field_move_show_mon')
+T.eq(package.loaded['src.core.Game'],nil);T.eq(Source.isActive(),false)
+love=require('tests.love_stub')
+local read,imageFile,created=require('tools.sprite-runtime.cpu-gpu').install(love)
+local makeImage=love.graphics.newImage
+love.graphics.newImage=function(value,...)
+ if type(value)=='string'then
+  local data=love.image.newImageData(value);local image=makeImage(data,...);data:release();return image
+ end
+ return makeImage(value,...)
+end
+local Native=require('src.world.Gen3FieldMove')
+local Host=require('src.mods.Runtime')
+local base={start=Source.start,step=Source.step,draw=Source.draw}
+local function fixture(edition)
+ Source.release()
+ local f=require('tools.session-runtime.fixture').new(edition);local g=f.game
+ g.data.pokemon={TEST={spriteFront='field-test-front.png',name='TEST',trueColor=true}}
+ g.data.constants.speciesOrder={[1]='TEST'};imageFile('field-test-front.png',64,64,string.rep('\255',64*64*4))
+ local strip={width=256,height=80,indexed=string.rep('\1',256*80),palette={}}
+ for i=1,16 do strip.palette[i]=i*37 end
+ g.data.constants.gen3FieldMovePresentation={schema=1,edition=edition,romSha1=require('src.core.GameVersion').info(edition).sha1,strips={outdoors=strip,indoors=strip}}
+ Source._observeMod('field-owner');g.mods.exports['field-owner']={}
+ return f
+end
+local nativeCry=require('src.core.Sound').playCry
+for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+ local f=fixture(edition);local g=f.game;local calls,starts,steps,cries=0,0,0,{}
+ local guard
+ require('src.core.Sound').playCry=function(_,species,opts)cries[#cries+1]={species,opts}end
+ Source.start=function(mon,opts,done)
+  starts=starts+1;guard=done;done()
+  local ok=base.start(mon,opts,function()done();done()end);base.start(mon,opts,done);return ok
+ end
+ Source.step=function()steps=steps+1;local result=base.step();base.step();return result end
+ Host.currentMod='field-owner'
+ T.eq(Native.show(g,{species='TEST'},function()calls=calls+1 end),true);Host.currentMod=nil
+ local state=g.stack:top();T.eq(getmetatable(state),Native);T.eq(starts,1);T.eq(calls,0,'premature source callback cannot run the HM continuation')
+ T.eq(Source._fx.phase,'pose');local metadata=Source._fx;metadata.phase=99;T.eq(Source._fx.phase,'pose')
+ Source.step();Source.step();T.eq(state.frame,0,'arbitrary source ticks cannot drive the state')
+ local beforeSteps=steps
+ local modal={};g.stack:push(modal);state:update();T.eq(state.frame,0)
+ Host.currentMod='field-peer';T.eq(Source.reset(),false);Host.currentMod=nil
+ T.eq(g.stack:top(),modal,'covered reset cannot pop another screen');g.stack:pop()
+ local ticks=0
+ while Source.isActive()and ticks<256 do g.stack:update(1/60);ticks=ticks+1 end
+ T.check(ticks<256);T.eq(calls,1);T.eq(#cries,1);T.eq(cries[1][1],'TEST');T.eq(g.stack:top(),f.world)
+ T.eq(f.player.fieldMove,nil);T.eq(f.player.fieldMovePose,nil);T.eq(f.player._gen3FieldMovePoseOwner,nil)
+ T.eq(steps-beforeSteps,ticks);guard();guard();T.eq(calls,1)
+ local after=state.frame;state:update();T.eq(state.frame,after)
+ T.eq(Source._fx,nil)
+ Source.start=base.start;Source.step=base.step
+ Host.currentMod='source-owner';T.eq(Source.start({species=1,isShiny=true},{pose=false,noDuck=true},function()calls=calls+1 end),true);Host.currentMod=nil
+ state=g.stack:top();T.eq(Source._fx.shiny,true);T.eq(Source._fx.species,1);T.eq(Source._fx.phase,1)
+ T.eq(f.player.fieldMove,nil,'a no-pose request leaves the native pose alone')
+ while Source.isActive()do g.stack:update(1/60)end
+ T.eq(calls,2);T.eq(cries[2][2].noDuck,true);T.eq(cries[2][2].volume,125)
+ Host.currentMod='source-owner';T.eq(Source.start(1,{pose=true}),true);Host.currentMod=nil
+ local abandoned=g.stack:top();local owned=abandoned.sprite
+ Source.cancelOwner('another-owner');T.eq(Source.isActive(),true)
+ local cover={};g.stack:push(cover)
+ Source.cancelOwner('source-owner');T.eq(g.stack:top(),cover);g.stack:pop();T.eq(Source.isActive(),false);T.eq(abandoned.completed,false)
+ T.check(not pcall(owned.getWidth,owned));T.eq(calls,2)
+ T.eq(Native.show(g,{species='TEST'},function()calls=calls+1 end),true)
+ state=g.stack:top();local wrappedNative=state.onDone
+ state.onDone=function()return wrappedNative()end
+ Source.release()
+ while not state.done do g.stack:update(1/60)end
+ T.eq(calls,3,'detaching observers preserves a native HM continuation')
+ T.eq(Native.show(g,{species='TEST'},function()calls=calls+1 end),true)
+ state=g.stack:top();g.save={};state:update();T.eq(g.stack:top(),f.world)
+ T.eq(calls,3,'a retired save cannot receive the old continuation')
+ T.eq(state.done,true)
+ T.eq(Native.show(g,{species='TEST'},function()calls=calls+1 end),true)
+ state=g.stack:top();local admittedStack=g.stack;local foreign={}
+ g.stack=setmetatable({states={foreign}},{__index=require('src.core.StateStack')})
+ T.eq(Source.isActive(),false);state:update()
+ T.eq(g.stack:top(),foreign,'retiring an old admission cannot remove a foreign screen')
+ T.eq(#admittedStack.states,1,'retire the admission from its actual original stack')
+ T.eq(calls,3);g.stack=admittedStack
+ -- A public sprite replacement cannot transfer ownership of that image.
+ f=fixture(edition);g=f.game
+ T.eq(Native.show(g,{species='TEST'},nil,{presentation='cartridge',pose=false}),true)
+ state=g.stack:top();local original=state.sprite
+ local borrowed=love.graphics.newImage(love.image.newImageData('field-test-front.png'));state.sprite=borrowed
+ T.eq(state:complete(false),true);T.check(not pcall(original.getWidth,original));T.eq(borrowed:getWidth(),64);borrowed:release()
+ -- Preparation failure returns to the caller before locking or pushing.
+ g.data.constants.gen3FieldMovePresentation=nil
+ T.eq(Source.start(1,{pose=true}),false);T.eq(g.stack:top(),f.world);T.eq(f.player.fieldMove,nil)
+ Source.release()
+end
+-- Held callback observations must not retain a completed battle/field payload.
+local f=fixture('emerald');local saved;local weak=setmetatable({},{__mode='v'})
+local function launch()
+ local payload={large={}};weak[1]=payload
+ T.eq(Native.show(f.game,{species='TEST'},function()T.check(payload.large~=nil)end),true)
+ saved=f.game.stack:top().onDone
+end
+launch();while Source.isActive()do f.game.stack:update(1/60)end
+collectgarbage('collect');collectgarbage('collect');T.eq(weak[1],nil,'retained callback observations release captured payloads');saved()
+Source.release()
+T.eq(Native.show(f.game,{species='TEST'}),true)
+T.eq(f.game.stack:top().effect,nil,'an inactive cached facade cannot change native field-move presentation')
+f.game.stack:top():complete(false)
+require('src.core.Sound').playCry=nativeCry
+Source.release();Source.start=base.start;Source.step=base.step;Source.draw=base.draw
+T.finish('native field-move admissions, clocks and continuations')
diff --git a/tools/field-move-runtime/host/conf.lua b/tools/field-move-runtime/host/conf.lua
new file mode 100644
index 000000000..8e56a9c11
--- /dev/null
+++ b/tools/field-move-runtime/host/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'));assert(t.identity:match('^oasc%-gen2recomp%-qa%-field%-move%-gpu%-'))
+ t.version='12.0';t.gammacorrect=false;t.window.width,t.window.height=320,240;t.window.vsync=0;t.window.highdpi=false
+ t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/field-move-runtime/host/main.lua b/tools/field-move-runtime/host/main.lua
new file mode 100644
index 000000000..78ecf0201
--- /dev/null
+++ b/tools/field-move-runtime/host/main.lua
@@ -0,0 +1,82 @@
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('FIELD_MOVE_ENGINE'));package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+local function file(p)local f=assert(io.open(p,'rb'));local s=f:read('*a');f:close();return s end
+function love.load()
+ local g=love.graphics;local T=require('tests.harness').suite('native field-move GPU rendering')
+ local J=require('src.link.Json');local Art=require('src.import.Gen3FieldMoveArt')
+ local Source=require('src.core.game3.field_move_show_mon');local Native=require('src.world.Gen3FieldMove')
+ local inputs=J.decode(file(assert(os.getenv('FIELD_MOVE_INPUTS'))));local original=assert(os.getenv('FIELD_MOVE_ORIGINAL'))
+ local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'));local renderer,version,vendor,device=g.getRendererInfo()
+ assert(renderer:lower():find(backend,1,true));assert(love.filesystem.getIdentity()==os.getenv('POKEPORT_IDENTITY'))
+ local pixels={};for y=0,63 do for x=0,63 do pixels[#pixels+1]=string.char(x*4,y*4,(x+y)*2,(x+y)%7==0 and 0 or 255)end end
+ local d=love.image.newImageData(64,64,'rgba8',table.concat(pixels));d:encode('png','field-front.png');local front=g.newImage(d);front:setFilter('nearest','nearest');d:release()
+ local a=g.newCanvas(240,160,{format='rgba8',dpiscale=1,msaa=0});local b=g.newCanvas(240,160,{format='rgba8',dpiscale=1,msaa=0})
+ local readbacks,comparisons=0,0
+ local function render(c,fn)
+  g.push('all');g.origin();g.setCanvas(c);g.setShader();g.setScissor();g.setColor(1,1,1,1);g.clear(0,0,0,0);g.setBlendMode('alpha','alphamultiply');fn();g.pop()
+  local data=g.readbackTexture and g.readbackTexture(c)or c:newImageData();local bytes=data:getString();data:release();readbacks=readbacks+1;return bytes
+ end
+ local function base(outside,art)
+  local mocks={['src.core.game3.player']={startFieldMove=function()end},['src.core.game3.audio']={playCry=function()end},
+   ['src.core.game3.pokemon']={picSpecies=function(n)return n end,isShiny=function()return false end,frontPic=function()return{image=front,w=64,h=64}end},
+   ['src.core.game3.field_effects']={_cache={read=function(_,p)return Art.rgba(art.strips[p:find('outdoors',1,true)and'outdoors'or'indoors'])end}},['src.import.gba.extract_island1']={CACHE_ROOT='private'}}
+  local env=setmetatable({package={loaded={['src.core.game3.map']={currentDef=function()return{mapType=outside and 3 or 8}end}}},require=function(n)return assert(mocks[n],n)end},{__index=_G})
+  local fn=assert(loadfile(original));setfenv(fn,env);return fn()
+ end
+ local oldCry=require('src.core.Sound').playCry;require('src.core.Sound').playCry=function()end
+ for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+  local raw=file(inputs[edition].path);local sha=love.data.encode('string','hex',love.data.hash('sha1',raw));assert(sha==inputs[edition].sha1)
+  local handle=io.open(root..'/tools/rom_manifest_'..edition..'.json','rb')
+  local manifest
+  if handle then manifest=J.decode(handle:read('*a'));handle:close()
+  else manifest={romSha1=sha}end -- exercise the authenticated legacy-metadata profile
+  local art=assert(Art.extract(require('src.import.RomGba').new(raw),manifest,sha,edition));raw=nil
+  for _,outside in ipairs({true,false})do for _,pose in ipairs({true,false})do for _,noDuck in ipairs({true,false})do
+   Source.release();local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+   game.data.pokemon={TEST={spriteFront='field-front.png'}};game.data.constants.speciesOrder={[1]='TEST'};game.data.constants.gen3FieldMovePresentation=art
+   f.map.def.mapType=outside and'ROUTE'or'INDOOR'
+   local ref=base(outside,art);ref.start(1,{pose=pose,noDuck=noDuck});assert(Source.start(1,{pose=pose,noDuck=noDuck}));local state=game.stack:top()
+   for tick=0,220 do
+    if not ref.isActive()then break end
+    local expected=render(a,ref.draw);local actual=render(b,function()state:draw()end)
+    T.eq(actual,expected,edition..' native/original frame '..tick);comparisons=comparisons+1
+    local frame=state.frame
+    T.eq(render(b,function()state:draw()end),actual,'extra render cannot advance the effect');T.eq(state.frame,frame)
+    -- The source renderer already draws this admission in the world pass.
+    T.eq(render(b,function()Source.draw();state:draw()end),actual,'manual source draw and native UI draw compose only once')
+    ref.step();game.stack:update(1/60)
+   end
+   T.eq(Source.isActive(),false);T.eq(state.completed,true)
+   for _,img in pairs(ref._img)do img:release()end;if ref._quad then ref._quad:release()end
+  end end end
+ end
+ -- Compare the ordinary native presentation to its frozen pre-change class.
+ Source.release()
+ local baseline=assert(loadfile(assert(os.getenv('FIELD_MOVE_NATIVE_BASELINE'))))
+ local loaded={};for k,v in pairs(package.loaded)do if k~='src.core.game3.field_move_show_mon'then loaded[k]=v end end
+ setfenv(baseline,setmetatable({package={loaded=loaded}},{__index=_G}));local previousClass=baseline()
+ local classicComparisons=0
+ for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+  local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+  game.data.pokemon={TEST={spriteFront='field-front.png'}}
+  assert(previousClass.show(game,{species='TEST'}));local old=game.stack:top();local frames={}
+  repeat
+   frames[#frames+1]=render(a,function()old:draw()end)
+   old:update()
+  until game.stack:top()==f.world
+  if old.sprite then old.sprite:release()end
+  assert(Native.show(game,{species='TEST'}));local state=game.stack:top()
+  T.eq(state.effect,nil,'cached inactive facade preserves ordinary native style')
+  for tick,expected in ipairs(frames)do
+   local actual=render(b,function()state:draw()end)
+   T.check(actual==expected,edition..' unchanged native frame '..tick);classicComparisons=classicComparisons+1
+   T.eq(render(b,function()state:draw()end),actual,'native repeated draws keep their frame')
+   state:update()
+  end
+  T.eq(game.stack:top(),f.world)
+ end
+ require('src.core.Sound').playCry=oldCry;Source.release();front:release();a:release();b:release()
+ T.finish();local result={status='pass',checks=T.checks,frameComparisons=comparisons,nativeDefaultComparisons=classicComparisons,readbacks=readbacks,backend=backend,renderer=renderer,version=version,vendor=vendor,device=device,identity=os.getenv('POKEPORT_IDENTITY'),realRomBands=true,syntheticFrontFixture=true,fullPortraitParity=false,fullFieldEffectApi=false,playerProfilesUsed=false}
+ local out=assert(io.open(assert(os.getenv('FIELD_MOVE_OUT'))..'/result.json','w'));out:write(J.encode(result));out:close();love.event.quit(0)
+end
diff --git a/tools/field-move-runtime/lifecycle-check.lua b/tools/field-move-runtime/lifecycle-check.lua
new file mode 100644
index 000000000..9f0ff3809
--- /dev/null
+++ b/tools/field-move-runtime/lifecycle-check.lua
@@ -0,0 +1,47 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.modkit')
+local _,imageFile=require('tools.sprite-runtime.cpu-gpu').install(love)
+local make=love.graphics.newImage
+love.graphics.newImage=function(v,...)if type(v)=='string'then local d=love.image.newImageData(v);local i=make(d,...);d:release();return i end;return make(v,...)end
+local native=require('tools.session-runtime.fixture').new('emerald').game
+native.data.pokemon={TEST={spriteFront='field-front.png'}};native.data.constants.speciesOrder={[1]='TEST'}
+imageFile('field-front.png',64,64,string.rep('\255',64*64*4))
+local strip={width=256,height=80,indexed=string.rep('\1',256*80),palette={}}
+for i=1,16 do strip.palette[i]=i end
+native.data.constants.gen3FieldMovePresentation={schema=1,edition='emerald',romSha1=require('src.core.GameVersion').info('emerald').sha1,strips={outdoors=strip,indoors=strip}}
+local Json=require('src.link.Json');local api=tonumber(os.getenv('SESSION_RUNTIME_API'))or require('src.core.Version').modApi
+local files={};local function mod(id,priority,body,manifestApi)
+ files['mods/'..id..'/manifest.json']=Json.encode({id=id,name=id,version='1.0.0',api=manifestApi or api,entry='main.lua',games={'gen3'},priority=priority,permissions={'engine_internals'}})
+ files['mods/'..id..'/main.lua']=body
+end
+mod('move_owner',100,[[local mod=...;local F=require('src.core.game3.field_move_show_mon');local base=F.start
+ mod.exports.base=base;F.start=function(...)return base(...)end
+ mod.exports.start=function(done)return F.start(1,{pose=true},done)end
+]])
+mod('move_bad',200,[[local F=require('src.core.game3.field_move_show_mon');assert(F.start(1,{pose=true}));F.step=function()error('failed wrapper survived')end;error('intentional move failure')]])
+mod('move_late',300,[[local mod=...;local F=require('src.core.game3.field_move_show_mon');assert(F.start(1,{pose=true}));F.draw=function()error('late wrapper survived')end
+ mod.content.map_scripts:register('FIELD_VALIDATION',{scripts={invalid={{'field_intentionally_unknown_command'}}}})
+]],math.max(2,api))
+local F=require('src.core.game3.field_move_show_mon');local step,draw=F.step,F.draw
+local paths={'mods/move_owner','mods/move_bad','mods/move_late'}
+-- Legacy script findings are warnings. Keep that contract while using an
+-- explicitly strict peer to exercise actual late rejection in the mixed set.
+if api==1 then
+ mod('move_warning',400,[[local mod=...;mod.content.map_scripts:register('FIELD_WARNING',{scripts={invalid={{'field_intentionally_unknown_command'}}}})]],1)
+ paths[#paths+1]='mods/move_warning'
+end
+local run=T.sdk.loadMods(paths,{fs=T.sdk.memfs(files),data=T.fixtures.fresh()})
+if api==1 then T.check(run.loader.exports.move_warning~=nil,'legacy validation remains a warning')end
+T.eq(#run.errors,2);T.eq(F.isActive(),false);T.eq(#native.stack.states,1);T.eq(native.overworld.player.fieldMove,nil)
+T.eq(F.step,step);T.eq(F.draw,draw)
+native.mods=run.loader;run.loader.game=native
+local owner=run.loader.exports.move_owner;local done=0
+local Host=require('src.mods.Runtime');Host.currentMod='move_owner';T.eq(owner.start(function()done=done+1 end),true);Host.currentMod=nil
+local state=native.stack:top();local image=state.sprite
+local cover={};native.stack:push(cover)
+require('src.mods.Loader').teardown()
+T.eq(native.stack:top(),cover);T.eq(state.done,true);T.eq(done,0);T.eq(F.isActive(),false)
+T.check(not pcall(image.getWidth,image));native.stack:pop();T.eq(F.start,owner.base)
+local N=require('src.world.Gen3FieldMove');T.eq(N.show(native,{species='TEST'}),true);T.eq(native.stack:top().effect,nil)
+native.stack:top():complete(false);run.release()
+T.finish('native field-move SDK lifecycle API '..api)
diff --git a/tools/field-move-runtime/oracle.lua b/tools/field-move-runtime/oracle.lua
new file mode 100644
index 000000000..1f852f0d3
--- /dev/null
+++ b/tools/field-move-runtime/oracle.lua
@@ -0,0 +1,54 @@
+-- The immutable original is supplied by a private QA wrapper, never bundled.
+package.path='./?.lua;./?/init.lua;'..package.path
+local T=require('tests.harness')
+love=require('tests.love_stub')
+require('tools.sprite-runtime.cpu-gpu').install(love)
+local Native=require('src.world.Gen3FieldMove')
+local Source=require('src.core.game3.field_move_show_mon')
+local raw=assert(arg[1]);local checks=0
+local function original(outdoors)
+ local p={startFieldMove=function()end}
+ local audio={}
+ local mocks={['src.core.game3.player']=p,['src.core.game3.pokemon']={picSpecies=function(n)return n end,isShiny=function(m)return m and m.shiny or false end},
+  ['src.core.game3.audio']={playCry=function(...)audio[#audio+1]={...}end}}
+ local loaded={['src.core.game3.map']={currentDef=function()return{mapType=outdoors and 3 or 8}end}}
+ local env=setmetatable({package={loaded=loaded},require=function(name)return assert(mocks[name],name)end},{__index=_G})
+ local fn=assert(loadfile(raw));setfenv(fn,env);return fn(),audio
+end
+local oldCry=require('src.core.Sound').playCry
+for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+ for _,outside in ipairs({true,false})do for _,pose in ipairs({true,false})do for _,noDuck in ipairs({true,false})do
+  Source.release();local f=require('tools.session-runtime.fixture').new(edition);local g=f.game
+  g.data.pokemon={TEST={spriteFront='unused.png',name='TEST'}};g.data.constants.speciesOrder={[1]='TEST'}
+  f.map.def.mapType=outside and'ROUTE'or'INDOOR'
+  local strip={width=256,height=80,indexed=string.rep('\1',256*80),palette={}}
+  for i=1,16 do strip.palette[i]=i end
+  g.data.constants.gen3FieldMovePresentation={schema=1,edition=edition,romSha1=require('src.core.GameVersion').info(edition).sha1,strips={outdoors=strip,indoors=strip}}
+  -- Use the CPU image loader with real owned construction; this fixture's
+  -- front image is arbitrary, the timing oracle never evaluates its pixels.
+  local image=love.image.newImageData(64,64,'rgba8')
+  local make=love.graphics.newImage
+  love.graphics.newImage=function(v)if v=='unused.png'then return make(image)end;return make(v)end
+  local base,calls=original(outside);local nativeCries=0;local doneA,doneB=0,0
+  require('src.core.Sound').playCry=function()nativeCries=nativeCries+1 end
+  base.start({species=1},{pose=pose,noDuck=noDuck},function()doneA=doneA+1 end)
+  T.eq(Source.start(1,{pose=pose,noDuck=noDuck},function()doneB=doneB+1 end),true)
+  for tick=0,220 do
+   local a,b=base._fx,Source._fx
+   T.eq(a~=nil,b~=nil,'active frame '..tick)
+   if not a then break end
+   for _,key in ipairs({'species','picSpecies','shiny','noDuck','outdoors','phase','posed','poseWait','hofs','winL','winT','winB','revealed','cleared','hidden'})do
+    T.eq(b[key],a[key],edition..' '..key..' tick '..tick);checks=checks+1
+   end
+   T.eq(a.sprite~=nil,b.sprite~=nil)
+   if a.sprite then for _,key in ipairs({'x','y','state','wait','done'})do T.eq(b.sprite[key],a.sprite[key],key..' tick '..tick);checks=checks+1 end end
+   T.eq(nativeCries,#calls);T.eq(doneA,doneB)
+   base.step();g.stack:update(1/60)
+  end
+  T.eq(doneA,1);T.eq(doneB,1)
+  love.graphics.newImage=make;image:release();Source.release()
+ end end end
+end
+require('src.core.Sound').playCry=oldCry
+print('FIELD_MOVE_ORACLE_VALUES',checks)
+T.finish('independent immutable field-move state oracle')
diff --git a/tools/gen3_discover.py b/tools/gen3_discover.py
index b3467fc64..bafc3a19c 100644
--- a/tools/gen3_discover.py
+++ b/tools/gen3_discover.py
@@ -15,6 +15,7 @@
 """
 import argparse
 import collections, hashlib, json, sys
+from gen3_field_move_profiles import field_move_profile
 
 BASE = 0x08000000
 NUM_SPECIES = 412      # named species slots, INCLUDING the 25 unused
@@ -5447,6 +5448,7 @@ def main():
         'generation': 3,
         'version': 'emerald',
         'romSha1': sha1,
+        'fieldMoveStreaks': field_move_profile(sha1),
         'romHeader': {'title': data[0xA0:0xAC].decode('ascii', 'replace'),
                       'gameCode': code, 'makerCode': data[0xB0:0xB2].decode('ascii'),
                       'revision': data[0xBC]},
diff --git a/tools/gen3_field_move_profiles.py b/tools/gen3_field_move_profiles.py
new file mode 100644
index 000000000..f30674a00
--- /dev/null
+++ b/tools/gen3_field_move_profiles.py
@@ -0,0 +1,26 @@
+"""Exact-ROM symbol profiles for the two field-move tilemaps.
+
+Primary declarations: pret/{pokefirered,pokeemerald,pokeruby}/src/field_effect.c.
+Offsets are identified file positions, never a cross-edition relocation guess.
+"""
+ROWS = {
+    '41cb23d8dccc8ebd7c649cd8fbb58eeace6e2fdc': ('pokefirered', (0x3CB5F0, 0x3CB7F0, 0x3CB810), (0x3CBA90, 0x3CBB10, 0x3CBB30)),
+    '574fa542ffebb14be69902d1d36f1ec0a4afd71e': ('pokefirered', (0x3CB42C, 0x3CB62C, 0x3CB64C), (0x3CB8CC, 0x3CB94C, 0x3CB96C)),
+    'f3ae088181bf583e55daf962a92bb46f4f1d07b7': ('pokeemerald', (0x55AE50, 0x55B050, 0x55B070), (0x55B2F0, 0x55B370, 0x55B390)),
+    'f28b6ffc97847e94a6c21a63cacf633ee5c8df1e': ('pokeruby', (0x39E914, 0x39EB14, 0x39EB34), (0x39EDB4, 0x39EE34, 0x39EE54)),
+    '3ccbbd45f8553c36463f13b938e833f652b793e4': ('pokeruby', (0x39E75C, 0x39E95C, 0x39E97C), (0x39EBFC, 0x39EC7C, 0x39EC9C)),
+}
+
+
+def field_move_profile(sha1):
+    row = ROWS.get(sha1)
+    if row is None:
+        return None
+    return {
+        'schema': 1, 'romSha1': sha1,
+        'source': f'https://github.com/pret/{row[0]}/blob/master/src/field_effect.c',
+        'strips': {
+            name: dict(zip(('tiles', 'palette', 'tilemap', 'tileCount'), (*offsets, count)))
+            for name, offsets, count in (('outdoors', row[1], 16), ('indoors', row[2], 4))
+        },
+    }
diff --git a/tools/indexed-palette-check/conf.lua b/tools/indexed-palette-check/conf.lua
new file mode 100644
index 000000000..58c3dfea2
--- /dev/null
+++ b/tools/indexed-palette-check/conf.lua
@@ -0,0 +1,8 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.version=love.getVersion()>=12 and '12.0'or'11.5'
+ t.window.width,t.window.height,t.window.vsync=160,96,0
+ t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+ local backend=os.getenv('POKEPORT_GRAPHICS_BACKEND')
+ if t.graphics and backend then t.graphics.renderers={backend}end
+end
diff --git a/tools/indexed-palette-check/main.lua b/tools/indexed-palette-check/main.lua
new file mode 100644
index 000000000..c153fe936
--- /dev/null
+++ b/tools/indexed-palette-check/main.lua
@@ -0,0 +1,82 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- The before-reference follows Cedric's existing native backdrop shader;
+-- its existing Gen2Recomped licence and notices remain applicable.
+function love.errorhandler(err)io.stderr:write(tostring(err)..'\n');return function()return 1 end end
+local root=love.filesystem.getSource():match('^(.*)/tools/indexed%-palette%-check$')or love.filesystem.getWorkingDirectory()
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+require('src.render.LegacyShaderCompat').install()
+local Core=require('src.render.Gen3IndexedPalette')
+local Pal=require('src.core.game3.battle.anim_pal')
+local g=love.graphics
+local checks=0
+local function check(ok,why)checks=checks+1;assert(ok,why)end
+local function read(c)return g.readbackTexture and g.readbackTexture(c)or c:newImageData()end
+local function canvas()return g.newCanvas(16,6,{format='rgba8',dpiscale=1})end
+local function draw(c,shader,image)
+ g.setCanvas(c);g.origin();g.setScissor();g.clear(0,0,0,0);g.setBlendMode('replace','premultiplied');g.setColor(1,1,1,1);g.setShader(shader);g.draw(image);g.setShader();g.setCanvas()
+ return read(c)
+end
+local function pixel(data,x,y,want,why)
+ local r,green,b,a=data:getPixel(x,y)
+ for i,v in ipairs{r,green,b,a}do check(math.abs(v-want[i])<=1/255,why..' channel '..i..' got '..v..' expected '..want[i])end
+end
+local function beforeShader()
+ local uniforms,branches={},{}
+ for i=0,15 do
+  uniforms[#uniforms+1]=('extern vec3 c%d;'):format(i)
+  branches[#branches+1]=(i==0 and 'if'or'else if')..(' (idx<%d.5)rgb=c%d;'):format(i,i)
+ end
+ return g.newShader(table.concat(uniforms,'\n')..[[
+ vec4 effect(vec4 colour,Image tex,vec2 uv,vec2 screen){
+  vec4 px=Texel(tex,uv);number idx=floor(px.r*15.0+0.5);vec3 rgb=c0;
+ ]]..table.concat(branches,'\n')..' return vec4(rgb,px.a)*colour;}')
+end
+function love.load()
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'), 'foreign QA profile')
+ local renderer,version,vendor,device=g.getRendererInfo()
+ print('PALETTE_GPU_BACKEND',renderer,version,vendor,device)
+ local limits=g.getSystemLimits();local keys={};for key in pairs(limits)do keys[#keys+1]=key end;table.sort(keys)
+ for _,key in ipairs(keys)do print('GPU_LIMIT',key,limits[key])end
+ check(renderer:lower():find(assert(os.getenv('POKEPORT_GRAPHICS_BACKEND')),1,true)~=nil,'requested backend was not used')
+ local data=love.image.newImageData(16,6,'rgba8');local alpha={0,.25,.49,.5,.75,1}
+ local normalized,packed={},{ }
+ for i=0,15 do
+  local r,green,b=(i*7+31)%32,(i*13+5)%32,(i*3+11)%32
+  normalized[i+1]={r/31,green/31,b/31,0};packed[i]=Core.pack(r,green,b)
+  for y=0,5 do data:setPixel(i,y,i/15,0,0,alpha[y+1])end
+ end
+ local image=g.newImage(data);image:setFilter('nearest','nearest')
+ local native=Core.new();local reference=beforeShader()
+ for i=0,15 do local c=normalized[i+1];reference:send('c'..i,{c[1],c[2],c[3]})end
+ local nativeCanvas,referenceCanvas=canvas(),canvas()
+ local a=draw(nativeCanvas,assert(native:sendNormalized(normalized)),image)
+ local b=draw(referenceCanvas,reference,image)
+ for y=0,5 do for x=0,15 do pixel(a,x,y,{b:getPixel(x,y)},'native before/after')end end
+ local sourceCanvas=canvas()
+ for _,opaque0 in ipairs{false,true}do
+  local output=draw(sourceCanvas,assert(Pal.send(packed,{opaque0=opaque0})),image)
+  for y=0,5 do for x=0,15 do
+   local c=normalized[x+1];local _,_,_,textureAlpha=data:getPixel(x,y)
+   local want=textureAlpha<.5 and{0,0,0,0}or{c[1],c[2],c[3],x==0 and not opaque0 and 0 or 1}
+   pixel(output,x,y,want,'source palette cutoff / zero-index opacity')
+  end end
+  output:release()
+ end
+ -- A second draw must not change the bank already borrowed by its caller.
+ local other={};for i=1,16 do other[i]={0,0,1}end
+ local sourceBank=os.getenv('POKEPORT_PALETTE_SHARED_NEGATIVE')=='1'and native or Core.new({cutout=true,paletteAlpha=true})
+ local nshader=assert(native:sendNormalized(normalized));local sshader=assert(sourceBank:sendNormalized(other))
+ local nested=draw(nativeCanvas,nshader,image)
+ pixel(nested,7,5,{normalized[8][1],normalized[8][2],normalized[8][3],1},'nested source draw preserves native uniforms')
+ local otherOutput=draw(sourceCanvas,sshader,image);pixel(otherOutput,7,5,{0,0,1,1},'source bank keeps its own palette')
+ local borrowed=Pal.shader();Pal._service:releaseOwner('engine')
+ local retained=draw(nativeCanvas,nshader,image);pixel(retained,7,5,{normalized[8][1],normalized[8][2],normalized[8][3],1},'source retirement preserves native program')
+ check(Pal.shader()~=borrowed,'source retirement recreates only its owned shader')
+ check(nshader==native:shader(),'native bank stays resident')
+ print('INDEXED_PALETTE_GPU_OK',checks,'checks')
+ g.setShader();g.setCanvas();Pal._service:release();native:release()
+ if sourceBank~=native then sourceBank:release()end
+ reference:release();image:release();data:release();a:release();b:release();nested:release();otherOutput:release();retained:release()
+ nativeCanvas:release();referenceCanvas:release();sourceCanvas:release()
+ love.event.quit(0)
+end
diff --git a/tools/native-ball-art/conf.lua b/tools/native-ball-art/conf.lua
new file mode 100644
index 000000000..56023bbc7
--- /dev/null
+++ b/tools/native-ball-art/conf.lua
@@ -0,0 +1,4 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'));t.version='12.0';t.window=false
+ t.modules.graphics=false;t.modules.audio=false;t.modules.joystick=false;t.modules.physics=false
+end
diff --git a/tools/native-ball-art/main.lua b/tools/native-ball-art/main.lua
new file mode 100644
index 000000000..a038e9b33
--- /dev/null
+++ b/tools/native-ball-art/main.lua
@@ -0,0 +1,64 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('NATIVE_TEXT_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+function love.errorhandler(err)print(debug.traceback(tostring(err),2));return function()return 1 end end
+local function read(path)local f=assert(io.open(path,'rb'));local s=f:read('*a');f:close();return s end
+function love.load()
+ assert(love.graphics==nil,'ball art import must not initialize graphics')
+ local J=require('src.link.Json');local V=require('src.core.GameVersion')
+ local X=require('src.import.RomExtractorGen3')
+ local inputs=J.decode(read(assert(os.getenv('NATIVE_TEXT_INPUTS'))))
+ local result={editions={},pass=true,gpu=false,playerProfilesUsed=false,visualAcceptance=false}
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition);require('src.import.CacheFs').prefix=edition..'/'
+  local raw=read(assert(inputs[edition]));local info=V.info()
+  assert(require('src.import.RomVerification').sha1(raw)==info.sha1,'exact native cartridge required')
+  local manifest=J.decode(read(root..'/'..info.manifest))
+  local x=X.new(raw,info,manifest)
+  local art
+  function x:saveImage(image,path)
+   if path=='battle/balls.png'then
+    assert(image:getWidth()==48 and image:getHeight()==192)
+    local cells={}
+    for ball=0,11 do for frame=0,2 do
+     local visible=0
+     for y=ball*16,ball*16+15 do for px=frame*16,frame*16+15 do
+      local _,_,_,a=image:getPixel(px,y);if a>0 then visible=visible+1 end
+     end end
+     assert(visible>0,'empty original ball cell');cells[#cells+1]=visible
+    end end
+    art={width=image:getWidth(),height=image:getHeight(),visiblePixels=cells,
+     rgbaSha256=love.data.encode('string','hex',love.data.hash('sha256',image:getString()))}
+   end
+   image:release()
+  end
+  local task=coroutine.create(function()x:extractBallAnims()end)
+  repeat local ok,why=coroutine.resume(task);assert(ok,why)until coroutine.status(task)=='dead'
+  local r=assert(x._constants and x._constants.gen3BallAnim,'native ball tables unavailable: '..edition)
+  assert(r.size==16 and r.frames==3 and r.count==12 and #r.balls==12)
+  assert(r.images.balls=='assets/generated/battle/balls.png'and art,'native ball art was not composed')
+  if edition=='ruby'or edition=='sapphire'then
+   for name,proof in pairs(assert(manifest.rsBallAnimationEvidence).functions)do
+    local bytes=raw:sub(proof.address+1,proof.address+proof.size)
+    assert(love.data.encode('string','hex',love.data.hash('sha256',bytes))==proof.sha256,name..' differs from original native metadata')
+   end
+   local send=assert(r.timing.sendOut,'verified native RS send-out unavailable')
+   assert(send.frames==25 and send.from.x==24 and send.from.y==68 and send.arc==-30 and send.riseStep==-288)
+   assert(send.foeWait==16 and send.fadeFrames==14 and send.targetOffsetY==24 and send.foeOffsetY==24)
+   assert(r.sounds.caught==371 and r.sounds.click==nil,'RS sound identity was lost')
+   local Ball=require('src.battle.Gen3BallAnim');art.nativeSendOutFrames={}
+   for _,side in ipairs{'player','opponent'}do
+    local ball=Ball.new({constants={gen3BallAnim=r}},{sendOut=side,to={x=176,y=40}})
+    local frames=ball:estimate();assert(frames==(side=='player'and 39 or 30))
+    for i=1,frames do ball:update();assert(ball.frame==i)end
+    assert(ball:isDone()and ball.monScale==1 and not ball.monHidden)
+    art.nativeSendOutFrames[side]=frames
+   end
+  end
+  art.sha1=info.sha1;result.editions[edition]=art
+  print('NATIVE_BALL_ART_EDITION',edition,art.width,art.height,#art.visiblePixels,art.rgbaSha256)
+ end
+ local file=assert(io.open(assert(os.getenv('NATIVE_TEXT_RESULT')),'wb'));file:write(J.encode(result));file:close()
+ print('NATIVE_BALL_ART_OK');love.event.quit(0)
+end
diff --git a/tools/native-ball-palette/conf.lua b/tools/native-ball-palette/conf.lua
new file mode 100644
index 000000000..c021eaf67
--- /dev/null
+++ b/tools/native-ball-palette/conf.lua
@@ -0,0 +1,7 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.version='12.0'
+ t.window.width,t.window.height,t.window.vsync=160,96,0
+ t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+ if t.graphics then t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}end
+end
diff --git a/tools/native-ball-palette/main.lua b/tools/native-ball-palette/main.lua
new file mode 100644
index 000000000..03879f0e4
--- /dev/null
+++ b/tools/native-ball-palette/main.lua
@@ -0,0 +1,48 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+function love.errorhandler(err)io.stderr:write(tostring(err)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local g=love.graphics
+local Ball=require('src.core.game3.battle.ball_open')
+local Core=require('src.render.Gen3IndexedPalette')
+local checks=0
+local function check(ok,why)checks=checks+1;assert(ok,why)end
+function love.load()
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'owned QA identity required')
+ local renderer=g.getRendererInfo()
+ check(renderer:lower():find(assert(os.getenv('POKEPORT_GRAPHICS_BACKEND')),1,true),'requested renderer is active')
+ local pixels=love.image.newImageData(32,4,'rgba8')
+ for y=0,3 do for x=0,31 do pixels:setPixel(x,y,x/31,(31-x)/31,((x*7)%32)/31,y/3)end end
+ local image=g.newImage(pixels);image:setFilter('nearest','nearest')
+ local target=g.newCanvas(32,4,{format='rgba8',dpiscale=1})
+ local prior=g.newShader('vec4 effect(vec4 c,Image t,vec2 uv,vec2 p){return Texel(t,uv)*c;}')
+ g.setShader(prior);check(Ball.setBlendShader(0)==false,'zero coefficient does not replace the caller shader')
+ check(g.getShader()==prior,'inactive blend retains shader identity')
+ local wrong=false;local borrowed
+ for _,coefficient in ipairs{.25,.5,1,4,8,12,15,16,20}do
+  local c=math.min(16,coefficient);local color={1,.75,.5,.625}
+  g.setCanvas(target);g.origin();g.setScissor();g.clear(0,0,0,0)
+  g.setBlendMode('replace','premultiplied');g.setColor(unpack(color))
+  check(Ball.setBlendShader(coefficient,7,23,16),'real blend program installed')
+  borrowed=g.getShader();g.draw(image);g.setShader();g.setCanvas()
+  local output=g.readbackTexture(target)
+  for y=0,3 do for x=0,31 do
+   local r,green,b,a=pixels:getPixel(x,y)
+   r,green,b=math.floor(r*31+.5),math.floor(green*31+.5),math.floor(b*31+.5)
+   local er,eg,eb=Core.blend5(r,green,b,c,7,23,16)
+   local expected={er/31*color[1],eg/31*color[2],eb/31*color[3],a*color[4]}
+   local actual={output:getPixel(x,y)}
+   for i,value in ipairs(actual)do check(math.abs(value-expected[i])<=1.01/255,'RGB555 blend/continuous-alpha channel '..i)end
+   if coefficient==8 and x==0 and y==3 then wrong=math.abs(actual[1]-r/31)>1/255 end
+  end end
+  output:release()
+ end
+ check(wrong,'independent unblended negative is observable')
+ Ball._service:releaseOwner('engine')
+ check(Ball.setBlendShader(8,7,23,16),'retired program can be recreated')
+ check(g.getShader()~=borrowed,'only the source-owned shader is recreated')
+ g.setShader(prior);check(prior:hasUniform('nativePaletteBlend')==false,'caller program has no source uniforms')
+ g.setShader();Ball._service:release();prior:release();target:release();image:release();pixels:release()
+ print('NATIVE_BALL_PALETTE_GPU_OK',renderer,checks)
+ love.event.quit(0)
+end
diff --git a/tools/native-color-effects-gpu/conf.lua b/tools/native-color-effects-gpu/conf.lua
new file mode 100644
index 000000000..c605324a5
--- /dev/null
+++ b/tools/native-color-effects-gpu/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=64,64;t.window.visible=false;t.window.vsync=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false
+end
diff --git a/tools/native-color-effects-gpu/main.lua b/tools/native-color-effects-gpu/main.lua
new file mode 100644
index 000000000..6dbc37a34
--- /dev/null
+++ b/tools/native-color-effects-gpu/main.lua
@@ -0,0 +1,73 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+function love.errorhandler(e)io.stderr:write(debug.traceback(tostring(e),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local g=love.graphics;local Fx=require('src.core.game3.gba_fx');local Alpha=require('src.render.NativeGbaAlpha')
+ local checks,paints=0,0
+ local function check(ok,why)checks=checks+1;assert(ok,why)end
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'own identity')
+ check(g.getRendererInfo():lower():find(os.getenv('POKEPORT_GRAPHICS_BACKEND'),1,true),'requested backend')
+ local rgb={3,13,29};local background={12,4,20};local targetColor={31,0,7}
+ local data=love.image.newImageData(16,16)
+ for y=0,15 do for x=0,15 do data:setPixel(x,y,rgb[1]/31,rgb[2]/31,rgb[3]/31,1)end end
+ local image=g.newImage(data);image:setFilter('nearest','nearest');data:release()
+ local function fade(c,to,n)local out={};for i=1,3 do out[i]=c[i]+math.floor((to[i]-c[i])*n/16)end;return out end
+ local function brighten(c,n)return fade(c,{31,31,31},n)end
+ local function samePixel(pixels,x,y,wanted,label)
+  local r,gg,b,a=pixels:getPixel(x,y)
+  for i,value in ipairs{r,gg,b}do check(math.abs(value-wanted[i]/31)<=1.1/255,label..' channel'..i..' actual'..value..' wanted'..wanted[i]/31)end
+  check(a>.99,label..' alpha')
+ end
+ for _,dpi in ipairs{1,2}do
+  local canvas=g.newCanvas(16,16,{dpiscale=dpi,format='rgba8',msaa=0});canvas:setFilter('nearest','nearest')
+  local function setup()
+   g.setCanvas(canvas);g.origin();g.setScissor();g.setShader();g.setColor(1,1,1,1)
+   g.setBlendMode('replace','premultiplied');g.clear(background[1]/31,background[2]/31,background[3]/31,1)
+  end
+  local function read()
+   g.setCanvas();return g.readbackTexture(canvas)
+  end
+  local function paint()paints=paints+1;g.draw(image,0,0)end
+  for n=0,16 do
+   setup();local before=paints;Fx.draw(paint,{y=n,color=targetColor});check(paints==before+1,'fade callback once')
+   local pixels=read();samePixel(pixels,4*dpi,6*dpi,fade(rgb,targetColor,n),'fade '..n..' dpi'..dpi);pixels:release()
+  end
+  for _,n in ipairs{0,1,8,16}do
+   setup();Fx.draw(paint,{bldy=n});local pixels=read();samePixel(pixels,2*dpi,2*dpi,brighten(rgb,n),'brightness');pixels:release()
+  end
+  for _,pair in ipairs{{0,16},{1,15},{7,9},{8,8},{16,0},{16,16}}do
+   setup();local before=paints
+   Fx.draw(paint,{y=5,color=targetColor},{eva=pair[1],evb=pair[2]})
+   check(paints==before+1,'combined colour/alpha callback once')
+   local colour=fade(rgb,targetColor,5);local wanted={}
+   for i=1,3 do wanted[i]=math.min(31,math.floor((colour[i]*pair[1]+background[i]*pair[2])/16))end
+   local pixels=read();samePixel(pixels,3*dpi,3*dpi,wanted,'combined alpha dpi'..dpi);pixels:release()
+  end
+  setup();Fx.draw(paint,{gray=true,y=4,color=targetColor,bldy=6})
+  local gray=math.floor((rgb[1]*76+rgb[2]*151+rgb[3]*29)/256)
+  local shade=gray>=30 and 31 or gray>=25 and 27 or gray>=20 and 21 or gray>=15 and 16 or gray>=10 and 11 or gray>=5 and 5 or 0
+  local pixels=read();samePixel(pixels,4*dpi,4*dpi,brighten(fade({shade,shade,shade},targetColor,4),6),'grayscale order');pixels:release()
+  local maskData=love.image.newImageData(8,8)
+  for y=0,7 do for x=0,7 do maskData:setPixel(x,y,1,1,1,x<4 and 1 or 0)end end
+  local mask=g.newImage(maskData);mask:setFilter('nearest','nearest');maskData:release()
+  setup();Fx.draw(paint,{objWin={image=mask,x=4,y=4,w=8,h=8,bldy=16}})
+  pixels=read();samePixel(pixels,5*dpi,5*dpi,{31,31,31},'inside object window')
+  samePixel(pixels,10*dpi,5*dpi,rgb,'transparent mask part');samePixel(pixels,2*dpi,2*dpi,rgb,'outside object window');pixels:release()
+  setup();Fx.draw(paint,{band=8});pixels=read()
+  for _,y in ipairs{0,8,15}do samePixel(pixels,5*dpi,y*dpi,brighten(rgb,15-math.abs(y-8)),'band row'..y..' dpi'..dpi)end
+  pixels:release();mask:release()
+  setup();Fx.withClip({x=2,y=3,w=5,h=6},paint);pixels=read()
+  samePixel(pixels,3*dpi,4*dpi,rgb,'inside clip');samePixel(pixels,1*dpi,1*dpi,background,'outside clip');pixels:release()
+  -- Existing default native-alpha users keep their old integer operation.
+  setup();local alpha=Alpha.new();local done,why=alpha:paint(7,9,paint);check(done,why)
+  pixels=read();local wanted={};for i=1,3 do wanted[i]=math.floor((rgb[i]*7+background[i]*9)/16)end
+  samePixel(pixels,3*dpi,3*dpi,wanted,'default native alpha');pixels:release();alpha:release()
+  canvas:release()
+ end
+ Fx._service.release();image:release()
+ print('NATIVE_COLOR_EFFECTS_GPU_OK',checks,paints);love.event.quit(0)
+end
diff --git a/tools/native-fade/host/conf.lua b/tools/native-fade/host/conf.lua
new file mode 100644
index 000000000..9c5d13972
--- /dev/null
+++ b/tools/native-fade/host/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=480,320;t.window.vsync=0;t.window.highdpi=false
+ t.modules.audio,t.modules.joystick,t.modules.physics=false,false,false
+ t.graphics=t.graphics or{};t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+end
diff --git a/tools/native-fade/host/main.lua b/tools/native-fade/host/main.lua
new file mode 100644
index 000000000..da1cd384c
--- /dev/null
+++ b/tools/native-fade/host/main.lua
@@ -0,0 +1,71 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('BATTLE_SOURCE_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+function love.load()
+ local T=require('tests.harness').suite('native fade GPU')
+ local Scope=require('src.render.GraphicsScope')
+ local Layer=require('src.render.FieldFade')
+ local Fade=require('src.ui.game3.fade')
+ local Stream=require('src.core.game3.asset_stream')
+ local Host=require('src.mods.Runtime')
+ local g=love.graphics
+ local renderer,version,vendor,device=g.getRendererInfo()
+ local backend=assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))
+ T.check(renderer:lower():find(backend,1,true)~=nil,'actual requested backend')
+ local source=debug.getinfo(Layer.draw,'S').source
+ T.check(source=='@'..root..'/src/render/FieldFade.lua'or source=='@./src/render/FieldFade.lua','frozen native painter chunk')
+ T.eq(love.filesystem.getWorkingDirectory(),root,'relative chunks resolve against the frozen source')
+ T.eq(love.filesystem.getIdentity(),os.getenv('POKEPORT_IDENTITY'))
+ local comparisons,readbacks=0,0
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  local f=require('tools.session-runtime.fixture').new(edition);local game=f.game
+  game.mods.mods={fade_gpu={enabled=true}};game.renderer={}
+  Host.currentMod='fade_gpu'
+  local width,height=require('src.ui.Theme').uiSize()
+  local canvas=g.newCanvas(width,height,{format='rgba8',dpiscale=1,msaa=0})
+  for mode=0,3 do
+   T.eq(Fade.begin(mode,1),true)
+   local layer=game.stack:top();T.eq(getmetatable(layer),Layer)
+   local white=mode>=2 and 1 or 0
+   for step=0,15 do
+    if step>0 then game.stack:update(1/60)end
+    local alpha=(mode%2==1)and step/16 or 1-step/16
+    T.eq(Fade.t,math.floor(alpha*16+.5))
+    local cover={};game.stack:push(cover)
+    local ok,why=Scope.call(function()
+     g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.setBlendMode('alpha','alphamultiply')
+     g.clear(37/255,103/255,211/255,1)
+     g.setColor(197/255,29/255,61/255,1);g.rectangle('fill',0,0,math.floor(width/3),height)
+     layer:draw()
+    end);assert(ok,why)
+    game.stack:pop()
+    local pixels=g.readbackTexture and g.readbackTexture(canvas)or canvas:newImageData()
+    readbacks=readbacks+1;local bad,maxError=0,0
+    for _,point in ipairs{{0,0},{width-1,0},{0,height-1},{width-1,height-1},{math.floor(width/2),math.floor(height/2)}}do
+     local r,b,c,a=pixels:getPixel(point[1],point[2])
+     local source=point[1]<math.floor(width/3)and{197,29,61}or{37,103,211}
+     for channel,value in ipairs{r,b,c}do
+      local err=math.abs(value*255-(source[channel]*(1-alpha)+255*white*alpha))
+      -- RGBA8 fixed-function factors can truncate an alpha byte before the
+      -- final colour rounding: <1 factor quantum plus <=.5 output quantum.
+      maxError=math.max(maxError,err);if err>1.51 then bad=bad+1 end
+     end
+     if math.abs(a-1)>.001 then bad=bad+1 end
+    end
+    pixels:release();comparisons=comparisons+1
+    T.check(bad==0,'native palette pixels '..edition..' mode '..mode..' step '..step..' error '..maxError)
+    layer:draw();T.eq(game.renderer.screenVeil[1],white);T.eq(game.renderer.screenVeil[2],alpha)
+   end
+   T.eq(Fade.clear(),true);T.eq(game.renderer.screenVeil,nil)
+  end
+  canvas:release();Stream.shutdown();require('src.core.Game3').release();Host.currentMod=nil
+ end
+ T.finish()
+ local report={passed=true,checks=T.checks,comparisons=comparisons,readbacks=readbacks,backend=backend,
+  renderer=renderer,version=version,vendor=vendor,device=device,nativePainter=true,
+  paletteSteps=16,editions=5,wholeWindowVeil=true,playerProfilesUsed=false,gameplayProven=false}
+ local file=assert(io.open(assert(os.getenv('BATTLE_SOURCE_REPORT')),'w'))
+ file:write(require('src.link.Json').encode(report));file:close();love.event.quit(0)
+end
diff --git a/tools/native-field/warp-fixture.lua b/tools/native-field/warp-fixture.lua
new file mode 100644
index 000000000..3548da795
--- /dev/null
+++ b/tools/native-field/warp-fixture.lua
@@ -0,0 +1,32 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+-- Real API-2 loader and native world; only map materialization is synthetic.
+local M={}
+function M.new(edition)
+ local T=require('tests.modkit')
+ local source=require('tools.session-runtime.fixture').new(edition)
+ local game,ow=source.game,source.world
+ local data=T.fixtures.fresh();data.maps=game.data.maps
+ local home,dest='TEST','SOURCE_WARP_DEST'
+ data.maps[home].width,data.maps[home].height=3,3
+ data.maps[dest]={id=dest,width=2,height=3,tileset='FIX',blocks={1}}
+ local run=T.sdk.loadMods({'mods/warp'},{data=data,fs=T.sdk.memfs({
+  ['mods/warp/manifest.json']=[[{"id":"warp","name":"Warp probe","version":"1.0.0","api":2,"entry":"main.lua"}]],
+  ['mods/warp/main.lua']=[[local mod=...;mod.exports.nativeOwner=true]],
+ })})
+ assert(#run.errors==0,table.concat(run.errors,'\n'))
+ game.data,game.mods=run.data,run.loader
+ local f={game=game,ow=ow,player=ow.player,loader=run.loader,home=home,dest=dest,trace={}}
+ function f:arrive()
+  local destination=assert(self.destination)
+  ow.map={id=destination[1],def=game.data.maps[destination[1]],isDoorTileCell=function()return false end}
+  ow.player.cellX,ow.player.cellY,ow.player.facing=destination[2],destination[3],destination[4]
+ end
+ function f:complete(...)if self.callback then self.callback(...)end end
+ function ow:startWarpTo(id,x,y,facing,done,opts)
+  f.trace[#f.trace+1]={mapId=id,x=x,y=y,facing=facing,keepMusic=opts.keepMusic,fade=opts.fade}
+  f.callback=done;f.destination={id,x,y,facing};self.arriveWarp=nil;self.transitioning=true
+ end
+ function f:close()require('src.mods.Loader').teardown();run.release()end
+ return f
+end
+return M
diff --git a/tools/native-frame-widgets-gpu/conf.lua b/tools/native-frame-widgets-gpu/conf.lua
new file mode 100644
index 000000000..c605324a5
--- /dev/null
+++ b/tools/native-frame-widgets-gpu/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=64,64;t.window.visible=false;t.window.vsync=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false
+end
diff --git a/tools/native-frame-widgets-gpu/main.lua b/tools/native-frame-widgets-gpu/main.lua
new file mode 100644
index 000000000..1a68b79b1
--- /dev/null
+++ b/tools/native-frame-widgets-gpu/main.lua
@@ -0,0 +1,83 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+function love.errorhandler(e)io.stderr:write(debug.traceback(tostring(e),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'));package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local g=love.graphics;local P=require('src.ui.game3.presentation');local Font=require('src.render.Font')
+ local V=require('src.core.GameVersion');local G=require('src.core.Game3');local Assets=require('src.render.Assets')
+ local image,exists=Assets.image,Assets.exists;local art={};local checks,frames=0,0
+ local function check(on,why)checks=checks+1;assert(on,why)end
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'owned profile')
+ check(g.getRendererInfo():lower():find(os.getenv('POKEPORT_GRAPHICS_BACKEND'),1,true),'requested backend')
+ local function texture(name,w,h,seed)
+  local data=love.image.newImageData(w,h)
+  for y=0,h-1 do for x=0,w-1 do
+   data:setPixel(x,y,((x*3+seed)%31)/31,((y*7+seed)%29)/29,((x+5*y+seed)%23)/23,1)
+  end end
+  art[name]=g.newImage(data);art[name]:setFilter('nearest','nearest');data:release()
+ end
+ texture('qa-frame-font',128,64,3);texture('qa-frame-user',24,24,5)
+ texture('qa-frame-dialogue',144,8,7);texture('qa-frame-standard',144,8,11);texture('qa-frame-sign',144,8,17)
+ Assets.image=function(path)return art[path]or image(path)end
+ Assets.exists=function(path)return art[path]~=nil or exists(path)end
+ local function setup(target,scale)
+  Font.clearStyles();g.setCanvas(target);g.origin();g.setShader();g.setScissor();g.setDepthMode()
+  g.setBlendMode('alpha','alphamultiply');g.clear(.1,.2,.3,1);g.scale(scale,scale);g.setColor(.2,.3,.4,.5)
+ end
+ local function read(target)
+  g.setCanvas();local data=g.readbackTexture(target);local bytes=data:getString();data:release();return bytes
+ end
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition)
+  local game={data={font={pages={main={image='qa-frame-font',base=128}}}},save={},mods={},stack={states={{}}}}
+  package.loaded['src.core.Game']=game
+  for _,imported in ipairs{false,true}do
+   local def=game.data.font
+   def.frame='drawn';def.frames=imported and{image='qa-frame-user',count=1,cell=24,tile=8}or nil
+   def.dialogueFrame=imported and{image='qa-frame-dialogue',tiles=18}or nil
+   def.standardFrame=imported and{image='qa-frame-standard',tiles=18}or nil
+   def.signpostFrame=imported and{image='qa-frame-sign',tiles=18}or nil
+   Font.load(game.data)
+   for _,dpi in ipairs{1,2}do for _,scale in ipairs{1,2}do
+    local actual=g.newCanvas(240*scale,160*scale,{dpiscale=dpi,format='rgba8',msaa=0})
+    local expected=g.newCanvas(240*scale,160*scale,{dpiscale=dpi,format='rgba8',msaa=0})
+    for _,sample in ipairs{{'drawBox','user',2,3,20,12},{'drawStandardBox','standard',2,3,20,12},
+      {'drawDialogueBox','dialogue',1,14,28,6},{'drawSignpostBox','sign',1,14,28,6}}do
+     local method,style,tx,ty,tw,th=unpack(sample)
+     for _,mode in ipairs{'false','borrow','error'}do
+      P._service.release();setup(expected,scale);Font[method](tx,ty,tw,th)
+      local expectedColor={g.getColor()}
+      -- A native label immediately after the frame makes colour leakage
+      -- visible, rather than checking only the frame's isolated pixels.
+      Font.drawCode(128,24,24)
+      local calls=0
+      P.register('frames',{enabled=function()return true end,draw=function(kind,ctx)
+       calls=calls+1;check(kind=='frame'and ctx.style==style,'actual native frame kind')
+       local x,y,w,h=tx*8,ty*8,tw*8,th*8
+       if imported and(style=='dialogue'or style=='sign')then x,w=(tx-1)*8,(tw+2)*8 end
+       check(ctx.x==x and ctx.y==y and ctx.width==w and ctx.height==h,'actual native painted bounds')
+       if mode=='borrow'then Font[method](tx,ty,tw,th);Font[method](tx,ty,tw,th)
+       elseif mode=='error'then g.push();g.setScissor(0,0,1,1);error('owned frame provider failure')end
+       return false
+      end})
+      setup(actual,scale);P.begin(game,240,160);local depth=g.getStackDepth()
+      Font[method](tx,ty,tw,th)
+      local color={g.getColor()};for i=1,4 do check(color[i]==expectedColor[i],'native post-colour')end
+      Font.drawCode(128,24,24)
+      check(calls==1,'provider sees one native frame, including fallback chains')
+      check(g.getCanvas()==actual and g.getStackDepth()==depth,'canvas/stack fence')
+      check(read(actual)==read(expected),'native frame+following label pixels '..edition..' '..method..' '..mode)
+      P._service.release();frames=frames+1
+     end
+    end
+    actual:release();expected:release()
+   end end
+  end
+  G.release()
+ end
+ g.setCanvas();Assets.image,Assets.exists=image,exists
+ for _,item in pairs(art)do item:release()end
+ print('NATIVE_FRAME_WIDGETS_GPU_OK',checks,frames);love.event.quit(0)
+end
diff --git a/tools/native-help-facts/conf.lua b/tools/native-help-facts/conf.lua
new file mode 100644
index 000000000..56023bbc7
--- /dev/null
+++ b/tools/native-help-facts/conf.lua
@@ -0,0 +1,4 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'));t.version='12.0';t.window=false
+ t.modules.graphics=false;t.modules.audio=false;t.modules.joystick=false;t.modules.physics=false
+end
diff --git a/tools/native-help-facts/main.lua b/tools/native-help-facts/main.lua
new file mode 100644
index 000000000..5d96a35ba
--- /dev/null
+++ b/tools/native-help-facts/main.lua
@@ -0,0 +1,62 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+local root=assert(os.getenv('NATIVE_TEXT_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+function love.errorhandler(err)print(debug.traceback(tostring(err),2));return function()return 1 end end
+local function read(path)local f=assert(io.open(path,'rb'));local value=f:read('*a');f:close();return value end
+function love.load()
+ assert(love.graphics==nil,'native Help import must remain windowless')
+ local J=require('src.link.Json');local V=require('src.core.GameVersion')
+ local F=require('src.import.Gen3HelpFacts');local X=require('src.import.RomExtractorGen3')
+ local inputs=J.decode(read(assert(os.getenv('NATIVE_TEXT_INPUTS'))))
+ local result={editions={},gpu=false,playerProfilesUsed=false,fullGameplay=false}
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition);require('src.import.CacheFs').prefix=edition..'/'
+  local raw=read(assert(inputs[edition]));local info=V.info()
+  assert(require('src.import.RomVerification').sha1(raw)==info.sha1,'exact native cartridge required')
+  local manifest=J.decode(read(root..'/'..info.manifest));local x=X.new(raw,info,manifest)
+  local worker=coroutine.create(function()x:extractConstants()end)
+  repeat local ok,why=coroutine.resume(worker);assert(ok,why)until coroutine.status(worker)=='dead'
+  local help=x._constants.gen3Help
+  if F.supports(edition)then
+   assert(help and help.schema==1 and help.edition==edition and help.romSha1==info.sha1)
+   local catalog=assert(require('src.import.Gen3TextCatalog').extract(x,{}))
+   local labels={help.greeting,help.cancel,help.heading}
+   for _,topic in ipairs(help.topics)do labels[#labels+1]=topic.label;labels[#labels+1]=topic.description end
+   local counts={}
+   for topic,entries in ipairs(help.entries)do
+    counts[topic]=#entries
+    for _,entry in ipairs(entries)do labels[#labels+1]=entry.question;labels[#labels+1]=entry.answer end
+   end
+   for _,name in ipairs{'gString_Help','gText_HelpSystemControls_A_Next','gText_HelpSystemControls_AorBtoCancel',
+    'gText_HelpSystemControls_PickOkEnd','gText_HelpSystemControls_PickOkCancel'}do labels[#labels+1]=name end
+   local nodeKinds,commands,placeholders={},{},{}
+   for _,name in ipairs(labels)do
+    local row=catalog.records[assert(catalog.named[name],'native Help label missing: '..name)]
+    assert(row and type(row.plain)=='string'and type(row.ir)=='table','native Help text lost its IR')
+    for _,node in ipairs(row.ir)do
+     nodeKinds[node.t]=(nodeKinds[node.t]or 0)+1
+     if node.t=='ext'then local key=tostring(node.cmd);commands[key]=(commands[key]or 0)+1 end
+     if node.t=='ph'then local key=tostring(node.code);placeholders[key]=(placeholders[key]or 0)+1 end
+    end
+   end
+   local contextEntries=0
+   for context=0,35 do
+    local row=assert(help.contexts[context])
+    for topic,list in ipairs(row)do for _,id in ipairs(list)do
+     assert(help.entries[topic][id]);contextEntries=contextEntries+1
+    end end
+   end
+   assert(#help.frame.tiles==288 and #help.frame.palette==16)
+   assert(#help.keypad.tiles==2048 and #help.keypad.regions==13)
+   result.editions[edition]={sha1=info.sha1,counts=counts,contexts=36,contextEntries=contextEntries,textReferences=#labels,
+    nodeKinds=nodeKinds,commands=commands,placeholders=placeholders}
+   print('NATIVE_HELP_EDITION',edition,table.concat(counts,','),contextEntries,#labels)
+  else
+   assert(help==nil,'Hoenn acquired an invented Help resource')
+   result.editions[edition]={sha1=info.sha1,absent=true};print('NATIVE_HELP_ABSENT',edition)
+  end
+ end
+ result.pass=true;local f=assert(io.open(assert(os.getenv('NATIVE_TEXT_RESULT')),'wb'));f:write(J.encode(result));f:close()
+ print('NATIVE_HELP_FACTS_OK');love.event.quit(0)
+end
diff --git a/tools/native-party-summary-gpu/conf.lua b/tools/native-party-summary-gpu/conf.lua
new file mode 100644
index 000000000..c605324a5
--- /dev/null
+++ b/tools/native-party-summary-gpu/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=64,64;t.window.visible=false;t.window.vsync=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false
+end
diff --git a/tools/native-party-summary-gpu/main.lua b/tools/native-party-summary-gpu/main.lua
new file mode 100644
index 000000000..0671c0727
--- /dev/null
+++ b/tools/native-party-summary-gpu/main.lua
@@ -0,0 +1,79 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+function love.errorhandler(e)io.stderr:write(debug.traceback(tostring(e),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local g=love.graphics;local Native=require('src.battle.Gen3Battle');local V=require('src.core.GameVersion')
+ local Assets=require('src.render.Assets');local original=Assets.image;local art={}
+ local checks,frames=0,0
+ local function check(ok,why)checks=checks+1;assert(ok,why)end
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'own identity')
+ check(g.getRendererInfo():lower():find(os.getenv('POKEPORT_GRAPHICS_BACKEND'),1,true),'requested backend')
+ local function build(kind,density)
+  local width,height=kind=='bar'and 128 or 32,8
+  local data=love.image.newImageData(width*density,height*density)
+  local tones={{1,0,0},{0,1,0},{0,0,1},{1,1,0}}
+  for y=0,height*density-1 do for x=0,width*density-1 do
+   local xx,yy=math.floor(x/density),math.floor(y/density)
+   if kind=='bar'then data:setPixel(x,y,(xx%31)/31,.5,yy/7,1)
+   else local c=tones[math.floor(xx/8)+1];local a=xx%8==0 or yy==0 and 0 or 1;data:setPixel(x,y,c[1],c[2],c[3],a==true and 0 or a)end
+  end end
+  local image=g.newImage(data);image:setFilter('nearest','nearest');data:release();return image
+ end
+ for density=1,3 do for _,kind in ipairs{'bar','balls'}do art[kind..density]=build(kind,density)end end
+ Assets.image=function(path)return art[path]or original(path)end
+ local party={{species='A',hp=5},{species='B',hp=5,status='PAR'},{species='C',hp=0}}
+ local packed={player={'alive','status','fainted','empty','empty','empty'},opponent={'empty','empty','empty','fainted','status','alive'}}
+ local function setup(canvas)
+  g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.setColor(1,1,1,1)
+  g.setBlendMode('alpha','alphamultiply');g.clear(.125,.25,.5,1)
+ end
+ local function read(canvas)g.setCanvas();local pixels=g.readbackTexture(canvas);local bytes=pixels:getString();pixels:release();return bytes end
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition)
+  for _,dpi in ipairs{1,2}do for _,width in ipairs{240,320}do
+   local actual=g.newCanvas(width,128,{dpiscale=dpi,format='rgba8',msaa=0})
+   local expected=g.newCanvas(width,128,{dpiscale=dpi,format='rgba8',msaa=0})
+   for density=1,3 do
+    local summary={bar='bar'..density,balls='balls'..(4-density),barWidth=128,barHeight=8,ballSide=8,count=6,step=10,
+     icons={empty=0,alive=1,status=2,fainted=3},
+     player={barX=136,barY=96,ballX=160,ballY=88,packFrom=1,packStep=1},
+     opponent={barX=-24,barY=40,ballX=30,ballY=33,packFrom=6,packStep=-1,flip=true}}
+    local battle={introBalls=true,introBallsFrom=100,kind='trainer',playerParty=party,enemyParty=party,
+     data={constants={gen3BattleHud={partySummary=summary}}},game={save={party=party}},gen3SurfaceWidth=function()return width end}
+    for _,player in ipairs{true,false}do for _,age in ipairs{0,7,14,18,30,40}do for _,custom in ipairs{false,true}do
+     local side=summary[player and'player'or'opponent'];local edge=player and width-240 or 0
+     local dx=(side.flip and -1 or 1)*(1-math.min(1,age/14))^2*144
+     local anchor=side.barX+(side.flip and 128 or edge)
+     local opts=custom and{x=anchor+5,y=side.barY+3,ox=2,alpha=.5,slots={'status','alive','fainted','empty','alive','status'},
+      ballHidden={false,true,false,true,false,true},ballOx={1,2,3,4,5,6}}or nil
+     battle.frame=100+age;setup(actual)
+     check(Native.paintPartySummary(battle,player,opts),'actual native party painter')
+     setup(expected)
+     local offsetX,offsetY,alpha=custom and 5 or 0,custom and 3 or 0,custom and .5 or 1
+     dx=custom and 2 or dx;g.setColor(1,1,1,alpha)
+     if side.flip then g.draw(art.bar1,anchor+dx+offsetX,side.barY+offsetY,0,-1,1)
+     else g.draw(art.bar1,anchor+dx+offsetX,side.barY+offsetY)end
+     local slots=custom and opts.slots or packed[player and'player'or'opponent']
+     for slot=1,6 do
+      local visible=custom and not opts.ballHidden[slot]or not custom and age>=14+(slot-1)*4
+      if visible then
+       local quad=g.newQuad(summary.icons[slots[slot]]*8,0,8,8,32,8)
+       local ox=custom and opts.ballOx[slot]or dx
+       g.draw(art.balls1,quad,side.ballX+edge+(slot-1)*10+ox+offsetX,side.ballY+offsetY)
+      end
+     end
+     check(read(actual)==read(expected),'native party pixels '..edition..' dpi '..dpi..' width '..width..' density '..density)
+     check(battle.frame==100+age and battle.introBallsFrom==100,'painting leaves native clocks unchanged');frames=frames+1
+    end end end
+   end
+   actual:release();expected:release()
+  end end
+ end
+ g.setCanvas();Assets.image=original
+ for _,image in pairs(art)do image:release()end
+ print('NATIVE_PARTY_SUMMARY_GPU_OK',checks,frames);love.event.quit(0)
+end
diff --git a/tools/native-presentation-gpu/conf.lua b/tools/native-presentation-gpu/conf.lua
new file mode 100644
index 000000000..c605324a5
--- /dev/null
+++ b/tools/native-presentation-gpu/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=64,64;t.window.visible=false;t.window.vsync=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false
+end
diff --git a/tools/native-presentation-gpu/main.lua b/tools/native-presentation-gpu/main.lua
new file mode 100644
index 000000000..d77f85ec6
--- /dev/null
+++ b/tools/native-presentation-gpu/main.lua
@@ -0,0 +1,67 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+function love.errorhandler(e)io.stderr:write(debug.traceback(tostring(e),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'));package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local g=love.graphics;local P=require('src.ui.game3.presentation')
+ local V=require('src.core.GameVersion');local G=require('src.core.Game3')
+ local R=require('src.render.Renderer');local checks,frames=0,0
+ local function check(on,why)checks=checks+1;assert(on,why)end
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'owned profile')
+ check(g.getRendererInfo():lower():find(os.getenv('POKEPORT_GRAPHICS_BACKEND'),1,true),'requested backend')
+ local function setup(target)
+  g.setCanvas(target);g.origin();g.setShader();g.setScissor();g.setDepthMode()
+  g.setColor(1,1,1,1);g.setBlendMode('alpha','alphamultiply');g.clear(.125,.25,.5,1)
+ end
+ local function picture(width)
+  g.setColor(.9,.1,.2,1);g.rectangle('fill',2,5,width-15,4)
+  g.setColor(.1,.8,.3,.75);g.rectangle('fill',13,29,19,121)
+  g.setColor(.3,.4,1,1);g.rectangle('fill',width-28,107,17,31)
+ end
+ local function read(target)
+  g.setCanvas();local data=g.readbackTexture(target);local bytes=data:getString();data:release();return bytes
+ end
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition)
+  local game={data={},save={},mods={},stack={states={{}}}}
+  package.loaded['src.core.Game']=game
+  for _,dpi in ipairs{1,2}do for _,width in ipairs{240,320}do for _,size in ipairs{{480,320},{640,480}}do
+   local w,h=size[1],size[2]
+   local actual=g.newCanvas(w,h,{dpiscale=dpi,format='rgba8',msaa=0})
+   local expected=g.newCanvas(w,h,{dpiscale=dpi,format='rgba8',msaa=0})
+   for _,mode in ipairs{'false-after-paint','error','disabled','unregistered','handled','nested'}do
+    local on=true;local count=0;local retained
+    local function paint()count=count+1;picture(width)end
+    local function fit()
+     local scale=math.max(1,math.floor(math.min(w/width,h/160)))
+     g.origin();g.translate(math.floor((w-width*scale)/2),math.floor((h-160*scale)/2));g.scale(scale,scale)
+    end
+    P.register('pixels',{enabled=function()return on end,draw=function()return false end,
+     defer=function()return true end,present=function(_,native,ctx)
+      retained=native;check(G.native(ctx.game)==game,'source game view')
+      check(g.getCanvas()==actual,'present retains compositor target')
+      if mode=='error'then g.push();g.setScissor(0,0,1,1);error('provider pixel error')end
+      fit()
+      if mode=='nested'then P.layer('child',function()native();native()end)
+      else native();native()end
+      return mode=='handled'or mode=='nested'
+     end})
+    setup(actual);P.begin(game,width,160);check(P.layer('pixels',paint),'admitted queue')
+    if mode=='disabled'then on=false elseif mode=='unregistered'then P.unregister('pixels')end
+    local depth=g.getStackDepth();P.flush(game,w,h)
+    check(g.getCanvas()==actual,'flush keeps actual canvas')
+    check(g.getStackDepth()==depth,'provider stack restored')
+    check(count==1,'native painter executes once')
+    if retained then check(retained()==false,'paint lease expires')end
+    setup(expected);fit();picture(width)
+    check(read(actual)==read(expected),'native window pixels '..edition..' dpi'..dpi..' width'..width..' '..mode)
+    P._service.release();frames=frames+1
+   end
+   actual:release();expected:release()
+  end end end
+  G.release()
+ end
+ g.setCanvas();print('NATIVE_PRESENTATION_GPU_OK',checks,frames);love.event.quit(0)
+end
diff --git a/tools/native-rs-cursor-gpu/conf.lua b/tools/native-rs-cursor-gpu/conf.lua
new file mode 100644
index 000000000..c605324a5
--- /dev/null
+++ b/tools/native-rs-cursor-gpu/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=64,64;t.window.visible=false;t.window.vsync=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false
+end
diff --git a/tools/native-rs-cursor-gpu/main.lua b/tools/native-rs-cursor-gpu/main.lua
new file mode 100644
index 000000000..d2b827b20
--- /dev/null
+++ b/tools/native-rs-cursor-gpu/main.lua
@@ -0,0 +1,121 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+function love.errorhandler(e)io.stderr:write(debug.traceback(tostring(e),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local g=love.graphics;local checks,frames=0,0
+ local function check(ok,why)checks=checks+1;assert(ok,why)end
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'own identity')
+ check(g.getRendererInfo():lower():find(os.getenv('POKEPORT_GRAPHICS_BACKEND'),1,true),'requested backend')
+ local Assets=require('src.render.Assets');local Cursor=require('src.ui.Gen3RsMenuCursor')
+ local Public=require('src.ui.game3.rs.menu_cursor');local Fx=require('src.core.game3.gba_fx')
+ local V=require('src.core.GameVersion');local Writer=require('src.import.LuaWriter')
+ local Chrome=require('src.ui.game3.battle_chrome');local Font=require('src.render.Font')
+ local Text=require('src.ui.game3.frlg_font')
+ local originalImage,originalExists=Assets.image,Assets.exists;local art={}
+ Assets.image=function(path)return art[path]or originalImage(path)end
+ Assets.exists=function(path)return art[path]~=nil or originalExists(path)end
+ local names={'left','middle','wide','right'}
+ local widths={left=8,middle=8,wide=32,right=8}
+ local function build(part,density)
+  local width=widths[part];local d=love.image.newImageData(width*density,16*density)
+  local tone=({left={1,0,0},middle={0,1,0},wide={0,0,1},right={1,1,0}})[part]
+  for y=0,16*density-1 do for x=0,width*density-1 do
+   local xx,yy=math.floor(x/density),math.floor(y/density)
+   local alpha=(yy<3 or yy>12 or xx<3 or xx>width-4)and 1 or 0
+   d:setPixel(x,y,tone[1],tone[2],tone[3],alpha)
+  end end
+  local image=g.newImage(d);image:setFilter('nearest','nearest');d:release();return image
+ end
+ local atlas=love.image.newImageData(128,64)
+ for y=0,63 do for x=0,127 do local c=x%8<4 and 0 or 1;atlas:setPixel(x,y,c,c,c,1)end end
+ art['qa-font']=g.newImage(atlas);art['qa-font']:setFilter('nearest','nearest');atlas:release()
+ for _,part in ipairs(names)do for density=1,3 do art[part..density]=build(part,density)end end
+ local plans={
+  [42]={{'right',35},{'wide',9},{'wide',1},{'left',-1}},
+  [72]={{'right',65},{'wide',33},{'wide',1},{'left',-1}},
+ }
+ local function setup(canvas)
+  g.setCanvas(canvas);g.origin();g.setShader();g.setScissor();g.setColor(1,1,1,1)
+  g.setBlendMode('alpha','alphamultiply');g.clear(.125,.25,.5,1)
+ end
+ local function read(canvas)g.setCanvas();return g.readbackTexture(canvas)end
+ local function same(a,b,why)
+  local x,y=read(a),read(b);check(x:getString()==y:getString(),why);x:release();y:release()
+ end
+ local path='data/generated/gba/rse/common_ui/manifest.lua';assert(love.filesystem.createDirectory('data/generated/gba/rse/common_ui'))
+ for _,edition in ipairs{'ruby','sapphire'}do
+  V.set(edition);local game={data={constants={gen3RsBag={format=1,version=edition,common=path}}}}
+  package.loaded['src.core.Game']=game
+  for _,dpi in ipairs{1,2}do
+   local actual=g.newCanvas(96,32,{dpiscale=dpi,format='rgba8',msaa=0})
+   local expected=g.newCanvas(96,32,{dpiscale=dpi,format='rgba8',msaa=0})
+   for density=1,3 do
+    local manifest={game=edition,layout='rs',menuCursor={}}
+    for _,part in ipairs(names)do manifest.menuCursor[part]={png=part..density,w=widths[part],h=16}end
+    assert(love.filesystem.write(path,Writer.encode(manifest)));Cursor._service.release()
+    for _,width in ipairs{42,72}do for _,fx in ipairs{false,{y=7,color={31,0,17}},{gray=true},{bldy=8}}do
+     setup(actual);check(Public.draw(4,8,width,fx),'actual native cursor painter')
+     setup(expected)
+     for _,row in ipairs(plans[width])do
+      Fx.draw(function()g.setColor(1,1,1,1);g.draw(art[row[1]..1],4+row[2],8)end,fx)
+     end
+     same(actual,expected,'logical cursor density '..density..' dpi '..dpi..' width '..width);frames=frames+1
+    end end
+   end
+   actual:release();expected:release()
+  end
+ end
+ -- The full native font shader must receive the indexed colour record.
+ local function rgb(word)
+  local out={};for i=1,3 do local n=math.floor(word/32^(i-1))%32;out[i]=(n*8+math.floor(n/4))/255 end
+  return out
+ end
+ for n,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition);local palette={};for i=1,16 do palette[i]=(i*1733+n*523)%32768 end
+  local windowPalette,ppPalette={},{}
+  for i=1,16 do windowPalette[i]=(palette[i]+173)%32768;ppPalette[i]=(palette[i]+743)%32768 end
+  local record={images={},format=1,version=edition,palette=palette,windowPalette=windowPalette,ppPalette=ppPalette}
+  local game={data={constants={},font={pages={main={image='qa-font',base=128,preTinted=true}},charmap={{code=128,seq='A'}}}}}
+  game.data.constants[(edition=='ruby'or edition=='sapphire')and'gen3RsBattlePanel'or'gen3BattleTextbox']=record
+  if edition=='ruby'or edition=='sapphire'then
+   game.data.constants.gen3RsBag={format=1,version=edition,palette=windowPalette};ppPalette=windowPalette
+  end
+  package.loaded['src.core.Game']=game;Font.load(game.data)
+  local manifest=Chrome.manifest()
+  check(#manifest.windowTextPal==16,'native window palette exposed')
+  check(#manifest.ppTextPal==16,'native PP palette exposed')
+  for _,dpi in ipairs{1,2}do
+   local canvas=g.newCanvas(16,16,{dpiscale=dpi,format='rgba8',msaa=0})
+   for fg=0,15 do
+    local shadow=15-fg;setup(canvas);Text.draw('A',0,0,{colors=Chrome.textboxColors(fg,shadow)})
+    local pixels=read(canvas)
+    for _,sample in ipairs{{2,rgb(palette[fg+1])},{6,rgb(palette[shadow+1])}}do
+     local r,gg,b,a=pixels:getPixel(sample[1]*dpi,2*dpi)
+     for i,value in ipairs{r,gg,b}do check(math.abs(value-sample[2][i])<=1.1/255,'native font palette pixel')end
+     check(a>.99,'native font palette alpha')
+    end
+    pixels:release();frames=frames+1
+   end
+   for _,name in ipairs{'windowTextPal','ppTextPal'}do for fg=0,15 do
+    local shadow=15-fg;local words=manifest[name]
+    setup(canvas);Text.draw('A',0,0,{colors={fg=rgb(words[fg+1]),shadow=rgb(words[shadow+1])}})
+    local pixels=read(canvas);local native=name=='windowTextPal'and windowPalette or ppPalette
+    for _,sample in ipairs{{2,rgb(native[fg+1])},{6,rgb(native[shadow+1])}}do
+     local r,gg,b,a=pixels:getPixel(sample[1]*dpi,2*dpi)
+     for i,value in ipairs{r,gg,b}do check(math.abs(value-sample[2][i])<=1.1/255,'manifest font palette pixel')end
+     check(a>.99,'manifest font palette alpha')
+    end
+    pixels:release();frames=frames+1
+   end end
+   canvas:release()
+  end
+ end
+ g.setCanvas();Cursor._service.release();Fx._service.release()
+ Assets.image,Assets.exists=originalImage,originalExists
+ for _,image in pairs(art)do image:release()end
+ print('NATIVE_RS_CURSOR_GPU_OK',checks,frames);love.event.quit(0)
+end
diff --git a/tools/native-text-pen-gpu/conf.lua b/tools/native-text-pen-gpu/conf.lua
new file mode 100644
index 000000000..c605324a5
--- /dev/null
+++ b/tools/native-text-pen-gpu/conf.lua
@@ -0,0 +1,6 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.window.width,t.window.height=64,64;t.window.visible=false;t.window.vsync=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false
+end
diff --git a/tools/native-text-pen-gpu/main.lua b/tools/native-text-pen-gpu/main.lua
new file mode 100644
index 000000000..2bfe65e13
--- /dev/null
+++ b/tools/native-text-pen-gpu/main.lua
@@ -0,0 +1,67 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+io.stdout:setvbuf('no')
+function love.errorhandler(e)io.stderr:write(debug.traceback(tostring(e),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local g=love.graphics;local checks,frames=0,0
+ local function check(ok,why)checks=checks+1;assert(ok,why)end
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'own profile')
+ check(g.getRendererInfo():lower():find(os.getenv('POKEPORT_GRAPHICS_BACKEND'),1,true),'requested backend')
+ local Font=require('src.render.Font');local F=require('src.ui.game3.frlg_font')
+ local Assets=require('src.render.Assets');local V=require('src.core.GameVersion')
+ local old=Assets.image;local art={}
+ for _,height in ipairs{8,13}do
+  local pixels=love.image.newImageData(128,16*height)
+  for y=0,16*height-1 do for x=0,127 do
+   local xx,yy=x%8,y%height
+   local tile=math.floor(x/8)+16*math.floor(y/height)
+   local c=((xx+tile)%8<2 or yy==1+tile%3 or xx==yy%7)and 0 or 1
+   pixels:setPixel(x,y,c,c,c,1)
+  end end
+  art[height]=g.newImage(pixels);art[height]:setFilter('nearest','nearest');pixels:release()
+ end
+ Assets.image=function(path)return art[path]or old(path)end
+ local function code(cmd,n)return string.char(0xfc,cmd,n)end
+ local raw=code(0x11,2)..code(0x14,6)..'Aé<PK>'
+ local colors={fg={.1,.6,.9,1},shadow={.9,.2,.4,1}}
+ local function setup(canvas,scale)
+  g.setCanvas(canvas);g.origin();g.scale(scale);g.setShader();g.setScissor();g.setColor(1,1,1,1)
+  g.setBlendMode('alpha','alphamultiply');g.clear(.125,.25,.5,1)
+ end
+ local function read(canvas)g.setCanvas();local d=g.readbackTexture(canvas);local s=d:getString();d:release();return s end
+ for _,edition in ipairs{'firered','leafgreen','emerald','ruby','sapphire'}do
+  V.set(edition)
+  Font.load({font={pages={main={image=8,base=0,glyphWidth=8,glyphHeight=8,advance=4,preTinted=true}},
+   faces={small={image=13,base=0,glyphWidth=8,glyphHeight=13,advance=3,preTinted=true}},
+   charmap={{seq='A',code=128},{seq='é',code=129},{seq='<PK>',code=130}}}})
+  for _,dpi in ipairs{1,2}do for _,scale in ipairs{1,2}do
+   local actual=g.newCanvas(64*scale,48*scale,{dpiscale=dpi,format='rgba8'})
+   local expected=g.newCanvas(64*scale,48*scale,{dpiscale=dpi,format='rgba8'})
+   for _,hd in ipairs{false,true}do Font.hd=hd
+   for _,small in ipairs{false,true}do
+    local opts={small=small,colors=colors}
+    setup(actual,scale);local shader=g.getShader();local depth=g.getStackDepth()
+    check(F.draw(raw,5,7,opts)==20,'fixed-cell native width')
+    check(g.getCanvas()==actual and g.getShader()==shader and g.getStackDepth()==depth,'graphics ownership')
+    setup(expected,scale)
+    for i,glyph in ipairs{'A','é','<PK>'}do F.draw(glyph,7+(i-1)*6,7,opts)end
+    check(read(actual)==read(expected),'positioned Unicode/ligature pixels '..edition);frames=frames+1
+    setup(actual,scale)
+    local total=0;for code=0x55,0x59 do total=total+F.advance(code,opts)end
+    check(F.draw('{POKEBLOCK}',5,7,opts)==total,'compound uses selected native face metrics')
+    setup(expected,scale);local pen=5
+    for code=0x55,0x59 do F.drawGlyph(code,pen,7,opts);pen=pen+F.advance(code,opts)end
+    check(read(actual)==read(expected),'native compound glyph identities/order/positions '..edition);frames=frames+1
+    setup(actual,scale);local ok=pcall(F.draw,'A'..string.char(0xfc,0x11),5,7,opts)
+    check(not ok,'truncated raw control refused')
+    setup(expected,scale);check(read(actual)==read(expected),'error paints no partial label');frames=frames+1
+   end end
+   actual:release();expected:release()
+  end end
+ end
+ Font.hd=false;g.setCanvas();Assets.image=old;for _,a in pairs(art)do a:release()end
+ print('NATIVE_TEXT_PEN_GPU_OK',checks,frames);love.event.quit(0)
+end
diff --git a/tools/native-ui-pass-gpu/conf.lua b/tools/native-ui-pass-gpu/conf.lua
new file mode 100644
index 000000000..bbf639a32
--- /dev/null
+++ b/tools/native-ui-pass-gpu/conf.lua
@@ -0,0 +1,7 @@
+function love.conf(t)
+ t.identity=assert(os.getenv('POKEPORT_IDENTITY'))
+ t.version='12.0';t.window.width=320;t.window.height=240
+ t.window.visible=true;t.window.vsync=0;t.window.msaa=0
+ t.graphics.renderers={assert(os.getenv('POKEPORT_GRAPHICS_BACKEND'))}
+ t.modules.audio=false;t.modules.joystick=false;t.modules.physics=false
+end
diff --git a/tools/native-ui-pass-gpu/main.lua b/tools/native-ui-pass-gpu/main.lua
new file mode 100644
index 000000000..4d2b069d4
--- /dev/null
+++ b/tools/native-ui-pass-gpu/main.lua
@@ -0,0 +1,100 @@
+-- Copyright (c) 2026 Roxas2712. See LICENSE-ROXAS2712.md.
+function love.errorhandler(err)io.stderr:write(debug.traceback(tostring(err),2)..'\n');return function()return 1 end end
+local root=assert(os.getenv('NATIVE_BALL_ENGINE'))
+package.path=root..'/?.lua;'..root..'/?/init.lua;'..package.path
+local g=love.graphics;local checks=0
+local function check(ok,why)checks=checks+1;assert(ok,why)end
+local function read(canvas)local data=g.readbackTexture(canvas);local value=data:getString();data:release();return value end
+local ran=false
+function love.draw()
+ if ran then return end;ran=true
+ local renderer=g.getRendererInfo()
+ check(renderer:lower():find(assert(os.getenv('POKEPORT_GRAPHICS_BACKEND')),1,true),'actual requested renderer')
+ check(love.filesystem.getIdentity():match('^oasc%-gen2recomp%-qa%-'),'owned QA identity')
+ local Pass=require('src.ui.game3.ui_pass');local base=Pass.drawUi
+ local NativeGame=require('src.core.Game');local R=require('src.render.Renderer');R:init()
+ -- Capture the real compositor through its existing output-owner contract.
+ -- These pixel tests require no default-window framebuffer or OS acceptance.
+ local Runtime=require('src.mods.Runtime')
+ local events,hooks,errors=Runtime.events,Runtime.hooks,Runtime.errors
+ local output=require('src.mods.Hooks').new();local completed,frameCanvas=0,nil
+ output:wrap('render.output_enabled',function()return true end,0,'ui-pass-qa')
+ output:wrap('render.output',function(_,ctx)
+  completed=completed+1;frameCanvas=ctx.canvas;return true
+ end,0,'ui-pass-qa')
+ Runtime.install(events,output,{})
+ local f=require('tools.battle-source-runtime.fixture').new('firered')
+ local game=setmetatable(f.game,{__index=NativeGame});package.loaded['src.core.Game']=game
+ local world={isOpaque=true,isOverworld=true,uiSize=function()return 240,160 end,draw=function()
+  g.setColor(.125,.25,.5,1);g.rectangle('fill',0,0,240,160)
+ end};game.overworld=world;game.stack:push(world)
+ local b=f.fresh('TACKLE').battle;b.enter=false;b.isOpaque=false
+ b.draw=function()g.setColor(1,.5,0,1);g.rectangle('fill',40,40,20,20)end;game.stack:push(b)
+ local paints=0
+ local a={isOpaque=false,uiSize=function()return 240,160 end,draw=function()
+  paints=paints+1;g.setColor(0,1,1,1);g.rectangle('fill',10,10,17,9)
+ end}
+ local c={isOpaque=false,uiSize=function()return 240,160 end,draw=function()
+  paints=paints+1;g.setColor(1,0,1,1);g.rectangle('fill',80,60,13,7)
+ end};game.stack:push(a);game.stack:push(c)
+ local function frame(mode)
+  if mode=='absent'then package.loaded['src.ui.game3.ui_pass']=nil
+  else package.loaded['src.ui.game3.ui_pass']=Pass end
+  Pass.drawUi=mode=='wrapped'and function()base();return base()end
+   or mode=='held'and function()return false end or base
+  local before,clock,frames=paints,b.frame,completed;NativeGame._draw(game)
+  check(paints-before==(mode=='held'and 0 or 2),'native overlays paint exactly once')
+  check(b.frame==clock,'UI drawing has no command clock')
+  check(completed==frames+1 and frameCanvas~=nil,'actual compositor completes one owned output frame')
+  return read(R.canvas),read(frameCanvas)
+ end
+ local original,originalFrame=frame('absent')
+ local native,nativeFrame=frame('default')
+ check(native==original and nativeFrame==originalFrame,'default module preserves native and composed pixels')
+ native,nativeFrame=frame('wrapped')
+ check(native==original and nativeFrame==originalFrame,'repeated base calls preserve native and composed pixels')
+ local underlay,underlayFrame=frame('held')
+ for _,dpi in ipairs{1,2}do
+  local hud=g.newCanvas(240,160,{format='rgba8',dpiscale=dpi,msaa=0})
+  local expected=love.image.newImageData(240*dpi,160*dpi,'rgba8')
+  for y=0,160*dpi-1 do for x=0,240*dpi-1 do
+   if x>=10*dpi and x<27*dpi and y>=10*dpi and y<19*dpi then expected:setPixel(x,y,0,1,1,1)
+   elseif x>=80*dpi and x<93*dpi and y>=60*dpi and y<67*dpi then expected:setPixel(x,y,1,0,1,1)end
+  end end
+  local function capture(shift)
+   g.setCanvas(hud);g.origin();g.setShader();g.setScissor();g.clear(0,0,0,0);g.setCanvas()
+   Pass.drawUi=function()
+    g.setCanvas(hud);g.origin();g.setShader();g.setScissor();g.translate(shift or 0,0);base();return base()
+   end
+   local before=paints;NativeGame._draw(game);check(paints==before+2,'redirected native UI paints once')
+   check(read(R.canvas)==underlay,'world and battle are never captured into the HUD')
+   check(read(frameCanvas)==underlayFrame,'redirected UI is absent from the owned world/battle output')
+   return read(hud)
+  end
+  check(capture()==expected:getString(),'redirected UI matches independent physical-pixel rectangles dpi'..dpi)
+  check(capture(1)~=expected:getString(),'positive control detects one logical pixel displacement')
+  expected:release();hud:release()
+ end
+ -- This boundary must also restore the physical clip when a source fails
+ -- after leaking a push and changing the render target's pixel density.
+ local caller=g.newCanvas(240,160,{format='rgba8',dpiscale=2,msaa=0})
+ local foreign=g.newCanvas(8,4,{format='rgba8',dpiscale=1,msaa=0})
+ local shader=g.newShader('vec4 effect(vec4 c,Image t,vec2 uv,vec2 p){return Texel(t,uv)*c;}')
+ g.setCanvas(caller);g.origin();g.setShader();g.setScissor();g.clear(.2,.3,.4,1)
+ g.setShader(shader);g.setScissor(2,1,236,110);local depth=g.getStackDepth()
+ Pass.drawUi=function()g.push('all');g.setCanvas(foreign);g.setScissor(1,1,2,2);error('intentional UI target failure')end
+ local ok,why=pcall(Pass._nativeDrawUi,game,function()error('failed callback must not reach native UI')end)
+ check(not ok and tostring(why):find('intentional UI target failure',1,true),'source failure retained')
+ check(g.getCanvas()==caller and g.getShader()==shader and g.getStackDepth()==depth,'borrowed graphics state restored')
+ g.setShader();g.setColor(1,0,1,1);g.rectangle('fill',0,0,240,160);g.setCanvas();g.setScissor()
+ local pixels=g.readbackTexture(caller)
+ for _,point in ipairs{{0,0},{3,2},{4,2},{6,4},{474,220},{478,224}}do
+  local x,y=point[1],point[2];local red=pixels:getPixel(x,y)
+  local inside=x>=4 and x<476 and y>=2 and y<222
+  check(math.abs(red-(inside and 1 or .2))<=1.01/255,'physical native UI clip at '..x..','..y)
+ end
+ pixels:release();caller:release();foreign:release();shader:release();Pass.drawUi=base
+ for _=1,4 do game.stack:pop()end;f.close();require('src.core.Game3').release()
+ Runtime.install(events,hooks,errors)
+ print('NATIVE_UI_PASS_GPU_OK',renderer,checks);love.event.quit(0)
+end
diff --git a/tools/session-runtime/check.lua b/tools/session-runtime/check.lua
new file mode 100644
index 000000000..fb166e006
--- /dev/null
+++ b/tools/session-runtime/check.lua
@@ -0,0 +1,118 @@
+package.path='./?.lua;./?/init.lua;'..package.path
+love=require('tests.love_stub')
+local T=require('tests.harness')
+local R=require('src.core.game3.runtime')
+local G=require('src.core.Game3')
+local NativeSession=require('src.compat.gen1.NativeSession')
+local Views=require('src.compat.gen1.SessionView')
+local NativeRuntime=require('src.mods.Runtime')
+T.eq(package.loaded['src.core.Game'],nil,'queries never bootstrap the native Game')
+T.eq(R.isActive(),false);T.eq(R.getSession(),nil);T.eq(R.defer(function()end),false)
+T.eq(R.update(),nil);T.eq(R.drainDeferred(),0)
+T.eq(G.new(),nil,'a source constructor cannot silently share another live game')
+local F=require('tools.session-runtime.fixture')
+local Touch=require('src.core.TouchControls');local poll=Touch.pollTouches;Touch.pollTouches=function()end
+local baseUpdate,baseFixed,baseRuntime,baseReset,baseDraw=G.update,G.fixedUpdate,R.update,G.reset,G.draw
+for _,edition in ipairs({'firered','leafgreen','emerald','ruby','sapphire'})do
+  R.release();G.release()
+  local f=F.new(edition);local native=f.game;local view=assert(G.forNative(native))
+  T.check(G~=native and view~=native,'source class/instance are distinct from the native Game')
+  T.eq(G.forNative(native),view);T.eq(G.native(view),native);T.eq(NativeSession.game(view),native)
+  T.eq(view.input,native.input);T.eq(view.generation,3);T.eq(view.phase,'field')
+  view.speedOverride=3;T.eq(native.speedOverride,3)
+  T.raises(function()view.speedOverride=0/0 end,'invalid native speed override')
+  view.speedOverride=nil;T.eq(native.speedOverride,nil)
+  local s=assert(R.getSession());T.eq(s,view.session);T.eq(s,view.save)
+  T.eq(s.map,f.canonical);T.eq(s.x,4);T.eq(s.y,4);T.eq(s.name,'NATIVE')
+  T.eq(s.trainerId,37);T.eq(s.gender,0);T.eq(s.money,300);T.eq(s.coins,4)
+  local before=native.save.playTime
+  for _=1,10 do
+    local clock=R.pumpRtc(native,10)
+    T.eq(clock.hours,1);T.eq(clock.minutes,1);T.eq(clock.seconds,1);T.eq(R._playTimeAcc,.25)
+    T.eq(R.tickVblank(s),0,'repeated clock queries cannot tick another owner')
+  end
+  T.eq(native.save.playTime,before,'clock projection never rewrites the native save')
+  s.money=91;s.name='SOURCE';s.gender=1
+  T.eq(native.save.money,91);T.eq(native.save.player.name,'SOURCE');T.eq(native.save.player.gender,1)
+  T.raises(function()s.money=0/0 end,'invalid session');T.raises(function()s.x=99 end,'native command owner')
+  T.eq(f.player.cellX,4,'source session writes cannot teleport the native actor')
+  s.presentation={foo=1};T.eq(native.save.presentation,nil,'presentation extensions stay detached')
+  T.check(type(s.party)=='table'and s.party~=native.save.party,'party is a separate typed observation')
+  native.save.playTime={hours=2,mins=2,secs=3,vblanks=15}
+  T.eq(Views.seconds(native.save),7323.25);T.eq(R._playTimeAcc,.25)
+  T.eq(type(native.save.playTime),'table','old save clocks are observed without normalization writes')
+  native.save.playTime=before
+  -- Preview leases shadow even nil, without touching the real stack/save.
+  local nativeStack=native.stack
+  view.stack=nil;T.eq(view.stack,nil);T.eq(native.stack,nativeStack)
+  view.stack=nativeStack
+  local scratch={name='PREVIEW'};R.session=scratch;T.eq(R.getSession(),scratch)
+  R.session=s;T.eq(R.getSession(),s);T.eq(native.save.player.name,'SOURCE')
+  local seq={}
+  T.eq(R.defer(function()
+    seq[#seq+1]='first';T.eq(R.drainDeferred(),0,'nested drains cannot run the next batch')
+    R.defer(function()seq[#seq+1]='next'end)
+  end),true)
+  R.defer(function()seq[#seq+1]='second'end)
+  T.eq(R.drainDeferred(),0,'only a native fixed step can drain callbacks')
+  local clock=native.save.playTime;native:_step(1/60)
+  T.same(seq,{'first','second'});T.eq(f.nativeUpdates,1);T.eq(f.inputSteps,1)
+  T.eq(native.save.playTime,clock+1/60);T.eq(R.tickVblank(),1)
+  native:_step(1/60);T.same(seq,{'first','second','next'});T.eq(R.tickVblank(),2)
+  NativeRuntime.errors={};NativeRuntime.currentMod='runtime_probe'
+  R.defer(function()error('intentional deferred failure')end)
+  R.defer(function()seq[#seq+1]='after failure'end)
+  NativeRuntime.currentMod=nil
+  native:_step(1/60)
+  T.eq(seq[#seq],'after failure');T.check(NativeRuntime.errors[1]:find('runtime_probe:',1,true)~=nil)
+  -- A callback may replace the save. No later callback from its old cohort runs.
+  R.defer(function()native.save={player=native.save.player,playTime=7,options={}}end)
+  R.defer(function()error('old save callback escaped retirement')end)
+  local old=s;native:_step(1/60)
+  T.eq(native.save.playTime,7,'a retired callback phase cannot tick the replacement save')
+  T.eq(old.map,nil);T.raises(function()old.money=200 end,'retired')
+  T.check(R.getSession()~=old,'replacement save receives a fresh source session view')
+  -- Runtime wrappers can hold the native field, then resume its single owner.
+  local updates=f.nativeUpdates;clock=native.save.playTime;local serial=R.tickVblank()
+  R.update=function()end;native:_step(1/60)
+  T.eq(f.nativeUpdates,updates);T.eq(native.save.playTime,clock);T.eq(R.tickVblank(),serial)
+  R.update=baseRuntime;native:_step(1/60);T.eq(f.nativeUpdates,updates+1)
+  -- The actual native fixed-step entry invokes its source wrapper. Calling
+  -- the captured base twice cannot double input, player, script or clock work.
+  G.fixedUpdate=function(game,dt)T.eq(game,view);baseFixed(game,dt);return baseFixed(game,dt)end
+  updates=f.nativeUpdates;clock=native.save.playTime;local steps=f.inputSteps
+  native:_step(1/60)
+  T.eq(f.nativeUpdates,updates+1);T.eq(f.inputSteps,steps+1);T.eq(native.save.playTime,clock+1/60)
+  G.fixedUpdate=baseFixed
+  -- Real native modal ownership, including the start/save focus exceptions.
+  native.stack:push({screenId='StartMenu',update=function()end})
+  T.eq(R.uiBusy(),true);T.eq(R.fieldScreenOpen(),false)
+  native.stack:push({screenId='SummaryMenu',update=function()end})
+  T.eq(R.fieldScreenOpen(),true)
+  R.setUi({preview=true});T.eq(R.uiBusy(),true);R.setUi(nil)
+  native.stack:pop();native.stack:pop();T.eq(R.uiBusy(),false)
+  local menus=0;local lighting=package.loaded['src.core.game3.league_lighting']
+  package.loaded['src.core.game3.league_lighting']={stop=function()menus=menus+1 end}
+  R.noteFieldFocus(true);R.noteFieldFocus(true);T.eq(menus,1)
+  R.noteFieldFocus(false);package.loaded['src.core.game3.league_lighting']=lighting
+  -- Holding a batch across source preview leases preserves its attribution.
+  R.defer(function()seq[#seq+1]='restored lease'end)
+  local deferred=R._deferred;R._deferred={};native:_step(1/60)
+  T.check(seq[#seq]~='restored lease');R._deferred=deferred;native:_step(1/60)
+  T.eq(seq[#seq],'restored lease')
+  R.defer(function()error('exit callback should be cancelled')end)
+  local calls=0
+  require('src.mods.ModSeams').run('runtime_probe',function()
+    G.reset=function(game)calls=calls+1;T.eq(game.mods,native.mods);return baseReset(game)end
+    G.update=function(...)return baseUpdate(...)end
+  end)
+  require('src.mods.Loader').teardown()
+  T.eq(calls,1,'native teardown invokes source cleanup before wrappers unwind')
+  T.eq(G.update,baseUpdate);T.eq(G.reset,baseReset);T.eq(R.isActive(),false)
+  T.eq(NativeSession.game(view),nil,'retired views cannot fall through to a new native owner')
+  T.eq(G.forNative(view),nil)
+  T.raises(function()baseFixed(view,1/60)end,'retired')
+end
+Touch.pollTouches=poll
+NativeRuntime.errors=nil
+T.finish('native source session lifecycle and fixed-step runtime')