The overlay moved from egui to Dear ImGui, rendered straight into the game's
OpenGL context. Two GL traps shaped it: a sampler left bound on unit 0 turns
the menu flat black, and a non-zero GL_UNPACK_ROW_LENGTH garbles the font
atlas — which is uploaded while the renderer is constructed, so the state is
neutralised around construction as well as around each draw. The C++ half of
ImGui is linked statically (.cargo/config.toml), because a DLL depending on
libstdc++-6.dll fails to inject with "a dependency is missing".

The menu is now the Enigma layout: one window with a navigation rail, content
and status panes, Poppins for the text. The accent is user-set (default
#B7CDD4), the open key is rebindable (default Insert), and UI scale is a real
scale — style sizes and every hand-drawn dimension — applied when the slider
is released. The ESP is fully configurable with a live preview drawn from the
player's own skin, sampled nearest-neighbour so it stays pixel-sharp.

Silent aim now works: the attack packet carries no rotation and the server
takes aim from the movement stream, so the aimed look is flushed as a PosRot
before the swing. Entities built on Player that are not in the tab list —
NPCs, holograms, clones — no longer count as players. New: Auto Crystal,
Auto Mace, and a Legit/Instant mode for Auto Totem. Scaffold places ahead of
the player instead of after arriving, and auto respawn is instant.

Linux: the client builds as a .so started from .init_array, input is chained
through GLFW callbacks, and the loader injects by LD_PRELOAD or ptrace. On
both platforms the loader embeds the client, waits for Minecraft with a
spinner, and injects once it appears. deploy.sh retries with a fresh DLL name
and unhooks off-thread when the game has never drawn a frame.

Co-Authored-By: Claude Opus 5 (1M context) <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>

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>

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>