Every release, in order.

GameHost.rewind(RewindConfig). The host arms after the arena is built and stops before it comes down, on every match; r.recording() exists by onRoundStart; the match's phase, clock, roster and arena size rewind with the world; a player rewound to before their elimination leaves spectating. That is PAIRED-RULES row 42, enforced.

The freeze is a freeze. Entities, scheduled block and fluid ticks, random ticks, weather, block entities, every player interaction and the held-item drop are held in a paused level; bodies are anchored with gravity off. Everyone is frozen except the operator: a director (spectating) walks freely and is never restored; an operator who is in the round is frozen with everyone and the panel follows them.

Speed is a choice per recording (RewindController.setSpeed returns null or a refusal reason), applied while live and on resume, refused while a person is outside the recorded level. Above 1× a vanilla client's walkers are scaled by a MOVEMENT_SPEED modifier; the Conduit client now lifts the 20/s cap (FastForwardTickMixin) and runs at the server's rate, with no modifier.

Block-entity data in the journal and the tape (BlockEntityNbt, RewindBlockEntityChangeMixin): chests, signs and furnaces rewind with their contents, seeded every capture tick.

Attribute modifiers in the pose (ModifierSnapshot): a game's own modifiers (not the minecraft namespace) rewind and persist in tapes.

The memory cap compares against a count (Recording.memoryBytes), entity NBT measured, shared inventory snapshots counted once; entity state keyframes are staggered per track; /conduit rewind status shows memory and capture cost.

Opt-in tape retention: rewind_tape_max_count and rewind_tape_max_mb, both 0 (never prune) by default.

Module master docs for core, render, rewind and fx; a rewind roadmap; 63 new game tests.

Custody.identityOf / destinationOf, and PlayerCustody.heldIdentity / heldDestination. Without them no diagnostic could read the record at all, which is why D3 could not be fixed at the command layer. status now prints HELD, HOME and BODY as three labelled lines.

Game tests for all three, each proven against a known-bad control: CustodyDeathScreenStashGameTest (dying vs live at release), CustodyConsoleCommandGameTest (held vs body). 17 game tests per line now.

CustodyConsoleCommandGameTest, two arms: the targeted form must answer a playerless source with an actual status, and the bare form must refuse out loud. Content-asserted, not presence-asserted, because a refusal is also output and a test that accepted any line would pass on it. Proven by restoring the silent return 0 and watching only the bare arm fail.

Custody is documented where builders read. Round 28's convergent finding was that grep -ci custody returned 0 on both archetype guides, MAKING-MODS.md, README.md and wiki/Home.md, so every page a builder is sent to still taught the hand-rolled teardown. Section 8 of each guide now carries the two calls and the migration table, section 10 carries the checklist lines, and the three entry docs point at them.

New content, not just relocation: how custody composes with GatherRoom, which no document stated. Settled against source. take before gather; leave the stash on; do not also call room.disperse, because custody queues its own return and disperse queues a second one to Prior, so two returns drain for one player; keep room.close(), which is the force-load ticket and not the return. That retires the dead-player PENDING_HOME branch entirely.

Section 2's reference mod on each page is bannered, not rewritten. It stays compiled and current for everything except teardown, and the rewrite waits for a round to verify it.

Doc pair custody-consumer-api so take and giveBack cannot change shape without failing the build until those pages are re-read.

Doc pair custody-diagnostics, 16 pairs now. checkEngineDocPairsTargeting rejected the first attempt because TESTING.md never named CustodyCommand, which was correct: re-reading a page that does not mention the class cannot reveal a change to it.

CustodyStashRetentionGameTest, two arms on a real server, differing in one variable: custody holds the player or it does not. Held survives the discard, unheld is still discarded. Proven against a known-bad control by restoring the original unconditional discard and watching the held arm fail by name while the control arm kept passing.

Doc pair stash-retention, so the two halves of this behaviour can no longer drift apart silently. 14 pairs now.

Player custody. me.zlex.conduit.custody.Custody (core, no Minecraft types, the state machine) and PlayerCustody (arena, the calls). A game writes take(player, instance) and giveBack(player) and nothing else: no leave handler, no in-flight set, no eviction on disconnect, instance release or shutdown, and no ordering rule for the spectator release. Supersedes the SendHome reference class in PAIRED-RULES.md, which is kept deliberately because checkReferenceModsCompile and checkReferenceModBehaviour run it. Migration table at the top of that section; the honest gap list is in docs/ownership-lifecycle/NOT-SOLVED.md.

/conduit admin custody — status, take, wreck, give, release, drop. Drives every exit path by hand on a dev server, printing gamemode, respawn and dimension before and after. runServer is re-enabled on conduit-arena as the host. See docs/ownership-lifecycle/TESTING.md.

Two Minecraft targets from one source tree. Stonecutter merged: 26.2 and 1.21.11, each with its own published coordinate and its own Java toolchain.

Game tests. The engine had none. Eight now, on each target, against a real headless server, plus an exhaustive interleaving suite over the custody state machine: 11,390,625 orderings in about four seconds, with eighteen historical defects planted as controls that it must catch.

DropReason.DESTINATION_GONE is now documented. It shipped in round 24 and appeared in no document at all — all three enumerations listed five of six members and one described them as "all four".

conduit-combat — new module. A custom, animation-agnostic melee engine (the "Better Combat" replacement). MeleeWeapon declares reach, sweep arc, attack cooldown, combo window, and a MeleeSwing sequence; MeleeCombat.install(WeaponResolver) intercepts AttackEntityCallback, returns FAIL for resolved weapons (owning combat), runs a forward cone-sweep, deals each combo swing's damage via hurtServer (i-frames cleared so a fast string lands), applies player-safe knockback, plays feedback, and fires a MeleeHit per target via onHit (the seam animations attach to). Any LivingEntity can fight: MeleeCombat.performSwing(level, attacker, weapon) runs the identical pipeline for AI opponents / scripted bosses / training bots (whiffs are audible, cooldown-gated), and comboState(uuid) exposes the combo cursor for AI observations and HUDs. Depends on conduit-core; server-side only. First consumer: the Blade Clash katana; first non-player consumer: the AI Fighters gym bridge.

conduit-world · GameplayRules.weatherCycle. A sixth toggle (default true); when false the enforcer freezes ADVANCE_WEATHER and forces clear weather, and when daylightCycle is false it now also pins the world to day — driving the vanilla time/weather commands (26.2's time/weather setters are reworked, so the command path is version-stable). Record gains a field (positional-ctor break for the two internal consumers; Codec back-compatible).

conduit-world · GameplayRules.daylightCycle. A fifth toggle (default true); when false the enforcer freezes the ADVANCE_TIME gamerule so a filming world stays at a fixed time of day. New applyWorldRules applies spawning + daylight together on server start. (Record gains a field — a positional constructor break for the two internal consumers; Codec stays back-compatible.)

conduit-instance · RuntimeDimensionSpec.superflatWorld. A one-call factory for a superflat runtime dimension (overworld dimension type, classic flat ground) beside voidWorld, wired to VoidWorldHelper.createSuperflatGenerator. A mod spins one up + teleports players in, so "everything is flat" doesn't depend on how the host generated their main world (which can't be reflattened after creation). Persist it for a single reusable arena across restarts.

conduit-world · superflat generator. VoidWorldHelper.createSuperflatGenerator builds a classic bedrock/dirt/grass-over-PLAINS FlatLevelSource (plus an overload taking a caller-chosen surface biome + FlatLayerInfo stack) — the flat, open surface prop rigs and Modplex creation worlds want, sitting right beside the existing void generator. Structures off — the structure overrides are an explicit empty set (not Optional.empty(), which would fall back to all default structures), so no villages/strongholds/etc. interrupt the flat surface.

conduit-world · Regions.railedLane. Stamps a single-file lane flanked by a rail on each side (left rail anchored, right rail pushed out by wallGap) and returns each lane slot's centre BlockPos so the caller spawns whatever it likes down the middle. The reusable geometry behind mob gauntlets / runways; stays block-agnostic like the rest of Regions.

conduit-world · GameplayRules + GameplayRulesEnforcer. An enforced server-wide toggle bag — naturalSpawns (SPAWN_MOBS gamerule), invincible (players take no damage), noHunger (food kept full), instakill (a player's hit one-shots any mob) — with a Codec and a one-call install(Supplier<…>) that wires the Fabric hooks once and reads live rules per event. Deliberately mirrors the Modplex runtime rule catalog (player.invincible, difficulty.hunger_rate, spawns.disable, player-instakill) so a mod built on this maps 1:1 onto a Modplex pack.

StructureScan + StructureLocator (me.zlex.conduit.world.structure) — structure finding as arithmetic instead of as search, generic over a structure TagKey rather than hardcoded to villages.

The village search was slow because it was searching. It walked a grid asking StructureManager.checkStructurePresence per cell — which scans the region files from disk on every probe — and then generated a chunk for every probe that survived. On a fresh instance: 810 probes, 31 chunk requests, 6,468 ms of server-thread time, worst tick 153.9 ms, and no village after 30 seconds. Vanilla /locate was worse: one tick, past 60 seconds, watchdog kill.

None of that work was necessary. Structure placement is a pure function of the world seed, in three stages of strictly increasing cost:

1. RandomSpreadStructurePlacement.getPotentialStructureChunk is integer maths over a LegacyRandomSource. One candidate per spacing-wide grid cell, and the mapping is a bijection — the candidate derived from a cell always floor-divides back to that cell, because the spread offset is bounded by spacing - separation — so enumerating cells enumerates every candidate in a region with none missed and none repeated. 2. The frequency reducer and the exclusion zone are also pure arithmetic. 3. Structure.findValidGenerationPoint is noise maths: one terrain column and one MultiNoiseBiomeSource sample. No chunk, no disk, no chunk system.

Stage 3 is the whole answer, not a shortlist to confirm later. StructureCheck.canCreateStructure — the predicate behind checkStructurePresence's CHUNK_LOAD_NEEDED — is literally findValidGenerationPoint(ctx).isPresent(), and ChunkGenerator.createStructures gates on the same call when a chunk really generates. Vanilla's chunk load in getStructureGeneratingAt exists only to re-read the start and bump its explorer-map reference count; the start's ChunkPos is the candidate chunk stage 1 already computed.

StructureScan also walks cells in true distance order rather than vanilla's square ring perimeters, so the first hit is the nearest hit and the walk stops on the next cell whose distance lower bound already exceeds it. Ring order is not distance order — a corner of ring 1 is further than an edge of ring 2 — so vanilla can return a village that is not the nearest. On 16 test seeds the two orders disagreed on 9, and the distance-ordered walk was nearer every time.

Measured over 12 seeds at radius 6 cells: 4-16 candidates, 86 ms of CPU on average (23-167 ms), 0 chunks generated, 0 region-file reads, and a village found on every one — against 6,468 ms and a failure. On the specific seed the old search lost on it visits 4 cells, spends 34 ms and returns a village 452 blocks out. Sliced into 2 ms tick budgets, 86 ms is about 43 ticks of barely-measurable work. Per-candidate the split is getNoiseBiome 8 us and getFirstFreeHeight 2,077 us — the biome test is free, the terrain column that decides which biome to test is the entire cost, which is why the early-out matters more than any micro-optimisation of the check.

Verified headlessly against two independent ground truths on every candidate: ChunkGenerator.createStructures (weighted variant draw included, run to an assembled StructureStart — what the game actually places) and StructureCheck.checkStart against a storage reporting every chunk absent (what /locate asks per probe on a fresh instance). 784 candidates over 16 seeds, 0 mismatches against either. minecraft:ruined_portal — a different structure set with different placement behaviour — agrees exactly on 200/200, so the genericity is tested rather than asserted.

StructureScan has no Conduit imports, no Fabric imports and no ServerLevel; its Context record is the guarantee that nothing reachable from it can load a chunk. That is also what lets the structure-finder tool (~/yt/structure-finder) compile the identical file and render the algorithm over a real biome map for any seed, without the engine and the picture being able to drift apart.

StructureLocator is the server-side driver: budgeted, resumable, cached per (seed, tag, radius), never blocking, never completing exceptionally. The per-tick budget is kept even though it barely matters now — cheap in the common case is not a reason to let a large radius on a rare structure spike a tick.

StructureScan landed additive, beside a still-working VillageSearch. The swap and the deletion are the Changed entries above, in this same release, so the two mechanisms never coexisted in a shipped version.

/conduit admin instance village <key> [rings] [blind], the hit-rate harness. "It finds a village" is a claim about a rate, not about one world, and nobody is going to sit through a dozen seeds in a lobby GUI. This runs the engine's real search headlessly, bypasses the seed cache so a repeat is a real repeat, and prints the instrumented line: probes split into biome-filtered and structure-checked, where the milliseconds went, worst tick, worst probe, wall clock, ticks elapsed.

blind disables the biome pre-filter, and it is how the filter gets verified rather than trusted: filtered and blind must reach the same answer, and over 16 seeds they do. The same escape hatch exists in code as VillageSearch.find(level, rings, biomePrefilter, useCache).

/conduit admin instance gives the instance system a headless hand. Everything the instance system does, it did from a GUI: the host picks a seed in the lobby's World tab and presses Start. That made the two things most worth checking untestable from a console, namely whether the seed asked for is the seed you got, and how long the tick stops for at round start.

/conduit admin instance list
/conduit admin instance new <void|flat|overworld> [seed]
/conduit admin instance probe <key>          seeds + a terrain fingerprint
/conduit admin instance spawnprep <key> [r]  the round-start step, timed
/conduit admin instance release <key>

probe is the seed check, and it takes a terrain fingerprint rather than trusting the reported seed, because a world can echo a seed it never generated with. Drivable over RCON, so instances can be exercised without a client.

ChunkSweep, and a hub builder allowed to finish on a later tick. Pad Party's hub build opens by sweeping 625 chunks for marker blocks with level.getChunk, one blocking disk read each: 356 ms in a single tick on an idle boot, and 3,252 ms on a boot where the runtime-dimension restore ran first and took the chunk workers with it. ChunkSweep is that scan shape done properly: keep up to 32 requests in flight through the non-blocking chunk entry point, visit whatever has arrived, stop when the tick's 2 ms budget is spent. Loading happens on the chunk workers in parallel and the tick thread only pays for visiting. Both the visitor and the completion callback run on the server thread, so a sweep may write blocks, which is the point for a marker scan that erases what it finds.

A sweep spans ticks, so a hub builder that starts with one cannot have finished when it returns. HubManager.CustomHubBuilder gains an explicit done signal and holds back the post-build work (roomBuilt, the pad-overlap self-check, GameRegistry.markHubBuilt) until it fires. The old BiConsumer overload still works and completes immediately.

The lobby World tab. LobbyMenu.Tabs.WORLD + me.zlex.conduit.lobby.WorldSetup. WorldSettings, the data, has lived in conduit-world since the modular split, and WorldSettingsScreen renders it on the legacy flat theme. The half every consumer re-implemented was the application logic: which WorldTemplate a settings bag asks for, how a typed seed becomes a long, which gamerules to push, and how to find the nearest village. WorldSetup packages that, plus the VanillaConfigMenu rows for a World tab so the surface matches the rest of the setup screen instead of being a separate flat-theme panel. Purely additive.

The engine still never regenerates a world for anyone. templateFor() names the template; acquiring and swapping the instance stays the game's call.

Solo-testable games (SoloMode, LobbyConfig.minPlayers, BaseLobby.beginRound/roundOver/underStrength). Every mini-game hard-coded the same if (players.size() < 2) refuse gate, so nobody could exercise a game without finding a second human. The minimum is now declared once, on LobbyConfig, and enforced through SoloMode.canStart. One server-side switch — solo_test in conduit.toml, the Solo test rounds toggle in /conduit settings, or /conduit solo on — lowers it to one player for every registered game at once. Nothing about it is silent: SoloMode.announce paints a red banner for every participant, sidebarNote() gives the HUD a persistent marker, GameRegistry.updateStatus tags the hub pad, and LobbyMenu tags the setup screen's title. It defaults to off, so shipped servers keep their real minimums.

The gate was only half the problem. Most party games end when "one player remains", which with one player is true at tick zero — so an unlocked game would have started and ended in the same instant. SoloMode.roundOver(alive, startingPlayers) (surfaced as BaseLobby.roundOver) is the corrected test: normally "at most one contender left", but for a round that began with one player, "the lone player is out". Games call BaseLobby.beginRound(min) at round start to record the round's size.

LobbyMenu — the one lobby-setup surface. Six games each hand-assembled the same VanillaConfigMenu.openTabbed call with their own footer labels and their own "waiting for host" title. LobbyMenu fixes the shape: Setup / Tuning / Arena tab names (LobbyMenu.Tabs), a footer that is always host-gated Start Game then always-available Leave Game, a shared showWaiting card, and the solo tag on the title.

Difficulty — the shared Easy / Normal / Hard / Insane / Custom vocabulary, plus indexOf / isCustom / isBundle. Five games declared byte-identical copies of this list and their own index helpers.

LobbyConfig.zoneId — a game may pin the HubZone id its pad claims instead of taking the derived "<game-id>:main". This is what lets a shipped game move onto GameRegistry.register without changing the id its hub, marker pipeline and saved state key off. GameRegistry also gained zoneIdOf, byZoneId, and a duplicate-zone-id guard.

Hub pads have a configurable size and shape (PadFootprint, ZoneShape). Pad geometry was hard-coded at PAD_PLATFORM_HALF = 4 — a 9×9 axis-aligned trigger box, in eleven places in HubManager. That is right for the pads the engine lays out on its own arc and wrong for a hand-built hub: a build whose pads are 5×5 gets a trigger sticking two blocks past every edge, and pads placed as close together as a human places them get flagged as overlapping when the pads themselves do not.

• PadFootprint(shape, size, height) — size is the full width / diameter in blocks, so square(5) and circle(5) are both 5 across. boundsAt(centre) produces the trigger box; at HubManager.DEFAULT_FOOTPRINT (9×9, 7 tall) it is character-for-character the box the engine built before.
• registerCustomPad(server, zone, centre, normal, footprint) — new overload. The four-argument form is unchanged and now delegates with DEFAULT_FOOTPRINT, so every existing call site keeps its exact geometry.
• HubManager.getZoneFootprint(zoneId) and zoneContains(zoneId, point) — shape-aware companions to getZoneAabb, which still returns the bounding box (for a circle, the circle's bounding box).
• The ambient particle ring now scales with the pad: its radius is the pad's own half-width less a 0.1 inset and the dot count scales with that radius, so a 5-wide pad gets a 5-wide ring. At the default footprint both work out to the previous constants (4.4 and 18), so engine pads emit the ring they always have.

ZoneShape (conduit-prefab) — sealed SQUARE / CIRCLE, the horizontal cross-section of a ZoneDef. SQUARE.contains is literally AABB.contains; CIRCLE is radial about the bounds' horizontal centre with the same half-open vertical rule. Neither variant carries state: a zone's position and size are always its aabb(), and a circle's is its bounding box — one source of geometric truth, so shape and bounds cannot drift apart.

• ZoneShape.overlaps(shapeA, a, shapeB, b) is exact for all three pairings. Square/square is box intersection (equivalently a Chebyshev test — Euclidean chord distance under-reports for axis-aligned boxes). Circle/circle is Euclidean (Chebyshev would over-report). The mixed case is neither: it clamps the circle's centre into the box on each axis and compares that distance against the radius.

HubManager.checkPadOverlaps() — boot-time self-check, run at the end of SERVER_STARTED after whichever build path ran, so it covers the engine's arc and a hand-built hub alike. Logs each overlapping pair with both centres, both footprints, the measured separation and the required one. Reports only; whether to refuse a bad layout is the hub owner's call.

The hologram read-back path is exposed (worldLabel + HubManager.getZoneLabelId). ServerLabelManager already stores every world label server-side so late joiners can be re-sent it, so a published hologram was readable all along; it just had no accessor. getZoneLabelId is the companion to getZoneAabb that turns a zone id into that widget id. Together they let a hub self-check assert that updateZoneStatus really repainted a pad, rather than assume the call landed.

MobBuff.glowing(ChatFormatting): coloured glow outlines. An un-teamed glowing entity always renders a white outline: vanilla takes the colour from the entity's scoreboard team, so a colour was simply unreachable through MobBuff and downstream mods had to hand-roll scoreboard teams around the engine. apply() now joins a conduit_glow_<colour> team that carries nothing but the colour and remove() leaves it again. One team per colour, created on demand and shared by every buff and event, so the cost is a bounded handful of scoreboard entries rather than one per event. leaveGlowTeam only unteams a glow team, so it will not strip an entity off a team someone else put it on. Non-colour formattings (BOLD and friends) fall back to plain white rather than making a junk team. glowing() with no argument keeps vanilla white.

EntityReg — custom-EntityType registration glue. register(namespace, path, EntityType.Builder) builds against the ResourceKey and registers into BuiltInRegistries.ENTITY_TYPE; attributes(EntityType<? extends LivingEntity>, AttributeSupplier.Builder) wraps FabricDefaultAttributeRegistry.register. Server-safe (no client imports) — the glue Cataclysm's GeckoLib mobs (alien, ghost, ninja, running creeper, cave monster, lava golem, shark) register through.

Forces — stateless, capped, per-tick field forces over nearby entities (caller owns the loop). pullToward(level, point, radius, strength) (black hole), vortex(level, axisBase, radius, swirl, lift) (tornado), sweep(level, lineCenter, dir, halfWidth, push) (tsunami wall). Radius clamped to MAX_RADIUS (96), entities capped at MAX_ENTITIES (512); velocities flagged dirty so player knockback resyncs.

Projectiles — observe/clone projectiles without a mixin. onProjectileSpawn(BiConsumer<ServerLevel, Projectile>) registers a ServerEntityEvents.ENTITY_LOAD listener filtered to Projectile; cloneWithSpread(Projectile, double spreadDegrees) spawns a same-type copy with yaw-rotated velocity (triple-shot fan-out).

StatusEffects — custom-MobEffect registration + contagion. register(namespace, path, MobEffect) → Holder<MobEffect> into BuiltInRegistries.MOB_EFFECT; spreadOnContact(level, carrier, effect, radius, durationTicks, amplifier) applies the effect to nearby living entities (Ebola spread). Caller ticks it; capped at MAX_SPREAD_TARGETS (256).

Debris — rain(level, center, radius, count, palette, spawnHeight, explodeOnImpact) drops Scheduler-staggered FallingBlockEntitys of random palette blocks over a disc, optional anvil-style impact damage. Count capped at MAX_COUNT (512). Meteor / volcano / falling-trees reuse this.

Atmosphere — environmental mood effects, self-restoring via Scheduler. bloodSky(players, ticks) envelops each player in a red dust haze (server-safe approximation of a fog shader — documented limitation); weather(level, storming, thundering, ticks) forces then restores weather; shake(players, intensity, ticks) best-effort camera rumble via relative- rotation position packets.

Flight (conduit-mob): hand-driven flight stepping for custom craft. The reusable primitive for flying entities that move by direct repositioning rather than pathfinding (UFOs, drones, flying bosses). It caps each step, turns the craft to face its travel, and zeroes velocity to avoid the double-step a LivingEntity's own travel() would otherwise add by integrating deltaMovement on top of the setPos. Pair it with noPhysics + noGravity + updateInterval(1) for smooth, client-interpolated flight.

Ufo — animated flying-saucer abduction prop (conduit-mob). A self-contained "custom model + animation" built from vanilla Display entities — no model library needed. Ufo.abduct(level, ground, target) spawns a saucer rig (disc body, glowing belly, glass dome, four orbiting rim lights) high above a point; a single Scheduler task drives a descend → beam → abduct → ascend → depart state machine. The saucer spins (each part bakes its offset/scale/spin into a Transformation the client tweens between updates), drops a glowing beam + END_ROD particle column, lifts the target up into the ship (non-players are taken/discarded, players released), then climbs away and cleans every entity up. The first set-piece for the Cataclysm "alien invasion" event.

MobBadge state accessors — displayInWorld() and currentText() to introspect a live nameplate. Added while runtime-verifying the enhanced-mob system end-to-end on a dedicated server: buffs apply (a boss zombie goes 20→100 HP, scale ×1.4, glowing), the nameplate is added to the world and follows, its health bar drains with the mob (100→80→60→40→20), and it auto-discards on death.

Enhanced "elite/boss" mobs (conduit-mob). MobBuff — a named, declarative, removable stat-buff bundle (the improved successor to MobBuffs' permanent setBaseValue scaling): stable-id AttributeModifiers applied via addOrUpdateTransientModifier (idempotent — re-apply updates in place, never stacks) and stripped cleanly by remove. Fluent builder over health / speed / damage / scale (visible size) / armor / knockback-resist / attack-knockback / follow-range, as percent or flat, plus a glow flag and ability-display lines; MobBuff.elite() / MobBuff.boss() presets. MobBadge — a floating nameplate that follows a mob (the engine's first entity-follow display): a vanilla billboard TextDisplay re-positioned each tick, showing the name, a live unicode health bar (green→yellow→red by %) with cur/max, and the buff's ability lines, auto-discarded when the mob dies. MobAnimations — general Display-transform animation helpers (scale-in pop / interpolated scale) over vanilla interpolation, the engine's first entity-attached animation support. Mobs.enhance(mob, buff, name) ties buff + badge together in one call.

MobWave controller (conduit-mob) — capped, interval-paced spawn waves, the runtime primitive the big scheduled events (a Blood Moon's "hundreds of mobs", an alien invasion) are built on. A fluent builder (MobWave.builder(level, type).follow(player).around(8, 24).perWave(8) .every(40).maxAlive(60).total(300).duration(...).onSpawn(...).start()) spawns batches around a re-evaluated anchor (so it can follow a player), counts only still-alive mobs against the concurrent cap, and defaults to persistent spawns so event mobs don't despawn mid-event. cancel(discardLiving) ends a wave and can sweep its survivors. A single MobWaves driver (one server-tick listener, CopyOnWriteArrayList-backed, wrapped in TickBudget) advances every active wave and drops finished ones, so waves don't each register their own hook.

conduit-mob module — runtime mob spawning + buffing helpers, the layer chaos / event mods build their spawns on (no per-mod vanilla boilerplate). MobSpawns.spawnAround(level, center, type, count, minR, maxR[, reason, afterSpawn]) scatters entities on the surface in an annulus (heightmap ground-snap, random yaw) and returns what it added; MobSpawns.spawnAt(...) places at an exact Y for arena / authored points. MobBuffs scales attributes (scaleHealth tops up to the new max, scaleSpeed, scaleDamage, empower) — every scale is null-guarded so attribute-less mobs (e.g. a creeper has no attack-damage attribute) pass through safely — plus equip(mob, slot, stack) with drop chance pinned to zero. Spawns use EntitySpawnReason.COMMAND by default (deliberate, not environmental). A capped/interval-paced MobWave controller and GeckoLib-aware custom-entity registration glue are planned follow-ups (see docs/MOB-FEATURES-PLAN.md).

mob-spawn prefab element — a named, authorable spawn point. Like Zone it is a descriptor, not an action: instantiating the prefab spawns nothing, Scene.mobSpawns() exposes the resolved MobSpawnDef (entity type, count, world centre, scatter radius) and the consuming game — or conduit-mob's MobSpawns.execute/executeAll(scene) — fires it on demand. This keeps the prefab purely declarative (no entity duplication on /reload) and is what lets Conduit Studio author mob spawns, closing its geometry-only gap.

conduit-rewind module — live full-fidelity rewind / time machine for a running match. A host arms a recording, then can pause, scrub to any earlier moment (players, blocks, entities, and scores all snap back), and resume play from there — a real do-over. Restores state, never replays behaviour (MC is non-deterministic), so the recording is only ever read backwards. Capture: per-tick player poses + inventory keyframes; block-write journal (LevelChunk.setBlockState mixin) restored by minimal diff; entity ledger (spawn/remove + spawn NBT + transform samples + state keyframes) via the modern ValueInput/ValueOutput NBT system. Pause freezes entity ticking (mixin) + locks players + shows a PAUSED overlay; a boss-bar scrub timeline tracks the preview head. SnapshotSlice SPI rewinds game state — arena ships MatchRewind.bind so Match scores rewind too (Match.restoreState). Full command tree (/conduit rewind arm|stop|pause|resume|back|step|to|commit| cancel|mark|status|save|discard|list|load, gated by conduit.rewind.control). Coverage is full up to rewind_memory_cap_mb, with logged eviction beyond it. At match end the host is prompted to save a durable match record (summary + event-marker timeline) under <world>/conduit_rewind/.

MatchCompletedEvent (arena) — fired on the bus from Match.finish; the completion signal a tournament/Season runner (and stats/announcers) consume.

WorldNpc (render) — frozen, vanilla-rendered character NPC figures (armor-stand-backed with equipment) for hub guards / doll / front-man. Fluent builder: name (Text markup), head/chest/legs/feet/hands, glow, slow spin; visible on every client incl. vanilla. Server-owned lifecycle (character(...).show() / worldHide).

Hologram (render) — fluent, handle-based floating label over ServerLabelManager (auto-allocated id; show()/lines()/label()/remove()).

Hud.sidebar (fx) — framed MCC-style scoreboard preset.

DebugOverlay (fx) + /conduit debug — toggleable action-bar dev HUD (players/mem/dimension + custom lines); first in-engine consumer of @Command.

Zones (core) — named AABB trigger regions firing ZoneEnterEvent/ZoneLeaveEvent on the bus; kills hand-rolled "is the player on the pad" polling.

ItemBuilder (core) — fluent ItemStack (Text-markup name/lore, glow, count).

FxPresets (fx) — confetti / winBurst / ringPulse particle choreography.

GameActivity + GameRule (arena) — Plasmid-style scoped, auto-unregistering event node + deny/allow rules (ALL_DAMAGE/FALL_DAMAGE/PVP/HUNGER/BLOCK_BREAK), enforced once via GameRuleEnforcer.

Sequence (core) — TaskChain-style run/delay/waitUntil/loop over the scheduler.

Leaderboard (fx) — top-N holographic board over ProfileStore counters (offline-safe names; the engine now records each player's name on join).

Event bus (core, me.zlex.conduit.event) — Minestom-style EventNode tree, cancellable + prioritized events, @Subscribe auto-listeners (explicit Listeners.register + conduit:listeners entrypoint), fault-isolated dispatch. Bridges Fabric server events (damage/join/leave/tick).

Declarative commands (core, me.zlex.conduit.command) — @Command/@Arg/ @Suggests reflector over Brigadier, permission-gated.

Scheduler + Cooldowns (core) — Bukkit-style task scheduling on the bus; per-owner millisecond cooldowns.

Text (core) — MiniMessage-style markup + gradients/rainbow → vanilla Component (no Adventure dependency).

Services (core) — typed service locator / DI-lite.

Ease + Tween (fx) — Penner easing curves + tick value tweener.

SoundKit (fx) — semantic per-player UI/gameplay sound vocabulary.

Menu (fx) — fluent themed menu over in-world screens (scale-in pop + audio).

Hud (fx) — countdown bossbar (drains/recolors/ticks) + cinematic role reveal.

Theme.premium() / Theme.lerp() (render) — navy+gold preset + crossfade.

See [wiki/framework.md](wiki/framework.md) for the full guide.

HubManager.setCustomBuilder (arena) — optional hook letting a mod replace the engine's default spawn-box / pad-arc hub build with its own (e.g. paste a custom hub). Registered zones stay available via the new HubManager.zones(); custom builders set the spawn through the new HubManager.setSpawn(pos, yaw).

Podium.celebrate(..., Collection<ServerPlayer> audience) overload — scopes the winner title card + fanfare to a supplied audience (e.g. the finishing lobby) instead of every player on the server.

Metrics (core) — a process-lifetime counter registry. Engine hotspots bump named counters (player.leaves, phase.stuck, callback.faults) so operators can read health without grepping logs.

/conduit admin instances — lists every live game instance (dimension, template, player count, callback-fault count). Op-gated.

/conduit admin metrics — dumps the Metrics registry. Op-gated.

/conduit leaderboard <stat> [count] — prints the top-N players by any ProfileStore counter (wins, games_played, points_total, …) in chat, with online-name resolution and stat-name suggestions. (The in-world board render remains future work — this is the data/command half.)

Quality & feature pass (engine-discovery roadmap). A survey of all eight modules drove a batch of additive, non-breaking features:

• PlayerLifecycle (conduit-core) — one engine-wide disconnect fan-out. Subsystems register onLeave(UUID) handlers; on disconnect every transient per-player map is pruned (state, inventory stash, fx sidebar, fx bossbars, spectator gamemode), so long-running servers no longer leak as players churn. New ConduitFxMod entrypoint (fx previously had none).
• ProfileStore + PlayerProfile (conduit-core) — durable cross-game player profiles (schema-free counters + attributes) persisted via SavedData on the overworld. get/increment/set/counter/setAttr/attr/top. The keystone for leaderboards, achievements, and match history.
• Achievement + Achievements (conduit-core) — declarative unlock triggers on profile counters ("first_win" when wins >= 1), persisted as ach.<id> attributes so they never re-fire. Default gold-toast presentation via AchievementToast (conduit-fx), wired through a callback handoff.
• MatchResult + MatchHistorySavedData (conduit-arena) — snapshot a finished Match (winner/standings/points), commitTo() folds wins/games_played/points_total into ProfileStore, and a capped ring buffer keeps the last 50 results queryable. Match.finish(gameId).
• PhaseFlow timeouts + PhaseWatchdog + TimedPhaseFlow (conduit-arena) — per-phase deadlines that auto-advance a stuck phase (AFK host, missed transitionTo) and log/alert on recovery. PhaseMachine.ticksInCurrentPhase().
• GuardedDispatch + FaultPolicy (conduit-arena) — exception-isolation barrier around game-supplied callbacks so one throwing onTick/phase callback can't kill the server tick or wedge a half-applied phase. Game.faultPolicy() (default LOG_ONLY, backward-compatible 8-arg ctor).
• fx choreography layer (conduit-fx) — Particles (burst/ring/puff + elimination/safe macros), FxTimeline (self-ticking at/after/repeat sequencer), EffectThrottle (per-key cooldown gate), ScoreBoardBinding (generic standings → Sidebar) + arena-side MatchScoreboard adapter.
• SpectatorManager.SpectatorListener (conduit-spectator) — observer seam fired on make/release spectator (spectator-HUD prerequisite).

Fixes flagged in the survey: thread-safety on PlayerStateManager, PlayerInventoryStash, Sidebar, PlayerBossbar, SpectatorManager maps (→ ConcurrentHashMap); the Sidebar.show subList aliasing bug.

Jar-bundled arena presets (conduit-world). ArenaStore.load now falls back to a classpath resource at /conduit/arenas/<gameId>/<preset>.json when no game-dir file exists, so a published mod can ship its authored arena inside its own jar (under src/main/resources/conduit/arenas/<gameId>/default.json) and it loads out of the box on a fresh install. An operator still overrides it by dropping a file of the same name into <gameDir>/conduit/arenas/… (disk wins). list() surfaces the bundled default so the host preset picker shows it too.

Multi-spawn points in the arena editor (conduit-world + conduit-arena). Operators can mark any number of player spawn points inside an edit session and bake them into the saved preset:

• /spawn add — record a spawn where you stand (position + facing yaw).
• /spawn list / /spawn remove <n> / /spawn clear — manage the set. Spawns persist in the preset JSON as offsets relative to the snapshot's low corner (a new optional spawns field on ArenaSnapshot, so older preset files still load), and ArenaSnapshot.worldSpawns(origin) resolves them for a paste. When a started game's preset carries spawns, players are distributed across them (cycling) instead of the procedural spawn ring; with no spawns the game falls back to its existing auto-spawn. Editing the default preset pre-loads its existing spawns so a re-save preserves them.

WorldEdit-style .schem schematic import/export (conduit-world). New SchematicIo reads [Sponge Schematic](https://github.com/SpongePowered/Schematic-Specification) files (gzip NBT) from <gameDir>/conduit/schematics/ and bridges them to ArenaSnapshot, plus a /schem subtree (gated on CAP_EDITOR):

• /schem list — list available .schem files.
• /schem paste <name> — paste a schematic at the player's pos1 (else their feet), pushed through the /undo stack. Reports block count, any unknown blocks (pasted as air), and whether block-entity data was dropped.
• /schem save <name> — write the current selection out as a Sponge v3 .schem. Read side covers Sponge v2 (flat root) and v3 (nested Schematic.Blocks); the varint block-index stream (YZX order) is decoded in-house and palette strings resolve via BlockStateParser. Blocks only — block entities, entities and biomes are ignored; air overwrites the destination so a paste matches the source exactly.

VanillaConfigMenu — customizable footer. New open / openTabbed overloads take a Footer (or a doneLabel + onDone shorthand): a primary button whose label/action you choose (e.g. "Start Game"), an optional secondary button beside it (e.g. "Leave Game"), and a large mode that renders both bigger + lower (for results screens). The no-arg form still defaults to a single "Done" button that hides (fully backward compatible).

Universal /lobby leave (conduit-arena) — leaves whatever game lobby the caller is in, routed through a new BaseLobby.leaveHandler the game sets so the leave runs the game's own teardown (eliminate / hub / release instance).

In-game arena editor + custom WorldEdit —

• me.zlex.conduit.editor.WorldEdit (conduit-world): a golden-axe selection wand (left-click → pos1, right-click → pos2, op-gated via the new ConduitPermissions.CAP_EDITOR) + a /cedit command tree (set/walls/replace/copy/paste/undo/pos1/pos2/sel/wand) over the selection, built on Regions, with a per-player clipboard, undo stack, and a particle selection outline.
• ArenaSnapshot (capture/paste a region; BlockState.CODEC JSON) + ArenaStore — named arena presets per game id, persisted under <gameDir>/conduit/arenas/<gameId>/<preset>.json (survives restart), reserved default preset.
• ArenaEditSession (conduit-arena) — op editor sessions: spin up a void edit world, paint the current arena, Creative + wand, capture-and-save a preset, return to hub. _(All of the above will be cut as 0.10.1.)_

VanillaConfigMenu (conduit-render) — declare a title + ordered list of ConfigEntry, pass an onChange callback, call open(); the framework compiles a vanilla-themed screen, routes every control click and text submit, applies the standard mutation, fires the callback, and re-issues the screen. Tabs (openTabbed + ConfigTab), automatic pagination (PAGE_SIZE = 6, [< Prev] Page x/y [Next >]), and a per-(player, screenId) open registry.

ConfigEntry sealed types — Toggle, Cycle, Stepper, Slider, Action, Text, each immutable with typed with* helpers the framework calls for you.

Real sliders — ConfigEntry.Slider + VanillaSliderElement + Widgets.vanillaSlider: a recessed track with a raised handle. Click routing goes through the new positional ServerScreenManager.onButtonAt handler, which carries the click's screen-UV (ButtonClickPayload gained clickU/clickV) so the server resolves the track fraction. Click-to-position (an in-world screen emits a click, not mouse-move), snapped to step.

Stateful vanilla controls — Widgets.vanillaToggle / vanillaCycle / vanillaStepper, the Vanilla*Widget records, and the ScreenLayoutCompiler branches that drive them.

Developer-velocity pass — four reusable primitives so new mini-games stop re-implementing the same scaffolding:

• SafeTeleport now preloads the destination chunks (to ChunkStatus.FULL) before the deferred teleport fires, fixing the "land in darkness / fall through unloaded terrain" stutter that every cross-area teleport hit. New overload teleport(player, level, pos, yaw, pitch, preloadRadius, after) and a public SafeTeleport.preloadChunks(level, pos, radius). Default radius is 1 (3×3 chunks); pass SafeTeleport.NO_PRELOAD to skip.
• conduit-fx Titles — show / actionBar / clear for single players or groups, dedup'ing the three-packet animation→subtitle→title dance every mod hand-rolled. Ticks for timing; sensible defaults.
• conduit-world Regions — axis-aligned box fill / fillHollow / fillWalls / replace. The geometry every prefab-built arena re-wrote; caller still picks the BlockState so the engine stays game-agnostic.
• conduit-core ConduitTest — a solo-testing harness: an op-gated test list / test run <scenario> brigadier subtree (buildCommand), a named-scenario registry (register), and a deterministic fake roster (fakeRoster(n) → "Bot1"…"BotN" with stable, tagged UUIDs) so a whole match can be driven from one client without a full lobby.
• conduit-core GatherRoom — the "assemble everyone, then send them home" lifecycle (meetings, voting rooms, finales): force-loads the room chunks while open, snapshots each player's prior dimension/position, optionally stashes their inventory, and reverses all of it on disperse. Both directions route through SafeTeleport. Geometry stays the caller's job.

RuntimeDimensionSpec data-driven factories: fromStem(stem, seed, persist), fromStemJson(server, json, seed, persist) (decode a LevelStem from JSON via LevelStem.CODEC + registry-aware RegistryOps), and fromDatapackStem(server, stemKey, seed, persist) (reference a datapack-registered dimension).

Persistent runtime worlds in conduit-instance. A persist=true RuntimeDimensionSpec is now recorded to a manifest (<world>/conduit_runtime_dimensions.json, its LevelStem serialized via LevelStem.CODEC + registry-aware RegistryOps) and recreated on the next server start, loading its existing region data. v0.6 silently deleted these on boot.

conduit-instance module — on-demand runtime dimensions. Create a fresh world per match and tear it down when the match ends, instead of claiming from conduit-arena's fixed 8-slot pool.

• RuntimeDimensions.create(server, spec) / .release(server, handle).
• RuntimeDimensionSpec with voidWorld(server) + copyOf(template) builders and a persist flag (default discard-on-release).
• RuntimeDimensionHandle — live handle to a created dimension.
• One accessor mixin (MinecraftServerLevelsAccessor) to reach the server's level map; everything else is public MC API + Fabric events.
• Crash-orphan sweep on SERVER_STARTED + force-release of all active runtime dimensions on SERVER_STOPPING.

v1 supports discard-on-release temp worlds only; persistent runtime worlds (restart recovery) are not yet implemented. Arena's fixed pool is unchanged — migrating it onto this is future work.

Modular split (Phase B.1): the monolithic engine became seven separately-published modules — conduit-core, conduit-render, conduit-world, conduit-spectator, conduit-fx, conduit-prefab, conduit-arena — plus a conduit aggregator BOM.

Per-module ModInitializers (Phase B.2).

PlayerSessionManager (Phase C) — engine-level disconnect snapshots + reconnect routing with a configurable hold window, persisted across restart via SavedData.

Initial stable Minecraft 26.1.2 port of the pre-modular monolithic engine.