Repository navigation
feat(compat): continue Bedrock compatibility improvements - #13
Merged
Merged
Conversation
Record the pinned-client dispatch, quantity, source and return constraints for the remaining authored cooking implementation. Keep controlled fixture boundaries and unfinished execution paths explicit so the backend does not inherit Java click-quantity assumptions.
|
Important Review skippedToo many files! This PR contains 119 files, which is 19 over the limit of 100. To get a review, reduce the PR to 100 files or fewer by splitting it into smaller PRs or changing its base branch. Upgrade to a paid plan to raise the limit. This review couldn't start because sufficient usage credits or metered capacity aren't available. Add credits or update usage-based reviews in the billing tab, then retry.
 |
Expand custom block carrier capacity while preserving vanilla selectors and continue reusing visuals after capacity is reached. Resolve geometry across model directories, retain orphan bone transforms, and load explicitly marked extended cuboid bounds in the client add-on. The recorded Galaxite palette now maps all 3,661 states. Validate vanilla selectors against Java assets, run the full build, and record a fresh playable Galaxite join. Keep larger palette limits and the remaining surveyed rendering defects open.
Carry ordinary native actors' 0.5 alpha reference through compiled GPU pipeline overrides and scope it to each bind. Iris shares shader programs with Java draws, so restore their original references rather than mutate the shared material or ShaderKey. Apply the same behavior to generated fallback shaders and retain scope restoration when a bind fails. Fold the change into the owning actor patch and replay the add-on stack. Builds pass 2352 tests with 152 optional skips. Actual GL readbacks verify native 0.5 and Java 0.1 in shared extended and fallback shader programs. Full shader-pack alpha parity and Galaxite's font particle path remain open.
The captured Galaxite gem-bag effect references font/glyph_E1, which is already present in the shared native resource archive. Accept validated pack-relative paths in the particle parser and fold the earlier resource lookup generalization into its owning runtime patch. The target native field reader retains the declared string without a folder prefix. Tests carry generated atlases through archive delivery, decoding and emitter output. Complete plain and Iris Galaxite replays extract the gem-bag quads with no particle-load errors. Marker geometry, camera item textures and full native rendering parity remain unresolved.
Use the native 64x64 texture defaults and retain empty geometry when bones are absent. Recognize legacy declarations by their geometry keys so optional dimensions do not filter them out. Preserve authored fields and source JSON. Fold the change into the owning CubeConverter patch. All four builds pass 2358 tests with 152 optional skips. Five captured declarations now export with finite values, and a complete Galaxite replay has no marker geometry errors. Camera texture fallback and full native rendering parity remain open.
Preserve secondary water and lava when Java carrier blocks cannot express their fluid layer. Version the native block dictionary, forward liquid state properties, and publish replacement sections for worker queries. Keep vanilla behavior for ordinary Java worlds and unknown native data. Fold the changes into the existing core transport and shared client runtime patches and replay their consumers. Native selector probes pass 180 cases. All four builds pass 2,360 tests; plain and Iris/Sodium replays match 1,280 sampled fluid queries. Fluid meshing, native occlusion and complete fluid simulation remain open.
Keep liquids over native air as real Java fluid blocks so section empty checks retain them. Feed vanilla and Sodium mesh builders and neighbor samples from the native layers while preserving primary block geometry. Rebuild their affected sections when fluid changes even if the Java carrier stays identical, including Sodium's wider exposure sampling area. Fold the work into the existing transport and shared runtime patches, replay both stacks, and keep the test dependency at its first consumer. Project validation totals 2,364 passing tests with 152 optional skips. Both Galaxite replay controls retain the Java bedrock state while native fluid queries transition wet/dry/wet and issue two attributed rebuilds. Both renderers also generate fluid vertices for native-air primary cells. The broader rendering audit still fails on existing camera texture and actor mappings. Native face occlusion, vertex-height parity and complete fluid simulation remain unverified.
Send normal inventory transactions for authored count-one chest controls on client-authoritative servers. Share native item registration, stack limits, destination planning and action scope with the server-authoritative adapter, and retain pending offhand and cursor ownership guards. Fold shared code into the UI patch and adapt the deferred inventory implementation instead of adding a repair patch. Full builds pass 2,371 tests with 152 optional skips. A live Galaxite run verifies form navigation but opens no container, so live chest acceptance and complete native parity remain unverified.
Add an independent patch that captures before and after items when an inventory action is built, so later item mutations cannot rewrite its planned transaction. Record the pinned native constructor evidence and retain a regression that fails against reference-only ownership. Update the owning offhand patch tests to compare preserved item contents instead of shared references, then replay all 103 core patches. The full core build passes 1,442 tests with 95 optional skips, all Checkstyle tasks and Maven POM generation. Live native wire parity remains unverified.
Use the verified native network-item comparator for count-one actions in both inventory authority modes. Share the existing cooking comparator from the first UI consumer, preserve destination-sided query semantics, and remove the obsolete cooking-specific class and API. Normalize binary-NBT float NaNs and non-finite doubles at the codec boundary, matching native userdata reads and scalar writer behavior. Keep generic little-endian IO unchanged and preserve source tag trees. Fold adapter changes into their owning patches and export a separate upstream-sized codec patch. Replay all 104 core patches. The complete four-project build passes 2,342 tests with 212 optional skips and no failures; offline validation and targeted native fixtures also pass. Full native controller and live authored-chest acceptance remain open.
Extend client-authoritative authored actions to hopper, dispenser and dropper layouts using balanced normal inventory transactions. Share exact provider, size and family checks with server-authoritative planning. Accept actor-resolved hopper providers that retain the generic CONTAINER wire type instead of rejecting their valid five-slot layout. Move ordinary storage classes and their opening/presentation foundation to the first UI consumer. Keep modern request-slot bindings in their inventory owner and replay the dependent patches. Require the negotiated family channel and its codec for the new presentation families. All 104 core patches replay. The four-project build passes 2,345 tests, with 212 optional skips and no failures or errors. Targeted action, activation and negotiation cases and offline validation also pass. Live native acceptance and graphical parity remain unverified.
Use constructed stacking properties for authored count-one transfers in both negotiated inventory modes. Ordinary items can merge across auxiliary values when subtype stacking is disabled; damaged destinations can reject merges despite spare capacity. Preserve typed userdata, restrictions and blocking state, and keep full recipe output identity checks separate. Fold the matcher and comparison tests into the owning UI patch, adapt the deferred authoritative backend, and share the userdata comparator with recipe output queries. Record the new canonical block-data prerequisite. The old raw planner fails the native destination-selection regression. Fresh complete native predicates agree across 756 cases. With those and existing native recipe output controls enabled, the full core build passes 1,485 tests with 90 optional skips, all Checkstyle tasks and POM generation. All 104 exported patches replay to the exact tested source tree. Complete native controller, wire and live server acceptance remain unverified. Preserve the concurrent binary-NBT normalization and redstone storage adapters. Keep the general stack-query API for recipe admission, with one shared userdata comparator and separate occupied-slot merge eligibility.
Record the complete physical-slot snapshot producer before wiring recipe selection actions. Separate verified traversal, append behavior, vector growth and item ownership from provider registration and the full history lifecycle, which still require evidence. Scope zero-count copy controls to ordinary non-block Items rather than inferring rules for populated userdata or associated-block wildcards. The private native probe passes 36 producer cases and two copy controls. Offline tooling, regression and patch-metadata validation also pass.
Extend snapshot evidence to long collection keys, complete hotbar and inventory captures, and aligned vector growth. All 45 producer cases and two ordinary zero-count copy controls pass with checked ownership cleanup. Preserve the concurrent native occupied-slot merge fix and validate its four-project integration with all four relevant private fixture suites. The build passes 2,350 tests with 212 optional skips and no failures. Offline validation passes. Cooking input, return/history lifecycle and live native parity remain separate implementation work.
Ignore unknown link roles before changing pending relationships, and skip repeated mounting for passengers already listed on the vehicle. This keeps an invalid role from creating a passenger and prevents a duplicate rider link from changing seat ownership. Fold the predicates into the passenger-link patch and replay all 104 core patches. Pinned native instruction comparisons cover 160 consumer cases and 288 has_rider query contexts; 40 resolved membership cases match core. Three regression checks fail before the fix and pass afterward. The full core build passes 1,488 tests with 90 optional skips and no failures. Native queue timing, unresolved relationship lifetimes, initial seat ordering and mounted-camera locator binding remain separate goal work.
Record the original provider registration and model-import path before implementing recipe actions. The resulting snapshot traverses inventory before hotbar, includes the combined view, and excludes recipe providers through their native callbacks. Document repeated-return controls that execute native history replacement with owned item caches. Keep supplied transfer effects and unverified controller, input, wire, and visual behavior explicit.
Both accepted Bedrock link roles enter the same native mounting path. Choose the first seat from actor kind instead of the wire role, so a new player precedes a resolved non-player while an existing first player or unresolved first passenger keeps its place. Reject self-mount links before they can become pending relationships. Fold the behavior into the owning passenger-link patch and remove the unused role argument from resolved insertion. Native Actor/Mob routines match 224 component-mutation cases and four self-mount rejection controls. Core matches both roles across 448 insertion comparisons. Four targeted checks fail against the previous role-based implementation. The full core build passes 1,491 tests with 90 optional skips and no failures. All 104 patches replay to the identical tested source tree; Checkstyle, Maven POM generation and patch metadata checks pass. A fresh mounted-scene capture remains unverified because the recorder's private-copy disk reserve check fails. Queue timing, relationship removal lifetimes, full cycle handling and mounted-camera providers remain open.
Return mismatched cooking input with the shared occupied-slot predicate. Permit compatible auxiliary variants of non-subtype items and reject damaged destinations that native stacking disallows. Fold the correction into the owning recipe patch. Regressions cover atomic refusal, request identities, destination metadata, and recovery of the original variants after server rejection.
A negotiated native inventory channel does not guarantee that Java loaded the converted pack. Keep the ordinary menu until resource loading succeeds, without consuming a presentation sequence. Report missing or corrupt pack images through the existing client presentation failure handler instead of silently drawing inventory items without their panel. Preserve asynchronous URL loading and recover cached image failures when a resource reload supplies a new source. Both regressions fail before the changes and pass afterward. The core passes 1,494 tests and the add-on passes 843, with 212 optional skips and no failures. All 104 core and 38 add-on patches replay to the identical tested source trees. The latest-release screenshots also report pearl/wind-charge rollback, repeated eating and a missing locator bar. Those symptoms and the exact screenshot cause remain unverified. Live capture could not launch because the private-profile copy requires more disk space than is available.
Record fresh native checks that connect constructed backing policies to owned slot mutation and Place request assembly. Distinguish ordinary source locks from cooking admission and preserve the remaining cooking, input, wire, and gameplay verification boundaries.
Record fresh return runs for all three ingredient descriptors with original backing policies, provider cache reset, generic placement, and request assembly. Keep unresolved world targets and the missing selection/input pipeline explicit so these checks cannot be mistaken for complete authored cooking support.
Wait for the recorded game JVM to exit before terminating its private Prism launcher and remaining owned descendants. Concurrent launcher teardown left the NetherNet capture client unresponsive and prevented its copied dependencies from being released. Recognize Minecraft's connection error before spawn so failed joins leave the startup wait promptly, including transfer-enabled runs. Preserve process birth checks and retain dependencies on shutdown failure.
Native dispatch distinguishes initial selection and selected-state release through a numeric event phase. Keep that phase alongside the command and snapshot identity in version 4 action and result envelopes, and reject older phase-free actions instead of assigning a default. This adds the transport prerequisite for authored controls; input delivery and the complete cooking action backend remain unfinished.
Reject correction tick zero before changing player state, as the pinned native receiver does, and retain all unsigned tick bits in the negotiated correction payload. Deliver authoritative vehicle velocity separately from Java's position-only vehicle update, including zero resets. Fold these changes into the existing movement patch. Native instruction controls cover 864 correction admissions and 48 command applications. Packet regressions fail before the fixes and pass afterward. Complete historical admission, input resimulation and vehicle ground/angular state remain open; the live boat probe still receives repeated corrections.
Document the original input startup and recipe callbacks verified by 1,008 controls on the pinned Bedrock executable. Preserve the raw phase ordering, typed collection-index rules, retained fields, and result bits for the unfinished authored cooking backend. Keep physical input mapping, provider index validity, selection effects, and live transaction acceptance explicit as unverified boundaries.
Match each authored recipe control to the exact sorted and filtered collection entry before granting action authority. Reject missing or non-integer indices and IDs that belong to a different visible cell. Record native source resolution, selection/release, and controlled first placement evidence with explicit fixture and wire-serialization limits. The full build passes 2,368 tests with 212 optional skips. Offline stack validation, Checkstyle, and embedded core class comparison pass.
Record fresh native quantity and repeated-selection controls through the original input graph, cooking manager, transfer executor, and request action assembly. The results distinguish native primary selection from Java recipe-book increments and verify capacity, item conservation, and player-provider aliases. Keep the shared open-request boundary explicit. Complete serialization, frame/request ownership, full controller construction, and server acceptance remain unverified.
Configure emitted-input retention from the server history size and match native capacity, continuity and unsigned oldest-tick admission. Missing prediction payloads retain their clocks and evict expired frame bindings. Reject expired player and vehicle corrections before they change live state. Fold the change into movement owner 0092 and replay the complete stack. Record 512 joined native queue/replay controls, 12 capacity controls and 1,500 production admission comparisons against 300 native history cases. Sixteen additional controls cover current-tick command transfer. The integrated build passes 2,382 tests with 212 optional skips. Historical component restoration and real physics replay remain unfinished. A fresh live recording still receives repeated corrections and fails normal JVM teardown; retain that evidence without claiming native movement parity.
Resolve the compound constructor through its 38 native enum names instead of inheriting Salt from the Java carrier. Preserve byte wrapping, absent and unknown descriptors, lazy source access, and registry replacement. Fold the provider into the authored UI owner and replay its consumers. Verify actual initialized native receiver keys and cleanup, packaged item conversion, mutation controls, existing name providers, and all four builds. Keep native descriptor/session ownership, query transport, visible screens, and the reported E-driven inventory failure explicitly open.
Record the packaged default-scene rejection and original native dispatch, toggle phase and checked-state behavior needed to admit those controls. Preserve the distinction between a verified private model and production input delivery, which still requires native focus and hover producers. Document supplied interfaces and negative controls so later integration does not replace focused input with pointer hit testing or activate touch controls on the wrong phase.
Record original focus ownership, float default ranking and bounded directional navigation alongside hover-produced focused dispatch. Preserve the verified construction and allocation boundaries so controller integration does not substitute Java focus for native event delivery.
Read native component flags as booleans or signed/unsigned 64-bit integers, preserving defaults for real values and other JSON types. Share the reader between scene admission and runtime queries, and default keyboard traversal focus to disabled as the native factory does. Fold the change into the existing shared UI patch. Original factory and ScreenView execution now cover construction, implicit hover, selected button delivery and history cleanup. Keep full native navigation, device translation and unchanged authored screen acceptance as explicit remaining work.
Java rectangle traversal cannot reach clipped controls or preserve authored focus-container routes. Use native edge scoring, scroll viewport searches, container policies and remembered focus while retaining widget identities across scene refreshes. Synchronize revealed edit fields during layout so they accept input before the next render pass. Fold the change into the shared scene patch. Original native comparisons cover geometry, container routing, viewport selection and history fallback. Complete native screen construction and physical controller input remain separate requirements.
Retain mapping phases, release captures, checked state and directional focus across container binding refreshes. Apply emitted toggle changes before scoped button events and compose non-consuming preference updates so tab and filter choices cannot overwrite each other. Keep collection selection separate from keyboard focus, and clip pointer input to scroll viewports. Fold the shared runtime and container consumer into their existing owning patches. Unsupported screen-owned routing and focused slot actions retain ordinary controls. Default search/slider handlers, complete controller and device delivery, native lifecycle and original screenshot reports remain open. Validation: 54 targeted tests; full build with 2,738 passing tests and 163 optional skips. Actual packaged input/container classes match 384 original native steps and parse all 15 unchanged default toggle definitions. The standalone container PR check still requires its declared shared UI patch.
Route implicit recipe-cell hover through the cooking controller and consume both entry and exit phases. Clear a selection only while its collection and cell index still match, so an older exit cannot erase a newer selection across binding refreshes. Verify native integer extraction and conditional clearing against original callback execution, add real screen and interleaved selection regressions, and retain explicit limits for complete default controllers.
Connect authored tab buttons and navigation input panels to the native category transition model and existing preference transport. Retain activation phases, layout rules, carried items and authoritative acknowledgment checks, and clear cell selection when the native tab callback refreshes. Require preference transport for zero-size global panels and preserve explicit limits for held-item commands, screen-host mappings and mixed inventory dispatch. Validate original callback execution and packaged transitions alongside real pointer and keyboard screen regressions.
Resolve the real authored screen graph so cooking input mappings, policies, overlays and inheritance survive program transport. Retain host-owned navigation phases across model updates and keep slot, recipe and title authority separate from presentation. Reject the unimplemented player-hurt policy before input. Add real host interaction coverage, verify exported desktop hosts and final packaged classes, and record the native pocket self-reference as unresolved without changing recursion semantics.
Resolve self-referencing pocket declarations through the owning shared UI patch. Finalize ancestors in declaration order, preserve local nulls, reuse completed parents, and stop at missing or visited declarations. Keep recursive control expansion bounded and preserve export order so client programs retain the same inheritance behavior. Original native registry execution supplies 751 lookup results across three-node graphs and the pocket declaration. Direct and exported Java programs match all 1,502 comparisons. All six desktop/pocket cooking hosts resolve and round-trip; physical input and native pixels remain unproven.
Route arrows through retained native input phases instead of moving focus on every Java key callback. Match initial focus precedence and float ranking, then reveal the selected control before pointer and nested hover delivery. Keep controller events behind the VIEW queue. Fold the changes into the scene and container patches. Native comparisons and packaged screen regressions cover the supported routes; full screen construction, pointer controllers, focus-tab groups, GLOBAL reinjection, physical devices and pixels remain open.
Reinject GLOBAL targets with the previous raw phase before delivering the original controller event. Keep phase two distinct from press and release, retain completed double-press state, and apply the current View mode while preserving physical coordinates for raw input clipping. Keep unsupported cooking inventory, recipe and close aliases on the ordinary screen until their native event receivers preserve action ownership. Fold the input and consumer changes into their owning patches. Original native comparisons cover raw phases, GLOBAL recursion, capture, hover and preference effects; packaged regressions verify the consumers.
Select visible and enabled navigation tabs by authored index, keeping native tree-order ownership for checked and duplicate indices. Deliver the group change before old/new tab hover events without moving View pointers. Keep this route distinct from Furnace category callbacks and admit keyboard input according to its VIEW receiver. Fold the consumer and screen regressions into the owning container patch. Original native comparisons cover selection, group state, phases, hover and controller effects. Focus-enabled tab lifecycle, full screen updates, controller pointer handling, devices and pixels remain incomplete.
Transfer focus and reveal focused VIEW tabs before delivering their hover queue and group change. Keep both View pointer positions, and retain the separate change-first route for tabs without focus. Do not derive the native selection latch from FocusManager ownership. Native overlapping controls assign hover and focus independently; the extra flag activated a second mapping and changed preferences twice. Fold the changes into the owning container patch. Original native comparisons and real screen regressions cover the bounded active-manager path. Complete manager activation, Button latch lifetime, pointer receivers, screen lifecycle, devices and pixels remain open.
Distinguish edit-box selection from the separate Button appearance component. Record the original factories, input composition and property producers together with the confirmed gaps in the published client. Keep the prior focus correction and runtime source unchanged. The native captures establish the next consumer work, not full screen parity.
Supported cooking controls consumed input even when the native Button component declined it, and draw collection never selected a pressed branch. Retain the press byte separately from applied visibility and apply native named setters before layout and hit geometry refresh. Preserve suppressed transitions, phase two, scene replacements and the different own/ancestor property lifetimes. Run raw component effects before later controls read their context, and keep implicit hover buttons on the controller route without another sibling press callback. Fold the runtime and consumer into their owning patches. Original native comparisons and packaged regressions cover the declared component and active input routes; full screen construction, property timing, pointer receivers, audio, physical devices and pixels remain open.
Invalidate native Input mappings when visibility callbacks or input-order removal require it, while preserving double-press history. Keep captured controls addressable after they leave normal input order so hidden GLOBAL releases retain their native phase and component delivery. Fold the changes into the shared UI and container owners. Compare the complete original pending-update path, initial hidden registration and direct visibility callbacks against the final packaged consumer. Record external notification scheduling and the remaining screen/device limits.
Create and index input components before resolving Button state names so nested and aliased setters notify their owners in native component order. Commit sender phases after reentrant callbacks, and dispatch wildcard callbacks before subsequent mappings sample their state. Keep registration and inherited visibility on the later View update. Restore cached appearance on matching scene copies without replaying property events that would reset held child input. Fold the implementation and regressions into their owning patches. Record 216 new original native cases with real notification queues and balanced cleanup, while retaining the full construction and physical-device limits.
The bare-context mode probe omitted the root component notification and its queued registration update. Record the complete producer's callback, phase invalidation and retained capture behavior before integrating mode delivery into supported screens. Keep native reference coverage separate from the published production parity claims, and retain the screen-install and device admission limits.
Prepare supported cooking mappings once before the first controller input. The original View queues initial mode invalidation before activation, so new mappings start at phase two. Keep held phases across scene refreshes and resize preparation instead of replaying that initial notification. Fold the implementation and screen regression into the container patch. Record the complete native wrapper reference and its supplied boundaries; physical mode notifications and full screen parity remain unfinished.
Java resynchronizes the pointer after screen initialization without a movement event, then forces the first frame before setScreenAndShow returns. Deliver initial hover at that resynchronization boundary so a stationary pointer selects the authored recipe immediately. Convert Java HUD coordinates through the native viewport and reject a callback for a screen that is no longer installed. Extend the screen regression across unequal scales, model refreshes and stale ownership. Replay later mixin descriptor contexts around the new admission hook. Record the complete original installer and client mode callback evidence, plus isolated-client verification of the transformed Gui hook ordering. Physical mode admission and full native screen parity remain unfinished.
Preserve native tabs, filtering and independent inventory/workbench layouts while projecting their active context into Java’s shared crafting book. Keep all four recipe-book settings in one connection-local storage without a compatibility shim. Fold the transport and menu lifecycle changes into the owning recipe patch and replay its downstream contexts. Verify packaged options, native UI references and live BDS crafting and furnace workflows before the patch release.
Establish the separate local-player renderer before extending the authored inventory path. Original execution distinguishes actor rotation from body and head yaw history, pose-specific framing, cursor admission and mounted actor restoration. Record 672 original draw calls with real sparse component access and normal return, while keeping supplied renderer boundaries and missing Java/GPU integration explicit. The runtime remains at the verified 0.3.53 source.
Give player inventory its separate local-actor renderer, with independent actor, body and head rotations and pose-specific native framing. Apply its model correction after Java PIP translation while retaining scoped GUI playback and world rotation state. Fold shared rendering and adapter admission into their owning patches. Verify the full stack, the original 672-case camera reference, packaged negative controls and actual Java submission at two viewport/GUI scale pairs. Full authored inventory, native pixels and successful native renderer effects remain unfinished.
Open the Bedrock inventory after Java installs the actual screen, using one negotiated route for direct translation and ViaProxy. Constructors can create unused screens, and Java reuses menu zero across openings. Retain retired native opens until acknowledgment, serialize close/reopen races, and correlate server closes to the owning client opening. Preserve global inventory actions, support the creative picker, and keep tokens monotonic when reconfiguration replaces the play listener. Recovery must not duplicate an outstanding native open. Fold the implementation into the existing inventory, offhand, and native container patches. All four builds pass 2,817 tests with 163 optional skips. Sixteen packaged regressions and four real E-key cycles cover lifecycle behavior. Full authored player UI and native parity remain open.
Execute the target constructor slice, layout and tab getters, collection-name initializer, and creative-mode predicate to establish the player controller state contract before implementing its authored screen. Distinguish the effective creative predicate from controller input mode and the independently produced constructor flag. Record supplied boundaries and keep complete recipe grouping, production presentation, physical input, and visible parity explicitly unfinished.
AlexProgrammerDE
marked this pull request as ready for review
October 24, 2026 08:57
Use the same native bucket partitioner for cooking and grouped recipe collections. Retain catalog identity and icon/count-based expansion history across refreshes. Fold the implementation into the shared UI patch. The full build passes 2,823 tests with 163 optional skips. The packaged core matches 4,128 original native cases and sixteen retained-state steps. Full catalog acquisition, player controller integration and the original bug reports remain open.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
This PR fixes compatibility issues found during the Bedrock server survey and continues the native movement, inventory, UI, camera and rendering work.
Galaxite custom blocks exhausted Java carrier states and appeared as dirt. The carrier pool now maps the recorded 3,661 states onto 3,340 visuals, reuses compatible visuals at capacity, and resolves shared and orphaned geometry.
Changes
Validation
All four projects build. The final build passes 2,823 tests with 163 optional skips and no failures or errors. Checkstyle and bundled native references pass. All 1,465 core classes match their add-on and proxy copies; all 1,191 client classes match the tested add-on. The standalone packaged core repeats all 4,144 recipe comparisons with its class origin verified. The 105-patch core stack replays successfully.
The recipe model matches 4,128 original Bedrock 1.26.51.1 cases and sixteen retained-state steps. These compare ordering, visible rows, evaluator calls and expansion notifications, with explicit item/evaluator/external callback boundaries.
Earlier integrated checks include sixteen packaged inventory lifecycle regressions, four real survival/creative E-key cycles through ViaProxy/BDS, 672 player-preview reference cases, 1,940 UI input cases and 35 screen regressions. The owning patch notes retain each check's build provenance and supplied boundaries. Controlled cooking projections retain real inventory addresses but remove unfinished controls; they do not establish unchanged authored-screen parity.
Scope and continuation
The user requested merging this completed milestone and continuing in a new generic improvements PR. This merge does not complete the five-part implementation goal or establish full native parity.
The original inventory background/scale, pearl/wind-charge rollback, endless eating and missing locator reports remain unresolved. E opens Java's ordinary inventory presentation today. Full authored player recipes, tabs, search and controller/touch input remain unfinished.
Remaining implementation
See player inventory evidence, cooking action evidence, the server survey, and each owning patch's
.pr.mdfor implementation details and verification limits. Private captures, screenshots, original native images and runtime diagnostics are excluded from this PR.