Render authored Descriptive Books and persist random Age seasons (#40)

README.md

@@ -32,6 +32,12 @@ Biome pages, with cave and Nether biomes in a separate Cave Biome creative tab.
 TerraBlender Overworld/Nether regions extend compatible Age
 biome pools. See [the compatibility matrix](docs/TERRABLENDER_COMPATIBILITY.md)
 for supported versions and in-game verification.
+Serene Seasons 1.21.1 can maintain separate season progress in an Age dimension.
+Rivencraft automatically whitelists loaded Ages without a restart when Serene is installed;
+season pages can instead opt an Age out or hold it in one season.
+See [the optional compatibility guide](docs/SERENE_SEASONS_COMPATIBILITY.md)
+for the supported manual configuration and current limits; Rivencraft does not
+require Serene Seasons or GlitchCore.
 The Writing Desk can copy a selected written page from its collection tabs.
 The Writing Desk is now craftable from planks, a glass bottle, and a feather.
 It occupies two adjacent blocks, with one shared inventory; loaded paper and

build.gradle

@@ -248,6 +248,14 @@ dependencies {
     if (providers.gradleProperty('withTerraBlender').map { it.toBoolean() }.orElse(false).get()) {
         localRuntime "com.github.glitchfiend:TerraBlender-neoforge:${minecraft_version}-${terrablender_version}"
     }
+    // The optional compatibility adapter uses Serene's dimension config API.
+    // Neither mod is a required dependency of the published Rivencraft jar.
+    compileOnly "maven.modrinth:e0bNACJD:${serene_seasons_version_id}"
+    compileOnly "maven.modrinth:s3dmwKy5:${glitchcore_version_id}"
+    if (providers.gradleProperty('withSereneSeasons').map { it.toBoolean() }.orElse(false).get()) {
+        localRuntime "maven.modrinth:e0bNACJD:${serene_seasons_version_id}"
+        localRuntime "maven.modrinth:s3dmwKy5:${glitchcore_version_id}"
+    }
     implementation "curse.maven:dynamicdimension-ar-edition-1469680:${dynamic_dimensions_file_id}"
     implementation "lol.bai:badpackets:neo-${badpackets_version}"
     // JEI integration is isolated in its plugin and absent from the published runtime dependencies.

docs/DESCRIPTIVE_BOOK_PRESENTATION.md

@@ -0,0 +1,16 @@
+# Descriptive Book presentation (Milestone 5, issue #40)
+
+The Legacy-style front spread has the Age name and author on the left and the destination panel on the right. The reference screenshots are `dev images/Pasted image.png` (front spread) and `dev images/Pasted image (2).png` (single-symbol spread). An authored book shows one full-size composed symbol on each turned right page, in the order stored in `BOOK_WRITING`; the former plain-text name and symbol ID are not shown for resolved pages. The last authored symbol is the last normal page, not a blank trailing page.
+
+The Binder records the taking player's name on the finished book; direct Age binding also records the binding player. Older books without this component display `Unknown author` rather than attributing them to whoever happens to open them. Link-Panel-only and older page-free books retain their random-Age glyph details and destination preview. On authored books, hovering the front-page name exposes the existing trait summary without filling the left page with text.
+
+The server resolves symbol display metadata from its current catalog and sends advisory grammar diagnostics with the book-opening payload. A missing data-pack symbol draws the unresolved page artwork and its original ID. An affected page displays a red `!` with the server's diagnostic on hover; separate writing-note pages show all diagnostics, including incomplete branches that the Age compiler filled. These UI notices do not alter or recompile the persisted Age plan. Symbol pages use the same bounded, runtime glyph composition as Page items and do not require Create, Ponder, or Immersive Portals.
+
+## Manual visual and behavior checks
+
+1. Bind a Descriptive Book with two distinct symbol pages. Open it: the front spread shows its Age name, your player name, and the link panel. Turn twice and confirm exactly one large symbol on each right page, in authored order, with no plain-text symbol description or blank trailing page.
+2. Hover the front-page name to confirm the trait summary remains accessible. Click the link panel to confirm normal travel; repeat from a lectern to check the name, panel, and page-turn layout.
+3. Open a Link-Panel-only book and confirm its existing random-Age details and destination preview still appear.
+4. In a copy of a test world, remove a data pack that supplied one authored symbol. Reopen the book: its original symbol ID should remain readable beside the unresolved artwork, and the writing notes should explain the missing definition. Restore the pack and verify the page artwork returns without changing the saved Age.
+
+`./gradlew build --offline` verifies compilation and jar assembly. The visual and data-pack-removal checks require an in-game client.

docs/GAMETESTS.md

@@ -47,6 +47,11 @@ automated check, and hand its exact scenario to the player for in-game
 verification. Do not keep retrying a stalled test or leave its process running.
 Keep the narrower non-stalling plan, persistence, and runtime checks automated.
 
+The optional `-PwithSereneSeasons=true` runtime is for a real dev client, not
+the GameTest server: Serene Seasons sends a season payload to GameTest mock
+players, which cannot negotiate its channel. Follow the real-client Serene test in
+`docs/SERENE_SEASONS_COMPATIBILITY.md` instead.
+
 ## Manual Ink Mixer modifier check (Milestone 5, issue #36)
 
 With optional JEI installed, search for the Ink Mixer category. It should show

docs/SERENE_SEASONS_COMPATIBILITY.md

@@ -0,0 +1,49 @@
+# Serene Seasons 1.21.1: automatic Age whitelist (issue #38)
+
+Serene Seasons has a [NeoForge 1.21.1 release, 10.1.0.8](https://modrinth.com/mod/serene-seasons/version/B6nTjh4b), with GlitchCore required ([2.1.0.2 for NeoForge 1.21.1](https://modrinth.com/mod/glitchcore/version/S2TfWrZR)). Its [1.21.1 source](https://github.com/Glitchfiend/SereneSeasons/tree/1.21.1) shows that each `ServerLevel` gets its own `SeasonSavedData` in that dimension's data storage. Season progress is keyed to the level's day time and saved separately, so an enabled Rivencraft Age can have a season independent of the Overworld and other Ages. The public [`SeasonHelper`](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/api/season/SeasonHelper.java) can read a level's current season; it does not provide a method to register a dimension or set its season.
+
+The activation point is Serene Seasons' [`dimension_settings.whitelisted_dimensions`](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/config/SeasonsConfig.java). Its default contains only `minecraft:overworld`. On the server, GlitchCore [reloads and synchronizes](https://github.com/Glitchfiend/GlitchCore/blob/1.21.1/common/src/main/java/glitchcore/config/ConfigSync.java) this config when a player connects. Rivencraft adds successfully loaded Age IDs to Serene's in-memory list **and** its saved config so later logins retain them. Rivencraft also sends each newly added ID to players already connected. No restart is needed for a newly generated Age.
+
+Serene Seasons 10.1.0.8 has no public dynamic-dimension registration hook, so the adapter uses its config object and GlitchCore's config writer directly. This is version-sensitive: verify this path when upgrading either mod. Rivencraft checks that Serene is installed before loading the adapter; neither dependency is required to run Rivencraft.
+
+## Real-client test path
+
+1. Install matching NeoForge 1.21.1 builds of Serene Seasons and GlitchCore on the server and client. Keep Rivencraft's `Weather: Normal` for this first test, so its own fixed/accelerated weather controller does not compete with seasonal weather timing.
+2. While the client stays connected, create an Age. Run `/rivencraft age list` as an operator and note its ID (for example `rivencraft:age/winter_garden`). Confirm this ID appeared in `config/sereneseasons/seasons.toml` under `dimension_settings.whitelisted_dimensions`, with existing entries intact.
+3. Without restarting or reconnecting, travel into the Age and check `/season get`; change its season with `/season set mid_winter` and check the Overworld and another Age separately.
+4. Reconnect another client and confirm it receives the same whitelist. Restart the server and confirm both the whitelist entry and the Age's season persisted.
+5. Build separate Ages with No Seasons, Seasons, and each Eternal page. Confirm No Seasons stays absent from Serene's whitelist, Seasons advances, and each Eternal Age remains in its named mid-season across several in-game days, a reconnect, and a server restart. Verify the Overworld still advances normally. The Eternal page should not stop the Age's sun or moon. With Serene removed, No Seasons should still bind, but the other five pages should refuse to bind with a clear message.
+6. With Serene installed and `auto_whitelist_ages=true`, create several new Link-Panel-only Ages and Ages with symbols but no season page. `/rivencraft age list` shows each saved random `season:` choice. Check that No Seasons is absent from Serene's whitelist, Seasons advances, and each Eternal choice holds its season. Reopen the world and confirm the listed choices do not change. Without Serene, create another unpaged Age and confirm the list has no saved season choice for it.
+
+For a local development run, `./gradlew runClient -PwithSereneSeasons=true` adds these two mods only to that run. The published Rivencraft jar does not include or require them.
+
+The server config `rivencraft-server.toml` has `serene_seasons.auto_whitelist_ages=true` by default. Set it to `false` to manage Serene's whitelist manually. Disabling it does not delete Age IDs previously added to Serene's config. On startup, Rivencraft also enrolls existing Ages that successfully load, so installing Serene after creating Ages does not require editing IDs one by one.
+
+## Seasonal pages
+
+An Age may specify one of six mutually exclusive seasonal modes:
+
+| Page | Intended Age behavior |
+| --- | --- |
+| No Seasons | Opt this Age out of seasonal effects and progression. |
+| Seasons | Run the optional season mod's normal cycle, independently of the Overworld. |
+| Eternal Winter | Hold this Age in winter. |
+| Eternal Summer | Hold this Age in summer. |
+| Eternal Fall | Hold this Age in fall/autumn. |
+| Eternal Spring | Hold this Age in spring. |
+
+The six pages are available in the Season creative tab and the same page feed used by JEI. The writing grammar accepts at most one seasonal page, and its choice is saved in the Age plan. No Seasons removes that Age's ID from Serene's whitelist, even if it was previously enrolled; the other explicit pages enroll it regardless of the automatic-enrollment setting. When a **new** Age has no season page and Serene Seasons is installed, Rivencraft chooses one of these six modes from the Age seed and saves that choice in the Age definition. A Link-Panel-only random Age is included. The choice does not change on reload or when the spawn moves. If Serene is absent at creation, no random seasonal modifier is assigned. Older Ages without a stored choice keep their previous normal-cycle behavior. The server's `auto_whitelist_ages=false` setting still prevents implicit (unpaged) modes other than No Seasons from enrolling the Age; explicit seasonal pages override it. If Serene Seasons is absent, No Seasons remains valid, but the other five pages reject **new** Age creation with a missing-dependency message rather than silently doing nothing. Existing Ages remain loadable with their saved pages, though their season effects are inactive until a supported season mod returns. Ecliptic Seasons integration was closed as unsupported for dynamic Ages in issue #39.
+
+For an eternal mode, Rivencraft sets Serene's per-Age saved clock to the midpoint of the chosen season and resets it before it leaves that mid-season. Clients receive Serene's normal season sync. This does not freeze the Age's day/night cycle or change the Overworld's season. Eternal Winter does not guarantee snow in every biome.
+
+## Current limits
+
+- The Serene adapter uses Serene's internal saved season state because there is no public per-dimension season-freeze API. The real-client behavior above, including each eternal mode and No Seasons, still needs player verification. Serene's [temperature and precipitation hooks](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHooks.java) only cool eligible biomes.
+- Serene Seasons' [season tick](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHandler.java) advances from a dimension's day-time changes. A Rivencraft Age with a stopped celestial cycle may also have a stopped season; this needs an in-game check.
+- Rivencraft's non-Normal weather modes currently control weather in each Age independently. Their timing can conflict with Serene Seasons' weather-frequency changes. Ecliptic Seasons integration remains issue #39; simultaneous installation is not a supported target.
+
+## Verification so far
+
+`./gradlew build` passed for candidate 0.4.9.2, and the baseline plus archived environment GameTests passed (35 required tests). The archive now covers seasonal page visibility, exclusivity, and saved-plan persistence without Serene installed. With Serene Seasons 10.1.0.8 and GlitchCore 2.1.0.2 in the optional local runtime, the GameTest server previously crashed when Serene Seasons sent `sereneseasons:sync_season_cycle` to a GameTest mock player that had not negotiated its client payload channel. The stack trace originates in Serene Seasons' `SeasonHandler.sendSeasonUpdate`, through GlitchCore's packet handler and NeoForge's packet check. This is a GameTest mock-network limitation, not a completed absent/present compatibility check. Do not keep rerunning that suite with Serene Seasons; use the real-client test path above instead.
+
+For candidate 0.4.10.1, `./gradlew build --offline` and the focused environment archive passed (36 required GameTests). The new regression check covers omitted-page selection, explicit-page precedence, no-Serene behavior, and save/reload. Actual Serene weather, whitelisting, and eternal-season visuals still require the real-client steps above.

gradle.properties

@@ -36,9 +36,11 @@ mod_name=Rivencraft
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=LGPL-3.0-or-later
 # The mod version. Rivencraft uses the x.y.z.b policy documented in README.md.
-mod_version=0.4.8.1
+mod_version=0.4.10.1
 immersive_portals_version=6.0.7
 terrablender_version=4.1.0.8
+serene_seasons_version_id=B6nTjh4b
+glitchcore_version_id=S2TfWrZR
 # The group ID for the mod. It is only important when publishing as an artifact to a Maven repository.
 # This should match the base package used for the mod sources.
 # See https://maven.apache.org/guides/mini/guide-naming-conventions.html

src/main/java/net/dnorberg/rivencraft/Rivencraft.java

@@ -18,6 +18,7 @@ import net.dnorberg.rivencraft.command.RivencraftCommands;
 import net.dnorberg.rivencraft.network.ModNetworking;
 import net.dnorberg.rivencraft.config.RivencraftConfig;
 import net.dnorberg.rivencraft.config.RivencraftClientConfig;
+import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeWeatherService;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
@@ -51,6 +52,7 @@ public final class Rivencraft {
         ModCreativeTabs.register(modEventBus);
         NeoForge.EVENT_BUS.addListener(BookStandConversionHandler::onRightClickBlock);
         NeoForge.EVENT_BUS.addListener(AgeWeatherService::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(SereneSeasonsCompatibility::onLevelTickPost);
         NeoForge.EVENT_BUS.addListener(AgeCelestialAngleSync::onPlayerLoggedIn);
         NeoForge.EVENT_BUS.addListener(AgeCelestialAngleSync::onPlayerChangedDimension);
         NeoForge.EVENT_BUS.addListener(AgeLifecycleEvents::onPlayerLoggedOut);

src/main/java/net/dnorberg/rivencraft/book/AgeDefinition.java

@@ -5,6 +5,7 @@ import java.util.UUID;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.core.BlockPos;
 import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
 
 /** Immutable, server-owned generation definition for one Age. */
 public record AgeDefinition(
@@ -17,7 +18,8 @@ public record AgeDefinition(
         ResourceLocation dimensionId,
         BlockPos spawn,
         AgeTraits traits,
-        AgeGenerationPlan plan
+        AgeGenerationPlan plan,
+        @Nullable AgeSeasonMode seasonMode
 ) {
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
@@ -39,7 +41,14 @@ public record AgeDefinition(
                          int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                          BlockPos spawn, AgeTraits traits) {
         this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, null);
+                dimensionId, spawn, traits, null, null);
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, null);
     }
 
     public static ResourceLocation dimensionId(UUID ageId) {
@@ -70,6 +79,6 @@ public record AgeDefinition(
 
     public AgeDefinition withSpawn(BlockPos spawn) {
         return new AgeDefinition(id, name, seed, generationProfile, generationVersion,
-                createdGameTime, dimensionId, spawn.immutable(), traits, plan);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode);
     }
 }

src/main/java/net/dnorberg/rivencraft/book/AgeDimensionService.java

@@ -14,6 +14,7 @@ import java.util.Comparator;
 import java.util.Random;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.compat.ImmersivePortalsChunkLoaders;
+import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.GlobalPos;
@@ -74,6 +75,7 @@ public final class AgeDimensionService {
                 );
                 if (level != null) {
                     applyCelestialClock(level, age);
+                    SereneSeasonsCompatibility.registerAge(server, age);
                 }
             }
             synchronizeImmersivePortals(server);
@@ -110,6 +112,7 @@ public final class AgeDimensionService {
         ServerLevel existing = server.getLevel(key);
         if (existing != null) {
             applyCelestialClock(existing, definition);
+            SereneSeasonsCompatibility.registerAge(server, definition);
             return existing;
         }
 
@@ -125,6 +128,7 @@ public final class AgeDimensionService {
             Rivencraft.LOGGER.error("Failed to load Age {} as {}", definition.id(), definition.dimensionId());
         } else {
             applyCelestialClock(loaded, definition);
+            SereneSeasonsCompatibility.registerAge(server, definition);
             synchronizeImmersivePortals(server);
         }
         return loaded;

src/main/java/net/dnorberg/rivencraft/book/AgeGenerationPlan.java

@@ -71,6 +71,7 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
                         symbol.index(), symbol.reference(), symbol.semantics())).toList(),
                 profile, biomes);
         AgeEnvironmentCompiler.apply(plan, traits);
+        AgeSeasonMode.validate(plan);
         return plan;
     }
 

src/main/java/net/dnorberg/rivencraft/book/AgeRegistrySavedData.java

@@ -15,6 +15,7 @@ import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.datafix.DataFixTypes;
 import net.minecraft.world.level.saveddata.SavedData;
+import net.neoforged.fml.ModList;
 
 /** Server-wide persistent mapping from stable book UUIDs to immutable Age definitions. */
 public final class AgeRegistrySavedData extends SavedData {
@@ -32,6 +33,7 @@ public final class AgeRegistrySavedData extends SavedData {
     private static final String SPAWN_Z_TAG = "SpawnZ";
     private static final String TRAITS_TAG = "Traits";
     private static final String PLAN_TAG = "GenerationPlan";
+    private static final String SEASON_MODE_TAG = "SeasonMode";
     private static final String BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
     private static final String LIGHTING_TAG = "Lighting";
     private static final String WEATHER_TAG = "Weather";
@@ -130,7 +132,8 @@ public final class AgeRegistrySavedData extends SavedData {
                 dimensionId,
                 null,
                 AgeEnvironmentCompiler.apply(plan, traits),
-                plan
+                plan,
+                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons"))
         );
         ages.put(created.id(), created);
         setDirty();
@@ -174,7 +177,9 @@ public final class AgeRegistrySavedData extends SavedData {
                     spawn,
                     readTraits(entry),
                     entry.contains(PLAN_TAG, CompoundTag.TAG_COMPOUND)
-                            ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null
+                            ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null,
+                    entry.contains(SEASON_MODE_TAG, CompoundTag.TAG_STRING)
+                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null
             ));
         }
         return data;
@@ -208,6 +213,7 @@ public final class AgeRegistrySavedData extends SavedData {
                     traits.putFloat(CELESTIAL_PHASE_TAG, age.traits().celestialPhase());
                     entry.put(TRAITS_TAG, traits);
                     if (age.plan() != null) entry.put(PLAN_TAG, age.plan().save());
+                    if (age.seasonMode() != null) entry.putString(SEASON_MODE_TAG, age.seasonMode().name());
                     serializedAges.add(entry);
                 });
         tag.put(AGES_TAG, serializedAges);

src/main/java/net/dnorberg/rivencraft/book/AgeSeasonMode.java

@@ -0,0 +1,63 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.Locale;
+import java.util.Random;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.neoforged.fml.ModList;
+
+/** One authored or seed-selected season policy per Age. */
+public enum AgeSeasonMode {
+    NO_SEASONS,
+    SEASONS,
+    ETERNAL_WINTER,
+    ETERNAL_SUMMER,
+    ETERNAL_FALL,
+    ETERNAL_SPRING;
+
+    private static final long RANDOM_SALT = 0x5E45_0A5E_5EED_21L;
+
+    /** An omitted page is selected once when an Age is created with Serene installed. */
+    public static AgeSeasonMode select(AgeGenerationPlan plan, long ageSeed, boolean sereneInstalled) {
+        if (hasAuthoredPage(plan)) return from(plan);
+        return sereneInstalled ? values()[new Random(ageSeed ^ RANDOM_SALT).nextInt(values().length)] : null;
+    }
+
+    /** Existing Ages without a stored choice retain their old cycling behavior. */
+    public static AgeSeasonMode from(AgeDefinition age) {
+        return age.seasonMode() == null ? from(age.plan()) : age.seasonMode();
+    }
+
+    public static boolean hasAuthoredPage(AgeGenerationPlan plan) {
+        return plan != null && plan.symbols().stream()
+                .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON);
+    }
+
+    public static AgeSeasonMode parseOrNull(String value) {
+        try {
+            return valueOf(value);
+        } catch (IllegalArgumentException exception) {
+            return null;
+        }
+    }
+
+    public static AgeSeasonMode from(AgeGenerationPlan plan) {
+        if (plan == null) return SEASONS;
+        return plan.symbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON)
+                .map(symbol -> valueOf(((SymbolSemantics.ChoiceValue) symbol.semantics().value())
+                        .id().toUpperCase(Locale.ROOT)))
+                .findFirst().orElse(SEASONS);
+    }
+
+    public static void validate(AgeGenerationPlan plan) {
+        if (plan == null) return;
+        if (hasAuthoredPage(plan) && from(plan) != NO_SEASONS
+                && !ModList.get().isLoaded("sereneseasons")) {
+            throw new IllegalArgumentException("This seasonal page requires Serene Seasons to create the Age");
+        }
+    }
+
+    public boolean eternal() {
+        return this != NO_SEASONS && this != SEASONS;
+    }
+}

src/main/java/net/dnorberg/rivencraft/book/EnvironmentWritingGameTests.java

@@ -10,8 +10,12 @@ import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
 import net.neoforged.neoforge.gametest.GameTestHolder;
@@ -51,6 +55,8 @@ public final class EnvironmentWritingGameTests {
                 "sky/overworld", "sky/nether", "sky/end",
                 "weather/normal", "weather/fast", "weather/slow", "weather/off",
                 "weather/always", "weather/storm", "celestial/normal_time",
+                "season/no_seasons", "season/seasons", "season/eternal_winter",
+                "season/eternal_summer", "season/eternal_fall", "season/eternal_spring",
                 "period/zero", "period/half", "period/full", "period/double",
                 "phase/nadir", "phase/rising", "phase/zenith", "phase/setting");
         Set<String> creative = PageItem.creativeSymbolPages(helper.getLevel().registryAccess()).stream()
@@ -73,6 +79,60 @@ public final class EnvironmentWritingGameTests {
         helper.succeed();
     }
 
+    @GameTest(template = "empty")
+    public static void seasonalPagesAreExclusiveAndPersist(GameTestHelper helper) {
+        OrderedWriting noSeasons = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(), page("season/no_seasons")));
+        var plan = AgeGenerationPlan.compile(noSeasons, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeSeasonMode.from(plan), AgeSeasonMode.NO_SEASONS,
+                "No Seasons must compile without an installed season mod");
+        helper.assertValueEqual(AgeSeasonMode.from(AgeGenerationPlan.load(plan.save())),
+                AgeSeasonMode.NO_SEASONS, "The Age's seasonal policy must survive reload");
+        OrderedWriting conflict = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                page("season/no_seasons"), page("season/eternal_winter")));
+        helper.assertFalse(WritingGrammar.parse(conflict).canCreate(),
+                "Only one seasonal page may be used in an Age");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void omittedSeasonPageSelectsOnlyWhenSereneIsPresent(GameTestHelper helper) {
+        helper.assertTrue(AgeSeasonMode.select(null, 42L, false) == null,
+                "An Age made without Serene must not receive a random seasonal modifier");
+        AgeSeasonMode selected = AgeSeasonMode.select(null, 42L, true);
+        helper.assertValueEqual(selected, AgeSeasonMode.select(null, 42L, true),
+                "The same Age seed must select the same seasonal modifier");
+        helper.assertTrue(selected != null, "Serene must select a mode when no season page is authored");
+        AgeDefinition age = new AgeDefinition(UUID.randomUUID(), "Season Test", 42L,
+                AgeGenerationProfiles.STANDARD, AgeDefinition.CURRENT_GENERATION_VERSION, 0L,
+                AgeDefinition.dimensionId(UUID.randomUUID()), null, AgeTraits.select(42L), null, selected);
+        helper.assertValueEqual(AgeSeasonMode.from(age.withSpawn(BlockPos.ZERO)), selected,
+                "Updating an Age spawn must preserve the chosen seasonal modifier");
+        OrderedWriting explicit = new OrderedWriting(List.of(WritingEntry.linkPanel(), page("season/no_seasons")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(explicit, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeSeasonMode.select(plan, 42L, true), AgeSeasonMode.NO_SEASONS,
+                "An authored season page must override random selection");
+        AgeReference reference = new AgeReference(UUID.randomUUID(), "Season Persistence");
+        AgeRegistrySavedData data = AgeRegistrySavedData.get(helper.getLevel());
+        AgeRegistrySavedData.resolveOrCreate(helper.getLevel(), reference);
+        CompoundTag saved = data.save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag entries = saved.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            if (entry.getUUID("Id").equals(reference.id())) {
+                entry.putString("SeasonMode", selected.name());
+                break;
+            }
+        }
+        AgeDefinition restored = AgeRegistrySavedData.load(saved, helper.getLevel().registryAccess())
+                .find(reference.id()).orElseThrow();
+        helper.assertValueEqual(restored.seasonMode(), selected,
+                "The selected seasonal modifier must survive Age data reload");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void writtenEnvironmentPersistsAndPageFreeAgesStaySeeded(GameTestHelper helper) {
         OrderedWriting writing = new OrderedWriting(List.of(

src/main/java/net/dnorberg/rivencraft/client/ClientBookInteractionHandler.java

@@ -92,8 +92,10 @@ public final class ClientBookInteractionHandler {
                 return;
             }
             minecraft.setScreen(payload.fromStand()
-                    ? new DescriptiveBookScreen(payload.source().pos(), payload.book(), payload.traits(), payload.writingSymbols())
-                    : new DescriptiveBookScreen(hand, payload.book(), payload.traits(), payload.writingSymbols()));
+                    ? new DescriptiveBookScreen(payload.source().pos(), payload.book(), payload.traits(),
+                            payload.writingSymbols(), payload.diagnostics())
+                    : new DescriptiveBookScreen(hand, payload.book(), payload.traits(),
+                            payload.writingSymbols(), payload.diagnostics()));
         });
     }
 }

src/main/java/net/dnorberg/rivencraft/client/ClientSereneAgeWhitelist.java

@@ -0,0 +1,15 @@
+package net.dnorberg.rivencraft.client;
+
+import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
+import net.dnorberg.rivencraft.network.SereneAgeWhitelistPayload;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
+
+/** Applies incremental Serene whitelist updates on the client main thread. */
+public final class ClientSereneAgeWhitelist {
+    private ClientSereneAgeWhitelist() {
+    }
+
+    public static void handle(SereneAgeWhitelistPayload payload, IPayloadContext context) {
+        context.enqueueWork(() -> SereneSeasonsCompatibility.acceptClient(payload.dimensionId(), payload.enabled()));
+    }
+}

src/main/java/net/dnorberg/rivencraft/client/SymbolPageTextures.java

@@ -69,6 +69,13 @@ public final class SymbolPageTextures {
         return forPage(stack, true);
     }
 
+    /** Book pages use the same server-resolved poem and glyph composition as Page items. */
+    public static ResourceLocation forDisplay(SymbolDisplayMetadata display) {
+        return display.resolved()
+                ? forSymbol(display.id(), display.poem(), false)
+                : texture("item/page_unresolved");
+    }
+
     private static ResourceLocation forPage(ItemStack stack, boolean item) {
         PageContent content = PageItem.content(stack);
         if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return texture("item/page_unresolved");

src/main/java/net/dnorberg/rivencraft/client/screen/DescriptiveBookScreen.java

@@ -16,6 +16,7 @@ import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.dnorberg.rivencraft.client.preview.DestinationPreviewRenderer;
 import net.dnorberg.rivencraft.client.preview.DestinationPreviewRenderers;
 import net.minecraft.core.BlockPos;
@@ -44,6 +45,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private static final int LINK_PANEL_Y = 20;
     private static final int LINK_PANEL_WIDTH = 132;
     private static final int LINK_PANEL_HEIGHT = 83;
+    private static final int DIAGNOSTICS_PER_PAGE = 2;
     private static final Component EXPLORE_ICON = Component.literal("👁");
 
     private final AgeReference age;
@@ -51,7 +53,9 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private final AgeTraits traits;
     private final OrderedWriting writing;
     private final List<SymbolDisplayMetadata> writingSymbols;
+    private final List<WritingGrammar.Diagnostic> diagnostics;
     private final boolean pageFree;
+    private final String author;
     private final InteractionHand hand;
     private final BlockPos bookStandPos;
     private DestinationPreviewRenderer preview;
@@ -63,27 +67,33 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private boolean movingToExploreOverlay;
 
     public DescriptiveBookScreen(InteractionHand hand, ItemStack book, @Nullable AgeTraits traits,
-                                 List<SymbolDisplayMetadata> writingSymbols) {
+                                 List<SymbolDisplayMetadata> writingSymbols,
+                                 List<WritingGrammar.Diagnostic> diagnostics) {
         super(book.getHoverName());
         age = book.get(ModDataComponents.AGE_REFERENCE.get());
         generationProfile = book.get(ModDataComponents.AGE_GENERATION_PROFILE.get());
         this.traits = traits;
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
+        this.diagnostics = List.copyOf(diagnostics);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
+        author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         this.hand = hand;
         bookStandPos = null;
     }
 
     public DescriptiveBookScreen(BlockPos bookStandPos, ItemStack book, @Nullable AgeTraits traits,
-                                 List<SymbolDisplayMetadata> writingSymbols) {
+                                 List<SymbolDisplayMetadata> writingSymbols,
+                                 List<WritingGrammar.Diagnostic> diagnostics) {
         super(book.getHoverName());
         age = book.get(ModDataComponents.AGE_REFERENCE.get());
         generationProfile = book.get(ModDataComponents.AGE_GENERATION_PROFILE.get());
         this.traits = traits;
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
+        this.diagnostics = List.copyOf(diagnostics);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
+        author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         hand = InteractionHand.MAIN_HAND;
         this.bookStandPos = bookStandPos.immutable();
     }
@@ -163,6 +173,33 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             else if (pageIndex < pageCount() && mouseX >= left + 293 && mouseX < left + 320)
                 graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.next_page"), mouseX, mouseY);
         }
+        if (pageIndex > 0 && pageIndex < writing.entries().size()
+                && mouseX >= left + 285 && mouseX < left + 306
+                && mouseY >= top + 149 && mouseY < top + 169) {
+            diagnostics.stream().filter(diagnostic -> diagnostic.index() == pageIndex)
+                    .findFirst().ifPresent(diagnostic -> graphics.renderTooltip(font,
+                            Component.literal(diagnostic.message()), mouseX, mouseY));
+        }
+        if (pageIndex == 0 && age != null && !pageFree && traits != null
+                && mouseX >= left + 38 && mouseX < left + 154
+                && mouseY >= top + 38 && mouseY < top + 67) {
+            graphics.renderComponentTooltip(font, List.of(
+                    Component.translatable("screen.rivencraft.age.trait.biomes",
+                            traitName("biome_distribution", traits.biomeDistribution())),
+                    Component.translatable("screen.rivencraft.age.trait.lighting",
+                            traitName("lighting", traits.lighting())),
+                    Component.translatable("screen.rivencraft.age.trait.weather",
+                            traitName("weather", traits.weather())),
+                    Component.translatable("screen.rivencraft.age.trait.day_length",
+                            traits.hasStoppedCelestialCycle()
+                                    ? Component.translatable("trait.rivencraft.day_length.stopped")
+                                    : Component.literal(String.format(Locale.ROOT, "%.2fx", traits.celestialPeriod()))),
+                    Component.translatable("screen.rivencraft.age.trait.celestial_angle",
+                            Component.literal(String.format(Locale.ROOT, "%.0f°", traits.celestialAngle()))),
+                    Component.translatable("screen.rivencraft.age.trait.celestial_phase",
+                            Component.literal(String.format(Locale.ROOT, "%.0f%%", traits.celestialPhase() * 100.0F)))
+            ), mouseX, mouseY);
+        }
     }
 
     private void renderBook(GuiGraphics graphics, float partialTick) {
@@ -182,9 +219,12 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             graphics.enableScissor(left + 38, top + 38, left + 154, top + 174);
             renderFirstPageText(graphics, left, top);
             graphics.disableScissor();
-        } else if (pageIndex < pageCount()) {
+        } else if (pageIndex < writing.entries().size()) {
             LegacyBookArtwork.drawFullPage(graphics, left, top);
             renderWrittenPage(graphics, left, top);
+        } else if (!diagnostics.isEmpty()) {
+            LegacyBookArtwork.drawFullPage(graphics, left, top);
+            renderDiagnosticsPage(graphics, left, top);
         }
         String counter = pageIndex + "/" + pageCount();
         graphics.drawString(font, counter, left + 165 - font.width(counter) / 2,
@@ -193,20 +233,27 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
 
     private int pageCount() {
         // Older page-free Descriptive Books do not have a BOOK_WRITING component.
-        return Math.max(1, writing.entries().size());
+        int authoredPages = Math.max(1, writing.entries().size() - 1);
+        return authoredPages + (diagnostics.isEmpty() ? 0
+                : (diagnostics.size() + DIAGNOSTICS_PER_PAGE - 1) / DIAGNOSTICS_PER_PAGE);
     }
 
     private void renderFirstPageText(GuiGraphics graphics, int left, int top) {
         int x = left + 40;
-        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.title"),
-                x, top + 40, 110);
         if (age == null) {
+            drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.title"),
+                    x, top + 40, 110);
             drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.name_prompt"),
                     x, top + 52, 110);
             return;
         }
-        int detailsY = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
-                x + 10, top + 52, 100) + 10;
+        int nameEnd = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
+                x, top + 40, 110);
+        int detailsY = drawWrappedWithoutShadow(graphics,
+                author == null || author.isBlank()
+                        ? Component.translatable("screen.rivencraft.age.unknown_author")
+                        : Component.literal(author), x + 10, nameEnd + 2, 100) + 10;
+        if (!pageFree) return;
         if (generationProfile != null) {
             Component profileName = generationProfile.getNamespace().equals("rivencraft")
                     ? Component.translatable("generator.rivencraft." + generationProfile.getPath())
@@ -242,11 +289,37 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                 .filter(candidate -> candidate.kind() == WritingEntry.Kind.SYMBOL).count() - 1;
         SymbolDisplayMetadata display = symbolIndex < writingSymbols.size()
                 ? writingSymbols.get(symbolIndex) : SymbolDisplayMetadata.unresolved(entry.symbol().orElseThrow());
-        int color = display.resolved() ? BOOK_TEXT_COLOR : UNRESOLVED_TEXT_COLOR;
-        drawWrappedWithoutShadow(graphics, Component.translatable(display.nameTranslationKey()),
-                x, top + 39, 126, color);
-        drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
-                x, top + 64, 126, color);
+        graphics.enableScissor(left + 174, top + 26, left + 306, top + 172);
+        int textureSize = display.resolved() ? 128 : 16;
+        graphics.blit(SymbolPageTextures.forDisplay(display), left + 177, top + 29,
+                128, 128, 0, 0, textureSize, textureSize, textureSize, textureSize);
+        if (!display.resolved()) {
+            drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
+                    x, top + 151, 126, UNRESOLVED_TEXT_COLOR);
+        }
+        graphics.disableScissor();
+        if (diagnostics.stream().anyMatch(diagnostic -> diagnostic.index() == pageIndex)) {
+            graphics.drawString(font, "!", left + 293, top + 153, UNRESOLVED_TEXT_COLOR, false);
+        }
+    }
+
+    private void renderDiagnosticsPage(GuiGraphics graphics, int left, int top) {
+        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.writing_notes"),
+                left + 176, top + 35, 126);
+        int start = (pageIndex - Math.max(1, writing.entries().size() - 1) - 1) * DIAGNOSTICS_PER_PAGE;
+        int y = top + 52;
+        graphics.enableScissor(left + 174, top + 50, left + 306, top + 173);
+        for (int index = start; index < Math.min(start + DIAGNOSTICS_PER_PAGE, diagnostics.size()); index++) {
+            WritingGrammar.Diagnostic diagnostic = diagnostics.get(index);
+            int color = diagnostic.error() ? UNRESOLVED_TEXT_COLOR : BOOK_TEXT_COLOR;
+            Component label = diagnostic.index() < 0
+                    ? Component.translatable("screen.rivencraft.age.writing_general")
+                    : Component.translatable("screen.rivencraft.age.writing_page", diagnostic.index() + 1);
+            y = drawWrappedWithoutShadow(graphics, label, left + 176, y, 126, color) + 3;
+            y = drawWrappedWithoutShadow(graphics, Component.literal(diagnostic.message()),
+                    left + 176, y, 126, color) + 10;
+        }
+        graphics.disableScissor();
     }
 
     private void turnPage(int direction) {

src/main/java/net/dnorberg/rivencraft/command/RivencraftCommands.java

@@ -43,6 +43,8 @@ public final class RivencraftCommands {
             source.sendSuccess(() -> Component.literal(
                     (loaded ? "[loaded] " : "[unloaded] ")
                             + age.name() + " — " + age.dimensionId()
+                            + (age.seasonMode() == null ? "" : " (season: "
+                            + age.seasonMode().name().toLowerCase(java.util.Locale.ROOT) + ")")
             ), false);
         }
         return ages.size();

src/main/java/net/dnorberg/rivencraft/compat/SereneSeasonsAdapter.java

@@ -0,0 +1,63 @@
+package net.dnorberg.rivencraft.compat;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.dnorberg.rivencraft.book.AgeSeasonMode;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import sereneseasons.api.season.Season;
+import sereneseasons.config.SeasonsConfig;
+import sereneseasons.init.ModConfig;
+import sereneseasons.season.SeasonHandler;
+import sereneseasons.season.SeasonSavedData;
+import sereneseasons.season.SeasonTime;
+
+/** Isolates references to optional Serene Seasons and GlitchCore classes. */
+final class SereneSeasonsAdapter {
+    private static final String WHITELIST_KEY = "dimension_settings.whitelisted_dimensions";
+
+    private SereneSeasonsAdapter() {
+    }
+
+    static boolean setServerWhitelist(ResourceLocation dimensionId, boolean enabled) {
+        SeasonsConfig config = ModConfig.seasons;
+        if (config == null || config.whitelistedDimensions.contains(dimensionId.toString()) == enabled) return false;
+        List<String> dimensions = new ArrayList<>(config.whitelistedDimensions);
+        if (enabled) dimensions.add(dimensionId.toString());
+        else dimensions.removeIf(dimensionId.toString()::equals);
+        // GlitchCore rereads this config from disk before synchronizing new clients.
+        config.set(WHITELIST_KEY, dimensions);
+        config.write();
+        config.whitelistedDimensions = dimensions;
+        return true;
+    }
+
+    static void setClientWhitelist(ResourceLocation dimensionId, boolean enabled) {
+        SeasonsConfig config = ModConfig.seasons;
+        if (config == null || config.whitelistedDimensions.contains(dimensionId.toString()) == enabled) return;
+        List<String> dimensions = new ArrayList<>(config.whitelistedDimensions);
+        if (enabled) dimensions.add(dimensionId.toString());
+        else dimensions.removeIf(dimensionId.toString()::equals);
+        config.whitelistedDimensions = dimensions;
+    }
+
+    static void holdSeason(ServerLevel level, AgeSeasonMode mode) {
+        SeasonSavedData data = SeasonHandler.getSeasonSavedData(level);
+        Season.SubSeason target = switch (mode) {
+            case ETERNAL_SPRING -> Season.SubSeason.MID_SPRING;
+            case ETERNAL_SUMMER -> Season.SubSeason.MID_SUMMER;
+            case ETERNAL_FALL -> Season.SubSeason.MID_AUTUMN;
+            case ETERNAL_WINTER -> Season.SubSeason.MID_WINTER;
+            default -> throw new IllegalArgumentException("Not an eternal season: " + mode);
+        };
+        int duration = SeasonTime.ZERO.getSubSeasonDuration();
+        int midpoint = target.ordinal() * duration + duration / 2;
+        // Reset well before the end of MID_* so the client never observes a
+        // different sub-season; avoid marking saved data dirty every tick.
+        int current = data.seasonCycleTicks;
+        if (current >= midpoint && current < midpoint + duration / 4) return;
+        data.seasonCycleTicks = midpoint;
+        data.setDirty();
+        SeasonHandler.sendSeasonUpdate(level);
+    }
+}

src/main/java/net/dnorberg/rivencraft/compat/SereneSeasonsCompatibility.java

@@ -0,0 +1,83 @@
+package net.dnorberg.rivencraft.compat;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.book.AgeDefinition;
+import net.dnorberg.rivencraft.book.AgeDimensionService;
+import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
+import net.dnorberg.rivencraft.book.AgeSeasonMode;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.dnorberg.rivencraft.network.SereneAgeWhitelistPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.server.level.ServerLevel;
+import net.neoforged.fml.ModList;
+import net.neoforged.neoforge.network.PacketDistributor;
+import net.neoforged.neoforge.network.registration.NetworkRegistry;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** Optional, guarded bridge for Serene Seasons' per-dimension whitelist. */
+public final class SereneSeasonsCompatibility {
+    private SereneSeasonsCompatibility() {
+    }
+
+    public static void registerAge(MinecraftServer server, AgeDefinition age) {
+        if (!available() || !isAge(age.dimensionId())) return;
+        AgeSeasonMode mode = AgeSeasonMode.from(age);
+        boolean explicit = AgeSeasonMode.hasAuthoredPage(age.plan());
+        if (mode != AgeSeasonMode.NO_SEASONS && !explicit && !RivencraftConfig.autoWhitelistSereneAges()) {
+            return;
+        }
+        boolean enabled = mode != AgeSeasonMode.NO_SEASONS;
+        try {
+            if (SereneSeasonsAdapter.setServerWhitelist(age.dimensionId(), enabled)) {
+                for (ServerPlayer player : server.getPlayerList().getPlayers()) {
+                    send(player, age.dimensionId(), enabled);
+                }
+            }
+            if (enabled && mode.eternal()) {
+                ServerLevel level = server.getLevel(AgeDimensionService.dimensionKey(age));
+                if (level != null) SereneSeasonsAdapter.holdSeason(level, mode);
+            }
+        } catch (RuntimeException exception) {
+            Rivencraft.LOGGER.warn("Could not apply Serene Seasons policy for Age {}", age.dimensionId(), exception);
+        }
+    }
+
+    public static void onLevelTickPost(LevelTickEvent.Post event) {
+        if (!(event.getLevel() instanceof ServerLevel level) || !available()
+                || !isAge(level.dimension().location())) return;
+        AgeDefinition age = AgeRegistrySavedData.get(level)
+                .findByDimension(level.dimension().location()).orElse(null);
+        if (age == null) return;
+        AgeSeasonMode mode = AgeSeasonMode.from(age);
+        if (!mode.eternal() || !AgeSeasonMode.hasAuthoredPage(age.plan())
+                && !RivencraftConfig.autoWhitelistSereneAges()) return;
+        try {
+            SereneSeasonsAdapter.holdSeason(level, mode);
+        } catch (RuntimeException exception) {
+            Rivencraft.LOGGER.warn("Could not hold Serene season in Age {}", age.dimensionId(), exception);
+        }
+    }
+
+    public static void acceptClient(ResourceLocation dimensionId, boolean enabled) {
+        if (available() && isAge(dimensionId)) {
+            SereneSeasonsAdapter.setClientWhitelist(dimensionId, enabled);
+        }
+    }
+
+    private static void send(ServerPlayer player, ResourceLocation dimensionId, boolean enabled) {
+        if (NetworkRegistry.hasChannel(player.connection, SereneAgeWhitelistPayload.TYPE.id())) {
+            PacketDistributor.sendToPlayer(player, new SereneAgeWhitelistPayload(dimensionId, enabled));
+        }
+    }
+
+    private static boolean available() {
+        return ModList.get().isLoaded("sereneseasons");
+    }
+
+    private static boolean isAge(ResourceLocation dimensionId) {
+        return dimensionId.getNamespace().equals(Rivencraft.MOD_ID)
+                && dimensionId.getPath().startsWith("age/");
+    }
+}

src/main/java/net/dnorberg/rivencraft/config/RivencraftConfig.java

@@ -17,6 +17,7 @@ public final class RivencraftConfig {
     private static final ModConfigSpec.EnumValue<ReturnLinkMode> RETURN_LINK_MODE;
     private static final ModConfigSpec.IntValue SYMBOL_INK_COST;
     private static final ModConfigSpec.IntValue LINK_PANEL_INK_COST;
+    private static final ModConfigSpec.BooleanValue AUTO_WHITELIST_SERENE_AGES;
 
     static {
         ModConfigSpec.Builder builder = new ModConfigSpec.Builder();
@@ -33,6 +34,12 @@ public final class RivencraftConfig {
         LINK_PANEL_INK_COST = builder.comment("Ink units consumed when preparing one baseline link-panel page.")
                 .defineInRange("link_panel_ink_cost", 2, 1, 16);
         builder.pop();
+        builder.push("serene_seasons");
+        AUTO_WHITELIST_SERENE_AGES = builder.comment(
+                "Automatically add Rivencraft Ages to Serene Seasons' dimension whitelist when loaded.",
+                "Existing entries are preserved; disabling this does not remove previously added Ages."
+        ).define("auto_whitelist_ages", true);
+        builder.pop();
         SPEC = builder.build();
     }
 
@@ -50,4 +57,8 @@ public final class RivencraftConfig {
     public static int linkPanelInkCost() {
         return LINK_PANEL_INK_COST.get();
     }
+
+    public static boolean autoWhitelistSereneAges() {
+        return AUTO_WHITELIST_SERENE_AGES.get();
+    }
 }

src/main/java/net/dnorberg/rivencraft/menu/BookBinderMenu.java

@@ -3,6 +3,7 @@ package net.dnorberg.rivencraft.menu;
 import java.util.Optional;
 import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.registry.ModMenus;
 import net.dnorberg.rivencraft.writing.PageContent;
@@ -33,6 +34,7 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     private final Container inputs;
     private final SimpleContainer result = new SimpleContainer(1);
     private final boolean clientSide;
+    private final Player bookAuthor;
     private int selectedPage = -1;
     private int grammarErrorCode = -1;
     private int grammarErrorStripIndex = -1;
@@ -47,6 +49,7 @@ public final class BookBinderMenu extends AbstractContainerMenu {
         this.binder = binder;
         inputs = binder == null ? new SimpleContainer(BookBinderBlockEntity.SIZE) : binder;
         clientSide = inventory.player.level().isClientSide;
+        bookAuthor = inventory.player;
         addDataSlot(new DataSlot() {
             @Override public int get() { return selectedPage; }
             @Override public void set(int value) { selectedPage = value; }
@@ -167,6 +170,7 @@ public final class BookBinderMenu extends AbstractContainerMenu {
             refreshResult();
             if (!binder.canAssemble()) return ItemStack.EMPTY;
             ItemStack book = binder.previewBook();
+            book.set(ModDataComponents.BOOK_AUTHOR.get(), player.getGameProfile().getName());
             ItemStack remainder = book.copy();
             if (!moveItemStackTo(remainder, PLAYER_START, slots.size(), true) || !remainder.isEmpty()) {
                 return ItemStack.EMPTY;
@@ -221,6 +225,9 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     private void refreshResult() {
         if (clientSide) return;
         ItemStack preview = binder == null ? ItemStack.EMPTY : binder.previewBook();
+        if (!preview.isEmpty()) {
+            preview.set(ModDataComponents.BOOK_AUTHOR.get(), bookAuthor.getGameProfile().getName());
+        }
         if (!ItemStack.matches(result.getItem(0), preview)) result.setItem(0, preview);
     }
 

src/main/java/net/dnorberg/rivencraft/network/ModNetworking.java

@@ -12,6 +12,7 @@ import net.dnorberg.rivencraft.block.entity.BookStandBlockEntity;
 import net.dnorberg.rivencraft.client.ClientLinkPreviewHandler;
 import net.dnorberg.rivencraft.client.ClientBookInteractionHandler;
 import net.dnorberg.rivencraft.client.ClientAgeCelestialAngles;
+import net.dnorberg.rivencraft.client.ClientSereneAgeWhitelist;
 import net.dnorberg.rivencraft.client.ClientWritingDeskCatalog;
 import net.dnorberg.rivencraft.event.AgeCelestialAngleSync;
 import net.dnorberg.rivencraft.item.DescriptiveBookItem;
@@ -58,7 +59,7 @@ public final class ModNetworking {
     }
 
     public static void register(RegisterPayloadHandlersEvent event) {
-        PayloadRegistrar registrar = event.registrar("13");
+        PayloadRegistrar registrar = event.registrar("14");
         registrar.playToServer(RequestDescriptiveBookScreenPayload.TYPE, RequestDescriptiveBookScreenPayload.STREAM_CODEC,
                 ModNetworking::requestDescriptiveBookScreen);
         registrar.playToClient(OpenDescriptiveBookScreenPayload.TYPE, OpenDescriptiveBookScreenPayload.STREAM_CODEC,
@@ -78,6 +79,8 @@ public final class ModNetworking {
                 ClientLinkPreviewHandler::handle);
         registrar.playToClient(AgeCelestialAnglePayload.TYPE, AgeCelestialAnglePayload.STREAM_CODEC,
                 ClientAgeCelestialAngles::handle);
+        registrar.playToClient(SereneAgeWhitelistPayload.TYPE, SereneAgeWhitelistPayload.STREAM_CODEC,
+                ClientSereneAgeWhitelist::handle);
         registrar.playToClient(WritingDeskCatalogPayload.TYPE, WritingDeskCatalogPayload.STREAM_CODEC,
                 ClientWritingDeskCatalog::handle);
         registrar.playToServer(SetBookBinderTitlePayload.TYPE, SetBookBinderTitlePayload.STREAM_CODEC,
@@ -111,17 +114,21 @@ public final class ModNetworking {
         // Requests run on the same server thread as Age creation. A request queued
         // during generation can only open the finished book, never a stale client copy.
         player.inventoryMenu.broadcastChanges();
-        List<SymbolDisplayMetadata> writingSymbols = access.stack()
-                .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY).entries().stream()
+        OrderedWriting writing = access.stack()
+                .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
+        List<SymbolDisplayMetadata> writingSymbols = writing.entries().stream()
                 .filter(entry -> entry.kind() == WritingEntry.Kind.SYMBOL)
                 .map(entry -> SymbolCatalog.display(entry.symbol().orElseThrow()))
                 .toList();
+        // Diagnostics are advisory display data from the authoritative server catalog.
+        // Opening a book never recompiles or changes its persisted Age plan.
+        var diagnostics = WritingGrammar.parse(writing).diagnostics();
         PacketDistributor.sendToPlayer(player, new OpenDescriptiveBookScreenPayload(
                 payload.fromStand(), payload.offhand(),
                 GlobalPos.of(player.level().dimension(), payload.standPos()), access.stack().copy(),
                 definition == null ? null : definition.plan() != null && definition.plan().biomeSelection() != null
                         ? definition.traits().withBiomeDistribution(definition.plan().biomeSelection().distribution())
-                        : definition.traits(), writingSymbols));
+                        : definition.traits(), writingSymbols, diagnostics));
     }
 
     private static void bindDescriptiveBook(BindDescriptiveBookPayload payload, IPayloadContext context) {
@@ -165,6 +172,7 @@ public final class ModNetworking {
             }
 
             access.stack().set(ModDataComponents.AGE_REFERENCE.get(), reference);
+            access.stack().set(ModDataComponents.BOOK_AUTHOR.get(), player.getGameProfile().getName());
             AgeRegistrySavedData.get(player.serverLevel()).find(reference.id()).ifPresent(definition ->
                     access.stack().set(ModDataComponents.AGE_GENERATION_PROFILE.get(), definition.generationProfile()));
             access.stack().set(DataComponents.CUSTOM_NAME, Component.literal(title));

src/main/java/net/dnorberg/rivencraft/network/OpenDescriptiveBookScreenPayload.java

@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.book.AgeTraits;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.GlobalPos;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
@@ -21,7 +22,8 @@ public record OpenDescriptiveBookScreenPayload(
         GlobalPos source,
         ItemStack book,
         @Nullable AgeTraits traits,
-        List<SymbolDisplayMetadata> writingSymbols
+        List<SymbolDisplayMetadata> writingSymbols,
+        List<WritingGrammar.Diagnostic> diagnostics
 )
         implements CustomPacketPayload {
     public static final Type<OpenDescriptiveBookScreenPayload> TYPE = new Type<>(
@@ -50,6 +52,15 @@ public record OpenDescriptiveBookScreenPayload(
         }
         buffer.writeVarInt(payload.writingSymbols().size());
         payload.writingSymbols().forEach(symbol -> SymbolDisplayMetadata.STREAM_CODEC.encode(buffer, symbol));
+        if (payload.diagnostics().size() > OrderedWriting.MAX_ENTRIES * 2) {
+            throw new IllegalArgumentException("Too many book grammar diagnostics");
+        }
+        buffer.writeVarInt(payload.diagnostics().size());
+        payload.diagnostics().forEach(diagnostic -> {
+            buffer.writeEnum(diagnostic.code());
+            buffer.writeVarInt(diagnostic.index());
+            buffer.writeUtf(diagnostic.message(), 1024);
+        });
     }
 
     private static OpenDescriptiveBookScreenPayload decode(RegistryFriendlyByteBuf buffer) {
@@ -75,8 +86,17 @@ public record OpenDescriptiveBookScreenPayload(
         for (int index = 0; index < count; index++) {
             writingSymbols.add(SymbolDisplayMetadata.STREAM_CODEC.decode(buffer));
         }
+        int diagnosticCount = buffer.readVarInt();
+        if (diagnosticCount < 0 || diagnosticCount > OrderedWriting.MAX_ENTRIES * 2) {
+            throw new IllegalArgumentException("Invalid book grammar diagnostic count " + diagnosticCount);
+        }
+        List<WritingGrammar.Diagnostic> diagnostics = new ArrayList<>(diagnosticCount);
+        for (int index = 0; index < diagnosticCount; index++) {
+            diagnostics.add(new WritingGrammar.Diagnostic(
+                    buffer.readEnum(WritingGrammar.Code.class), buffer.readVarInt(), buffer.readUtf(1024)));
+        }
         return new OpenDescriptiveBookScreenPayload(fromStand, offhand, source, book, traits,
-                List.copyOf(writingSymbols));
+                List.copyOf(writingSymbols), List.copyOf(diagnostics));
     }
 
     @Override

src/main/java/net/dnorberg/rivencraft/network/SereneAgeWhitelistPayload.java

@@ -0,0 +1,25 @@
+package net.dnorberg.rivencraft.network;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+
+/** Updates an already connected client's Serene whitelist for one Age. */
+public record SereneAgeWhitelistPayload(ResourceLocation dimensionId, boolean enabled) implements CustomPacketPayload {
+    public static final Type<SereneAgeWhitelistPayload> TYPE = new Type<>(
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "serene_age_whitelist"));
+    public static final StreamCodec<RegistryFriendlyByteBuf, SereneAgeWhitelistPayload> STREAM_CODEC =
+            StreamCodec.of(
+                    (buffer, payload) -> {
+                        buffer.writeResourceLocation(payload.dimensionId());
+                        buffer.writeBoolean(payload.enabled());
+                    },
+                    buffer -> new SereneAgeWhitelistPayload(buffer.readResourceLocation(), buffer.readBoolean()));
+
+    @Override
+    public Type<? extends CustomPacketPayload> type() {
+        return TYPE;
+    }
+}

src/main/java/net/dnorberg/rivencraft/registry/ModCreativeTabs.java

@@ -42,7 +42,7 @@ public final class ModCreativeTabs {
                     .build());
 
     private static final List<String> CATEGORY_ORDER = List.of(
-            "terrain", "biome", "cave_biome", "biome_generation", "weather", "lighting", "sky", "celestial", "block", "fluid", "feature");
+            "terrain", "biome", "cave_biome", "biome_generation", "weather", "season", "lighting", "sky", "celestial", "block", "fluid", "feature");
 
     public static final Map<ResourceLocation, DeferredHolder<CreativeModeTab, CreativeModeTab>> SYMBOL_PAGES =
             registerSymbolPageTabs();

src/main/java/net/dnorberg/rivencraft/registry/ModDataComponents.java

@@ -75,6 +75,12 @@ public final class ModDataComponents {
                     .networkSynchronized(OrderedWriting.STREAM_CODEC)
                     .cacheEncoding()
                     .build());
+    public static final DeferredHolder<DataComponentType<?>, DataComponentType<String>> BOOK_AUTHOR =
+            DATA_COMPONENTS.register("book_author", () -> DataComponentType.<String>builder()
+                    .persistent(Codec.STRING)
+                    .networkSynchronized(ByteBufCodecs.STRING_UTF8)
+                    .cacheEncoding()
+                    .build());
     public static final DeferredHolder<DataComponentType<?>, DataComponentType<Integer>> INK_REMAINING =
             DATA_COMPONENTS.register("ink_remaining", () -> DataComponentType.<Integer>builder()
                     .persistent(Codec.intRange(0, 16))

src/main/java/net/dnorberg/rivencraft/writing/SymbolSemantics.java

@@ -80,6 +80,8 @@ public record SymbolSemantics(Role role, Value value) {
         SKY("sky", Kind.CHOICE, "overworld", "nether", "end"),
         WEATHER("weather", Kind.CHOICE,
                 "normal", "fast", "slow", "off", "always", "cloudy", "rain", "snow", "storm"),
+        SEASON("season", Kind.CHOICE,
+                "no_seasons", "seasons", "eternal_winter", "eternal_summer", "eternal_fall", "eternal_spring"),
         CELESTIAL("celestial", Kind.CHOICE, "normal_time"),
         PERIOD_MODIFIER("period_modifier", Kind.NUMBER),
         ANGLE_MODIFIER("angle_modifier", Kind.NUMBER),

src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java

@@ -152,7 +152,7 @@ public final class WritingGrammar {
 
     private static boolean singular(Role role) {
         return switch (role) {
-            case TERRAIN, BIOME_CONTROLLER, WEATHER, LIGHTING, SKY, CELESTIAL -> true;
+            case TERRAIN, BIOME_CONTROLLER, WEATHER, SEASON, LIGHTING, SKY, CELESTIAL -> true;
             default -> false;
         };
     }
@@ -167,11 +167,12 @@ public final class WritingGrammar {
             case BIOME -> 1;
             case BIOME_CONTROLLER -> 2;
             case WEATHER -> 3;
-            case LIGHTING -> 4;
-            case SKY -> 5;
-            case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER -> 6;
-            case CELESTIAL -> 7;
-            case BLOCK, FEATURE -> 8;
+            case SEASON -> 4;
+            case LIGHTING -> 5;
+            case SKY -> 6;
+            case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER -> 7;
+            case CELESTIAL -> 8;
+            case BLOCK, FEATURE -> 9;
         };
     }
 

src/main/resources/assets/rivencraft/lang/en_us.json

@@ -88,12 +88,16 @@
   "screen.rivencraft.book.unwritten": "This Descriptive Book is unwritten",
   "screen.rivencraft.age.title": "Age name",
   "screen.rivencraft.age.title_hint": "Name this Age",
+  "screen.rivencraft.age.unknown_author": "Unknown author",
   "screen.rivencraft.age.name_prompt": "Name this Age before writing the Descriptive Book",
   "screen.rivencraft.age.create": "Create",
   "screen.rivencraft.age.generator": "Terrain: %s",
   "screen.rivencraft.age.pages": "Pages",
   "screen.rivencraft.age.details": "Details",
   "screen.rivencraft.age.pages_count": "Writing %s/%s",
+  "screen.rivencraft.age.writing_notes": "Writing notes",
+  "screen.rivencraft.age.writing_general": "Book",
+  "screen.rivencraft.age.writing_page": "Page %s",
   "screen.rivencraft.age.trait.biomes": "Biomes: %s",
   "screen.rivencraft.age.trait.lighting": "Lighting: %s",
   "screen.rivencraft.age.trait.weather": "Weather: %s",
@@ -195,6 +199,18 @@
   "symbol.rivencraft.weather.always.description": "Keep the Age rainy.",
   "symbol.rivencraft.weather.storm": "Storm Weather",
   "symbol.rivencraft.weather.storm.description": "Keep the Age rainy and thundering.",
+  "symbol.rivencraft.season.no_seasons": "No Seasons",
+  "symbol.rivencraft.season.no_seasons.description": "Keep seasonal changes out of this Age.",
+  "symbol.rivencraft.season.seasons": "Seasons",
+  "symbol.rivencraft.season.seasons.description": "Let this Age follow its own season cycle.",
+  "symbol.rivencraft.season.eternal_winter": "Eternal Winter",
+  "symbol.rivencraft.season.eternal_winter.description": "Hold this Age in midwinter where the biome allows winter effects.",
+  "symbol.rivencraft.season.eternal_summer": "Eternal Summer",
+  "symbol.rivencraft.season.eternal_summer.description": "Hold this Age in midsummer.",
+  "symbol.rivencraft.season.eternal_fall": "Eternal Fall",
+  "symbol.rivencraft.season.eternal_fall.description": "Hold this Age in midautumn.",
+  "symbol.rivencraft.season.eternal_spring": "Eternal Spring",
+  "symbol.rivencraft.season.eternal_spring.description": "Hold this Age in midspring.",
   "symbol.rivencraft.celestial.normal_time": "Normal Time",
   "symbol.rivencraft.celestial.normal_time.description": "Use a normal-length celestial cycle.",
   "symbol.rivencraft.period.zero": "Zero Length",
@@ -261,6 +277,7 @@
   "itemGroup.rivencraft.pages.cave_biome": "Rivencraft Cave Biome Pages",
   "itemGroup.rivencraft.pages.biome_generation": "Rivencraft Biome Generation Pages",
   "itemGroup.rivencraft.pages.weather": "Rivencraft Weather Pages",
+  "itemGroup.rivencraft.pages.season": "Rivencraft Season Pages",
   "itemGroup.rivencraft.pages.lighting": "Rivencraft Lighting Pages",
   "itemGroup.rivencraft.pages.sky": "Rivencraft Sky Pages",
   "itemGroup.rivencraft.pages.celestial": "Rivencraft Celestial Pages",

src/main/resources/data/rivencraft/rivencraft/symbols/season/eternal_fall.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.season.eternal_fall",
+  "description": "symbol.rivencraft.season.eternal_fall.description",
+  "category": "rivencraft:season",
+  "semantics": { "role": "season", "value": "eternal_fall" }
+}

src/main/resources/data/rivencraft/rivencraft/symbols/season/eternal_spring.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.season.eternal_spring",
+  "description": "symbol.rivencraft.season.eternal_spring.description",
+  "category": "rivencraft:season",
+  "semantics": { "role": "season", "value": "eternal_spring" }
+}

src/main/resources/data/rivencraft/rivencraft/symbols/season/eternal_summer.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.season.eternal_summer",
+  "description": "symbol.rivencraft.season.eternal_summer.description",
+  "category": "rivencraft:season",
+  "semantics": { "role": "season", "value": "eternal_summer" }
+}

src/main/resources/data/rivencraft/rivencraft/symbols/season/eternal_winter.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.season.eternal_winter",
+  "description": "symbol.rivencraft.season.eternal_winter.description",
+  "category": "rivencraft:season",
+  "semantics": { "role": "season", "value": "eternal_winter" }
+}

src/main/resources/data/rivencraft/rivencraft/symbols/season/no_seasons.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.season.no_seasons",
+  "description": "symbol.rivencraft.season.no_seasons.description",
+  "category": "rivencraft:season",
+  "semantics": { "role": "season", "value": "no_seasons" }
+}

src/main/resources/data/rivencraft/rivencraft/symbols/season/seasons.json

@@ -0,0 +1,7 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.season.seasons",
+  "description": "symbol.rivencraft.season.seasons.description",
+  "category": "rivencraft:season",
+  "semantics": { "role": "season", "value": "seasons" }
+}