1.0.3

Extend far render to a slider-tied bound past Voxy's 48k projection plane

Terrain and distant players were both clipped at fixed limits — Voxy's
hardcoded 48,000-block projection far plane cut off injected far columns,
and the managed-entity far plane was capped at 16,384, so a viewed player
would vanish while the ground under them kept drawing (or vice versa).

Lift both to a single shared, live-computed bound:

• Raise Voxy's far plane: an @ModifyConstant mixin on
  VoxyRenderSystem.computeProjectionMat swaps its 48,000 constant for the
  shared bound. Voxy is an optional client dependency and its classes are
  absent on a vanilla client / dedicated server, so the mixin lives in its
  own config (iseeyourchunks.voxy.mixins.json) gated by an
  IMixinConfigPlugin that only applies it when Voxy is loaded — matching
  the reflective-only pattern used everywhere else Voxy is touched. Nearly
  free on depth precision because computeProjectionMat is reverse-Z.

• Tie the bound to the slider: ClientEntityVisibility.farRenderPlaneBlocks()
  returns the visibility-distance slider clamped to a 48,000 floor (never
  below Voxy's own render sphere) and a 1,024,000 ceiling. Both the Voxy
  far plane and the managed-entity far plane read it, and both projections
  rebuild every frame, so moving the slider extends terrain and players
  together, immediately, with no reconnect. The entity ceiling is no longer
  a separate 16,384 constant. The 1,024,000 ceiling is a deliberate "more
  than enough" cap, not a technical limit — reverse-Z means it could go
  further at no real cost.

• Stop calling the slider max "Infinite": rendering reaches at most
  1,024,000 blocks, so the top stop now reads "Maximum (1,024,000 blocks)"
  and the README reflects the real limit.

1.0.2

Render distant players' terrain live on real Voxy geometry, far past its render sphere

Stream and draw the terrain around a viewed player thousands of blocks
away, updating live, well past Voxy's own render sphere — with real
lighting.

Four pieces make this work:

• Far-node injection (VoxyFarNodeInjector): Voxy only draws a camera-
  centred LOD sphere, so streamed columns beyond it never render. Instead
  of enlarging the sphere (cost grows with its area), inject just our
  streamed columns as extra top-level render roots via AsyncNodeManager,
  and lift the traversal shader's distance cull for them by forcing its
  sectionRenderDistance uniform past any streamable range. Occlusion and
  LOD are unchanged — same traverser and screen-space detail, more roots.
  Terrain then reaches Voxy's projection far plane (~48k blocks).

• Real-light ingest (VoxyIngestBridge): Voxy's tryAutoIngestChunk reads
  the client light engine, which never lights a chunk past render distance,
  so it silently wrote nothing and terrain showed only VSS's stale cache.
  Run Voxy's own convert -> mip -> insertUpdate pipeline directly, feeding
  the chunk packet's real block+sky light (captured by
  ClientPacketListenerMixin/FarChunkLightCapture), so torches, lava, and
  shadows are correct. Falls back to a heightmap sky approximation if a
  chunk ever arrives without light data.

• Deferred re-mesh (VoxyFarNodeInjector.tick): Voxy won't re-mesh a far
  node live on its own, so after the async node add settles, force it with
  WorldEngine.markDirty on a client tick.

• Dirty-tracked re-send (FarChunkStreamer, ChunkHolderMixin): the streamer
  sent each far chunk once. Mark a streamed chunk dirty on broadcast
  (scoped to chunks we actually stream — never vanilla's) and re-send the
  whole chunk on the update interval, so the client re-ingests and Voxy
  re-meshes it. Full re-send because a client can't apply incremental
  deltas to an out-of-range chunk it never cached.

1.0.1

Render distant players and mobs at unlimited range via a custom entity pass

Beyond the client chunk-storage radius (~816 blocks) vanilla culls entities
whose chunk has left the client cache, so a streamed distant player vanished
even though Voxy still drew its terrain. Add FarEntityRenderMixin: at the tail
of LevelRenderer.submitEntities, extract and submit managed entities past
render distance with camera-relative coordinates, bypassing that cull. Extend
the camera far clip plane (CameraMixin) so they aren't clipped. Tested to
17000 blocks.

1.0.0

I See Your Chunks

A Fabric mod that renders distant players standing on real terrain, far
past render distance, instead of floating in the void. The server streams
the already-resident chunks around each viewed player; the client accepts
them and hands them to Voxy, which draws them through its own far renderer.

Server:

• FarChunkStreamer: send-only streaming of already-loaded chunks around
  revealed players, chosen nearest-first up to a configurable count and
  capped at the server's render distance, plus a one-chunk neighbour halo
  so Voxy's neighbour-dependent mesher can build the visible edge.
• Entity tracking mixins lift vanilla's distance/chunk caps per viewer:
  always for players and their (nested) mount chains, and for loose mobs
  only while they stand on a chunk that actually renders for that viewer.
• ChunkHolder.broadcast forwarding keeps streamed far chunks live.
• VisibilityFilter: spectator/invisible/vanish (melius-vanish) exclusions.
  Client:
• Widens the ClientChunkCache storage radius to accept far chunks, and
  re-applies it on config change so slider edits take effect without a
  reload.
• Hands each arriving far chunk straight to Voxy's VoxelIngestService,
  since Voxy otherwise only ingests chunks on unload and streamed chunks
  never unload.
• Entity render overrides that respect the frustum; mounts of a shown
  player render with it regardless of the distant-mob toggle or terrain.

Networking: opt-in ClientHelloPayload handshake with a ServerAckPayload
reply carrying the server's render distance, so the client's terrain
slider and chunk storage track what the server can actually deliver.
Config + Mod Menu screen; en_us/fr_fr. Voxy required on clients (recommended,
enforced with a runtime warning); dedicated servers neither need nor load it.
Versioned single-source-set layout (26.2/src + 26.2/fabric). AGPL-3.0.