Commit Graph
184 Commits
Author SHA1 Message Date
Algent 53e5901360 test: characterize multipart compatibility
Pin the Scala Function4 callback surface and MCPC fallback behavior before the Java port.
2026-08-30 15:29:59 +02:00
Algent 970e888b7f refactor: port client tile traits to java
Preserve the exact generated client interfaces, render-cache behavior, and ordered display ticks.

Teach Java mixin generation to linearize a registered parent and exclude transient runtime caches from copying.
2026-08-30 15:25:15 +02:00
Algent 6417e9b731 test: characterize client tile traits
Pin render-cache state, random display dispatch, and the generated TileMultipartClient inheritance before the Java port.
2026-08-30 14:06:13 +02:00
Algent 4e8d238b57 refactor: port inventory tile trait to java
Keep TIInventoryTile as AE2's public rebuild API and JInventoryTile as the registered mixin input, preserving both generated interfaces and flattened sided-slot behavior.
2026-08-30 13:56:05 +02:00
Algent 48cbb7ff3e test: characterize inventory tile trait
Pin flattened slot routing, sided access, AE2-style rebuild calls, and the generated TIInventoryTile/JInventoryTile interfaces before the Java port.
2026-08-30 13:50:31 +02:00
Algent bf8c9c24b8 refactor: port fluid handler trait to java
Preserve the exact generated interface and ordered fluid behavior.

Isolate FluidStack.amount access outside the transformed class. The transformer treats every field read as trait-owned state.
2026-08-30 13:33:05 +02:00
Algent cad4b1cef0 test: characterize fluid handler trait
Freeze ordered tank state and fluid distribution behavior.

Pin capability short-circuiting and the exact generated interface. All checks run against the untouched Scala trait.
2026-08-30 13:26:13 +02:00
Algent bef35139fb refactor: port tile change trait to java
The fourth generated tile written directly in Java, and the first with
both mutable state and inherited member access. The eight characterization
tests pass unchanged, and the runtime interface keeps the exact thirteen
methods. INeighborTileChange, the surface shipping jars link against, is
byte-identical between the reference and ported dev jars, and no consumer
references the removed $class or closure classes.

Two transformer constraints turned up, both now in the handoff gotchas.

registerJavaTrait rejects a trait with a non-empty InnerClasses attribute
outright, so the anonymous AbstractFunction1 for the operate callback
could not stay in the trait; it is a named class in the access shim.

The shim's parameters are Object rather than the trait type. Typing them
as the trait let javac elide the cast to TileMultipart, since the
untransformed trait extends it, and the verifier then rejected the
getfield once Forge rewrote the trait to an interface.
TRedstoneTileAccess only escapes this because IRedstoneTile is unrelated
to TileMultipart and forces a real checkcast.
2026-08-28 18:44:47 +03:00
Algent 003e8f94ca test: characterize tile change trait
Seven behavioral tests and a generated-interface freeze, both against the
untouched Scala trait. Nothing in the frozen consumer baseline references
TTileChangeTile or a $class helper for it, so there is no binary fixture
to take: the load-bearing surface is INeighborTileChange, which is already
Java and unchanged.

The behavior pinned is the flag lifecycle and the coordinate filter.
bindPart only ever ors the flag in, copyFrom takes it from another change
tile but leaves it alone for a plain source, clearParts resets it, and
partRemoved recomputes from the remaining list rather than from the part
handed to it. onNeighborTileChange dispatches only for an axial offset of
one or two blocks, and marks the two-block case weak.

The runtime interface is the exact thirteen methods: six overrides, the
field getter and setter, and five super accessors.
2026-08-28 18:35:22 +03:00
Algent bde3445488 test: characterize multipart raytrace index production
rayTraceAll was the one method the read-path cleanup restructured, moving
from an indexed loop over a copied list to an iterator with a manual
counter, and nothing covered it. The index it writes into ExtendedMOP.data
is what reduceMOP hands back to every click, activate, harvest and pick
block, so an off-by-one there would misroute interactions silently.

Six tests pin the index production: a part that misses still consumes its
index, sorting by distance happens after the indices are assigned, the
part's own data is nested underneath rather than replaced, subHit keeps
its default because data is assigned directly, and an index taken from a
hit still selects the part that produced it. harvestPart's indexing and
collisionRayTrace's nearest-or-null are covered alongside.

All six also pass against the pre-cleanup implementation at 370b353^,
which is the evidence that the restructure preserved behavior.
2026-08-28 18:31:33 +03:00
Algent 370b35328f perf: remove multipart read-path wrappers 2026-08-28 17:02:02 +03:00
Algent 85c2c4d15c test: characterize multipart read paths 2026-08-28 16:54:50 +03:00
Algent e2822d3938 refactor: port redstone tile trait to java 2026-08-28 16:16:31 +03:00
Algent eff7509585 test: characterize redstone tile trait 2026-08-28 15:58:57 +03:00
Algent 39e0858006 refactor: port slotted tile trait to java 2026-08-28 11:42:06 +03:00
Algent 7894c98352 test: characterize slotted tile trait 2026-08-28 11:36:38 +03:00
Algent 6c370c8734 refactor: port partial occlusion tile trait to java 2026-08-28 11:27:29 +03:00
Algent 2b04a2e52b test: characterize partial occlusion tile trait 2026-08-28 11:19:44 +03:00
Algent 984d3a2f61 refactor: port microblock recipes to java 2026-08-28 11:07:57 +03:00
Algent df21e4041c test: characterize microblock recipes 2026-08-28 10:59:04 +03:00
Algent 1cb2cc4cc6 refactor: port redstone interaction unit to java 2026-08-28 10:48:19 +03:00
Algent 28c90189a6 test: characterize redstone interaction unit 2026-08-27 23:15:56 +03:00
Algent 56b7a4791a perf: remove multipart traversal copies 2026-08-27 22:54:44 +03:00
Algent dffc65a894 test: characterize multipart traversal mutations 2026-08-27 22:49:00 +03:00
Algent 54d6df002e test: add focused performance baseline 2026-08-27 20:51:57 +03:00
Algent 2aa9928ad0 test: freeze generated trait and pass-through behavior 2026-08-27 20:25:38 +03:00
Algent 57b314dd4e test: freeze multipart NBT and description packets 2026-08-27 18:11:28 +03:00
Algent 6410cc0028 test: characterize multipart ordering and move lifecycle 2026-08-27 18:02:41 +03:00
Algent 4616b5834c test: guard source-only consumer reflection contracts 2026-08-27 14:11:53 +03:00
Algent 49ed6fd751 fix: restore Schematica registry reflection compatibility 2026-08-27 14:02:47 +03:00
Algent fa976c2002 refactor: port MultipartRenderer to Java
Kept in the TickScheduler$ shape: the companion holds the implementation
because Forge registers that instance itself, and the plain class holds static
forwarders. Both halves are load-bearing for different reasons -- guidenh
resolves renderWorldBlock as a static first and falls back to MODULE$ -- and
neither has a bytecode consumer, only reflective names.

The emitted class list is unchanged. All five rendering callbacks keep their
signatures, MODULE$ keeps its type and flags, and both classes keep class-level
@SideOnly(CLIENT). Only three Scala forwarders for inherited
TileEntitySpecialRenderer members and the companion clinit's ACC_PUBLIC differ.

The render id is still claimed in the singleton's initialiser, matching the
reference's first-access timing. The breaking-overlay branch moved to a private
helper that checks the erased Tuple2 and the boxed index before unboxing, which
is what the reference's pattern match compiled to.

125 plain-JVM tests and 22 Forge server tests pass, none changed by the port.
This class needs a client, so it adds nothing to either suite and everything to
the manual checklist.
2026-08-15 20:13:20 +02:00
Algent da472f1fd3 test: characterize MultipartRenderer
Everything this class does needs a client, so nothing here can run it. What is
pinned is the contract two other parties depend on and the ABI diff cannot see.

guidenh reflects on both MultipartRenderer and MultipartRenderer$ by name,
calling renderWorldBlock as a static first and falling back to the companion's
MODULE$, so both the static's exact signature and the singleton field are
pinned. Forge needs that singleton to be both a TileEntitySpecialRenderer and
an ISimpleBlockRenderingHandler or it rejects the registration. Both classes
carry class-level @SideOnly(CLIENT) and are stripped on a dedicated server.

Every lookup uses initialize = false: initialising the companion runs its
constructor, which claims a render id from Forge's RenderingRegistry.

125 plain-JVM tests, 22 Forge server tests.
2026-08-15 20:09:49 +02:00
Algent d224ce116d refactor: remove the package objects instead of porting them
A Scala package object compiles to a class literally named 'package', and that
is a Java keyword, so no Java source can declare or even name it. The
characterization had to reach both through Class.forName, which is the argument
in one line. There is no Java form to port to.

Each held exactly one member, a logger alias for its proxy, so the indirection
is inlined at its eight call sites: ConfigContent (7) and MultipartGenerator
(1). The functional characterization asserted beforehand that each alias
returned the very instance its proxy holds, so the substitution is an identity;
both classes are descriptor-identical afterwards.

Exactly four classes leave the jar and nothing else changes. No consumer
referenced them, and no Java consumer could have.

120 plain-JVM tests and 22 Forge server tests pass. PackageObjectCharacterization
went with its subject; ProxyLoggerFunctionalTest keeps the assertion worth
having, that both proxies publish a logger during preInit.
2026-08-15 20:04:55 +02:00
Algent d6bba7ff46 test: characterize the package objects
Each holds one member, a logger alias for its proxy's logger. Everything goes
through reflection because 'package' is a Java keyword and cannot appear as a
type name in Java source, which is also why these two classes have no Java
form at all.

The plain-JVM half pins the shape and that the alias reads the proxy's var
rather than holding anything, so it reports null before preInit. The Forge
server half pins the part that matters for what comes next: after preInit each
alias returns the very instance its proxy holds, adding nothing.

123 plain-JVM tests, 23 Forge server tests.
2026-08-15 20:02:42 +02:00
Algent a2797c986b refactor: port ControlKeyModifer and ControlKeyHandler to Java
isControlDown(EntityPlayer) and isClientPressing() keep their descriptors.
map() became a java.util.Map and isClientPressing_$eq became setClientPressing.

Dropped playerControlValue and ControlKeyValue. They existed only to give Scala
player.isControlDown sugar through an implicit conversion, and the reference
already shipped the explicit static 'for Java users'. MicroblockPlacement now
calls that static directly.

ControlKeyHandler was a Scala object extending KeyBinding, so the instance both
the key registry and the event bus needed was ControlKeyHandler$.MODULE$. It is
now an ordinary KeyBinding subclass with an INSTANCE constant, which also drops
the twelve static forwarders Scala generated for inherited KeyBinding members.

The misspelling in ControlKeyModifer is the published type name and is kept;
only the file name, which said ControlKeyModifier.scala, is corrected.

120 plain-JVM tests and 21 Forge server tests pass, none of them changed by the
port.
2026-08-15 19:45:53 +02:00
Algent 8f73a693cc test: characterize ControlKeyModifer
Plain-JVM coverage is structural: the Java-facing isControlDown(EntityPlayer)
static that the reference scaladoc calls out as existing for Java callers, and
the typo in the class name, which is the published name.

Forge server coverage for the behavior. isControlDown branches on whether the
player's world is remote, so it needs a real player; a Forge FakePlayer on a
dedicated server world takes the server branch and reads the map the client
keeps in sync through packet 1. Unknown players default to not holding, the map
reflects the last recorded value, and clearing resets it.

The client branch reads isClientPressing instead and no harness has a client.

120 plain-JVM tests, 21 Forge server tests.
2026-08-15 19:42:38 +02:00
Algent 40bb1b71b7 refactor: port PacketScheduler to Java
IScheduledPacketPart is descriptor-identical and schedulePacket is unchanged.
TScheduledPacketPart.read stays abstract: TMultiPart declares read, so a
default would be shadowed and a part would silently read a description instead
of a mask. The dispatch that lived in the $class helper is now the interface
static readMask, with the one-line forwarder documented on read.

writeScheduled and readScheduled became defaults. TMultiPart declares neither,
and empty bodies are what mixing the Scala trait in already gave a Scala
implementor -- only Java implementors ever had to write them out.

sendScheduled is public because the reference's private[multipart] reaches the
handler package and Java has no equivalent scope. An unsupported mask width now
throws IllegalArgumentException rather than scala.MatchError; both are
RuntimeException and the map is still left uncleared on that path, as before.

Dropped PacketScheduler$, TScheduledPacketPart$class and two closure classes,
none referenced in bytecode or by reflective name.

118 plain-JVM tests and 18 Forge server tests pass.
2026-08-15 17:04:41 +02:00
Algent 3ad25f56cb test: characterize PacketScheduler
Plain-JVM coverage is structural: the shapes of IScheduledPacketPart and
TScheduledPacketPart, and the fact that read must stay abstract. TMultiPart
declares read, so a superclass method would beat any default the interface
tried to supply, and a part that does not declare it resolves to TMultiPart's,
which reads a description rather than a mask.

Forge server coverage for the behavior, which needs a part bound to a tile in a
non-remote world and a real write stream: masks OR-ing into one write, the map
clearing after a send, a part that lost its tile being skipped, all four
documented mask widths being accepted, and an undocumented one being rejected
rather than silently writing nothing.

117 plain-JVM tests, 18 Forge server tests.
2026-08-15 17:01:18 +02:00
Algent 31ec83f91b refactor: port TileCache to Java
The first port free to change shape rather than preserve it: TileCache has zero
downstream references in bytecode and does not appear in guidenh's reflective
names. map() became a java.util.Map, add/remove became void, and apply returns
a nullable FlaggedTile instead of a scala.Option. No internal caller used any
of the discarded return values.

Dropped TileCache$, TileCache$FlaggedTile$ and FlaggedTile's case-class
machinery. It is only ever a map value, never compared, hashed, printed or
destructured.

findTile is unchanged, including the branch the reference obscures: its
trailing 'case _ => null' is unreachable because Some(FlaggedTile(t, rem))
matches whatever the flag holds, so a tile flagged removed is returned like any
other and only the warning is suppressed. That is pinned by a functional test
written before the port.

114 plain-JVM tests and 13 Forge server tests pass; the only test change is the
two-line adapter that stopped unwrapping a scala.Option.
2026-08-15 16:23:47 +02:00
Algent b92d4b7af4 test: characterize TileCache
Plain-JVM coverage for the map half: add stores the tile unflagged, remove
replaces the entry rather than dropping it, entries are keyed by coordinate
value rather than identity, and clear empties everything.

Forge server coverage for findTile, which needs a world. It pins the branch
that is easy to misread: the removed flag only suppresses the warning, and a
tile flagged removed is still returned, because the Some pattern matches
regardless of the flag and the reference's trailing null case is unreachable.
The empty-cache path throws with a message starting 'DC: Client multipart @'.

114 plain-JVM tests, 13 Forge server tests.
2026-08-15 16:21:14 +02:00
Algent c3d5b08ff7 refactor: port MultipartHelper to Java
MultipartHelper, MultipartHelper$ and MultipartHelper$IPartTileConverter are
all public-member- and descriptor-identical to the reference, and the full
emitted class list is unchanged -- this port neither adds nor removes a class.
MultipartHelper gains a private constructor and its companion's class
initializer loses ACC_PUBLIC, neither of which is nameable by a caller.

MultipartHelper$ was kept deliberately. It is not among the 17 MODULE$
singletons read from bytecode and no jar links against it, but guidenh names it
as a reflective string, and removing a companion breaks that invisibly.

createTileFromParts now builds one JavaConversions wrapper for both calls
instead of one per call site, and convertMulti returns Collections.emptyList or
singletonList instead of a Scala Seq wrapper. The declared type was always
java.lang.Iterable.

107 plain-JVM tests and 10 Forge server tests pass unchanged.
2026-08-15 15:47:17 +02:00
Algent 0fdf9e5e75 test: characterize MultipartHelper
Plain-JVM coverage for the half that needs no world: the id guard on
createTileFromNBT and the whole of IPartTileConverter. MultipartSaveLoad
cannot class-initialize headless, which makes it a usable probe -- returning
null rather than raising a LinkageError is what proves the guard short-circuits
before the loadingWorld assignment.

Forge server coverage for the rest, none of which is reachable headless:
createTileFromParts runs the ASM generator, the NBT round trip needs the
save/load hooks, registerTileConverter appends to a Scala MutableList, and
sendDescPacket needs a loaded chunk.

Also pins the two static descriptors other jars link against and the
MultipartHelper/MultipartHelper$ names guidenh reflects on, which the ABI diff
cannot see.

107 plain-JVM tests, 10 Forge server tests.
2026-08-15 15:43:18 +02:00
Algent 9db07f8c7c refactor: port the marker interfaces to Java
TSlottedPart, IRandomDisplayTick, INeighborTileChange, TRandomUpdateTick,
ISidedHollowConnect and IMicroMaterialRender.

All six are member- and descriptor-identical to the reference. The seven
implementors and mixin tiles were diffed too and are unchanged member for
member. Five were already pure abstract interfaces in bytecode, so their
conversion has no bytecode consequence; exactly one class leaves the jar,
TRandomUpdateTick$class.

onWorldJoin cannot become a default: TMultiPart declares it, and a superclass
method beats an interface default, so the auto-registration would silently
never run. It stays abstract and implementors call TickScheduler.loadRandomTick
themselves, as RedstoneTorchPart already did.

No bridge was written for TRandomUpdateTick$class. No jar in the pack
references TRandomUpdateTick in any form, and the frozen baseline holds exactly
the eight helpers the inventory lists.

99 plain-JVM tests and 5 Forge server tests pass.
2026-08-15 15:32:45 +02:00
Algent 3e68e67599 test: characterize the marker interfaces
TSlottedPart, IRandomDisplayTick, INeighborTileChange, TRandomUpdateTick,
ISidedHollowConnect and IMicroMaterialRender carry no implementation, so their
characterization is their shape: every member abstract and public, no
superinterface, and the exact member names.

Two of them extend TMultiPart in Scala source but emit a bare interface, and
IMicroMaterialRender is satisfied entirely by TMultiPart's Scala-style
world/x/y/z accessors, so the names are load-bearing.

TRandomUpdateTick's onWorldJoin auto-registration lives in its $class helper.
A part that does not declare onWorldJoin resolves it to TMultiPart's no-op;
that is pinned so the port cannot quietly turn it into an interface default,
which the superclass would shadow.
2026-08-15 15:28:17 +02:00
Algent cd5b801878 refactor: port BlockMultipart to Java
Converts the Block face of the API and its companion object.
BlockMultipart$ is descriptor-identical to the reference including
reduceMOP's Tuple2 return, and the class differs by exactly one
descriptor: hasTileEntity$default$1, the accessor Scala emits for a
default argument, which Java has no equivalent for. No jar references any
member of this class.

addCollisionBoxesToList keeps its descriptor; only its generic signature
changes from Scala's List<?> to the raw List that vanilla's Block actually
declares, which is the more faithful override.

getClientTile returns TileMultipartClient, a Scala trait extending
TileMultipart, so in bytecode it is a bare interface carrying none of the
class's members; addHitEffects casts to reach the part list. Third
occurrence of that pattern after JIconHitEffects and TRandomUpdateTick.

Four anonfun classes removed, including two nested inner closures.

Validated with 90 plain-JVM tests, a clean build, and the Java 8 Forge
dedicated-server suite. Most of this class needs a player, a ray trace or
a renderer, so breaking, selection, collision, pick block, activation and
particles stay on the manual checklist.
2026-08-15 11:45:56 +02:00
Algent 213ff0c8ea refactor: port TickScheduler to Java
Converts the scheduler, its two extension classes and PartTickEntry. No
jar in the pack references this class, so the ABI constraint was minimal,
but the reference shape was kept anyway: TickScheduler$ and PartTickEntry
are descriptor-identical including the Scala-style accessor pairs, and the
statics class adds only a private constructor.

TickScheduler$ is the one companion singleton in this migration that is
not a pure forwarder. The object extends WorldExtensionInstantiator and
WorldExtensionManager is handed the instance itself, so the two
instantiator hooks stay on the singleton.

processTicks filtered a ListBuffer with a side-effecting predicate that
fires part callbacks and mutates the entry; the Java version iterates and
rebuilds in the same order, so callback order and the reschedule mutation
are unchanged.

One Scala call site changed: the registration now passes
TickScheduler$.MODULE$. TRandomUpdateTick needed casts because a Scala
trait extending a class is a bare interface in bytecode, the same pattern
already recorded for JIconHitEffects.

Five anonfun classes removed.

Validated with 90 plain-JVM tests, a clean build, and the Java 8 Forge
dedicated-server suite, which runs this code every tick because the
scheduler is registered as a world extension at startup.
2026-08-15 11:38:07 +02:00
Algent 1b9eb05726 refactor: port TMultiPart to Java
Converts the base class every part extends. The cleanest port so far:
every descriptor is identical to the reference across all members, no
public member is lost or added, @SideOnly sits on the same seven members,
and the same two members stay deprecated.

No in-repo Scala call site needed changing, which is a first for a type
this widely used. Scala resolves the empty-paren Java accessors as it did
the Scala ones, and assignment to tile still desugars to tile_$eq.

The only real implementation is collisionRayTrace. getSubParts was
traversed through JavaConversions purely to get Scala's map, but
rayTraceCuboids already took a java.util.List, so the Java loop builds
that list directly and the conversion disappears along with the single
anonfun class.

Validated with 90 plain-JVM tests, a clean build, and the Java 8 Forge
dedicated-server suite.
2026-08-15 11:23:42 +02:00
Algent cacc9a30a8 refactor: port TileMultipart to Java
Converts the central tile class and its companion object. TileMultipartClient
moves to its own Scala file unchanged: it is registered with the ASM
generator through registerTrait, so converting it is Phase 5
registerJavaTrait work rather than part of this step.

Every public member of the reference survives except protected$worldObj,
the accessor Scala emitted so the dropItems closure could reach the
protected field; no jar references it, and TileMultipartClient lost
nothing including its generated super accessor for markRender. All five
Scala-typed descriptors are preserved: partList and its setter, operate,
getOrConvertTile2's Tuple2, loadParts, and the Tuple2 rayTraceAll stores
into ExtendedMOP.data.

partList stays an immutable Scala List republished on each mutation, which
matches the reference semantics exactly and takes no performance decision;
that belongs to Phase 4 with profiling. Internal callers still go through
operate rather than a private loop, so a trait overriding it still sees
every call.

Recompiled Scala consumers need four adjustments, all source-only:
partList.apply(i) for indexing, renderID_$eq for assignment, an explicit
cast on getOrConvertTile2._2, and an explicit AbstractFunction1 for
operate since 2.11 will not adapt a lambda to Function1[_, BoxedUnit].
Eleven, one, two and one in-repo call sites respectively.

31 anonfun classes collapse to one Java anonymous class.

Validated with 90 plain-JVM tests, a clean build, and the Java 8 Forge
dedicated-server suite, which is the load-bearing check here because the
ASM generator builds composite tiles on top of this class.
2026-08-15 11:15:03 +02:00
Algent beb0995e60 test: characterize TileMultipart part storage and predicates
Gate step before converting the central tile. Covers the surface that does
not need a world: the part list is replaced rather than mutated so a
previously published Seq never changes under a caller, jPartList reflects
the current parts, operate skips parts whose tile has been cleared,
getLightValue is the maximum and zero when empty while
getExplosionResistance is the maximum but throws when empty, occlusionTest
needs agreement in both directions, canReplacePart excludes the outgoing
part but still rejects a part already present, and solidity falls back to
partMap being null on a bare tile.

One assumption was wrong and the test caught it: TMultiPart.doesTick
defaults to true, so a default part starts the tile ticking and a part has
to opt out to leave it idle. The case now records the real behavior.

Anything touching worldObj, the registry or packets stays out of this
layer because it cannot run headless; the Forge server suite covers that
side.

90 plain-JVM tests, all passing against the untouched Scala.
2026-08-15 10:49:57 +02:00
Algent b9d5e6ab52 refactor: port MultiPartRegistry to Java
Replaces MultiPartRegistry.scala with a Java registry, its companion
singleton and the three nested interfaces. All three interfaces are
descriptor-identical to the reference and MODULE$ keeps every instance
method downstream links against. Twelve jars reference this type.

Both Scala-typed registerParts descriptors are preserved, since
ForgeRelocationFMP links against the Function2 form and ProjRed against
the IPartFactory2 Seq form. That leaves TileMultipart.partList as the last
Scala-typed descriptor in the inventory.

The two array overloads are declared varargs. The descriptor is unchanged
and ACC_VARARGS does not affect linkage, but MicroblockClass called the
Scala varargs form with a single string, which no longer resolves against
a plain array parameter.

readIDMap moves to java.util.List and the mangled accessors Scala emitted
for its closures are gone; neither is referenced by any jar. Eight anonfun
classes and one anonymous class are replaced by the two Java adapters the
deprecated overloads build.

Validated with 78 plain-JVM tests, a clean build, and the Java 8 Forge
dedicated-server suite, which is the only layer where registration can run
at all since it needs FML's active mod container.
2026-08-15 10:35:15 +02:00