All Classes and Interfaces
Class
Description
Runtime controller instructions, including the authored stop-expression version.
Full-precision live velocity plus its placement in the actor's retained input history.
Admitted native movement, independent of both the receive cache and Java interpolation.
One wire layout for ordinary, attack, and predicted-use swings.
Protocol 2193 packet 158 uses unsigned runtime IDs, not unique actor IDs.
The cumulative vanilla resource cutoff advertised by a world, independent of server packs.
Native world-version parsing strips suffixes before comparing feature gates.
Physical fence geometry for Bedrock 1.26.51, independent of Java shape merging.
Complete non-trickle HTTP signaling shared by direct clients and proxies.
CraftingData results keep their complete headers and clamp signed counts before Item construction.
The native float lookup shared by actor expressions and view bobbing.
Ordered resource-pack rules retain the authored bone, cube and face selection.
Tracks block interaction sounds already played by the Java client's prediction.
Native BlockLegacy identity and the auxiliary value stored by its canonical palette entry.
Canonical block-item metadata, independent of connection runtime IDs and saved-item auxiliary lookup.
Resolves a block item's legacy auxiliary value before concrete descriptor conversion.
Resolves native primary registrations before aliases and namespace fallback.
Network trait state registration, in the native block's auxiliary-bit order.
Local result matched to the concluding Java prediction sequence.
A held control can span targets, selected items, and authoritative corrections.
Compiled native block-definition keys, before localization or item-specific dispatch.
Supplies licensed native images and actor resources missing from the bundled metadata packs.
Bedrock 1.26.60.5 bundle cells retain their original dynamic-container slots.
Native tooltip bindings use physical contents and input mode independently of screen layout.
Modes 1 and 2 activate the retained tooltip source.
Native packet-321 requests and their connection-scoped client context.
Native block discovery, two-slice cache and visible-face queries.
Priority and exclusion are resolved against the current native category before the query.
Publishes complete catalogs only when changed, with independent actor metadata diffs.
Client-thread state with atomic view replacement and ordered, lifetime-scoped actor bindings.
Native 1.26.51 camera identifier/control-scheme interaction policy.
Protocol-2193 aim-assist commands, definitions, and actor-priority updates.
Native odd-tick position/facing cache.
Native eye-space candidate geometry, independent of actor enumeration and world obstruction.
Native held-name/category cache and actor-exclusion recheck flag, retained for an active component's lifetime.
Negotiated, ordered aim state; actor bindings have the same lifetime as native actor snapshots.
Native preset/category lookup and block policy.
Connection-owned native definitions and pending command requests.
Native non-debug ranking after geometry, exclusion and obstruction queries produce candidates.
Blocks supply visible face points; entities supply their picking-box center.
Accepted connection state.
Listener orientation is independent of the rendered camera when a preset selects the player.
Native camera avoidance.
Angles are radians.
Camera interpolation functions used by the native client.
A core-resolved fade timeline.
Matches the target client's fade point insertion and overlapping fade rules.
Runs follow-camera instances independently of the active position blend.
Native actor identity stays available while its render entity or physical bounds are pending.
Translated entity position and native physical center, sampled at the same render time.
Follow-camera instances and attachment generations, independent of position-blend commands.
A resolved FOV transition and, for live delivery, the command that changed it.
Core retains the unresolved local projection, without substituting a fixed FOV.
Shared native command and frame update rules.
Protocol 2193 camera fields.
Native orbit component math.
World position and native quaternion, with rendering fields retained during a blend.
Native incremental camera blend.
Preset instances retain instruction overrides independently of the active camera.
Core-resolved command.
Protocol 2193 presets.
Resolves received names without changing their instruction indexes or inventing missing parents.
Float camera traversal and box surface intersections, independent of the renderer's world access.
Eligibility bounds and final ray-hit bounds can differ for custom blocks.
World-space hit.
Native common pick policies.
A sequenced command and a resumable snapshot of the native shake queues.
Native queue updates shared by proxies and rendering clients.
Packet 338 uses a required curve type and optional easing on named keyframes.
Native channel interpolation and chord-weighted linear or Catmull-Rom curves.
Compiled spline channels.
Named definitions replace the table atomically.
A spline command belongs to one preset epoch and does not select a camera.
Per-preset target rotation.
Maintains all free-camera instances independently of the active rendered perspective.
Complete preset identities and target commands; rendered rotations remain client-owned.
Versioned presentation state.
Computed light data of a whole chunk column.
Native 1.26.51 separated-axis contact clipping.
One complete command block edit, including Bedrock settings absent from Java's packet.
Compiled Item flags and persistent components have separate update lifetimes.
Normalizes legacy connected blocks whose state version did not change in 26.60.
Native opening fields, distinct from the translated menu type and physical block binding.
Native container scenes bound to actual Java menu slots, without a second inventory authority.
Raw authored title conditions and independent native label localization.
Target cooking-controller transitions, independent of item and recipe authority.
Native availability tests alternative input presence, independently of placement capacity.
Authoritative station catalog, including all unlocked input alternatives for each displayed output.
Cooking descriptor visitation constructs default Items rather than retaining the declared auxiliary value.
The pinned native cooking book sorts signed priorities and can reorder equal priorities.
Native cooking collection caches eligibility by concrete descriptor before ordering source groups.
The furnace edit callback retains only the latest raw value until its controller is ready.
Native cooking scenes retain raw actor progress and separate recipe identities from item slots.
Unlock and deduplicate registry entries before priority sorting and tab/search/filter selection.
outputName is the native item's unqualified name, independently of metadata or namespace.
Native selection identifies a cell in its resolved collection, independently of recipe network IDs.
Reads the separate recipe arrays introduced by Bedrock protocol 2193.
An action can use this snapshot only on its original connection and catalog revision.
The creative inventory advertised by one Bedrock server connection.
One player model's progressive creative collections and retained active-tab refresh state.
Native culling rules and face slices, independent of collision, Java carriers and connection route.
Resolves component overlays against one concrete state without modifying server definitions.
Native terrain neighborhood selection, independent of the client renderer and world storage.
Inner axis is X for horizontal/North/South faces and Z for West/East faces.
Opacity controls the diagonal fallback; ambient brightness is a separate native property.
Material lighting retained on each authored face, independently of texture and culling identity.
Compiles static Bedrock block components in block units, without item-display fitting.
Native position-seeded block offsets.
Tracks acknowledgement of the supplemental block-model pack during configuration.
Physical properties transported with the converted server pack, independently of its connection route.
Exports resolved Bedrock block visuals on unused Java carrier states.
Immutable render and shape information for one reserved Java block state.
Block-local bounds in Java block units, after the Bedrock component transformation.
Client-owned emote controls.
World policy needed before the client makes its optimistic local announcement.
Bedrock 1.26.51 EmotePacketPayload (protocol 2193).
Client integrations may consume native emotes directly or through the versioned payload.
The connected client's advertised wheel and local playback state.
Keeps native references while their targets are outside the Java client's entity set.
Native player flight input and drag, with separate float operations.
Flight values that the standard Java abilities packet cannot represent.
Native 1.26.51 accumulation and motion update for observed liquid flows.
Atomic command and biome settings resolved against this connection's selected resource packs.
Native per-family preferences; retain unknown enum values without interpreting them.
Protocol 2193: byte family, signed VarInt tab, boolean filter, signed VarInt layout.
Plans ingredient transfers only.
Native 1.26.51 geyser movement using the player's current block column.
Native glide travel before collision resolution, with confirmed rocket boosts.
Convert the resolved bitmap family and its Unicode fallbacks as one font.
Resolves action-bar factories independently of title instances and title timing.
Resolves native HUD factories from the bundled and accepted HUD definitions.
Persistent accepted-pack HUD decorations independent of title and actionbar lifetimes.
Resolves native title factories from the bundled and accepted HUD definitions.
Server restrictions supplement the player's HUD settings.
Returns temporary inputs and the cursor before acknowledging a screen close.
Owned, nonphysical frontend targets for each native picking box.
Native inventory filtering changes item lighting independently of control opacity.
Native player-inventory preferences, including independent inventory and crafting layouts.
Connection-local native options and the separate Java recipe-book projection.
Protocol 2193: signed VarInt tabs, boolean filtering, then signed VarInt inventory and crafting layouts.
Native slot, cursor and recipe labels share this count text producer.
Immutable native item context needed by client animation queries.
Native equipment values, indexed in Bedrock's head, chest, legs, feet order.
Compiled block-placer state, including partial reads and post-load owner binding.
Item traits used by Bedrock's cooking recipe categories, independently of Java item types.
Description sources are evaluated only by the selected definition's producer.
Native food admission includes other installed components that can start use.
A serialized parent is shared; each child owns its texture bindings and display transforms.
Connection-owned sources stay lazy until the receiving native name method needs them.
A source descriptor retains the resolved Item receiver independently of its numeric cache key.
Concrete descriptor identity used by native recipe grouping and availability caches.
A connection's constructed definitions, raw declarations and independent lookup owners.
Constructed native Item ownership, auxiliary metadata and optional Block identity.
Runtime IDs identify exact palette slots.
Stacking state belongs to the constructed native Item factory.
The result descriptor inside a stack request uses an item name, unlike inventory slot items.
Definition-owned storage rules, before descriptor resolution through the native registry.
Storage components belong to the selected native Item definition.
Native ItemUseSlowdownSystem produces a modifier; its apply system squares it.
Immutable loaded JSON UI declarations, resolved with a domain controller for each session.
Native UI images retain their pixels; UI controls receive isolated Java resource identifiers.
Byte-oriented Bedrock language-file parsing, before text display conversion.
The native shulker label passes one typed integer to a length-aware printf formatter.
Native exact-key lookup followed by cached or ASCII-folded language lookup.
Native language token expansion and argument substitution over UTF-8 bytes.
Ordinary Item definitions update flat namespaced scalars independently.
Computes Minecraft style sky and block light for a chunk using the block data of the chunk and
its eight neighbors.
Caller-owned compiled source.
Shared Molang functions using the target Bedrock float arithmetic.
Builds Mocha expressions with assignment precedence and modern nested Molang conditionals.
Typed packet variables retain native names, member order and float conversions.
Native 1.26.51.1 collision-cache admission, swept query, and uncovered-region traversal.
Native 1.26.51.1 collision-world traversal and unavailable-region geometry.
Native unsigned input clocks bound to the connection's monotonically increasing physics frames.
Confirmed effect, exact history binding and the latest paired input clock.
Client frame clock, local effect prediction and server confirmations.
A server-enabled dynamic recipe whose inputs and result depend on item data.
One complete attack, including the frontend's picked world position and actor lifetime.
Physical actor dimensions, independent of interactive picking boxes and Java entity dimensions.
Native picking boxes, independent of the actor's physical collision dimensions.
Target-verified Molang reads from the actor's typed integer metadata, without Java entity substitutions.
Native actor resources in resolved pack order, including their server or built-in provenance.
Immutable native inputs, independent of frontend translation objects.
Raw unsigned native palette indices, independent of frontend dye colors.
Separate picking geometry; physical actor dimensions are not changed.
Reach excludes this surface padding; authored picking boxes carry zero.
Client-thread registry with native lifetime checks and local Java identity resolution.
Retained command definitions; each rendering context resolves its own animation resources.
Animation commands bind to the actor lifetime that received the server packet.
Ordered authoritative block identity snapshots and changes for native client effects.
Native layer identities retain distinctions lost by the Java block mapping.
A client mirror of both native block layers and state properties, with no reverse Java mapping.
Only a displayed source and input are client supplied; stacks and physical contents remain server owned.
A trusted opening's physical bundle operations, separate from Java bundle item ordinals.
A rejected insertion can still submit preparation requests.
Published physical source values own commands independently of client item previews.
Optional bundle reply keeps operation sounds distinct from unavailable or stale input.
Retain native physical slots independently of Java's compacted bundle contents.
Physical previews are independent of the compacted and capacity-limited Java bundle component.
Native physical-slot operations, independent of Java bundle item ordinals and wire request IDs.
Trusted definition and slot policies belong to the current server-owned inventory snapshot.
One request's owned before/after items.
Only a clicked source ordinal is client supplied.
Server-authoritative request adapter for the negotiated count-one manual presentation.
One trusted exported presentation's authorized native count-one slot actions.
Resolve action scope from the current authoritative menu and authored program.
Server-owned plan for the ordinary container_items count-one native action.
Immutable counter update scoped to one exported menu presentation.
Normal inventory transactions for a client-authoritative authored storage presentation.
Presentation for an existing Java menu; ordinary inventory packets retain item authority.
Server acknowledgment of the exact live presentation's action backend and current scoped
controls.
The ordinary container_items count-one action, independent of inventory authority.
Connection-local presentation ownership; the selected inventory backend retains item authority.
The genuine current-menu backend, not a client-supplied item or destination plan.
A native command and event phase refer to one exact server-owned presentation and inventory snapshot.
Preserve the authored input command without assuming Java placement quantities.
A completed selection can resume only while its exact inventory snapshot remains current.
Activation and retirement belong to the exact cooking snapshot shown by the client.
A cooking presentation retains Bedrock state independently of Java menu properties.
Progress changes do not retire item authority or restart the cooking activation handshake.
Native output selection, ingredient collection, and item return.
Echo the full control identity so delayed acknowledgments cannot activate a refreshed screen.
Publishes one exact menu's authoritative cooking state; progress does not replace item authority.
The native typed crafting-table component, independently of its admission and state selection.
Manual output pickup and the separately scoped requests from one native Shift-click.
Core-evaluated render controllers for the actual Java actor identity.
Fishing feedback retains the authoritative fish metadata and samples the current client hook.
A resolved resource-pack form uses the ordinary form response identifier and original indices.
Negotiated native preferences, independent of Java recipe-book state and connection route.
Native equip height and retained-item update for one simulation tick.
Action-bar instances expire independently; title clear, reset and timing packets do not affect them.
An authored HUD scene and its native lifetime.
Retains subtitle-before-title ordering without restarting a live title for subtitle updates.
Constructor-owned definition identities and the independent native lookup tables.
The executed native custom-name/lore branch, without guessed default item localization.
A name and auxiliary value before native definition lookup and Item construction.
Native unfiltered name selection.
Immutable decoded Bedrock stack data before Java conversion.
Native occupied-slot merge eligibility, separate from transfer identity and capacity.
Native item queries compare network-loaded stacks in one stable connection registry.
Native storage weight is independent of the Java bundle component and its capacity rules.
Retained network position and interpolation inputs used by the native solid-shape refresh.
A null scene closes only the matching conversation, so delayed closes cannot replace a newer scene.
Native effects retain their source actor and a complete standard Java fallback.
The native legacy particle path uses the rendered camera and two independent distance settings.
Commands bind to one displayed snapshot, independently of Java menu-zero reuse.
Complete player presentations are compressed within Java's custom-payload limit.
A reply releases only the command which belongs to the same opening and generation.
Retains the installed player/workbench model without granting it item-request ownership.
Projectile Java UUIDs identify individual spawn lifetimes, including reused native actor IDs.
Applies authoritative owners when the source and target exist in the frontend's entity set.
Native ingredient availability rounds, independent of placement and stack request authority.
Output lookup owns candidate admission, concrete grid requirements and priority.
The concrete recipe owns descriptor emptiness and ingredient matching.
A captured native collection.
Plans one native catalog auto-craft without mutating its authoritative sources.
Resolved native descriptor values.
The representative is retained for presentation.
Each native ingredient position owns its deferred value and retains the first resolution.
Native Molang payloads have no representative even when their predicate matches concrete Items.
These are native registry/block interfaces, not a fallback policy for unavailable data.
Admission and emptiness enumerate the index; matching reads the candidate receiver independently.
Recipe lookup through the connection's constructed definitions and registered block context.
Searches native item names and display labels with the owning screen's matching policy.
The pinned native search uses Unicode 5.0 compatibility composition and case folding.
Player blocking timestamps sampled once per simulation tick.
One ordered transfer per client connection.
A client request supplies appearance data; core selects the native player identity.
A versioned fragment of the target protocol's complete SkinData, including persona and animation fields.
Keeps ordered wire snapshots until the Java play listener advertises native skin support.
The pinned native STL sort, including its ordering of comparator-equivalent entries.
Ordinary external storage providers with direct container slot identities.
Descriptor bindings belong to the storage definition and its connection registry.
MSVC unordered-map traversal for unique UTF-8 keys, with the caller's native hash function.
Native transfer quantity decoding, after source validation and available-count resolution.
Original local-player damage cause, before Java damage registry mappings coalesce causes.
Player-owned pending check and update counter, independent of the current screen's lifetime.
NBT byte strings in Java.
Connection-owned construction from raw headers and descriptor conversion from constructed native Items.
Server conversation bindings for the native NPC screen, independent of its authored layout.
Actor-scoped editing state shared by the server projection and the add-on controller.
Physical use-control lifetime, independent of repeated Java block-use packets.
Exact native correction, paired with a Java player or controlled-vehicle position packet.
Connection-scoped pairing for a correction payload followed by its standard Java position packet.
A gameplay key sample before the server's permission mask is applied.
Server permission mask.
Identifies one installed player screen, independently of Java's persistent menu zero.
Admits one requested player screen after its native container acknowledgment.
Identifies one installed player screen, independently of Java's persistent menu zero.
Serializes uncorrelated Bedrock opens and retains retired openings until their acknowledgments arrive.
Authored player and workbench scenes retain actual slot and recipe-cell identities.
A negotiated local mode event and an immutable copy of all native ability owners.
Float bits preserve signed zero and NaN payloads in historical state and equality.
Connection-owned native ability snapshots and monotonically ordered local mode events.
Exact input bindings for a native game-type event, including holes in retained history.
Independent native posture flags, evaluated after the swimming trigger and before travel.
Completed local physics for one Java movement frame, admitted through the Java movement gates.
Read-only recipe sources follow the presentation lifetime, independently of item-request authority.
One backend's recipe query, selected output and collections, independent of screen presentation.
PlaySound positions are signed fixed-point coordinates in eighths of a block.
Native recipe buckets, contiguous groups and retained header expansion.
Current evaluator results and native icon/count comparisons for an admitted view.
Native Recipe source matching after ordinary ingredient descriptors resolve.
Native recipe expressions use the tags query group, independently of Actor query bindings.
Exact Item-definition and auxiliary bucket used before full output-stack matching.
Connection-owned recipe result construction after wire bounds and count conversion.
Native inputs paired with their next translated Java position or rotation packet.
Connection-scoped FIFO pairing; an unmatched packet cannot reuse an old mode.
Chunk assembly is owned by the event loop; a completed buffer is read only by its decoder.
Bounded background work that never falls back to the connection's event loop.
Compresses large archives in parallel while preserving entry order and bounded working storage.
Entry bytes remain owned by the caller and must not change during the write.
Runtime slots retain their state objects even when several slots serialize equally.
Saved-NBT loading and the distinct ItemInstance and ItemStack constructor tails.
A deliberately limited subset of objective-dependent JSON UI image controls.
Form response identities and presentation over the shared JSON UI program.
One bounded upload and native confirmation per connection, confined to its channel event loop.
Retains the native SneakingComponent between input calculation and posture application.
Native caption admission, direction, localized duplicate refresh, and elapsed-time state.
Native float listener admission shared by server requests and local sound emitters.
Ordered server audio commands for a client with native playback support.
Pack-ordered caption translations with English fallback and case-independent locale codes.
Packet 118 uses an actor offset unless its unique ID is the world-space sentinel.
A read-through view of the root pack with one selected subpack overlaid on top.
Native SwiftSneakEnchantComponent retains its initial level until unequipped or replaced by an unenchanted item.
Native UI colors and server formatting overrides from effective pack globals.
Controller data and semantic control annotations for one JSON UI resolution.
Bounded JSON UI binding expressions.
Live children of one native UI factory.
Shared bounds for converted pack textures and their decoded client images.
The authoritative underwater attribute, which has no equivalent Java attribute.
Retains target-native visuals where the mapped Java block has changed its appearance.
Completed motion of the controlling local vehicle, paired with a player frame.
Connection-owned mount identity for optional completed vehicle physics.
Optional mount physics; neither its watermark nor the player clock resets on correction.
Session-scoped culling grids sent before StartGame.
Native 1.26.51 water acceleration and damping, including confirmed dolphin boosts.
Bounded RIFF/WAVE decoding to interleaved signed little-endian 16-bit PCM.
Buffers ordered world packets while Java loads resources or initializes its play listener.