Safewalk holds sneak (setShiftKeyDown) whenever the block under any step
direction is missing, so the client's own maybeBackOffFromEdge keeps you on the
block — and since player position is client-authoritative, the server accepts
it. Forced only at an actual edge and released after, so it never fights a real
sneak. Pairs with Scaffold for bridging.

Timer scales the game clock. advanceGameTime divides elapsed real time by the
timer's msPerTick to decide how many ticks to run; writing a smaller value runs
the whole client — movement, mining, eating, and the packets they emit —
proportionally faster, and the server processes them as they arrive. Multiplier
slider 0.5x-5x, restored to 1x on toggle-off. The server's move-frequency check
clamps the movement half past a few x, so it is kept modest.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

NoFall was zeroing our own fallDistance, which the server never reads. It now
sends ServerboundMovePlayerPacket.StatusOnly(onGround=true) once a tick while
airborne and descending (and not flying, which takes no fall damage anyway) —
the server runs its fall check against the onGround flag we send, so reporting
grounded resets its accumulation and no damage lands. Server-effective, unlike
the old client-only zeroing, which is kept only for the local landing animation.

Auto Build is now labelled Scaffold; the config key stays autobuild so saved
configs keep working.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The menu frees the cursor with a raw glfwSetInputMode, which the game's
MouseHandler never sees — so the motion made while the cursor was free sat in
its accumulator and got applied to the camera in one jump on the next grab.
Closing (and opening) the menu now zeroes MouseHandler.accumulatedDX/DY and
calls setIgnoreFirstMove — the same reset the game performs when it grabs the
mouse itself — so the leftover delta is discarded instead of snapping the view.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

The cooldown research confirmed the server (ServerGamePacketListenerImpl) has
only three rate limiters — item-drop, chat, command — and none on use, place,
interact, attack, or break. So three client fields throttle the player with no
server rule behind them:

  Minecraft.rightClickDelay  (4t) — every right-click: place, throw a pearl or
                                    potion, start eating, draw a bow, raise a
                                    shield. The universal use cap.
  MultiPlayerGameMode.destroyDelay (5t) — creative and post-break mining.
  Minecraft.missTime         (10t) — missed swings.

No Cooldown clears all three each frame, so by the next input tick the gate is
open — lifting the cap to one action per tick, the input loop's own ceiling.

Attack-strength cooldown was correctly left alone: the server recomputes damage
scaling from its own ticker, so spamming attacks only loses the crit/sweep
bonus rather than gaining rate. Use-item *duration* (eat/drink/draw time) is
likewise server-counted and untouched.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Backtrack: a second injected netty handler (lodestone/Backtrack) spliced before
packet_handler that holds the current target's movement packets for a bounded
delay and re-fires them on the same event loop. The server rewinds the target
to where your latency says you last saw it when validating a hit, so hitting the
delayed position still lands as long as the delay stays inside that rewind
window. Only the target's movement is held; everything else passes instantly.
Entity id per packet is resolved reflectively once per class and cached.

Bow aimbot: solves the launch angle by simulating the arrow — power*3 initial
speed, 0.05 gravity, 0.99 drag per tick — and leads the target by its own
velocity, converging flight time and lead together. Aims only; the release is
still yours.

Sprint reset: stops and restarts sprint around an aura swing so the hit lands on
a sprint (re)start and takes the knockback bonus. Off when criticals is on,
since a crit needs no sprint.

Hitbox: expands the target box outward by a configurable margin for selection
and aim, within the reach tolerance the server already allows.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Criticals, and any move the server has to see to credit, only worked on the
tick's own position send — and not at all while Blink held those sends back.
World.flush_position builds a ServerboundMovePlayerPacket.PosRot and sends it
through the client's own ClientPacketListener.send, then updates xLast/yLast/
zLast so the client agrees a packet went out. Criticals now flushes the
leaving-ground position on the hop, so the server registers off-ground-and-
descending at the moment it matters regardless of Blink.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Rather than reimplementing the crit condition, Criticals now calls
Player.canCriticalAttack. It is private, so it needs a non-virtual invoke, but
it is the same method on the same class the server evaluates — so a yes here is
a yes there, provided the movement behind it has been sent. The swing is held
until the game says yes.

Getting to yes no longer needs a jump. The predicate only wants you off the
ground and descending; a vanilla jump is 0.42 and rises over a block, where a
nudge of about 0.1 clears the ground and is falling two ticks later. Visible to
the server in the position stream, barely visible to anyone watching. The size
is a slider down to 0.05.

Sprinting disqualifies a critical, so it is dropped before the hop rather than
at the swing, and Auto Sprint is held off while a hop is in flight instead of
switching sprint straight back on and cancelling the hit it was waiting for.

Server Ghost draws where the server still thinks you are, read from the last
position the client actually sent. Normally it tracks within a tick; under lag,
Blink or Freecam it is somewhere else entirely, and the gap it shows is exactly
what a server undoes when it disagrees. Turns red past a metre.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Reading Player.canCriticalAttack settled two things. The condition is
fallDistance > 0 and not on ground, climbing, in water, mobility-restricted, a
passenger — or sprinting. It is evaluated on ServerPlayer, from the state the
server built out of your movement packets, and ServerboundAttackPacket carries
nothing but an entity id. So a critical cannot be asserted, only earned: the
jump has to be visible in the position stream.

That last clause also meant Auto Sprint was silently cancelling every critical,
since sprinting disqualifies the hit. Criticals now drops sprint for the swing.

Three ESP additions from data the server already sends. Show Invisible marks
entities the client is told about but does not draw. Show Ping reads the
latency out of the tab-list entry the server maintains anyway. Threat Range
asks each player's own synced interaction-range attribute whether it already
covers you, rather than assuming vanilla's three blocks — so somebody with
extra reach reads as dangerous before they are in it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Gizmos. The game ships a public 3D debug-drawing API — Gizmos.cuboid, .line,
.billboardTextOverMob — collected by LevelExtractor and drawn by the game's own
renderer. Drawing through it means real depth, real interpolation, and
setAlwaysOnTop() gives see-through-walls for free rather than by projecting to
2D by hand. The static helpers post to a thread-local collector the game only
installs while extracting, so we install the extractor's own collector around
our draw and put it back afterwards. Gizmos are drained once a frame, so ours
persist briefly to survive until the next drain.

Fast Chunks. getDesiredChunksPerTick is literally 7_000_000 divided by the
client's own measurement of how long a chunk took to process, and the server
throttles chunk delivery to whatever that comes out as. Writing that one double
changes the answer without touching the packet. The handler has no permission
check.

Player Radar. The locator bar's data is a Map<UUID, TrackedWaypoint> the server
fills in for players you cannot see — exact block positions where the server
sends that tier, chunk positions where it sends the coarser one. Read straight
out of ClientWaypointManager.

Every signature here came from javap over the real 26.2 jar rather than from
memory, including the parts that would have been guessed wrong: the gizmo
collector's thread-local lifetime, and that the chunk rate is a measurement
rather than a setting.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Auto build was queued behind the shared placement delay and would only place
into open air if Air Place happened to be on as well. Both were wrong for what
it is: a scaffold that waits is a scaffold you fall through, and there is
nothing to build against underneath someone who is falling, which is the entire
situation it exists for. It now runs ahead of the delay and always places
unsupported.

Auto totem had a health threshold, which is the wrong trigger in both
directions — it either holds the offhand hostage for nothing, or arrives after
the hit that mattered. What decides it is damage landing, so it now fires on
any drop in health (or a rise in hurt time), checked every frame rather than
every tick so it is as early as the client can manage. That also covers the
case the threshold handled worst: the moment a totem pops and leaves the hand
empty, the next one goes straight in.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

World: Air Place puts a block where you are looking with nothing under it, and
Auto Build puts one under your feet when there is nothing there and you are on
the way down. Both go through useItemOn with a BlockHitResult built the way a
real click would have produced one, so the packet, cooldown and swing are the
game's own. A neighbouring face is preferred and only genuinely unsupported
placement falls back to clicking empty air, since that is the part a server can
refuse.

Auto Totem moves a totem to the offhand below a health threshold, through the
container path (26.2 renamed ClickType to ContainerInput) so the server sees an
ordinary inventory action. Auto Shield raises on the tick a hit lands rather
than predicting the swing: a shield that comes up before the attacker moves is
a tell, one that comes up on the hit is just fast.

No Hurt Camera was clearing hurtTime after the frame that had already drawn the
lurch, so every hit still showed one. It now zeroes damageTiltStrength, the
option the renderer consults while drawing, so there is nothing to see at all.

The aimbot was a lerp, which is fastest the instant it acquires and then crawls
— the opposite of how a hand moves, and the reason it read as a bot. It is now
a critically damped spring with a capped turn rate, so a turn accelerates,
carries and settles, and no acquisition is ever instant. A little noise on the
aim point keeps it from sitting perfectly still on a moving target.

Also: watermark off by default, and the unload watchdog no longer gives up
after one sighting of the marker — if the marker appeared while the game was
not drawing, the request went unheard and the copy was stranded for good.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Two separate bugs, neither of them the row sizes I had been adjusting.

The windows were stuck short because of fixed_size([width, 0.0]): that pins both
dimensions, and a height of zero leaves egui to clamp it to a minimum. Width is
fixed now and height is free, so a window grows to its content, and the scroll
cap comes from the screen height minus where the window sits rather than a pixel
count chosen in advance.

Scaling was blurry because the menu was laid out at 1x and the scale handed to
the painter, so egui rasterised the font atlas at 1x and the painter magnified
those bitmaps. The density is set on the context before layout now, which makes
the glyphs render at the size they are drawn. The scale steps in quarters, since
a pixel face is sharpest on whole numbers.

Sizes up throughout as well, and every font size is a whole number: a pixel face
asked for 10.5 lands its edges between pixels and the rasteriser smears them.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The menu was styled like a modern app: rounded panels, a pastel accent, soft
padding, and a paragraph of explanation under every module. Rebuilt in the idiom
these clients have used for fifteen years — Minecraft's own chat palette, hard
square borders, 15px rows, no switch graphics (an enabled module is simply lit),
values written across the slider they belong to, and no prose at all. Every
string is drawn twice, offset, the way the game draws its own text: the absence
of that shadow is the clearest sign of something bolted on from outside.

Binding moved to right-click on a module, which is where it belongs and frees
the row of its chip.

Made it shippable while I was in there. Everything the client reads or writes
now lives beside the DLL rather than at a hardcoded C:\lodestone, the font is
embedded with a file beside the DLL still taking precedence, and the loader
carries the client inside it: build.rs embeds the DLL, and the loader writes it
out under a fresh name before injecting. An explicit path argument still wins,
so the dev loop is unchanged.

The earlier conclusion that embedding the font broke loading was wrong — that
was the shell quoting bug in deploy.sh, and the test that seemed to confirm it
was marshalling ANSI into LoadLibraryW.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

No Java crash report, no JVM fatal log, no Windows fault event — and the game
log shows a public server rather than a single-player world. That pattern is a
hang, not a crash, and the cause is that the scans were written for a quiet
world.

A single-player world holds a handful of entities and a few chests. A public
server near spawn holds thousands of each, and every one costs several JNI
calls per frame — entity ESP even reads a name string per entity per frame. The
base scan was the worst of it: it walked every block entity in 289 chunks once
a second, which near a chest room is a multi-hundred-millisecond stall on the
render thread, every second.

So everything now has a ceiling: entity targets are capped and sorted nearest
first so the cap keeps what matters; block entities cap both what is kept and
what is examined, because looking for shulkers on a server that has none
otherwise walks the lot; the drawing caps boxes independently; and the ore sweep
budget is halved, since each position is a Java allocation and three calls.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Every recent crash report was the same one — Sodium's UniformBufferManager
throwing "Overflowed the mesh time buffer" from setupTerrain — and it was
Extend View's doing.

Asking for a wider view is three things in principle: set the option, raise the
client's copy of the server-announced distance, and resize the chunk store.
Doing the last two by hand is what broke it. A renderer sizes its buffers from
the view distance it was told about, so quietly growing the world behind it
leaves more chunk sections in existence than those buffers can index.

None of it was necessary. Setting the option and sending the settings packet is
the entire request; the server answers with a chunk-cache-radius packet and the
game's own handler resizes the store and notifies the renderer properly. So the
module now only asks, and is clamped to 32 — past vanilla's own maximum the
renderer is outside the range it was built for.

Two more hardening fixes found while reading that path: getChunk is typed
ChunkAccess, so calling a LevelChunk method id on the result is undefined
behaviour rather than an exception unless it is checked first; and block ESP now
caps how many boxes it will draw, since picking coal at a wide radius finds tens
of thousands and each is eight projected corners.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Auto Dodge treats the two threats differently, because they are different
problems. An arrow is already in flight on a known path, so the answer is
geometry: solve for the time of closest approach, and if it passes within about
a player's width, step across the path on the side you are already drifting
towards — sooner means a smaller step, so urgency scales the commitment. A
hostile mob follows you instead, so the answer is distance, weighted by inverse
square so the one breathing on you outweighs the one across the room.

Both produce a direction to want. The last step is the one a naive "run away"
skips: try that heading, then progressively wider deviations either side, and
take the first that is actually walkable — head clear, and something to land on
rather than a ledge. blocksMotion is the game's own passability test, so tall
grass reads as passable and a fence does not. A one-block step is a hop rather
than a stall.

Freecam now hides the HUD. 26.2 moved it out of Gui into its own Hud class, so
the flag F1 sets is Hud.isHidden; the old Options.hideGui is gone, which is the
same restructuring that moved Minecraft.screen onto Gui.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

A server sends chunks out to the smaller of its own view distance and the one
the client asked for in its settings packet, so asking for more is not a trick —
it is the documented way to get more, and it works wherever the server's limit
sits above what the client was requesting.

Three parts, because any one alone does nothing: set the render-distance
option, raise the client's copy of the server-announced distance (which
otherwise caps the effective distance locally), and call broadcastOptions so
the request actually goes out. The chunk store is widened to match via
ClientChunkCache.updateViewRadius, so chunks that do arrive are kept instead of
dropped the moment you move away.

The request is only sent when the number changes; one settings packet per frame
would be a flood. Loaded chunk count is shown next to the slider so the effect
is visible rather than assumed.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The spin was not the rotation bookkeeping at all. LivingEntity.getViewYRot does
not read yRot: it interpolates yHeadRotO to yHeadRot. The camera entity had
yRot and yRotO set and its head angles left untouched, so every frame the view
lerped between a stale head rotation and the current one by whatever the
partial tick happened to be. The camera now has yHeadRot, yHeadRotO, yBodyRot
and yBodyRotO written alongside yRot, and holds still.

Minecraft.smartCull turns off occlusion culling, so chunk sections the renderer
believes are hidden are drawn anyway — which is what makes a cave visible from
inside the rock instead of a black wall. Exposed as No Culling under Visuals,
with the honest caveat that it cannot show chunks the server never sent.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Trigger Bot attacked whatever the crosshair touched, with no filter. Vanilla's
handleInteract does not merely ignore an attack on a dropped item, an
experience orb or yourself — it disconnects the client for it. Both attack
paths now require the target to be a LivingEntity other than you, which is
exactly the set the server accepts.

Freecam span because it tried to hold the body's rotation still: it reset the
player's yaw each frame and accumulated the mouse delta into the camera, so any
frame where the reset did not stick re-applied the same delta forever. It also
cleared ClientInput every frame, which raced the tick that fills it, so the key
reads came back empty and the camera would not move.

Both go away by not fighting the game for the controls. The mouse turns the
player as usual and the camera simply follows the view; the body is held still
by pinning its position, velocity and fall distance every frame instead, with
position and rotation packets both suppressed so none of it is sent.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The old freecam moved your body with collision off and suppressed the position
packets, which is a ghost, not spectator. This detaches the view instead.

Minecraft.setCameraEntity points the camera at an ArmorStand constructed with
NewObject and never added to the level: nothing ticks it, nothing renders it,
nothing about it is sent anywhere. The player is not touched at all, so the body
stands where it was doing exactly what the server expects of someone standing
still — there is nothing for it to disagree with and nothing to pull back.

The mouse still turns the player, so each frame the turn it applied is taken
back off the body and added to the camera instead. WASD/space/shift are read
out of ClientInput.keyPresses and then cleared to Input.EMPTY so the legs do not
walk while the camera flies. Previous-tick and render-previous positions move
with the camera so the view does not smear, and the ESP overlay projects from
the detached camera, so it keeps working while you are out there.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The rubber-banding was not bad luck, it was three specific vanilla checks:

- A server counts ticks where your vertical delta is >= -0.03125 while you are
  not allowed to fly, and disconnects at eighty of them. Flight now dips below
  that threshold on a timer, which puts the counter back to zero, so the kick
  never arrives.
- handleMovePlayer re-simulates the move you claim, with collision, and pulls
  you back when the result differs. Teleport steps that pass through a block do
  exactly that, so steps are capped and a "stay within server limits" switch
  holds velocity and step size to what is accepted.
- Nothing at all is checked if nothing is sent. LocalPlayer.sendPosition only
  builds a packet when the position differs from xLast/yLast/zLast or
  positionReminder reaches 20, so writing the current position into those every
  frame suppresses movement packets entirely. Freecam is now genuinely free
  rather than a fight with the server, and Blink falls out of the same trick.

Added Bhop, which is just vanilla's own sprint-jump bonus and therefore nothing
for a server to disagree with.

X-Ray takes a block selection: thirteen groups, each with its own colour,
deepslate variants folded in.

Base finder reads block entities out of the loaded chunks instead of sweeping
blocks — shulker boxes, ender chests, beacons, brewing stands, enchanting
tables — covering the whole loaded area in one pass, with a coordinate list.
Container ESP moved onto the same mechanism and is much faster for it.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Kill aura was a nearest-target loop on a timer, which in modern Minecraft
lands twenty hits for a fraction of the damage of one. It now waits on the
attack-cooldown bar (Player.getAttackStrengthScale), picks targets by
nearest/weakest/smallest-turn, asks the game whether it can actually see the
target (hasLineOfSight) instead of ignoring the through-walls switch, and
rotates for the swing.

Criticals were backwards: the hop was applied with the swing, so every hit
landed while rising and none of them were critical. It now hops, holds the
swing, and lands it on the way down.

Frame-rate dependence fixed throughout: physics runs per tick, so velocity
modules act on a tick boundary (Entity.tickCount) and velocity speed sets an
absolute speed instead of scaling each frame, which compounded into a
slingshot. Aimbot smoothing is time-based, so the turn takes the same time at
30 fps as at 300.

ESP finished: X-Ray and container highlighting. Blocks have no list to walk, so
the volume is swept a slice per frame with a fixed budget and the completed
pass swapped in; block identity is System.identityHashCode on the singleton
Block, one int compare rather than a chain of reference tests.

Also: auto respawn.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

The project gains a second half. The external explorer stays (and is how every
name below was verified against the running game), but the cheat menu now runs
inside Minecraft:

- inject a DLL, hook glfwSwapBuffers, draw egui in the game's own GL context
- drive the game through JNI rather than raw memory, so writes go through the
  GC's barriers and methods can be called directly
- five draggable windows: Combat, Movement, ESP, Visuals, Misc
- client-side only: nothing depends on owning the server

Modules wired to the game: fly (vanilla/smooth/glide/teleport), speed
(abilities/velocity), no-fall, jetpack, auto-sprint, noclip, step, high jump,
jesus, spider, freecam; kill aura, aimbot (camera/silent, smoothed), trigger
bot, reach, auto clicker with jitter, anti-knockback, criticals; entity ESP with
boxes, tracers, nametags and health bars; fullbright, custom FOV, no hurt
camera, no weather, no view bob; hide-from-capture.

Per-module keybinds, a panic key, and settings saved to disk.

GL state the game leaves behind has to be neutralised before drawing and put
back after: a sampler object on unit 0 renders everything black, and a stale
GL_UNPACK_ROW_LENGTH scrambles the font atlas.

Unload unhooks and goes inert rather than unmapping the module, which crashed
the game while the window still pointed at our window procedure.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

Reads HotSpot's exported VMStructs table through ReadProcessMemory to resolve
Java classes, fields and objects in a running Minecraft, with no code loaded
into the game: no mod, no injected DLL, no JVMTI agent.

- win: OpenProcess + RPM/WPM, module enumeration, PE export parsing
- vm: VMStructs/VMTypes/constants parsed live out of jvm.dll
- jvm: ClassLoaderDataGraph walk, UNSIGNED5 fieldinfo stream decode (JDK 21+),
  vmSymbols for injected fields, mirrors for statics, strings, arrays, HashMaps
- game: Minecraft 26.2 layer (flight, speed, noclip, no-fall, god, instabuild,
  teleport, world clock), gated on single player, primitives only
- egui menu + CLI explorer

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>