All Classes and Interfaces
Class
Description
Abstract base for library-provided
PanelElement implementations.THE keystone of THE ONE WINDOW: one kind-agnostic value that names ANY
addressable thing — a vanilla slot, a created slot, a panel element, or a panel
itself — so the engine can resolve every behavior by address without ever
asking what kind it is.
Builder for a modal acknowledge dialog.
Builder for an AlertDialog Panel.
Port (MK defines, MKC implements): the READ side of the server tier — AXIS-1 of
the cascade.
MKC's server-authoritative behavior store — the implementation of MK's two
server-tier ports (
ServerTierBridge write side, AuthoritativeDeclarations read/AXIS-1 side).Names ONE behavior the window can resolve — gating, visibility, a panel's
opacity, a reaction, and so on.
The library's built-in
BehaviorKeys.Drops all block-scoped M7 attachment contents at a given BlockEntity
position before the BE is destroyed.
An interactive button within a
Panel.A two-state boolean control rendered as a small square with a check-mark
indicator and an adjacent label.
A mouse click as seen by a
PanelElement: which button, plus the
modifier keys held at the moment the click was dispatched.The single client-side "live slot →
Address" mapping that every client
slot-observer shares — observed reactions (ObservedReactions) and slot
interaction signals (WindowSignals).Maps a live slot to its
Address; swapped for the kind-aware MKC one when present.The one client-side gate that folds the engine
VISIBILITY behavior into
the panel dispatch — the bridge between "set visibility through the window" and
"the renderer/input loop actually honors it."Build-time vertical layout helper.
Builder for a single column layout.
Builder for a modal confirm/cancel dialog.
Builder for a ConfirmDialog Panel.
The one owner of frame composition order on a container screen — what
MenuKit draws, and where in vanilla's frame it lands.
MKC's implementation of MK's
CreatedSlotResolver port — resolves a
CREATED_SLOT Address to its live in-menu slot (position is
read off that slot's own x/y, like a vanilla slot's).Port (MK defines, MKC implements): resolve a
CREATED_SLOT
Address to its live in-menu slot.A library-built stand-in for vanilla's package-private
CreativeModeInventoryScreen$SlotWrapper, used to carry a registered
MKCSlot into the creative non-inventory tabs so it draws
and routes there exactly as it does on the inventory tab (§0051 creative parity,
extended to all tabs).Phase 16h — utility for preserving OS cursor position across screen
transitions.
Consumer-implemented interface for M7's extension point.
A behavior declaration at ONE specificity level (per-slot, per-group, …).
Explicit deferral; the cascade falls through to the next level.
An explicit declared value; the cascade stops here.
A horizontal or vertical line separating content sections within a panel.
Single-selection dropdown control.
Multi-selection dropdown control.
Per-attachment death-drop policy for player-scoped slot content (death
handling, Phase 1).
A typed handle on a panel element (label, button, outline) — a created thing
that is NOT a slot.
In-memory storage that is not persisted.
The general reactive flow-wrap primitive — a
PanelElement that holds a
run of child elements and FLOWS the visible ones left-to-right into the panel's
available content width, WRAPPING to new rows that grow downward when the run
exceeds that width.The context a
SlotGate decision runs in — who/what is acting, plus the
library-owned non-modded capability query.§0052 floor refinement — detects whether any known grave-container mod
is installed (a mod that holds a dead player's items in a persistent grave,
chest, or bag).
A bulk-addressing group: a stable id plus a membership predicate over
Addresses.Ordered registry of handler recognizers.
A recognizer inspects a handler and returns its slot groups, or null
if it doesn't apply to this handler type.
Named regions for positioning HUD panels against the game window.
A sprite rendered at a fixed position and explicit size.
A persistent info box rendered at a declared panel position.
An item icon rendered at a fixed position with optional count overlay
and durability bar.
A
Storage that knows its own persistent identity.Factories for
KeyedStorage — a Storage that declares its
own PersistentContainerKey so M1 per-slot metadata persists for
registered slots (§0045).What KIND of addressable thing an
Address names — the one place THE
ONE WINDOW distinguishes a slot from an element from a panel.Movement ③ — the custom-screen layout resolver.
The mending primitive's consumer candidate hook — lets a consumer
contribute EXTRA items into MKC's unified XP-repair pool, beyond the registered
slots opted in by Address via the engine
MKCBehaviorKeys.MENDING key.One mendable item plus how to persist its repair.
Supplies a player's extra mend candidates when an XP orb is collected.
Library-owned registry of vanilla-menu-chrome extents — the pixel
amounts each
AbstractContainerScreen subclass draws outside
its declared imageWidth × imageHeight frame.Per-side chrome extents outside the declared menu frame.
Computes chrome extents for a live screen instance.
Named regions for positioning decoration panels inside vanilla menu screens.
Mod entry point for MenuKit and the process-wide facade for HUD panels,
notifications, and the recipe-book query.
Mod entry point for the
menukit-containers artifact —
"MenuKit: Containers."MKC's server-tier
BehaviorKeys — the behaviors whose value types are
MKC types (so the constant lives here, not in MK's BehaviorKeys).Client-side entry point for the MenuKit: Containers artifact.
The one-call, no-mixin registration for a panel whose slots have container
parity — they appear, click, and sync on every screen that shows
the player inventory (survival, creative, and every chest/furnace/modded
container), default-on, opt-out per screen.
Fluent configuration; terminates in
register().Client-side partner to
MKCScreenHandler.A custom drag behavior for MenuKit slots.
Action triggered by a key press while this screen is open.
Listener for events happening within a MenuKit screen.
Shared helper used by the
MKHasClickedOutside*Mixin family to detect
whether a click lands on any active slot's bounds.Client-side entry point for MenuKit.
The turnkey custom-menu primitive — one
define(...).register() chain
replaces the ~4 plumbing pieces a consumer used to hand-write for every custom
MKCScreenHandler menu (its own MenuType registration, its own
open C2S payload + receiver, its own MenuScreens.register, its own open
call).Fluent configuration; terminates in
register().Builds the menu's
MKCScreenHandler, handed the menu's own
MenuType so the consumer never reaches back to the static handle
the define(...).register() chain is still mid-assigning.Builds the client
MKCHandledScreen for a registered MKCMenu.The structural heart of MenuKit.
A vanilla
Slot to the outside world.Resolves a slot in a screen's
menu.slots to the MKCSlot it
represents — directly, or through the creative SlotWrapper that wraps
it.Internal client-side input resolver for panel-hosted registered slots — the
hover/click half of the panel-unified
SlotElement path, and the
slot-context enforcement of §0046 (a panel makes what it covers inert, in every
context).Resolution of a screen point against the revealed registered panels on a
screen.
Projects
InventoryMenu-bound slots onto foreign menus — chests,
furnaces, donkeys, any AbstractContainerMenu — so a registered slot a
consumer registered for the player inventory also appears, clicks, and
syncs on a container screen.Builds (appends) a slot onto a matching foreign menu.
Library-owned shift-click (quick-move) routing for registered slots on a
foreign menu — a chest/furnace/donkey menu MenuKit didn't build, that a
slot has been projected onto (
MKCSlotProjection).Slots real, server-synced, persistent slots onto a vanilla menu — the
library half of the §0045 "consumer-composed slot" pattern (IP Pockets,
IP Equipment Slots).
Fluent configuration for a single slot.
MenuKit-Containers' implementation of MenuKit's neutral
SlotScreenHook —
the one place panel-hosted registered-slot input resolution plugs into
MenuKit's library-owned screen dispatch (§0042).MKC's §0050-backed implementation of MK's
VanillaSlotIdentity port —
the menu-independent identity of a vanilla slot.MK-managed focus registration + screen-level focus utilities.
Screen-edge anchor positions for HUD panels.
HUD sprite icon element — renders a texture sprite at configurable size.
HUD notification element — a timed popup that slides in, displays for
a duration, then fades out.
Direction the notification slides in from.
Builder entry point for HUD panels — visual elements rendered on the
game's heads-up display.
Builder for customizing progress bar elements.
Builder for customizing item display elements.
Builder for customizing HUD slot elements.
Builder for customizing text elements.
Immutable definition of a HUD panel — created at mod init, stored in
MenuKit's registry, rendered each frame by the HUD dispatch.
Callback for custom rendering on a HUD panel.
HUD element that renders an item inside a hotbar-style slot background.
ACCEPTED aesthetic-only exception to §0019 (see
MKVanillaButtonPressedMixin class javadoc for the
full carve-out rationale).MenuKit-owned
RenderPipelines for GUI rendering.Base class for standalone screens built with MenuKit — full-screen,
client-local, interactive UIs that are not tied to a container menu.
Public entry point for M1 per-slot persistent state.
Shared text-rendering helper for MK widgets that render single-line
text inside a bounded width.
The single library entry point for queuing a hover-float tooltip — the one
place a
Component tooltip becomes pixels on screen.The client-observed half of the reactive verbs (the part the architecture says
"ships working now") — a client-side detector that fires
ON_INSERT_OBSERVED
/ ON_TAKE_OBSERVED when a slot's synced contents change.The owner an
Address is resolved relative to — the chain that lets a
handle re-bind to the live backing each call (and that makes the held-handle
"wrong/no screen" case a clean no-op: an owner that doesn't resolve against the
live session yields the neutral default).A thing owned by another addressable, identified by the parent's token.
Chain root: a menu family namespaced by a scope.
Namespaces an owner-coordinate when a bare
(family, index) would alias
— the disambiguation tool inside a RootOwner.The default scope — no namespacing needed (the common case).
Composite per-backing scope (server-derivable from §0050).
Active-creative-tab scope (CLIENT-tier only).
The fundamental unit of composition.
Fluent builder for
Panel.Mints the
Address of a panel and a panel element — the panel-subtree
half of THE ONE WINDOW's addressing, the counterpart to VanillaAddressing
(vanilla slots) and the MKC created-slot adapter (created slots).Computed screen-relative bounds for a
Panel after layout
resolution.Phase 16j R2 — shared element-iteration primitive across the four
rendering contexts (MK standalone screens, MKC container screens,
HUD overlays, vanilla-screen injection adapters).
A visual or interactive element within a
Panel.A typed handle on a panel itself — its own visibility, opacity, and inertness.
Pure layout utility.
Minimal interface for the owner of a
Panel tree.Describes how a panel is positioned within a screen's layout.
How a panel is positioned.
Static rendering utilities for
PanelStyle backgrounds and
slot backgrounds.Visual style for a panel's background rendering.
Phase 16j R1 — shared layout primitive across the standalone-screen
(MK) and container-screen (MKC) rendering contexts.
The side-neutral registry of container-parity slot recipes — the single
source of truth both menu-build seams read so a registered slot appears on
every menu the player opens, identically on both sides.
Persistent identity for a
Container — the owner a slot's state
attaches to, in a form that survives session boundaries.Block-entity-backed container (chest, shulker box, furnace, hopper, etc.).
The player's ender chest (distinct from their main inventory).
Entity-backed container (donkey, llama, mule, minecart-with-chest, etc.).
Modded container type.
The player's main inventory, hotbar, armor, and offhand slots.
Drops (or keeps / destroys) all death-droppable player-scoped attachment
contents when a player dies — the player-death twin of
BlockScopedDropHandler.§0052 Phase 2 — the grave-capture surface.
One captured slot: stable identity (the attachment's registered
Identifier + the local slot index) plus the stack.Marker interface for
Storage implementations that represent the
player inventory side of a menu, as opposed to the container side.A filled bar indicating progress on a 0-to-1 scale.
Fill direction for the progress bar.
Declares how a
SlotGroup participates in shift-click routing.A single-selection control.
Coordinator for a set of
Radio elements that share single-selection
state.Why a reaction fired — an open, identity-tagged descriptor, deliberately
not a sealed enum a consumer must
switch over (architecture
Part 2 §6).What a
ReactiveHook receives when a slot's contents change.The frozen re-entrancy bound of the reactive contract (architecture Part 3
§3.6 / #3b).
Port (MK defines, MKC implements): the firing side of server-authoritative
reactions.
MKC's implementation of the
ReactiveDispatch port — the server-thread
firing of authoritative reactions.A consumer's reaction to a slot's contents changing — the value type of the
ON_INSERT/ON_TAKE behavior keys (and their observed variants).Read-only
Storage adapter for observed (non-MenuKit) screens.A region plus an explicit stacking priority.
Single source of truth for the region-positioning layout constants —
stacking gaps and edge insets — shared across all four region contexts
(
MenuRegion, SlotGroupRegion, HudRegion,
ScreenRegion) and both pure math helpers
(RegionMath, SlotGroupRegionMath).Pure coordinate resolver for M5 regions.
Internal registry mapping M5 regions to their registered panels.
Render-time context passed to every
PanelElement.render(RenderContext).Build-time horizontal layout helper.
Builder for a single row layout.
Snapshot of a vanilla
AbstractContainerScreen's layout bounds for
one render or input-dispatch frame.Stable identity of a menu/screen family — the top of an
Address's owner chain (a RootOwner pairs one of these with an
OwnerScope).Which screens a registered-slot presence (or any screen-complete feature) applies
to — the consumer-facing expression of inventory-screen parity's
default-on, opt-out-per-screen rule.
Screen-space top-left coordinates of an injected panel.
Renders a
Panel inside a vanilla container screen and dispatches
input to it.Library-owned registry of MenuContext
ScreenPanelAdapters that
declare targeting via .on(...) or .onAny().A spot on the SCREEN edge — the nine-spot screen-edge vocabulary: the four
corners, the four edge midpoints, and the centre.
A clipped viewport hosting pre-positioned
PanelElements with
vertical scroll input.Builder for ScrollContainer.
The MK-side holder for the server tier's installed implementation (DIP
ownership-inversion: MK owns the ports, MKC conforms and registers here at
init).
Port (MK defines, MKC implements): the WRITE side of the server tier.
Continuous-value slider control.
The one MKC-side entry that mints the
Address of any live slot,
kind-dispatched — the server/enforcement counterpart of the client resolver.A registered MKC slot presented as a
PanelElement — the keystone of
the everything-is-a-panel model.The set of
SlotElements currently attached to an open screen — the
bridge that lets MenuKit's library-owned screen hook resolve hover/click for
panel-hosted slots.The reactive slot-wrapping primitive — the slot analogue of element/text
reactive sizing (Movement ④).
The value of the
GATING server-tier behavior — what a slot accepts and
releases.Where structure lives.
The bounding rectangle of a slot group in screen space.
Library-owned registry of per-menu-class
SlotGroupResolvers.Pure identity tag identifying a slot group for SlotGroupContext panel
targeting.
The uniform abstraction for slot groups.
Adapter that anchors a
Panel to a slot group's bounding box.Library-owned registry of SlotGroupContext
SlotGroupPanelAdapters
that declare targeting via .on(SlotGroupCategory...).Named regions for positioning decoration panels around the bounding box
of a slot group.
Pure coordinate resolver for SlotGroupContext regions.
Internal registry for SlotGroupContext panel registrations.
Per-menu-class strategy that maps an
AbstractContainerMenu instance
to its SlotGroupCategory-keyed slot groupings, expressed as
slot indices (positions in menu.slots).A typed handle on a slot (vanilla or created) — exposes the slot verbs whose
value type is an MK type, plus the generic substrate inherited from
WindowHandle.Neutral result of resolving a screen point against the revealed registered slots
on a screen — the value a
SlotScreenHook.resolveHover(AbstractContainerScreen, double, double) call returns to
MenuKit's getHoveredSlot mixin.Stable cross-menu identity for a slot: the pair of its backing
Container reference and its index within that container
(Slot.getContainerSlot()).The display-NAME layer for windowed slots — MK-owned, client-side, purely a
display concern (separate from identity; see
Address).The recessed 18×18 slot frame for registered slots that live outside a
vanilla container texture — the one piece of a created slot's presentation
that is panel chrome rather than the slot itself.
The one place a slot in a screen's
menu.slots is resolved to the real
vanilla Slot it represents — itself on most screens, or the slot a
creative SlotWrapper delegates to on the creative inventory tab.The §0042 firewall between MenuKit's registered-slot screen dispatch and
MenuKit-Containers' registered-slot work.
The neutral plug MenuKit exposes so panel-hosted registered slots can resolve
hover/click through a library-owned screen dispatch — without MenuKit ever
referencing a registered-slot type (§0042).
A vanilla slot's on-screen item box in absolute screen-space pixels — what
VanillaSlotResolver.resolve(AbstractContainerScreen, int) returns.A side-neutral, declarative description of one registered-slot group that a
MKCContainerPanel projects onto every container the player opens —
the "recipe" half of container parity.Typed per-slot state channel — the consumer-facing handle for reading and
writing slot state.
Channel visibility (§0049).
Resolves an
Address back to its live backing — the resolution
mechanics of THE ONE WINDOW (still no behavior; pure location).Where items live.
M7 — Storage Attachment Taxonomy.
The death-handling-capable specialization of
StorageAttachment, returned
only by player-anchored factories (StorageAttachment.playerAttached(String, String, int) and
StorageAttachment.customPlayerAttached(CustomAttachmentSpec)).Fabric attachment-type registry for M7.
Adapts a MenuKit
Storage to vanilla's Container interface.Single-line editable text field.
A non-interactive text label within a
Panel.Which authority tier a
BehaviorKey belongs to — the seam where THE ONE
WINDOW's client/server split lives.A two-state on/off control.
A deterministic declaration id (created slot / panel element).
A slot's vanilla menu-space index (vanilla and created slots alike).
A panel's registration key (the panel itself).
An explicit two-valued boolean for boolean
BehaviorKeys — the value a
Decl.Set carries, so "explicitly off" is a real declared value
distinct from "unset / inherit".§0052 Phase 2 — Universal Graves adapter.
Mints the
Address of a vanilla slot — the single place that decides a
vanilla slot's identity, shared by the client resolver (render/decorate) and
the server gating seam, so both agree.Phase 18s — sibling to
ScreenPanelAdapter that anchors MK
panels onto vanilla NON-container screens — the Options screen, Controls,
KeyBinds, world-select, server-list, anywhere Screen is the
superclass rather than AbstractContainerScreen.Phase 18s — sibling to
ScreenPanelRegistry for non-container
vanilla screens.Library-shipped
SlotGroupResolver registrations for every vanilla
26.2 AbstractContainerMenu whose slots map to named categories
in the M8 v1 coverage catalog.Port (MK defines, MKC implements via §0050): the menu-INDEPENDENT identity of a
vanilla slot — its container's stable identity plus the container-relative
index.
Resolves a player-inventory slot's on-screen position — slot-agnostic
and screen-agnostic.
The observed-screen equivalent of
SlotGroup.The escape hatch.
The value of the
VISIBILITY behavior — whether an addressable thing is
shown, as a client-side predicate rather than a static flag.The entry point to THE ONE WINDOW — how a consumer obtains a typed handle to set
or read behavior on anything addressable.
The resolution engine of THE ONE WINDOW — MK ring-0, pure policy, no Minecraft
I/O.
The base of THE ONE WINDOW's typed handle family — an immutable value addressing
one thing by its
Address, never by a held live reference (the menu and
every Slot are recreated each reopen, so a held reference would dangle).Derives the stable
ScreenFamilyKey and OwnerScope of a LIVE
menu — the client mint of an Address's root owner.The fire-entry for reactive verbs — the one place a contents change is turned
into a
ReactiveHook invocation, going through the same WindowEngine
cascade as every behavior and bounded by the same ReactionGuard.The client-observed slot INTERACTION signals — which slot the cursor is over
(
WindowSignals.hovered) and which slot was last clicked (WindowSignals.selected), as
Addresses.The per-session facade of THE ONE WINDOW — bound to the current concrete menu,
it mints typed
WindowHandles (architecture Part 2 §2).