feat(worlds): overhaul per-world storage architecture for 26.1

Previously, SpongeWorldManager created a separate LevelStorageAccess per
dimension via createLevelStorageAccess(), with bridge$setDedicated(true)
overriding getDimensionPath() to bypass vanilla's DimensionType.getStorageFolder().
This produced the old DIM-1/DIM1 directory layout with per-dimension level.dat
files containing a SpongeData compound (UUID, key, WeatherState, CustomBossEvents,
WorldOptions). Each dimension had its own session.lock and the SpongeData was
injected into level.dat during saveDataTag() and extracted during
getLevelDataAndDimensions() via bridge$readSpongeLevelData/writeSpongeLevelData.

Now, all dimensions share the server's single LevelStorageAccess. Vanilla's
DimensionType.getStorageFolder() handles path resolution, placing all dimensions
under dimensions/{namespace}/{path}/. Each ServerLevel's ServerChunkCache creates
an independent SavedDataStorage at getDimensionPath(dim)/data/, enabling per-world
data through vanilla's own SavedData mechanism.

Per-world features now use vanilla SavedDataType instances directly:
- WeatherData.TYPE (minecraft:weather) via ServerLevel.getWeatherData() override
- GameRuleMap.TYPE (minecraft:game_rules) via ServerLevel.getGameRules() override
- CustomBossEvents.TYPE via bridge$getBossBarManager() using per-dim storage
- WorldBorder already per-dimension in vanilla 26.1 (no override needed)

Sponge-specific identity (UUID, ResourceKey) is stored as SpongeRegistryData,
a custom SavedData at data/sponge/registry.dat per dimension. Global map/player
UUID indices are stored as SpongeMapUUIDData at data/sponge/map_uuids.dat in
the server-level SavedDataStorage.

level.dat no longer contains any SpongeData — it is pure vanilla format.
The SpongeData injection in LevelStorageSource_LevelStorageAccessMixin and
the read hooks in LevelStorageSourceMixin_Vanilla and PrimaryLevelDataMixin
are removed.

Migration from old Sponge format is handled by FileFixerUpperMixin, which
hooks into FileFixerUpper.fix() at HEAD to extract UUIDs from SpongeData in
level.dat and DIM-1/DIM1 level.dat files before vanilla's DimensionStorageFileFix
deletes those directories. Legacy SavedData files (random_sequences.dat, etc.)
left behind by vanilla's fixer are moved to the correct namespaced paths and
the old directories are cleaned up. Extracted identities are cached in
SpongeLevelMigration (static volatile, cross-thread from main to Server thread)
and written to per-dimension registry.dat during MinecraftServer.loadLevel()
HEAD inject, before any ServerLevel is created.

Additional fixes:
- SavedDataStorageMixin.readSpongeMapData() was returning null unconditionally,
  breaking ALL SavedData persistence (return null -> return result)
- Weather hasCeiling() logic in advanceWeatherCycle was inverted, preventing
  weather visual effects in overworld-type dimensions
- DedicatedServerMixin constructor signature updated for new Optional<GameRules>
  parameter in 26.1-snapshot-6

Signed-off-by: Gabriel Harris-Rouquette <[email protected]>

Author: gabizou

src/accessors/java/org/spongepowered/common/accessor/server/bossevents/CustomBossEventsAccessor.java

@@ -1,3 +1,27 @@
+/*
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * Copyright (c) contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
 package org.spongepowered.common.accessor.server.bossevents;
 
 import com.mojang.serialization.Codec;

src/accessors/java/org/spongepowered/common/accessor/world/entity/npc/wanderingtrader/WanderingTraderSpawnerAccessor.java

@@ -28,7 +28,6 @@
 import net.minecraft.world.level.saveddata.WanderingTraderData;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.gen.Invoker;
-import org.spongepowered.common.UntransformedInvokerError;
 
 @Mixin(WanderingTraderSpawner.class)
 public interface WanderingTraderSpawnerAccessor {

src/main/java/org/spongepowered/common/bridge/world/level/storage/LevelStorageAccessBridge.java

@@ -25,10 +25,7 @@
 package org.spongepowered.common.bridge.world.level.storage;
 
 import com.google.common.collect.BiMap;
-import com.mojang.serialization.Dynamic;
 import net.kyori.adventure.text.Component;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
 import net.minecraft.world.Difficulty;
 import net.minecraft.world.level.dimension.DimensionType;
 import net.minecraft.world.level.dimension.LevelStem;
@@ -67,8 +64,4 @@ public interface PrimaryLevelDataBridge extends ServerLevelDataBridge {
     void bridge$hardcore(boolean hardcore);
 
     void bridge$allowCommands(boolean commands);
-
-    void bridge$readSpongeLevelData(Dynamic<Tag> impl$spongeLevelData);
-
-    CompoundTag bridge$writeSpongeLevelData();
 }

src/main/java/org/spongepowered/common/bridge/world/level/storage/PrimaryLevelDataBridge.java

@@ -35,9 +35,9 @@
 import org.spongepowered.api.world.DefaultWorldKeys;
 import org.spongepowered.common.SpongeCommon;
 import org.spongepowered.common.accessor.world.level.saveddata.maps.MapIndexAccessor;
-import org.spongepowered.common.bridge.world.level.storage.PrimaryLevelDataBridge;
 import org.spongepowered.common.event.SpongeCommonEventFactory;
 import org.spongepowered.common.event.tracking.PhaseTracker;
+import org.spongepowered.common.world.server.SpongeMapUUIDData;
 
 import java.util.Collection;
 import java.util.HashMap;
@@ -120,7 +120,8 @@ public void addMapInfo(final MapInfo mapInfo) {
 
     private void ensureHasMapUUIDIndex() {
         if (this.mapIdUUIDIndex == null) {
-            this.mapIdUUIDIndex = ((PrimaryLevelDataBridge) Sponge.server().worldManager().world(DefaultWorldKeys.DEFAULT).get().properties()).bridge$getMapUUIDIndex();
+            this.mapIdUUIDIndex = SpongeCommon.server().getDataStorage()
+                .computeIfAbsent(SpongeMapUUIDData.TYPE).mapUUIDIndex();
         }
     }
 }

src/main/java/org/spongepowered/common/map/SpongeMapStorage.java

@@ -0,0 +1,162 @@
+/*
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * Copyright (c) contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.spongepowered.common.world.server;
+
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NbtIo;
+import net.minecraft.nbt.NbtOps;
+import net.minecraft.nbt.NbtUtils;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.dimension.DimensionType;
+import org.checkerframework.checker.nullness.qual.Nullable;
+import org.spongepowered.common.SpongeCommon;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Map;
+import java.util.Optional;
+import java.util.UUID;
+
+/**
+ * Handles migration of old Sponge world data (UUID, key) from the pre-26.1 format
+ * to the new per-dimension {@link SpongeRegistryData} SavedData format.
+ *
+ * <p>The migration flow is:</p>
+ * <ol>
+ *   <li>{@code FileFixerUpperMixin} extracts UUIDs from old {@code SpongeData} in level.dat
+ *       and per-dimension level.dat files BEFORE vanilla's file fixer rewrites them.</li>
+ *   <li>Cached identities are stored via {@link #cacheIdentities(Map)}.</li>
+ *   <li>{@code MinecraftServerMixin.loadLevel()} calls {@link #writeCachedRegistryData(Path)}
+ *       AFTER the file fix completes but BEFORE any ServerLevel is created.</li>
+ * </ol>
+ */
+public final class SpongeLevelMigration {
+
+    // Static fields (not ThreadLocal) because fix() runs on "main" thread
+    // but loadLevel() runs on "Server thread".
+    private static volatile @Nullable Map<ResourceKey<Level>, UUID> cachedIdentities;
+    private static volatile @Nullable CompoundTag cachedGlobalSpongeData;
+
+    private SpongeLevelMigration() {
+    }
+
+    public static void cacheIdentities(final Map<ResourceKey<Level>, UUID> identities) {
+        cachedIdentities = identities;
+    }
+
+    public static void cacheGlobalSpongeData(final CompoundTag spongeData) {
+        cachedGlobalSpongeData = spongeData;
+    }
+
+    /**
+     * Writes cached migrated identities to per-dimension {@code data/sponge/registry.dat} files.
+     * Must be called AFTER FileFixerUpper.fix() completes (directory structure is final)
+     * and BEFORE any ServerLevel is created (so SavedDataStorage finds files on disk).
+     */
+    public static void writeCachedRegistryData(final Path worldDir) {
+        final @Nullable Map<ResourceKey<Level>, UUID> identities = cachedIdentities;
+        if (identities == null || identities.isEmpty()) {
+            cachedIdentities = null;
+            return;
+        }
+        cachedIdentities = null;
+
+        for (final var entry : identities.entrySet()) {
+            final ResourceKey<Level> dimKey = entry.getKey();
+            final UUID uuid = entry.getValue();
+            try {
+                final Path dimDir = DimensionType.getStorageFolder(dimKey, worldDir);
+                final Path dataDir = dimDir.resolve("data").resolve("sponge");
+                final Path registryFile = dataDir.resolve("registry.dat");
+                if (Files.exists(registryFile)) {
+                    continue;
+                }
+                Files.createDirectories(dataDir);
+                final SpongeRegistryData registryData = new SpongeRegistryData(uuid, Optional.of(dimKey));
+                final var encoded = SpongeRegistryData.CODEC.encodeStart(NbtOps.INSTANCE, registryData);
+                if (encoded.isSuccess()) {
+                    final CompoundTag savedDataTag = new CompoundTag();
+                    savedDataTag.put("data", encoded.getOrThrow());
+                    NbtUtils.addCurrentDataVersion(savedDataTag);
+                    NbtIo.writeCompressed(savedDataTag, registryFile);
+                    SpongeCommon.logger().info("[Sponge]   Wrote migrated {} UUID {} -> {}", dimKey.identifier(), uuid, registryFile);
+                }
+            } catch (final IOException e) {
+                SpongeCommon.logger().warn("[Sponge]   Failed to write registry.dat for {}", dimKey.identifier(), e);
+            }
+        }
+
+        // Write global Sponge data (MapUUIDs, player-uuid-table) to server-level SavedData
+        writeGlobalSpongeData(worldDir);
+    }
+
+    private static void writeGlobalSpongeData(final Path worldDir) {
+        final @Nullable CompoundTag spongeData = cachedGlobalSpongeData;
+        cachedGlobalSpongeData = null;
+        if (spongeData == null) {
+            return;
+        }
+
+        final Path dataDir = worldDir.resolve("data").resolve("sponge");
+        final Path mapUUIDFile = dataDir.resolve("map_uuids.dat");
+        if (Files.exists(mapUUIDFile)) {
+            return; // Already migrated
+        }
+
+        // Extract MapUUIDs and player-uuid-table from old SpongeData
+        final var mapUUIDs = spongeData.getCompound("MapUUIDs").orElse(null);
+        final var playerTable = spongeData.getList("player-uuid-table").orElse(null);
+
+        // Only write if there's actual data to migrate
+        final boolean hasMapData = mapUUIDs != null && !mapUUIDs.isEmpty();
+        final boolean hasPlayerData = playerTable != null && !playerTable.isEmpty();
+        if (!hasMapData && !hasPlayerData) {
+            return;
+        }
+
+        try {
+            Files.createDirectories(dataDir);
+            // Write as a raw compound since the old format doesn't match the new codec exactly.
+            // The SpongeMapUUIDData.CODEC will read the proper format; here we just preserve the raw data
+            // for potential manual migration. The new SavedData will be created fresh on first access.
+            final CompoundTag savedDataTag = new CompoundTag();
+            final CompoundTag data = new CompoundTag();
+            if (hasMapData) {
+                data.put("legacy_map_uuids", mapUUIDs);
+            }
+            if (hasPlayerData) {
+                data.put("legacy_player_uuids", playerTable);
+            }
+            savedDataTag.put("data", data);
+            NbtUtils.addCurrentDataVersion(savedDataTag);
+            NbtIo.writeCompressed(savedDataTag, mapUUIDFile);
+            SpongeCommon.logger().info("[Sponge]   Preserved global MapUUIDs/player-uuid-table -> {}", mapUUIDFile);
+        } catch (final IOException e) {
+            SpongeCommon.logger().warn("[Sponge]   Failed to write global Sponge data", e);
+        }
+    }
+}

src/main/java/org/spongepowered/common/world/server/SpongeLevelMigration.java

@@ -0,0 +1,92 @@
+/*
+ * This file is part of Sponge, licensed under the MIT License (MIT).
+ *
+ * Copyright (c) SpongePowered <https://www.spongepowered.org>
+ * Copyright (c) contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ */
+package org.spongepowered.common.world.server;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import net.minecraft.core.UUIDUtil;
+import net.minecraft.resources.Identifier;
+import net.minecraft.util.datafix.DataFixTypes;
+import net.minecraft.world.level.saveddata.SavedData;
+import net.minecraft.world.level.saveddata.SavedDataType;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * Stores Sponge's map ID → UUID index and player UUID table as server-global SavedData.
+ * Previously stored in {@code SpongeData} within {@code level.dat}.
+ *
+ * <p>Persisted at {@code data/sponge/map_uuids.dat} in the server-level data directory.</p>
+ */
+public final class SpongeMapUUIDData extends SavedData {
+
+    private static final Codec<Map<Integer, UUID>> MAP_INDEX_CODEC =
+        Codec.unboundedMap(Codec.INT, UUIDUtil.CODEC);
+
+    public static final Codec<SpongeMapUUIDData> CODEC = RecordCodecBuilder.create(
+        i -> i.group(
+                MAP_INDEX_CODEC.optionalFieldOf("map_uuids", Map.of()).forGetter(SpongeMapUUIDData::mapIndex),
+                MAP_INDEX_CODEC.optionalFieldOf("player_uuids", Map.of()).forGetter(SpongeMapUUIDData::playerIndex)
+            )
+            .apply(i, SpongeMapUUIDData::new)
+    );
+
+    public static final SavedDataType<SpongeMapUUIDData> TYPE = new SavedDataType<>(
+        Identifier.fromNamespaceAndPath("sponge", "map_uuids"), SpongeMapUUIDData::new, CODEC, DataFixTypes.LEVEL
+    );
+
+    private final BiMap<Integer, UUID> mapUUIDIndex;
+    private final BiMap<Integer, UUID> playerUUIDIndex;
+
+    public SpongeMapUUIDData() {
+        this.mapUUIDIndex = HashBiMap.create();
+        this.playerUUIDIndex = HashBiMap.create();
+    }
+
+    public SpongeMapUUIDData(final Map<Integer, UUID> mapIndex, final Map<Integer, UUID> playerIndex) {
+        this.mapUUIDIndex = HashBiMap.create(mapIndex);
+        this.playerUUIDIndex = HashBiMap.create(playerIndex);
+    }
+
+    private Map<Integer, UUID> mapIndex() {
+        return new HashMap<>(this.mapUUIDIndex);
+    }
+
+    private Map<Integer, UUID> playerIndex() {
+        return new HashMap<>(this.playerUUIDIndex);
+    }
+
+    public BiMap<Integer, UUID> mapUUIDIndex() {
+        return this.mapUUIDIndex;
+    }
+
+    public BiMap<Integer, UUID> playerUUIDIndex() {
+        return this.playerUUIDIndex;
+    }
+}