RustNotMC/docs/collision-geometry.md

Horizon collision geometry

The version target is Minecraft Java Edition 26.3. Geometry is a simulation foundation; Horizon has a native client for inspecting a controlled block scene. Live gameplay and entity simulation remain unfinished.

horizon-core::geometry provides Vec3, Aabb, Axis, Direction, BlockHit, and immutable VoxelShape values. Coordinates are doubles. Arithmetic keeps vanilla's operation order, signed zero, NaN comparisons, normalization threshold, and collision epsilon. It does not enable approximate or fused simulation math.

Implemented vector operations include addition/subtraction, vector-to, component products, scaling, normalization, dot/cross products, interpolation, projection, distance/length, horizontal vectors and finite/equality checks. Rotations, look directions, alignment, axis replacement, direction offsets, and pitch/yaw extraction are also implemented. The full Vec3 API and entity integration remain absent.

Trig uses vanilla's 65,536-entry float sine table with double angle scaling and Java long narrowing. The table is generated from the pinned formula in Rust; the geometry suite compares every generated entry against the runtime table. Inverse trig narrows to float at vanilla's conversion points. These comparisons validate the tested platform; other platforms need the same bit comparisons.

Bounding boxes normalize endpoints with Java-compatible min/max. Queries include half-open containment, strict intersection, transforms, distances, ray clipping, block-coordinate construction with wrapping integer endpoints, setters, next-value deflation, and swept-box collision tests. A disjoint intersect preserves vanilla's constructor normalization rather than introducing a different empty-box rule.

Shapes keep exact coordinate arrays and a packed occupancy grid. Greedy boxes are cached once in vanilla order. Collision-distance queries use occupied grid cells; ray and closest-point queries reuse the cached boxes. Column minima/maxima use vanilla's cyclic perpendicular coordinates and infinity for empty/outside cells. Cube shapes retain arithmetic lookup; moved shapes use array lookup even for a zero offset. Ray hits preserve face tie ordering, endpoint exclusion, tolerances, and the 0.001 inside-hit nudge. Boolean shape joins and overlap predicates preserve cube, identical, disjoint and epsilon-merger behavior. Shape operations reject truth tables that fill two empty cells, as vanilla does. Per-axis cube-coordinate metadata survives partial merges and is checked when importing cached shapes. Box construction preserves thin-box rejection and up to 1/8 cube quantization. Optimized joins reconstruct greedy boxes in vanilla order. Face extraction is implemented; edge extraction and shape rotations remain absent.

Discrete axis extrema are retained separately from occupied cells. A box can quantize to no occupied cells while retaining a finite minimum/maximum on other axes. That state affects vanilla's lower-block floor-height lookup. Empty joins also preserve their integer sentinel extrema; optimization and moving an empty shape return the canonical empty shape.

Shape clones preserve identity and share immutable coordinate, occupancy and box storage. New shapes keep separate identities even when their grids are equal. This preserves alias-sensitive join shortcuts and avoids copying large grids when an operation returns an existing shape. The cache importer shares equal grid storage while retaining the distinct vanilla shape identities.

resolve_shape_movement ports vanilla's movement resolver over a supplied shape list: Y first, then horizontal axes in movement-magnitude order, translating the box by resolved motion before each axis query. candidate_step_heights preserves float narrowing, duplicate identity, current-Y exclusion, and sorted candidate heights. resolve_step_movement adds the initial collision and step-up decision, including landing-height adjustment, a second collider query, and the first candidate improving horizontal movement. entity_collision_bounds preserves the initial entity query bounds. These helpers take caller-selected colliders; they do not choose world/entity shapes, set grounding, change velocity, or apply inside-block effects.

The step-up corpus calls the actual private Entity.collide method for 17,680 cases per JAR. Reference fixtures supply entity inputs and controlled block/entity/border shape lists; vanilla performs the movement decisions. Query bounds and results are compared bit for bit. This verifies the decision with those inputs, not live world selection or entity state transitions.

block_floor_height returns the selected shape's maximum Y, or lazily queries the lower shape only when the current one is empty. Its 12,000-case corpus also checks the lower supplier's invocation count against BlockGetter.

traverse_blocks visits blocks in vanilla ray order, including its endpoint nudge, strict corner comparisons, early callback return, integer wrap and signed-zero endpoint equality. It accepts finite rays and an explicit visit budget. Invalid geometry or exceeding that budget returns a typed error; earlier callbacks remain applied. Actual block/fluid ray selection is a separate integration task.

Inclusive block-box iterators preserve X/Y/Z order, while directional iterators preserve vanilla's movement-dependent axis order and corner signs. AABB iteration includes floored maximum faces. They return independent position values and reject true volumes above the positive Java-int domain, instead of reproducing overflowed Java iteration counts.

sweep_intersected_blocks ports movement-path visits from BlockGetter.forEachBlockIntersectedBetween: tiny movement, the initial box, ray-clipped footprints, packed-position deduplication, final box, step indices, and early callback stops. Stationary/tiny movement avoids a deduplication-set allocation. Inputs and computed geometry must be finite; a caller-selected work budget counts ray steps and iterator candidates, including suppressed duplicates. Earlier callbacks are not rolled back on an error. Block effects still need their own implementations and integration with entity movement.

horizon-world::collision::CachedCollisionRegistry imports a private local export of vanilla cache data. The export includes DataVersion, all state descriptors, deduplicated shapes, coordinate-kind metadata, discrete extrema, and a per-state cache index. Import verifies every state ID against the block registry. Section lookup also requires the same borrowed registry. Imported nonempty extrema must agree with occupancy; empty extrema must be in the grid's domain or match vanilla's empty-join sentinel triple. Extrema form part of the grid-sharing key, so equal occupancy does not erase different metadata. There is no fallback shape for an unsupported state: None means block behavior must select it, while a cached empty shape is a valid Some value.

This covers the cached branch of the no-context BlockState.getCollisionShape method. Vanilla's overload taking CollisionContext always calls block behavior; the cache cannot establish entity collision parity. Dynamic and ordinary entity-context selection are implemented as described below. Experimental minecart contexts, world borders, movement integration, fluid simulation, block effects and live collision broad-phase queries remain pending.

Run the comparisons after preparing the pinned artifacts:

python3 tools/test_geometry_parity.py
python3 tools/test_collision_parity.py

Both suites invoke actual vanilla methods from the authenticated client and server JARs. They compare canonical double bits, including infinities/NaNs, rather than using a numerical tolerance. The geometry corpus includes empty and sparse grids, greedy decomposition, overlapping boxes, rays, tiny movements and IEEE boundaries. It compares 1,320,187 output lines per JAR, including 2,400 integer-box iterator cases, 2,400 AABB iterator cases, and 9,022 movement-path traces. The registry suite exercises cached shape queries through resident section IDs, translation at negative and world-border coordinates, and invalid import rejection. Its export records 35,524 cached states, 199 uncached states, 6,093 shape identities, and 330 distinct grids. The comparison runs 213,144 queries plus state/box/identity checks, producing 1,097,456 matching output lines per JAR. These counts describe this branch and corpus; they are not a gameplay coverage percentage.

Raw grids admit at most 1,048,576 cells with strictly increasing, non-NaN coordinates. Oversized or malformed imports/joins return typed errors. This bounded library API does not reproduce Java's complete exception/object surface.

All exported data, test inputs, reference output, and compiled adapters remain under gitignored .local/. Success reports record exact sources, inputs, outputs, and reference hashes. A runner removes its prior success report before running and rejects edits to the captured sources during validation. Passing these suites does not prove whole-game parity or any FPS/render-distance improvement.

Checked-in geometry metadata and cached-collision metadata identify their tested source versions. Reports cover their recorded snapshots; later changes require fresh validation.

Entity obstruction now evaluates ordered candidate snapshots, excluded entity identity, spectator/removal/building flags, shared root-vehicle identity and voxel-shape intersection. Empty shapes skip the query; candidate collection finishes before obstruction evaluation. Unit-block queries translate in floating point, including integer-coordinate boundaries. Run python3 tools/test_entity_obstruction_parity.py to compare against the actual vanilla EntityGetter default methods and entity metadata queries.

The entity-obstruction report records 15,121 matching output lines per JAR over composite shapes, boundary contacts, thin boxes, metadata filters, vehicle roots and injected query failures. The Java fixture privately allocates entity snapshots without running their constructors. Entity lifecycle, spatial indexing and vehicle-tree maintenance remain separate implementation work. Workspace tests, warning-free Clippy and 138 Python tests passed at this snapshot.

Legacy block solidity now uses explicit definition overrides and cached collision bounds, with force-on precedence and native mean-size/height thresholds. The no-context replaceable and liquid flags are kept independently. Solid rendering uses the occlusion definition flag and a full-shape test over imported raw occlusion geometry. Import validates the pinned DataVersion, full state identities and complete block definitions before building a shared property table. Predicates query this table in constant time.

python3 tools/test_block_properties_parity.py compares all 35,723 states and 18,096 synthetic cache/flag/shape cases, including adjacent floating-point values around solidity thresholds and both occlusion flag values. The block-properties report records 197,180 matching lines per JAR. Definition flags, collision and raw occlusion data are private runtime inputs; Rust calculates solidity and solid rendering and caches full-face occlusion masks. Every state and synthetic shape is compared on all six faces; source and fixture hashes are recorded. Item/fluid-context replacement and collision with live entities remain separate work.

Face selection now preserves native cube-axis shortcuts, epsilon sample points, slice coordinates and clamped parent extrema, including sparse slices whose native bounds differ from occupied boxes. Repeated queries share face identities. The FULL, CENTER and RIGID support tests execute against the selected shape. python3 tools/test_face_support_parity.py compares 1,615 input shapes and nested faces, producing 595,686 matching lines per JAR in the face-support report. The refreshed geometry report also retains 1,320,187 matching lines per JAR after face slicing was added. Block-specific support-shape selection is a separate layer.

Registered support caches now derive FULL/CENTER/RIGID masks from privately imported support geometry and share results by shape identity. The importer checks the data kind and full state identities. None explicitly requests uncached behavior; it never becomes an assumed unsupported face. python3 tools/test_block_support_parity.py compares 35,524 cached states across six directions and three support kinds, while retaining 199 uncached states. The cached-support report records 248,867 matching lines per JAR.

Face-cache storage is now lazy and attached to shape identity. Clones share it; new identities and moved shapes start with an empty cache. A regression test checks that cached faces do not retain their parent after it is dropped. The face and geometry differential suites passed again after this allocation change, as did workspace tests, Clippy and 140 Python tests. No FPS claim is inferred from these library checks.

Dynamic support selection now handles bamboo collision offsets, dripstone and sulfur-spike thickness/direction, the empty-context scaffolding support shape, powder snow, and shulker animation-state support faces. Moving-piston lookup preserves missing/wrong block-entity behavior and delegates active entity shape calculation to the world. The dynamic-support report records 4,867,780 matching lines per JAR over 107,308 fixtures covering all 199 uncached states, coordinate boundaries, block-entity snapshots and query failures. Run python3 tools/test_dynamic_support_parity.py to reproduce it. The current suite also compares no-entity-context collision geometry in 60,161 fixtures, including 13,014 shulker progress fixtures. Shulker collision bounds retain native float interpolation and differ from animation-state support faces. BlockCollisionRegistry dispatches cached and dynamic collision queries; entity movement contexts and block-entity lifecycle remain separate work. Workspace tests, warning-free Clippy and seven focused Python tests passed.

Moving-piston collision now selects stationary extended bases and moving heads, translates shapes using native float progress arithmetic, and honors the movement-direction collision exclusion. Interpolation preserves float operation order, including negative partial ticks and IEEE edge cases. The separate collision-related state used for entity pushing retains its own sticky/head rules; entity pushing itself is not implemented by this module.

python3 tools/test_piston_shape_parity.py compares 102,315 fixtures, including every registered moved state and 10,000 raw float interpolation cases. The piston-shape report records 1,096,811 matching lines per JAR. This corpus uses absent block entities for moved-block collision selection. Workspace tests, warning-free Clippy and 142 Python tests passed. Tick progression and live world mutation remain separate work.

The refreshed dynamic-support corpus also includes 9,216 active piston snapshots, composing block-entity lookup with piston collision generation and all support tests. It compares extension/retraction, source heads, progress boundaries, collision exclusions and query failures. These snapshots do not exercise piston ticks, pushed entities or chunk updates.

The archived block-survival snapshot executes 51 rule kinds with 63 distinct rule/tag bindings over registry-bound solid flags, air identity, support tags and FULL/CENTER/RIGID geometry and empty-context collision. The verified snapshot covers all 1,286 pinned block definitions and 35,723 states. Candidate properties select attachment direction, hanging state, door/plant halves and pale moss carpet's serialized bottom property. Pressure plates and cactus flowers preserve repeated neighbor reads. Downward center support applies the unstable-bottom-center tag only where native helpers do. Upper doors require the same block below; upper double plants also require its lower half. Crop survival checks brightness against 8 before querying support; farmland preserves its conditional second read above, and dripleaf stems read both neighbors. Sugar cane, lily pads, frogspawn, spore blossoms, small dripleaves and tall seagrass preserve their independent fluid queries, source/full-water requirements and tag checks. Growing plants preserve head/body identity and kelp support restrictions. Scaffolding recomputes neighbor distance in native order; chorus plants and flowers preserve branching reads and early exits. Piston heads validate base type, facing and extension. Mangrove propagules, speleothems, pitcher crops, bells and shelf mushrooms use their version-specific attachment rules. Multiface blocks, vines, hanging moss, snow layers and sea pickles preserve support/collision query order. Fire uses imported ignition odds and waterlogging; cactus checks horizontal solids and lava before its support and upper liquid state. Paths recognize fence gates, and mushrooms preserve the light-override tag and solid-render requirement.

Interrupted runs can be resumed with python3 tools/test_block_survival_parity.py --resume. The runner verifies source, environment, fixture and compiled-artifact hashes before reusing completed stages. A changed output is regenerated; changed inputs require a fresh run without --resume. Checkpoints stay under .local, and a parity report is written only after both native comparisons pass.

python3 tools/test_block_survival_parity.py compares actual native canSurvive calls in both pinned JARs. The block-survival report records 35,998,488 matching output lines per JAR across 9,229,463 fixtures. Each supported candidate state is exercised; behavior representatives are tested against every neighbor state, changing repeated reads, integer-coordinate wrapping, absent/closed/open shulker snapshots and injected block/entity query failures, plus light thresholds, independent fluid sequences and fluid-query failures. Native method ownership and support-tag fields supply private definition metadata; survival results are calculated in Rust. Workspace tests, Clippy and the 147-test Python suite passed. This establishes the recorded survival scope; full placement, neighbor updates, scheduled behavior and complete block gameplay remain pending.

Collision contexts now preserve empty-context fallback heights, position-only queries, and captured entity position, descending, main-hand and placement flags. Height comparisons retain the native float epsilon widened to double. Null placement factories use -Double.MAX_VALUE; withPosition sets the placement flag and ignores the supplied height when the entity is absent. Empty item stacks match AIR in entity/empty contexts, while position-only contexts never report a held item. Living-entity fluid callbacks run before the same-family exclusion, with the second fluid as their argument, and propagate failures.

python3 tools/test_collision_context_parity.py exercises actual native factories and queries over 8,338 context snapshots, comparing 225,126 output lines per JAR. The context report records the pinned artifacts and exact source/input/output hashes. The corpus includes adjacent representable values around height thresholds, empty shapes, integer-coordinate extremes, NaN/infinity, null entities, item count boundaries, all five fluid types and callback failures. Native entity and stack snapshots are allocated privately without their constructors; this checks query behavior, not entity construction or inventory lifecycle. Inventory changes after context capture, experimental minecart contexts and live movement integration remain pending. Contextual block-shape selection is being added separately.

ScaffoldingCollision now selects stable scaffold geometry, the unstable bottom platform, or an empty shape using the collision context. Placement contexts are always empty. Descending affects the top surface check; the bottom platform also requires nonzero support distance, the bottom flag and the lower height check. No-context support and contextual collision share the same immutable stable shape.

python3 tools/test_scaffolding_collision_parity.py compares all 32 states across 56,448 fixtures, producing 524,300 matching lines per JAR in the scaffolding report. The native context dispatch executes against a world proxy that rejects all queries. Full shape coordinates, bounds, ordered boxes and cube metadata match for empty, position, entity and placement contexts, including adjacent doubles at both height thresholds. Block placement, distance updates, collapse and live entity motion through scaffolding are separate work.

LiquidCollision implements contextual water/lava collision selection. The always-fluid flag returns a full cube before querying entities or neighbors. Otherwise, flowing block levels and nonliving contexts return empty. Source blocks request the living entity's standing shape, check its height, then read the fluid above and invoke the entity's standing predicate. Empty candidate shapes still follow those query rules. Above-block coordinates wrap as Java integers.

python3 tools/test_liquid_collision_parity.py compares all 32 water/lava block states, all 33 possible above-block liquid/empty states, full selected shape data and ordered callback traces, including failures at each query. The liquid-collision report records 571,179 matching lines per JAR. Standing shapes and fluid abilities are controlled inputs in this suite; each entity type still needs its implementation. Fluid spreading, swimming, drowning and live movement remain pending.

Powder snow now selects the native 0.9f-high falling shape when fall distance exceeds 2.5, a full cube for falling-block entities, and a full cube for entities that can walk on it, are above it and are not descending. Placement and absent entity contexts are empty. Walkability checks the entity-type tag first, then leather boots only for living entities; successful tags skip equipment queries. The API takes current entity metadata and lazy tag/equipment providers.

python3 tools/test_powder_snow_collision_parity.py compares 63,336 fixtures and 599,180 matching lines per JAR in the powder-snow report. The native block method and walkability predicate execute over controlled entity snapshots. The corpus covers fall-distance and top-height boundaries, nonfinite values, falling-block instances, item counts, query failures and skipped queries. Entity tag loading, freezing, sinking and live movement remain separate work.

BlockCollisionRegistry::collision_shape_with_context now combines the contextual scaffolding, liquid and powder-snow rules with the existing cached/dynamic paths. It dispatches these overrides before consulting cached geometry. The pinned native audit checks 35,492 context-independent cached states at seven positions with both interface and entity contexts that reject every query: each returns the identical cache object without world reads. The 32 cached liquid states query the context and take their separate behavior path. The 199 uncached states continue through explicit behavior implementations.

python3 tools/test_contextual_collision_parity.py validates integrated dispatch for all 35,723 states, 11 contexts and both fluid-flag inputs: 785,906 fixtures and 2,391,334 matching output lines per JAR in the contextual-registry report. Outputs compare cache-relative shape equality or full uncached geometry, plus ordered world/entity callbacks. This integration corpus supplies missing block entities; active shulker and piston snapshots retain their separate suites. These checks establish the recorded collision-query scope, not entity movement or whole-game parity.

Private shape exports now carry explicit canonical-identity markers. The importer restores the global empty/full-block shapes only when their complete grid metadata matches, and rejects duplicate or malformed canonical claims. Equal unmarked shapes keep distinct identities. Older exports remain readable and report has_canonical_identities() == false; they cannot establish the canonical identity needed by vanilla's block-collision iterator fast path.

The canonical-identity report adds identity checks for every cached state: 5,566 canonical empty, 3,348 canonical full-block and 26,610 other cached states, with 1,132,980 matching output lines per JAR. The integrated contextual comparison also passes again with 2,391,334 lines per JAR in its regression report. Five import tests cover legacy data, equal-but-distinct grids, canonical restoration and malformed identity metadata. Workspace Clippy passes without warnings.

BlockCollisionScan now implements lazy cursor selection around entity bounds. It retains the native epsilon-expanded cursor, X/Y/Z visit order, skipped corners, large-shape face filtering, moving-piston edge filtering and suffocation-before- shape query order. Only successful chunk lookups are reused; absent chunks are queried again. Shape selection uses the global collision world, while suffocation uses the selected chunk. Canonical full blocks use native AABB intersection; other shapes use moved voxel intersection. Returned positions are independent values. Providers supply current block metadata and contextual shape selection.

python3 tools/test_block_collision_scan_parity.py compares 4,176 fixtures and 517,820 matching lines per JAR in the collision-scan report. The native iterator runs over controlled metadata, shapes and chunk availability; traces cover early termination, missing chunks, query failures, thin/zero-width bounds, integer-coordinate wrapping and equal shapes with different canonical identities. Two Rust API tests cover finite/bounded input requirements, cursor visit budgets and termination after errors. Unsupported cursor volumes return errors; Java's overflowing iteration counts are outside this bounded API. Registry/world integration and live movement still need implementation.

BlockCollisionRegistry now prepares native cursor-filter flags for every state: uncached shapes are large, while cached shapes are large when any axis extends outside the unit block. Moving-piston identity is bound to the same registry. SuffocationRegistry binds the native predicate definitions and resolved causes_suffocation tag. Default predicates combine tag membership with full collision geometry; overrides preserve piston extension, constant predicates and lazy shulker block-entity checks. Missing or wrong-type shulker block entities count as suffocating. Tag changes require rebinding the suffocation registry.

python3 tools/test_suffocation_parity.py checks all 35,723 states with natural, empty and all-block tag bindings at four positions, including integer extremes. Every shulker state also covers absent/wrong block entities, all animation states and query failures. The suffocation report records 1,697,193 matching lines per JAR, including scan flags and query traces. These are registry predicates; live collision-world binding, movement and suffocation damage remain separate integration work. The contextual regression also passes again with 2,391,334 lines per JAR, and its all-state native audit now compares large-shape and moving-piston flags. Workspace Clippy passes.

RegistryCollisionWorld now binds BlockCollisionScan directly to registered metadata, contextual shapes and suffocation rules. Chunk providers return current state IDs and a chunk-local block-entity provider; contextual collision uses the global world. Construction rejects legacy collision exports without complete canonical identity metadata, because their unit-block fast paths can differ.

python3 tools/test_registry_collision_scan_parity.py compares native BlockCollisions over resident ProtoChunk sections with the Rust binding over TerrainChunk sections. All registered states cover ordinary and suffocating-only selection. Additional scenes cover partial/dynamic blocks, chunk and build-height boundaries, missing chunks, replacements, early termination and query failures. Shulker fixtures deliberately give the chunk and global providers different entities to check routing. The resident collision report records 3,046,929 matching output lines per JAR. Six collision import/binding tests pass, including legacy-metadata rejection; workspace Clippy passes. Live chunk loading, entity lifecycle, movement and the playable client remain separate integration work.

resolve_world_movement now joins registry-backed block scanning to the native step-up decision. It selects entity colliders once, including for zero/underflow movement, then collects applicable border and block shapes in native order for the initial and optional step query. try_resolve_step_movement accepts owned or borrowed collider lists and propagates provider failures without returning a partial displacement. The shared implementation avoids allocating reference lists for owned shapes; existing borrowed callers retain the same API.

python3 tools/test_world_movement_parity.py runs actual Entity.collide over registered blocks and resident Java sections, comparing the Rust world collector and step solver. Every registered state appears as an obstacle; additional cases cover step heights, grounded/falling motion, ceilings, partial/dynamic blocks, chunk boundaries, zero/underflow motion and failures during collection. The world movement report records 7,062,798 matching lines per JAR. Entity collider lists, border proximity/shapes and collision contexts are controlled fixture inputs. Actual entity selection, border state, travel/gravity/velocity, grounded side effects and playable integration remain pending.

The geometry regression passes again with 1,320,187 lines per JAR, including the existing native step fixtures. All six movement unit tests and workspace Clippy pass. New tests cover owned-query failures during both initial and step collection and signed zero preservation when collection is skipped.

entity_collision_shapes now implements EntityGetter.getEntityCollisions selection over ordered entity snapshots: average-size short circuit, epsilon inflation, exact bounds/excluded-identity filtering, spectator suppression and lazy collision-policy callbacks. With a source entity it invokes that entity's canCollideWith; without one it invokes each candidate's canBeCollidedWith(null). Selected bounds become shapes after policy evaluation. Providers retain responsibility for live storage and each entity type's policy.

python3 tools/test_entity_collision_parity.py compares the actual native getter, default vehicle-root checks and controlled policy overrides, including failures at query/callback boundaries. Tiny/zero-width and nonfinite query boxes, inflated boundary contacts, spectators, shared vehicles, null sources and ordered shape outputs are covered. The entity collision report records 158,558 matching lines per JAR. Workspace Clippy passes. This adds the selection helper needed by movement; live entity indexing, lifecycle and entity-type policy implementations remain pending.

BorderGeometry now models stationary and moving world-border extents, cached stationary collision geometry, center/absolute-limit changes, tick progression, partial-tick bounds and movement proximity. The pinned version decrements size transition progress once per tick. Ordinary bounds and collision shapes use the previous size while moving; completing the transition installs a stationary extent at the target. Collision geometry subtracts the floor/ceil-rounded inner column from the infinite outer shape. Boundary predicates retain their asymmetric inclusive minimum/exclusive maximum tests and native floating-point order.

python3 tools/test_world_border_parity.py compares actual WorldBorder mutation sequences, extent metadata, complete shape geometry and proximity predicates. The border report records 1,138,830 matching lines per JAR, including zero/large durations, wrapping start timestamps, completion, retargeting, signed zero, extreme finite centers/sizes and nonfinite query/interpolation inputs. The supported construction and mutation domain requires finite nonnegative sizes, finite centers and nonnegative absolute limits/durations. A unit test verifies invalid parameters leave the existing extent unchanged; workspace Clippy passes. Saved-data codecs, listeners, dirty-state events, damage, synchronization and live movement binding remain separate work.

restitute_movement now implements the pinned post-collision velocity calculation with lazy entity/block bounce queries, gravity thresholds, nonliving float scaling and air-drag interpolation. It preserves horizontal/vertical collision branches, callback ordering, the position-sync field write and final velocity assignment. Errors retain already performed effects instead of rolling back the world or returning a fabricated successful velocity.

python3 tools/test_restitution_parity.py executes actual Entity.restituteMovementAfterCollisions on living and nonliving snapshots with controlled block restitution and suppression tags. The restitution report records 177,090 matching lines per JAR. Fixtures cover changing lazy getter values, signed zero/nonfinite arithmetic, bounce callbacks that alter velocity, and failures before/after each side effect. Workspace Clippy passes. Registered block property/tag provisioning, actual bounce sounds/events, Entity.move guards, fall damage, grounding and full player simulation remain pending.

find_supporting_block now selects the nearest colliding block center using the native distance arithmetic and wrapping Y/Z/X position tie-break. GroundState implements the thin foot query, previous-horizontal-footprint fallback and both ground/collision flag updates. Null movement preserves the prior support in the native branch where no fallback query can run; query failures retain preceding flag writes.

python3 tools/test_ground_support_parity.py compares actual CollisionGetter.findSupportingBlock, Entity.checkSupportingBlock and both setOnGroundWithMovement overloads. The ground support report records 342,709 selection lines and 151,444 state-transition lines per JAR, covering ties, nonfinite entity positions, missing chunks, query errors, nullable movement and sequential changes of support. Shape/context snapshots are controlled; registry-backed scanning has separate integration coverage. Workspace Clippy passes. Full live entity movement, support-dependent effects and gameplay remain pending. The shared scanner regression also passes with 517,820 matching lines per JAR after extending its fixtures.

movement_support now implements support-dependent positions, the three public offset variants and base-entity block jump/speed factors. It preserves the support X/Z coordinates, conditional fence/wall/gate lookup, float-to-double offset widening, cached entity block position and lazy block queries. Jump-factor lookup always reads the lower block; speed lookup can short-circuit for water, bubble columns or a non-unit current factor.

python3 tools/test_movement_support_parity.py compares the actual native methods with controlled state/tag/property snapshots. The movement support report records 51,572 matching lines per JAR, including float boundaries, nonfinite positions/offsets/factors, tag/type short circuits and errors at every query. Workspace Clippy passes. Registered movement-property provisioning, living-entity efficiency and the full movement lifecycle remain pending.

MovementProperties imports version-bound raw friction, speed, jump, bounce and fall-distance-reduction fields plus fence-gate type. BoundMovementProperties binds resolved fence/wall/bounce-suppression tags; rebinding leaves previous snapshots unchanged. RegistryMovementWorld connects real state IDs from a block provider to the support-position and factor calculations, rejecting unknown IDs.

python3 tools/test_movement_registry_parity.py independently checks native property getters for every state, then runs actual entity support/factor queries over all 35,723 states / 1,286 blocks under normal, empty and universal tags. Mixed-block scenes and failing providers check query order. The registered movement report records 2,300,888 matching lines per JAR. Three import/binding tests and workspace Clippy pass. This provisions movement data; full player travel, live entity state and block bounce effects remain separate integration work.

PistonMovement now accumulates displacement per axis and resets it when the game tick changes. It preserves the initial squared-length short circuit, lazy time lookup, first nonzero axis, the +/-0.51 cumulative clamp and float-derived small-displacement threshold. A failed time lookup leaves the accumulator intact.

python3 tools/test_piston_movement_parity.py runs actual Entity.limitPistonMovement across sequential tick/push inputs. The piston movement report records 325,197 matching lines per JAR, including repeated/opposing pushes, threshold neighbors, signed zero, nonfinite inputs and injected failures. Workspace Clippy passes. Piston block events, entity pushing and the surrounding Entity.move lifecycle remain pending. The registered movement regression passes again with 2,300,888 lines per JAR on the integrated sources.

no_world_collision implements the entity-bearing collision-free query over the registry-bound world. It consumes block collisions lazily, then checks whether the selected entity list is empty, then tests applicable border geometry. Each stage short-circuits the later providers; a nonempty entity list blocks the query even if its supplied shape is empty. Collision contexts are supplied explicitly.

python3 tools/test_world_collision_check_parity.py executes native CollisionGetter.noCollision over registered blocks and resident Java sections. The world collision-check report records 4,793,095 matching lines per JAR. All states, context variants, empty and disjoint controlled entity/border shapes, missing chunks, boundaries and provider failures are covered. Workspace Clippy passes. Null-entity overloads, actual entity-list/border providers and live player ledge behavior remain pending. The shared movement regression also passes with 7,062,798 matching lines per JAR.

back_off_from_edge implements the player ledge guards, above-ground test and X/Z/diagonal displacement reductions. It retains lazy step/staying/grounded queries, float step widening, signed-zero behavior and the exact thin collision probe arithmetic. A caller-supplied query budget bounds nonconverging inputs and returns an error without fabricating a successful displacement.

python3 tools/test_edge_backoff_parity.py executes actual player methods with controlled collision-free query results. The edge backoff report records 46,578 matching lines per JAR, covering all mover types, flight/crouch guards, fall/step and 0.05 thresholds, nonfinite values and query failures. Two query-budget unit tests and workspace Clippy pass. Registered-world ledge probes, live crouching/attribute state and the complete player movement loop are separate integration work.

Registered-world ledge integration now runs back_off_from_edge through no_world_collision and registry-bound resident chunk scans. The native side executes actual Player.maybeBackOffFromEdge and its collision probes over ProtoChunk sections. Every state is used as a supporting block, with additional falling, step-height, chunk-edge, diagonal, dynamic-block and guard/error cases.

python3 tools/test_world_edge_backoff_parity.py passes with 27,109,699 matching lines per JAR in the world ledge report. The shared fixture now supports player probes alongside direct movement and collision checks; workspace Clippy passes. Entity lists, border applicability and collision contexts remain controlled snapshots. A complete player movement/travel loop and playable client remain pending.

check_fall_damage now implements base-entity fall-distance accumulation and landing order. Downward displacement narrows to float before being subtracted from the double fall distance. Grounded landings call the block, read the possibly changed position/support, emit the ground event and reset fall distance. Errors preserve completed field writes and callback effects.

python3 tools/test_fall_damage_parity.py runs actual Entity.checkFallDamage with controlled water, landing and event providers. The base fall report records 44,566 matching lines per JAR, including nonfinite arithmetic, float underflow, callback mutations and failures at every boundary. Workspace Clippy passes. Living-entity fluid/particle behavior, registered block landing effects, health/damage and full movement remain pending.

living_fall implements default living-entity fall power/damage calculation, impulse-height exemption and landing damage callback order. It retains separate immunity checks for passenger propagation and damage calculation, double/float arithmetic and saturating floor-to-int conversion. Positive damage resets the impulse context, selects the fall sound, plays block landing sound and dispatches hurt. A rejected hurt callback does not change the native positive-damage result. ImpulseContext also models setter, grace-extension and reset behavior; disabling ignore clears grace time while retaining the impact position until a later reset.

python3 tools/test_living_fall_parity.py compares actual living methods and sequential impulse changes. The living fall report records 153,025 matching lines per JAR, including changing immunity, passenger callback mutations, nonfinite arithmetic, sound threshold selection and failures after partial state changes. Workspace Clippy passes. Attribute provisioning, passenger storage/recursion, actual health processing, tick/save/network behavior and the complete movement lifecycle remain pending.

push_entities_up implements the block-replacement push: query old/new shapes, subtract old occupied space without optimizing the join, translate to world coordinates and select entities using the added shape's bounds. It reads each current entity box before calculating its upward displacement and invokes a relative teleport even when that displacement is zero.

python3 tools/test_block_push_parity.py compares actual Block.pushEntitiesUp with controlled shapes and selected entity lists. The block push report records 101,006 matching lines per JAR, including empty/redundant geometry, partial shapes, large coordinates, nonfinite entity boxes, mutations of later entities and failures after partial effects. Workspace Clippy passes. Registered replacement dispatch, actual entity selection and teleport/network semantics remain separate integration work.

block_landing binds audited native landing/bounce families to every registered state. It implements fall-distance reduction, hay/honey damage multipliers, slime suppression, powder-snow fall sounds, upward dripstone tips, farmland replacement with occupant pushes, turtle-egg destruction/decrement and shelf mushroom bounce sounds. Random draws, server-class checks, client flags, spawn protection, mob griefing, sounds, writes and events retain native order.

python3 tools/test_block_landing_parity.py invokes registered native methods for all 35,723 states / 1,286 blocks with eight entity class families. The registered landing report records 3,524,267 matching lines per JAR, including float/double boundaries, NaN/infinity, failed writes, callback failures, egg hatch preservation and farmland collision pushes. Targeted Clippy passes. Actual health, live entity selection/storage, teleport/network behavior, audio playback and full movement lifecycle integration remain separate work.

movement_emission accumulates native movement/flight distances, evaluates climbable and powder-snow states, and dispatches step/swim/flap effects. Legacy and current support blocks retain their separate sound/event rules. Threshold updates use Java float-to-int saturation and wrapping integer addition, and sound/event callbacks can change fields observed by subsequent operations.

python3 tools/test_movement_emission_parity.py compares actual native movement emission, block vibration dispatch, flapping and next-step arithmetic. The movement emission report records 598,611 matching lines per JAR across 53,036 fixtures, including predicate combinations, sound/event modes, differing support blocks, nonfinite numbers, mutations and provider failures. Targeted Clippy passes. Sound callbacks are controlled and the crystal-sound predicate is false in this gate; registered sound selection, audio playback and full movement integration remain pending.

entity_move sequences native movement phases: no-physics/piston early exits, stuck multiplier reset, edge backoff, collision resolution, fall-reset clipping, position/recording writes, collision/ground flags, landing, removal, restitution, movement emission and block speed multiplication. MovementHistory retains at most 100 records by merging the oldest pair and dropping their original-axis movement metadata. Callbacks can change fields read by later phases.

python3 tools/test_entity_move_parity.py invokes actual Entity.move with native shape resolution and zero restitution. The movement lifecycle report records 543,653 matching lines per JAR, covering signed zero, tiny/nonfinite movement, collisions, early exits, recording cap, authority guards, landing mutations/removal and failures after partial writes. Targeted Clippy passes. This gate controls piston/edge decisions, ground support, ray hits and landing callbacks; step height is zero and non-passenger emission is tested separately. Binding all phases to a live entity/world and player travel remains pending.

world_ray implements ordered block/fluid ray clipping, nearest-hit selection with block precedence on ties, and interaction-shape overrides that replace only the hit face. It also implements native fluid pick modes and fall-reset shape selection, including player type identity, end portals/gateways and server-side zero-delay Nether portals. Traversal limits and invalid geometry return errors.

python3 tools/test_world_ray_parity.py compares actual BlockGetter.clip and native ClipContext modes. The world ray report records 248,725 matching lines per JAR, including inside hits, ties, misses, interaction geometry, short/signed-zero rays, lazy predicates/rules and provider failures. Targeted Clippy passes. Separate limit tests distinguish a miss from nonfinite geometry, exhausted traversal budget and failed world reads. Shapes and state predicates are controlled; registered shape binding, actual fluid shape caching and full entity/world integration remain pending.

FluidShapeCache matches native registered-fluid shape caching. The first successful lookup of a nonempty fluid state samples the fluid above and retains its resulting shape across later positions/world views. Failed reads leave the state uncached. Empty and full cube shapes preserve canonical identity; distinct noncanonical cached shapes retain their own identities.

python3 tools/test_fluid_shape_parity.py runs every registered native fluid state in changing query sequences. The fluid shape report records 387,950 matching lines per JAR across 5,181 sequences, comparing geometry, cache population, canonical/alias identities, query suppression and failures. Targeted Clippy passes. The pinned registry has no amount-nine state; unsupported custom fluid definitions are outside this module. Fluid propagation, entity immersion and live world/ray integration remain pending.

InteractionShapes imports a complete state-bound table with a distinct table kind and mandatory canonical identity metadata. The pinned owner audit finds only default empty, cauldron, composter, hopper and scaffolding implementations; all are static per state. Geometry uses the existing validated discrete shape importer while preserving eight native shape identities.

python3 tools/test_interaction_shape_parity.py compares every registered state and actual native interaction-face overrides with supplied collision geometry. The interaction shape report records 188,682 matching lines per JAR across all 35,723 states. Native interaction-shape world queries are rejected by the fixture. Import checks reject wrong table kind, partial mappings, missing canonical metadata, foreign state ordering and invalid IDs. Targeted Clippy passes. Registered outline/visual shapes, complete ray-world binding and gameplay integration remain pending.

FallRayRegistry binds fall-reset tags, portal identities, interaction geometry and fluid states to the complete registered block-state table. fall_reset_ray uses that binding with the shared fluid-shape cache and native water selection. Tag reloads produce new validated registry snapshots; unknown tag members and invalid state IDs are rejected.

python3 tools/test_registry_fall_ray_parity.py compares actual registered BlockGetter.clip behavior with native block/fluid tags and shape getters. The registered fall-ray report records 3,024,623 matching lines per JAR across 120,297 fixtures, including all 35,723 states, tag reloads, server/client distinctions, player type checks, portal delays, changing above-fluid states, shared cache reuse and failures. Targeted Clippy passes. World storage is controlled; live entity movement and complete player/world gameplay integration remain pending.

living_landing wraps base fall handling with fluid refresh, server-only changed block notification and landing particles, followed by climbing-position cleanup. Particle positions preserve the native support-block edge projection and capture entity coordinates before later callbacks. Attribute, fluid, particle and block callbacks can mutate fields; failures retain preceding writes.

python3 tools/test_living_landing_parity.py invokes actual LivingEntity.checkFallDamage and its base implementation. The living landing report records 244,844 matching lines per JAR, including server/nonserver levels, water changes, numeric boundaries, particle locations/counts, callback failures, field mutations and climbing cleanup. Targeted Clippy passes. Fluid immersion, changed-block enchantments, particle rendering and live gameplay binding remain pending; those providers are controlled by this gate.

living_air implements input normalization/rotation, friction-influenced speed, ladder/scaffolding limits, relative movement, collision-triggered climbing and air travel. Ground friction is captured before movement while levitation, gravity and drag are sampled afterwards. Player class identity controls ladder slide suppression. Native float arithmetic and quantized trigonometry are kept.

python3 tools/test_living_air_parity.py invokes the actual native private air, relative movement, climbing, speed, friction and input-vector methods. The air travel report records 443,554 matching lines per JAR, including both player/nonplayer classes, changed ground/climbing predicates, missing client chunks, levitation, nonfinite boundaries, callback mutations and failures. Targeted Clippy passes. Extreme effect amplifiers are injected directly for integer-boundary checks; normal constructor clamping is outside this gate. Collision movement, gravity, attributes and immersion remain controlled providers; live gameplay binding and complete player travel are pending.

living_fluid adds native water/lava acceleration, slowdown, falling adjustment, shallow-lava handling, collision escape and ridden buoyancy. It shares input rotation with air movement. Fluid heights and escape queries remain lazy, with movement mutations visible to subsequent velocity updates.

python3 tools/test_living_fluid_parity.py compares the actual native travel and fluid helper methods. The fluid travel report records 265,100 matching lines per JAR, including sprint changes, movement efficiency, dolphin effects, shallow-fluid boundaries, escape probes, ridden float guards, nonfinite values, callback mutations and failures. Targeted Clippy passes. Collision movement, immersion depths, free-space queries, attributes and gravity are controlled; live fluid propagation and gameplay binding remain pending.

living_motion implements default living jump strength/boost, sprint jump impulses, gravity and slow falling, vertical liquid input, rider flight speed and air drag. Native finite-addition filtering and delayed synchronization flags preserve partial writes when providers fail.

python3 tools/test_living_motion_parity.py compares the corresponding actual living methods plus Entity.applyGravity and addDeltaMovement. The jump and gravity report records 113,623 matching lines per JAR, including float thresholds, extreme raw effect amplifiers, signed zero/nonfinite values, rider classes, callback mutations and failures. Targeted Clippy passes. Entity-type jump/flight overrides, effect and attribute storage, registered jump-factor binding and live gameplay integration remain pending.

player_travel wraps living travel with passenger bypass, swimming pitch adjustment, head-fluid checks and preservation of creative-flight vertical velocity. It also binds player flight speed to sprint/passenger/ability rules and implements the flying ability's fluid-affection predicate.

python3 tools/test_player_travel_parity.py invokes actual Player.travel, getFlyingSpeed and isAffectedByFluids. The player travel report records 120,933 matching lines per JAR, including ability and velocity mutations, callback failures, signed zero/nonfinite positions and the distinction between direct ability fields and virtual ability access. Targeted Clippy passes. Parent travel is selected through a controlled fluid callback; connecting the verified living phases and collision movement to the live player/world remains pending.

ClimbingRegistry binds resolved climbing/glide-through tags and actual trapdoor class identities to all registered states. on_climbable preserves spectator and gliding guards, open-trapdoor/ladder facing checks, wrapping below-position arithmetic and last-climbable position writes. Negative or failed checks retain the previous climbing position. Unknown members/properties and IDs are rejected.

python3 tools/test_climbing_parity.py invokes actual registered LivingEntity.onClimbable and trapdoor support checks. The climbing report records 3,820,054 matching lines per JAR across all 35,723 states, including all trapdoor states against every registered ladder facing, tag reloads, spectator/gliding guards, captured positions, mutations and failures. Targeted Clippy passes. Entity/world storage is controlled; live movement binding and equipment-based glide eligibility remain pending.

fluid_occupancy implements section-ordered liquid checks over resident block sections with a complete registered fluid-presence table. BlockSection.any_state checks active palette entries so dry sections skip cell unpacking. Bounds use inclusive floored endpoints, and chunk requests retain native behavior even when no requested vertical section is within world height. Invalid geometry, foreign registries and query-budget exhaustion return explicit errors.

python3 tools/test_fluid_occupancy_parity.py compares actual LevelReader.containsAnyLiquid, BoxBlockMatcher and BlockScanUtils with native ProtoChunk sections. The liquid occupancy report records 116,664 matching lines per JAR, including fluid presence for all 35,723 states, public chunk/section query order, height boundaries, palette changes/compaction and failures. Rust-only checks verify typed budget, nonfinite and registry errors. Targeted Clippy passes. Chunk snapshots repeat controlled resident data; collision composition for Entity.isFree and live world binding remain pending. No performance gain is claimed without measurement.

free_space.offset_is_free composes native offset bounds, registry-bound block/entity/border collision clearance and resident liquid occupancy. The liquid scan runs only after collision clearance succeeds. Both phases share resident TerrainChunk storage through RegistryCollisionWorld; their typed errors and separate query budgets remain visible to the caller.

python3 tools/test_free_space_parity.py invokes actual Entity.isFree, native collision iteration and liquid scanning on the corresponding resident ProtoChunk storage. The free-space report records 5,764,046 matching lines per JAR across all 35,723 states, offsets, fluid/context variants, height boundaries, required missing chunks and failures. Targeted Clippy passes. Entity lists, border applicability and collision contexts are controlled; chunk generation, live entity indexing and full playable integration remain pending. The collision-only regression also passes 4,793,095 matching lines per JAR after extending the shared fixture and registry binding.

entity_fluid tracks body depth, eye immersion and current accumulation across updates. It preserves one-tick tracker retention, missing-chunk preflight, ordered cell scans, the first matching current tag, camera support checks and partial writes on query failure. Current application distinguishes player averaging from other entities' normalization and dispatches the final velocity addition with its finite-input filter and fresh velocity read.

python3 tools/test_entity_fluid_parity.py invokes actual EntityFluidInteraction and Entity.addDeltaMovement. The entity fluid report records 607,338 matching lines per JAR with real ProtoChunk fluid-presence sections, ordered/reloaded overlapping tags, wet/dry sequences, eye boundaries, nonfinite heights/current arithmetic, mutations and injected failures. Rust-only checks cover explicit query-budget/nonfinite errors and reset-before-error behavior. Targeted Clippy passes. Fluid heights/flows and entity fields are controlled here; neighboring-cell flow calculation, live world/entity binding and full playable integration remain pending. Extreme-coordinate Java scans are bounded by injected callback failures rather than allowed to traverse billions of cells.

fluid_flow computes water/lava current vectors from ordered horizontal and lower neighbors, preserving f32 height subtraction before f64 accumulation. Falling fluids apply the native wall deflection, including the same-family, upward-face and IceBlock guards, then normalize the resulting vector.

python3 tools/test_fluid_flow_parity.py invokes actual registered FluidState.getFlow, FlowingFluid.getFlow and its solid-face helper. The fluid flow report records 1,051,071 matching lines per JAR from 51,846 fixtures covering all registered fluid states, neighboring families/heights, per-face wall flags, falling deflection, wrapping coordinates and query failures. Targeted Clippy passes. Block tag/class flags and face support are controlled in this comparison; binding those to registered block storage and support shapes, fluid spreading and complete gameplay remain pending.

registry_fluid now binds contained fluid states, resolved flow-blocking tags and actual IceBlock class membership to the full block registry. Its world adapter composes current/height/camera queries with cached and dynamic support shapes. Foreign registry identities, unknown tag members and invalid state IDs are rejected explicitly; tag reloads use a new immutable binding.

python3 tools/test_registry_fluid_parity.py compares actual registered height, camera immersion, current vectors and solid-face queries. The registered fluid report records 2,446,969 matching lines per JAR from 409,389 fixtures, covering all 35,723 block states, waterlogged contents, cached/dynamic support, natural and reloaded tags, neighboring fluid families, coordinate wrapping and failures. Targeted Clippy passes, including checks for typed invalid-ID and foreign-registry errors. World cells are controlled and block entities are absent in this suite; active block-entity lifecycle, live entity binding, fluid spreading and complete playable integration remain pending.

entity_fluid_tick composes immersion updates with entity water-entry behavior and current application. It captures water/lava membership before effects, resets fall distance in water, dispatches a splash after the first tick when newly entering water, updates the touching-water flag and queries the push predicate again before applying forces. Lava uses the dimension's FAST_LAVA attribute to select its current coefficient.

python3 tools/test_entity_fluid_tick_parity.py invokes actual Entity.updateFluidInteraction with native immersion and current application. The entity fluid tick report records 953,830 matching lines per JAR, including changing push predicates, first-tick/entry flags, simultaneous water/lava, attribute selection, nonfinite arithmetic, callback mutations and failures around partial writes. The immersion regression also passes 607,338 lines per JAR after extending the shared fixtures. Targeted Clippy passes. Splash dispatch is controlled; audio/particle generation, full live entity/world binding and playable integration remain pending.

RegistryFluidWorld now implements entity immersion queries through the bound fluid contents, height calculations, camera support and neighbor-derived current vectors. Entity fields and loaded chunk/section views remain supplied by the world provider, preserving captured positions and partial-write order.

python3 tools/test_registered_entity_fluid_parity.py invokes actual EntityFluidInteraction with registered fluid and support behavior. The registered immersion report records 6,550,126 matching lines per JAR, including all 35,723 states in immersed and above-eye cells, mixed water/lava neighborhoods, waterlogged blocks, ordered/reloaded tags, current velocities, tracker retention and query failures. Targeted Clippy passes. Shared-fixture regressions also pass: tick composition (953,830 lines per JAR) and controlled immersion (607,338 lines per JAR). Chunk presence and section wet flags are controlled, and block entities are absent here; full live chunk/entity lifecycle, fluid propagation and playable gameplay remain pending.

swimming implements entity/player swimming transitions, underwater/shallow-water predicates and the fluid jump threshold. The player flying ability disables swimming directly. Other transitions preserve short-circuit query order, prior eye-in-water state, passenger guards, captured block position and final state writes only after all required queries succeed.

python3 tools/test_swimming_parity.py compares actual Entity/Player methods. The swimming report records 191,142 matching lines per JAR, including flag combinations, native fluid tag membership, failures/mutations, and f32 eye-height boundaries/nonfinite values. Targeted Clippy passes. Synchronized entity storage, full input/tick integration and playable gameplay remain pending.

fluid_box implements default entity immersion bounds and boat passenger waterline clipping. Entity bounds are deflated and captured before vehicle lookup. Submerged boats retain those bounds; other boats restrict immersion to the portion strictly above their top, returning no box when none remains.

python3 tools/test_fluid_box_parity.py compares actual entity/boat methods. The fluid box report records 92,822 matching lines per JAR, including actual boat status values, virtual modifier dispatch, thin/inverted bounds, waterline boundaries, signed zero/nonfinite values and mutations/failures. Targeted Clippy passes. Vehicle snapshots are controlled; live passenger lifecycle and full gameplay remain pending.

water_splash generates native water-entry sound, bubble/splash particle and game event requests. It preserves controlling-passenger identity, captured velocity, f32 volume/pitch arithmetic, float-rounded surface height, changing entity width, and random draws before each emitted effect. A particle budget returns an explicit error after preserving preceding effects and RNG consumption.

python3 tools/test_water_splash_parity.py invokes actual Entity.doWaterSplashEffect with native legacy and xoroshiro random generators. The water splash report records 192,506 matching lines per JAR across 7,840 fixtures, including sound thresholds, self/other passengers, particle positions/velocities, callback mutations/failures, nonfinite arithmetic and the next RNG value after the effect. A Rust-only budget check verifies that exhaustion preserves the two sound-pitch random draws. Targeted Clippy passes. Sound identities and effect sinks are controlled; audio playback, particle simulation/rendering and full gameplay integration remain pending.

attributes implements basic/ranged attribute instances, ordered modifiers, three-stage value calculation, cache invalidation and permanent-state packing. Modifier clones retain reference identity for transient-update notifications. Per-operation maps preserve native hash-table iteration, growth and deletion order because modifier arithmetic is sensitive to floating-point association. The implementation also retains native partial writes when a dirty observer fails, stale operation entries after operation-changing updates, merge-on-apply semantics and self-replacement behavior.

python3 tools/test_attribute_parity.py compares actual AttributeInstance methods using every registered attribute definition. The attribute report records 1,404,798 matching lines per JAR across 2,391 fixtures, including collision clusters, resize/shrink boundaries, seeded operation sequences, reference identity, observer cache reads/failures, nonfinite values and signed zero. The adapter observes iterator order, as native calculation does; Java stream traversal can differ. Targeted Clippy passes. Registry/entity/equipment binding, packed data/network codecs and full gameplay integration remain pending.

attributes::entity imports version-checked attribute definitions and entity supplier bases, and composes them with the attribute engine. Reads fall back to the supplier without creating instances; first instance access schedules an update and a sync for client-syncable attributes. Mutations retain those set memberships until individually acknowledged. Base resets use the entity's supplier value and do not instantiate absent entries. Missing attributes and missing modifiers remain distinguishable, including lookup after instantiation.

python3 tools/test_entity_attribute_parity.py compares actual AttributeMap operations with 40 registered attributes and 93 entity suppliers. The entity attribute report records 1,771,555 matching lines per JAR across 4,720 fixtures. Targeted Clippy passes. The exporter asserts that registered default suppliers contain no modifiers. Set membership is observed in registry order: this does not establish JVM identity-hash collection order, cross-attribute bulk assignment/serialization, custom suppliers, equipment integration or a live entity tick.

food implements eating, saturation, exhaustion, hunger predicates and the server hunger tick. It retains the captured level/difficulty, short-circuit player queries, fast/slow regeneration timers, starvation health/difficulty guards, wrapping integer arithmetic, Java float edge behavior and partial state writes when callbacks fail. Heal and starvation requests use explicit world hooks, which can mutate food state before subsequent tick work.

python3 tools/test_food_parity.py compares actual FoodData methods. The food report records 180,878 matching lines per JAR across 15,211 fixtures, including 240-tick sequences, threshold boundaries, all difficulties, callback mutation/failure, signed zero and nonfinite arithmetic. Targeted Clippy passes. World rules, player health/healing and damage delivery are controlled; consumables, saved hunger data and live survival gameplay integration remain pending.

food_storage reads/writes hunger state in player NBT compounds. Missing and nonnumeric fields use native defaults; numeric tags retain vanilla coercions, including floor-to-int for floats/doubles, truncation of long integer bits and no post-load clamping. Writes replace the four hunger fields with native int/ float types, normalize float signed zero and preserve unrelated player fields.

python3 tools/test_food_storage_parity.py compares actual FoodData persistence through TagValueInput/TagValueOutput. The food storage report records 45,955 matching lines per JAR, covering every NBT numeric type, missing/wrong-type fields, conversion boundaries, nonfinite values and save/load round trips. Targeted Clippy passes. ProblemReporter diagnostics and the complete player save lifecycle remain pending; these results establish the four hunger fields, not a playable save/load implementation.

living_health implements health/absorption clamping, healing dispatch, player hurt and living dead-or-dying predicates. Health writes capture synchronized storage before attribute lookup. SyncedFloat preserves Java boxed-float equality, writes the value before the update callback, and marks dirty only after that callback succeeds; it also supports default/dirty extraction for a single float item.

python3 tools/test_living_health_parity.py compares actual LivingEntity/Player methods and actual SynchedEntityData float items. The living health report records 442,007 matching lines per JAR, covering nonfinite values, signed zeros/NaN equality, forced updates, dirty extraction, health-data replacement during callbacks and partial effects after exceptions. Targeted Clippy passes. Attribute values and the internal absorption sink are controlled. Player-specific absorption synchronization, multiple synchronized items, registered attribute binding, full damage processing and playable entities remain pending.

attribute_health binds the health engine to registered entity attributes and mutable synchronized health. AttributeHealth borrows existing state, queries actual modified MAX_HEALTH/MAX_ABSORPTION values and propagates observer errors without losing partial health writes. Base living absorption uses field storage.

python3 tools/test_attribute_health_parity.py composes actual registered AttributeMap, LivingEntity/Player health methods, SynchedEntityData and FoodData. The composition report records 666,082 matching lines per JAR, including all 93 entity suppliers, attribute base/modifier changes, real regeneration health writes, 100-tick hunger sequences and failed synchronization callbacks. Targeted Clippy passes. The internal absorption sink and starvation damage delivery are controlled; player absorption synchronization, attribute-change refresh, full damage and live gameplay integration remain pending.

Entity attribute storage now shares immutable supplier bases and allocates each mutable instance only on first access. This retains dense lookup indices while avoiding space for unused instance objects in every entity.

python3 tools/measure_attribute_memory.py --phase before|after measures a Linux release-process workload of 20,000 held-live zombie attribute maps, using five fresh processes per case. Median process RSS changed from 175,820 to 12,848 KiB with defaults only, and 175,800 to 29,076 KiB with four active attributes per entity. Both cases retain the same health-read checksum. The before and after reports record samples and source hashes; the baseline entity implementation is fd185a6. RSS includes runtime, catalog and allocator overhead. This is not whole-game memory, a timing benchmark or evidence of an FPS improvement.

The optimized implementation passes both pinned JAR comparisons again: entity attributes (1,771,555 lines per JAR) and health/hunger composition (666,082 lines per JAR). Targeted Clippy passes.

combat_rules implements armor/toughness and magic-protection damage arithmetic. It preserves the nonnull-weapon/server-level guards and clamps modified armor effectiveness only after the server enchantment hook.

python3 tools/test_combat_rules_parity.py compares actual CombatRules methods. The combat rules report records 184,248 matching lines per JAR, including armor/toughness boundaries, random float bit patterns, nonfinite/signed-zero values, query mutations/failures, null/empty/unenchanted weapons and server/nonserver branches. Native unenchanted stacks have explicitly empty components. Targeted Clippy passes. Enchanted item components, damage tags, armor durability and the complete damage pipeline remain pending; the exposed enchantment hook is not an enchantment implementation.

living_damage implements the inner actuallyHurt sequence for base living entities and players. It preserves invulnerability/armor/magic dispatch, both absorption reads before the first write, guarded absorbed statistics, Java float rounding, player exhaustion/taken statistics, base-living second absorption writes, and combat/health/game-event ordering. Callback failures retain preceding writes and effects.

python3 tools/test_living_damage_parity.py compares actual LivingEntity/Player methods with real final absorption clamping and controlled phase/storage sinks. The living damage report records 161,198 matching lines per JAR, including entity/player paths, attacker types, stat limits/rounding, nonfinite values, mutations and failures at query boundaries. Targeted Clippy passes. Armor/magic results, health storage, combat/ stat sinks and exhaustion delivery are controlled. Outer hurt gates, resistance/ equipment binding, combat tracking and playable damage integration remain pending.

player_food implements player exhaustion, eating eligibility and the hunger threshold for exhaustive manoeuvres. Invulnerability reads the abilities field directly. Exhaustion additionally checks the client/server side before updating direct food storage; manoeuvre eligibility uses virtual food and ability lookups. StoredPlayerFood binds these operations to ordinary mutable FoodData state.

python3 tools/test_player_food_parity.py compares actual Player methods and native FoodData. The player food report records 32,723 matching lines per JAR, covering direct/virtual distinctions, captured food identity during mutations, guard short-circuiting, injected failures, nonfinite exhaustion and integer hunger boundaries. The stored-state binding is also compared. Targeted Clippy passes. Consumable components, full ability storage and live player tick integration remain pending.

damage_reduction composes native armor/toughness arithmetic with living damage bypass checks and armor-durability dispatch. Its magic-reduction path preserves resistance amplifier overflow, reduced-damage clamping, resisted statistics, repeated attacker lookup and the server-only enchantment protection query. Armor attributes floor to Java's saturated integer range before float conversion.

python3 tools/test_damage_reduction_parity.py compares actual living methods for base entities and ServerPlayer receivers. The damage reduction report records 78,069 matching lines per JAR, covering bypass combinations, resistance/stat boundaries, numeric edges, query failures/mutations and actual empty-equipment protection iteration. Targeted Clippy passes. Equipment is empty; enchanted components, actual armor durability, registered damage/effect bindings and the full hurt sequence remain pending.

synced_floats stores multiple synchronized float fields. It preserves boxed float equality, per-field/global dirty state, ascending-ID dirty/default lists, received assignment without newly marking dirty, per-entry and batch callbacks, and prefix effects when an observer or field lookup fails. Callbacks may reenter the table to set/assign fields or drain existing dirty values.

python3 tools/test_synced_floats_parity.py compares actual SynchedEntityData. The synchronized float report records 554,909 matching lines per JAR, including forced/equal updates, received duplicates, reentrant operations, missing IDs, callback failures and NaN/signed-zero equality. Native gaps are untouched default float items; observed keys are explicit configured IDs. Targeted Clippy passes. Other serializers, serializer-mismatch errors, wire codecs and player absorption binding remain pending.

player_health binds ordinary registered player attributes to health and absorption in one synchronized float table. The player absorption getter and internal setter use virtual data access; health retains its direct data access. The final absorption setter still applies the registered maximum before writing.

python3 tools/test_player_health_parity.py compares actual Player methods, registered player attributes and SynchedEntityData, exporting the actual pinned health/absorption field IDs. The player health report records 243,146 matching lines per JAR, covering modified limits, healing, absorption reads/writes, combined dirty/default lists, received assignments, callback packet drains and failures. Targeted Clippy passes. Observer effects are controlled; custom virtual data replacement, other synchronized serializers, wire codecs and full player damage/tick integration remain pending.

server_player_damage composes ordinary server-player inner damage with registered armor/toughness and health/absorption limits, shared synchronized float storage and stored hunger. Armor break callbacks may change attributes before the hit queries armor; received damage uses the actual reduction and health modules, and player exhaustion retains its ability/client guards.

python3 tools/test_server_player_damage_parity.py compares the native Player inner damage method on ServerPlayer receivers, using actual native reduction, registered modified attributes, synchronized data and FoodData. The server-player damage report records 373,455 matching lines per JAR, covering repeated hits, bypass flags, resistance, numeric edges, armor attribute mutation, dirty packet drains and callback failures. Targeted Clippy passes. Empty equipment and controlled source/effect, durability, combat/stat/event services bound this scope; outer hurt gates, enchanted equipment and the complete player lifecycle remain pending.

living_hurt implements the outer living hurt sequence: early rejection, blocking/freezing/helmet dispatch, non-finite damage sanitization, repeated-hit cooldowns, hurt-animation writes, attribution, impact/knockback, death/sound branches, last-source timestamps, effect notifications and criterion dispatch. Services receive live hurt state, including the distinct field writes before and after the inner hit in fresh-hit and cooldown-difference branches.

python3 tools/test_living_hurt_parity.py invokes the native LivingEntity method directly on base and ServerPlayer receivers. The living hurt report records 441,413 matching lines per JAR, including numeric edges, repeated hits, callback mutations/failures, empty-hand death-protection lookup, native soundless blocking components and victim criteria with no listeners. Targeted Clippy passes. Inner damage, blocking amounts, sounds, knockback, death and attribution/effect services are controlled. Successful totems, attacker-player criteria, actual blocking reduction, full service bindings and player-specific outer gates remain pending.

player_hurt adds the player ability/invulnerability gates, no-action reset, shoulder removal, damage-source difficulty scaling and exact-zero rejection before living hurt. The server-player wrapper first checks PvP permission for player attackers and player owners of arrow attackers. Difficulty is queried separately for the peaceful, easy and hard branches as in vanilla.

python3 tools/test_player_hurt_parity.py compares actual Player and ServerPlayer methods through the native living hurt sequence. The player hurt report records 410,880 matching lines per JAR, including all three-query difficulty combinations, player/arrow-owner PvP gates, repeated hits and callback failures. Targeted Clippy passes. Native downstream living services retain the controlled fixture scope above; invulnerability internals, rule/source registries, actual team permissions, successful totems, attacker server-player criteria and complete player lifecycle integration remain pending.

damage_immunity implements entity permanent/temporary invulnerability and base source immunity, living enchantment dispatch, ordered player damage gamerules, and server-player dimension-change/client-loading checks. It preserves early returns and repeated source-tag queries across the inheritance layers.

python3 tools/test_damage_immunity_parity.py compares each native layer on ServerPlayer receivers, retaining native empty-equipment enchantment iteration. The damage immunity report records 170,314 matching lines per JAR, including mixed damage tags, rule precedence, virtual flag mutations and callback failures. Targeted Clippy passes. Source/rule queries and virtual flags are controlled; registered source/rule bindings, nonempty enchantment immunity and full pipeline integration remain pending.

server_player_combat binds server/player/living outer hurt to the checked registered-attribute, synchronized-health/absorption and hunger inner damage path. Dead-or-dying reads live health and the direct death flag; the outer cooldown/animation state is shared across hits. PvP, blocking, effects, attribution, knockback, death and other world services remain explicit.

python3 tools/test_server_player_combat_parity.py compares the actual native ServerPlayer hurt chain through actual inner reduction and player storage. The server-player combat report records 561,528 matching lines per JAR, including repeated hits, death rejection, modified attributes, cooldown differences, packet drains, numeric edges and failures after partial writes. Some fixtures explicitly reset cooldown between hits; they do not claim entity-tick coverage. Targeted Clippy passes. Invulnerability answers, blocking amounts, armor-durability callbacks, effects, PvP permission, combat/event/knockback/death services and criterion listeners are controlled. Enchanted items, registered sources, actual lifecycle services and playable integration remain pending.

The stored-player combat binding now executes the verified server-player invulnerability predicates at every outer and inner query. Its inner damage body is shared with standalone living/player damage after the required predicate has run. Native integration retains inherited Entity/LivingEntity/Player/ServerPlayer immunity methods, including empty-equipment enchantment iteration, gamerule precedence, dimension changes and client-loading guards.

The combat immunity integration report records 1,176,994 matching lines per JAR. The standalone inner-damage regression report retains 161,198 matching lines per JAR after extracting the shared body. Targeted Clippy passes. Virtual flags, source tags/rule values and the other world services listed above remain controlled; the fixture now executes the immunity decisions themselves instead of supplying their final result.

damage_source imports version-checked native decoded damage definitions and resolves their raw tag resources with the shared tag implementation. Sources retain distinct direct/causing entities and optional explicit positions. Weapon and fallback position queries use the direct entity; difficulty scaling uses the stored causing entity, while creative-source detection dispatches virtual causing-entity access before reading player abilities.

python3 tools/test_damage_source_parity.py covers all 51 bundled damage types and 36 damage-type tags, using the actual native DamageType codec and TagLoader. The damage-source report records 152,175 matching lines per JAR, including constructor identities, scaling, exhaustion, tag/type membership, position/weapon queries, virtual causing-entity replacement, mutations and failures. Targeted Clippy passes. Catalogs are immutable snapshots with local indices, not network IDs. Rust DamageType codecs, runtime reload, death-message generation, full entity query bindings and combat source integration remain pending.

Registered damage sources now drive a composed player-combat fixture. Source helpers map the immunity, outer-hurt and reduction tag enums to the imported vanilla tags. Native source methods supply exhaustion, difficulty scaling, creative-source abilities and direct-entity weapon selection through the real ServerPlayer hurt chain; thorns also follows its native secondary-sound branch.

python3 tools/test_registered_player_combat_parity.py records 1,431,711 matching lines per JAR in the registered player-combat report, covering all 51 damage types and 36 tags, direct/causing entity combinations, repeated hits, health/absorption/hunger, cooldown state and callback failures. Targeted Clippy passes. Equipment is unenchanted; virtual entity flags/rule values, blocking amounts, durability, PvP permission, attribution, effects, knockback/death services and empty criterion listeners remain controlled. Complete entity lifecycle and playable game integration remain pending.

blocking_rules implements damage-reduction angle/type conditions, ordered reduction sums and clamping, block delay/disable tick rounding and item-damage threshold/floor arithmetic. Source type-set membership is queried only when its entry's angle condition reaches that check.

python3 tools/test_blocking_rules_parity.py compares native BlocksAttacks records and direct holder-set membership. The blocking rules report records 105,068 matching lines per JAR, including exact angle boundaries, NaN/infinity/signed zero, randomized float bits, source-type mutations and query failures. Targeted Clippy passes. Angles are supplied in radians; direction/acos calculation, component codecs, item durability, sounds and full blocking integration remain pending.

view_direction implements native float-table pitch/yaw vectors and horizontal blocking angles, using the pinned pure-Rust libm 0.2.16 inverse cosine. A local 203,072-input probe found 7,908 differences with the platform acos, versus none with this pinned implementation, so platform math is not used for this path.

python3 tools/test_view_direction_parity.py compares actual native view vectors and Java Math.acos, plus the native view/subtract/normalize/dot/acos composition used by blocking. The view-direction report records 226,459 matching lines per JAR, including random doubles, inverse- cosine boundaries, arbitrary float rotations, degenerate horizontal vectors and the widened float-PI fallback. Targeted Clippy passes. Full item-blocking dispatch and validation against JVMs on other platforms remain pending. This does not resolve the separately tracked Math.cos/Gaussian portability differences.

item_blocking implements living blocking dispatch: item/component capture, bypass and pierced-arrow rejection, source direction, component reduction, blocking-item damage dispatch and the later non-projectile melee response. The virtual level/used hand are queried after reduction; melee response retains the original server-level argument and performs a fresh direct-entity lookup.

python3 tools/test_item_blocking_parity.py compares actual LivingEntity applyItemBlocking with native components on base and ServerPlayer receivers. The item-blocking report records 87,930 matching lines per JAR, including callback mutations/failures, captured items/components, piercing/bypass combinations, native direction/math, client/stat guards and melee responses. Targeted Clippy passes. Native stacks are explicitly undamageable; actual damageable-item mutation, blocking eligibility, component codecs and complete combat/world integration remain pending.

item_use implements blocking-item eligibility and both elapsed-use timer overloads. It retains the original blocking delay while rereading active-item storage and remaining ticks after the virtual duration query; partial-tick queries preserve the second virtual use-state check.

python3 tools/test_item_use_parity.py compares the actual inherited native methods with real blocking components and controlled virtual item durations. The item-use report records 108,690 matching lines per JAR, covering wrapping tick arithmetic, delay boundaries, absent components, empty stacks, shared item types, partial float values and callback mutations/failures. Targeted Clippy passes. Full item-use lifecycle, damageable-item storage and complete combat/world integration remain pending.

item_durability stores the durability projection of an item stack, including raw versus visible counts/components, clamped damage access, damageability/break predicates and wrapping count changes. Server-level damage preserves creative immunity, the positive float enchantment pipeline, advancement-before-write and copy-before-shrink ordering. The non-breaking variant retains its native empty break consumer, including unusual invalid component values.

python3 tools/test_item_durability_parity.py compares actual unenchanted native ItemStack operations. The durability report records 81,762 matching lines per JAR, including absent components, empty/air stacks, unbreakable flags, integer boundaries, callback mutations and failures. Targeted Clippy passes. This is a durability projection, not complete item-stack component storage. Enchantment effects, component codecs, equipment break handling and full gameplay integration remain pending.

blocking_item_damage composes blocking-component item-damage arithmetic with stored durability. It preserves player-only handling, the passed level's client guard for item-use statistics, the later virtual entity-level check and the server-player-only creative/advancement queries. Break callbacks receive the pre-shrink stack copy and the caller's original equipment slot.

python3 tools/test_blocking_item_damage_parity.py compares actual native BlocksAttacks calls into ItemStack storage on non-player, Player and ServerPlayer receivers. The blocking durability report records 71,800 matching lines per JAR, including scalar float boundaries, invalid/absent durability components, statistic item capture, callback mutations and failures. Targeted Clippy passes. Stacks are unenchanted; full component storage, equipment lifecycle and complete combat/world integration remain pending.

item_use_lifecycle implements living use ticks, per-item updates, completion, release and stop ordering. Stable stack handles preserve type versus identity checks, rereads after virtual hand queries, captured level/item arguments, wrapping countdowns, returned-item placement and failure-visible state changes.

python3 tools/test_item_use_lifecycle_parity.py compares actual inherited native methods and ItemStack dispatch with controlled custom item handlers. The lifecycle report records 144,736 matching lines per JAR, including empty stacks, changed held/active items, shared item types, client/server queries, finish vibrations, kinetic-map presence and callback mutation/failure ordering. Targeted Clippy passes. Starting use, actual synchronized flags, consumable/kinetic effects, remainder/cooldown components and full inventory/game-tick integration remain pending.

item_use_start starts use from a captured held stack, writes the returned duration after its callback, synchronizes equipment before changing using/offhand flags, emits the component's start vibration and resets recent kinetic enemies when the final active stack has a kinetic-weapon component.

python3 tools/test_item_use_start_parity.py compares inherited native startUsingItem and its private equipment packet construction. The start-use report records 84,873 matching lines per JAR, including captured stack/level/hand arguments, empty stacks, callback mutation/failure ordering, flag writes, native UseEffects/KineticWeapon presence and clearing a populated kinetic-enemy map. Targeted Clippy passes; all 20 existing horizon-world library tests pass with these changes. Synchronized flag storage, packet encoding/delivery, kinetic combat and complete inventory/game-tick integration remain pending.

item_use_catalog imports all 1,658 pinned item identities and a typed projection of their default components for stack size, durability and use-duration/release queries. Component-driven use preserves consumable precedence over blocking and kinetic weapons. Registered duration overrides remain separate; consumables truncate float ticks while instruments floor them. Empty stacks query air behavior and hide their stored components.

python3 tools/test_item_use_catalog_parity.py binds vanilla's actual component initializers and confirms both JARs export equivalent defaults. The registered item-use report records 246,715 matching lines per JAR, covering every item default, count changes and component mutation sequences, override behavior, stackability, durability and integer/float extremes. Targeted Clippy passes. The imported projection does not implement all item components or their codecs; full inventory, enchantment effects and stored gameplay integration remain pending.

component_patch stores shared immutable prototypes and ordered copy-on-write patches. Set/remove return values, redundant-value sanitation, explicit removals, unsanitized restoration, independent copies and saved patch snapshots retain native behavior. Entry iteration emits patched values before untouched defaults; key-set order instead applies the patch to the prototype's key sequence.

python3 tools/test_component_patch_parity.py compares actual native patched maps. The component-patch report records 622,680 matching lines per JAR, including integer/boxed-float equality, NaN/signed zero, copy isolation and mutation-before-error when a restored removal has no prototype default. Targeted Clippy passes. Prototypes have at most seven keys in this suite; callers supply prototype order and native value equality. Native large-prototype identity-hash ordering, codecs, mutable payload aliases and full item/inventory integration remain pending.

component_durability binds damage/count queries and mutations directly to shared component prototypes and patches. The durability algorithm now accepts DurabilityStorage, so writes and storage errors occur at their native points, including before break callbacks. The earlier plain durability projection remains supported through the same interface.

python3 tools/test_component_durability_parity.py compares native ItemStack operations with nonempty prototypes and observable patches at every callback. The component durability report records 83,727 matching lines per JAR, including original/copy independence and mutation-before-error for unsanitized restored removals. Targeted Clippy passes. The refactor also preserves both native regression suites: scalar durability (81,762 lines per JAR) and blocking durability (71,800 lines per JAR). Full component codecs, enchanted durability, equipment and complete gameplay integration remain pending.

item_stack_storage implements stored item identity, count/pop-time storage, component visibility, copying, splitting, transmutation and consumption. Copies share component data until a write; canonical empty results are explicit so a containing item store can preserve reference identity. Negative counts and wrapping arithmetic follow the pinned methods, including mutations to an empty stack and consumption callbacks that change or fail after a copy is captured.

python3 tools/test_item_stack_storage_parity.py compares 7,856 fixtures with actual native ItemStack methods and small bound integer-component prototypes. The storage report records 568,580 matching lines per JAR. Comparisons include raw and visible state, component patch order, stack identity and item/component/count equality. Targeted Clippy passes. The fixture arena preserves canonical EMPTY aliases; a production inventory, full component values/codecs and complete item-use, equipment and game-tick integration remain pending.

item_stack_refs adds shared stack identity with automatic reference-counted lifetime management on the simulation thread. simple_container uses these references for get/set, merging, removals, reverse removal by type, clearing, capacity checks and item counts. Copies retain independent component patches; container slots and callers can deliberately share the same stack.

python3 tools/test_simple_container_parity.py compares actual native container and stack methods, including changes and failures in virtual size/change hooks. The container report records 590,402 matching lines per JAR. It checks alias identity, raw/visible counts, empty-stack references, component-sensitive merging, overflow, invalid indices and mutation prefixes on failure. In particular, native insertion into the first empty slot clears the remainder before limiting the inserted copy. Targeted Clippy passes. Player inventory, menus, crafting accounting, persistence, arbitrary getItem/setItem overrides and complete gameplay integration remain pending. Reference counting here has not been benchmarked as a performance gain.

player_inventory implements the 36 ordinary slots, seven mapped equipment slots, shared entity equipment, selected hotbar slot, picking, matching/crafting eligibility, removals, replacement, clearing and the change counter. Equipment retains populated entries when cleared. Stack and equipment references can be shared across inventories; replacing an inventory retains stack aliases.

python3 tools/test_player_inventory_parity.py compares actual native Inventory, EntityEquipment and ItemStack methods. The inventory report records 790,440 matching lines per JAR, including invalid-index failure prefixes, selected-slot changes, negative equipment removal amounts, ordinary versus equipment identity, self-replacement and shared equipment clearing. Components cover damage, unbreakable presence, a fixed enchantment and literal custom names. Native Map.of iteration order varies by JVM; fixtures explicitly supply equipment-map order to both sides when removing an aliased reference. Targeted Clippy passes. Pickup, inventory/equipment ticks, menus, recipe accounting, persistence, full component values and complete gameplay integration remain pending.

inventory_pickup composes player slot search and insertion with shared stack storage. Search checks the selected slot, offhand, then ordinary slots. Insertion consumes its source, preserves component-sensitive merging and pop time, and handles damaged stacks and creative fallback at their native callback points.

python3 tools/test_inventory_pickup_parity.py compares actual native Inventory.add/getSlotWithRemainingSpace, ItemStack operations and shared equipment. The pickup report records 424,282 matching lines per JAR, including source/destination aliases, callback mutations, failures, count overflow, invalid slots and the damaged copy-and-clear that happens before slot validation. Targeted Clippy passes. Native crash-report wrapping is represented as an error; diagnostic text is not compared. Item-entity pickup events, networking, inventory ticks, menus, full components and complete gameplay integration remain pending.

inventory_tick composes inventory/equipment iteration with ItemStack's pop-time update and ServerLevel-only item dispatch. It retains stack arguments across level callbacks, reads hotbar selection at the native point and observes changes to later equipment entries during the same tick. Aliased stacks can be visited more than once, with each visit updating their shared pop-time counter.

python3 tools/test_inventory_tick_parity.py compares actual Inventory.tick, EntityEquipment.tick and ItemStack.inventoryTick with custom item handlers. The tick report records 195,957 matching lines per JAR, including empty stacks, callbacks that mutate later slots, weakly consistent equipment iteration and failure prefixes. The client comparison uses an actual allocated ClientLevel for the non-server branch; the dedicated JAR uses null because ClientLevel is absent. Targeted Clippy passes. Registered items' individual tick effects, full entity and world ticking and complete gameplay integration remain pending.

player_equipment binds the main hand to the selected inventory slot and other equipment to the shared entity map. Hand/slot writes capture the previous item, store the new reference and then invoke the equip callback. Clearing the base equipment map does not clear the selected stack; clearing the inventory does.

python3 tools/test_player_equipment_parity.py compares actual PlayerEquipment and inherited LivingEntity hand/slot access over a real native Inventory. The equipment report records 408,852 matching lines per JAR, including selection changes, callback mutations/failures, old/new aliases, raw enum-map main-hand entries and the selected main-hand override. Targeted Clippy passes. Full onEquipItem effects, synchronized flags, active-use integration and complete gameplay integration remain pending.

The item-use interfaces now accept cloned shared references as well as small copyable handles. StackRef equality compares object identity; component/count value comparisons remain explicit. Captured references stay alive through callbacks that replace the active or held stack. The lifecycle fixture now uses the production reference-counted stack implementation.

The native regressions retain 144,736 lifecycle, 84,873 start-use and 108,690 eligibility/timing matching lines per JAR. Reports: lifecycle, start, eligibility. Targeted Clippy and all 20 horizon-world library tests pass. Hand queries and flags remain controlled in these fixtures; composing them with actual player inventory, synchronized flags and full item effects remains pending.

synced_values shares the synchronized scalar algorithm between bytes and floats, retaining Java boxed-float equality. living_use_flags binds the pinned byte field to using-item/offhand queries and signed-mask flag writes. Flag writes use the same write-before-callback, callback-before-dirty ordering as other synchronized values.

python3 tools/test_synced_bytes_parity.py compares actual byte SynchedEntityData and inherited LivingEntity flag methods. The byte/flag report records 572,100 matching lines per JAR, covering all initial bytes, signed masks, forced updates, assignments, reentrant callbacks, dirty packing and failures. The float regression retains 554,909 matching lines per JAR. Targeted Clippy passes. Mixed-serializer storage, entity schemas, wire codecs and full item-use/gameplay integration remain pending.

inventory_use binds living item-use ticks, completion, release and stop to actual player inventory/hands, shared stack references and synchronized byte flags. Equipment storage changes precede equip callbacks; synchronized flag writes retain their value/callback/dirty ordering. Effects receive the same mutable inventory, flag storage and active-use state.

python3 tools/test_inventory_use_parity.py compares inherited native lifecycle methods composed with real Inventory, PlayerEquipment and SynchedEntityData. The combined report records 349,310 matching lines per JAR, including live count mutations, selection/offhand changes, equipment callbacks, flag dirty prefixes, completion replacement and failed callbacks. Targeted Clippy passes. Item/level effects and the equip/synchronized observers are controlled; starting use, default observer reactions, consumables, kinetic combat, remainders/cooldowns and complete gameplay integration remain pending.

inventory_use::flags_updated implements LivingEntity's synchronized use-flag reaction. On clients, a using flag can select the held stack and query its duration; clearing use can clear the active stack and remaining time. Server notifications leave active-use state unchanged. Received assignments notify even when the byte value is unchanged, while ordinary unchanged writes do not.

python3 tools/test_use_flag_reaction_parity.py invokes the inherited native observer through actual synchronized writes/assignments, player inventory and equipment. The reaction report records 366,331 matching lines per JAR, including duration callbacks, empty-but-distinct stack references, signed masks, repeated received values, selection/count mutations and failures before dirty marking. Ordinary lifecycle operations are also exercised with the real observer reaction. Targeted Clippy passes. Other synchronized keys, start-use packet flow, full item/equip effects and complete gameplay integration remain pending.

inventory_use now binds start-use to stored inventory, shared active stacks and synchronized flag reactions. Server equipment synchronization precedes flag writes, followed by start vibration and the kinetic-enemy reset service. Captured stack/hand arguments and live state reads retain native callback ordering.

python3 tools/test_inventory_use_start_parity.py exercises inherited native start-use with actual Inventory, PlayerEquipment and synchronized storage. The start report records 9,506 fixtures and 223,004 matching lines per JAR, including native equipment packet construction, observer reactions, callback mutations/failures and clearing a populated kinetic-enemy map. Targeted Clippy passes. Packet encoding/delivery, the full kinetic-enemy map and combat, complete item/equip effects and full gameplay integration remain pending.

item_template implements immutable template construction, conversion from stacks, count replacement with native reference identity, current-prototype component lookup, creation and patch precedence. Strict validation checks damageable/stackable incompatibility before contained components and top-level size. A required component-schema service handles contained validation. Rejected creations return canonical EMPTY; rejected applied patches restore the exact previous raw patch, including redundant entries.

python3 tools/test_item_template_parity.py compares actual ItemStackTemplate and ItemStack validation with scalar max-stack-size/max-damage/damage components. The template report records 518,556 matching lines per JAR, covering zero/negative/overflow-edge counts, changed prototypes, component removals, aliasing and validation rollback. Targeted Clippy passes. Contained components and bundle-weight validation are not exercised by this corpus; their schema implementation, codecs, use-remainder integration and complete gameplay integration remain pending.

use_remainder converts a consumed stack using the validated item-template factory. Infinite materials and unchanged visible counts retain the original reference. An exhausted stack returns the created remainder; otherwise an extra item callback runs and the captured original reference is returned. Callback mutations and failures retain their native prefix.

python3 tools/test_use_remainder_parity.py compares actual UseRemainder with native template creation. The remainder report records 353,264 matching lines per JAR, including canonical EMPTY creation, empty-but-distinct inputs, reference replacement and callback failures. Targeted Clippy passes. The concrete actor inventory/drop handler, contained-component validation, finish-use side effects and complete gameplay integration remain pending.

bundle_weight implements checked native fraction construction, addition and multiplication, nested-bundle overhead, occupied-beehive weight and lazy caching of successful and failed weight calculations. Contained validation checks container sizes, then bundle sizes and weight, then charged projectile sizes. It does not recursively apply full strict validation to each contained item.

python3 tools/test_bundle_weight_parity.py compares pinned Fraction arithmetic, actual BundleContents and ItemStack strict validation. The bundle report records 137,332 matching lines per JAR, including overflow, negative template counts, changed prototypes, cached errors, nested bundles, bee presence, empty component visibility and validation order. Targeted Clippy passes. Typed schema adapters remain fixture-local; complete bundle inventory operations, codecs, item-use integration and full gameplay integration remain pending.

java_hash_map supplies default-capacity storage for non-null keys with native hash codes and a total comparable ordering consistent with equality. It retains linked bucket traversal, tree-bin root movement, red/black insertion/deletion, resize splits, iterator removal and structural-modification checks. Tree lookup uses the ordered tree; removed arena slots are reused.

python3 tools/test_java_hash_map_parity.py compares this API with the actual JDK 25 HashMap used by vanilla cooldown storage. The map report records 601,084 matching lines for each pinned-game classpath run, including all-key collisions, tree/list transitions, varied removal orders, iterator mutations and clear-on-empty behavior. Both runs use the same installed JDK; this is a collection comparison, not a gameplay parity claim. Targeted Clippy passes. Null/non-comparable keys, alternate map constructors and unexposed Map methods are outside this storage API. Concrete cooldown and gameplay integration remain pending.

item_cooldowns composes cooldown entries with native hash-map ordering. Adds store before start notifications; removals notify even for missing groups. Tick expiry removes before end notifications, rereads the live clock and preserves iterator invalidation after callback mutations. Percentages use native wrapping integer differences and float arithmetic. identifier supplies validated names, Java hashes and path-first ordering. UseCooldown converts seconds and retrieves the player cooldown manager before adding through the stack's current group.

python3 tools/test_item_cooldowns_parity.py compares actual ItemCooldowns and UseCooldown over real stack components, with controlled player/start/end callbacks. The cooldown report records 167,906 matching lines per JAR, including colliding identifiers, wrapping clocks, zero/negative durations, float edge cases, empty visibility, reentrant ticks and mutation/failure prefixes. Targeted Clippy passes. Complete item-finish integration, server cooldown packets and full gameplay remain pending.

item_after_use composes shared stack copying, item completion, validated remainder creation and cooldown application. The original stack is copied before the item handler; remainder, cooldown and count are captured from that copy before actor callbacks. The original copy reaches cooldown grouping even when the item handler returns another stack. use_remainder::convert_with permits creation and delivery to share the same mutable world without overlapping borrows. Templates and component patches support structural value equality.

python3 tools/test_item_after_use_parity.py invokes actual ItemStack.finishUsingItem and native remainder/template/cooldown implementations. The completion report records 211,804 matching lines per JAR, including prototype changes, original copies, empty aliases and mutations/failures at each effect boundary. The remainder regression retains 353,264 matching lines per JAR. Targeted Clippy passes. Item handlers and actor extra-item delivery remain controlled; concrete consumables, full inventory-use binding, contained schemas and complete gameplay remain pending.

extra_items::deliver connects server-player remainder delivery to actual inventory pickup. Failed insertion reaches the predicted drop service with the same remaining stack; successful insertion retains native count consumption and slot aliases. The drop service represents throwRandomly=false and Prediction::PREDICTED.

python3 tools/test_extra_items_parity.py composes native item completion, remainders and cooldowns with inherited ServerPlayer extra-item handling and real Inventory/PlayerEquipment. The delivery report records 272,124 matching lines per JAR, including full/partially filled inventories, offhand merging, aliased slots, creative material queries, partial insertion and callback failures. Targeted Clippy passes. Drop arguments are verified, but entity spawning remains controlled. Concrete item handlers, full contained schemas, complete use lifecycle and full gameplay remain pending.

food_properties implements the food consumption listener with stored FoodData and native random streams. It captures the actor's random source before the first sound, updates hunger and saturation for players, then emits the burp sound using the captured source and current position.

python3 tools/test_food_properties_parity.py compares actual FoodProperties.onConsume with real FoodData and both native random generators. The food listener report records 70,632 matching lines per JAR, including player/non-player actors, sound arguments, subsequent random state, changed food stores and positions, and callback mutation/failure prefixes. Targeted Clippy passes. Sound playback, complete consumable dispatch, particles/effects and full gameplay integration remain pending.

item_particles emits eating particles from one retained ItemStackTemplate. Each iteration reads the actor's direct random field and current rotations; eye-height and level callbacks preserve native evaluation order. Component mutations after capture do not alter the particle template.

python3 tools/test_item_particles_parity.py compares inherited LivingEntity.spawnItemParticles with real templates and both native random generators. The particle report records 143,167 matching lines per JAR, including exact position/velocity bits, empty stacks, negative particle counts, snapshot identity, float edge cases, random-source replacement and callback mutation/failure prefixes. Targeted Clippy passes. The fixture uses scalar damage component patches and controlled particle delivery; renderer enqueue, full consumable dispatch and complete gameplay remain pending.

consumable supplies consumption timing and particle/sound dispatch. Both eating and drinking pitch draws occur for every animation before particle callbacks. Sound overrides run afterward; volume and pitch retain their previously drawn values. Particle emission may use a different actor random source from the one supplied for sound selection.

python3 tools/test_consumable_emission_parity.py composes actual Consumable emission with inherited LivingEntity particles and real item templates. The consumable emission report records 124,732 matching lines per JAR, covering all animations, timing overflow and float edges, random-source aliases, optional particles, sound overrides and callback mutation/failure prefixes. Targeted Clippy passes. Sound playback, rendering, consumable completion/effects and full gameplay remain pending.

consumable now also runs eligibility, immediate/timed start and completion. Completion captures its random source before emission, selects the current item for server statistics, dispatches live component listeners, then runs server effects, the game event and finite-material stack shrink in native order. The same input stack is returned even when callbacks empty it. Timed starts return CONSUME without a transformed stack; immediate starts return that stack.

python3 tools/test_consumable_parity.py compares actual Consumable methods with concrete FoodProperties/FoodData, inherited particles, shared stacks and both native random generators. The consumption report records 246,033 matching lines per JAR, covering player/non-player/server branches, food component changes, stat item selection, empty advancement trigger storage, client/server effects, game events, creative material queries and mutation/failure prefixes. Targeted Clippy passes. Eligibility and start-use callbacks, statistics, effect bodies and event delivery remain controlled; listener enumeration here binds the ordinary food schema. Full advancement evaluation, potion effects, entity/world lifecycle integration and playable gameplay remain pending.

status_effect stores shared MobEffectInstance identity, scalar details, hidden chains and blend state. Native copies retain scalar details while omitting hidden effects and resetting blend state. Stronger/longer effect updates preserve hidden-chain aliases and native change flags. Duration mapping skips zero and infinite durations; scaling uses the pinned version's floor and narrowing rules.

python3 tools/test_status_effect_parity.py compares actual constructors, copy/update operations, duration mapping/scaling, equality and blend copying. The status storage report records 655,643 matching lines per JAR, covering constructor clamping, raw amplifiers, shared hidden chains, negative/overflow/infinite durations, float edges and mapper mutation/failure behavior. Equality excludes hidden and blend state as in vanilla. Mismatched-holder warning logs are outside the comparison. Server/client ticking, concrete effect behavior, registries and full entity integration remain pending.

consume_effect implements apply-status, remove-status, clear-status and sound consumption effects. Applying status effects draws probability even for an empty list, creates fresh native-style instance copies and visits every entry without short-circuiting on success. Removal preserves holder order and duplicates; sound playback captures block position before querying the actor's category.

python3 tools/test_consume_effect_parity.py compares the four actual native consume-effect classes with real effect instances and random generators. The consume-effect report records 184,437 matching lines per JAR, including NaN/probability edges, copy identity/details, hidden/blend resets, shared input mutation, return-value aggregation, sound arguments and callback failure prefixes. Targeted Clippy passes. Actor status add/remove/clear and sound delivery remain controlled; named holder-set rebinding, teleport consumption and full gameplay integration remain pending.

teleport_consume implements random-teleport consumption, including the 16-attempt limit, coordinate/random evaluation order, logical-height bounds, dismounting and post-success effects. Successful teleports emit the game event, class-specific sound and optional packed directional-particle event before resetting fall distance and impulse context.

python3 tools/test_teleport_consume_parity.py compares actual TeleportRandomlyConsumeEffect with both native random generators, ordinary and fox actor classes, native offset packing and fall/impulse reset bodies. The teleport consumption report records 282,010 matching lines per JAR, including exact candidates and subsequent random state, height overflow, float edges, attempt exhaustion, captured/live positions and callback mutation/failure prefixes. Targeted Clippy passes. Destination validation and teleporting, passenger links and world event delivery remain controlled services; full gameplay integration remains pending.

status_effect also implements server/client ticking and client blend updates. Hidden instances count down with their parent. When the active duration reaches zero, the hidden details are restored before the server downgrade callback. Infinite effects use the actor's tick count for scheduling. Blend updates retain native callback/read ordering, duration-dependent steps and interpolation.

python3 tools/test_status_tick_parity.py compares actual MobEffectInstance ticks, skipBlending and getBlendFactor with controlled MobEffect callbacks. The status tick report records 412,552 matching lines per JAR, including shared hidden chains, zero/negative/infinite durations, raw amplifiers, early application failures, downgrade notifications, blend float edge cases, removed actors and callback mutation/failure prefixes. Targeted Clippy passes. Registered effect behaviors, entity effect maps, UI rendering and full gameplay remain pending.

java_hash_map now supports non-comparable keys, unequal keys whose comparable ordering returns zero, and the native map-copy constructor. Lookup searches ambiguous tree branches; tree insertion uses class/identity tie-breaking. Copies size their table from the source count before insertion, retaining shared values while allowing the resulting bucket order to differ.

python3 tools/test_java_identity_map_parity.py compares actual JDK 25 HashMap operations and copies across mixed key classes. Each Java process exports its actual identity hashes for Rust to use in that same scenario. The identity/copy report records 577,200 matching lines per classpath run. The ordered-key regression retains 601,084 matching lines, and the cooldown regression retains 167,906 matching lines per JAR. Targeted Clippy passes. Map-only runs use the same installed JDK; these comparisons do not assert gameplay parity or equal identity hashes across processes. Keys must have pure operations; null keys and other unexposed Map APIs remain outside this storage subset.

PlayerAttributeHealth, ServerPlayerDamage and ServerPlayerCombat can now borrow LiveAttributes, the same storage used by the resident moving player, as well as EntityAttributes. Health limits and armor queries use the borrowed store; equipment damage callbacks can update it before damage reduction reads armor and toughness. Player absorption retains synchronized float storage.

The live player combat comparison runs the identical corpus through both stores and matches 1,176,994 output lines against each pinned Java reference. It covers repeated hits, cooldowns, health and absorption writes, exhaustion, numeric edges, armor mutation during a hit and callback failures. Equipment, attribution, death services and other world consumers retain the controlled boundaries documented in the report. Connecting this binding to the resident client landing consumer remains the next step.