Port bounded meteor, burning, and erosion effects (#70)

Persist repaired Age writing and provisional instability penalties, retain fatal diagnostics for unsupported content, and hide TerraBlender's deferred placeholder biome from creative and JEI.

README.md

@@ -4,12 +4,13 @@ Rivencraft is a clean, incremental port of the ideas and gameplay of
 [Mystcraft Legacy](https://github.com/Mystcraft/Mystcraft-Legacy) to Minecraft
 1.21.1 on NeoForge.
 
-The bootstrap, books/linking, Ages, and writing-system milestones are complete.
+The bootstrap, books/linking, Ages, writing-system, and Age-grammar milestones are complete.
 The writing system uses a data-pack symbol catalog and persistent
-ordered-writing model. The project currently provides functional Linking Books
+ordered-writing model. Linking Books and Descriptive Books create persistent
-and randomly seeded, persistent vanilla-like Ages created from page-free
+Ages from either authored supported symbols or seeded random completion.
-Descriptive Books. Instability and full symbol-to-world grammar interpretation
+Instability and the remaining unsupported Legacy symbol effects have not been
-have not been ported yet.
+ported yet. The [Milestone 5 acceptance record](docs/MILESTONE_5_ACCEPTANCE.md)
+lists the supported grammar, optional integrations, and limits.
 
 Milestone 4 now includes stackable blank Pages plus server-created symbol,
 unresolved-symbol, and baseline link-panel states. Page visuals follow the
@@ -21,9 +22,23 @@ The spent vial returns a glass bottle. Server owners can adjust the symbol-copy
 and link-panel costs in the `writing` section of `rivencraft-server.toml`.
 The Ink Mixer now offers a Legacy-style station for producing Link Panels:
 insert paper and Ink Vials, then take a Link Panel from the result slot. Each
-vial fills its 16-unit basin and returns a glass bottle; no server tick is
+vial fills its 16-unit basin and returns a glass bottle; taking one Link Panel
-needed. The earlier paper-in-one-hand method remains available. Ink modifier
+uses the full vial. No server tick is needed. The earlier paper-in-one-hand
-ingredients and link properties are planned for Milestone 5.
+method still uses the configurable link-panel ink cost. Ink Mixer
+additives can roll Disarm, Maintain Momentum, and Intra Linking onto a Link
+Panel. Descriptive Books retain Disarm and Momentum; Intra Linking is only
+meaningful for same-dimension travel with a Linking Book.
+TerraBlender 1.21.1 integration is optional: registered modded biomes receive
+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
@@ -79,6 +94,9 @@ With JEI installed, Rivencraft displays the Ink Mixer operation in its own
 category and the hand-use, copying, binding, and Linking Book crafting flows in a Writing category.
 The Link Panel and individual symbol Pages, including registered vanilla biome
 pages, appear as separately searchable JEI ingredients.
+Creative inventory separates Link Pages and each symbol category into their own
+tabs, including distinct Biome and Biome Generation tabs. Blank Pages are hidden
+from creative inventory and JEI.
 JEI is optional; vanilla crafting
 recipes and all writing interactions work without it. For a development client
 with JEI, run `./gradlew runClient -PwithJei=true`.
@@ -99,14 +117,15 @@ into a versioned, server-owned Age plan. The plan freezes the Age seed, resolved
 symbol meanings, page order, and runtime profile, so later data-pack changes do
 not reinterpret an existing Age. An authored terrain page selects its runtime
 profile. Built-in pages cover Standard, Amplified, Cave, Island, Flat, and Void;
-other symbol effects are scheduled for later Milestone 5 slices. The
+authored biome, environment, and supported feature pages also affect new Ages.
+The
 writing is also stored on the book; the Descriptive Book screen's turned pages
 show ordered symbols and unresolved IDs. The Descriptive Book screen follows
 Legacy's book spread: the title and Age details are on the left, the destination
 preview is on the right, and clicks in the bottom corners turn pages. Ordered
-symbol pages appear before the final blank spread; their pictograms await
+symbol pages appear before the final blank spread with their runtime-rendered
-Milestone 5. Link-panel-only books show their details in the enchantment-table
+pictograms. Link-panel-only books use Rivencraft glyphs for their generated
-font.
+Age description.
 
 ## Linking Book
 

build.gradle

@@ -17,7 +17,7 @@ tasks.named('wrapper', Wrapper).configure {
 version = mod_version
 group = mod_group_id
 
-List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'desk', 'binder', 'mixer', 'recipe']
+List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'generation', 'desk', 'binder', 'mixer', 'recipe']
 List<String> selectedArchivedGameTestSuites = providers.gradleProperty('withArchivedGameTests')
         .map { it.toBoolean() }.orElse(false).get() ? archivedGameTestSuites
         : providers.gradleProperty('archivedGameTestSuites').orElse('').get()
@@ -91,6 +91,11 @@ repositories {
         content { includeGroup 'curse.maven' }
     }
     maven { url = 'https://maven.bai.lol' }
+    maven {
+        name = 'TerraBlenderMaven'
+        url = 'https://maven.minecraftforge.net/releases/'
+        content { includeGroup 'com.github.glitchfiend' }
+    }
     maven {
         url = 'https://api.modrinth.com/maven'
         content { includeGroup 'maven.modrinth' }
@@ -238,6 +243,19 @@ dependencies {
     // Keep them on the compile classpath without forcing either mod at runtime.
     compileOnly "net.createmod.ponder:ponder-neoforge:${ponder_version}+mc${minecraft_version}"
     compileOnly "maven.modrinth:immersive-portals-neoforge:${immersive_portals_version}"
+    // TerraBlender's region API is only used by the guarded compat adapter.
+    compileOnly "com.github.glitchfiend:TerraBlender-neoforge:${minecraft_version}-${terrablender_version}"
+    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/AGE_CLOUD_PLATFORM.md

@@ -0,0 +1,7 @@
+# Age arrival cloud platform
+
+Newly created Ages now place a 5×5 solid cloud platform instead of cobblestone at their saved spawn. The block has full collision, passes skylight, renders translucently, has no loot table, and cannot be obtained with pick-block. Existing Ages retain their already-placed platform; this change does not overwrite a player's saved world.
+
+The block texture is `assets/rivencraft/textures/block/cloud_platform.png`, verified at exactly 16×16 RGBA. Legacy's supplied assets contain no cloud-block texture, so this one was generated with the built-in image tool, then reduced by nearest-neighbor sampling. The final prompt requested a seamless Minecraft block-face pixel-art tile with 2–3 chunky white, icy-blue, and powder-blue cloud swirls, genuine transparent holes between them, strong 16×16-scale contrast, and no background or text.
+
+The separate [decay provider](INSTABILITY_DECAY.md) protects the saved spawn area by position, so its protection remains in force regardless of the platform's material.

docs/AGE_PROFILES.md

@@ -40,6 +40,153 @@ profiles, not claims that Legacy had identically named terrain symbols.
 Every family retains a safe cobblestone arrival platform. An omitted terrain
 page still uses the deterministic seed-selected profile.
 
+The separate **Floating Islands** feature page adds rare high-altitude island
+clusters above Standard, Amplified, Sky Islands, Flat, or Void terrain; it does
+not replace the terrain page. The feature is seeded by the Age and saved with the written
+plan, so revisiting an Age recreates the same islands. Without a preceding
+Block page, the Age seed chooses one valid full-collision block from the Block
+Pages pool for the island body. A full-block material page immediately before
+Floating Islands overrides that choice. Ordinary surface biomes still get
+dirt/grass top layers; Nether and End biomes use the chosen block throughout.
+The feature is additive even on Sky Islands terrain,
+which already forms its own islands. Cave terrain rejects it. A page-free random
+Age may also roll Floating Islands as one of its material features.
+
+An unpaired Block or Fluid page chooses a compatible feature from the Age seed:
+full blocks can become Rocks, Floating Islands, Tendrils, Spheres, or Spikes; source fluids can become one
+of the lake features. Flat terrain can use Floating Islands, Tendrils, Spheres,
+or Spikes; Void can use Floating Islands, Tendrils, or Spheres; Cave can use
+Spheres or Tendrils. A page-free
+random Age rolls zero, one, or two distinct compatible material features, choosing each
+material from the Block or Fluid Pages pool. The choices are saved on the Age
+definition, so opening the Age again does not reroll them.
+Repeated Block/Fluid and Feature pages remain separate entries in authored
+writing. Each unpaired material gets its own compatible feature, and repeated
+decorations use separate placement rolls. Repeated unmodified feature pages
+choose different compatible materials until their material pool is exhausted.
+
+Structure pages are separate Feature symbols. Legacy's Dungeons, Mineshafts,
+Nether Fortresses, Strongholds, and Villages have writable pages, as do modern
+Trial Chambers, Bastion Remnants, Buried Treasure, Shipwrecks, Ocean Ruins,
+Pillager Outposts, Ruined Portals, Nether Fossils, Ancient Cities, and Trail
+Ruins. They use Minecraft's 1.21.1 structure templates and placement rules,
+not a recreation of 1.12.2 structure geometry. A page enables only its own
+structure set; absent pages do not inherit these structures from a biome.
+Nether Fortresses and Bastions use separate sets instead of vanilla's shared
+Nether-complexes set, so writing one does not enable the other. Dungeons use
+the vanilla monster-room feature with eight attempts per chunk; unpaged Ages
+do not inherit biome-default monster-room attempts. A page-free random Age
+may choose zero to two distinct compatible structure types, frozen on creation.
+An authored structure needs a compatible biome in the Age's selected pool.
+Fortresses, Bastions, and Nether Fossils require Cave terrain plus a Nether
+biome; surface-only structures reject Cave terrain. Void rejects all of these
+structure pages. Villages and Strongholds can also be written into Flat Ages.
+
+For visual testing, write a Standard/Plains/Single Age with Mineshafts,
+Villages, and Trial Chambers, then use `/locate structure` in that Age to find
+each. An unwritten Pillager Outpost should not locate there. Test a Cave Age
+with Nether Wastes/Single and either the Nether Fortresses or Bastion page:
+only the selected type should locate. Ocean structures need their matching
+ocean or beach biome page; Ancient Cities need Deep Dark. Check the new pages
+in Rivencraft's Feature creative tab and JEI as well.
+
+**Dense Ores** is an authored-only Feature page. Each copy replays one extra
+pass of every ore placement registered in the Age's nearby biomes, using that
+placement's existing height, vein-size, rarity, and biome rules. It therefore
+also densifies conventional mod-added ores without hard-coded mod IDs. Output
+blocks tagged `c:ores` qualify; OreConfiguration outputs with `_ore` in their
+registry name also qualify. A mod with a custom, non-OreConfiguration placed
+feature can opt in by tagging that feature `rivencraft:dense_ores`. Non-ore
+stone/dirt blobs are not repeated. Flat and Void reject the page, as does a
+biome pool without any ore placements. Page-free random Ages never roll Dense
+Ores. The extra pass applies only as new chunks generate; it does not retrofit
+existing chunks or discover ore systems that bypass biome placed features.
+
+For an in-game check, write a Standard/Plains/Single Age with Dense Ores and
+verify that new underground chunks contain visibly more vanilla ore while
+stone/dirt blob frequency remains unchanged. With an ore-adding mod installed,
+write an Age using a biome where that mod registers its ore and verify the ore
+also appears more often. Check that Flat plus Dense Ores is rejected by the
+Binder and that a random, Link-Panel-only Age has no Dense Ores feature page.
+
+**Obelisks** adds Legacy-shaped, rare 4×4 plinths with a 2×2 shaft rising 12
+blocks, at most one attempt per 128 chunks per page. A preceding full-block
+Block page chooses the material; otherwise the Age seed chooses from valid
+block pages. Repeated Obelisks pages make independent attempts. Generation is
+deterministic and stays within one chunk; it requires a reasonably level,
+exposed solid surface, so Cave and Void terrain reject the page. Standard,
+Amplified, Sky Islands, and Flat terrain permit it. Page-free random surface
+Ages can roll Obelisks as one of their material features.
+
+For a visual check, write a Standard or Flat Age with an Obelisks page and
+search newly generated terrain for the 4×4 base and 12-block shaft. Try a
+Block page such as Obsidian immediately before Obelisks to verify its material
+changes. The Binder should reject Obelisks in Cave and Void Ages. Placement
+is deliberately rare, so several hundred fresh chunks may be needed.
+
+For an in-game visual check, bind Descriptive Books with a Link Panel,
+one of Standard, Amplified, Sky Islands, Flat, or Void terrain, and the Floating Islands
+feature page in that order. Fly through each Age at roughly Y=170–220 and
+verify the elevated clusters appear above its unchanged base terrain. Reopen
+the same Age to check that island positions stay fixed. Islands should be less
+common than in the first test build (one source chunk in 128 instead of 64).
+Sky Islands should retain its terrain islands and gain occasional additional
+feature islands. Try Cave terrain too; the Binder should reject that pairing.
+
+**Skylands** is a separate subtractive feature, not the Sky Islands terrain
+profile or the additive Floating Islands feature. Following Legacy's primer
+filter, it removes base terrain below a smooth, seven-octave cutoff around
+world Y=76 and removes liquid above the cutoff. The selected terrain still
+generates first; Floating Islands and Tendrils are added afterward, so they
+can coexist with Skylands. Skylands has no Block-page modifier. It can be
+authored on every terrain, though Flat loses its low ground and Void has no
+base terrain to change. Page-free random noise Ages have a seeded one-in-eight
+chance to gain Skylands; random Flat and Void Ages do not roll this ineffective
+filter. The cloud-height and horizon changes from Legacy are not included yet.
+
+For an in-game check, compare Standard terrain with and without a Skylands
+page. Skylands should leave upper hills suspended over open space, while a
+Floating Islands page instead adds isolated high islands without removing the
+ground below. Try Sky Islands terrain plus Skylands to confirm the page filters
+the terrain rather than replacing its generator. A book with both Skylands and
+Floating Islands should retain the added feature islands above the cutoff.
+
+The **Tendrils** feature adapts Legacy's winding, branching cave-node geometry
+into solid tubes. It is additive on all current terrain families, including
+Flat, Void, and Cave; it does not change biome selection. A preceding full-
+collision Block page chooses the tendril material. Otherwise the Age seed
+chooses a valid Block Pages material, consistent with other authored material
+features. Page-free random Ages can select Tendrils as a solid-material feature,
+including on Cave terrain where the surface material features are unavailable.
+The shape and placement use only the Age seed and source-chunk coordinates, so
+revisiting an Age recreates the same geometry.
+
+**Spheres** and **Spikes** are two separate Feature pages. Spheres adds
+winding chains of solid sphere nodes within terrain generation; like Tendrils,
+it works on all terrain families, even Void and Cave. Spikes is a later,
+rarer surface decoration (roughly one attempt per 18 chunks) that rises from
+solid ground on Standard, Amplified, Sky Islands, or Flat terrain. Cave and
+Void reject the Spikes page because they do not provide a suitable exposed
+surface. Each page accepts its own immediately preceding full-collision Block
+page; without one, the Age seed chooses a compatible material. The pages
+remain distinct in the catalog, Creative menu, JEI, ordered writing, and
+saved Age definition. Page-free random Ages can select either where compatible.
+
+For an in-game check, make separate Void/Spheres and Flat/Spikes books with
+Glowstone Block pages directly before their respective Feature pages. Spheres
+should form connected bright globes across chunk boundaries in Void; Spikes
+should appear as rare upward clusters rooted on the Flat surface. Revisit the
+same Ages to confirm stable locations. Check that a Void/Spikes book is
+rejected, and that Spheres and Spikes remain two independently selectable
+pages in Creative and JEI.
+
+For a clear visual check, bind a Void Age with a Glowstone Block page followed
+by Tendrils. Fly around world Y=0–120 across several chunks: branching solid
+forms should appear in the otherwise empty dimension, continue across chunk
+borders, and remain in place after leaving and returning. Repeat with a lone
+Tendrils page to confirm its seed-chosen material, and with Cave terrain to
+confirm the feature does not require a surface biome.
+
 ## Written biome selection (generation version 16)
 
 Biome pages follow the terrain page and precede the distribution-control page
@@ -52,11 +199,11 @@ eligible biomes for Tiled/Grid and Tiny–Huge. The eligible pool comes from the
 terrain's biome preset, or `#rivencraft:cave_biomes` for Cave terrain, so future
 biome integrations can expand it without changing the count rule. Single uses
 one; Native uses its preset biome pool. This random-age maximum does not truncate
-authored pages: the Binder's 27 symbol-page positions bound an authored book.
+authored pages: the Binder's 252 symbol-page positions bound an authored book. Legacy's Binder itself had no explicit page-count check; this remains a fixed-slot storage ceiling.
 Native cannot be paired with explicit biome pages. Legacy filled Tiny–Huge to
 three; Rivencraft deliberately uses two so a pair of written biome pages stays
 exactly as written.
-The Pages creative tab offers pages for every registered vanilla biome.
+The Biome Pages creative tab offers pages for every registered vanilla biome.
 Hand-authored symbol definitions take precedence; the remaining vanilla pages
 are generated from the biome registry, so they do not each need a JSON file.
 Custom/modded biomes still require a data-pack symbol definition.
@@ -72,8 +219,15 @@ also accepted. Other cave/biome pairings are diagnosed and blocked for now.
 Milestone 6 instability should allow such illegal combinations as unstable
 Ages, without silently treating them as ordinary cave generation. Flat terrain
 uses Overworld choices when a distribution is authored; its Native default
-remains Plains. Void terrain defaults to The Void and needs additional authored
+remains Plains. Void terrain defaults to The Void when no biome page is written,
-biomes for a multi-biome distribution.
+but accepts authored biome pages. One authored biome uses Single distribution
+when no controller is written. An explicit multi-biome distribution needs enough
+authored biomes; The Void is not silently added to fill missing positions. These
+biome regions exist even without blocks or a Floating Islands page, so biome-
+dependent weather and optional season behavior can still vary there. To check
+this in-game, bind Void terrain with a Desert Biome page and no feature page:
+the Age should be empty while F3 reports Desert. A Void book without biome
+pages should instead report The Void.
 
 The resolved list of biome IDs, their order/repetitions, and distribution are
 frozen into the Age plan. A removed biome ID emits a warning and uses an
@@ -99,7 +253,7 @@ cannot reproduce those Legacy distinctions yet, and Snow remains planned for
 the optional season integrations. A data pack that supplies these unsupported
 weather choices receives a binding error rather than a false success.
 
-The Pages creative tab and optional JEI page ingredients use the same generated
+The category creative tabs and optional JEI page ingredients use the same generated
 index of bundled environment symbols. Existing Age definitions and page-free
 random Ages retain their saved or seeded environment unchanged.
 

docs/ASSET_PROVENANCE.md

@@ -7,9 +7,8 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | Rivencraft asset | Upstream asset | Upstream revision | Changes |
 | --- | --- | --- | --- |
 | `assets/rivencraft/textures/item/page.png` | `assets/mystcraft/textures/items/page_background.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
-| `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Notebook draws the native 30×40 page at atlas coordinates `(156, 0)` |
+| `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared by the Notebook, Desk, Binder, and turned left book page after removing a byte-identical duplicate |
 | `assets/rivencraft/textures/gui/bookui_cover.png` | `assets/mystcraft/gui/bookui_cover.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared book cover, with gold edges drawn only for Descriptive Books |
-| `assets/rivencraft/textures/gui/bookui_pagel.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; turned left page |
 | `assets/rivencraft/textures/gui/bookui_pager.png` | `assets/mystcraft/gui/bookui_pager.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; link-panel frame on the first right page |
 | `assets/rivencraft/textures/gui/bookui_rpage_full.png` | `assets/mystcraft/gui/bookui_rpage_full.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; full right written page |
 | `assets/rivencraft/textures/item/writing_desk.png` | `assets/mystcraft/textures/items/writingdesk.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
@@ -25,6 +24,11 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | `assets/rivencraft/textures/item/page_link_panel.png` | `page_background.png` and `PageBuilder.BasicPageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Reproduces the legacy 160 px scale, black panel at `(25,30)`–`(135,75)`, and 128 px resample |
 | `assets/rivencraft/textures/gui/symbolcomponents.png` | `assets/mystcraft/textures/symbolcomponents.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Byte-identical shared 512×512 component sheet for client-side page composition |
 | Runtime-composed symbol pages (`SymbolPageTextures`) | `page_background.png`, `textures/symbolcomponents.png`, `WordData`, `ModSymbols`, and `PageBuilder.PageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Replaces the six pre-generated symbol PNGs; layers four poem words on the shared page background and caches bounded client textures |
+| `assets/rivencraft/textures/block/crystal_block.png` | `assets/mystcraft/textures/blocks/crystal.png` | Legacy 0.13.7.06 local extraction | Exact 16×16 blue tile shared by Crystal Block and Budding Crystal models after removing a byte-identical duplicate |
+| `assets/rivencraft/textures/block/{small,medium,large}_crystal_bud.png`, `crystal_cluster.png` | Minecraft 1.21.1 `textures/block/{small,medium,large}_amethyst_bud.png`, `amethyst_cluster.png` | Minecraft 1.21.1 | Original 16×16 alpha masks and silhouettes preserved; hue shifted toward Legacy blue, with brighter saturation; exported as 8-bit RGBA (not indexed PNG) |
+| `assets/rivencraft/textures/item/crystal_shard.png` | Original sprite generated with OpenAI ImageGen from the Legacy crystal palette | 2026-10-05 | Cropped and nearest-neighbor scaled to 16×16 |
+| `assets/rivencraft/sounds/linking/link-fissure.ogg` | `assets/mystcraft/sounds/linking/link-fissure.ogg` | Legacy 0.13.7.06 local extraction | Namespace/path rename only; plays when a Star Fissure returns an entity home |
+| `assets/rivencraft/sounds/entity/meteor/roar.ogg` | `assets/mystcraft/sounds/entity/meteor/roar.ogg` | Legacy 0.13.7.06 local extraction | Byte-identical copy under the Rivencraft namespace; plays during the bounded meteor descent |
 
 Mystcraft Legacy identifies XCompWiz as its project developer and includes the
 full LGPL v3 text in its root `LICENSE` file. Rivencraft's root `LICENSE`

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. A missing data-pack symbol draws the unresolved page artwork and its original ID. Descriptive Books do not show writing notes or grammar warning markers; grammar validation remains in the Binder and on the server when an Age is created. Opening a book never changes its 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, with no writing-notes pages. 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

@@ -1,6 +1,6 @@
 # GameTest suites
 
-The default dedicated-server run is a small smoke suite: 23 Rivencraft tests
+The default dedicated-server run is a small smoke suite. Its Rivencraft tests
 cover core linking, deterministic Age definition, writing persistence, legacy
 data migration, workstation transactions, and forged/replayed menu actions.
 
@@ -8,7 +8,7 @@ data migration, workstation transactions, and forged/replayed menu actions.
 ./gradlew runGameTestServer
 ```
 
-The remaining 58 Rivencraft tests are archived, not deleted. They cover
+The remaining Rivencraft tests are archived, not deleted. They cover
 completed milestone details such as every Age terrain profile, Notebook and
 Desk surface interactions, refill edge cases, book assembly controls, and
 workstation break/drop behavior. Run only the relevant archive alongside the
@@ -17,10 +17,15 @@ core tests when investigating an issue:
 ```shell
 ./gradlew runGameTestServer -ParchivedGameTestSuites=desk
 ./gradlew runGameTestServer -ParchivedGameTestSuites=grammar,binder
+./gradlew runGameTestServer -ParchivedGameTestSuites=generation
 ```
 
-Available suite names are `linking`, `environment`, `writing`, `grammar`, `desk`,
+Available suite names are `linking`, `environment`, `writing`, `grammar`,
-`binder`, `mixer`, and `recipe`. Run all 81 Rivencraft tests before a
+`generation`, `desk`, `binder`, `mixer`, and `recipe`. The `generation` archive
+keeps the detailed feature, structure, ore, crystal, and fissure regressions
+out of the default smoke run. Three checks formerly registered twice in the
+core and their archives now run only through the core wrapper. Run all
+Rivencraft tests before a
 release or after broad cross-system changes:
 
 ```shell
@@ -41,3 +46,126 @@ Logs and configuration remain available. Cleanup never targets a custom
 `-PgameTestRunDir` or a player world; callers using a custom directory manage
 it themselves. The full suite should still be run
 before shipping changes in the archived systems.
+
+If a new GameTest stalls the server, stop that run, remove the offending
+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.
+
+For issue #41, the combined archive and the focused `linking` archive initially
+stalled during the multi-profile travel acceptance test. That test is no longer
+registered with GameTest; the rerun passed all 116 registered tests before the
+subsequent random-biome-count adjustment. The 51-test core suite passes after
+that adjustment, but the full archive stalled again late in its first batch;
+do not treat that interrupted run as a pass. Verify its
+scenario manually: in a fresh world, bind
+one Descriptive Book for each of Standard, Flat, Amplified, Island, Cave, and
+Void terrain (use the corresponding Terrain Page to select each one). Visit
+each Age, confirm a safe arrival platform and headroom, and
+travel back using a bound Linking Book. The narrower creation, persistence,
+terrain, and travel checks remain automated. See
+[random Age weights](RANDOM_AGE_WEIGHTS.md) for the Legacy rank mapping and
+the opt-in weighting regression.
+
+Also bind several Link-Panel-only Descriptive Books with no authored biome
+pages. Check that each Age retains its biome set after leaving, unloading, and
+reopening it, and that the selected biome count varies between Ages without
+exceeding the eligible pool. This covers the bounded random-biome path touched
+after the last successful full-archive run.
+
+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
+the base paper/ink/vial operation and separate entries for Gunpowder, Mushroom
+Stew, Experience Bottle, Ender Pearl, Feather, and Fire Charge,
+with their property chances. Black Dye and Clay Ball should not appear: the
+former had no working Legacy effect, while Generate Platform is redundant
+with default Age arrival. Without JEI, Rivencraft should still
+start and the mixer should work normally.
+
+Put paper and an Ink Vial in the mixer. Hold Gunpowder on the cursor and
+right-click the ink basin once; one Gunpowder should be consumed, and hovering
+the basin should show a 20% Disarm chance. Black Dye, Clay Balls, and an
+unrelated item such as Stone should remain untouched.
+Closing and reopening the mixer should retain the chance. Taking a Link Panel
+should consume one paper and one full Ink Vial, clear the current
+mixture, and possibly give a panel with Disarm on its tooltip. Repeat until
+a property-bearing panel appears, craft it with leather, and confirm the
+unwritten Linking Book preserves the property tooltip. After binding it,
+link to another dimension; inventory items should drop at the departure point.
+With twenty Ender Pearls added to a fresh mixture, both Disarm and Intra
+Linking should show about 96.1%, and the basin should animate both property
+colors. Taking a panel should reset all three percentages and clear the color
+effect; a near-certain modifier should show the brighter outer animation.
+Also bind a Descriptive Book with a Disarm panel and check the same drop behavior.
+Bind a Descriptive Book with both Intra Linking and Maintain Momentum on its
+panel: the assembled book should retain Maintain Momentum but omit Intra
+Linking. For Linking Books, try an unmodified book whose destination is the
+current dimension: it should refuse travel. A Linking Book with Intra Linking
+should work in the same dimension. A Descriptive Book does not require or use
+Intra Linking, even if an older book retained that flag.
+Automatic Return Links should still appear according to the existing setting
+and work from an Age back to the Overworld. A full player inventory or blocked glass-bottle slot
+must not duplicate or consume materials for an output that cannot be taken.
+
+Link Panels should not enter Notebooks (folders) or Writing Desk tabs, whether
+clicked, shift-clicked, or dragged onto the page surface. An old Notebook or
+Desk already holding a Link Panel should still let the player take it out,
+but the Desk must not offer a copy of it. The Desk should continue to copy
+ordinary symbol Pages; JEI should show that example instead of Link Panel copying.
+
+## Manual Age unload/reload check
+
+The automated suite does not unload a freshly generated Age. Minecraft can
+queue point-of-interest block updates after generation; closing that Age's
+region storage while a queued update is still pending can leave the dedicated
+GameTest server waiting forever in `SectionStorage.readColumn`. Plan save/load,
+terrain generation, and safe spawn remain automated; runtime unload/reload is
+checked in a normal game session:
+
+1. Back up the test world. Bind one Link-Panel-only Descriptive Book and one
+   Descriptive Book with a terrain page (for example, Island), using distinct
+   names. Bring a working way back to the Overworld.
+2. Travel through each book, confirm the named Age and expected terrain, then
+   return to the Overworld. Close book screens and wait a few seconds.
+3. With cheats enabled, run `/rivencraft age list` and record each Age's
+   `rivencraft:age/...` dimension ID. Run `/rivencraft age unload <dimension>`
+   for one Age at a time, then list again to confirm it is unloaded.
+4. Reopen the same Descriptive Books and travel back. Confirm each book reaches
+   its original Age, the terrain and safe arrival remain intact, and no extra
+   Age entry was created. Save, restart the world, and repeat the book check.
+
+## Manual feature-generation check (Milestone 5, issue #35)
+
+The automated suite verifies feature pages, compiled and saved feature IDs,
+vanilla registry mappings, unsupported combinations, and the runtime generator.
+An automated scan across many newly generated chunks stalled the GameTest
+server, so physical placement is handed to the player for in-game verification:
+
+1. In a fresh world, bind a Descriptive Book with Link Panel, Standard Terrain,
+   Plains Biome, Single Biome, Caves, and Rocks pages in that order.
+   Missing weather/lighting/celestial branches may be seed-filled. Travel to
+   the Age and explore several fresh surface chunks: boulders made from one
+   seed-selected full-collision block should appear among the plains terrain.
+   Then explore underground in fresh
+   chunks; the Caves page should add a second cave-carving pass to Standard
+   terrain, not switch the Age to Cave terrain.
+2. Make a second book with Flat Terrain and Caves. The Binder should mark the
+   Caves page unsupported and prevent assembly. Cave Terrain plus Caves should
+   be accepted; Cave Terrain plus Rocks should be rejected.
+3. Return, save, and restart the world. Re-enter the first Age and explore
+   *new* chunks. The authored decorations should continue without rebinding.
+   Previously generated chunks are intentionally unchanged.
+4. Title-derived terrain regression (with Create installed): with no Terrain Page, assemble Link Panel,
+   Glowstone, Rocks, Chocolate, Small Lakes in that order and name the Age
+   `glow`. The Binder should accept it and generate compatible surface terrain;
+   Glowstone should be the rock material and Chocolate should appear in authored
+   Small Lakes across fresh chunks. Ordinary vanilla lava lakes may still occur.
+   Repeat
+   with `gl` or `glo` to confirm names do not change page validity. An explicit
+   Flat or Cave Terrain Page with Rocks should still be rejected.

docs/INK_MIXER_MODIFIER_AUDIT.md

@@ -0,0 +1,30 @@
+# Ink Mixer and Link Panel modifiers (Milestone 5, issue #36)
+
+Legacy source: [`InkEffects`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/InkEffects.java), [`TileEntityInkMixer`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/tileentity/TileEntityInkMixer.java), and [`LinkPropertyAPI`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/api/java/com/xcompwiz/mystcraft/api/hook/LinkPropertyAPI.java).
+
+Legacy does **not** use a conventional ingredient slot: the player clicks the ink basin with a carried item. Each accepted item is consumed immediately, changing the basin's property probabilities. A Link Panel is a virtual result; taking it consumes paper and ink, rolls each property independently using a saved next-seed, writes the selected flags to the Page, then resets that basin's mixture. The Link Panel passes those flags to a Linking Book made with leather. The preview must not roll or consume anything.
+
+| Ingredient | Property | Chance per item |
+| --- | --- | ---: |
+| Gunpowder | Disarm | 20% |
+| Mushroom Stew | Disarm | 5% |
+| Clay Ball | Generate Platform | 25% |
+| Experience Bottle | Intra Linking | 15% |
+| Ender Pearl | Intra Linking + Disarm | 15% each |
+| Feather | Maintain Momentum | 15% |
+| Fire Charge | Disarm | 25% |
+| Black dye | Empty effect key; ignored by Legacy's mixer | None in practice |
+
+Legacy also has optional ore-dictionary dusts: brass, bronze, tin, iron, lead, silver, diamond, and gold. Their effect combinations are in `InkEffects.init()`. Forge's ore dictionary does not exist in NeoForge 1.21.1, so these should be mapped through item tags only when a suitable tag and item exist; none should become a hard dependency. The `Relative` and `Intra Linking Only` properties are registered but have no built-in ingredient. `Natural`, `External`, `Offensive`, `Op-TP`, and `Following` are internal link flags, not mixer ingredients.
+
+For each additive, Legacy scales each existing probability by `1 - sum(additive chances)` and then adds the additive's probabilities. Properties are rolled independently on the final Page. The Legacy link effects are: Disarm drops carried inventory before travel; Generate Platform places a single arrival block if a drop exists; Maintain Momentum retains velocity; Intra Linking permits a same-dimension link.
+
+Rivencraft deliberately diverges from Legacy's shared-probability dilution here: each supported modifier accumulates independently as `new = 1 - (1 - old) × (1 - item chance)^item count`. Twenty Ender Pearls therefore produce about 96.1% each for Disarm and Intra Linking, and a panel can receive both. Taking the panel resets every probability to zero. The GUI uses Legacy's empty-basin atlas sprite, fills the basin dark when ink is present, and projects its colored rotating D'ni effect over the ink (red Disarm, blue Momentum, green Intra); the effect intensifies as a modifier approaches certainty and disappears after output is taken.
+
+Implementation requirements: keep the mixer server-authoritative; persist mixture probabilities and next-seed; show a deterministic virtual result; consume exact inputs once; prevent duplicate output on shift-click; preserve inputs when output cannot be taken; copy the Page's link properties into a Linking Book; apply supported properties only after destination validation; retain unmodified books' current safe-link behavior; and expose both base and modifier sequences to optional JEI. Tests should cover persistence, multiple additives, invalid items, full inventory/bottle output, and panel-to-book transfer.
+
+## Rivencraft 0.4.7.x implementation scope
+
+The built-in vanilla-item rows above are supported except black dye and clay balls. Legacy ignores black dye's empty effect key, so Rivencraft does not consume or advertise it in JEI. Clay Balls are omitted because Age arrival already builds a safe platform by default and a separate Generate Platform link modifier would be redundant. Right-clicking the Ink Mixer basin with a carried item adds one; left-clicking adds the carried stack. The mixture is persistent and its next panel is deterministic. The visual basin tooltip shows current probabilities. Only taking the virtual Link Panel consumes paper/ink and clears the mixture. The Link Panel's property component is copied to a Linking Book by the leather recipe or a Descriptive Book by the Binder. JEI's optional Ink Mixer category lists the base panel and each supported additive interaction with its per-property chance; Rivencraft does not require JEI to run.
+
+Disarm and Maintain Momentum are applied by the server after confirming a safe destination. Disarm spawns each inventory stack as an item entity at the departure point, including for Descriptive Books. Intra Linking is required only for a Linking Book whose destination is in the player's current dimension; ordinary cross-dimensional Linking Books still work. The Binder treats an Intra Linking panel as an ordinary Link Panel and omits that flag from the resulting Descriptive Book, while retaining Disarm and Maintain Momentum. Automatic Return Links remain enabled under the existing configuration, as requested. The old Generate Platform bit remains readable on pre-0.4.7.1 test items but is neither rolled nor applied. Optional dust-tag mappings remain outside this built-in subset until their cross-mod tags and gameplay meaning are agreed.

docs/INSTABILITY_DECAY.md

@@ -0,0 +1,13 @@
+# Colored decay (Milestone 6, issue #68)
+
+Legacy defines seven decay block-state colors and has a texture/model for every one: black, red, green, blue, purple, yellow, and white. That does not mean all seven are active instability hazards. Its active provider deck registers blue, purple, red, and white. Black has a decay handler and provider class, but its provider registration is commented out; green and yellow have visual states without registered spread handlers. Rivencraft currently implements the four active provider colors. Their 16×16 textures are exact copies of the local Mystcraft 1.12.2-0.13.7.06 assets at `assets/mystcraft/textures/blocks/decay_{blue,purple,red,white}.png`. Legacy's `blockdecay.json` and `blockdecay_*.json` map these to cube-all models; Rivencraft uses the same mapping.
+
+The local Legacy bytecode (`EffectDecayBasic`, `DecayHandlerSpreading`, and the four color handlers) seeds decay in a chunk, then spreads to six neighbors. Blue prefers softer blocks, red uses explosion resistance, purple is slower, and white converts almost anything and damages entities on contact. Rivencraft preserves the four colors, six-neighbor growth, relative conversion tendencies, and white contact damage. It adapts the exact difficulty formulas to modern block hardness and safety checks; fluids are not replaced, and provider attempts are deterministic from the Age seed and persisted attempt counter.
+
+Decay requires both `instability.world_mutation=true` and `instability_decay.enabled=true` in the server config. Both now default to true, matching Legacy's enabled-by-default Age instability and provider registration. Existing config files retain their saved values, including `false`; change them explicitly to opt in after updating an existing installation. At most `instability_decay.max_attempts_per_call` neighbors (default four) are examined, each within radius one, and at most one block can be replaced per provider run. The shared Age action budget may lower that further. Only chunks already loaded and supplied by the scheduler are touched; no cross-dimension or force-loading path exists. A per-Age `rivencraft_decay` saved data file stores a bounded frontier (1024 positions per color) and attempt counter. Disabling decay stops seeding, spreading, and white contact damage; existing blocks remain so re-enabling can resume.
+
+Decay rejects the saved Age spawn and its nearby 5×5 arrival platform (with a two-block margin), block entities, fluids, unbreakable blocks, vanilla portal/command/structure infrastructure, blocks in `#minecraft:portals`, all non-decay Rivencraft blocks, and blocks in `#rivencraft:decay_protected`. Data packs can append other mods' protected blocks to that tag. A fake-player break event is posted before replacement, and a placement event after it; a cancellation prevents or restores the change. As with other fake-player automation, protection mods need to handle NeoForge block events for this safeguard to apply.
+
+GameTests cover persistence, frontier deduplication, selected-chunk limits, and Overworld isolation. A real-client check should enable both settings in a disposable Age, observe growth, leave/reload that Age, then disable decay and verify growth stops. Also test a claim-protected block and a block entity if a protection mod is installed.
+
+For current test builds, an operator standing in an Age can use `/rivencraft age decay pulse white 32` (or `blue`, `purple`, `red`). This performs at most 32 budgeted provider calls in the player's already-loaded chunk and reports how many blocks converted. It does not edit the saved Age plan or instability score. Repeat the command to observe spread, leave/reload the Age to check persistence, then disable decay and confirm the command refuses to act. This test hook remains useful because the provisional authored-page scoring does not yet provide a reliable route to the Legacy eating deck's 15,000-point gate.

docs/INSTABILITY_ENVIRONMENTAL.md

@@ -0,0 +1,15 @@
+# Environmental instability (#70)
+
+The local Mystcraft Legacy 0.13.7.06 bytecode was audited for `EffectMeteor`, `EntityMeteor`, `EffectScorched`, `EffectErosion`, and their providers. The active deck registers `meteors` in destructive and `burning` (scorching) in harsh. Erosion's provider is present in bytecode but not registered in the active deck. Its old chunk-population lake routines are not run at Age creation in Rivencraft; ordinary authored lake features already own generation. The old erosion tick spread a neighboring water/lava or Forge fluid block into a random non-liquid position, excluding downward neighbors and block containers.
+
+Rivencraft keeps the active `meteors` and `burning` provider IDs in frozen Age plans. Erosion does not become a deck card. For this test slice, `instability_erosion.enabled` defaults **on** as an explicit adaptation requested by the user. It runs only in Ages whose frozen instability score reaches the destructive deck threshold (10,000), and may be disabled independently. Existing Age plans are not rerolled.
+
+Legacy's meteor spawned at Y=500, fell as a custom entity, broke blocks along its path, and made multiple large explosions on impact. Modern Ages can have different build heights and dynamic dimensions. Rivencraft instead records one bounded active descent per Age (16 globally), starting no more than 48 blocks above the loaded surface. Server particles show the trajectory and the byte-identical Legacy `entity/meteor/roar.ogg` plays near the impact. A single strength-3 impact reuses the capped explosion/protection hooks from #69. There is no persistent projectile entity or custom model; stopping/unloading a dimension cancels a descent rather than replaying it on restart. The saved per-Age attempt sequence and cooldown prevent immediate repeated rolls. The adaptation is intentionally less destructive than Legacy's chain of explosions.
+
+Scorching checks at most eight loaded chunks and eight living-entity candidates per chunk per scheduler pass, igniting at most the configured target count. Targets must be open to sky; survival/adventure players are included by default as in Legacy, while creative/spectator players and spawn safety positions are excluded. Fire duration is four seconds per provider level, capped at twelve seconds. This affects entities, not blocks, and does not request distant chunks.
+
+Erosion inspects at most eight already-loaded candidate positions per pass and can replace at most one safe block with an adjacent source fluid. It excludes block entities, protected/critical Rivencraft blocks, portals, spawn safety positions, and unloaded neighboring chunks. Break and place events with a fake player permit claim/protection hooks to veto a change; rejected placement is rolled back. World mutation and `mobGriefing` must also be enabled. The modern Y range is taken from the Age level rather than Legacy's fixed 0–127 sample.
+
+The server config has independent meteor enable/block damage/player damage/fire/caps, scorching enable/player targeting/cap, and erosion enable switches. Meteor frequency preserves Legacy's 1/50,000 chance per chunk-tick across nearby loaded chunks, capped to one active descent per Age. Visual/audio effects still run when meteor block damage is disabled. No client-only class is loaded on a dedicated server. The reused roar sound is recorded in [asset provenance](ASSET_PROVENANCE.md); Legacy has no separate meteor texture in the supplied asset tree.
+
+Operator checks in a loaded, sufficiently unstable Age: `/rivencraft age environment pulse meteor` starts one protected descent (200-tick cooldown), `/rivencraft age environment pulse burning` ignites the issuing survival player only when open to sky and outside spawn protection, and `/rivencraft age environment pulse erosion` converts the block being looked at if a source fluid touches its side or top. The burning test reports when rain or water would immediately extinguish the fire. Place water or lava next to a plain stone block and aim at the stone to test erosion. These commands refuse to run in the Overworld and still honor enable switches, protection hooks, and world-mutation policy. Natural meteor occurrence is intentionally rare, as in Legacy.

docs/INSTABILITY_RUNTIME.md

@@ -0,0 +1,19 @@
+# Instability provider runtime (Milestone 6, issue #66)
+
+Each new Age stores an `InstabilityPlan` beside its frozen `Instability` score. The version-1 plan contains provider IDs and levels. Selection uses the saved score rounded down to a 500-point step and the Age seed. It independently walks Legacy's basic, harsh, destructive, eating, and death decks with their audited entry costs (0, 2,500, 10,000, 15,000, 20,000), shuffling each deck deterministically before paying its weighted card costs. The source card weights and default provider costs are copied from the user's local Mystcraft 0.13.7.06 `InstabilityData` class. This preserves Legacy's multiple-deck behavior, but does not claim byte-for-byte reproduction of its historical Java RNG state, difficulty multiplier, config overrides, or 400-chunk block profiling delay.
+
+The saved provider IDs are independent of installed handlers. A missing optional handler leaves its ID and level intact and is skipped at runtime. A syntactically invalid saved ID or unsupported plan version fails loading explicitly; an unknown but valid ID is preserved and logged once when encountered. Disabling instability or world mutation never rewrites a saved score or provider plan. Saves from #64 with a frozen score but no provider plan are selected once from that score and Age seed, then marked dirty for persistence. Older pre-score Ages remain neutral and inert.
+
+The server scheduler runs only for loaded `rivencraft:age/*` levels with a player present and an Age definition. It uses only chunks already loaded near those players, never requests a chunk, and rotates among eligible Ages when the per-tick cap is reached. Configuration bounds the cooldown (minimum 20 ticks), active Ages, handlers and actions per Age, effective provider level, and examined loaded chunks. A handler must claim a shared action permit before each effect. A throwing handler is logged and quarantined temporarily without stopping the server. World-mutating handlers are enabled by default to match Legacy; the setting can still disable them. These limits are guards for upcoming providers, not proof that an arbitrary third-party handler cannot misuse world APIs.
+
+Issue #67 registers the non-world-mutating potion handlers; see [status-effect policy](INSTABILITY_STATUS_EFFECTS.md). Issue #68 adds configurable [colored decay](INSTABILITY_DECAY.md), enabled by default for newly generated configs. Issue #69 adds lightning and explosions; issue #70 adds [meteor, scorching, and erosion](INSTABILITY_ENVIRONMENTAL.md). The runtime rejects Overworld and preview dimension IDs; its player requirement excludes unattended snapshot chunk loaders. GameTests cover deterministic selection, save round-trips, score-only migration, unknown IDs, scope checks, fair admission, and action caps.
+
+# Lightning and explosions (#69)
+
+The `lightning` and `explosions` cards now run only in loaded Rivencraft Ages with players. Legacy rolled once per chunk per tick: explosions at 1/1000 and lightning at 1/5000 during thunder or 1/100000 otherwise. Each selected hazard card gets an independent roll every scheduler pass, rather than waiting for the rotating two-provider sample. The roll uses up to 81 already-loaded chunks near Age players and the exact probability of at least one Legacy opportunity over that many chunk-ticks. It permits at most one event per hazard type per pass. A per-Age saved sequence and last-event time prevent the same roll/event from replaying after a restart. Lightning also skips an existing bolt at the target.
+
+Legacy used a real lightning bolt and a flaming, block-damaging strength-3 explosion. Both remain enabled by default. Unlike Legacy, the bolt is visual-only and its damage/fire are applied through separate bounded paths. The explosion uses NeoForge's normal explosion hooks plus break-event checks, with a calculator that restricts destruction to one already-loaded chunk, protects spawn, block entities, portals, decay-protected blocks and Rivencraft infrastructure, and caps affected blocks and entity damage. The visual/audio explosion still occurs when griefing is disabled. `mobGriefing` and `doFireTick` gate block changes and ignition; survival/adventure player damage is separately configurable. These are deliberate modern server-safety differences from Legacy.
+
+Server config `instability_hazards` controls enablement, block damage, player damage, fire, interval, maximum nearby loaded chunks, maximum destroyed blocks, damaged entities, damage per entity, and explosion radius. `instability.world_mutation=false` also suppresses block damage and fire without suppressing visuals or entity damage. No hazard is dispatched into preview, Overworld, or another Age.
+
+For an operator smoke test inside an Age, `/rivencraft age hazard pulse lightning` and `/rivencraft age hazard pulse explosion` force one event in a safe loaded chunk. They still honor the Age scope, enable switch, cooldown, spawn exclusion, game rules and damage policies. Repeat after `minimum_gap_ticks` (default 20 ticks); run the same command in the Overworld to verify that it refuses to fire. The earlier 200-tick `min_interval_ticks` test key is retired; existing configs receive the new default when NeoForge corrects them.

docs/INSTABILITY_SCORE.md

@@ -0,0 +1,9 @@
+# Frozen Age instability score (Milestone 6, issue #64)
+
+Every newly created Age now gets a version-1 `Instability` compound inside its server-owned `rivencraft_ages` saved definition. It contains the total `Score` and an ordered `Breakdown` of reason, original page index (zero-based, or -1 for an Age-wide cause), points, and explanation. `AgeRegistrySavedData.instability(UUID)` is the read-only server query. No client tooltip or live data-pack lookup is needed to read a saved score.
+
+The baseline is explicitly zero for page-free and Link-Panel-only random Ages, and for authored Ages. Incomplete writing receives seed-based completion and a zero-point explanatory entry. Supported writing defects use the provisional Milestone 6 grammar costs: duplicate/conflicting single-choice pages +500, out-of-order or misplaced pages +100. Legacy's audited bright-lighting symbol adds +500 whether authored or seed-selected. Other balance costs are not guessed for symbols that Rivencraft has not implemented. The score is not yet an active hazard or effect selection.
+
+The score is calculated after the Age plan and effective traits are chosen, then saved with the Age identity before its dimension is generated. The same UUID returns the existing definition, including the same score, on repeated use. Spawn updates preserve it. Reload only deserializes the frozen breakdown; it never reruns the current grammar or catalog. An older Age definition without `Instability` is migrated to a persisted version-1 neutral score of zero, rather than retroactively scoring its writing. A future scoring-rule change must introduce an explicit new schema/migration policy, not silently reinterpret existing Ages. Issue #66 additionally freezes a provider selection from this score; see [runtime policy](INSTABILITY_RUNTIME.md).
+
+Unknown or unsupported pages remain invalid for *new* Ages. Their absence from a later registry does not change an already saved score. Focused GameTests cover stable/defective writing, random baseline and bright lighting, repeated identity, save round-trip, and missing-symbol/old-save behavior.

docs/INSTABILITY_STATUS_EFFECTS.md

@@ -0,0 +1,9 @@
+# Age status effects (Milestone 6, issue #67)
+
+This slice activates the Legacy potion cards selected and saved by issue #66. The user-provided Mystcraft 0.13.7.06 `EffectPotion` chooses a random living entity in a chunk section. A local card requires sky visibility; a global card does not. `EffectPotionEnemy` excludes players. Its amplifier is selected level minus one. The defaults in `InstabilityData` give blindness and nausea 60 ticks, mining fatigue/hunger/poison/slowness/weakness 80 ticks, wither 30 ticks, and enemy regeneration/resistance 200 ticks. Rivencraft preserves those durations, sky rules, and level-to-amplifier mapping, subject to the server's lower duration/level caps.
+
+General debuffs can affect survival/adventure players and other living entities, as Legacy did. The two enemy buffs affect hostile mobs only; Legacy affected any non-player living entity, so excluding passive animals is a deliberate modern adaptation. Creative and spectator players are exempt per issue #67, although the inspected Legacy potion class did not have that exemption. Existing effects from vanilla or another mod are never overwritten.
+
+The issue #66 scheduler chooses an already-loaded chunk near a player, at most the configured number of provider calls and action claims per Age run. This provider queries at most `max_candidates_per_attempt` living entities in that chunk, picks one deterministically from the bounded candidates, and claims an action before applying. It holds at most `max_active_per_age` short-lived, owned-effect leases. It neither force-loads chunks nor scans all entities or chunks. Exact target RNG therefore intentionally differs from Legacy's random chunk-section walk; the target types, local/global distinction, duration, and strength are retained.
+
+The server config can disable all status effects, player targets, general non-player targets, or hostile buffs, and can lower active leases, candidates, and duration. Leaving an Age, logging out, disabling effects, or stopping the server removes only an effect instance this provider actually installed; it will not remove a replacement from another mod. Leases also expire automatically after their short duration. The runtime never runs in the Overworld or a preview dimension. Automated tests cover mappings, target eligibility, creative/spectator exemption, and Overworld isolation. In-game multiplayer, Age-to-Age travel, and restart checks remain useful because GameTests do not create a second dynamic Age for this slice.

docs/LEGACY_AGE_GRAMMAR_AUDIT.md

@@ -18,7 +18,7 @@ Legacy does **not** reject a book just because it omits terrain, biome, weather,
 | `WeatherNorm`, `Fast`, `Slow`, `Off`, `On`, `Cloudy`, `Rain`, `Snow`, `Storm` | `AgeTraits.Weather` has matching names except Legacy `On` maps to `ALWAYS` | Compile weather semantics separately from biome selection. `Snow` must remain deferred until optional season integration; do not silently substitute another weather mode. |
 | Suns, moons, starfields; angle, phase, period, color/gradient/sunset modifiers | One `celestialPeriod`, `celestialAngle`, `celestialPhase` on `AgeTraits` | Compile only the representable single-cycle subset first. Multiple celestial bodies, independent periods, custom stars, gradients and sunsets need a richer definition and renderer, not flattening into one value. |
 | Sky/fog/cloud/grass/foliage/water colors, natural variants, horizon, rainbow | Existing sky/dimension visuals and preview | Require an explicit modern client/biome-color design; metadata-only symbol pages must not pretend to change rendering. |
-| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile and vanilla data-pack generation | Compile only features for which registered 1.21.1 placed features/structures exist. Defer bespoke structures and polish to milestone 7. |
+| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile, authored Floating Islands/Tendrils/Skylands/Spheres/Spikes/Obelisks/Crystal Formations/Star Fissures and Dense Ores, and page-gated vanilla Dungeons/Mineshafts/Nether Fortresses/Strongholds/Villages | The five Legacy vanilla structure symbols gate Minecraft 1.21.1 generation. Dungeons use monster-room placement; the others use vanilla structure sets. Obelisks use a bespoke 4×4 plinth and 2×12×2 shaft with safe modern placement. Crystal Formations retain Legacy's blue tile and one-in-fifteen attempt rate but use new budding, shard-producing mounds. Star Fissures reproduce Legacy's spawn-chunk footprint, open-to-sky columns, home link, and sound. Their renderer uses the modern End Portal pipeline in place of Legacy's retired fixed-function OpenGL calls. Exact 1.12 geometry for other structures remains separate work. |
 | `EnvAccel`, explosions, lightning, meteors, scorching; PvP and dummy suppression pages | No equivalent Age-definition effect | Defer environmental hazards/instability effects to milestone 6, PvP rule to a separately scoped server policy; retain authored IDs without fake behavior. |
 
 The Legacy symbol list and page names come from [ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L129-L240) and [SymbolRules](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/SymbolRules.java#L19-L137). Rivencraft's [catalog](../src/main/java/net/dnorberg/rivencraft/writing/SymbolCatalog.java) currently holds display metadata only; its built-in set is just standard terrain, native biomes, normal weather, normal lighting, normal time, and caves. [OrderedWriting](../src/main/java/net/dnorberg/rivencraft/writing/OrderedWriting.java) preserves page order, but no compiler yet connects it to [AgeTraits](../src/main/java/net/dnorberg/rivencraft/book/AgeTraits.java) or [Age profiles](AGE_PROFILES.md).

docs/LEGACY_INSTABILITY_AUDIT.md

@@ -0,0 +1,64 @@
+# Mystcraft Legacy instability audit (Milestone 6, issue #63)
+
+This is a behavior contract for Milestone 6, **not a completed runtime instability system**. It compares the user-provided 0.13.7.06 class files at `/home/dnorberg/Documents/mystcraft-src/mystcraft-1.12.2-0.13.7.06/` with [Mystcraft Legacy source at commit `9bc8ddc`](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae). Values below are source defaults, not a claim that every historical config or server used them. Rivencraft 0.5.1.0 saves a provisional writing-instability score and repaired active-page order, but has no hazard loop yet.
+
+## Score, grammar, and selection in Legacy
+
+Legacy's [`AgeController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java) calculates `debug + symbol + block + book/base + bonus`, then applies difficulty 0/1/2/3 multipliers of 0.25/0.5/1/1.75. Global instability is enabled by default; an Age also has its own enable flag. The unmodified score is not simply “number of bad pages.” Block profiling may delay a usable score: `blockinstability` is null until **more than** 400 Age chunks are profiled, and `getInstabilityScore()` returns zero until then. It is recalculated after additional profiling. [`ChunkProfiler`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/profiling/ChunkProfiler.java) compares watched block abundance with a baseline, subtracting only positive excess above each baseline. The baseline is profiled or read from balance config; [`InstabilityDataCalculator`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/profiling/InstabilityDataCalculator.java) sets its default tolerance to 1.05, and default `useconfigs=false`. We should not copy its 400-chunk profiling delay or dynamic block scan into 1.21.1 without a separate performance case.
+
+| Input | Verified Legacy behavior | Rivencraft M6 interpretation |
+| --- | --- | --- |
+| Missing required controller | Terrain, biome controller, weather, and lighting are generated when missing. `InstabilityData.missing.controller = 0`; lighting explicitly adds zero. Missing pages themselves are not a penalty. | Keep Age-seeded completion. No penalty solely for an omitted branch. |
+| Repeated same symbol | `addSymbol` increments a per-`IAgeSymbol` count and adds that symbol's `instabilityModifier(count)`. This method is symbol-specific; there is no universal “duplicate = N” rule. | Distinguish legal repeated features/materials from repeated single-choice pages. Do not add a flat duplicate penalty to every occurrence. |
+| Extra/conflicting controller | Registering a second terrain, biome, weather, or lighting controller adds `InstabilityData.extra.controller = 500`; the **last registered** controller replaces the prior one. This is separate from each symbol's own modifier. | Eligible supported conflicts may become unstable rather than fatal in #65, with deterministic winner and a saved penalty. |
+| Dangling modifier | An unconsumed modifier contributes its `dangling` value; a default `Modifier` has `dangling=100`. Replacing a pending modifier charges the old one. `clearModifiers()` charges 20% (`clearPercentage=0.20`) of each pending value, with Java integer compound-assignment truncation. | Record the ordered offending page and a reason; calculate a deterministic penalty from the consumed/leftover modifier semantics, not from GUI position alone. |
+| Unsupported/unmatched page | Legacy logs unmatched symbols during reconstruction and skips their logic; its `AgeData.getBaseInstability()` still has a TODO for calculating instability from pages. This is not a sound compatibility contract. | Remains fatal for *new* books until semantic and runtime support exists; never silently erase the page or pretend its effect applied. Existing saved books retain their IDs. |
+| Other penalties/bonuses | `AgeController.addInstability(int)` is available to symbol logic. The base/book score is persisted as a `short`; Legacy's [`InstabilityBonusManager`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/bonus/InstabilityBonusManager.java) also has dynamic player death/behavior components. | Persist a versioned score breakdown for Age writing and environmental contributions. Do not infer death/troll mechanics from the mere existence of Legacy classes. |
+
+Source for controller and modifier defaults: [`InstabilityData`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java), [`AgeController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java). The local 0.13.7.06 `Modifier.class` confirms `dangling_default=100`. Legacy grammar **ranks** weight which missing symbols are selected; they are not a direct instability score or deck tier. See [grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) and [random weights](RANDOM_AGE_WEIGHTS.md).
+
+[`InstabilityController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityController.java) rounds its working score toward zero to the current smallest registered positive provider cost (500 by default), then rebuilds active effects when that rounded score changes. Each seeded deck preserves its saved card order; new cards are shuffled with the Age seed. For each deck it subtracts the deck entry cost, then walks cards in order, paying each provider activation cost until the next card cannot be afforded. A provider's occurrences become its level. **Deck costs are gates, not mutually exclusive severity bands**: at high score multiple decks can contribute effects. Provider `.enabled` config can remove cards. The actual effect set cannot be inferred from a score alone without the saved deck orders and enabled providers ([`Deck`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/Deck.java), [`InstabilityManager`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityManager.java)).
+
+| Legacy deck | Entry cost | Examples of registered cards |
+| --- | ---: | --- |
+| basic | 0 | enemy regeneration/resistance, fatigue, hunger, poison, slowness, weakness |
+| harsh | 2,500 | stronger/global potions, burning, lightning, wither |
+| destructive | 10,000 | crumble, explosions, lightning, meteors, wither |
+| eating | 15,000 | colored decay, blindness, nausea, wither |
+| death | 20,000 | global blindness/nausea/wither, colored decay |
+
+These entry costs are from [`InstabilityData.initialize()`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java), not guaranteed first-activation scores: each card also costs 500–5,000 depending on provider. A zero-cost basic deck still needs enough score to buy its first card. `stability.*` numbers in that file are provider activation costs, despite the misleading field name.
+
+## Effect inventory and modern policy
+
+[`InstabilityData.initialize()`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java) is the authoritative list of *registered* providers. Some implemented classes are commented out there; their existence does not mean they occur normally. Each Legacy environmental effect is called for chunks that the Age's runtime processes, often with its own chance. No per-Age global work budget is visible in these effect classes.
+
+| Family | Legacy behavior | M6 disposition |
+| --- | --- | --- |
+| Player and hostile-mob potions | Local/global blindness, fatigue, hunger, nausea, poison, slowness, weakness, wither; hostile regeneration/resistance ([`EffectPotion`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectPotion.java)). | Implement in #67 with server-only, Age-scoped entity targeting and rate limits. No effects in preview/snapshot worlds. |
+| Colored decay | Blue, purple, red, white providers place advancing decay and extra-tick it; black provider is commented out. Decay handlers differ in spread/consumption ([providers](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/providers), [handlers](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/decay)). | Implement bounded, reversible-by-admin world mutation in #68; exact 1.12 spread/update rates require adaptation and tests. Exclude protected spawn/portal areas. Black/green/yellow are **not** proven active Legacy providers. |
+| Lightning and explosions | Random per-chunk strike/explosion attempts ([`EffectLightning`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectLightning.java), [`EffectExplosions`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectExplosions.java)). | Implemented in #69 with separate damage/fire/griefing policies and loaded-Age bounds; see `INSTABILITY_RUNTIME.md`. |
+| Meteor, scorching | Meteor entity spawn and sky-exposed entity ignition ([`EffectMeteor`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectMeteor.java), [`EffectScorched`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectScorched.java)). | #70 implements a bounded meteor descent/impact and the active `burning` card; see `INSTABILITY_ENVIRONMENTAL.md`. Legacy `meteor/roar.ogg` is reused. |
+| Crumble and erosion | Crumble maps blocks to weaker states; erosion spreads adjacent fluids and has extra lake-generation methods ([`EffectCrumble`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectCrumble.java), [`EffectErosion`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectErosion.java)). | #70 implements guarded fluid spread. Erosion's provider is absent from the active Legacy deck; it is deliberately enabled by default in this test slice without adding a saved deck card, per user request. |
+| Extra ticks | Registered alongside blue/purple/red/white decay, targeting decay blocks ([`EffectExtraTicks`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectExtraTicks.java)). | Implement only as a bounded decay helper in #68; do not accelerate arbitrary blocks/block entities. |
+| Other dormant code | Black decay, global burning, bedrock crumble, erosion provider are commented out; ordinary `burning` (scorching) remains active. | Erosion has been explicitly requested for #70 testing. The other dormant variants remain deferred; an authored symbol requiring one must fail clearly until supported. |
+
+Assets in the supplied local tree: `assets/mystcraft/textures/blocks/decay_{black,blue,green,purple,red,white,yellow}.png`, corresponding decay block/item model JSON, and `assets/mystcraft/sounds/entity/meteor/roar.ogg`. Before importing, review attribution/license and fit modern 16×16 assets. Texture availability does not make an effect active. Use current Minecraft effects/sounds where adaptation is cleaner; no new artwork is needed for this audit.
+
+## Rivencraft boundary and proposed safety contract
+
+[`WritingGrammar`](../src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java) classifies `INCOMPLETE` as seeded completion and supported writing defects as accepted instability. `AgeGenerationPlan.compile()` freezes the original writing, repaired active-page indexes, and a provisional writing-instability score before world generation. #64 now persists a versioned score breakdown; saved provider/deck choice remains future work. The plan must not mutate an already-created Age when a data pack changes. Server-side settings may disable execution, but should not rewrite the saved authored score.
+
+For #65, **eligible-to-become-unstable** means a known, supported page whose semantics and resulting world are still deterministic: repeated/conflicting single-choice pages and otherwise valid out-of-order or misplaced pages. The implementation retains every original page, uses the last single-choice page, sorts active categories, and saves 500 per extra/conflicting choice or 100 per misplaced page. These are provisional Rivencraft values, not a full port of every `IAgeSymbol.instabilityModifier`. Missing branches are explicitly classified as zero-cost seeded completion; legal repeated feature/material pages are not automatically errors. **Remain fatal**: missing/duplicate/misordered Link Panel, over-capacity book, unresolved or schema-v1 display-only symbol, unsupported weather/angle/runtime profile/biome/feature, unavailable required optional mod, and any combination the compiler cannot represent safely. Binder and unbound-book previews distinguish blocked writing, seeded completion, and accepted instability before binding; the server revalidates on output. This intentionally differs from Legacy's silent unmatched-symbol skip, universal controller cost assumptions, and modifier-specific dangling costs. A full symbol-specific Legacy penalty port remains a separate balance task, not a claim of parity in this slice.
+
+Automated #65 checks cover classification, preserved input slots on rejection, and an accepted unstable preview. The live output/one-time Age creation check is assigned to in-game testing because the GameTest storage phase stalled when that transaction ran; the test world is not retained.
+
+Issue #66 establishes a server-only scheduler with bounded per-Age actions, provider calls, levels, cooldowns, loaded-chunk candidates, and rotating active-Age admission. World-mutating handlers are **off by default**. No provider effects are registered yet; #67–#70 must enforce protected spawn/link platforms, portals, and provider-specific damage/spread limits before activation. These are **Rivencraft safety adaptations**, not Legacy defaults. Expose score breakdown, selected effects, enablement, and budget suppression in server diagnostics (#72). See [runtime policy](INSTABILITY_RUNTIME.md).
+
+M6 owns scoring, selection, effects, controls, and regression. M7 still owns portal/transport and broader polish; M6 must not depend on new M7 structures. An illegal biome/terrain combination that is presently unrepresentable remains a generation failure until a separate, safe compiler path exists; instability must not be used to disguise absent worldgen support. Existing pre-release saves need explicit migration behavior in #73 rather than a silent rescore.
+
+## Verification and open questions
+
+- Inspected pinned source for `AgeController`, `AgeData`, `GrammarTree`, `InstabilityData`, `InstabilityManager`, `InstabilityController`, `Deck`, all active provider families, effect classes, `ChunkProfiler`, and `InstabilityDataCalculator`; checked matching local 0.13.7.06 class names and `Modifier.dangling_default` with `javap`.
+- The supplied extraction has no generated user balance config; registered defaults can be overridden or providers disabled. There is no single universal instability value for “wrong order” or “duplicate page.” `IAgeSymbol.instabilityModifier(count)` implementations and runtime configs determine the final Legacy value.
+- Exact Legacy visual/decay behavior, dynamic bonus registration, and full 1.12 block-baseline parity need focused checks when their slices are implemented. Do not label proposed modern caps as source facts.

docs/MILESTONE_5_ACCEPTANCE.md

@@ -0,0 +1,39 @@
+# Milestone 5 acceptance: Age grammar
+
+This is the completion record for [Gitea issue #42](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/issues/42) and release 0.5.0.0. Issues #28–#41, #45–#59, #61, and #62 are closed. #39 was closed with an explicit Ecliptic Seasons limitation, not with a working Ecliptic adapter. #42 is the final gate. Issues #43, #44, and #60 are separate open follow-ups, not hidden Milestone 5 completion claims.
+
+## Authoring and generation contract
+
+- Schema-v2 symbol JSON lives at `data/<namespace>/rivencraft/symbols/<path>.json`. Its file path is the stable page ID; `name`, `description`, and `category` are display metadata, while typed `semantics.role` and `semantics.value` control generation on the server. See [schema and role table](SYMBOL_SEMANTICS.md). Schema v1 remains display-only. Registry-derived biome, solid-block, and source-fluid pages are generated from valid registered entries rather than requiring one PNG or JSON definition per material.
+- Ordered writing is parsed as Link Panel, terrain, biomes/controller, weather, season, lighting, sky, celestial modifiers/celestial, then material/feature pairs. Missing branches are seeded completion warnings. Unresolved symbols, unsupported combinations, conflicting single-choice pages, incorrect order, and an invalid Link Panel produce Binder diagnostics before items are consumed. Repeated feature and material pages retain their occurrence order. See [grammar and diagnostics](WRITING_GRAMMAR.md).
+- Legacy's grammar ranks informed the random-choice weights; Rivencraft does not claim to run Legacy's complete 1.12.2 grammar or reproduce its terrain byte-for-byte. The [source audit](LEGACY_AGE_GRAMMAR_AUDIT.md), [weight table](RANDOM_AGE_WEIGHTS.md), and [runtime profiles](AGE_PROFILES.md) record exact mappings and adaptations. Authored supported symbols override seeded choices. A page-free or Link-Panel-only Descriptive Book creates a random Age. The resolved plan, seed, profile, biome IDs, traits, features, and writing order are saved with its Age identity before chunks generate. Reopening a book or restarting must not reroll it.
+- Feature pages cover decorations, terrain additions, dense ores, crystals, fissures, and supported structures including Trial Chambers and newer vanilla structures. Material pages may explicitly choose a compatible block/fluid or receive a seeded compatible feature. Terrain and biome eligibility still restrict combinations; incompatibility is reported rather than silently ignored. [Age documentation](AGES.md) and [feature rules](WRITING_GRAMMAR.md) describe the supported subset.
+
+## Optional integrations and fallback
+
+| Integration | Milestone 5 result |
+| --- | --- |
+| TerraBlender | Optional adapter reads registered Overworld and Nether region biome IDs. Any compatible biome-producing mod using those regions can supply eligible pages; no Biomes O' Plenty ID is hard-coded. Missing TerraBlender leaves vanilla Age generation intact. A removed biome warns and uses an eligible load-time fallback without rewriting the saved plan. See [TerraBlender checks](TERRABLENDER_COMPATIBILITY.md). |
+| Serene Seasons | Optional per-Age seasonal modes: No Seasons, Seasons, Eternal Winter/Summer/Fall/Spring. The adapter enrolls dynamic Age IDs in Serene's whitelist and synchronizes connected clients without a restart. Its internal config/saved-clock hooks are version-sensitive because a public dynamic-dimension registration/fixed-season API is unavailable. Without Serene, only No Seasons is valid for a *new* book; saved Ages retain their data with effects inactive. See [config and real-client checks](SERENE_SEASONS_COMPATIBILITY.md). |
+| Ecliptic Seasons | Deliberately not integrated. Its 1.21.1 `ValidDimensions` setting requires a world restart and caches validity on server/client level load; no supported live registration or per-dimension calendar-control API was found. Issue #39 records the blocker and the upstream API needed to revisit it. Rivencraft does not require Ecliptic and does not support both season mods together. |
+| JEI, Create/Ponder, Immersive Portals | Optional presentation/integration paths; none is required for core dedicated-server loading or Age grammar. Existing preview fallback and manual checks remain in [preview compatibility](PREVIEW_COMPATIBILITY.md). |
+
+## Migration, limits, and milestone boundary
+
+Existing saved writing keeps its stable IDs and order. Unresolved pages remain recoverable in books instead of being silently replaced. Existing bound books without a plan are not reinterpreted as newly authored grammar. A frozen plan can load without the old symbol definition or runtime-profile JSON, but missing referenced registry resources prevent or alter that load as documented in [runtime profiles](AGE_PROFILES.md); restore the data pack/mod and keep a backup. The migration regression suite covers legacy writing components, schema-v1 display pages, missing symbols, and old Binder/Desk data. It is **not** a promise of full compatibility with every pre-release world; that broader requirement is tracked separately by open issue #60.
+
+Milestone 5 owns recognized symbol semantics, ordered grammar, deterministic completion, persistent Age configuration, and supported feature/integration effects. Milestone 6 owns instability from invalid or excessive writing and server-safe instability effects. Milestone 7 owns remaining structures/polish, portals, recipes, models, sounds, advancements, and migration depth. Several Legacy structures and crystals were pulled forward into Milestone 5 as their own closed port issues; that does not imply the rest of Milestone 7 is complete. Custom multi-body skies, gradients, unsupported direct Rain/Snow pages, and exact Legacy terrain/feature parity remain outside the accepted M5 subset. Open issue #44 tracks custom skybox work.
+
+## Test and acceptance matrix
+
+| Check | Result or handoff |
+| --- | --- |
+| Default dedicated-server GameTests, no optional mods | 26/26 passed after moving 25 detailed generation checks to the selectable `generation` archive. Core persistence, grammar, transaction, and migration checks remain. |
+| Focused generation archive | 51/51 passed on the reduced core plus `-ParchivedGameTestSuites=generation`. No generation test was deleted; 25 detailed checks moved out of the default run. |
+| Full archive | Previously passed 116/116 before the final random-biome-count adjustment in #41. Its later rerun stalled in the first batch and was stopped under the project GameTest rule; **not** claimed as a passing current run. Manual random-Age biome and six-terrain travel checks are in [GameTest handoffs](GAMETESTS.md). |
+| Optional TerraBlender | An earlier optional-mod GameTest run passed 51/51; Biomes O' Plenty/Nether-region behavior was checked in-game during #37. The published jar does not bundle TerraBlender. |
+| Optional Serene Seasons | In-game acceptance was recorded on #38 for six pages, saved whitelist, and no-restart sync. The GameTest mock player cannot negotiate Serene's season packet; the real-client path is documented. |
+| Gradle build and JAR | `./gradlew build --offline --no-daemon` passed and produced `build/libs/rivencraft-0.5.0.0.jar`. Its SHA-256 is attached to the Gitea release. |
+| Asset audit | Three byte-identical PNGs were replaced by references to their retained counterparts; no other unreferenced shipped textures or sounds were found. The user-provided `dev images` reference remains untouched. |
+
+Completion checklist: implementation issues reviewed; #39 explicitly scoped as unsupported; schema/Legacy/grammar/generation/integration/migration boundaries documented; core and focused validation recorded; current archive stall disclosed; release JAR and SHA-256 published; issue #42 and Milestone 5 closed **only after** those release artifacts are verified.

docs/PORTING.md

@@ -34,14 +34,17 @@ acceptance issue and all required implementation issues are complete.
    renderer compatibility. **Complete.** See
    [Milestone 3](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/8).
 4. **Writing system** — pages, notebooks, desks, book assembly, and the baseline
-   Ink Mixer for Link Panels. Symbol effects are deferred until Milestone 5.
+   Ink Mixer for Link Panels. Symbol effects were deferred to Milestone 5.
    **Complete.** See [Milestone 4](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/9)
    and [writing-system data and migration](WRITING_DATA.md).
-5. **Age grammar** — translate symbol combinations into modern biome, noise,
+5. **Age grammar** — translate supported symbol combinations into modern biome,
-   dimension-type, and world-generation configuration. Optional integrations
+   noise, dimension-type, and world-generation configuration, with optional
-   may add composable biome regions and seasonal behavior. See the
+   TerraBlender and Serene Seasons integration. **Complete for the supported
+   subset.** See the [acceptance record](MILESTONE_5_ACCEPTANCE.md) and
    [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md).
-6. **Instability** — deterministic validation and server-safe effects.
+6. **Instability** — deterministic validation and server-safe effects. Start with the
+   [Legacy instability audit](LEGACY_INSTABILITY_AUDIT.md), which separates
+   source behavior from proposed 1.21.1 safety limits.
 7. **Structures and polish** — libraries, crystals, portals, recipes, models,
    sounds, advancements, compatibility, and migration tests.
 
@@ -61,17 +64,16 @@ live rendering when their dependencies are installed. The tested selection
 matrix and integration boundaries are documented in
 [PREVIEW_COMPATIBILITY.md](PREVIEW_COMPATIBILITY.md).
 
-The writing system and Age grammar will build on the existing page-free Age
+The writing system and Age grammar build on the existing page-free Age path.
-path. Page-free books remain a useful deterministic fallback and test fixture
+Page-free books remain a useful deterministic fallback and test fixture.
-after written symbol combinations become available.
 
 Milestone 4 delivered a versioned, data-pack-defined symbol catalog and an
 immutable ordered-writing model. See [WRITING_DATA.md](WRITING_DATA.md). These
-contracts preserve unknown symbol identifiers and store author intent; they do
+contracts preserve unknown symbol identifiers and store author intent;
-not interpret symbols into Age generation, which remains Milestone 5 work.
+Milestone 5 adds the server-owned interpretation and persistent Age plan.
 The Ink Mixer is included in Milestone 4 after book assembly; it
 uses paper and Ink Vials to make baseline Link Panels. Adding modifier
-ingredients and symbol-driven link properties belongs to Milestone 5.
+ingredients and symbol-driven link properties were delivered in Milestone 5.
 
 ## Provenance rules
 

docs/RANDOM_AGE_WEIGHTS.md

@@ -0,0 +1,18 @@
+# Random Age selection (issue #41)
+
+Page-free and Link-Panel-only books still make one random Age definition from the Age seed. A written page overrides its branch; random completion never rewrites the book. The resulting terrain, traits, season mode, biome pool, and feature choices are saved with the Age identity, so loading an existing Age does not reroll it. This change affects **new** Ages only.
+
+The rank-weight calculation follows Mystcraft Legacy's `GrammarGenerator.buildRankWeights` in the user-provided 0.13.7.06 classes: starting at the highest numbered (rarest) rank, a rank's weight is at least one greater than the preceding rank's total divided by the number of entries at the current rank. A missing intermediate rank still advances the weight. The corresponding `SymbolRules` entries supply the ranks. This is a selection policy, not a port of Legacy's full grammar tree or its Minecraft 1.12 world generator.
+
+| Branch | Relative tickets for supported choices |
+| --- | --- |
+| Terrain | Standard 6, Flat 5, Amplified/Island/Cave/Void 1 each. Cave and Island occupy the rare slots corresponding to Legacy Nether and End terrain. Additional data-pack runtime profiles default to the rare rank and cause the group weights to be recomputed. |
+| Biome controller | Native/Single/Medium 3 each; Tiled/Grid/Tiny/Small/Large/Huge 1 each. The selected controller still applies terrain eligibility and minimum-biome rules. |
+| Additional random biomes | After Rivencraft's existing controller minimum, each extra biome has a 2-in-3 continuation chance and a 1-in-3 stop chance, capped by the eligible biome pool (including optional TerraBlender additions). This mirrors Legacy's ranked biome-list branch without changing the project's authored-page minimums. |
+| Lighting | Normal 3; Dark/Bright 1 each. |
+| Weather | Normal 9; Fast/Slow/Off/Always/Cloudy/Rain/Snow/Storm 1 each. WeatherOn is named Always here. |
+| Season (Serene Seasons only) | Seasons 6, No Seasons 5, each eternal season 1. These are Rivencraft ranks for features absent from Legacy; normal cycling is most common and eternal seasons are rare. No season policy is rolled without Serene Seasons. |
+
+Random-feature selection remains bounded to two material features and two structures. Within those limits, surface/deep lakes have Legacy rank 1; lava lakes rank 2 as a separate new fluid choice; spheres/spikes/obelisks rank 3; and floating islands/tendrils rank 4. Rocks, which are a Rivencraft generalization, use rank 4. For structures, villages/strongholds/mineshafts use rank 1, dungeons/Nether fortresses rank 2, and newer Minecraft structures rank 3. Eligibility filtering still removes features incompatible with the selected terrain/biomes. Separate rare Skylands, Crystals, and Legacy-weighted Star Fissure rolls remain. This preserves Rivencraft's existing count limits rather than claiming exact parity with the full Legacy feature grammar. Existing saved random feature lists are retained. The current celestial stopped-time chance (1 in 7) follows the verified Legacy period ranks; other numeric celestial values still use Rivencraft's documented range.
+
+Regression coverage: `RandomAgeWeightGameTests` (archived grammar suite) checks exact terrain rank tickets and stable selections across many seeds. Core Age persistence tests cover page-free and Link-Panel-only books, plan/trait round-trips, and migrated definitions. Binder and grammar archives cover page order, missing symbols, rejected assembly, and replayed output. The default GameTest runtime has none of TerraBlender, Serene Seasons, Ecliptic Seasons, JEI, Create, Ponder, or Immersive Portals installed. Optional-mod interactions and real unload/restart checks remain manual per `GAMETESTS.md`.

docs/SERENE_SEASONS_COMPATIBILITY.md

@@ -0,0 +1,51 @@
+# 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 was closed as unsupported for live dynamic Ages in 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.
+
+The user subsequently reported an in-game pass for issue #38, recorded in its Gitea comment and release V0.4.9.2. The earlier candidate notes above describe the historical automated checks; the real-client matrix remains useful when upgrading Serene Seasons or GlitchCore.

docs/SYMBOL_SEMANTICS.md

@@ -16,7 +16,7 @@ Milestone 5 issue #29 adds typed meaning to the existing data-pack symbol catalo
 }
 ```
 
-`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that a later compiler must resolve and validate. A syntactically valid resource ID alone does not guarantee the profile or feature exists.
+`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that the compiler resolves and validates. A syntactically valid resource ID alone does not guarantee the profile or feature exists.
 
 `poem` is optional, client-safe artwork metadata: exactly four alphabetic words, ordered top, right, bottom, left. The client layers their glyphs from the shared Legacy component sheet at runtime. GUI thumbnails use the full transparent artwork over their page backgrounds; item icons use the same artwork reduced from 16 to 13 pixels across, over the page texture. Unregistered words use a stable generated component combination; when a symbol has no poem, the six original built-in IDs retain their Legacy poems and other IDs produce four stable fallback words. This affects appearance only, never Age generation. Generated images are cached up to 256 entries and discarded on resource reload.
 
@@ -28,17 +28,20 @@ The Writing Desk's 88 collection tabs use Legacy's number components, chiefly th
 | `biome_controller` | `native`, `single`, `tiled`, `grid`, `tiny`, `small`, `medium`, `large`, or `huge`. |
 | `biome` | Canonical namespaced biome ID. |
 | `lighting` | `normal`, `dark`, or `bright`. |
+| `sky` | `overworld`, `nether`, or `end`. |
 | `weather` | `normal`, `fast`, `slow`, `off`, `always`, `cloudy`, `rain`, `snow`, or `storm`. |
+| `season` | `no_seasons`, `seasons`, `eternal_winter`, `eternal_summer`, `eternal_fall`, or `eternal_spring`. Seasonal effects other than No Seasons require optional Serene Seasons. |
 | `celestial` | `normal_time` (the first representable single-cycle behavior). |
 | `period_modifier` | JSON number in `[0, 2]`; zero is stopped time. |
 | `angle_modifier` | JSON number in `[0, 360)` degrees. |
 | `phase_modifier` | JSON number in `[0, 360)` degrees; the compiler will convert to turns. |
-| `feature` | Canonical namespaced feature-effect ID; future generation mapping must recognize it. |
+| `block` | Canonical namespaced material ID for a compatible following feature; registered full-collision blocks and source fluids receive generated Pages. |
+| `feature` | Canonical namespaced feature-effect ID; the compiler must recognize and validate it. This includes supported decorations and structures. |
 
-These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, special structures, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field.
+These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field. Recognized schema values can still be rejected by the current compiler when their runtime effect is unsupported, such as angle modifiers or direct Rain/Snow weather pages.
 
 The server rejects a v2 definition with an unknown top-level or semantics field, missing/incorrectly typed field, unknown role or choice, malformed/non-canonical resource ID, or out-of-range/non-finite number. An invalid definition is logged with its file ID and excluded from the active catalog. Saved pages and books still retain that ID, allowing the player to recover them if the data pack is corrected. A reload atomically replaces the catalog rather than mutating saved writing.
 
-Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only `SymbolDisplayMetadata` (ID, translation keys, category, resolved flag); semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, but does **not yet apply** written symbols to Age generation; issue #31 adds compilation.
+Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only display metadata; semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, and the server compiles supported writing into a frozen Age plan before Binder inputs are consumed.
 
 The six built-in definitions demonstrate terrain, biome-controller, lighting, weather, celestial, and feature roles. A third-party pack may add its own definitions under its namespace. Use an explicit semantic role even when the display category has the same name; the two fields serve different purposes.

docs/TERRABLENDER_COMPATIBILITY.md

@@ -0,0 +1,63 @@
+# Optional TerraBlender biome compatibility (Milestone 5, issue #37)
+
+Rivencraft targets TerraBlender NeoForge **1.21.1-4.1.0.8**. The official
+[1.21.1 release](https://modrinth.com/mod/terrablender/version/4.1.0.8) and
+[region API](https://github.com/Glitchfiend/TerraBlender/blob/1.21.1/Common/src/main/java/terrablender/api/Regions.java)
+are available for this Minecraft version. TerraBlender is `compileOnly` and
+is **not** required by the published Rivencraft jar. For a local development
+run with TerraBlender, use `-PwithTerraBlender=true`.
+
+TerraBlender's API registers Overworld and Nether biome *regions*; it does not
+register arbitrary Rivencraft Age dimensions. Rivencraft therefore keeps its
+own deterministic Age biome sources and uses a guarded adapter to read the
+registered region biome IDs. Only biomes still present in Minecraft's biome
+registry are accepted. TerraBlender Overworld region biomes extend the pool
+for standard, flat, and sky-island Ages; Nether region biomes extend Cave Age
+pools and are valid authored Cave biome pages. Vanilla Nether-tagged biomes
+are also valid Cave biomes. This is generic: no Biomes O' Plenty IDs are
+hard-coded.
+
+Every registered biome receives a generated page in Rivencraft's Biome or Cave
+Biome creative tab, and in JEI when JEI is installed. Cave-tagged, Nether-tagged,
+and TerraBlender Nether-region biomes go in the Cave Biome tab. Existing vanilla page IDs such as
+`rivencraft:biome/desert` are unchanged; modded biome IDs include their
+namespace, for example `rivencraft:biome/example/orchard` for a biome named
+`example:orchard`.
+Authoring still validates the exact biome registry key. New Age plans freeze
+the selected biome IDs, distribution, and seed, so a reload with the same mods
+retains the result. If a modded biome later disappears, the Age loader warns
+and uses an eligible fallback for that load without rewriting its frozen plan.
+Restore the mod to recover the authored biome. Do not remove biome mods from
+an existing play world without a backup.
+
+## Compatibility matrix
+
+| Setup | Expected result | Validation |
+| --- | --- | --- |
+| Rivencraft without TerraBlender | Vanilla biome pages and Age generation remain functional; no TerraBlender classes load on the core path. | Default GameTest server and build. |
+| Rivencraft with TerraBlender 4.1.0.8, no biome addon | Same baseline pool; default TerraBlender regions add no modded biome IDs. | GameTest server with `-PwithTerraBlender=true`. |
+| Rivencraft + TerraBlender + Biomes O' Plenty 1.21.1 | BOP registry biomes appear as distinct Biome pages, with Nether-region pages in the Cave Biome tab. Its Overworld regions can enter composed standard/sky-island Age pools; its Nether regions can enter Cave Age pools. | In-game check below; this combination is not bundled in automated tests. |
+| TerraBlender present but its region API cannot be read | Log one warning and use Rivencraft's normal biome pool. | Guarded adapter fallback; intentionally not forced by GameTest. |
+
+## In-game check requested for Biomes O' Plenty
+
+Use a **new test world** with compatible NeoForge 1.21.1 builds of
+TerraBlender and Biomes O' Plenty installed on both sides.
+
+1. In the Rivencraft Biome and Cave Biome Pages creative tabs (and JEI, if installed), find
+   at least one BOP Overworld biome and one BOP Nether biome, respectively. The page tooltip
+   should identify the biome and not show an unresolved symbol.
+2. Bind a Descriptive Book with a Link Panel, Standard Terrain, a two-biome
+   distribution page, and two different BOP Overworld biome pages. Travel to
+   the Age and confirm both named biomes can occur. Reopen the same world and
+   confirm the Age still uses the same authored biome pool.
+3. Bind a second book using Cave Terrain and a BOP Nether biome page. The
+   Binder must accept the page, and the resulting Cave Age must use the
+   selected Nether biome rather than rejecting it as non-cave.
+4. Separately, run Rivencraft without TerraBlender and confirm a Link-Panel-
+   only random Age can still be created and entered. Do not reuse the BOP test
+   world for this absence check.
+
+The previous broad registry-enumeration GameTest stalled in the test server,
+so the BOP-specific and client-side checks are deliberately handed off for
+manual testing instead of retaining that stalled test.

docs/WRITING_DATA.md

@@ -87,10 +87,10 @@ placement. The surface draws the native 30×40 portrait page region from
 Legacy's book UI atlas; symbols are layered at a uniform scale, while the
 square item models remain unchanged in inventories.
 
-A Notebook holds 27 ordered positions. Its pages, names, gaps, and unresolved
+A Notebook holds 252 ordered positions. Its pages, names, gaps, and unresolved
 IDs are saved on the item, so moving the Notebook between an inventory, Desk,
 and Binder does not rearrange them. A loose Page in a Desk tab exposes just one
-position; a Notebook exposes all 27. The Desk has 88 persistent collection
+position; a Notebook exposes all 252. The Desk has 88 persistent collection
 tabs, shown four at a time. Use the up/down tab controls to move by four, put
 paper and Ink Vials in their input slots, select a stored page, and take the
 copy from the virtual output. Taking it spends one paper and the configured
@@ -100,7 +100,7 @@ copying. Moving a page within the Desk or dragging it into the inventory removes
 the original only when the destination accepts it.
 
 The Book Binder takes a leather or empty-Notebook cover, an Age title, one Link
-Panel, and optionally up to 27 ordered written Pages. A filled Notebook can be
+Panel, and optionally up to 252 ordered written Pages. A filled Notebook can be
 imported at a chosen strip position; the empty Notebook remains recoverable.
 The preview result is virtual. Taking the completed Descriptive Book commits the
 inputs once, creates its Age identity, and saves schema-versioned

docs/WRITING_GRAMMAR.md

@@ -2,12 +2,24 @@
 
 `WritingGrammar` interprets the saved `OrderedWriting` on the server using only `SymbolCatalog`'s schema-v2 semantics. Client display metadata, page names, and supplied translations never determine an Age's meaning. The parser is pure: it returns immutable parsed entries and indexed diagnostics without changing a book or its pages.
 
-New Binder writing has at most one Link Panel plus 27 symbol pages. The Link Panel must be first. A Link-Panel-only book, or an older book with no writing component, keeps the existing random Age path. Any authored supported symbol makes the book a partial or complete grammar. From 0.4.3.0, the server compiles it into a persistent Age plan before consuming Binder inputs or generating chunks.
+New Binder writing has at most one Link Panel plus 252 symbol pages (the current fixed-slot save-format ceiling, not a Legacy gameplay limit). The Link Panel must be first. A Link-Panel-only book, or an older book with no writing component, keeps the existing random Age path. Any authored supported symbol makes the book a partial or complete grammar. From 0.4.3.0, the server compiles it into a persistent Age plan before consuming Binder inputs or generating chunks.
 
-The supported order follows the representable subset of the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md): terrain; zero or more biome pages; biome controller; weather; lighting; sky effects; zero or more period or phase modifiers; one celestial page; then zero or more distinct features. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, lighting, sky, and celestial are single-choice categories; identical repeats are duplicates and differing values conflict. Repeated modifiers are intentional. Biome pages may repeat, preserving author order and any future weighting; feature IDs may not repeat. Angle modifiers remain recognized in the schema but are rejected at binding until a sky renderer can apply sun tilt.
+The supported order follows the representable subset of the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md): terrain; zero or more biome pages; biome controller; weather; season; lighting; sky effects; zero or more period or phase modifiers; one celestial page; then zero or more features, each optionally preceded by a compatible material page. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, season, lighting, sky, and celestial are single-choice categories; identical repeats are duplicates and differing values conflict. Repeated modifiers, biome pages, feature pages, and material pages are intentional and retain their order. An unpaired material page receives a seeded compatible feature during compilation. Angle modifiers remain recognized in the schema but are rejected at binding until a sky renderer can apply sun tilt.
 
-Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains the seed-selected profile and traits for missing branches. The minimum is zero for Native, one for Single, and two for Tiled/Grid and Tiny–Huge. Native cannot consume authored biome pages; Single accepts only one. Unknown IDs, schema-v1 display-only symbols, wrong ordering, misplaced modifiers, duplicates, conflicts, missing/extra Link Panels, and oversized writing are errors. The Binder disables output and exposes the first error on the result-slot tooltip. When that error belongs to a page, its thumbnail is tinted and outlined red, the strip scrolls to it, and hovering it shows the diagnostic. This maps the parser's compact entry position back through any empty page positions. Rejected inputs remain removable. Binding an unwritten Descriptive Book rechecks its server-owned writing and reports the first error without creating an Age. A terrain symbol whose profile is unavailable is also rejected before Binder inputs are consumed.
+Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains seed-selected traits for missing branches. An omitted terrain page uses a seed-selected profile compatible with authored feature pages, so changing the Age name cannot accidentally select Flat, Void, or Cave terrain for Rocks or Lakes. If no profile can support the writing, binding still rejects it. Native consumes no authored biome pages; Single consumes one; Tiled/Grid and Tiny–Huge require two, with seeded filler when pages are missing. From 0.5.1.0, known misplaced or repeated pages no longer block creation: the book keeps its original order, while the server repairs category order, uses the last single-choice controller, and stores a writing-instability score in the Age plan. A conflicting/repeated choice adds 500; an out-of-order page or misplaced modifier adds 100. Native ignores surplus authored biome pages and Single uses the first, with the conflict recorded as instability. These are Rivencraft's provisional penalties, not a claim of exact Legacy values for every symbol. Incorrectly placed pages are **not** red-highlighted; their warning remains available as a tooltip. Unknown IDs, schema-v1 display-only symbols, unavailable dependencies/profiles, unsupported semantic effects or feature/material pairs, missing/extra Link Panels, and oversized writing still reject a new Age. The Binder disables output for those fatal errors and shows a red page indication where applicable. Rejected inputs remain removable.
 
-The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the Age seed, and a copy of the selected runtime profile. An explicit terrain page replaces the random terrain selection; an omitted terrain uses the seed-selected profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages now affect new Ages; feature effects remain issue #35 work, and instability remains Milestone 6 work.
+The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the active repaired-page indexes, the writing-instability score, the Age seed, and a copy of the selected runtime profile. An explicit terrain page overrides random terrain selection; an omitted terrain uses a seed-selected compatible profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages affect new Ages, and the supported feature subset below is compiled into the same frozen plan. Runtime effects for a nonzero writing-instability score are not implemented yet.
 
-The Rivencraft Pages creative tab reads a generated index of bundled symbol definitions. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page automatically in the next build; no Java starter-page list needs updating. The server catalog still decides whether that page is valid for writing. External server data-pack symbols are not included in this bundled index.
+## Supported feature pages (issue #35)
+
+Feature pages come after the celestial section. Their order is retained in the plan and in decoration placement. The Caves page adds a second, Age-seeded vanilla cave-carving pass to Noise terrain, including Standard, Amplified, Island, and Cave terrain. It chooses the vanilla Overworld or Nether cave carver from the source biome. This is separate from the Milestone 7 issue about Cave **terrain** generation. Flat and Void terrain have no suitable solid noise body and reject Caves with a binder diagnostic.
+
+Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and Lava Lakes add vanilla placed features after normal biome decoration. Huge Trees currently use vanilla old-growth spruce placement as a modern approximation of Legacy's huge-tree page; it is not the custom Legacy tree generator. Without a preceding material page, each material-bearing feature selects a valid solid block or source fluid from the registered pool. The selection is deterministic for the Age seed and feature occurrence, so repeated feature pages can receive different materials while remaining stable across restarts with the same block registry. The page-specific feature preserves vanilla placement rules other than the biome-list filter, since an authored page deliberately adds it to the Age. Surface and Lava Lakes use a more visible one-in-twelve-chunks attempt rate instead of vanilla lava lakes' one-in-two-hundred; Deep Lakes retain their underground placement. Vanilla biome lava lakes are separate and can still appear alongside authored fluid lakes. These decorations require surface Noise terrain; Cave, Flat, and Void reject them. Flowers and both tree pages require at least one surface Overworld biome and only run in compatible chunks; Nether, End, and tagged cave biomes do not receive surface vegetation. Ravines add a separate Age-seeded vanilla canyon-carving pass to Noise terrain. Unsupported feature IDs and missing vanilla registry entries produce diagnostics instead of becoming no-ops.
+
+Material pages are generated for registered full-collision, non-fluid blocks and genuine source-fluid blocks, including eligible blocks supplied by other mods. Blocks with block entities are excluded. Waterlogged plants and coral are not fluid blocks and receive no pages. Valid source-fluid blocks appear only in the Fluid Pages creative tab; valid full-collision solids appear only in Block Pages. Both categories use the same saved material-page semantics. Put a Block Page before a compatible solid feature (Rocks, Floating Islands, Tendrils, Spheres, Spikes, or Obelisks), or a Fluid Page before a lake feature. A material page with no explicit feature receives a seeded compatible one. A material directly attached to an incompatible feature is rejected. The effective feature and material IDs are frozen with the Age, so future chunks retain their choices after restart. Existing chunks are not retroactively decorated.
+
+Crystal Formations are an authored, material-free feature on exposed solid terrain, including Flat terrain; Cave and Void reject the page. Like Legacy, one in fifteen eligible chunks attempts a formation, with the site fixed by the Age seed and chunk coordinates. The modern formation is a compact mound with budding hearts instead of Legacy's long crystal lines. Budding blocks grow through small, medium, and large buds into clusters using vanilla amethyst timing and sounds. Non-silk cluster harvest yields Crystal Shards; four shards craft one Crystal Block. These blocks and shards use 16×16 textures: Legacy's crystal tile for solids and hue-shifted vanilla amethyst sprites for buds and clusters. A page-free Age can also randomly select Crystal Formations; an authored page always retains its exact choice in the saved plan.
+
+Star Fissures are a material-free feature on every terrain profile, including Cave and Void. The fissure is generated once beside the first resolved spawn, using Legacy's spawn-chunk offset and 10–17 paired, irregular X-span rows running along +Z. Legacy's y=0 portal floor maps to the modern dimension's minimum build height, replacing lower bedrock if present. The rift opens to the sky on ordinary terrain; in Cave terrain it opens into the cavern but stops below the upper bedrock roof. Water in the carved columns is cleared before the portal is placed. Its non-solid portal links to the Overworld spawn with the Legacy fissure sound; the animated starfield is drawn with Minecraft's current End Portal renderer, which uses the same end-sky/end-portal art as Legacy's custom renderer. Random Ages sample Legacy's default small-feature grammar for fissure selection: the stop/one/repeat branches have rank-derived weights 1:1:3, and the fissure has weight 1 of 9 among its small-feature rules. The remainder of random feature selection still follows Rivencraft's current pipeline, rather than running Legacy's entire Age grammar.
+
+The Rivencraft symbol-page creative tabs read a generated index of bundled symbol definitions and group Pages by each definition's category, except biome-controller roles, which appear in a separate Biome Generation tab rather than the Biome tab. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page in the matching category tab on the next build; a new bundled category receives its own tab. Registry-derived Block and Fluid Pages have separate tabs and both appear in optional JEI. Registry-derived biome pages share a creative/JEI feed; `terrablender:deferred_placeholder` is excluded because it is TerraBlender's internal staging biome, not a player-facing biome choice. Other modded biomes remain listed. Link Pages have a separate tab. Blank Pages appear in neither the creative tabs nor JEI's ingredient list. The server catalog still decides whether a page is valid for writing. External server data-pack symbols are not included in this bundled index.

gradle.properties

@@ -36,8 +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.6.0
+mod_version=0.5.8.2
 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,8 +18,14 @@ 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.AgeInstabilityRuntime;
+import net.dnorberg.rivencraft.book.AgeStatusEffectProviders;
+import net.dnorberg.rivencraft.book.AgeDecayProviders;
+import net.dnorberg.rivencraft.book.AgeHazardProviders;
+import net.dnorberg.rivencraft.book.AgeEnvironmentalProviders;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.neoforged.bus.api.IEventBus;
@@ -36,6 +42,10 @@ public final class Rivencraft {
 
     public Rivencraft(IEventBus modEventBus, ModContainer modContainer) {
         AgeDimensionService.register();
+        AgeStatusEffectProviders.register();
+        AgeDecayProviders.register();
+        AgeHazardProviders.register();
+        AgeEnvironmentalProviders.register();
         modContainer.registerConfig(ModConfig.Type.SERVER, RivencraftConfig.SPEC);
         modContainer.registerConfig(ModConfig.Type.CLIENT, RivencraftClientConfig.SPEC);
         modEventBus.addListener(ModNetworking::register);
@@ -51,10 +61,21 @@ public final class Rivencraft {
         ModCreativeTabs.register(modEventBus);
         NeoForge.EVENT_BUS.addListener(BookStandConversionHandler::onRightClickBlock);
         NeoForge.EVENT_BUS.addListener(AgeWeatherService::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeInstabilityRuntime::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeEnvironmentalProviders::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeEnvironmentalProviders::onLevelUnload);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onServerTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onEntityTravel);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onPlayerChangedDimension);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onPlayerLoggedOut);
+        NeoForge.EVENT_BUS.addListener(SereneSeasonsCompatibility::onLevelTickPost);
         NeoForge.EVENT_BUS.addListener(AgeCelestialAngleSync::onPlayerLoggedIn);
         NeoForge.EVENT_BUS.addListener(AgeCelestialAngleSync::onPlayerChangedDimension);
         NeoForge.EVENT_BUS.addListener(AgeLifecycleEvents::onPlayerLoggedOut);
         NeoForge.EVENT_BUS.addListener(AgeLifecycleEvents::onServerStopping);
+        NeoForge.EVENT_BUS.addListener(AgeInstabilityRuntime::onServerStopping);
+        NeoForge.EVENT_BUS.addListener(AgeEnvironmentalProviders::onServerStopping);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onServerStopping);
         NeoForge.EVENT_BUS.addListener(RivencraftCommands::register);
         NeoForge.EVENT_BUS.addListener(AgeRuntimeProfiles::register);
         NeoForge.EVENT_BUS.addListener(SymbolCatalog::register);

src/main/java/net/dnorberg/rivencraft/block/BuddingCrystalBlock.java

@@ -0,0 +1,45 @@
+package net.dnorberg.rivencraft.block;
+
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.AmethystBlock;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.BuddingAmethystBlock;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.Fluids;
+
+/** Vanilla amethyst growth, mapped to Rivencraft's blue crystal stages. */
+public final class BuddingCrystalBlock extends AmethystBlock {
+    public BuddingCrystalBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    protected void randomTick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        if (random.nextInt(5) != 0) return;
+        Direction direction = Direction.values()[random.nextInt(Direction.values().length)];
+        BlockPos target = pos.relative(direction);
+        BlockState existing = level.getBlockState(target);
+        Block next = nextStage(existing, direction);
+        if (next == null) return;
+        level.setBlockAndUpdate(target, next.defaultBlockState()
+                .setValue(AmethystClusterBlock.FACING, direction)
+                .setValue(AmethystClusterBlock.WATERLOGGED,
+                        existing.getFluidState().getType() == Fluids.WATER));
+    }
+
+    public static Block nextStage(BlockState existing, Direction direction) {
+        if (BuddingAmethystBlock.canClusterGrowAtState(existing)) return ModBlocks.SMALL_CRYSTAL_BUD.get();
+        if (!existing.hasProperty(AmethystClusterBlock.FACING)
+                || existing.getValue(AmethystClusterBlock.FACING) != direction) return null;
+        if (existing.is(ModBlocks.SMALL_CRYSTAL_BUD)) return ModBlocks.MEDIUM_CRYSTAL_BUD.get();
+        if (existing.is(ModBlocks.MEDIUM_CRYSTAL_BUD)) return ModBlocks.LARGE_CRYSTAL_BUD.get();
+        if (existing.is(ModBlocks.LARGE_CRYSTAL_BUD)) return ModBlocks.CRYSTAL_CLUSTER.get();
+        return null;
+    }
+}

src/main/java/net/dnorberg/rivencraft/block/CloudPlatformBlock.java

@@ -0,0 +1,36 @@
+package net.dnorberg.rivencraft.block;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+
+/** Solid footing for Age arrivals, rendered as a translucent cloud. */
+public final class CloudPlatformBlock extends Block {
+    public CloudPlatformBlock(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public ItemStack getCloneItemStack(LevelReader level, BlockPos pos, BlockState state) {
+        return ItemStack.EMPTY;
+    }
+
+    @Override
+    protected boolean skipRendering(BlockState state, BlockState adjacent, Direction side) {
+        return adjacent.is(this) || super.skipRendering(state, adjacent, side);
+    }
+
+    @Override
+    protected boolean propagatesSkylightDown(BlockState state, BlockGetter level, BlockPos pos) {
+        return true;
+    }
+
+    @Override
+    protected int getLightBlock(BlockState state, BlockGetter level, BlockPos pos) {
+        return 0;
+    }
+}

src/main/java/net/dnorberg/rivencraft/block/DecayBlock.java

@@ -0,0 +1,46 @@
+package net.dnorberg.rivencraft.block;
+
+import net.dnorberg.rivencraft.book.AgeInstabilityRuntime;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+
+/** The four colored decay variants selected by the current instability deck. */
+public final class DecayBlock extends Block {
+    public static final EnumProperty<Color> COLOR = EnumProperty.create("color", Color.class);
+
+    public DecayBlock(Properties properties) {
+        super(properties);
+        registerDefaultState(stateDefinition.any().setValue(COLOR, Color.BLUE));
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        builder.add(COLOR);
+    }
+
+    @Override
+    public void stepOn(Level level, BlockPos pos, BlockState state, Entity entity) {
+        if (!level.isClientSide && state.getValue(COLOR) == Color.WHITE
+                && RivencraftConfig.decayEnabled() && RivencraftConfig.instabilityWorldMutation()
+                && AgeInstabilityRuntime.isAgeDimension(level.dimension().location())) {
+            entity.hurt(level.damageSources().magic(), 1.0F);
+        }
+        super.stepOn(level, pos, state, entity);
+    }
+
+    public enum Color implements StringRepresentable {
+        BLUE, PURPLE, RED, WHITE;
+
+        @Override
+        public String getSerializedName() {
+            return name().toLowerCase(java.util.Locale.ROOT);
+        }
+    }
+}

src/main/java/net/dnorberg/rivencraft/block/StarFissureBlock.java

@@ -0,0 +1,84 @@
+package net.dnorberg.rivencraft.block;
+
+import com.mojang.serialization.MapCodec;
+import net.dnorberg.rivencraft.block.entity.StarFissureBlockEntity;
+import net.dnorberg.rivencraft.book.LinkingService;
+import net.dnorberg.rivencraft.registry.ModSounds;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Portal;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.level.portal.DimensionTransition;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.phys.shapes.BooleanOp;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+/** A starry, non-obtainable portal at the base of a generated fissure. */
+public final class StarFissureBlock extends BaseEntityBlock implements Portal {
+    public static final MapCodec<StarFissureBlock> CODEC = simpleCodec(StarFissureBlock::new);
+    private static final VoxelShape SHAPE = Block.box(0, 0, 0, 16, 1.6, 16);
+
+    public StarFissureBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    protected MapCodec<? extends BaseEntityBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        return new StarFissureBlockEntity(pos, state);
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return SHAPE;
+    }
+
+    @Override
+    protected void entityInside(BlockState state, Level level, BlockPos pos, Entity entity) {
+        if (entity.canUsePortal(false) && Shapes.joinIsNotEmpty(
+                Shapes.create(entity.getBoundingBox().move(-pos.getX(), -pos.getY(), -pos.getZ())),
+                state.getShape(level, pos), BooleanOp.AND)) {
+            entity.setAsInsidePortal(this, pos);
+        }
+    }
+
+    @Override
+    public DimensionTransition getPortalDestination(ServerLevel level, Entity entity, BlockPos pos) {
+        if (level.dimension() == Level.OVERWORLD) return null;
+        ServerLevel overworld = level.getServer().overworld();
+        if (overworld == null) return null;
+        Vec3 destination = LinkingService.resolveDestination(overworld, overworld.getSharedSpawnPos(), true)
+                .orElse(overworld.getSharedSpawnPos().getBottomCenter());
+        level.playSound(null, pos, ModSounds.LINK_FISSURE.get(), SoundSource.BLOCKS, 1.0F, 1.0F);
+        return new DimensionTransition(overworld, destination,
+                entity.getDeltaMovement(), entity.getYRot(), entity.getXRot(),
+                DimensionTransition.PLACE_PORTAL_TICKET);
+    }
+
+    @Override
+    public ItemStack getCloneItemStack(LevelReader level, BlockPos pos, BlockState state) {
+        return ItemStack.EMPTY;
+    }
+
+    @Override
+    protected boolean canBeReplaced(BlockState state, Fluid fluid) {
+        return false;
+    }
+}

src/main/java/net/dnorberg/rivencraft/block/entity/BookBinderBlockEntity.java

@@ -5,7 +5,6 @@ import java.util.List;
 import java.util.UUID;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
-import net.dnorberg.rivencraft.book.AgeGenerationPlan;
 import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.item.PageItem;
@@ -24,7 +23,7 @@ import net.minecraft.core.NonNullList;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceKey;
 import net.dnorberg.rivencraft.book.AgeBiomeSelection;
-import net.minecraft.tags.BiomeTags;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
 import net.minecraft.core.component.DataComponents;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
@@ -117,19 +116,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             if (!page.isEmpty() && (!validPage(page) || !PageItem.isUsableWriting(page) || page.getCount() != 1
                     || PageItem.content(page).kind() == PageContent.Kind.BLANK)) return false;
         }
-        OrderedWriting writing = currentWriting();
+        return writingGrammar().canCreate();
-        if (!writingGrammar().canCreate()) return false;
-        try {
-            if (level instanceof ServerLevel serverLevel) {
-                AgeRegistrySavedData.validateNewWriting(serverLevel, title, writing);
-            } else {
-                AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD,
-                        net.dnorberg.rivencraft.book.AgeTraits.select(0L), level.registryAccess());
-            }
-            return true;
-        } catch (IllegalArgumentException exception) {
-            return false;
-        }
     }
 
     public WritingGrammar.Result writingGrammar() {
@@ -138,7 +125,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
         List<WritingGrammar.Diagnostic> diagnostics = new ArrayList<>(parsed.diagnostics());
         var terrain = parsed.symbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
-                .findFirst();
+                .reduce((first, last) -> last);
         if (terrain.isPresent()) {
             var profileId = ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id();
             if (!AgeRuntimeProfiles.profiles().containsKey(profileId)) {
@@ -151,7 +138,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             var selectedProfile = terrain.isPresent()
                     ? ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id()
                     : level instanceof ServerLevel serverLevel
-                    ? AgeRegistrySavedData.previewGenerationProfile(serverLevel, title)
+                    ? AgeRegistrySavedData.previewGenerationProfile(serverLevel, title, currentWriting())
                     : AgeGenerationProfiles.STANDARD;
             var runtimeProfile = AgeRuntimeProfiles.profiles().get(selectedProfile);
             boolean cave = runtimeProfile != null && AgeBiomeSelection.isCave(runtimeProfile);
@@ -162,12 +149,42 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
                         if (holder.isEmpty()) {
                             diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNKNOWN_BIOME,
                                     symbol.index(), "Restore biome " + id + " or remove this page"));
-                        } else if (cave && !holder.orElseThrow().is(AgeBiomeSelection.CAVE_BIOMES)
+                        } else if (cave && !AgeBiomeSelection.isCaveBiome(level.registryAccess(),
-                                && !holder.orElseThrow().is(BiomeTags.IS_NETHER)) {
+                                holder.orElseThrow())) {
                             diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNSUPPORTED_BIOME,
                                     symbol.index(), "Cave Ages require cave or Nether biomes; remove " + id));
                         }
                     });
+            if (runtimeProfile != null) {
+                parsed.symbols().stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                        .forEach(symbol -> {
+                            var id = ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id();
+                            String error = AgeFeatureSelection.error(id, runtimeProfile, level.registryAccess());
+                            if (error != null) diagnostics.add(new WritingGrammar.Diagnostic(
+                                    WritingGrammar.Code.UNSUPPORTED_FEATURE, symbol.index(), error));
+                        });
+            }
+            // Compile against the actual title-derived Age seed as a final compatibility
+            // check. This also pinpoints biome-pool conflicts that cannot be inferred from
+            // an individual feature page alone (for example Trees with only Nether biomes).
+            if (level instanceof ServerLevel serverLevel && diagnostics.stream().noneMatch(
+                    WritingGrammar.Diagnostic::error)) {
+                try {
+                    AgeRegistrySavedData.validateNewWriting(serverLevel, title, currentWriting());
+                } catch (IllegalArgumentException exception) {
+                    boolean feature = exception.getMessage() != null
+                            && (exception.getMessage().startsWith("Feature ")
+                            || exception.getMessage().startsWith("Caves "));
+                    int index = feature ? parsed.symbols().stream()
+                            .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                            .mapToInt(WritingGrammar.ParsedSymbol::index).findFirst().orElse(-1) : -1;
+                    diagnostics.add(new WritingGrammar.Diagnostic(
+                            feature ? WritingGrammar.Code.UNSUPPORTED_FEATURE
+                                    : WritingGrammar.Code.UNSUPPORTED_COMBINATION,
+                            index, exception.getMessage() == null ? "The Age compiler rejected this writing"
+                                    : exception.getMessage()));
+                }
+            }
         }
         return new WritingGrammar.Result(parsed.symbols(), diagnostics);
     }
@@ -210,6 +227,11 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
         ItemStack book = new ItemStack(ModItems.DESCRIPTIVE_BOOK.get());
         book.set(ModDataComponents.AGE_REFERENCE.get(), new AgeReference(pendingAgeId, title));
         book.set(ModDataComponents.BOOK_WRITING.get(), currentWriting());
+        if (items.get(LINK_PANEL).has(ModDataComponents.LINK_PROPERTIES.get())) {
+            var properties = items.get(LINK_PANEL).get(ModDataComponents.LINK_PROPERTIES.get())
+                    .forDescriptiveBook();
+            if (properties.flags() != 0) book.set(ModDataComponents.LINK_PROPERTIES.get(), properties);
+        }
         book.set(DataComponents.CUSTOM_NAME, Component.literal(title));
         return book;
     }

src/main/java/net/dnorberg/rivencraft/block/entity/InkMixerBlockEntity.java

@@ -1,10 +1,14 @@
 package net.dnorberg.rivencraft.block.entity;
 
+import java.util.Random;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.writing.InkVialExchange;
+import net.dnorberg.rivencraft.writing.InkModifierIngredients;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
-import net.dnorberg.rivencraft.writing.WritingInkService;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.HolderLookup;
 import net.minecraft.core.NonNullList;
@@ -18,7 +22,7 @@ import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
 
-/** Baseline Link Panel mixer. Modifier ingredients belong to the symbol/ink-effects milestone. */
+/** Server-owned Link Panel mixer with a persistent, Legacy-style additive mixture. */
 public final class InkMixerBlockEntity extends BlockEntity implements Container {
     public static final int INK = 0;
     public static final int PAPER = 1;
@@ -27,6 +31,12 @@ public final class InkMixerBlockEntity extends BlockEntity implements Container
 
     private NonNullList<ItemStack> items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
     private int inkRemaining;
+    private long nextModifierSeed = new Random().nextLong();
+    private final double[] modifierChances = new double[3];
+    private static final int[] FLAGS = {LinkProperties.DISARM,
+            LinkProperties.MAINTAIN_MOMENTUM, LinkProperties.INTRA_LINKING};
+    private static final String[] CHANCE_KEYS = {"DisarmChance", "MomentumChance", "IntraLinkingChance"};
+    private static final int[] OLD_CHANCE_INDEX = {0, 2, 3};
 
     public InkMixerBlockEntity(BlockPos pos, BlockState state) {
         super(ModBlockEntities.INK_MIXER.get(), pos, state);
@@ -34,6 +44,44 @@ public final class InkMixerBlockEntity extends BlockEntity implements Container
 
     public int inkRemaining() { return inkRemaining; }
 
+    public int modifierChancePermille(int index) {
+        return Math.clamp((int) Math.round(modifierChances[index] * 1000), 0, 1000);
+    }
+
+    /** Infuses a carried ingredient into the current ink pool; only the server calls this. */
+    public boolean addModifier(ItemStack carried, int amount) {
+        InkModifierIngredients.Ingredient ingredient = InkModifierIngredients.find(carried);
+        if (ingredient == null || inkRemaining == 0 || amount <= 0 || carried.getCount() < amount)
+            return false;
+        for (InkModifierIngredients.Effect effect : ingredient.effects())
+            for (int index = 0; index < FLAGS.length; index++)
+                if (FLAGS[index] == effect.flag())
+                    modifierChances[index] = 1.0 - (1.0 - modifierChances[index])
+                            * Math.pow(1.0 - effect.chance(), amount);
+        carried.shrink(amount);
+        setChanged();
+        return true;
+    }
+
+    public ItemStack previewLinkPanel() {
+        if (!canCreateLinkPanel()) return ItemStack.EMPTY;
+        ItemStack panel = PageItem.createLinkPanelPage();
+        LinkProperties properties = rollProperties(nextModifierSeed).properties();
+        if (properties.flags() != 0) panel.set(ModDataComponents.LINK_PROPERTIES.get(), properties);
+        return panel;
+    }
+
+    private record Roll(LinkProperties properties, long nextSeed) {}
+
+    private Roll rollProperties(long seed) {
+        Random random = new Random(seed);
+        int selected = 0;
+        for (int index = 0; index < FLAGS.length; index++)
+            if (modifierChances[index] > 0 && random.nextDouble() < modifierChances[index])
+                selected |= FLAGS[index];
+        return new Roll(new LinkProperties(selected), random.nextLong());
+    }
+
     @Override public int getContainerSize() { return SIZE; }
     @Override public boolean isEmpty() { return items.stream().allMatch(ItemStack::isEmpty); }
     @Override public ItemStack getItem(int slot) { return items.get(slot); }
@@ -78,20 +126,21 @@ public final class InkMixerBlockEntity extends BlockEntity implements Container
 
     public boolean canCreateLinkPanel() {
         if (!items.get(PAPER).is(Items.PAPER)) return false;
-        int cost = WritingInkService.linkPanelCost();
+        return InkVialExchange.canPay(items, INK, BOTTLES, inkRemaining, InkVialItem.CAPACITY);
-        return InkVialExchange.canPay(items, INK, BOTTLES, inkRemaining, cost);
     }
 
     /** Commit inputs only when a virtual output is actually taken. */
     public boolean consumeLinkPanelMaterials() {
         if (!canCreateLinkPanel()) return false;
-        int cost = WritingInkService.linkPanelCost();
+        int cost = InkVialItem.CAPACITY;
         if (inkRemaining < cost) {
             inkRemaining += InkVialExchange.exchange(items, INK, BOTTLES);
         }
         inkRemaining -= cost;
         items.get(PAPER).shrink(1);
         if (items.get(PAPER).isEmpty()) items.set(PAPER, ItemStack.EMPTY);
+        nextModifierSeed = rollProperties(nextModifierSeed).nextSeed();
+        java.util.Arrays.fill(modifierChances, 0);
         setChanged();
         if (inkRemaining == 0) refillEmptyBasin();
         return true;
@@ -104,6 +153,7 @@ public final class InkMixerBlockEntity extends BlockEntity implements Container
     @Override public void clearContent() {
         items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
         inkRemaining = 0;
+        java.util.Arrays.fill(modifierChances, 0);
         setChanged();
     }
     @Override protected void loadAdditional(CompoundTag tag, HolderLookup.Provider registries) {
@@ -111,11 +161,20 @@ public final class InkMixerBlockEntity extends BlockEntity implements Container
         items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
         ContainerHelper.loadAllItems(tag, items, registries);
         inkRemaining = Math.clamp(tag.getInt("InkRemaining"), 0, InkVialItem.CAPACITY);
+        if (tag.contains("NextModifierSeed")) nextModifierSeed = tag.getLong("NextModifierSeed");
+        for (int index = 0; index < modifierChances.length; index++) {
+            double chance = tag.contains(CHANCE_KEYS[index]) ? tag.getDouble(CHANCE_KEYS[index])
+                    : tag.getDouble("ModifierChance" + OLD_CHANCE_INDEX[index]);
+            modifierChances[index] = Math.clamp(chance, 0.0, 1.0);
+        }
         refillEmptyBasin();
     }
     @Override protected void saveAdditional(CompoundTag tag, HolderLookup.Provider registries) {
         super.saveAdditional(tag, registries);
         ContainerHelper.saveAllItems(tag, items, registries);
         tag.putInt("InkRemaining", inkRemaining);
+        tag.putLong("NextModifierSeed", nextModifierSeed);
+        for (int index = 0; index < modifierChances.length; index++)
+            tag.putDouble(CHANCE_KEYS[index], modifierChances[index]);
     }
 }

src/main/java/net/dnorberg/rivencraft/block/entity/StarFissureBlockEntity.java

@@ -0,0 +1,13 @@
+package net.dnorberg.rivencraft.block.entity;
+
+import net.dnorberg.rivencraft.registry.ModBlockEntities;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.entity.TheEndPortalBlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+
+/** Reuses Minecraft's animated starfield renderer with a valid Rivencraft block-entity type. */
+public final class StarFissureBlockEntity extends TheEndPortalBlockEntity {
+    public StarFissureBlockEntity(BlockPos pos, BlockState state) {
+        super(ModBlockEntities.STAR_FISSURE.get(), pos, state);
+    }
+}

src/main/java/net/dnorberg/rivencraft/block/entity/WritingDeskBlockEntity.java

@@ -1,8 +1,12 @@
 package net.dnorberg.rivencraft.block.entity;
 
 import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.writing.InkVialExchange;
 import net.dnorberg.rivencraft.writing.WritingInkService;
+import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.core.BlockPos;
@@ -83,7 +87,11 @@ public final class WritingDeskBlockEntity extends BlockEntity implements Contain
                         worldPosition.getZ() + 0.5) <= 64.0;
     }
     @Override public boolean canPlaceItem(int slot, ItemStack stack) {
-        if (slot < COLLECTIONS) return stack.is(ModItems.NOTEBOOK.get()) || stack.is(ModItems.PAGE.get());
+        if (slot < COLLECTIONS) return stack.is(ModItems.NOTEBOOK.get())
+                && stack.getOrDefault(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY)
+                        .pages().stream().noneMatch(page -> PageItem.content(page).kind() == PageContent.Kind.LINK_PANEL)
+                || stack.is(ModItems.PAGE.get())
+                && PageItem.content(stack).kind() != PageContent.Kind.LINK_PANEL;
         return switch (slot) {
             case INK -> stack.is(ModItems.INK_VIAL.get());
             case RETURN -> false;

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

@@ -7,6 +7,7 @@ import java.util.List;
 import java.util.Random;
 import java.util.Set;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
 import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.Holder;
@@ -47,7 +48,8 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
             distribution = AgeTraits.BiomeDistribution.SINGLE;
         }
         if (controller.isEmpty() && !authored.isEmpty()) {
-            if (distribution == AgeTraits.BiomeDistribution.NATIVE
+            if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID
+                    || distribution == AgeTraits.BiomeDistribution.NATIVE
                     || (distribution == AgeTraits.BiomeDistribution.SINGLE && authored.size() > 1)) {
                 distribution = authored.size() == 1 ? AgeTraits.BiomeDistribution.SINGLE
                         : authored.size() == 2 ? AgeTraits.BiomeDistribution.TILED
@@ -59,9 +61,10 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         for (ResourceLocation id : authored) {
             Holder.Reference<Biome> holder = registry.get(ResourceKey.create(Registries.BIOME, id))
                     .orElseThrow(() -> new IllegalArgumentException("Unknown biome " + id + "; restore its data pack or remove its page"));
-            if (cave && !holder.is(CAVE_BIOMES) && !holder.is(BiomeTags.IS_NETHER)) {
+            if (cave && !isCaveBiome(registries, holder)) {
                 throw new IllegalArgumentException("Biome " + id
-                        + " is not a cave or Nether biome; use #rivencraft:cave_biomes or #minecraft:is_nether");
+                        + " is not a cave or Nether biome; use #rivencraft:cave_biomes, #minecraft:is_nether,"
+                        + " or a TerraBlender Nether region");
             }
         }
         List<ResourceLocation> availableBiomes = eligible(registries, profile);
@@ -69,22 +72,25 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         if (distribution == AgeTraits.BiomeDistribution.NATIVE) {
             if (!authored.isEmpty()) throw new IllegalArgumentException("Native biome distribution cannot use biome pages");
             return new AgeBiomeSelection(distribution, profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
-                    ? List.of(ResourceLocation.withDefaultNamespace("plains")) : availableBiomes);
+                    ? List.of(ResourceLocation.withDefaultNamespace("plains"))
+                    : isCave(profile) ? availableBiomes : presetBiomes(registries, profile));
         }
         List<ResourceLocation> selected = new ArrayList<>(authored);
         Set<ResourceLocation> distinct = new LinkedHashSet<>(selected);
         int minimum = minimum(distribution);
         int target = minimum;
         if (authored.isEmpty()) {
-            // The terrain's available pool is the upper bound. For Cave terrain,
+            // Legacy's BiomesAdv continuation/stop ranks are 2:3, which yield
-            // eligible() returns the cave tag; other terrains use their preset.
+            // two continuation tickets for every one stop ticket. Keep our
+            // existing minimum and cap the list at the available biome pool.
             int availableBiomeCount = new LinkedHashSet<>(availableBiomes).size();
             int maximum = distribution == AgeTraits.BiomeDistribution.SINGLE ? 1 : availableBiomeCount;
-            if (maximum >= minimum) {
+            Random countRandom = new Random(seed ^ 0x42494F4D45434F55L);
-                target += new Random(seed ^ 0x42494F4D45434F55L).nextInt(maximum - minimum + 1);
+            while (target < maximum && countRandom.nextInt(3) != 0) target++;
-            }
         }
-        List<ResourceLocation> filler = new ArrayList<>(availableBiomes);
+        // An authored Void Age must not acquire The Void as an unrequested second biome.
+        List<ResourceLocation> filler = profile.terrain() == AgeRuntimeProfile.Terrain.VOID && !authored.isEmpty()
+                ? new ArrayList<>() : new ArrayList<>(availableBiomes);
         java.util.Collections.shuffle(filler, new Random(seed ^ 0x42494F4D45504F4FL));
         for (ResourceLocation id : filler) {
             if (distinct.size() >= target) break;
@@ -102,14 +108,26 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         if (isCave(profile)) {
             List<ResourceLocation> tagged = registry.listElements().filter(holder -> holder.is(CAVE_BIOMES))
                     .map(holder -> holder.key().location()).sorted().toList();
-            if (!tagged.isEmpty()) return tagged;
+            List<ResourceLocation> vanilla = !tagged.isEmpty() ? tagged : List.of("minecraft:deep_dark", "minecraft:dripstone_caves", "minecraft:lush_caves")
-            return List.of("minecraft:deep_dark", "minecraft:dripstone_caves", "minecraft:lush_caves")
                     .stream().map(ResourceLocation::parse)
                     .filter(id -> registry.get(ResourceKey.create(Registries.BIOME, id)).isPresent()).toList();
+            List<ResourceLocation> nether = registry.listElements().filter(holder -> holder.is(BiomeTags.IS_NETHER))
+                    .map(holder -> holder.key().location()).toList();
+            return merge(merge(vanilla, nether), TerraBlenderBiomes.nether(registries));
         }
         if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID) {
             return List.of(ResourceLocation.withDefaultNamespace("the_void"));
         }
+        ResourceLocation preset = profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
+                ? ResourceLocation.withDefaultNamespace("overworld") : profile.biomePreset();
+        List<ResourceLocation> nativeBiomes = presetBiomes(registries, profile);
+        return merge(nativeBiomes, preset.equals(ResourceLocation.withDefaultNamespace("nether"))
+                ? TerraBlenderBiomes.nether(registries) : TerraBlenderBiomes.overworld(registries));
+    }
+
+    private static List<ResourceLocation> presetBiomes(RegistryAccess registries, AgeRuntimeProfile profile) {
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+            return List.of(ResourceLocation.withDefaultNamespace("the_void"));
         ResourceLocation preset = profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
                 ? ResourceLocation.withDefaultNamespace("overworld") : profile.biomePreset();
         var parameters = registries.lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST)
@@ -119,6 +137,15 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
                 .sorted(Comparator.naturalOrder()).toList();
     }
 
+    public static boolean isCaveBiome(RegistryAccess registries, Holder.Reference<Biome> holder) {
+        return holder.is(CAVE_BIOMES) || holder.is(BiomeTags.IS_NETHER)
+                || TerraBlenderBiomes.nether(registries).contains(holder.key().location());
+    }
+
+    private static List<ResourceLocation> merge(List<ResourceLocation> vanilla, List<ResourceLocation> additions) {
+        return java.util.stream.Stream.concat(vanilla.stream(), additions.stream()).distinct().sorted().toList();
+    }
+
     public static boolean isCave(AgeRuntimeProfile profile) {
         return profile.terrain() == AgeRuntimeProfile.Terrain.NOISE
                 && profile.noiseSettings().equals(ResourceLocation.withDefaultNamespace("caves"));

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

@@ -0,0 +1,87 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class AgeDecayGameTests {
+    private AgeDecayGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void frontierRoundTripsWithoutDuplicates(GameTestHelper helper) {
+        AgeDecaySavedData data = new AgeDecaySavedData();
+        BlockPos first = new BlockPos(3, 70, 5);
+        data.add(DecayBlock.Color.BLUE, first);
+        data.add(DecayBlock.Color.BLUE, first);
+        data.add(DecayBlock.Color.WHITE, new BlockPos(-4, 64, 9));
+        helper.assertValueEqual(data.frontier(DecayBlock.Color.BLUE).size(), 1,
+                "One frontier block must not be stored twice");
+        helper.assertValueEqual(data.nextAttempt(), 0L, "First attempt starts at zero");
+        AgeDecaySavedData restored = AgeDecaySavedData.load(
+                data.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.nextAttempt(), 1L, "Attempt sequence survives reload");
+        helper.assertValueEqual(restored.frontier(DecayBlock.Color.BLUE).getFirst(), first,
+                "Blue frontier survives reload");
+        helper.assertValueEqual(restored.frontier(DecayBlock.Color.WHITE).size(), 1,
+                "White frontier survives reload independently");
+        restored.remove(DecayBlock.Color.BLUE, first);
+        helper.assertTrue(restored.frontier(DecayBlock.Color.BLUE).isEmpty(),
+                "Removed frontier is not scheduled for further spread");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void targetMustRemainInChosenLoadedChunk(GameTestHelper helper) {
+        BlockPos center = helper.absolutePos(new BlockPos(1, 1, 1));
+        ChunkPos chunk = new ChunkPos(center);
+        helper.assertTrue(AgeDecayProviders.isLoadedTarget(helper.getLevel(), List.of(chunk), center),
+                "An already-loaded target inside the selected chunk is eligible");
+        BlockPos outside = new BlockPos((chunk.x + 1) << 4, center.getY(), center.getZ());
+        helper.assertTrue(!AgeDecayProviders.isLoadedTarget(helper.getLevel(), List.of(chunk), outside),
+                "Spread cannot cross into a chunk absent from this Age run");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void overworldCannotRunDecayProvider(GameTestHelper helper) {
+        UUID ageId = UUID.randomUUID();
+        AgeDefinition age = new AgeDefinition(ageId, "Decay isolation", 100L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(ageId), null,
+                AgeTraits.LEGACY_DEFAULTS);
+        AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(1);
+        var context = new AgeInstabilityRuntime.Context(helper.getLevel(), age,
+                List.of(new ChunkPos(helper.absolutePos(new BlockPos(1, 1, 1)))),
+                helper.getLevel().getServer().getTickCount(), budget);
+        AgeDecayProviders.apply(context, ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "decayblue"), 1);
+        helper.assertValueEqual(budget.remaining(), 1, "Overworld decay cannot claim an Age action");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void savedSpawnAndPlatformAreProtected(GameTestHelper helper) {
+        UUID ageId = UUID.randomUUID();
+        BlockPos spawn = new BlockPos(0, 65, 0);
+        AgeDefinition age = new AgeDefinition(ageId, "Protected arrival", 100L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(ageId), spawn,
+                AgeTraits.LEGACY_DEFAULTS);
+        helper.assertTrue(AgeDecayProviders.isSpawnProtected(age, spawn.below().offset(2, 0, 2)),
+                "Arrival platform must not decay");
+        helper.assertTrue(AgeDecayProviders.isSpawnProtected(age, spawn.offset(4, 0, 4)),
+                "The protective margin must not decay");
+        helper.assertTrue(!AgeDecayProviders.isSpawnProtected(age, spawn.offset(5, 0, 0)),
+                "Spawn protection is bounded");
+        helper.succeed();
+    }
+}

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

@@ -0,0 +1,202 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.util.BlockSnapshot;
+import net.neoforged.neoforge.common.util.FakePlayerFactory;
+import net.neoforged.neoforge.event.level.BlockEvent;
+
+/** Bounded, per-Age decay seeding and six-direction Legacy-style spreading. */
+public final class AgeDecayProviders {
+    public static final TagKey<Block> PROTECTED = TagKey.create(Registries.BLOCK,
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "decay_protected"));
+    private static final Map<ResourceLocation, DecayBlock.Color> COLORS = Map.of(
+            id("decayblue"), DecayBlock.Color.BLUE,
+            id("decaypurple"), DecayBlock.Color.PURPLE,
+            id("decayred"), DecayBlock.Color.RED,
+            id("decaywhite"), DecayBlock.Color.WHITE);
+    private static final Direction[] DIRECTIONS = Direction.values();
+
+    private AgeDecayProviders() {}
+
+    public static void register() {
+        COLORS.keySet().forEach(id -> AgeInstabilityRuntime.register(id, true, AgeDecayProviders::apply));
+    }
+
+    /** Operator test hook; never changes the Age's saved instability score or provider plan. */
+    public static int pulseForTesting(ServerPlayer player, DecayBlock.Color color, int count) {
+        ServerLevel level = player.serverLevel();
+        if (!RivencraftConfig.decayEnabled() || !RivencraftConfig.instabilityWorldMutation()
+                || !AgeInstabilityRuntime.isAgeDimension(level.dimension().location())
+                || !level.getChunkSource().hasChunk(player.chunkPosition().x, player.chunkPosition().z)) return -1;
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null) return -1;
+        ResourceLocation id = id("decay" + color.getSerializedName());
+        int changed = 0;
+        for (int i = 0; i < Math.min(count, 32); i++) {
+            AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(1);
+            apply(new AgeInstabilityRuntime.Context(level, age, List.of(player.chunkPosition()),
+                    level.getServer().getTickCount(), budget), id, 1);
+            changed += 1 - budget.remaining();
+        }
+        return changed;
+    }
+
+    static void apply(AgeInstabilityRuntime.Context context, ResourceLocation id, int level) {
+        if (!RivencraftConfig.decayEnabled() || !RivencraftConfig.instabilityWorldMutation()
+                || !AgeInstabilityRuntime.isAgeDimension(context.level().dimension().location())
+                || !context.age().dimensionId().equals(context.level().dimension().location())
+                || context.loadedChunks().isEmpty()) return;
+        DecayBlock.Color color = COLORS.get(id);
+        if (color == null) return;
+        AgeDecaySavedData data = AgeDecaySavedData.get(context.level());
+        Random random = new Random(context.age().seed() ^ data.nextAttempt() * 0x9E3779B97F4A7C15L
+                ^ id.hashCode());
+        List<BlockPos> frontier = data.frontier(color);
+        BlockPos source = selectLoadedSource(context.level(), context.loadedChunks(), frontier, random);
+        if (source == null) {
+            seed(context, color, data, random);
+            return;
+        }
+        BlockState sourceState = context.level().getBlockState(source);
+        if (!sourceState.is(ModBlocks.DECAY.get()) || sourceState.getValue(DecayBlock.COLOR) != color) {
+            data.remove(color, source);
+            return;
+        }
+        for (int attempt = 0; attempt < RivencraftConfig.decayMaxAttempts(); attempt++) {
+            BlockPos target = source.relative(DIRECTIONS[random.nextInt(DIRECTIONS.length)]);
+            if (!isLoadedTarget(context.level(), context.loadedChunks(), target)
+                    || isSpawnProtected(context.age(), target)) continue;
+            BlockState prior = context.level().getBlockState(target);
+            if (!canReplace(context.level(), target, prior, color)) continue;
+            int difficulty = conversionDifficulty(context.level(), target, prior, color);
+            if (random.nextInt(difficulty) != 0) continue;
+            if (replace(context, target, prior, color)) data.add(color, target);
+            return;
+        }
+    }
+
+    private static void seed(AgeInstabilityRuntime.Context context, DecayBlock.Color color,
+                             AgeDecaySavedData data, Random random) {
+        ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+        int x = chunk.getMinBlockX() + random.nextInt(16);
+        int z = chunk.getMinBlockZ() + random.nextInt(16);
+        BlockPos pos = new BlockPos(x,
+                context.level().getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x, z) - 1, z);
+        if (!isLoadedTarget(context.level(), context.loadedChunks(), pos)
+                || isSpawnProtected(context.age(), pos)) return;
+        BlockState prior = context.level().getBlockState(pos);
+        if (canReplace(context.level(), pos, prior, color) && replace(context, pos, prior, color)) {
+            data.add(color, pos);
+        }
+    }
+
+    private static BlockPos selectLoadedSource(ServerLevel level, List<ChunkPos> chunks,
+                                                List<BlockPos> frontier, Random random) {
+        if (frontier.isEmpty()) return null;
+        int start = random.nextInt(frontier.size());
+        for (int i = 0; i < Math.min(frontier.size(), 16); i++) {
+            BlockPos pos = frontier.get((start + i) % frontier.size());
+            if (isLoadedTarget(level, chunks, pos)) return pos;
+        }
+        return null;
+    }
+
+    static boolean isLoadedTarget(ServerLevel level, List<ChunkPos> chunks, BlockPos pos) {
+        return level.isInWorldBounds(pos) && level.getChunkSource().hasChunk(pos.getX() >> 4, pos.getZ() >> 4)
+                && chunks.contains(new ChunkPos(pos));
+    }
+
+    static boolean isSpawnProtected(AgeDefinition age, BlockPos pos) {
+        BlockPos spawn = age.spawn();
+        return spawn != null && Math.abs(pos.getX() - spawn.getX()) <= 4
+                && Math.abs(pos.getZ() - spawn.getZ()) <= 4
+                && pos.getY() >= spawn.getY() - 2 && pos.getY() <= spawn.getY() + 4;
+    }
+
+    static boolean canReplace(ServerLevel level, BlockPos pos, BlockState prior, DecayBlock.Color color) {
+        if (!AgeInstabilityRuntime.isAgeDimension(level.dimension().location())
+                || !level.isInWorldBounds(pos) || !level.getChunkSource().hasChunk(pos.getX() >> 4, pos.getZ() >> 4)
+                || prior.is(PROTECTED) || prior.is(BlockTags.PORTALS)
+                || prior.hasBlockEntity() || level.getBlockEntity(pos) != null
+                || prior.getDestroySpeed(level, pos) < 0 || !prior.getFluidState().isEmpty()
+                || isCritical(prior)) return false;
+        return !prior.is(ModBlocks.DECAY.get()) || prior.getValue(DecayBlock.COLOR) != color;
+    }
+
+    private static boolean isCritical(BlockState prior) {
+        return prior.is(Blocks.BEDROCK) || prior.is(Blocks.BARRIER)
+                || prior.is(Blocks.END_PORTAL) || prior.is(Blocks.END_PORTAL_FRAME)
+                || prior.is(Blocks.END_GATEWAY) || prior.is(Blocks.NETHER_PORTAL)
+                || prior.is(Blocks.COMMAND_BLOCK) || prior.is(Blocks.CHAIN_COMMAND_BLOCK)
+                || prior.is(Blocks.REPEATING_COMMAND_BLOCK) || prior.is(Blocks.STRUCTURE_BLOCK)
+                || prior.is(Blocks.JIGSAW) || prior.is(Blocks.LIGHT)
+                || prior.is(Blocks.REINFORCED_DEEPSLATE)
+                || prior.getBlock() != ModBlocks.DECAY.get()
+                && net.minecraft.core.registries.BuiltInRegistries.BLOCK.getKey(prior.getBlock())
+                        .getNamespace().equals(Rivencraft.MOD_ID);
+    }
+
+    static int conversionDifficulty(ServerLevel level, BlockPos pos, BlockState state, DecayBlock.Color color) {
+        if (state.isAir()) return switch (color) {
+            case BLUE, RED -> 20;
+            case PURPLE -> 8;
+            case WHITE -> 50;
+        };
+        if (state.is(ModBlocks.DECAY.get())) return color == DecayBlock.Color.WHITE ? 1 : 5;
+        float hardness = Math.min(1000.0F, Math.max(0.0F, state.getDestroySpeed(level, pos)));
+        return switch (color) {
+            case BLUE -> Math.max(1, (int) hardness * 2);
+            case RED -> Math.max(1, (int) hardness);
+            case PURPLE -> Math.max(1, ((int) hardness + 1) * 10);
+            case WHITE -> 1;
+        };
+    }
+
+    private static boolean replace(AgeInstabilityRuntime.Context context, BlockPos pos, BlockState prior,
+                                   DecayBlock.Color color) {
+        ServerLevel level = context.level();
+        // A fake player gives claim/protection listeners the Age and exact block position.
+        var actor = FakePlayerFactory.getMinecraft(level);
+        actor.setPos(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        if (!prior.isAir()) {
+            var breakEvent = new BlockEvent.BreakEvent(level, pos, prior, actor);
+            NeoForge.EVENT_BUS.post(breakEvent);
+            if (breakEvent.isCanceled()) return false;
+        }
+        if (level.getBlockState(pos) != prior || !context.budget().claim()) return false;
+        var snapshot = BlockSnapshot.create(level.dimension(), level, pos);
+        BlockState decay = ModBlocks.DECAY.get().defaultBlockState().setValue(DecayBlock.COLOR, color);
+        if (!level.setBlock(pos, decay, 3)) return false;
+        var placeEvent = new BlockEvent.EntityPlaceEvent(snapshot, prior, actor);
+        NeoForge.EVENT_BUS.post(placeEvent);
+        if (placeEvent.isCanceled()) {
+            snapshot.restore();
+            return false;
+        }
+        return true;
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+}

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

@@ -0,0 +1,81 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.datafix.DataFixTypes;
+import net.minecraft.world.level.saveddata.SavedData;
+
+/** Small, per-Age frontier and deterministic attempt counter; never stores chunk references. */
+public final class AgeDecaySavedData extends SavedData {
+    private static final int MAX_FRONTIER_PER_COLOR = 1024;
+    private static final Factory<AgeDecaySavedData> FACTORY = new Factory<>(AgeDecaySavedData::new,
+            AgeDecaySavedData::load, DataFixTypes.SAVED_DATA_MAP_DATA);
+    private final EnumMap<DecayBlock.Color, List<BlockPos>> frontiers = new EnumMap<>(DecayBlock.Color.class);
+    private long attempts;
+
+    public AgeDecaySavedData() {
+        for (DecayBlock.Color color : DecayBlock.Color.values()) frontiers.put(color, new ArrayList<>());
+    }
+
+    public static AgeDecaySavedData get(ServerLevel level) {
+        return level.getDataStorage().computeIfAbsent(FACTORY, "rivencraft_decay");
+    }
+
+    public long nextAttempt() {
+        setDirty();
+        return attempts++;
+    }
+
+    public List<BlockPos> frontier(DecayBlock.Color color) {
+        return frontiers.get(color);
+    }
+
+    public void add(DecayBlock.Color color, BlockPos pos) {
+        List<BlockPos> frontier = frontiers.get(color);
+        if (frontier.contains(pos)) return;
+        if (frontier.size() >= MAX_FRONTIER_PER_COLOR) frontier.remove(0);
+        frontier.add(pos.immutable());
+        setDirty();
+    }
+
+    public void remove(DecayBlock.Color color, BlockPos pos) {
+        if (frontiers.get(color).remove(pos)) setDirty();
+    }
+
+    @Override
+    public CompoundTag save(CompoundTag tag, HolderLookup.Provider registries) {
+        tag.putLong("Attempts", attempts);
+        for (DecayBlock.Color color : DecayBlock.Color.values()) {
+            ListTag positions = new ListTag();
+            for (BlockPos pos : frontiers.get(color)) {
+                CompoundTag entry = new CompoundTag();
+                entry.putInt("X", pos.getX());
+                entry.putInt("Y", pos.getY());
+                entry.putInt("Z", pos.getZ());
+                positions.add(entry);
+            }
+            tag.put(color.getSerializedName(), positions);
+        }
+        return tag;
+    }
+
+    static AgeDecaySavedData load(CompoundTag tag, HolderLookup.Provider registries) {
+        AgeDecaySavedData data = new AgeDecaySavedData();
+        data.attempts = Math.max(0L, tag.getLong("Attempts"));
+        for (DecayBlock.Color color : DecayBlock.Color.values()) {
+            ListTag positions = tag.getList(color.getSerializedName(), CompoundTag.TAG_COMPOUND);
+            for (int index = 0; index < Math.min(positions.size(), MAX_FRONTIER_PER_COLOR); index++) {
+                CompoundTag entry = positions.getCompound(index);
+                data.frontiers.get(color).add(new BlockPos(entry.getInt("X"), entry.getInt("Y"), entry.getInt("Z")));
+            }
+        }
+        return data;
+    }
+}

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

@@ -1,10 +1,12 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.Objects;
+import java.util.List;
 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 +19,11 @@ public record AgeDefinition(
         ResourceLocation dimensionId,
         BlockPos spawn,
         AgeTraits traits,
-        AgeGenerationPlan plan
+        AgeGenerationPlan plan,
+        @Nullable AgeSeasonMode seasonMode,
+        List<AgeFeatureSelection.Choice> randomFeatures,
+        AgeInstability instability,
+        AgeInstabilityPlan instabilityPlan
 ) {
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
@@ -30,6 +36,12 @@ public record AgeDefinition(
         Objects.requireNonNull(generationProfile, "generationProfile");
         Objects.requireNonNull(dimensionId, "dimensionId");
         Objects.requireNonNull(traits, "traits");
+        Objects.requireNonNull(instability, "instability");
+        Objects.requireNonNull(instabilityPlan, "instabilityPlan");
+        randomFeatures = List.copyOf(randomFeatures);
+        if (plan != null && !randomFeatures.isEmpty()) {
+            throw new IllegalArgumentException("Authored Ages cannot also have random features");
+        }
         if (plan != null && plan.ageSeed() != seed) {
             throw new IllegalArgumentException("Age plan seed does not match its Age definition");
         }
@@ -39,7 +51,40 @@ 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, List.of(), AgeInstability.legacyNeutral());
+    }
+
+    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, List.of(), AgeInstability.legacyNeutral());
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
+                         @Nullable AgeSeasonMode seasonMode) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, List.of(), AgeInstability.legacyNeutral());
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
+                         @Nullable AgeSeasonMode seasonMode, List<AgeFeatureSelection.Choice> randomFeatures) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, randomFeatures, AgeInstability.legacyNeutral());
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
+                         @Nullable AgeSeasonMode seasonMode, List<AgeFeatureSelection.Choice> randomFeatures,
+                         AgeInstability instability) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, randomFeatures, instability,
+                AgeInstabilityPlan.empty());
     }
 
     public static ResourceLocation dimensionId(UUID ageId) {
@@ -70,6 +115,7 @@ 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,
+                randomFeatures, instability, instabilityPlan);
     }
 }

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

@@ -13,7 +13,10 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.Random;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.registry.ModBlocks;
 import net.dnorberg.rivencraft.compat.ImmersivePortalsChunkLoaders;
+import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
+import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.GlobalPos;
@@ -37,6 +40,8 @@ import net.minecraft.world.level.biome.FixedBiomeSource;
 import net.minecraft.world.level.biome.MultiNoiseBiomeSource;
 import net.dnorberg.rivencraft.world.ScaledBiomeSource;
 import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.StarFissureFeature;
 import net.minecraft.world.level.chunk.ChunkGenerator;
 import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
 import net.minecraft.world.level.dimension.DimensionType;
@@ -73,6 +78,7 @@ public final class AgeDimensionService {
                 );
                 if (level != null) {
                     applyCelestialClock(level, age);
+                    SereneSeasonsCompatibility.registerAge(server, age);
                 }
             }
             synchronizeImmersivePortals(server);
@@ -95,6 +101,13 @@ public final class AgeDimensionService {
         if (spawn == null) {
             applyInitialCelestialPhase(level, definition);
             spawn = createSafeSpawn(level, definition);
+            if (AgeFeatureSelection.resolved(definition.plan()).stream()
+                    .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES))
+                    || definition.randomFeatures().stream()
+                    .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES))) {
+                StarFissureFeature.generate(level, definition.seed(), spawn,
+                        AgeBiomeSelection.isCave(runtimeProfile(definition)));
+            }
             definition = AgeRegistrySavedData.get(level).setSpawn(definition.id(), spawn);
         }
         return Optional.of(new LinkTarget(
@@ -109,6 +122,7 @@ public final class AgeDimensionService {
         ServerLevel existing = server.getLevel(key);
         if (existing != null) {
             applyCelestialClock(existing, definition);
+            SereneSeasonsCompatibility.registerAge(server, definition);
             return existing;
         }
 
@@ -124,6 +138,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;
@@ -214,7 +229,7 @@ public final class AgeDimensionService {
         for (int x = -PLATFORM_RADIUS; x <= PLATFORM_RADIUS; x++) {
             for (int z = -PLATFORM_RADIUS; z <= PLATFORM_RADIUS; z++) {
                 BlockPos floor = floorCenter.offset(x, 0, z);
-                level.setBlock(floor, Blocks.COBBLESTONE.defaultBlockState(), 2);
+                level.setBlock(floor, ModBlocks.CLOUD_PLATFORM.get().defaultBlockState(), 2);
                 for (int y = 1; y <= 4; y++) {
                     level.setBlock(floor.above(y), Blocks.AIR.defaultBlockState(), 2);
                 }
@@ -297,6 +312,8 @@ public final class AgeDimensionService {
     private static ChunkGenerator createGenerator(MinecraftServer server, AgeDefinition age) {
         AgeRuntimeProfile profile = runtimeProfile(age);
         BiomeSource biomeSource = createBiomeSource(server, age, profile);
+        List<AgeFeatureSelection.Choice> features = age.plan() == null
+                ? age.randomFeatures() : AgeFeatureSelection.resolved(age.plan());
         if (profile.terrain() == AgeRuntimeProfile.Terrain.FLAT) {
             var settings = FlatLevelGeneratorSettings.getDefault(
                     server.registryAccess().lookupOrThrow(Registries.BIOME),
@@ -304,7 +321,7 @@ public final class AgeDimensionService {
                     server.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE)
             );
             return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
-                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings, features, age.seed());
         }
         if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID) {
             FlatLevelGeneratorSettings settings = new FlatLevelGeneratorSettings(
@@ -314,14 +331,19 @@ public final class AgeDimensionService {
             );
             settings.updateLayers();
             return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
-                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings, features, age.seed());
         }
 
         var noiseSettings = server.registryAccess().lookupOrThrow(Registries.NOISE_SETTINGS);
         ResourceKey<NoiseGeneratorSettings> settingsKey = ResourceKey.create(
                 Registries.NOISE_SETTINGS, profile.noiseSettings());
         NoiseGeneratorSettings baseSettings = noiseSettings.getOrThrow(settingsKey).value();
-        return new NoiseBasedChunkGenerator(biomeSource, Holder.direct(withBiomeMaterialRules(baseSettings)));
+        Holder<NoiseGeneratorSettings> settings = Holder.direct(withBiomeMaterialRules(baseSettings));
+        boolean caveTerrain = AgeBiomeSelection.isCave(profile);
+        return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
+                ? new NoiseBasedChunkGenerator(biomeSource, settings)
+                : new AgeFeatureChunkGenerator(biomeSource, settings, features, age.seed(),
+                        caveTerrain, caveTerrain ? TerraBlenderBiomes.nether(server.registryAccess()) : List.of());
     }
 
     private static NoiseGeneratorSettings withBiomeMaterialRules(NoiseGeneratorSettings base) {

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

@@ -15,14 +15,14 @@ public final class AgeEnvironmentCompiler {
         AgeTraits.Weather weather = seeded.weather();
         double period = seeded.celestialPeriod();
         float phase = seeded.celestialPhase();
-        boolean normalTime = plan.symbols().stream()
+        boolean normalTime = plan.activeSymbols().stream()
                 .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.CELESTIAL);
         if (normalTime) period = 1.0D;
         boolean writtenPeriod = false;
         boolean writtenPhase = false;
         float phaseDegrees = 0.0F;
 
-        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.symbols()) {
+        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.activeSymbols()) {
             SymbolSemantics semantics = symbol.semantics();
             switch (semantics.role()) {
                 case LIGHTING -> lighting = AgeTraits.Lighting.valueOf(
@@ -61,7 +61,7 @@ public final class AgeEnvironmentCompiler {
     /** Vanilla effects are the sky styles the current renderer can honor exactly. */
     public static ResourceLocation skyEffects(AgeGenerationPlan plan, ResourceLocation fallback) {
         if (plan == null) return fallback;
-        return plan.symbols().stream()
+        return plan.activeSymbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SKY)
                 .map(symbol -> ((SymbolSemantics.ChoiceValue) symbol.semantics().value()).id())
                 .map(choice -> switch (choice) {
@@ -73,7 +73,7 @@ public final class AgeEnvironmentCompiler {
     }
 
     public static boolean hasWrittenPhase(AgeGenerationPlan plan) {
-        return plan != null && plan.symbols().stream()
+        return plan != null && plan.activeSymbols().stream()
                 .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.PHASE_MODIFIER);
     }
 

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

@@ -0,0 +1,292 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.dnorberg.rivencraft.registry.ModSounds;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.particles.ParticleTypes;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.entity.EntityTypeTest;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.util.BlockSnapshot;
+import net.neoforged.neoforge.common.util.FakePlayerFactory;
+import net.neoforged.neoforge.event.level.BlockEvent;
+import net.neoforged.neoforge.event.level.LevelEvent;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** Meteor, active Legacy burning, and test-enabled Legacy erosion. */
+public final class AgeEnvironmentalProviders {
+    private static final ResourceLocation METEORS = id("meteors");
+    private static final ResourceLocation BURNING = id("burning");
+    private static final ResourceLocation EROSION = id("erosion");
+    private static final int METEOR_FLIGHT_TICKS = 30;
+    private static final int MAX_ACTIVE_AGES = 16;
+    private static final Direction[] FLUID_SIDES = {
+            Direction.UP, Direction.NORTH, Direction.SOUTH, Direction.EAST, Direction.WEST
+    };
+    private static final Map<ServerLevel, Meteor> ACTIVE = new WeakHashMap<>();
+
+    private AgeEnvironmentalProviders() {}
+
+    public static void register() {
+        AgeInstabilityRuntime.register(METEORS, false, AgeEnvironmentalProviders::apply);
+        AgeInstabilityRuntime.register(BURNING, false, AgeEnvironmentalProviders::apply);
+        AgeInstabilityRuntime.register(EROSION, true, AgeEnvironmentalProviders::apply);
+    }
+
+    /** Operator test pulse; bypasses chance but never Age, loading, policy, or cooldown checks. */
+    public static int pulseForTesting(ServerPlayer player, String effect) {
+        ServerLevel level = player.serverLevel();
+        if (!AgeInstabilityRuntime.isAgeDimension(level.dimension().location())) return -1;
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null) return -1;
+        List<ChunkPos> chunks = AgeHazardProviders.loadedChunksNearPlayers(level, 16);
+        if (chunks.isEmpty()) return 0;
+        var context = new AgeInstabilityRuntime.Context(level, age, chunks,
+                level.getServer().getTickCount(), new AgeInstabilityRuntime.Budget(1));
+        return switch (effect) {
+            case "meteor" -> RivencraftConfig.meteorEnabled() && scheduleMeteor(context, 1, true) ? 1 : 0;
+            case "burning" -> {
+                if (!RivencraftConfig.scorchEnabled() || !RivencraftConfig.scorchPlayers()
+                        || !eligibleScorch(context, player)) yield 0;
+                // Vanilla extinguishes this fire on the next entity tick in rain or water.
+                // Report that explicitly instead of claiming the test pulse worked.
+                if (player.isInWaterRainOrBubble()) yield -2;
+                player.igniteForSeconds(4);
+                yield 1;
+            }
+            case "erosion" -> {
+                if (!RivencraftConfig.erosionEnabled() || !AgeHazardProviders.canMutate(level)
+                        || age.instability().score() < InstabilityProviderCatalog.Deck.DESTRUCTIVE.entryCost()
+                        || !(player.pick(6.0, 0.0F, false) instanceof BlockHitResult hit)) yield 0;
+                BlockPos pos = hit.getBlockPos();
+                yield erodeAt(context, pos) ? 1 : 0;
+            }
+            default -> -1;
+        };
+    }
+
+    static boolean isEnvironmental(ResourceLocation id) {
+        return METEORS.equals(id) || BURNING.equals(id) || EROSION.equals(id);
+    }
+
+    static void tickPlanned(ServerLevel level, AgeDefinition age, long tick) {
+        List<AgeInstabilityPlan.ProviderLevel> cards = age.instabilityPlan().providers().stream()
+                .filter(card -> isEnvironmental(card.id())).toList();
+        boolean optInErosion = RivencraftConfig.erosionEnabled()
+                && age.instability().score() >= InstabilityProviderCatalog.Deck.DESTRUCTIVE.entryCost();
+        if (cards.isEmpty() && !optInErosion) return;
+        List<ChunkPos> chunks = AgeHazardProviders.loadedChunksNearPlayers(level,
+                RivencraftConfig.hazardsMaxChunks());
+        if (chunks.isEmpty()) return;
+        for (AgeInstabilityPlan.ProviderLevel card : cards) {
+            int maximum = BURNING.equals(card.id()) ? RivencraftConfig.scorchMaxTargets() : 1;
+            var context = new AgeInstabilityRuntime.Context(level, age, chunks, tick,
+                    new AgeInstabilityRuntime.Budget(maximum));
+            AgeInstabilityRuntime.invoke(context, card.id(), card.level());
+        }
+        if (optInErosion && cards.stream().noneMatch(card -> EROSION.equals(card.id()))) {
+            var context = new AgeInstabilityRuntime.Context(level, age, chunks, tick,
+                    new AgeInstabilityRuntime.Budget(1));
+            AgeInstabilityRuntime.invoke(context, EROSION, 1);
+        }
+    }
+
+    static void apply(AgeInstabilityRuntime.Context context, ResourceLocation id, int effectiveLevel) {
+        if (!matchesAge(context.age(), context.level().dimension().location())
+                || context.loadedChunks().isEmpty()) return;
+        if (METEORS.equals(id)) scheduleMeteor(context, effectiveLevel, false);
+        else if (BURNING.equals(id)) scorch(context, effectiveLevel);
+        else if (EROSION.equals(id)) erode(context);
+    }
+
+    static boolean matchesAge(AgeDefinition age, ResourceLocation dimension) {
+        return AgeInstabilityRuntime.isAgeDimension(dimension) && age.dimensionId().equals(dimension);
+    }
+
+    private static boolean scheduleMeteor(AgeInstabilityRuntime.Context context, int effectiveLevel, boolean force) {
+        if (!RivencraftConfig.meteorEnabled() || ACTIVE.containsKey(context.level())
+                || ACTIVE.size() >= MAX_ACTIVE_AGES) return false;
+        AgeHazardSavedData data = AgeHazardSavedData.get(context.level());
+        long gameTime = context.level().getGameTime();
+        if (!data.meteorReady(gameTime, 200)) return false;
+        Random random = new Random(context.age().seed() ^ data.nextAttempt() * 0xD1B54A32D192ED03L
+                ^ METEORS.hashCode());
+        if (!force && random.nextDouble() >= AgeHazardProviders.legacyChance(context.loadedChunks().size(),
+                RivencraftConfig.instabilityCooldown(), effectiveLevel, 50000)) return false;
+        int start = random.nextInt(context.loadedChunks().size());
+        for (int offset = 0; offset < Math.min(16, context.loadedChunks().size()); offset++) {
+            ChunkPos chunk = context.loadedChunks().get((start + offset) % context.loadedChunks().size());
+            int x = chunk.getMinBlockX() + 6 + random.nextInt(4);
+            int z = chunk.getMinBlockZ() + 6 + random.nextInt(4);
+            int surfaceY = context.level().getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x, z);
+            BlockPos impact = new BlockPos(x, surfaceY, z);
+            if (surfaceY >= context.level().getMaxBuildHeight() - 8
+                    || !AgeHazardProviders.safeTarget(context, impact, 8)) continue;
+            if (!context.budget().claim()) return false;
+            int startY = Math.min(context.level().getMaxBuildHeight() - 2, surfaceY + 48);
+            data.recordMeteor(gameTime);
+            ACTIVE.put(context.level(), new Meteor(chunk, impact, startY, METEOR_FLIGHT_TICKS));
+            context.level().playSound(null, impact, ModSounds.METEOR_ROAR.get(), SoundSource.WEATHER, 2.0F, 1.0F);
+            return true;
+        }
+        return false;
+    }
+
+    public static void onLevelTickPost(LevelTickEvent.Post event) {
+        if (!(event.getLevel() instanceof ServerLevel level)) return;
+        Meteor meteor = ACTIVE.get(level);
+        if (meteor == null) return;
+        if (!RivencraftConfig.instabilityEnabled() || !RivencraftConfig.meteorEnabled()
+                || !AgeInstabilityRuntime.isAgeDimension(level.dimension().location())
+                || level.players().isEmpty()
+                || !level.getChunkSource().hasChunk(meteor.chunk().x, meteor.chunk().z)) {
+            ACTIVE.remove(level);
+            return;
+        }
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null) {
+            ACTIVE.remove(level);
+            return;
+        }
+        int remaining = meteor.remaining() - 1;
+        if (remaining <= 0) {
+            ACTIVE.remove(level); // clear before impact so an exception cannot replay it
+            AgeHazardProviders.explodeBounded(level, age, meteor.chunk(), meteor.impact(),
+                    RivencraftConfig.meteorBlockDamage(), RivencraftConfig.meteorPlayerDamage(),
+                    RivencraftConfig.meteorFire(), RivencraftConfig.meteorMaxBlocks(),
+                    RivencraftConfig.meteorMaxEntities(), RivencraftConfig.meteorMaxDamage(), 3);
+            return;
+        }
+        double progress = 1.0 - remaining / (double) METEOR_FLIGHT_TICKS;
+        double y = meteor.startY() + (meteor.impact().getY() - meteor.startY()) * progress;
+        double x = meteor.impact().getX() + 0.5 + (1.0 - progress) * 2.0;
+        double z = meteor.impact().getZ() + 0.5 + (1.0 - progress) * 2.0;
+        level.sendParticles(ParticleTypes.FLAME, x, y, z, 5, 0.25, 0.25, 0.25, 0.01);
+        level.sendParticles(ParticleTypes.LARGE_SMOKE, x, y, z, 2, 0.3, 0.3, 0.3, 0.02);
+        ACTIVE.put(level, new Meteor(meteor.chunk(), meteor.impact(), meteor.startY(), remaining));
+    }
+
+    public static void onServerStopping(ServerStoppingEvent event) {
+        ACTIVE.clear(); // an interrupted descent is cancelled, never replayed after restart
+    }
+
+    public static void onLevelUnload(LevelEvent.Unload event) {
+        if (event.getLevel() instanceof ServerLevel level) ACTIVE.remove(level);
+    }
+
+    private static void scorch(AgeInstabilityRuntime.Context context, int effectiveLevel) {
+        if (!RivencraftConfig.scorchEnabled() || RivencraftConfig.scorchMaxTargets() == 0) return;
+        ServerLevel level = context.level();
+        Random random = new Random(context.age().seed() ^ AgeHazardSavedData.get(level).nextAttempt()
+                * 0x9E3779B97F4A7C15L ^ BURNING.hashCode());
+        int start = random.nextInt(context.loadedChunks().size());
+        int affected = 0;
+        for (int offset = 0; offset < Math.min(8, context.loadedChunks().size()); offset++) {
+            ChunkPos chunk = context.loadedChunks().get((start + offset) % context.loadedChunks().size());
+            AABB bounds = new AABB(chunk.getMinBlockX(), level.getMinBuildHeight(), chunk.getMinBlockZ(),
+                    chunk.getMaxBlockX() + 1, level.getMaxBuildHeight(), chunk.getMaxBlockZ() + 1);
+            List<LivingEntity> candidates = new ArrayList<>();
+            level.getEntities(EntityTypeTest.forClass(LivingEntity.class), bounds,
+                    entity -> eligibleScorch(context, entity), candidates, 8);
+            candidates.sort(Comparator.comparing(Entity::getUUID));
+            for (LivingEntity entity : candidates) {
+                if (affected >= RivencraftConfig.scorchMaxTargets() || context.budget().remaining() == 0) return;
+                // Legacy sampled each chunk each tick with a 1/10 gate. With 20 ticks/pass this
+                // gives at least one opportunity for nearly every inspected loaded chunk.
+                if (random.nextDouble() >= AgeHazardProviders.legacyChance(1,
+                        RivencraftConfig.instabilityCooldown(), 1, 10)) continue;
+                if (!context.budget().claim()) return;
+                entity.igniteForSeconds(Math.min(12, 4 * effectiveLevel));
+                affected++;
+                break;
+            }
+        }
+    }
+
+    private static boolean eligibleScorch(AgeInstabilityRuntime.Context context, LivingEntity entity) {
+        if (!entity.isAlive() || entity.isRemoved() || entity.level() != context.level()
+                || !context.level().canSeeSky(entity.blockPosition())
+                || AgeDecayProviders.isSpawnProtected(context.age(), entity.blockPosition())) return false;
+        if (entity instanceof Player player) return RivencraftConfig.scorchPlayers()
+                && !player.isCreative() && !player.isSpectator();
+        return true;
+    }
+
+    private static void erode(AgeInstabilityRuntime.Context context) {
+        if (!RivencraftConfig.erosionEnabled() || !AgeHazardProviders.canMutate(context.level())) return;
+        ServerLevel level = context.level();
+        Random random = new Random(context.age().seed() ^ AgeHazardSavedData.get(level).nextAttempt()
+                * 0xC2B2AE3D27D4EB4FL ^ EROSION.hashCode());
+        for (int attempt = 0; attempt < 8; attempt++) {
+            ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+            int x = chunk.getMinBlockX() + random.nextInt(16);
+            int z = chunk.getMinBlockZ() + random.nextInt(16);
+            int y = level.getMinBuildHeight() + 1 + random.nextInt(level.getHeight() - 2);
+            if (erodeAt(context, new BlockPos(x, y, z))) return;
+        }
+    }
+
+    private static boolean erodeAt(AgeInstabilityRuntime.Context context, BlockPos pos) {
+        ServerLevel level = context.level();
+        if (!AgeDecayProviders.isLoadedTarget(level, context.loadedChunks(), pos)
+                || AgeDecayProviders.isSpawnProtected(context.age(), pos)) return false;
+        BlockState prior = level.getBlockState(pos);
+        if (!AgeDecayProviders.canReplace(level, pos, prior, DecayBlock.Color.BLUE)) return false;
+        for (Direction direction : FLUID_SIDES) {
+            BlockPos neighbor = pos.relative(direction);
+            if (!AgeDecayProviders.isLoadedTarget(level, context.loadedChunks(), neighbor)) continue;
+            var fluid = level.getFluidState(neighbor);
+            if (fluid.isSource() && replaceFluid(context, pos, prior, fluid.createLegacyBlock())) return true;
+        }
+        return false;
+    }
+
+    private static boolean replaceFluid(AgeInstabilityRuntime.Context context, BlockPos pos,
+            BlockState prior, BlockState fluidBlock) {
+        ServerLevel level = context.level();
+        var actor = FakePlayerFactory.getMinecraft(level);
+        actor.setPos(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        if (!prior.isAir()) {
+            var breaking = new BlockEvent.BreakEvent(level, pos, prior, actor);
+            NeoForge.EVENT_BUS.post(breaking);
+            if (breaking.isCanceled()) return false;
+        }
+        if (level.getBlockState(pos) != prior || !context.budget().claim()) return false;
+        var snapshot = BlockSnapshot.create(level.dimension(), level, pos);
+        if (!level.setBlock(pos, fluidBlock, 3)) return false;
+        var placing = new BlockEvent.EntityPlaceEvent(snapshot, prior, actor);
+        NeoForge.EVENT_BUS.post(placing);
+        if (placing.isCanceled()) {
+            snapshot.restore();
+            return false;
+        }
+        return true;
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private record Meteor(ChunkPos chunk, BlockPos impact, int startY, int remaining) {}
+}

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

@@ -0,0 +1,399 @@
+package net.dnorberg.rivencraft.book;
+
+import com.mojang.serialization.Codec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Random;
+import net.dnorberg.rivencraft.writing.BlockSymbolPages;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.dnorberg.rivencraft.world.AgeDenseOres;
+import net.minecraft.core.Holder;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.BiomeTags;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.Blocks;
+
+/** Validates and freezes supported feature pages and their preceding material modifiers. */
+public final class AgeFeatureSelection {
+    private static final List<ResourceLocation> BLOCK_FEATURES = List.of(
+            id("rocks"), id("floating_islands"), id("tendrils"), id("spheres"), id("spikes"),
+            id("obelisks"));
+    private static final List<ResourceLocation> FLUID_FEATURES = List.of(
+            id("surface_lakes"), id("deep_lakes"), id("lava_lakes"));
+    private static final long RANDOM_SKYLANDS_SALT = 0x534B594C414E4453L;
+    private static final long RANDOM_STAR_FISSURES_SALT = 0x535441524752414DL;
+    public static final ResourceLocation CRYSTAL_FORMATIONS = id("crystal_formations");
+    public static final ResourceLocation STAR_FISSURES = id("star_fissures");
+
+    private AgeFeatureSelection() {}
+
+    public record Choice(ResourceLocation id, Optional<ResourceLocation> material) {
+        public static final Codec<Choice> CODEC = RecordCodecBuilder.create(instance -> instance.group(
+                ResourceLocation.CODEC.fieldOf("id").forGetter(Choice::id),
+                ResourceLocation.CODEC.optionalFieldOf("material").forGetter(Choice::material)
+        ).apply(instance, Choice::new));
+
+        public Choice {
+            if (id == null || material == null) throw new IllegalArgumentException("Missing feature choice");
+        }
+    }
+
+    public static List<Choice> compile(WritingGrammar.Result writing, AgeRuntimeProfile profile,
+                                       AgeBiomeSelection biomes, RegistryAccess registries, long ageSeed) {
+        List<Choice> choices = choices(writing.symbols().stream()
+                .map(symbol -> symbol.semantics()).toList(), profile, ageSeed);
+        for (Choice choice : choices) {
+            String error = error(choice.id(), profile, registries);
+            if (error == null && AgeStructureSelection.feature(choice.id()))
+                error = AgeStructureSelection.error(choice.id(), profile, biomes, registries);
+            if (error == null && choice.id().equals(AgeDenseOres.ID))
+                error = AgeDenseOres.error(profile, biomes, registries);
+            if (error == null) error = materialError(choice);
+            if (error != null) throw new IllegalArgumentException(error);
+            if (surfaceVegetation(choice.id()) && biomes.biomes().stream()
+                    .allMatch(id -> !supportsSurfaceVegetation(id, registries))) {
+                throw new IllegalArgumentException("Feature " + choice.id()
+                        + " needs at least one surface Overworld biome in the selected pool");
+            }
+        }
+        return choices;
+    }
+
+    private static List<Choice> choices(List<SymbolSemantics> symbols, AgeRuntimeProfile profile, long ageSeed) {
+        List<Choice> choices = new ArrayList<>();
+        ResourceLocation pendingMaterial = null;
+        for (int index = 0; index < symbols.size(); index++) {
+            SymbolSemantics semantics = symbols.get(index);
+            if (pendingMaterial != null && semantics.role() != SymbolSemantics.Role.FEATURE) {
+                choices.add(implied(pendingMaterial, profile, ageSeed, index - 1));
+                pendingMaterial = null;
+            }
+            if (semantics.role() == SymbolSemantics.Role.BLOCK) {
+                pendingMaterial = ((SymbolSemantics.ResourceValue) semantics.value()).id();
+            } else if (semantics.role() == SymbolSemantics.Role.FEATURE) {
+                choices.add(new Choice(((SymbolSemantics.ResourceValue) semantics.value()).id(),
+                        Optional.ofNullable(pendingMaterial)));
+                pendingMaterial = null;
+            }
+        }
+        if (pendingMaterial != null) choices.add(implied(pendingMaterial, profile, ageSeed, symbols.size() - 1));
+        return List.copyOf(choices);
+    }
+
+    private static Choice implied(ResourceLocation material, AgeRuntimeProfile profile, long ageSeed, int index) {
+        List<ResourceLocation> candidates = compatibleFeatures(material, profile);
+        if (candidates.isEmpty()) throw new IllegalArgumentException("No compatible feature for material "
+                + material + " on " + profile.terrain() + " terrain");
+        long mixed = mix(ageSeed ^ (long) material.hashCode() * 0x9E3779B97F4A7C15L ^ index);
+        return new Choice(candidates.get(Math.floorMod(mixed, candidates.size())), Optional.of(material));
+    }
+
+    public static boolean supportsUnpairedMaterials(WritingGrammar.Result writing, AgeRuntimeProfile profile) {
+        List<SymbolSemantics> symbols = writing.symbols().stream().map(symbol -> symbol.semantics()).toList();
+        ResourceLocation pending = null;
+        for (SymbolSemantics symbol : symbols) {
+            if (pending != null && symbol.role() != SymbolSemantics.Role.FEATURE) {
+                if (compatibleFeatures(pending, profile).isEmpty()) return false;
+                pending = null;
+            }
+            if (symbol.role() == SymbolSemantics.Role.BLOCK)
+                pending = ((SymbolSemantics.ResourceValue) symbol.value()).id();
+            else if (symbol.role() == SymbolSemantics.Role.FEATURE) pending = null;
+        }
+        return pending == null || !compatibleFeatures(pending, profile).isEmpty();
+    }
+
+    private static List<ResourceLocation> compatibleFeatures(ResourceLocation material, AgeRuntimeProfile profile) {
+        var block = BuiltInRegistries.BLOCK.getOptional(material);
+        if (block.isEmpty()) return List.of();
+        List<ResourceLocation> candidates = BlockSymbolPages.isFluidMaterial(block.orElseThrow())
+                ? FLUID_FEATURES : BlockSymbolPages.isRockMaterial(block.orElseThrow())
+                ? BLOCK_FEATURES : List.of();
+        return candidates.stream().filter(id -> compatible(id, profile)).toList();
+    }
+
+    private static boolean compatible(ResourceLocation feature, AgeRuntimeProfile profile) {
+        if (tendrils(feature) || spheres(feature)) return true;
+        if (obelisks(feature)) return !AgeBiomeSelection.isCave(profile)
+                && profile.terrain() != AgeRuntimeProfile.Terrain.VOID;
+        if (AgeBiomeSelection.isCave(profile)) return false;
+        if (spikes(feature)) return profile.terrain() != AgeRuntimeProfile.Terrain.VOID;
+        return floatingIslands(feature) || profile.terrain() == AgeRuntimeProfile.Terrain.NOISE;
+    }
+
+    public static List<Choice> resolved(AgeGenerationPlan plan) {
+        if (plan == null) return List.of();
+        Map<ResourceLocation, List<ResourceLocation>> materialOrders = new HashMap<>();
+        Map<ResourceLocation, Integer> occurrences = new HashMap<>();
+        List<Choice> resolved = new ArrayList<>();
+        for (Choice choice : choices(plan.activeSymbols().stream().map(symbol -> symbol.semantics()).toList(),
+                plan.runtimeProfile(), plan.ageSeed())) {
+            if (choice.material().isPresent()
+                    || !isRock(choice.id()) && !isLake(choice.id())
+                    && !floatingIslands(choice.id()) && !tendrils(choice.id())
+                    && !spheres(choice.id()) && !spikes(choice.id())
+                    && !obelisks(choice.id())) {
+                resolved.add(choice);
+                continue;
+            }
+            List<ResourceLocation> materials = materialOrders.computeIfAbsent(choice.id(),
+                    id -> shuffledMaterials(plan.ageSeed(), id));
+            int occurrence = occurrences.merge(choice.id(), 1, Integer::sum) - 1;
+            resolved.add(new Choice(choice.id(), Optional.of(materials.get(occurrence % materials.size()))));
+        }
+        return List.copyOf(resolved);
+    }
+
+    /** Page-free Ages roll up to two material features, plus rare Skylands, once at creation. */
+    public static List<Choice> randomChoices(long ageSeed, AgeRuntimeProfile profile, RegistryAccess registries) {
+        Random random = new Random(ageSeed ^ 0x4D4154455249414CL);
+        int count = random.nextInt(3);
+        List<LegacyRankChoice.Option<ResourceLocation>> features = new ArrayList<>();
+        for (ResourceLocation id : BLOCK_FEATURES) if (error(id, profile, registries) == null)
+            features.add(new LegacyRankChoice.Option<>(id, randomMaterialRank(id)));
+        for (ResourceLocation id : FLUID_FEATURES) if (error(id, profile, registries) == null)
+            features.add(new LegacyRankChoice.Option<>(id, randomMaterialRank(id)));
+        List<Choice> choices = new ArrayList<>();
+        while (choices.size() < count && !features.isEmpty()) {
+            ResourceLocation feature = LegacyRankChoice.choose(random, features);
+            features.removeIf(option -> option.value().equals(feature));
+            var category = solidFeature(feature)
+                    ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
+            List<ResourceLocation> materials = BlockSymbolPages.availableBlocks(category).stream()
+                    .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList();
+            if (!materials.isEmpty()) choices.add(new Choice(feature,
+                    Optional.of(materials.get(random.nextInt(materials.size())))));
+        }
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.NOISE
+                && Math.floorMod(mix(ageSeed ^ RANDOM_SKYLANDS_SALT), 8) == 0)
+            choices.add(new Choice(id("skylands"), Optional.empty()));
+        if (error(CRYSTAL_FORMATIONS, profile, registries) == null && random.nextInt(10) == 0)
+            choices.add(new Choice(CRYSTAL_FORMATIONS, Optional.empty()));
+        if (randomStarFissure(ageSeed))
+            choices.add(new Choice(STAR_FISSURES, Optional.empty()));
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(WritingGrammar.parse(OrderedWriting.EMPTY),
+                AgeTraits.select(ageSeed), profile, ageSeed, registries);
+        choices.addAll(AgeStructureSelection.randomChoices(ageSeed, profile, biomes, registries));
+        return List.copyOf(choices);
+    }
+
+    static int randomMaterialRank(ResourceLocation feature) {
+        if (feature.equals(id("surface_lakes")) || feature.equals(id("deep_lakes"))) return 1;
+        if (feature.equals(id("lava_lakes"))) return 2; // New separate fluid choice.
+        if (spheres(feature) || spikes(feature) || obelisks(feature)) return 3;
+        return 4; // Legacy Floating Islands/Tendrils and the new Rocks choice.
+    }
+
+    /**
+     * Legacy's default FeatureSmalls0 grammar: stop without a feature (rank 4),
+     * emit one (rank 4), or emit one and repeat (rank 2). Its rank-derived
+     * weights are 1:1:3. Within FEATURE_SMALL, the Star Fissure rule has weight
+     * 1 of 9: three rank-3 choices have weight 1 each and two rank-1 lake
+     * choices have weight 3 each. Other small features remain selected by this
+     * port's existing random feature pipeline; only the fissure result is used.
+     */
+    private static boolean randomStarFissure(long ageSeed) {
+        Random random = new Random(mix(ageSeed ^ RANDOM_STAR_FISSURES_SALT));
+        for (int step = 0; step < 27; step++) {
+            int branch = random.nextInt(5);
+            if (branch == 0) return false;
+            if (random.nextInt(9) == 0) return true;
+            if (branch == 1) return false;
+        }
+        return false;
+    }
+
+    private static List<ResourceLocation> shuffledMaterials(long ageSeed, ResourceLocation feature) {
+        var category = solidFeature(feature)
+                ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
+        List<ResourceLocation> pool = new ArrayList<>(BlockSymbolPages.availableBlocks(category).stream()
+                .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList());
+        if (pool.isEmpty()) throw new IllegalStateException("No valid material blocks for " + feature);
+        Collections.shuffle(pool, new Random(mix(ageSeed ^ (long) feature.hashCode() * 0x9E3779B97F4A7C15L)));
+        return pool;
+    }
+
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath("rivencraft", path);
+    }
+
+    public static String error(ResourceLocation choice, AgeRuntimeProfile profile, RegistryAccess registries) {
+        if (AgeStructureSelection.feature(choice))
+            return AgeStructureSelection.error(choice, profile, null, registries);
+        if (choice.equals(AgeDenseOres.ID))
+            return AgeDenseOres.error(profile, null, registries);
+        if (choice.equals(CRYSTAL_FORMATIONS)) {
+            if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+                return "Feature " + choice + " needs exposed solid ground, not Cave or Void terrain";
+            return null;
+        }
+        if (choice.equals(STAR_FISSURES)) return null;
+        if (skylands(choice)) return null;
+        if (tendrils(choice)) return null;
+        if (spheres(choice)) return null;
+        if (spikes(choice)) {
+            if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+                return "Feature " + choice + " needs an exposed solid surface, not Cave or Void terrain";
+            return null;
+        }
+        if (obelisks(choice)) {
+            if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+                return "Feature " + choice + " needs exposed solid surface terrain, not Cave or Void";
+            return null;
+        }
+        if (floatingIslands(choice)) {
+            if (AgeBiomeSelection.isCave(profile))
+                return "Feature " + choice + " cannot form above Cave terrain";
+            return null;
+        }
+        if (caves(choice) || ravines(choice)) {
+            if (profile.terrain() != AgeRuntimeProfile.Terrain.NOISE) {
+                return "Feature " + choice + " requires noise terrain with stone to carve; not Flat or Void";
+            }
+            var carvers = registries.lookupOrThrow(Registries.CONFIGURED_CARVER);
+            List<String> ids = caves(choice) ? List.of("cave", "nether_cave") : List.of("canyon");
+            for (String path : ids) {
+                var key = ResourceKey.create(Registries.CONFIGURED_CARVER, ResourceLocation.withDefaultNamespace(path));
+                if (carvers.get(key).isEmpty()) return "Feature " + choice
+                        + " requires missing configured carver " + key.location();
+            }
+            return null;
+        }
+        ResourceLocation placed = placedFeature(choice);
+        if (placed == null) return "Unsupported feature " + choice
+                + "; remove its page (custom structures remain future work)";
+        if (profile.terrain() != AgeRuntimeProfile.Terrain.NOISE || AgeBiomeSelection.isCave(profile)) {
+            return "Feature " + choice + " requires surface noise terrain; not Flat, Void, or Cave";
+        }
+        if (registries.lookupOrThrow(Registries.PLACED_FEATURE)
+                .get(ResourceKey.create(Registries.PLACED_FEATURE, placed)).isEmpty()) {
+            return "Feature " + choice + " requires missing placed feature " + placed;
+        }
+        return null;
+    }
+
+    public static String materialError(Choice choice) {
+        if (choice.material().isEmpty()) return null;
+        ResourceLocation material = choice.material().orElseThrow();
+        var block = BuiltInRegistries.BLOCK.getOptional(material);
+        if (block.isEmpty() || block.orElseThrow() == Blocks.AIR) {
+            return "Feature " + choice.id() + " references missing block material " + material;
+        }
+        if (solidFeature(choice.id())) {
+            if (!BlockSymbolPages.isRockMaterial(block.orElseThrow())) {
+                return "Feature " + choice.id() + " needs a full solid block without a block entity: " + material;
+            }
+        } else if (isLake(choice.id())) {
+            if (!BlockSymbolPages.isFluidMaterial(block.orElseThrow())) {
+                return "Feature " + choice.id() + " needs a source-fluid block: " + material;
+            }
+        } else {
+            return "Feature " + choice.id() + " cannot consume a block material page";
+        }
+        return null;
+    }
+
+    public static boolean isRock(ResourceLocation choice) {
+        return is(choice, "rocks");
+    }
+
+    public static boolean isLake(ResourceLocation choice) {
+        if (!choice.getNamespace().equals("rivencraft")) return false;
+        return switch (choice.getPath()) {
+            case "surface_lakes", "deep_lakes", "lava_lakes" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean surfaceVegetation(ResourceLocation choice) {
+        if (!choice.getNamespace().equals("rivencraft")) return false;
+        return switch (choice.getPath()) {
+            case "flowers", "trees", "huge_trees" -> true;
+            default -> false;
+        };
+    }
+
+    public static boolean caves(ResourceLocation choice) {
+        return is(choice, "caves");
+    }
+
+    public static boolean ravines(ResourceLocation choice) {
+        return is(choice, "ravines");
+    }
+
+    public static boolean floatingIslands(ResourceLocation choice) {
+        return is(choice, "floating_islands");
+    }
+
+    public static boolean tendrils(ResourceLocation choice) {
+        return is(choice, "tendrils");
+    }
+
+    public static boolean spheres(ResourceLocation choice) {
+        return is(choice, "spheres");
+    }
+
+    public static boolean spikes(ResourceLocation choice) {
+        return is(choice, "spikes");
+    }
+
+    public static boolean obelisks(ResourceLocation choice) {
+        return is(choice, "obelisks");
+    }
+
+    private static boolean solidFeature(ResourceLocation choice) {
+        return isRock(choice) || floatingIslands(choice) || tendrils(choice)
+                || spheres(choice) || spikes(choice) || obelisks(choice);
+    }
+
+    public static boolean skylands(ResourceLocation choice) {
+        return is(choice, "skylands");
+    }
+
+    private static boolean is(ResourceLocation choice, String path) {
+        return choice.getNamespace().equals("rivencraft") && choice.getPath().equals(path);
+    }
+
+    public static boolean supportsSurfaceVegetation(ResourceLocation id, RegistryAccess registries) {
+        var biome = registries.lookupOrThrow(Registries.BIOME)
+                .get(ResourceKey.create(Registries.BIOME, id));
+        return biome.isPresent() && supportsSurfaceVegetation(biome.orElseThrow());
+    }
+
+    public static boolean supportsSurfaceVegetation(Holder<Biome> biome) {
+        return !biome.is(BiomeTags.IS_NETHER) && !biome.is(BiomeTags.IS_END)
+                && !biome.is(AgeBiomeSelection.CAVE_BIOMES);
+    }
+
+    /** Fixed 1.21.1 mappings; data-pack symbols must opt in through a future extension. */
+    public static ResourceLocation placedFeature(ResourceLocation choice) {
+        if (!choice.getNamespace().equals("rivencraft")) return null;
+        return switch (choice.getPath()) {
+            case "flowers" -> ResourceLocation.withDefaultNamespace("flower_default");
+            case "trees" -> ResourceLocation.withDefaultNamespace("trees_plains");
+            case "huge_trees" -> ResourceLocation.withDefaultNamespace("trees_old_growth_spruce_taiga");
+            case "rocks" -> ResourceLocation.withDefaultNamespace("forest_rock");
+            case "dungeons" -> ResourceLocation.fromNamespaceAndPath("rivencraft", "dungeons");
+            case "surface_lakes", "lava_lakes" -> ResourceLocation.withDefaultNamespace("lake_lava_surface");
+            case "deep_lakes" -> ResourceLocation.withDefaultNamespace("lake_lava_underground");
+            default -> null;
+        };
+    }
+}

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

@@ -16,8 +16,9 @@ import net.minecraft.resources.ResourceLocation;
 
 /** A frozen interpretation of authored pages. Later slices consume its resolved branches. */
 public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
-                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
+                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection,
-    public static final int CURRENT_VERSION = 2;
+                                List<Integer> activeSymbolIndices, int writingInstability) {
+    public static final int CURRENT_VERSION = 3;
 
     public AgeGenerationPlan {
         if (version < 1 || version > CURRENT_VERSION) {
@@ -25,12 +26,14 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         }
         Objects.requireNonNull(writing, "writing");
         symbols = List.copyOf(symbols);
+        activeSymbolIndices = List.copyOf(activeSymbolIndices);
+        if (writingInstability < 0) throw new IllegalArgumentException("Negative writing instability");
         Objects.requireNonNull(runtimeProfile, "runtimeProfile");
         if (runtimeProfile.schemaVersion() != AgeRuntimeProfile.CURRENT_SCHEMA_VERSION) {
             throw new IllegalArgumentException("Unsupported runtime profile snapshot version");
         }
-        if (version == CURRENT_VERSION && biomeSelection == null) {
+        if (version >= 2 && biomeSelection == null) {
-            throw new IllegalArgumentException("Version 2 Age plan requires a biome selection snapshot");
+            throw new IllegalArgumentException("Version 2+ Age plan requires a biome selection snapshot");
         }
         for (ResolvedSymbol symbol : symbols) {
             if (symbol.index() < 0 || symbol.index() >= writing.entries().size()
@@ -38,12 +41,31 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
                 throw new IllegalArgumentException("Resolved symbol does not match original page order");
             }
         }
+        if (version >= 3 && !symbols.isEmpty() && activeSymbolIndices.isEmpty()) {
+            throw new IllegalArgumentException("Version 3 Age plan has no active symbols");
+        }
+        if (activeSymbolIndices.stream().distinct().count() != activeSymbolIndices.size()) {
+            throw new IllegalArgumentException("Age plan repeats an active symbol index");
+        }
+        for (int index : activeSymbolIndices) {
+            if (symbols.stream().noneMatch(symbol -> symbol.index() == index)) {
+                throw new IllegalArgumentException("Active symbol is not in the saved writing: " + index);
+            }
+        }
     }
 
     /** Existing version 1 plans retain their original biome behavior on reload. */
     public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
                              AgeRuntimeProfile runtimeProfile) {
-        this(version, ageSeed, writing, symbols, runtimeProfile, null);
+        this(version, ageSeed, writing, symbols, runtimeProfile, null,
+                symbols.stream().map(ResolvedSymbol::index).toList(), 0);
+    }
+
+    /** Existing call sites and version-2 plans retain every resolved symbol. */
+    public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
+                             AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
+        this(version, ageSeed, writing, symbols, runtimeProfile, biomeSelection,
+                symbols.stream().map(ResolvedSymbol::index).toList(), 0);
     }
 
     /** No plan is made for old page-free books or Link-Panel-only random Ages. */
@@ -52,7 +74,9 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         WritingGrammar.Result parsed = WritingGrammar.parse(writing);
         if (!parsed.canCreate()) throw new IllegalArgumentException(parsed.firstError().orElseThrow().message());
         if (parsed.randomFallback()) return null;
-        ResourceLocation terrain = parsed.symbols().stream()
+        List<WritingGrammar.ParsedSymbol> active = parsed.activeSymbols();
+        WritingGrammar.Result effective = new WritingGrammar.Result(active, parsed.diagnostics());
+        ResourceLocation terrain = active.stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
                 .findFirst().orElse(null);
@@ -64,21 +88,29 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         ResourceLocation selected = terrain == null ? seedProfile : terrain;
         AgeRuntimeProfile profile = AgeRuntimeProfiles.profiles().get(selected);
         if (profile == null) throw new IllegalArgumentException("Unsupported Age terrain profile " + selected);
-        AgeBiomeSelection biomes = AgeBiomeSelection.compile(parsed, traits, profile, ageSeed, registries);
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(effective, traits, profile, ageSeed, registries);
+        AgeFeatureSelection.compile(effective, profile, biomes, registries, ageSeed);
         AgeGenerationPlan plan = new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
                 parsed.symbols().stream().map(symbol -> new ResolvedSymbol(
                         symbol.index(), symbol.reference(), symbol.semantics())).toList(),
-                profile, biomes);
+                profile, biomes, active.stream().map(WritingGrammar.ParsedSymbol::index).toList(),
+                parsed.writingInstability());
         AgeEnvironmentCompiler.apply(plan, traits);
+        AgeSeasonMode.validate(plan);
         return plan;
     }
 
     public ResourceLocation authoredTerrain() {
-        return symbols.stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
+        return activeSymbols().stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
                 .findFirst().orElse(null);
     }
 
+    public List<ResolvedSymbol> activeSymbols() {
+        return activeSymbolIndices.stream().map(index -> symbols.stream()
+                .filter(symbol -> symbol.index() == index).findFirst().orElseThrow()).toList();
+    }
+
     public CompoundTag save() {
         CompoundTag tag = new CompoundTag();
         tag.putInt("Version", version);
@@ -104,6 +136,10 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
             resolved.add(item);
         }
         tag.put("Resolved", resolved);
+        if (version >= 3) {
+            tag.putIntArray("ActiveSymbolIndices", activeSymbolIndices);
+            tag.putInt("WritingInstability", writingInstability);
+        }
         CompoundTag profile = new CompoundTag();
         profile.putInt("Version", runtimeProfile.schemaVersion());
         profile.putString("Terrain", runtimeProfile.terrain().name());
@@ -139,7 +175,7 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
             SymbolSemantics.Role role = SymbolSemantics.Role.valueOf(item.getString("Role"));
             String raw = item.getString("Value");
             SymbolSemantics.Value value = switch (role) {
-                case TERRAIN, BIOME, FEATURE -> new SymbolSemantics.ResourceValue(ResourceLocation.parse(raw));
+                case TERRAIN, BIOME, BLOCK, FEATURE -> new SymbolSemantics.ResourceValue(ResourceLocation.parse(raw));
                 case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER ->
                         new SymbolSemantics.NumberValue(Double.parseDouble(raw));
                 default -> new SymbolSemantics.ChoiceValue(raw);
@@ -160,12 +196,16 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
             selection = new AgeBiomeSelection(AgeTraits.BiomeDistribution.valueOf(
                     biomeTag.getString("Distribution")), ids);
         }
+        List<Integer> activeIndices = version >= 3
+                ? java.util.Arrays.stream(tag.getIntArray("ActiveSymbolIndices")).boxed().toList()
+                : resolved.stream().map(ResolvedSymbol::index).toList();
         return new AgeGenerationPlan(version, tag.getLong("AgeSeed"), new OrderedWriting(pages), resolved,
                 new AgeRuntimeProfile(profile.getInt("Version"),
                         AgeRuntimeProfile.Terrain.valueOf(profile.getString("Terrain")),
                         ResourceLocation.parse(profile.getString("Noise")),
                         ResourceLocation.parse(profile.getString("Biomes")),
-                        ResourceLocation.parse(profile.getString("Dimension"))), selection);
+                        ResourceLocation.parse(profile.getString("Dimension"))), selection,
+                activeIndices, version >= 3 ? tag.getInt("WritingInstability") : 0);
     }
 
     public record ResolvedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {

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

@@ -1,6 +1,8 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.List;
+import java.util.Random;
+import java.util.Comparator;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.resources.ResourceLocation;
 
@@ -13,24 +15,37 @@ public final class AgeGenerationProfiles {
     public static final ResourceLocation FLAT = id("flat");
     public static final ResourceLocation VOID = id("void");
 
-    private static final List<ResourceLocation> RANDOM_PROFILES = List.of(
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> RANDOM_PROFILES = List.of(
-            STANDARD, AMPLIFIED, ISLAND, CAVE, FLAT, VOID
+            new LegacyRankChoice.Option<>(STANDARD, 1),
+            new LegacyRankChoice.Option<>(FLAT, 2),
+            new LegacyRankChoice.Option<>(AMPLIFIED, 3),
+            new LegacyRankChoice.Option<>(ISLAND, 3),
+            new LegacyRankChoice.Option<>(CAVE, 3),
+            new LegacyRankChoice.Option<>(VOID, 3)
     );
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> SORTED_RANDOM_PROFILES =
+            RANDOM_PROFILES.stream().sorted(Comparator.comparing(LegacyRankChoice.Option::value)).toList();
 
     private AgeGenerationProfiles() {
     }
 
     /** Selects one stable base terrain from the Age's already-persisted seed. */
     public static ResourceLocation select(long seed) {
-        return RANDOM_PROFILES.get(Math.floorMod(Long.hashCode(seed), RANDOM_PROFILES.size()));
+        return LegacyRankChoice.choose(new Random(seed ^ 0x5445525241494E4CL), SORTED_RANDOM_PROFILES);
     }
 
     public static boolean isSupported(ResourceLocation profile) {
-        return RANDOM_PROFILES.contains(profile);
+        return RANDOM_PROFILES.stream().anyMatch(option -> option.value().equals(profile));
     }
 
     public static List<ResourceLocation> all() {
-        return RANDOM_PROFILES;
+        return RANDOM_PROFILES.stream().map(LegacyRankChoice.Option::value).toList();
+    }
+
+    static int randomRank(ResourceLocation profile) {
+        if (profile.equals(STANDARD)) return 1;
+        if (profile.equals(FLAT)) return 2;
+        return 3;
     }
 
     /** Maps removed legacy aliases to a stable built-in profile. */

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

@@ -0,0 +1,329 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Random;
+import java.util.Set;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.LightningBolt;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.Explosion;
+import net.minecraft.world.level.ExplosionDamageCalculator;
+import net.minecraft.world.level.GameRules;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.material.FluidState;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.util.FakePlayerFactory;
+import net.neoforged.neoforge.event.level.BlockEvent;
+
+/** Legacy hazard cards, with one loaded-chunk event and explicit damage budgets. */
+public final class AgeHazardProviders {
+    private static final ResourceLocation LIGHTNING = id("lightning");
+    private static final ResourceLocation EXPLOSIONS = id("explosions");
+
+    private AgeHazardProviders() {}
+
+    public static void register() {
+        // Visuals and entity damage remain available when block mutation is disabled.
+        AgeInstabilityRuntime.register(LIGHTNING, false, AgeHazardProviders::apply);
+        AgeInstabilityRuntime.register(EXPLOSIONS, false, AgeHazardProviders::apply);
+    }
+
+    static boolean isHazard(ResourceLocation id) {
+        return LIGHTNING.equals(id) || EXPLOSIONS.equals(id);
+    }
+
+    /** Roll every selected hazard card each scheduler pass, independently of other providers. */
+    static void tickPlanned(ServerLevel level, AgeDefinition age, long tick) {
+        if (!RivencraftConfig.hazardsEnabled()) return;
+        List<AgeInstabilityPlan.ProviderLevel> hazards = age.instabilityPlan().providers().stream()
+                .filter(provider -> isHazard(provider.id())).toList();
+        if (hazards.isEmpty()) return;
+        List<ChunkPos> chunks = loadedChunksNearPlayers(level, RivencraftConfig.hazardsMaxChunks());
+        if (chunks.isEmpty()) return;
+        for (AgeInstabilityPlan.ProviderLevel hazard : hazards) {
+            var context = new AgeInstabilityRuntime.Context(level, age, chunks, tick,
+                    new AgeInstabilityRuntime.Budget(1));
+            AgeInstabilityRuntime.invoke(context, hazard.id(), hazard.level());
+        }
+    }
+
+    static List<ChunkPos> loadedChunksNearPlayers(ServerLevel level, int maximum) {
+        Set<ChunkPos> chunks = new LinkedHashSet<>();
+        List<ServerPlayer> players = level.players().stream()
+                .sorted(Comparator.comparing(Entity::getUUID)).toList();
+        for (int radius = 0; radius <= 4; radius++) {
+            for (int dx = -radius; dx <= radius; dx++) {
+                for (int dz = -radius; dz <= radius; dz++) {
+                    if (Math.max(Math.abs(dx), Math.abs(dz)) != radius) continue;
+                    for (ServerPlayer player : players) {
+                        ChunkPos center = player.chunkPosition();
+                        int x = center.x + dx;
+                        int z = center.z + dz;
+                        if (level.getChunkSource().hasChunk(x, z)) chunks.add(new ChunkPos(x, z));
+                        if (chunks.size() >= maximum) return List.copyOf(chunks);
+                    }
+                }
+            }
+        }
+        return List.copyOf(chunks);
+    }
+
+    /** Operator-only test pulse; skips the random roll, not Age, cooldown, or safety checks. */
+    public static int pulseForTesting(ServerPlayer player, boolean lightning) {
+        ServerLevel level = player.serverLevel();
+        if (!RivencraftConfig.hazardsEnabled()
+                || !AgeInstabilityRuntime.isAgeDimension(level.dimension().location())) return -1;
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null) return -1;
+        AgeHazardSavedData data = AgeHazardSavedData.get(level);
+        if (!data.ready(lightning, level.getGameTime(), RivencraftConfig.hazardsMinInterval())) return 0;
+        ChunkPos center = player.chunkPosition();
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                ChunkPos chunk = new ChunkPos(center.x + dx, center.z + dz);
+                if (!level.getChunkSource().hasChunk(chunk.x, chunk.z)) continue;
+                int x = chunk.getMinBlockX() + 8;
+                int z = chunk.getMinBlockZ() + 8;
+                int y = lightning ? level.getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)
+                        : player.getBlockY();
+                BlockPos pos = new BlockPos(x, y, z);
+                var context = new AgeInstabilityRuntime.Context(level, age, List.of(chunk),
+                        level.getServer().getTickCount(), new AgeInstabilityRuntime.Budget(1));
+                if (!safeTarget(context, pos, 8)) continue;
+                data.nextAttempt();
+                data.record(lightning, level.getGameTime());
+                if (lightning) strike(level, age, chunk, pos);
+                else explode(level, age, chunk, pos);
+                return 1;
+            }
+        }
+        return 0;
+    }
+
+    static void apply(AgeInstabilityRuntime.Context context, ResourceLocation id, int effectiveLevel) {
+        ServerLevel level = context.level();
+        if (!RivencraftConfig.hazardsEnabled() || context.loadedChunks().isEmpty()
+                || !AgeInstabilityRuntime.isAgeDimension(level.dimension().location())
+                || !context.age().dimensionId().equals(level.dimension().location())) return;
+        boolean lightning = id.equals(LIGHTNING);
+        if (!lightning && !id.equals(EXPLOSIONS)) return;
+        AgeHazardSavedData data = AgeHazardSavedData.get(level);
+        long gameTime = level.getGameTime();
+        if (!data.ready(lightning, gameTime, RivencraftConfig.hazardsMinInterval())) return;
+        Random random = new Random(context.age().seed() ^ data.nextAttempt() * 0x9E3779B97F4A7C15L
+                ^ id.hashCode());
+        int legacyDenominator = lightning ? level.isRaining() && level.isThundering() ? 5000 : 100000 : 1000;
+        // Legacy rolled once per chunk per tick; the shared scheduler visits this Age every >=20 ticks.
+        double chance = legacyChance(context.loadedChunks().size(), RivencraftConfig.instabilityCooldown(),
+                effectiveLevel, legacyDenominator);
+        if (random.nextDouble() >= chance) return;
+        ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+        int margin = lightning ? 2 : 6;
+        int x = chunk.getMinBlockX() + margin + random.nextInt(16 - margin * 2);
+        int z = chunk.getMinBlockZ() + margin + random.nextInt(16 - margin * 2);
+        int y = lightning ? level.getHeight(Heightmap.Types.MOTION_BLOCKING, x, z)
+                : level.getMinBuildHeight() + 1 + random.nextInt(level.getHeight() - 2);
+        BlockPos pos = new BlockPos(x, y, z);
+        if (!safeTarget(context, pos, 8) || !context.budget().claim()) return;
+        data.record(lightning, gameTime); // persist before dispatch so a restart cannot replay the event
+        if (lightning) strike(level, context.age(), chunk, pos);
+        else explode(level, context.age(), chunk, pos);
+    }
+
+    static double legacyChance(int loadedChunks, int intervalTicks, int copies, int denominator) {
+        if (loadedChunks <= 0 || intervalTicks <= 0 || copies <= 0 || denominator <= 0) return 0;
+        return 1.0 - Math.pow(1.0 - 1.0 / denominator, (double) loadedChunks * intervalTicks * copies);
+    }
+
+    static boolean safeTarget(AgeInstabilityRuntime.Context context, BlockPos pos, int spawnMargin) {
+        if (!AgeDecayProviders.isLoadedTarget(context.level(), context.loadedChunks(), pos)) return false;
+        BlockPos spawn = context.age().spawn();
+        return spawn == null || Math.abs(pos.getX() - spawn.getX()) > spawnMargin
+                || Math.abs(pos.getZ() - spawn.getZ()) > spawnMargin;
+    }
+
+    private static void strike(ServerLevel level, AgeDefinition age, ChunkPos chunk, BlockPos pos) {
+        AABB bounds = new AABB(pos).inflate(2);
+        if (!level.getEntitiesOfClass(LightningBolt.class, bounds).isEmpty()) return;
+        LightningBolt bolt = EntityType.LIGHTNING_BOLT.create(level);
+        if (bolt == null) return;
+        bolt.setPos(pos.getX() + 0.5, pos.getY(), pos.getZ() + 0.5);
+        bolt.setVisualOnly(true); // vanilla bolt damage/fire bypasses our explicit budgets
+        if (!level.addFreshEntity(bolt)) return;
+        List<LivingEntity> targets = level.getEntitiesOfClass(LivingEntity.class, bounds,
+                entity -> entity.isAlive() && entity.level() == level && eligibleEntity(entity));
+        targets.sort(Comparator.comparing(Entity::getUUID));
+        int count = 0;
+        for (LivingEntity target : targets) {
+            if (count++ >= RivencraftConfig.hazardsMaxEntities()) break;
+            if (RivencraftConfig.hazardsMaxDamage() > 0)
+                target.hurt(level.damageSources().lightningBolt(), Math.min(5, RivencraftConfig.hazardsMaxDamage()));
+        }
+        // Legacy lightning started fires. Keep it separately gated by block policy and game rule.
+        if (canMutate(level) && RivencraftConfig.hazardsFire()
+                && level.getGameRules().getBoolean(GameRules.RULE_DOFIRETICK)
+                && !AgeDecayProviders.isSpawnProtected(age, pos)
+                && AgeDecayProviders.isLoadedTarget(level, List.of(chunk), pos)) ignite(level, pos);
+    }
+
+    private static void explode(ServerLevel level, AgeDefinition age, ChunkPos chunk, BlockPos pos) {
+        explodeBounded(level, age, chunk, pos, RivencraftConfig.hazardsBlockDamage(),
+                RivencraftConfig.hazardsPlayerDamage(), RivencraftConfig.hazardsFire(),
+                RivencraftConfig.hazardsMaxBlocks(), RivencraftConfig.hazardsMaxEntities(),
+                RivencraftConfig.hazardsMaxDamage(), RivencraftConfig.hazardsExplosionRadius());
+    }
+
+    /** Shared blast guard for meteor impacts; each effect supplies its own damage policy. */
+    static void explodeBounded(ServerLevel level, AgeDefinition age, ChunkPos chunk, BlockPos pos,
+            boolean blockDamage, boolean playerDamage, boolean ignite, int maxBlocks, int maxEntities,
+            int maxDamage, int radius) {
+        boolean grief = canMutate(level) && blockDamage && maxBlocks > 0;
+        boolean fire = grief && ignite
+                && level.getGameRules().getBoolean(GameRules.RULE_DOFIRETICK);
+        Explosion explosion = level.explode(null, null, new BoundedExplosion(level, age, chunk, grief,
+                        playerDamage, maxBlocks, maxEntities, maxDamage),
+                pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5,
+                radius, false,
+                grief ? Level.ExplosionInteraction.BLOCK : Level.ExplosionInteraction.NONE);
+        if (fire) {
+            int ignited = 0;
+            for (BlockPos affected : explosion.getToBlow()) {
+                if (ignited >= 4) break;
+                if (!AgeDecayProviders.isSpawnProtected(age, affected) && ignite(level, affected)) ignited++;
+            }
+        }
+    }
+
+    private static boolean ignite(ServerLevel level, BlockPos pos) {
+        if (!level.getBlockState(pos).isAir() || !Blocks.FIRE.defaultBlockState().canSurvive(level, pos))
+            return false;
+        var actor = FakePlayerFactory.getMinecraft(level);
+        actor.setPos(pos.getX() + 0.5, pos.getY(), pos.getZ() + 0.5);
+        var snapshot = net.neoforged.neoforge.common.util.BlockSnapshot.create(level.dimension(), level, pos);
+        BlockState prior = level.getBlockState(pos);
+        if (!level.setBlock(pos, Blocks.FIRE.defaultBlockState(), 3)) return false;
+        var place = new BlockEvent.EntityPlaceEvent(snapshot, prior, actor);
+        NeoForge.EVENT_BUS.post(place);
+        if (place.isCanceled()) {
+            snapshot.restore();
+            return false;
+        }
+        return true;
+    }
+
+    static boolean canMutate(ServerLevel level) {
+        return RivencraftConfig.instabilityWorldMutation()
+                && level.getGameRules().getBoolean(GameRules.RULE_MOBGRIEFING);
+    }
+
+    private static boolean eligibleEntity(Entity entity) {
+        return eligibleEntity(entity, RivencraftConfig.hazardsPlayerDamage());
+    }
+
+    private static boolean eligibleEntity(Entity entity, boolean playerDamage) {
+        return !(entity instanceof Player player) || playerDamage
+                && !player.isCreative() && !player.isSpectator();
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private static final class BoundedExplosion extends ExplosionDamageCalculator {
+        private final ServerLevel level;
+        private final AgeDefinition age;
+        private final ChunkPos chunk;
+        private final boolean grief;
+        private final boolean playerDamage;
+        private final int maxBlocks;
+        private final int maxEntities;
+        private final int maxDamage;
+        private final Set<BlockPos> approved = new HashSet<>();
+        private final Set<UUID> damagedEntities = new HashSet<>();
+        private int damaged;
+
+        private BoundedExplosion(ServerLevel level, AgeDefinition age, ChunkPos chunk, boolean grief,
+                boolean playerDamage, int maxBlocks, int maxEntities, int maxDamage) {
+            this.level = level;
+            this.age = age;
+            this.chunk = chunk;
+            this.grief = grief;
+            this.playerDamage = playerDamage;
+            this.maxBlocks = maxBlocks;
+            this.maxEntities = maxEntities;
+            this.maxDamage = maxDamage;
+        }
+
+        @Override
+        public Optional<Float> getBlockExplosionResistance(Explosion explosion, BlockGetter reader,
+                BlockPos pos, BlockState state, FluidState fluid) {
+            if (!inLoadedChunk(pos)) return Optional.of(Float.MAX_VALUE);
+            return super.getBlockExplosionResistance(explosion, reader, pos, state, fluid);
+        }
+
+        @Override
+        public boolean shouldBlockExplode(Explosion explosion, BlockGetter reader, BlockPos pos,
+                BlockState state, float power) {
+            if (!grief || !inLoadedChunk(pos) || state.isAir() || state.hasBlockEntity()
+                    || state.is(Blocks.TNT)
+                    || state.is(AgeDecayProviders.PROTECTED) || state.is(BlockTags.PORTALS)
+                    || AgeDecayProviders.isSpawnProtected(age, pos)
+                    || state.getDestroySpeed(level, pos) < 0
+                    || BuiltInRegistries.BLOCK.getKey(state.getBlock()).getNamespace().equals(Rivencraft.MOD_ID)) return false;
+            if (approved.contains(pos)) return true;
+            if (approved.size() >= maxBlocks) return false;
+            var actor = FakePlayerFactory.getMinecraft(level);
+            actor.setPos(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+            var event = new BlockEvent.BreakEvent(level, pos, state, actor);
+            NeoForge.EVENT_BUS.post(event);
+            if (event.isCanceled()) return false;
+            approved.add(pos.immutable());
+            return true;
+        }
+
+        @Override
+        public boolean shouldDamageEntity(Explosion explosion, Entity entity) {
+            if (damaged >= maxEntities || !eligibleEntity(entity, playerDamage)
+                    || maxDamage == 0) return false;
+            damaged++;
+            damagedEntities.add(entity.getUUID());
+            return true;
+        }
+
+        @Override
+        public float getEntityDamageAmount(Explosion explosion, Entity entity) {
+            return Math.min(super.getEntityDamageAmount(explosion, entity), maxDamage);
+        }
+
+        @Override
+        public float getKnockbackMultiplier(Entity entity) {
+            return damagedEntities.contains(entity.getUUID()) ? 1.0F : 0.0F;
+        }
+
+        private boolean inLoadedChunk(BlockPos pos) {
+            return level.isInWorldBounds(pos) && new ChunkPos(pos).equals(chunk)
+                    && level.getChunkSource().hasChunk(chunk.x, chunk.z);
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+package net.dnorberg.rivencraft.book;
+
+import net.minecraft.core.HolderLookup;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.datafix.DataFixTypes;
+import net.minecraft.world.level.saveddata.SavedData;
+
+/** Per-Age hazard sequence and cooldowns survive unloads and server restarts. */
+public final class AgeHazardSavedData extends SavedData {
+    private static final Factory<AgeHazardSavedData> FACTORY = new Factory<>(AgeHazardSavedData::new,
+            AgeHazardSavedData::load, DataFixTypes.SAVED_DATA_MAP_DATA);
+    private long attempts;
+    private long lastLightning = Long.MIN_VALUE;
+    private long lastExplosion = Long.MIN_VALUE;
+    private long lastMeteor = Long.MIN_VALUE;
+
+    public static AgeHazardSavedData get(ServerLevel level) {
+        return level.getDataStorage().computeIfAbsent(FACTORY, "rivencraft_hazards");
+    }
+
+    public long nextAttempt() {
+        setDirty();
+        return attempts++;
+    }
+
+    public boolean ready(boolean lightning, long gameTime, int interval) {
+        long last = lightning ? lastLightning : lastExplosion;
+        return last == Long.MIN_VALUE || gameTime < last || gameTime - last >= interval;
+    }
+
+    public void record(boolean lightning, long gameTime) {
+        if (lightning) lastLightning = gameTime;
+        else lastExplosion = gameTime;
+        setDirty();
+    }
+
+    public boolean meteorReady(long gameTime, int interval) {
+        return lastMeteor == Long.MIN_VALUE || gameTime < lastMeteor || gameTime - lastMeteor >= interval;
+    }
+
+    public void recordMeteor(long gameTime) {
+        lastMeteor = gameTime;
+        setDirty();
+    }
+
+    @Override
+    public CompoundTag save(CompoundTag tag, HolderLookup.Provider registries) {
+        tag.putLong("Attempts", attempts);
+        tag.putLong("LastLightning", lastLightning);
+        tag.putLong("LastExplosion", lastExplosion);
+        tag.putLong("LastMeteor", lastMeteor);
+        return tag;
+    }
+
+    static AgeHazardSavedData load(CompoundTag tag, HolderLookup.Provider registries) {
+        AgeHazardSavedData data = new AgeHazardSavedData();
+        data.attempts = Math.max(0L, tag.getLong("Attempts"));
+        if (tag.contains("LastLightning")) data.lastLightning = tag.getLong("LastLightning");
+        if (tag.contains("LastExplosion")) data.lastExplosion = tag.getLong("LastExplosion");
+        if (tag.contains("LastMeteor")) data.lastMeteor = tag.getLong("LastMeteor");
+        return data;
+    }
+}

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

@@ -0,0 +1,95 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+
+/** Frozen, server-owned score. Only new Age creation consults the current symbol catalog. */
+public record AgeInstability(int version, int score, List<Contribution> breakdown) {
+    public static final int CURRENT_VERSION = 1;
+
+    public AgeInstability {
+        if (version != CURRENT_VERSION) throw new IllegalArgumentException("Unsupported instability version " + version);
+        breakdown = List.copyOf(breakdown);
+        if (score < 0 || score != breakdown.stream().mapToInt(Contribution::points).sum()) {
+            throw new IllegalArgumentException("Instability score does not match breakdown");
+        }
+    }
+
+    /** Pre-scoring saves are explicitly neutral, never rescored from current data packs. */
+    public static AgeInstability legacyNeutral() {
+        return new AgeInstability(CURRENT_VERSION, 0,
+                List.of(new Contribution("legacy_neutral", -1, 0, "Age predates frozen instability scoring")));
+    }
+
+    static AgeInstability compute(AgeGenerationPlan plan, AgeTraits traits) {
+        Objects.requireNonNull(traits, "traits");
+        List<Contribution> contributions = new ArrayList<>();
+        if (plan == null) {
+            contributions.add(new Contribution("random_baseline", -1, 0, "Page-free or Link-Panel-only Age"));
+        } else {
+            contributions.add(new Contribution("authored_baseline", -1, 0, "Authored Age"));
+            WritingGrammar.Result parsed = WritingGrammar.parse(plan.writing());
+            if (!parsed.canCreate() || parsed.writingInstability() != plan.writingInstability()) {
+                throw new IllegalArgumentException("Writing changed between Age compilation and scoring");
+            }
+            for (WritingGrammar.Diagnostic diagnostic : parsed.diagnostics()) {
+                contributions.add(new Contribution(diagnostic.code().name().toLowerCase(java.util.Locale.ROOT),
+                        diagnostic.index(), diagnostic.instability(), diagnostic.message()));
+            }
+        }
+        // Legacy's bright-lighting symbol adds +500. Other balance costs are deferred
+        // until their corresponding authored symbols and audited values exist.
+        if (traits.lighting() == AgeTraits.Lighting.BRIGHT) {
+            int pageIndex = plan == null ? -1 : plan.activeSymbols().stream()
+                    .filter(symbol -> symbol.semantics().role()
+                            == net.dnorberg.rivencraft.writing.SymbolSemantics.Role.LIGHTING)
+                    .mapToInt(AgeGenerationPlan.ResolvedSymbol::index).findFirst().orElse(-1);
+            contributions.add(new Contribution("bright_lighting", pageIndex, 500,
+                    pageIndex < 0 ? "Seeded bright lighting" : "Authored bright lighting"));
+        }
+        return new AgeInstability(CURRENT_VERSION,
+                contributions.stream().mapToInt(Contribution::points).sum(), contributions);
+    }
+
+    public CompoundTag save() {
+        CompoundTag tag = new CompoundTag();
+        tag.putInt("Version", version);
+        tag.putInt("Score", score);
+        ListTag entries = new ListTag();
+        for (Contribution contribution : breakdown) {
+            CompoundTag entry = new CompoundTag();
+            entry.putString("Reason", contribution.reason());
+            entry.putInt("PageIndex", contribution.pageIndex());
+            entry.putInt("Points", contribution.points());
+            entry.putString("Detail", contribution.detail());
+            entries.add(entry);
+        }
+        tag.put("Breakdown", entries);
+        return tag;
+    }
+
+    public static AgeInstability load(CompoundTag tag) {
+        ListTag entries = tag.getList("Breakdown", CompoundTag.TAG_COMPOUND);
+        List<Contribution> contributions = new ArrayList<>();
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            contributions.add(new Contribution(entry.getString("Reason"), entry.getInt("PageIndex"),
+                    entry.getInt("Points"), entry.getString("Detail")));
+        }
+        return new AgeInstability(tag.getInt("Version"), tag.getInt("Score"), contributions);
+    }
+
+    public record Contribution(String reason, int pageIndex, int points, String detail) {
+        public Contribution {
+            Objects.requireNonNull(reason, "reason");
+            Objects.requireNonNull(detail, "detail");
+            if (reason.isBlank() || pageIndex < -1 || points < 0) {
+                throw new IllegalArgumentException("Invalid instability contribution");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.resources.ResourceLocation;
+
+/** Frozen provider selection; handler availability and server settings never reroll this plan. */
+public record AgeInstabilityPlan(int version, List<ProviderLevel> providers) {
+    public static final int CURRENT_VERSION = 1;
+
+    public AgeInstabilityPlan {
+        if (version != CURRENT_VERSION) throw new IllegalArgumentException("Unsupported provider-plan version " + version);
+        providers = List.copyOf(providers);
+        if (providers.stream().map(ProviderLevel::id).distinct().count() != providers.size()) {
+            throw new IllegalArgumentException("Duplicate provider ID in saved Age plan");
+        }
+    }
+
+    public static AgeInstabilityPlan empty() { return new AgeInstabilityPlan(CURRENT_VERSION, List.of()); }
+
+    public static AgeInstabilityPlan select(AgeInstability instability, long ageSeed) {
+        int roundedScore = instability.score() / 500 * 500;
+        Map<ResourceLocation, Integer> levels = new LinkedHashMap<>();
+        for (InstabilityProviderCatalog.Deck deck : InstabilityProviderCatalog.Deck.values()) {
+            int remaining = roundedScore - deck.entryCost();
+            if (remaining <= 0) continue;
+            List<InstabilityProviderCatalog.Card> cards = new ArrayList<>(InstabilityProviderCatalog.cards(deck));
+            Collections.shuffle(cards, new Random(ageSeed ^ (0x9E3779B97F4A7C15L * (deck.ordinal() + 1))));
+            for (InstabilityProviderCatalog.Card card : cards) {
+                if (remaining < card.cost()) break;
+                remaining -= card.cost();
+                levels.merge(card.id(), 1, Integer::sum);
+            }
+        }
+        return new AgeInstabilityPlan(CURRENT_VERSION, levels.entrySet().stream()
+                .map(entry -> new ProviderLevel(entry.getKey(), entry.getValue())).toList());
+    }
+
+    public CompoundTag save() {
+        CompoundTag tag = new CompoundTag();
+        tag.putInt("Version", version);
+        ListTag entries = new ListTag();
+        for (ProviderLevel provider : providers) {
+            CompoundTag entry = new CompoundTag();
+            entry.putString("Id", provider.id().toString());
+            entry.putInt("Level", provider.level());
+            entries.add(entry);
+        }
+        tag.put("Providers", entries);
+        return tag;
+    }
+
+    public static AgeInstabilityPlan load(CompoundTag tag) {
+        ListTag entries = tag.getList("Providers", CompoundTag.TAG_COMPOUND);
+        List<ProviderLevel> providers = new ArrayList<>();
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            ResourceLocation id = ResourceLocation.tryParse(entry.getString("Id"));
+            if (id == null) throw new IllegalArgumentException("Invalid saved instability provider ID at " + index);
+            providers.add(new ProviderLevel(id, entry.getInt("Level")));
+        }
+        return new AgeInstabilityPlan(tag.getInt("Version"), providers);
+    }
+
+    public record ProviderLevel(ResourceLocation id, int level) {
+        public ProviderLevel {
+            Objects.requireNonNull(id, "id");
+            if (level < 1 || level > 255) throw new IllegalArgumentException("Invalid provider level " + level);
+        }
+    }
+}

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

@@ -0,0 +1,181 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** Server-only scheduler. Effect handlers are registered by later provider slices. */
+public final class AgeInstabilityRuntime {
+    private static final Map<ResourceLocation, Handler> HANDLERS = new HashMap<>();
+    private static final Map<MinecraftServer, TickState> TICKS = new WeakHashMap<>();
+    private static final Map<ServerLevel, Map<ResourceLocation, Long>> FAILURES = new WeakHashMap<>();
+    private static final Set<ResourceLocation> UNKNOWN_LOGGED = new HashSet<>();
+
+    private AgeInstabilityRuntime() {}
+
+    /** Register once during mod setup. Missing optional handlers never alter saved provider IDs. */
+    public static void register(ResourceLocation id, boolean worldMutating, ProviderEffect effect) {
+        Objects.requireNonNull(id, "id");
+        Objects.requireNonNull(effect, "effect");
+        if (HANDLERS.putIfAbsent(id, new Handler(worldMutating, effect)) != null) {
+            throw new IllegalArgumentException("Duplicate instability handler " + id);
+        }
+    }
+
+    public static void onLevelTickPost(LevelTickEvent.Post event) {
+        if (!(event.getLevel() instanceof ServerLevel level) || !RivencraftConfig.instabilityEnabled()
+                || !isAgeDimension(level.dimension().location()) || level.players().isEmpty()) return;
+        MinecraftServer server = level.getServer();
+        long tick = server.getTickCount();
+        int cooldown = RivencraftConfig.instabilityCooldown();
+        if (tick % cooldown != 0) return;
+        TickState state = TICKS.computeIfAbsent(server, ignored -> new TickState());
+        if (state.tick != tick) {
+            state.tick = tick;
+            state.eligible = loadedPlayerAges(server);
+        }
+        if (!admitted(state.eligible, level.dimension().location(), tick / cooldown,
+                RivencraftConfig.instabilityMaxAges())) return;
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null || age.instabilityPlan().providers().isEmpty()) return;
+        // Legacy's per-chunk hazards must not wait for the rotating two-provider sample.
+        AgeHazardProviders.tickPlanned(level, age, tick);
+        AgeEnvironmentalProviders.tickPlanned(level, age, tick);
+        List<ChunkPos> chunks = loadedChunksNearPlayers(level, RivencraftConfig.instabilityMaxChunks());
+        if (chunks.isEmpty()) return;
+        Budget budget = new Budget(RivencraftConfig.instabilityMaxActions());
+        Context context = new Context(level, age, chunks, tick, budget);
+        List<AgeInstabilityPlan.ProviderLevel> providers = age.instabilityPlan().providers();
+        int first = (int) Math.floorMod(tick / cooldown + age.seed(), providers.size());
+        int ran = 0;
+        for (int offset = 0; offset < providers.size() && ran < RivencraftConfig.instabilityMaxProviders()
+                && budget.remaining() > 0; offset++) {
+            AgeInstabilityPlan.ProviderLevel provider = providers.get((first + offset) % providers.size());
+            if (AgeHazardProviders.isHazard(provider.id())
+                    || AgeEnvironmentalProviders.isEnvironmental(provider.id())) continue;
+            if (invoke(context, provider.id(), provider.level())) ran++;
+        }
+    }
+
+    /** Shared handler guard, including quarantine, for rotating and per-chunk provider lanes. */
+    static boolean invoke(Context context, ResourceLocation id, int level) {
+        Handler handler = HANDLERS.get(id);
+        if (handler == null) {
+            if (!InstabilityProviderCatalog.contains(id) && UNKNOWN_LOGGED.add(id)) {
+                Rivencraft.LOGGER.warn("Saved Age references unknown instability provider {}; skipping it", id);
+            }
+            return false;
+        }
+        if (handler.worldMutating() && !RivencraftConfig.instabilityWorldMutation()) return false;
+        long retryAfter = FAILURES.computeIfAbsent(context.level(), ignored -> new HashMap<>())
+                .getOrDefault(id, 0L);
+        if (context.serverTick() < retryAfter) return false;
+        try {
+            handler.effect().apply(context, id,
+                    Math.min(level, RivencraftConfig.instabilityMaxLevel()));
+        } catch (RuntimeException exception) {
+            FAILURES.get(context.level()).put(id, context.serverTick()
+                    + Math.max(200L, RivencraftConfig.instabilityCooldown() * 10L));
+            Rivencraft.LOGGER.error("Instability provider {} failed in Age {}; temporarily quarantined",
+                    id, context.age().id(), exception);
+        }
+        return true;
+    }
+
+    public static void onServerStopping(ServerStoppingEvent event) {
+        TICKS.remove(event.getServer());
+        FAILURES.clear();
+        UNKNOWN_LOGGED.clear();
+    }
+
+    public static boolean isAgeDimension(ResourceLocation id) {
+        return id.getNamespace().equals(Rivencraft.MOD_ID) && id.getPath().startsWith("age/");
+    }
+
+    static boolean admitted(List<ResourceLocation> eligible, ResourceLocation id, long run,
+                            int maximum) {
+        int index = eligible.indexOf(id);
+        if (index < 0 || maximum < 1) return false;
+        if (eligible.size() <= maximum) return true;
+        return Math.floorMod(index - (int) Math.floorMod(run, eligible.size()), eligible.size()) < maximum;
+    }
+
+    private static List<ResourceLocation> loadedPlayerAges(MinecraftServer server) {
+        List<ResourceLocation> eligible = new ArrayList<>();
+        AgeRegistrySavedData registry = AgeRegistrySavedData.get(server.overworld());
+        for (ServerLevel level : server.getAllLevels()) {
+            ResourceLocation id = level.dimension().location();
+            if (isAgeDimension(id) && !level.players().isEmpty()
+                    && registry.findByDimension(id).filter(age -> !age.instabilityPlan().providers().isEmpty())
+                    .isPresent()) eligible.add(id);
+        }
+        eligible.sort(Comparator.comparing(ResourceLocation::toString));
+        return List.copyOf(eligible);
+    }
+
+    private static List<ChunkPos> loadedChunksNearPlayers(ServerLevel level, int maximum) {
+        Set<ChunkPos> chunks = new LinkedHashSet<>();
+        for (var player : level.players()) {
+            ChunkPos center = player.chunkPosition();
+            for (int dx = -1; dx <= 1; dx++) {
+                for (int dz = -1; dz <= 1; dz++) {
+                    int x = center.x + dx;
+                    int z = center.z + dz;
+                    if (level.getChunkSource().hasChunk(x, z)) chunks.add(new ChunkPos(x, z));
+                    if (chunks.size() >= maximum) return List.copyOf(chunks);
+                }
+            }
+        }
+        return List.copyOf(chunks);
+    }
+
+    @FunctionalInterface
+    public interface ProviderEffect {
+        /** Claim budget before each effect action; only use chunks supplied in the context. */
+        void apply(Context context, ResourceLocation id, int effectiveLevel);
+    }
+
+    public record Context(ServerLevel level, AgeDefinition age, List<ChunkPos> loadedChunks,
+                          long serverTick, Budget budget) {
+        public Context { loadedChunks = List.copyOf(loadedChunks); }
+    }
+
+    public static final class Budget {
+        private int remaining;
+
+        public Budget(int maximum) {
+            if (maximum < 0) throw new IllegalArgumentException("Negative work budget");
+            remaining = maximum;
+        }
+
+        public boolean claim() {
+            if (remaining == 0) return false;
+            remaining--;
+            return true;
+        }
+
+        public int remaining() { return remaining; }
+    }
+
+    private record Handler(boolean worldMutating, ProviderEffect effect) {}
+
+    private static final class TickState {
+        private long tick = Long.MIN_VALUE;
+        private List<ResourceLocation> eligible = List.of();
+    }
+}

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

@@ -0,0 +1,167 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.GameType;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Pure server-side provider-plan and scheduler-boundary checks for issue #66. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class AgeInstabilityRuntimeGameTests {
+    private AgeInstabilityRuntimeGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void selectionIsDeterministicAndFrozen(GameTestHelper helper) {
+        AgeInstability score = new AgeInstability(AgeInstability.CURRENT_VERSION, 30_000,
+                List.of(new AgeInstability.Contribution("fixture", -1, 30_000, "provider selection")));
+        AgeInstabilityPlan first = AgeInstabilityPlan.select(score, 44L);
+        helper.assertTrue(!first.providers().isEmpty(), "An eligible score must select providers");
+        helper.assertValueEqual(AgeInstabilityPlan.select(score, 44L), first,
+                "The same Age seed and frozen score must select the same providers");
+        helper.assertValueEqual(AgeInstabilityPlan.load(first.save()), first,
+                "Saved provider IDs and levels must survive a round trip");
+        helper.assertTrue(first.providers().stream().allMatch(provider -> provider.level() > 0
+                        && InstabilityProviderCatalog.contains(provider.id())),
+                "Only audited providers with positive levels may be selected");
+        helper.assertTrue(AgeInstabilityPlan.select(AgeInstability.legacyNeutral(), 44L)
+                        .providers().isEmpty(), "Neutral old Ages must stay inert");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void savedPlanSurvivesAgeUpdatesAndMissingHandlers(GameTestHelper helper) {
+        ResourceLocation optional = ResourceLocation.parse("example:optional_provider");
+        AgeInstabilityPlan plan = new AgeInstabilityPlan(1,
+                List.of(new AgeInstabilityPlan.ProviderLevel(optional, 2)));
+        helper.assertValueEqual(AgeInstabilityPlan.load(plan.save()), plan,
+                "A syntactically valid provider ID must persist even if no handler is installed");
+        UUID id = UUID.randomUUID();
+        AgeDefinition age = new AgeDefinition(id, "Runtime", 91L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(id), null,
+                AgeTraits.LEGACY_DEFAULTS, null, null, List.of(), AgeInstability.legacyNeutral(), plan);
+        helper.assertValueEqual(age.withSpawn(new BlockPos(1, 64, 2)).instabilityPlan(), plan,
+                "Setting an Age spawn must not reroll selected providers");
+        CompoundTag corrupt = plan.save();
+        corrupt.getList("Providers", CompoundTag.TAG_COMPOUND).getCompound(0)
+                .putString("Id", "bad provider id");
+        boolean rejected = false;
+        try { AgeInstabilityPlan.load(corrupt); }
+        catch (IllegalArgumentException expected) { rejected = true; }
+        helper.assertTrue(rejected, "Malformed provider IDs must fail clearly");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void ageScopeRotationAndActionBudgetAreBounded(GameTestHelper helper) {
+        ResourceLocation first = ResourceLocation.parse("rivencraft:age/first");
+        ResourceLocation second = ResourceLocation.parse("rivencraft:age/second");
+        ResourceLocation third = ResourceLocation.parse("rivencraft:age/third");
+        helper.assertTrue(!AgeInstabilityRuntime.isAgeDimension(helper.getLevel().dimension().location()),
+                "The GameTest Overworld must never be treated as an Age");
+        helper.assertTrue(!AgeInstabilityRuntime.isAgeDimension(ResourceLocation.parse("rivencraft:preview")),
+                "Preview worlds must not receive Age effects");
+        List<ResourceLocation> loaded = List.of(first, second, third);
+        helper.assertTrue(AgeInstabilityRuntime.admitted(loaded, first, 0, 1)
+                        && AgeInstabilityRuntime.admitted(loaded, second, 1, 1)
+                        && AgeInstabilityRuntime.admitted(loaded, third, 2, 1),
+                "A global cap must rotate fairly among loaded Ages");
+        AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(2);
+        helper.assertTrue(budget.claim() && budget.claim() && !budget.claim(),
+                "A handler cannot claim more actions than the Age budget");
+        helper.assertValueEqual(budget.remaining(), 0, "The budget must not go negative");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void hazardCooldownAndAttemptSequenceSurviveReload(GameTestHelper helper) {
+        AgeHazardSavedData data = new AgeHazardSavedData();
+        helper.assertTrue(data.ready(true, 1000, 200) && data.ready(false, 1000, 200),
+                "Each hazard type starts eligible independently");
+        helper.assertValueEqual(data.nextAttempt(), 0L, "First hazard roll has a stable sequence");
+        data.record(true, 1000);
+        helper.assertTrue(!data.ready(true, 1199, 200) && data.ready(false, 1199, 200),
+                "Lightning cooldown must not suppress explosions");
+        AgeHazardSavedData restored = AgeHazardSavedData.load(
+                data.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.nextAttempt(), 1L, "Restart must not replay the previous roll");
+        helper.assertTrue(!restored.ready(true, 1199, 200) && restored.ready(true, 1200, 200),
+                "Reloaded cooldown must still enforce the minimum interval");
+        helper.assertTrue(restored.meteorReady(1200, 200), "Meteor cooldown starts independently");
+        restored.recordMeteor(1200);
+        AgeHazardSavedData meteorReloaded = AgeHazardSavedData.load(
+                restored.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertTrue(!meteorReloaded.meteorReady(1399, 200)
+                        && meteorReloaded.meteorReady(1400, 200),
+                "A meteor attempt must not replay immediately after restart");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void environmentalCardsPreserveLegacyDeckAndAgeScope(GameTestHelper helper) {
+        helper.assertTrue(InstabilityProviderCatalog.contains(ResourceLocation.parse("rivencraft:meteors"))
+                        && InstabilityProviderCatalog.contains(ResourceLocation.parse("rivencraft:burning")),
+                "Meteor and burning must retain their audited Legacy deck cards");
+        helper.assertTrue(!InstabilityProviderCatalog.contains(ResourceLocation.parse("rivencraft:erosion")),
+                "Enabling dormant erosion must not silently change frozen provider selection");
+        var level = helper.getLevel();
+        var budget = new AgeInstabilityRuntime.Budget(1);
+        var age = new AgeDefinition(UUID.randomUUID(), "Fixture", 1L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L,
+                ResourceLocation.parse("rivencraft:age/fixture"), null,
+                AgeTraits.LEGACY_DEFAULTS, null, null, List.of(), AgeInstability.legacyNeutral(),
+                AgeInstabilityPlan.empty());
+        var context = new AgeInstabilityRuntime.Context(level, age, List.of(new net.minecraft.world.level.ChunkPos(0, 0)),
+                level.getServer().getTickCount(), budget);
+        helper.assertTrue(AgeEnvironmentalProviders.matchesAge(age, age.dimensionId())
+                        && !AgeEnvironmentalProviders.matchesAge(age, ResourceLocation.parse("rivencraft:age/other"))
+                        && !AgeEnvironmentalProviders.matchesAge(age, level.dimension().location()),
+                "One player's environmental Age effects must not leak into another Age or the Overworld");
+        for (String path : List.of("meteors", "burning", "erosion")) {
+            AgeEnvironmentalProviders.apply(context, ResourceLocation.parse("rivencraft:" + path), 1);
+        }
+        helper.assertValueEqual(budget.remaining(), 1,
+                "Environmental effects must never run in the GameTest Overworld");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void burningPersistsOnDrySurvivalPlayer(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        player.setGameMode(GameType.SURVIVAL);
+        player.igniteForSeconds(4);
+        helper.assertTrue(player.getRemainingFireTicks() >= 79,
+                "Burning should set at least four seconds of server-side fire ticks");
+        helper.runAfterDelay(2, () -> {
+            helper.assertTrue(player.isOnFire() && player.getRemainingFireTicks() > 0,
+                    "A dry survival player should remain on fire after Minecraft ticks the entity");
+            helper.succeed();
+        });
+    }
+
+    @GameTest(template = "empty")
+    public static void hazardRollMatchesLegacyChunkOpportunity(GameTestHelper helper) {
+        double oneChunk = AgeHazardProviders.legacyChance(1, 1, 1, 1000);
+        double nearby = AgeHazardProviders.legacyChance(81, 20, 1, 1000);
+        double thunder = AgeHazardProviders.legacyChance(81, 20, 1, 5000);
+        double clear = AgeHazardProviders.legacyChance(81, 20, 1, 100000);
+        helper.assertTrue(Math.abs(oneChunk - 0.001) < 0.000001,
+                "One chunk tick must retain Legacy's 1/1000 explosion roll");
+        helper.assertTrue(nearby > 0.79 && nearby < 0.82,
+                "Nearby loaded chunks must produce frequent bounded explosions");
+        helper.assertTrue(thunder > clear && clear > 0,
+                "Legacy lightning must be more frequent in thunder than clear weather");
+        helper.assertTrue(AgeHazardProviders.legacyChance(0, 20, 1, 1000) == 0,
+                "Unloaded chunks must never produce a hazard opportunity");
+        helper.succeed();
+    }
+}

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

@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
@@ -30,7 +31,7 @@ public final class AgePersistenceGameTests {
                 WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:weather/normal"))),
                 WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal"))),
                 WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:celestial/normal_time"))),
-                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:feature/caves")))
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:feature/flowers")))
         ));
         UUID id = UUID.randomUUID();
         AgeReference reference = new AgeReference(id, "Authored Plan " + id);
@@ -55,6 +56,124 @@ public final class AgePersistenceGameTests {
                 registry.save(new CompoundTag(), helper.getLevel().registryAccess()),
                 helper.getLevel().registryAccess()).find(id).orElseThrow();
         helper.assertValueEqual(restored, created, "The complete plan must survive a saved-data round trip");
+        helper.assertValueEqual(restored.instability(), created.instability(),
+                "The complete instability breakdown must survive reload");
+        helper.assertValueEqual(restored.instabilityPlan(), created.instabilityPlan(),
+                "The selected provider levels must not reroll on reload");
+        helper.assertValueEqual(registry.instability(id).orElseThrow(), created.instability(),
+                "The server diagnostic query must return the saved score");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void instabilitySeparatesStableAndDefectiveWriting(GameTestHelper helper) {
+        OrderedWriting stable = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal")))
+        ));
+        OrderedWriting defective = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))
+        ));
+        AgeDefinition stableAge = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Stable Writing"), stable);
+        AgeDefinition defectiveAge = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Defective Writing"), defective);
+        helper.assertValueEqual(stableAge.instability().score(), 0,
+                "Missing seeded branches do not add instability");
+        helper.assertValueEqual(defectiveAge.instability().score(), 600,
+                "Out-of-order and repeated terrain pages each add their saved penalty");
+        helper.assertTrue(defectiveAge.instability().breakdown().stream()
+                        .anyMatch(part -> part.reason().equals("duplicate") && part.pageIndex() == 3),
+                "The score must explain the offending page");
+        AgeDefinition reused = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(defectiveAge.id(), "Changed Name"), stable);
+        helper.assertValueEqual(reused, defectiveAge, "Repeated book use must not rescore an Age");
+        CompoundTag scoreOnlySave = AgeRegistrySavedData.get(helper.getLevel())
+                .save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag savedAges = scoreOnlySave.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < savedAges.size(); index++) {
+            CompoundTag entry = savedAges.getCompound(index);
+            if (entry.getUUID("Id").equals(defectiveAge.id())) entry.remove("InstabilityPlan");
+        }
+        AgeRegistrySavedData migrated = AgeRegistrySavedData.load(scoreOnlySave,
+                helper.getLevel().registryAccess());
+        AgeDefinition migratedAge = migrated.find(defectiveAge.id()).orElseThrow();
+        helper.assertValueEqual(migratedAge.instabilityPlan(),
+                AgeInstabilityPlan.select(defectiveAge.instability(), defectiveAge.seed()),
+                "A score-only save must receive one deterministic provider migration");
+        helper.assertValueEqual(AgeRegistrySavedData.load(
+                        migrated.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                        helper.getLevel().registryAccess()).find(defectiveAge.id()).orElseThrow().instabilityPlan(),
+                migratedAge.instabilityPlan(), "Migrated provider selection must then remain frozen");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void randomBaselineAndBrightBalanceAreFrozen(GameTestHelper helper) {
+        AgeDefinition random = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Random Score"), OrderedWriting.EMPTY);
+        helper.assertTrue(random.instability().breakdown().stream()
+                        .anyMatch(part -> part.reason().equals("random_baseline") && part.points() == 0),
+                "Random Ages require an explicit baseline entry");
+        helper.assertValueEqual(random.instability().score(),
+                random.traits().lighting() == AgeTraits.Lighting.BRIGHT ? 500 : 0,
+                "Seeded bright lighting must use the audited balance cost");
+        AgeInstability bright = AgeInstability.compute(null, new AgeTraits(
+                AgeTraits.LEGACY_DEFAULTS.biomeDistribution(), AgeTraits.Lighting.BRIGHT,
+                AgeTraits.LEGACY_DEFAULTS.weather(), AgeTraits.LEGACY_DEFAULTS.celestialPeriod(),
+                AgeTraits.LEGACY_DEFAULTS.celestialAngle(), AgeTraits.LEGACY_DEFAULTS.celestialPhase()));
+        helper.assertValueEqual(bright.score(), 500, "Bright lighting has the audited Legacy cost");
+        helper.assertValueEqual(AgeInstability.load(bright.save()), bright,
+                "A score must survive its own versioned round trip");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void missingRegistryEntryDoesNotReinterpretAnOldAge(GameTestHelper helper) {
+        UUID id = UUID.randomUUID();
+        CompoundTag root = new CompoundTag();
+        ListTag entries = new ListTag();
+        entries.add(entry(id, "Old Age", 17L, AgeGenerationProfiles.STANDARD, 15, 1L,
+                AgeDefinition.dimensionId(id), new BlockPos(0, 64, 0), AgeTraits.LEGACY_DEFAULTS));
+        root.put("Ages", entries);
+        AgeRegistrySavedData old = AgeRegistrySavedData.load(root, helper.getLevel().registryAccess());
+        helper.assertValueEqual(old.instability(id).orElseThrow(), AgeInstability.legacyNeutral(),
+                "Old Ages without a score must migrate to a neutral saved value");
+        helper.assertTrue(old.instabilityPlan(id).orElseThrow().providers().isEmpty(),
+                "Pre-score Ages must not acquire effects during migration");
+        helper.assertValueEqual(AgeRegistrySavedData.load(
+                old.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess()).instability(id).orElseThrow(), AgeInstability.legacyNeutral(),
+                "Neutral migration must persist after restart");
+        OrderedWriting missing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:missing_symbol")))));
+        helper.assertTrue(!WritingGrammar.parse(missing, symbol -> java.util.Optional.empty()).canCreate(),
+                "Missing registry symbols remain fatal for new Ages");
+
+        OrderedWriting authored = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))));
+        AgeDefinition created = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Catalog Snapshot"), authored);
+        CompoundTag saved = AgeRegistrySavedData.get(helper.getLevel())
+                .save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag savedAges = saved.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < savedAges.size(); index++) {
+            CompoundTag savedAge = savedAges.getCompound(index);
+            if (!savedAge.getUUID("Id").equals(created.id())) continue;
+            CompoundTag plan = savedAge.getCompound("GenerationPlan");
+            plan.getList("Resolved", CompoundTag.TAG_COMPOUND).getCompound(0)
+                    .putString("Symbol", "rivencraft:removed_from_catalog");
+            plan.getList("Writing", CompoundTag.TAG_COMPOUND).getCompound(1)
+                    .putString("Symbol", "rivencraft:removed_from_catalog");
+        }
+        AgeDefinition restored = AgeRegistrySavedData.load(saved, helper.getLevel().registryAccess())
+                .find(created.id()).orElseThrow();
+        helper.assertValueEqual(restored.instability(), created.instability(),
+                "A removed symbol must not reroll or reinterpret the frozen instability score");
         helper.succeed();
     }
 
@@ -66,7 +185,34 @@ public final class AgePersistenceGameTests {
                 new AgeReference(UUID.randomUUID(), "Panel Only"),
                 new OrderedWriting(List.of(WritingEntry.linkPanel())));
         helper.assertTrue(pageFree.plan() == null && panelOnly.plan() == null,
-                "Old and Link-Panel-only books must retain the random Age path");
+                "Page-free and Link-Panel-only books must retain the random Age path");
+        for (AgeDefinition age : List.of(pageFree, panelOnly)) {
+            helper.assertTrue(age.randomFeatures().stream().filter(choice -> choice.material().isPresent())
+                            .count() <= 2,
+                    "A random Age may roll at most two material features");
+            helper.assertTrue(age.randomFeatures().stream().filter(choice ->
+                    AgeFeatureSelection.skylands(choice.id())).count() <= 1,
+                    "A random Age may roll at most one Skylands filter");
+            helper.assertTrue(age.randomFeatures().stream().filter(choice ->
+                    AgeStructureSelection.feature(choice.id())).count() <= 2,
+                    "A random Age may roll at most two distinct structure features");
+            for (AgeFeatureSelection.Choice choice : age.randomFeatures()) {
+                helper.assertTrue(AgeFeatureSelection.skylands(choice.id())
+                                || choice.id().equals(AgeFeatureSelection.CRYSTAL_FORMATIONS)
+                                || choice.id().equals(AgeFeatureSelection.STAR_FISSURES)
+                                || AgeStructureSelection.feature(choice.id())
+                                ? choice.material().isEmpty()
+                                : choice.material().isPresent()
+                                && AgeFeatureSelection.materialError(choice) == null,
+                        "Random material features need valid blocks or fluids; material-free features need none");
+            }
+        }
+        AgeRegistrySavedData registry = AgeRegistrySavedData.get(helper.getLevel());
+        var restored = AgeRegistrySavedData.load(
+                registry.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.find(pageFree.id()).orElseThrow().randomFeatures(),
+                pageFree.randomFeatures(), "Random material features must survive a saved-data round trip");
         helper.succeed();
     }
 
@@ -143,6 +289,8 @@ public final class AgePersistenceGameTests {
                 "Definitions predating traits must receive stable legacy defaults");
         helper.assertTrue(definition.plan() == null,
                 "Existing Ages must not be reinterpreted as authored plans during migration");
+        helper.assertValueEqual(definition.instability(), AgeInstability.legacyNeutral(),
+                "Old Ages must not be rescored from modern page rules");
 
         CompoundTag serialized = migrated.save(new CompoundTag(), helper.getLevel().registryAccess());
         AgeDefinition reloaded = AgeRegistrySavedData.load(serialized, helper.getLevel().registryAccess())

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,10 @@ 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 RANDOM_FEATURES_TAG = "RandomFeatures";
+    private static final String SEASON_MODE_TAG = "SeasonMode";
+    private static final String INSTABILITY_TAG = "Instability";
+    private static final String INSTABILITY_PLAN_TAG = "InstabilityPlan";
     private static final String BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
     private static final String LIGHTING_TAG = "Lighting";
     private static final String WEATHER_TAG = "Weather";
@@ -66,21 +71,35 @@ public final class AgeRegistrySavedData extends SavedData {
         ServerLevel overworld = level.getServer().overworld();
         AgeRegistrySavedData data = get(overworld);
         long seed = ageSeed(overworld.getSeed(), data.availableDimensionId(normalizedName(name)));
-        AgeGenerationPlan.compile(writing, seed, AgeRuntimeProfiles.select(seed), AgeTraits.select(seed),
+        AgeGenerationPlan.compile(writing, seed,
+                AgeRuntimeProfiles.selectForWriting(seed, writing, overworld.registryAccess()), AgeTraits.select(seed),
                 overworld.registryAccess());
     }
 
     public static ResourceLocation previewGenerationProfile(ServerLevel level, String name) {
+        return previewGenerationProfile(level, name, OrderedWriting.EMPTY);
+    }
+
+    public static ResourceLocation previewGenerationProfile(ServerLevel level, String name, OrderedWriting writing) {
         ServerLevel overworld = level.getServer().overworld();
         AgeRegistrySavedData data = get(overworld);
         long seed = ageSeed(overworld.getSeed(), data.availableDimensionId(normalizedName(name)));
-        return AgeRuntimeProfiles.select(seed);
+        return AgeRuntimeProfiles.selectForWriting(seed, writing, overworld.registryAccess());
     }
 
     public Optional<AgeDefinition> find(UUID ageId) {
         return Optional.ofNullable(ages.get(ageId));
     }
 
+    /** Read-only server diagnostic; never compiles writing or mutates a saved Age. */
+    public Optional<AgeInstability> instability(UUID ageId) {
+        return find(ageId).map(AgeDefinition::instability);
+    }
+
+    public Optional<AgeInstabilityPlan> instabilityPlan(UUID ageId) {
+        return find(ageId).map(AgeDefinition::instabilityPlan);
+    }
+
     public Optional<AgeDefinition> findByDimension(ResourceLocation dimensionId) {
         return ages.values().stream()
                 .filter(age -> age.dimensionId().equals(dimensionId))
@@ -112,9 +131,12 @@ public final class AgeRegistrySavedData extends SavedData {
         String name = normalizedName(reference.name());
         ResourceLocation dimensionId = availableDimensionId(name);
         long seed = ageSeed(worldSeed, dimensionId);
-        ResourceLocation seedProfile = AgeRuntimeProfiles.select(seed);
+        ResourceLocation seedProfile = AgeRuntimeProfiles.selectForWriting(seed, writing, registries);
         AgeTraits traits = AgeTraits.select(seed);
         AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile, traits, registries);
+        AgeTraits effectiveTraits = AgeEnvironmentCompiler.apply(plan, traits);
+        AgeInstability instability = AgeInstability.compute(plan, effectiveTraits);
+        AgeInstabilityPlan instabilityPlan = AgeInstabilityPlan.select(instability, seed);
         AgeDefinition created = new AgeDefinition(
                 reference.id(),
                 name,
@@ -124,8 +146,13 @@ public final class AgeRegistrySavedData extends SavedData {
                 createdGameTime,
                 dimensionId,
                 null,
-                AgeEnvironmentCompiler.apply(plan, traits),
+                effectiveTraits,
-                plan
+                plan,
+                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons")),
+                plan == null ? AgeFeatureSelection.randomChoices(seed,
+                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of(),
+                instability,
+                instabilityPlan
         );
         ages.put(created.id(), created);
         setDirty();
@@ -158,6 +185,19 @@ public final class AgeRegistrySavedData extends SavedData {
             BlockPos spawn = entry.contains(SPAWN_Y_TAG)
                     ? new BlockPos(entry.getInt(SPAWN_X_TAG), entry.getInt(SPAWN_Y_TAG), entry.getInt(SPAWN_Z_TAG))
                     : null;
+            AgeInstability instability = entry.contains(INSTABILITY_TAG, CompoundTag.TAG_COMPOUND)
+                    ? AgeInstability.load(entry.getCompound(INSTABILITY_TAG)) : AgeInstability.legacyNeutral();
+            AgeInstabilityPlan instabilityPlan;
+            if (entry.contains(INSTABILITY_PLAN_TAG, CompoundTag.TAG_COMPOUND)) {
+                instabilityPlan = AgeInstabilityPlan.load(entry.getCompound(INSTABILITY_PLAN_TAG));
+            } else {
+                // The previous release froze scores but did not yet choose providers.
+                // Migrate once from that frozen score, then persist the result.
+                instabilityPlan = entry.contains(INSTABILITY_TAG, CompoundTag.TAG_COMPOUND)
+                        ? AgeInstabilityPlan.select(instability, entry.getLong(SEED_TAG))
+                        : AgeInstabilityPlan.empty();
+                data.setDirty();
+            }
             data.ages.put(id, new AgeDefinition(
                     id,
                     normalizedName(entry.getString(NAME_TAG)),
@@ -169,7 +209,12 @@ 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,
+                    readRandomFeatures(entry),
+                    instability,
+                    instabilityPlan
             ));
         }
         return data;
@@ -203,12 +248,37 @@ 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.randomFeatures().isEmpty()) {
+                        ListTag featureTags = new ListTag();
+                        for (AgeFeatureSelection.Choice choice : age.randomFeatures()) {
+                            CompoundTag feature = new CompoundTag();
+                            feature.putString("Id", choice.id().toString());
+                            choice.material().ifPresent(id -> feature.putString("Material", id.toString()));
+                            featureTags.add(feature);
+                        }
+                        entry.put(RANDOM_FEATURES_TAG, featureTags);
+                    }
+                    if (age.seasonMode() != null) entry.putString(SEASON_MODE_TAG, age.seasonMode().name());
+                    entry.put(INSTABILITY_TAG, age.instability().save());
+                    entry.put(INSTABILITY_PLAN_TAG, age.instabilityPlan().save());
                     serializedAges.add(entry);
                 });
         tag.put(AGES_TAG, serializedAges);
         return tag;
     }
 
+    private static List<AgeFeatureSelection.Choice> readRandomFeatures(CompoundTag age) {
+        ListTag tags = age.getList(RANDOM_FEATURES_TAG, CompoundTag.TAG_COMPOUND);
+        List<AgeFeatureSelection.Choice> features = new java.util.ArrayList<>();
+        for (int index = 0; index < tags.size(); index++) {
+            CompoundTag item = tags.getCompound(index);
+            features.add(new AgeFeatureSelection.Choice(ResourceLocation.parse(item.getString("Id")),
+                    item.contains("Material", CompoundTag.TAG_STRING)
+                            ? Optional.of(ResourceLocation.parse(item.getString("Material"))) : Optional.empty()));
+        }
+        return List.copyOf(features);
+    }
+
     private static AgeTraits readTraits(CompoundTag age) {
         if (!age.contains(TRAITS_TAG, CompoundTag.TAG_COMPOUND)) {
             return AgeTraits.LEGACY_DEFAULTS;

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

@@ -5,8 +5,13 @@ import com.google.gson.GsonBuilder;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import java.util.Map;
+import java.util.List;
+import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceKey;
@@ -55,8 +60,36 @@ public final class AgeRuntimeProfiles {
         if (PROFILES.isEmpty()) {
             return AgeGenerationProfiles.select(seed);
         }
-        java.util.List<ResourceLocation> ids = PROFILES.keySet().stream().sorted().toList();
+        List<LegacyRankChoice.Option<ResourceLocation>> profiles = PROFILES.keySet().stream().sorted()
-        return ids.get(Math.floorMod(Long.hashCode(seed), ids.size()));
+                .map(id -> new LegacyRankChoice.Option<>(id, AgeGenerationProfiles.randomRank(id))).toList();
+        return LegacyRankChoice.choose(new Random(seed ^ 0x5445525241494E4CL), profiles);
+    }
+
+    /** Keep seed-selected terrain random, but only among profiles able to host authored features. */
+    public static ResourceLocation selectForWriting(long seed, OrderedWriting writing, RegistryAccess registries) {
+        ResourceLocation selected = select(seed);
+        WritingGrammar.Result parsed = WritingGrammar.parse(writing);
+        if (parsed.activeSymbols().stream().anyMatch(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)) return selected;
+        List<ResourceLocation> features = parsed.activeSymbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
+        boolean hasMaterial = parsed.activeSymbols().stream().anyMatch(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.BLOCK);
+        if ((features.isEmpty() && !hasMaterial) || PROFILES.isEmpty()) return selected;
+        AgeRuntimeProfile initial = PROFILES.get(selected);
+        if (initial != null && features.stream().allMatch(id ->
+                AgeFeatureSelection.error(id, initial, registries) == null)
+                && AgeFeatureSelection.supportsUnpairedMaterials(
+                        new WritingGrammar.Result(parsed.activeSymbols(), parsed.diagnostics()), initial)) return selected;
+        List<ResourceLocation> compatible = PROFILES.entrySet().stream()
+                .filter(entry -> features.stream().allMatch(id ->
+                        AgeFeatureSelection.error(id, entry.getValue(), registries) == null)
+                        && AgeFeatureSelection.supportsUnpairedMaterials(
+                                new WritingGrammar.Result(parsed.activeSymbols(), parsed.diagnostics()), entry.getValue()))
+                .map(Map.Entry::getKey).sorted().toList();
+        return compatible.isEmpty() ? selected
+                : compatible.get(Math.floorMod(Long.hashCode(seed), compatible.size()));
     }
 
     static AgeRuntimeProfile parse(ResourceLocation id, JsonElement json, RegistryAccess registries) {

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

@@ -0,0 +1,70 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.Locale;
+import java.util.Random;
+import java.util.List;
+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 ? LegacyRankChoice.choose(new Random(ageSeed ^ RANDOM_SALT), List.of(
+                new LegacyRankChoice.Option<>(SEASONS, 1),
+                new LegacyRankChoice.Option<>(NO_SEASONS, 2),
+                new LegacyRankChoice.Option<>(ETERNAL_WINTER, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_SUMMER, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_FALL, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_SPRING, 3))) : 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.activeSymbols().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.activeSymbols().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/AgeStatusEffectGameTests.java

@@ -0,0 +1,94 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.level.GameType;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Focused mapping, targeting, and isolation checks for issue #67. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class AgeStatusEffectGameTests {
+    private AgeStatusEffectGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void legacyPotionMappingRetainsShortDurationsAndSkyRule(GameTestHelper helper) {
+        helper.assertValueEqual(AgeStatusEffectProviders.legacyDuration(id("wither")), 30,
+                "Legacy Wither lasts only 30 ticks per application");
+        helper.assertValueEqual(AgeStatusEffectProviders.legacyDuration(id("poison_global")), 80,
+                "Global Poison retains Legacy's 80-tick duration");
+        helper.assertValueEqual(AgeStatusEffectProviders.legacyDuration(id("enemyregen_global")), 200,
+                "The enemy regeneration card retains its 200-tick duration");
+        helper.assertTrue(AgeStatusEffectProviders.localRequiresSky(id("poison"))
+                        && !AgeStatusEffectProviders.localRequiresSky(id("poison_global")),
+                "Only local potion cards require open sky");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void generalDebuffsIncludeLivingEntitiesButCreativePlayersAreExempt(GameTestHelper helper) {
+        var player = helper.makeMockPlayer(GameType.SURVIVAL);
+        var cow = helper.spawnWithNoFreeWill(EntityType.COW, new BlockPos(1, 1, 1));
+        var hostile = helper.spawnWithNoFreeWill(EntityType.SPIDER, new BlockPos(2, 1, 1));
+        helper.assertTrue(player.isAlive(), "Mock survival player must be alive");
+        helper.assertTrue(player.level() == helper.getLevel(), "Mock survival player must be in the test level");
+        helper.assertTrue(!player.isCreative() && !player.isSpectator(),
+                "Mock survival player must not be creative or spectator");
+        helper.assertTrue(RivencraftConfig.statusEffectsPlayers(), "Player status effects must be enabled");
+        helper.assertTrue(AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), player, id("poison_global")),
+                "A survival player is eligible for a general Legacy debuff");
+        helper.assertTrue(AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), cow, id("poison_global")),
+                "General Legacy debuffs are not limited to players");
+        helper.assertTrue(hostile.isAlive() && hostile.level() == helper.getLevel(),
+                "Mock hostile mob must be alive in the test level");
+        helper.assertTrue(RivencraftConfig.statusEffectsHostiles(), "Hostile status effects must be enabled");
+        helper.assertTrue(hostile.getEffect(MobEffects.REGENERATION) == null,
+                "Mock hostile mob must not already have regeneration");
+        helper.assertTrue(hostile.canBeAffected(new MobEffectInstance(MobEffects.REGENERATION, 200, 0)),
+                "Mock hostile mob must accept regeneration");
+        helper.assertTrue(AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), hostile,
+                        id("enemyregen_global")), "Hostile mobs can receive the enemy buff");
+        helper.assertTrue(!AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), cow,
+                        id("enemyregen_global")), "Passive mobs do not receive the adapted enemy buff");
+        var creative = helper.makeMockPlayer(GameType.CREATIVE);
+        helper.assertTrue(!AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), creative,
+                        id("poison_global")), "Creative players must be exempt");
+        var spectator = helper.makeMockPlayer(GameType.SPECTATOR);
+        helper.assertTrue(!AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), spectator,
+                        id("poison_global")), "Spectators must be exempt");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void overworldCannotRunAnAgeStatusProvider(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        player.setGameMode(GameType.SURVIVAL);
+        UUID ageId = UUID.randomUUID();
+        AgeDefinition age = new AgeDefinition(ageId, "Isolated", 100L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(ageId), null,
+                AgeTraits.LEGACY_DEFAULTS);
+        AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(1);
+        var context = new AgeInstabilityRuntime.Context(helper.getLevel(), age,
+                List.of(player.chunkPosition()), helper.getLevel().getServer().getTickCount(), budget);
+        AgeStatusEffectProviders.apply(context, id("poison_global"), 1);
+        helper.assertTrue(player.getEffect(MobEffects.POISON) == null,
+                "An Age provider must not apply in the Overworld");
+        helper.assertValueEqual(budget.remaining(), 1,
+                "A rejected cross-world attempt must not consume the Age budget");
+        helper.succeed();
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+}

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

@@ -0,0 +1,218 @@
+package net.dnorberg.rivencraft.book;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.Holder;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.entity.EntityTypeTest;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.event.entity.EntityTravelToDimensionEvent;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.ServerTickEvent;
+
+/** Legacy potion cards adapted to bounded, Age-local server effects. */
+public final class AgeStatusEffectProviders {
+    private static final int MAX_TRACKED_AGES = 64;
+    private static final Map<ResourceLocation, Spec> SPECS = createSpecs();
+    private static final Map<ServerLevel, List<Lease>> LEASES = new WeakHashMap<>();
+
+    private AgeStatusEffectProviders() {}
+
+    public static void register() {
+        SPECS.keySet().forEach(id -> AgeInstabilityRuntime.register(id, false, AgeStatusEffectProviders::apply));
+    }
+
+    static void apply(AgeInstabilityRuntime.Context context, ResourceLocation id, int level) {
+        if (!RivencraftConfig.statusEffectsEnabled()
+                || !AgeInstabilityRuntime.isAgeDimension(context.level().dimension().location())
+                || !context.age().dimensionId().equals(context.level().dimension().location())) return;
+        Spec spec = SPECS.get(id);
+        if (spec == null || spec.target() == Target.HOSTILE && !RivencraftConfig.statusEffectsHostiles()
+                || spec.target() == Target.GENERAL && !RivencraftConfig.statusEffectsPlayers()
+                && !RivencraftConfig.statusEffectsNonplayers()) return;
+        List<Lease> leases = LEASES.get(context.level());
+        if (leases == null) {
+            if (LEASES.size() >= MAX_TRACKED_AGES) return;
+            leases = new ArrayList<>();
+            LEASES.put(context.level(), leases);
+        }
+        prune(context.level(), leases, context.serverTick(), false);
+        if (leases.size() >= RivencraftConfig.statusEffectsMaxActive()) return;
+
+        Random random = new Random(context.age().seed() ^ (context.serverTick() * 0x9E3779B97F4A7C15L)
+                ^ id.hashCode());
+        ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+        AABB bounds = new AABB(chunk.getMinBlockX(), context.level().getMinBuildHeight(), chunk.getMinBlockZ(),
+                chunk.getMaxBlockX() + 1, context.level().getMaxBuildHeight(), chunk.getMaxBlockZ() + 1);
+        int duration = Math.min(spec.legacyDuration(), RivencraftConfig.statusEffectsMaxDuration());
+        int amplifier = Math.max(0, level - 1);
+        MobEffectInstance instance = new MobEffectInstance(spec.effect(), duration, amplifier);
+        List<LivingEntity> candidates = new ArrayList<>();
+        context.level().getEntities(EntityTypeTest.forClass(LivingEntity.class), bounds,
+                entity -> eligible(context.level(), entity, spec, instance), candidates,
+                RivencraftConfig.statusEffectsMaxCandidates());
+        if (candidates.isEmpty()) return;
+        candidates.sort(Comparator.comparing(Entity::getUUID));
+        LivingEntity target = candidates.get(random.nextInt(candidates.size()));
+        if (!context.budget().claim() || !target.addEffect(instance)) return;
+        leases.add(new Lease(new WeakReference<>(target), instance,
+                context.serverTick() + duration, spec.target()));
+    }
+
+    private static boolean eligible(ServerLevel level, LivingEntity entity, Spec spec,
+                                    MobEffectInstance instance) {
+        if (!entity.isAlive() || entity.isRemoved() || entity.level() != level
+                || entity.getEffect(spec.effect()) != null || !entity.canBeAffected(instance)
+                || !spec.global() && !level.canSeeSky(entity.blockPosition())) return false;
+        return allowedByPolicy(spec.target(), entity);
+    }
+
+    private static boolean allowedByPolicy(Target target, LivingEntity entity) {
+        if (entity instanceof Player player) {
+            return target == Target.GENERAL && RivencraftConfig.statusEffectsPlayers()
+                    && !player.isCreative() && !player.isSpectator();
+        }
+        return target == Target.GENERAL ? RivencraftConfig.statusEffectsNonplayers()
+                : entity instanceof Monster && RivencraftConfig.statusEffectsHostiles();
+    }
+
+    public static void onServerTickPost(ServerTickEvent.Post event) {
+        if (event.getServer().getTickCount() % 20 != 0) return;
+        boolean disabled = !RivencraftConfig.instabilityEnabled() || !RivencraftConfig.statusEffectsEnabled();
+        long tick = event.getServer().getTickCount();
+        for (var entry : LEASES.entrySet()) prune(entry.getKey(), entry.getValue(), tick, disabled);
+        LEASES.values().removeIf(List::isEmpty);
+    }
+
+    public static void onEntityTravel(EntityTravelToDimensionEvent event) {
+        Entity entity = event.getEntity();
+        if (entity instanceof LivingEntity living && !entity.level().dimension().equals(event.getDimension())) {
+            clearEntity(living);
+        }
+    }
+
+    public static void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) clearEntity(player);
+    }
+
+    public static void onPlayerLoggedOut(PlayerEvent.PlayerLoggedOutEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) clearEntity(player);
+    }
+
+    public static void onServerStopping(ServerStoppingEvent event) {
+        long tick = event.getServer().getTickCount();
+        for (var entry : LEASES.entrySet()) prune(entry.getKey(), entry.getValue(), tick, true);
+        LEASES.clear();
+    }
+
+    private static void clearEntity(LivingEntity entity) {
+        for (List<Lease> leases : LEASES.values()) {
+            Iterator<Lease> iterator = leases.iterator();
+            while (iterator.hasNext()) {
+                Lease lease = iterator.next();
+                if (lease.entity().get() != entity) continue;
+                removeOwnedEffect(entity, lease);
+                iterator.remove();
+            }
+        }
+    }
+
+    private static void prune(ServerLevel level, List<Lease> leases, long tick, boolean removeAll) {
+        Iterator<Lease> iterator = leases.iterator();
+        while (iterator.hasNext()) {
+            Lease lease = iterator.next();
+            LivingEntity entity = lease.entity().get();
+            if (entity == null || entity.isRemoved() || entity.getEffect(lease.instance().getEffect()) == null) {
+                iterator.remove();
+                continue;
+            }
+            boolean revoke = removeAll || entity.level() != level
+                    || !allowedByPolicy(lease.target(), entity);
+            if (revoke || tick >= lease.expiresAt()) {
+                removeOwnedEffect(entity, lease);
+                iterator.remove();
+            }
+        }
+    }
+
+    private static void removeOwnedEffect(LivingEntity entity, Lease lease) {
+        // addEffect stores the supplied instance when no effect exists. Do not remove
+        // a replacement from another mod (or a stronger/extended effect).
+        if (entity.getEffect(lease.instance().getEffect()) == lease.instance()
+                && lease.instance().getAmplifier() == lease.amplifier()
+                && lease.instance().getDuration() <= lease.originalDuration()) {
+            entity.removeEffect(lease.instance().getEffect());
+        }
+    }
+
+    static int legacyDuration(ResourceLocation id) {
+        Spec spec = SPECS.get(id);
+        return spec == null ? -1 : spec.legacyDuration();
+    }
+
+    static boolean localRequiresSky(ResourceLocation id) {
+        Spec spec = SPECS.get(id);
+        return spec != null && !spec.global();
+    }
+
+    static boolean eligibleTarget(ServerLevel level, LivingEntity entity, ResourceLocation id) {
+        Spec spec = SPECS.get(id);
+        return spec != null && eligible(level, entity, spec,
+                new MobEffectInstance(spec.effect(), spec.legacyDuration(), 0));
+    }
+
+    private static Map<ResourceLocation, Spec> createSpecs() {
+        Map<ResourceLocation, Spec> specs = new HashMap<>();
+        addPair(specs, "blindness", MobEffects.BLINDNESS, 60);
+        addPair(specs, "fatigue", MobEffects.DIG_SLOWDOWN, 80);
+        addPair(specs, "hunger", MobEffects.HUNGER, 80);
+        addPair(specs, "nausea", MobEffects.CONFUSION, 60);
+        addPair(specs, "poison", MobEffects.POISON, 80);
+        addPair(specs, "slow", MobEffects.MOVEMENT_SLOWDOWN, 80);
+        addPair(specs, "weakness", MobEffects.WEAKNESS, 80);
+        addPair(specs, "wither", MobEffects.WITHER, 30);
+        specs.put(id("enemyregen_global"), new Spec(MobEffects.REGENERATION, 200, true, Target.HOSTILE));
+        specs.put(id("enemyresist_global"), new Spec(MobEffects.DAMAGE_RESISTANCE, 200, true, Target.HOSTILE));
+        return Map.copyOf(specs);
+    }
+
+    private static void addPair(Map<ResourceLocation, Spec> specs, String name,
+                                Holder<MobEffect> effect, int duration) {
+        specs.put(id(name), new Spec(effect, duration, false, Target.GENERAL));
+        specs.put(id(name + "_global"), new Spec(effect, duration, true, Target.GENERAL));
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private enum Target { GENERAL, HOSTILE }
+    private record Spec(Holder<MobEffect> effect, int legacyDuration, boolean global, Target target) {}
+    private record Lease(WeakReference<LivingEntity> entity, MobEffectInstance instance, long expiresAt,
+                         Target target, int amplifier, int originalDuration) {
+        private Lease(WeakReference<LivingEntity> entity, MobEffectInstance instance, long expiresAt,
+                      Target target) {
+            this(entity, instance, expiresAt, target, instance.getAmplifier(), instance.getDuration());
+        }
+    }
+}

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

@@ -0,0 +1,100 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.levelgen.structure.BuiltinStructureSets;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Authored structure pages gate their own structure sets without enabling unrelated structures. */
+@GameTestHolder("rivencraft_archive_generation")
+@PrefixGameTestTemplate(false)
+public final class AgeStructureGameTests {
+    private static final Map<String, ResourceLocation> SETS = Map.ofEntries(
+            Map.entry("mineshafts", BuiltinStructureSets.MINESHAFTS.location()),
+            Map.entry("nether_fortresses", id("fortresses")),
+            Map.entry("strongholds", BuiltinStructureSets.STRONGHOLDS.location()),
+            Map.entry("villages", BuiltinStructureSets.VILLAGES.location()),
+            Map.entry("trial_chambers", BuiltinStructureSets.TRIAL_CHAMBERS.location()),
+            Map.entry("bastions", id("bastions")),
+            Map.entry("buried_treasure", BuiltinStructureSets.BURIED_TREASURES.location()),
+            Map.entry("shipwrecks", BuiltinStructureSets.SHIPWRECKS.location()),
+            Map.entry("ocean_ruins", BuiltinStructureSets.OCEAN_RUINS.location()),
+            Map.entry("pillager_outposts", BuiltinStructureSets.PILLAGER_OUTPOSTS.location()),
+            Map.entry("ruined_portals", BuiltinStructureSets.RUINED_PORTALS.location()),
+            Map.entry("nether_fossils", BuiltinStructureSets.NETHER_FOSSILS.location()),
+            Map.entry("ancient_cities", BuiltinStructureSets.ANCIENT_CITIES.location()),
+            Map.entry("trail_ruins", BuiltinStructureSets.TRAIL_RUINS.location()));
+
+    private AgeStructureGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void structurePagesGateDistinctVanillaSets(GameTestHelper helper) {
+        var lookup = helper.getLevel().registryAccess().lookupOrThrow(Registries.STRUCTURE_SET);
+        for (var entry : SETS.entrySet()) {
+            var setKey = ResourceKey.create(Registries.STRUCTURE_SET, entry.getValue());
+            helper.assertTrue(lookup.get(setKey).isPresent(), entry.getKey() + " needs a registered structure set");
+            var filtered = AgeStructureSelection.filteredLookup(lookup,
+                    List.of(new AgeFeatureSelection.Choice(id(entry.getKey()), Optional.empty())));
+            helper.assertTrue(filtered.get(setKey).isPresent(), entry.getKey() + " must enable its structure set");
+            helper.assertTrue(filtered.get(ResourceKey.create(Registries.STRUCTURE_SET,
+                    BuiltinStructureSets.NETHER_COMPLEXES.location())).isEmpty(),
+                    "Vanilla Nether complexes must stay disabled to keep fortresses and bastions separate");
+            for (var other : SETS.entrySet()) {
+                if (other.getKey().equals(entry.getKey())) continue;
+                helper.assertTrue(filtered.get(ResourceKey.create(Registries.STRUCTURE_SET,
+                        other.getValue())).isEmpty(),
+                        entry.getKey() + " must not enable " + other.getKey());
+            }
+        }
+        helper.assertTrue(AgeStructureSelection.filteredLookup(lookup, List.of()).listElements()
+                        .noneMatch(holder -> SETS.containsValue(holder.key().location())),
+                "An Age without structure pages must not inherit these structures from vanilla biomes");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void authoredPagesPersistAndRejectIncompatibleTerrain(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        OrderedWriting written = new OrderedWriting(List.of(WritingEntry.linkPanel(), page("terrain/standard"),
+                page("biome/plains"), page("biome/single"), page("feature/mineshafts"),
+                page("feature/villages"), page("feature/trial_chambers")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(written, 149L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(149L), registries);
+        List<AgeFeatureSelection.Choice> expected = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(expected.stream().map(AgeFeatureSelection.Choice::id).toList(),
+                List.of(id("mineshafts"), id("villages"), id("trial_chambers")),
+                "Authored structure pages must retain their order");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), expected,
+                "Authored structure choices must survive an Age plan reload");
+        var filtered = AgeStructureSelection.filteredLookup(registries.lookupOrThrow(Registries.STRUCTURE_SET), expected);
+        helper.assertTrue(filtered.get(ResourceKey.create(Registries.STRUCTURE_SET,
+                BuiltinStructureSets.VILLAGES.location())).isPresent(), "Village set must be enabled");
+        helper.assertTrue(filtered.get(ResourceKey.create(Registries.STRUCTURE_SET,
+                BuiltinStructureSets.PILLAGER_OUTPOSTS.location())).isEmpty(), "Unwritten outposts must stay disabled");
+        String error = AgeStructureSelection.error(id("bastions"),
+                AgeRuntimeProfiles.profiles().get(id("standard")), null, registries);
+        helper.assertTrue(error != null && error.contains("Cave terrain"),
+                "Bastion page must not silently run on Standard terrain");
+        helper.succeed();
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private static WritingEntry page(String path) {
+        return WritingEntry.symbol(new SymbolReference(id(path)));
+    }
+}

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

@@ -0,0 +1,180 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import java.util.Random;
+import java.util.Set;
+import java.util.stream.Stream;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.levelgen.structure.BuiltinStructureSets;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
+
+/** Frozen Age structure-page choices and their vanilla structure-set gate. */
+public final class AgeStructureSelection {
+    private static final ResourceLocation FORTRESSES = ResourceLocation.fromNamespaceAndPath("rivencraft", "fortresses");
+    private static final ResourceLocation BASTIONS = ResourceLocation.fromNamespaceAndPath("rivencraft", "bastions");
+    private static final List<ResourceLocation> FEATURES = List.of(
+            id("dungeons"), id("mineshafts"), id("nether_fortresses"), id("strongholds"),
+            id("villages"), id("trial_chambers"), id("bastions"), id("buried_treasure"),
+            id("shipwrecks"), id("ocean_ruins"), id("pillager_outposts"), id("ruined_portals"),
+            id("nether_fossils"), id("ancient_cities"), id("trail_ruins"));
+    private static final Map<ResourceLocation, ResourceLocation> STRUCTURE_SETS = Map.ofEntries(
+            Map.entry(id("mineshafts"), BuiltinStructureSets.MINESHAFTS.location()),
+            Map.entry(id("nether_fortresses"), FORTRESSES),
+            Map.entry(id("strongholds"), BuiltinStructureSets.STRONGHOLDS.location()),
+            Map.entry(id("villages"), BuiltinStructureSets.VILLAGES.location()),
+            Map.entry(id("trial_chambers"), BuiltinStructureSets.TRIAL_CHAMBERS.location()),
+            Map.entry(id("bastions"), BASTIONS),
+            Map.entry(id("buried_treasure"), BuiltinStructureSets.BURIED_TREASURES.location()),
+            Map.entry(id("shipwrecks"), BuiltinStructureSets.SHIPWRECKS.location()),
+            Map.entry(id("ocean_ruins"), BuiltinStructureSets.OCEAN_RUINS.location()),
+            Map.entry(id("pillager_outposts"), BuiltinStructureSets.PILLAGER_OUTPOSTS.location()),
+            Map.entry(id("ruined_portals"), BuiltinStructureSets.RUINED_PORTALS.location()),
+            Map.entry(id("nether_fossils"), BuiltinStructureSets.NETHER_FOSSILS.location()),
+            Map.entry(id("ancient_cities"), BuiltinStructureSets.ANCIENT_CITIES.location()),
+            Map.entry(id("trail_ruins"), BuiltinStructureSets.TRAIL_RUINS.location()));
+    private static final Set<ResourceLocation> CONTROLLED_SETS = Set.of(
+            BuiltinStructureSets.MINESHAFTS.location(), BuiltinStructureSets.NETHER_COMPLEXES.location(),
+            BuiltinStructureSets.STRONGHOLDS.location(), BuiltinStructureSets.VILLAGES.location(),
+            BuiltinStructureSets.TRIAL_CHAMBERS.location(), FORTRESSES, BASTIONS,
+            BuiltinStructureSets.BURIED_TREASURES.location(), BuiltinStructureSets.SHIPWRECKS.location(),
+            BuiltinStructureSets.OCEAN_RUINS.location(), BuiltinStructureSets.PILLAGER_OUTPOSTS.location(),
+            BuiltinStructureSets.RUINED_PORTALS.location(), BuiltinStructureSets.NETHER_FOSSILS.location(),
+            BuiltinStructureSets.ANCIENT_CITIES.location(), BuiltinStructureSets.TRAIL_RUINS.location());
+
+    private AgeStructureSelection() {}
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath("rivencraft", path);
+    }
+
+    public static boolean feature(ResourceLocation id) {
+        return FEATURES.contains(id);
+    }
+
+    public static boolean dungeons(ResourceLocation id) {
+        return id.equals(id("dungeons"));
+    }
+
+    private static ResourceLocation setId(ResourceLocation feature) {
+        return STRUCTURE_SETS.get(feature);
+    }
+
+    public static String error(ResourceLocation feature, AgeRuntimeProfile profile,
+                               AgeBiomeSelection biomes, RegistryAccess registries) {
+        if (!feature(feature)) return "Unsupported structure feature " + feature;
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+            return "Feature " + feature + " requires terrain, not Void";
+        if (dungeons(feature)) {
+            if (profile.terrain() != AgeRuntimeProfile.Terrain.NOISE)
+                return "Feature " + feature + " needs enclosed noise terrain, not Flat";
+            return placedExists(registries, id("dungeons")) ? null
+                    : "Feature " + feature + " requires missing placed feature rivencraft:dungeons";
+        }
+        if (!feature.equals(id("villages")) && !feature.equals(id("strongholds"))
+                && profile.terrain() != AgeRuntimeProfile.Terrain.NOISE)
+            return "Feature " + feature + " needs noise terrain, not Flat";
+        if (feature.equals(id("nether_fortresses")) || feature.equals(id("bastions"))
+                || feature.equals(id("nether_fossils"))) {
+            if (!AgeBiomeSelection.isCave(profile))
+                return "Feature " + feature + " requires Cave terrain with a Nether biome";
+        } else if (feature.equals(id("villages")) || feature.equals(id("strongholds"))
+                || feature.equals(id("buried_treasure")) || feature.equals(id("shipwrecks"))
+                || feature.equals(id("ocean_ruins")) || feature.equals(id("pillager_outposts"))
+                || feature.equals(id("trail_ruins"))) {
+            if (AgeBiomeSelection.isCave(profile))
+                return "Feature " + feature + " requires surface terrain, not Cave";
+        }
+        ResourceLocation setId = setId(feature);
+        var set = registries.lookupOrThrow(Registries.STRUCTURE_SET)
+                .get(ResourceKey.create(Registries.STRUCTURE_SET, setId));
+        if (set.isEmpty()) return "Feature " + feature + " requires missing structure set " + setId;
+        if (biomes == null) return null;
+        Set<ResourceLocation> selected = Set.copyOf(biomes.biomes());
+        boolean compatible = set.orElseThrow().value().structures().stream()
+                .flatMap(entry -> entry.structure().value().biomes().stream())
+                .map(holder -> holder.unwrapKey().map(ResourceKey::location).orElse(null))
+                .anyMatch(selected::contains);
+        return compatible ? null : "Feature " + feature
+                + " needs at least one biome allowed by structure set " + setId;
+    }
+
+    private static boolean placedExists(RegistryAccess registries, ResourceLocation id) {
+        return registries.lookupOrThrow(Registries.PLACED_FEATURE)
+                .get(ResourceKey.create(Registries.PLACED_FEATURE, id)).isPresent();
+    }
+
+    public static List<AgeFeatureSelection.Choice> randomChoices(long ageSeed, AgeRuntimeProfile profile,
+                                                                   AgeBiomeSelection biomes, RegistryAccess registries) {
+        List<LegacyRankChoice.Option<ResourceLocation>> eligible = new ArrayList<>(FEATURES.stream()
+                .filter(id -> error(id, profile, biomes, registries) == null)
+                .map(id -> new LegacyRankChoice.Option<>(id, randomRank(id))).toList());
+        Random random = new Random(ageSeed ^ 0x5354525543545552L);
+        int count = random.nextInt(3);
+        List<AgeFeatureSelection.Choice> choices = new ArrayList<>();
+        while (choices.size() < count && !eligible.isEmpty()) {
+            ResourceLocation selected = LegacyRankChoice.choose(random, eligible);
+            choices.add(new AgeFeatureSelection.Choice(selected, Optional.empty()));
+            eligible.removeIf(option -> option.value().equals(selected));
+        }
+        return List.copyOf(choices);
+    }
+
+    static int randomRank(ResourceLocation feature) {
+        if (feature.equals(id("villages")) || feature.equals(id("strongholds"))
+                || feature.equals(id("mineshafts"))) return 1;
+        if (feature.equals(id("dungeons")) || feature.equals(id("nether_fortresses"))) return 2;
+        return 3; // Structures added after Legacy are uncommon, but still discoverable.
+    }
+
+    private static Set<ResourceLocation> enabledSets(List<AgeFeatureSelection.Choice> choices) {
+        return choices.stream().filter(choice -> feature(choice.id()) && !dungeons(choice.id()))
+                .map(choice -> setId(choice.id())).collect(java.util.stream.Collectors.toUnmodifiableSet());
+    }
+
+    public static Stream<Holder<StructureSet>> allowedSets(Stream<Holder<StructureSet>> sets,
+                                                            List<AgeFeatureSelection.Choice> choices) {
+        Set<ResourceLocation> enabled = enabledSets(choices);
+        return sets.filter(holder -> holder.unwrapKey()
+                .map(key -> allowed(key.location(), enabled)).orElse(false));
+    }
+
+    public static HolderLookup<StructureSet> filteredLookup(HolderLookup<StructureSet> lookup,
+                                                             List<AgeFeatureSelection.Choice> choices) {
+        Set<ResourceLocation> enabled = enabledSets(choices);
+        return new HolderLookup<>() {
+            @Override
+            public Optional<Holder.Reference<StructureSet>> get(ResourceKey<StructureSet> key) {
+                return allowed(key.location(), enabled) ? lookup.get(key) : Optional.empty();
+            }
+
+            @Override
+            public Optional<HolderSet.Named<StructureSet>> get(TagKey<StructureSet> key) {
+                return lookup.get(key);
+            }
+
+            @Override
+            public Stream<Holder.Reference<StructureSet>> listElements() {
+                return lookup.listElements().filter(holder -> allowed(holder.key().location(), enabled));
+            }
+
+            @Override
+            public Stream<HolderSet.Named<StructureSet>> listTags() {
+                return lookup.listTags();
+            }
+        };
+    }
+
+    private static boolean allowed(ResourceLocation set, Set<ResourceLocation> enabled) {
+        return !CONTROLLED_SETS.contains(set) || enabled.contains(set);
+    }
+}

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

@@ -1,6 +1,7 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.Random;
+import java.util.List;
 
 /** Immutable random-Age traits selected once from the Age seed. */
 public record AgeTraits(
@@ -42,9 +43,30 @@ public record AgeTraits(
 
     public static AgeTraits select(long seed) {
         Random random = new Random(seed ^ 0x524956454E435241L);
-        BiomeDistribution biomeDistribution = randomChoice(random, BiomeDistribution.values());
+        BiomeDistribution biomeDistribution = LegacyRankChoice.choose(random, List.of(
-        Lighting lighting = randomChoice(random, Lighting.values());
+                new LegacyRankChoice.Option<>(BiomeDistribution.NATIVE, 1),
-        Weather weather = randomChoice(random, Weather.values());
+                new LegacyRankChoice.Option<>(BiomeDistribution.SINGLE, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.MEDIUM, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.TILED, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.GRID, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.TINY, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.SMALL, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.LARGE, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.HUGE, 2)));
+        Lighting lighting = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(Lighting.NORMAL, 1),
+                new LegacyRankChoice.Option<>(Lighting.DARK, 2),
+                new LegacyRankChoice.Option<>(Lighting.BRIGHT, 2)));
+        Weather weather = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(Weather.NORMAL, 1),
+                new LegacyRankChoice.Option<>(Weather.FAST, 2),
+                new LegacyRankChoice.Option<>(Weather.SLOW, 2),
+                new LegacyRankChoice.Option<>(Weather.OFF, 2),
+                new LegacyRankChoice.Option<>(Weather.ALWAYS, 2),
+                new LegacyRankChoice.Option<>(Weather.CLOUDY, 2),
+                new LegacyRankChoice.Option<>(Weather.RAIN, 2),
+                new LegacyRankChoice.Option<>(Weather.SNOW, 2),
+                new LegacyRankChoice.Option<>(Weather.STORM, 2)));
         // Legacy's PERIOD_BASIC grammar gives ModZero rank 2 and its other
         // three length modifiers rank 1, producing an effective 1-in-7 weight.
         boolean stopped = random.nextInt(7) == 0;
@@ -77,10 +99,6 @@ public record AgeTraits(
         }
     }
 
-    private static <E> E randomChoice(Random random, E[] values) {
-        return values[random.nextInt(values.length)];
-    }
-
     public enum BiomeDistribution {
         NATIVE, SINGLE, TILED, GRID, TINY, SMALL, MEDIUM, LARGE, HUGE
     }

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

@@ -0,0 +1,27 @@
+package net.dnorberg.rivencraft.book;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class CloudPlatformGameTests {
+    private CloudPlatformGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void cloudIsSolidFootingWithoutAnObtainableItem(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        var state = ModBlocks.CLOUD_PLATFORM.get().defaultBlockState();
+        helper.getLevel().setBlock(pos, state, 2);
+        helper.assertTrue(!state.getCollisionShape(helper.getLevel(), pos).isEmpty(),
+                "Cloud platform must support a standing player");
+        helper.assertTrue(ModBlocks.CLOUD_PLATFORM.get().getCloneItemStack(helper.getLevel(), pos, state).isEmpty(),
+                "Cloud platform must not provide a pick-block item");
+        helper.succeed();
+    }
+}

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

@@ -6,11 +6,16 @@ import java.util.UUID;
 import java.util.stream.Collectors;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
+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;
@@ -22,6 +27,27 @@ import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 public final class EnvironmentWritingGameTests {
     private EnvironmentWritingGameTests() {}
 
+    @GameTest(template = "empty")
+    public static void caveBiomesHaveSeparateCreativePages(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        var biomePages = PageItem.creativeSymbolPages(registries,
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "biome"));
+        var cavePages = PageItem.creativeSymbolPages(registries,
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "cave_biome"));
+        helper.assertTrue(PageItem.bundledCreativeCategories().contains(
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "cave_biome")),
+                "The cave biome creative tab must be registered");
+        helper.assertTrue(biomePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/desert")), "Biome pages must remain in the Biome tab");
+        helper.assertTrue(cavePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/lush_caves")), "Cave biomes need their own tab");
+        helper.assertTrue(cavePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/crimson_forest")), "Nether biomes belong in the Cave tab");
+        helper.assertFalse(biomePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/lush_caves")), "Cave biomes must leave the general Biome tab");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void environmentPagesEnterCreativeAndJeiFeed(GameTestHelper helper) {
         Set<String> expected = Set.of(
@@ -29,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()
@@ -51,6 +79,62 @@ 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.assertTrue(WritingGrammar.parse(conflict).canCreate(),
+                "A repeated seasonal page must be recoverable as unstable writing");
+        helper.assertValueEqual(WritingGrammar.parse(conflict).writingInstability(), 500,
+                "The seasonal conflict must contribute instability");
+        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/book/FeatureWritingGameTests.java

@@ -0,0 +1,518 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeDenseOres;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.BlockSymbolPages;
+import net.dnorberg.rivencraft.writing.SymbolCatalog;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Issue #35: authored decorations must resolve to real placed features and survive plan reload. */
+@GameTestHolder("rivencraft_archive_generation")
+@PrefixGameTestTemplate(false)
+public final class FeatureWritingGameTests {
+    private FeatureWritingGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void featurePagesCompileToFrozenVanillaPlacements(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        Set<String> pages = Set.of("feature/caves", "feature/flowers", "feature/trees",
+                "feature/huge_trees", "feature/rocks", "feature/lava_lakes",
+                "feature/surface_lakes", "feature/deep_lakes", "feature/ravines",
+                "feature/floating_islands", "feature/tendrils", "feature/skylands",
+                "feature/spheres", "feature/spikes", "feature/dungeons",
+                "feature/mineshafts", "feature/nether_fortresses",
+                "feature/strongholds", "feature/villages", "feature/trial_chambers",
+                "feature/bastions", "feature/buried_treasure", "feature/shipwrecks",
+                "feature/ocean_ruins", "feature/pillager_outposts", "feature/ruined_portals",
+                "feature/nether_fossils", "feature/ancient_cities", "feature/trail_ruins",
+                "feature/dense_ores", "feature/obelisks", "feature/crystal_formations",
+                "feature/star_fissures");
+        helper.assertTrue(PageItem.bundledCreativeSymbols().containsAll(pages),
+                "Supported feature pages must appear in the creative and JEI symbol feed");
+        for (String path : pages) {
+            helper.assertTrue(PageItem.isUsableWriting(PageItem.createBundledCreativePage(path)),
+                    path + " must be usable in authored writing");
+        }
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                page("biome/plains"), page("biome/single"), page("feature/caves"), page("feature/flowers"),
+                page("feature/trees"), page("feature/rocks"), page("feature/lava_lakes")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), registries);
+        List<AgeFeatureSelection.Choice> resolved = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(resolved.stream().map(AgeFeatureSelection.Choice::id).toList(), List.of(
+                id("caves"), id("flowers"), id("trees"), id("rocks"), id("lava_lakes")),
+                "The compiled Age plan must keep feature order and exact semantic IDs");
+        for (AgeFeatureSelection.Choice choice : resolved) {
+            if (AgeFeatureSelection.isRock(choice.id()) || AgeFeatureSelection.isLake(choice.id())) {
+                helper.assertTrue(choice.material().isPresent()
+                                && AgeFeatureSelection.materialError(choice) == null,
+                        "Unmodified rocks and lakes must choose a valid material from the registry");
+            }
+        }
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())),
+                AgeFeatureSelection.resolved(plan), "Features must survive the saved-plan round trip");
+        for (AgeFeatureSelection.Choice choice : AgeFeatureSelection.resolved(plan)) {
+            if (AgeFeatureSelection.caves(choice.id()) || AgeFeatureSelection.ravines(choice.id())
+                    || AgeFeatureSelection.floatingIslands(choice.id())
+                    || AgeFeatureSelection.tendrils(choice.id())
+                    || AgeFeatureSelection.skylands(choice.id())
+                    || AgeFeatureSelection.spheres(choice.id())
+                    || AgeFeatureSelection.spikes(choice.id())
+                    || AgeFeatureSelection.obelisks(choice.id())
+                    || choice.id().equals(AgeFeatureSelection.CRYSTAL_FORMATIONS)
+                    || choice.id().equals(AgeFeatureSelection.STAR_FISSURES)
+                    || choice.id().equals(AgeDenseOres.ID)) continue;
+            var placement = AgeFeatureSelection.placedFeature(choice.id());
+            helper.assertTrue(registries.lookupOrThrow(Registries.PLACED_FEATURE)
+                            .get(ResourceKey.create(Registries.PLACED_FEATURE, placement)).isPresent(),
+                    choice.id() + " must map to an existing vanilla placed feature");
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void unsupportedFeaturesAndTerrainsFailBeforeBinding(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        helper.assertTrue(AgeFeatureSelection.error(id("unknown"),
+                        AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD), registries)
+                        .contains("Unsupported feature"),
+                "Unimplemented feature meanings must report a diagnostic");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/flat"), page("feature/flowers"))),
+                "requires surface noise terrain");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/flat"), page("feature/caves"))),
+                "requires noise terrain");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/cave"), page("feature/lava_lakes"))),
+                "requires surface noise terrain");
+        helper.assertTrue(AgeGenerationPlan.compile(new OrderedWriting(List.of(panel(),
+                        page("terrain/cave"), page("feature/caves"))), 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), registries) != null,
+                "Caves must add carving to Cave terrain as well as surface noise terrain");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                page("biome/nether_wastes"), page("biome/single"), page("feature/trees"))),
+                "surface Overworld biome");
+        helper.assertTrue(AgeFeatureSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(
+                        new OrderedWriting(List.of(panel(), page("terrain/standard"), page("feature/flowers")))),
+                AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD),
+                AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(
+                                new OrderedWriting(List.of(panel(), page("terrain/standard"), page("feature/flowers")))),
+                        AgeTraits.select(87L), AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD),
+                87L, registries), registries, 87L).contains(choice("flowers")),
+                "A valid surface feature must still compile");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void floatingIslandsAreAdditiveAcrossSupportedTerrains(GameTestHelper helper) {
+        for (String terrain : List.of("standard", "amplified", "flat", "void")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/" + terrain),
+                    page("feature/floating_islands")));
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 450L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(450L), helper.getLevel().registryAccess());
+            helper.assertValueEqual(plan.authoredTerrain(), id(terrain),
+                    "Floating Islands must not replace the terrain page");
+            List<AgeFeatureSelection.Choice> resolved = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(resolved.stream().map(AgeFeatureSelection.Choice::id).toList(),
+                    List.of(id("floating_islands")),
+                    "The island feature must be frozen independently of terrain");
+            helper.assertTrue(resolved.getFirst().material().isPresent()
+                            && AgeFeatureSelection.materialError(resolved.getFirst()) == null,
+                    "An unmodified island feature must choose a valid full-block material");
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())),
+                    resolved, "The seeded island material must survive an Age reload");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                page("feature/floating_islands"))), "cannot form above Cave terrain");
+        OrderedWriting materialWriting = new OrderedWriting(List.of(panel(), page("terrain/flat"),
+                block("glowstone"), page("feature/floating_islands")));
+        AgeGenerationPlan materialPlan = AgeGenerationPlan.compile(materialWriting, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeFeatureSelection.resolved(materialPlan), List.of(
+                new AgeFeatureSelection.Choice(id("floating_islands"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("glowstone")))),
+                "A preceding full-block page must set the island interior");
+        AgeGenerationPlan randomPlan = AgeGenerationPlan.compile(new OrderedWriting(List.of(panel())),
+                450L, AgeGenerationProfiles.STANDARD, AgeTraits.select(450L),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeFeatureSelection.resolved(randomPlan), List.of(),
+                "A page-free plan must not implicitly author Floating Islands");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void tendrilsAreAuthoredAndCanAppearInRandomAges(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        AgeRuntimeProfiles.profiles().forEach((profileId, profile) ->
+                helper.assertTrue(AgeFeatureSelection.error(id("tendrils"), profile, registries) == null,
+                        "Tendrils must support loaded terrain profile " + profileId));
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/" + terrain),
+                    page("feature/tendrils")));
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 450L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(450L), registries);
+            List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(choices.size(), 1, "Tendrils must compile on " + terrain + " terrain");
+            helper.assertValueEqual(choices.getFirst().id(), id("tendrils"),
+                    "Tendrils must not replace the terrain page");
+            helper.assertTrue(choices.getFirst().material().isPresent()
+                            && AgeFeatureSelection.materialError(choices.getFirst()) == null,
+                    "Unmodified Tendrils must choose a full-block material");
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                    "The Tendrils material must survive a plan reload");
+        }
+        OrderedWriting materialWriting = new OrderedWriting(List.of(panel(), page("terrain/void"),
+                block("glowstone"), page("feature/tendrils")));
+        AgeGenerationPlan materialPlan = AgeGenerationPlan.compile(materialWriting, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), registries);
+        helper.assertValueEqual(AgeFeatureSelection.resolved(materialPlan), List.of(
+                new AgeFeatureSelection.Choice(id("tendrils"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("glowstone")))),
+                "A preceding Block page must set the Tendrils material");
+        var caveProfile = AgeRuntimeProfiles.resolve(id("cave"));
+        boolean found = false;
+        for (long seed = 0; seed < 12; seed++) {
+            List<AgeFeatureSelection.Choice> random = AgeFeatureSelection.randomChoices(seed, caveProfile, registries);
+            helper.assertTrue(random.stream().allMatch(choice -> AgeFeatureSelection.tendrils(choice.id())
+                            || AgeFeatureSelection.spheres(choice.id())
+                            || AgeFeatureSelection.skylands(choice.id())
+                            || choice.id().equals(AgeFeatureSelection.STAR_FISSURES)
+                            || AgeStructureSelection.feature(choice.id())),
+                    "Cave random Ages must only choose compatible features, including Star Fissures");
+            if (random.stream().anyMatch(choice -> AgeFeatureSelection.tendrils(choice.id()))) found = true;
+        }
+        helper.assertTrue(found, "A page-free random Cave Age must be able to roll Tendrils");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void skylandsFiltersBaseTerrainIndependentlyOfIslandFeatures(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/" + terrain),
+                    page("feature/skylands"), page("feature/floating_islands")));
+            if (terrain.equals("cave")) {
+                writing = new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                        page("feature/skylands")));
+            }
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 707L,
+                    AgeGenerationProfiles.STANDARD, AgeTraits.select(707L), registries);
+            List<AgeFeatureSelection.Choice> resolved = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(resolved.getFirst(), new AgeFeatureSelection.Choice(
+                            id("skylands"), Optional.empty()),
+                    "Skylands must be a separate material-free feature on " + terrain);
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), resolved,
+                    "Skylands and any Floating Islands page must survive a plan reload");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("stone"), page("feature/skylands"))), "cannot consume a material page");
+        List<AgeFeatureSelection.Choice> randomNoise = AgeFeatureSelection.randomChoices(7L,
+                AgeRuntimeProfiles.resolve(id("standard")), registries);
+        helper.assertTrue(randomNoise.stream().anyMatch(choice -> AgeFeatureSelection.skylands(choice.id())
+                        && choice.material().isEmpty()),
+                "A page-free random noise Age must be able to roll material-free Skylands");
+        for (String terrain : List.of("flat", "void")) {
+            helper.assertTrue(AgeFeatureSelection.randomChoices(7L,
+                            AgeRuntimeProfiles.resolve(id(terrain)), registries).stream()
+                            .noneMatch(choice -> AgeFeatureSelection.skylands(choice.id())),
+                    "Random " + terrain + " Ages must not roll a filter without useful upper terrain");
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void spheresAndSpikesHaveSeparateAuthoredPagesAndMaterials(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("glowstone"), page("feature/spheres"), block("stone"), page("feature/spikes")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 1717L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(1717L), registries);
+        List<AgeFeatureSelection.Choice> expected = List.of(
+                new AgeFeatureSelection.Choice(id("spheres"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("glowstone"))),
+                new AgeFeatureSelection.Choice(id("spikes"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("stone"))));
+        helper.assertValueEqual(AgeFeatureSelection.resolved(plan), expected,
+                "Each page must preserve its own preceding Block material and writing order");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), expected,
+                "Spheres and Spikes must retain their identities and materials after reload");
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) {
+            var profile = AgeRuntimeProfiles.resolve(id(terrain));
+            helper.assertTrue(AgeFeatureSelection.error(id("spheres"), profile, registries) == null,
+                    "Spheres must be additive on " + terrain + " terrain");
+            boolean surface = !terrain.equals("void") && !terrain.equals("cave");
+            helper.assertValueEqual(AgeFeatureSelection.error(id("spikes"), profile, registries) == null,
+                    surface, "Spikes require a solid surface on " + terrain + " terrain");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"),
+                page("feature/spikes"))), "needs an exposed solid surface");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                page("feature/spikes"))), "needs an exposed solid surface");
+        boolean randomSpheres = false;
+        boolean randomSpikes = false;
+        for (long seed = 0; seed < 80; seed++) {
+            var random = AgeFeatureSelection.randomChoices(seed,
+                    AgeRuntimeProfiles.resolve(id("standard")), registries);
+            randomSpheres |= random.stream().anyMatch(choice -> AgeFeatureSelection.spheres(choice.id()));
+            randomSpikes |= random.stream().anyMatch(choice -> AgeFeatureSelection.spikes(choice.id()));
+        }
+        helper.assertTrue(randomSpheres && randomSpikes,
+                "Page-free surface Ages must be able to select both separate features");
+        for (String terrain : List.of("void", "cave")) {
+            var profile = AgeRuntimeProfiles.resolve(id(terrain));
+            for (long seed = 0; seed < 30; seed++) {
+                helper.assertTrue(AgeFeatureSelection.randomChoices(seed, profile, registries).stream()
+                                .noneMatch(choice -> AgeFeatureSelection.spikes(choice.id())),
+                        "Random " + terrain + " Ages must never choose unsupported Spikes");
+            }
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void voidBiomesAreIndependentOfFloatingIslands(GameTestHelper helper) {
+        OrderedWriting voidDefault = new OrderedWriting(List.of(panel(), page("terrain/void")));
+        AgeGenerationPlan voidDefaultPlan = AgeGenerationPlan.compile(voidDefault, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(voidDefaultPlan.biomeSelection().biomes(),
+                List.of(net.minecraft.world.level.biome.Biomes.THE_VOID.location()),
+                "Void terrain without biome pages must keep The Void biome");
+        OrderedWriting voidDesert = new OrderedWriting(List.of(panel(), page("terrain/void"),
+                page("biome/desert"), page("biome/single")));
+        AgeGenerationPlan voidDesertPlan = AgeGenerationPlan.compile(voidDesert, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(voidDesertPlan.biomeSelection().biomes(),
+                List.of(net.minecraft.world.level.biome.Biomes.DESERT.location()),
+                "An authored biome must override The Void even with no generated blocks");
+        helper.assertValueEqual(AgeGenerationPlan.load(voidDesertPlan.save()).biomeSelection(),
+                voidDesertPlan.biomeSelection(), "The Void Age biome must survive reload");
+        OrderedWriting voidDesertWithoutController = new OrderedWriting(List.of(panel(),
+                page("terrain/void"), page("biome/desert")));
+        AgeGenerationPlan implicitSinglePlan = AgeGenerationPlan.compile(voidDesertWithoutController, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(implicitSinglePlan.biomeSelection().biomes(),
+                List.of(net.minecraft.world.level.biome.Biomes.DESERT.location()),
+                "A Void Age with one authored biome must not add The Void as filler");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"),
+                page("biome/desert"), page("biome/tiny"))),
+                "requires 2 distinct biomes");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void blockPagesModifyFeaturesAndSurviveReload(GameTestHelper helper) {
+        var stone = ResourceLocation.withDefaultNamespace("stone");
+        var water = ResourceLocation.withDefaultNamespace("water");
+        helper.assertTrue(BlockSymbolPages.availableBlocks().contains(stone),
+                "Registry-derived material pages must include vanilla stone");
+        helper.assertTrue(BlockSymbolPages.availableBlocks(BlockSymbolPages.CATEGORY).contains(stone),
+                "Stone must appear among standard Block Pages");
+        helper.assertTrue(!BlockSymbolPages.availableBlocks(BlockSymbolPages.CATEGORY).contains(water),
+                "Water must not appear among standard Block Pages");
+        helper.assertTrue(BlockSymbolPages.availableBlocks(BlockSymbolPages.FLUID_CATEGORY).contains(water),
+                "Water must appear among Fluid Pages");
+        for (String path : List.of("fern", "seagrass", "tube_coral")) {
+            helper.assertTrue(!BlockSymbolPages.availableBlocks().contains(ResourceLocation.withDefaultNamespace(path)),
+                    path + " must not receive a rock or fluid material page");
+        }
+        var glowstone = ResourceLocation.withDefaultNamespace("glowstone");
+        helper.assertTrue(BlockSymbolPages.availableBlocks(BlockSymbolPages.CATEGORY).contains(glowstone),
+                "Glowstone should be a valid full-collision rock material");
+        helper.assertTrue(AgeFeatureSelection.materialError(new AgeFeatureSelection.Choice(
+                id("rocks"), Optional.of(glowstone))) == null,
+                "Glowstone must bind successfully before Rocks");
+        helper.assertTrue(!BlockSymbolPages.availableBlocks().contains(ResourceLocation.withDefaultNamespace("chest")),
+                "Blocks with block entities must not receive generated pages");
+        helper.assertTrue(!SymbolCatalog.isKnown(new SymbolReference(BlockSymbolPages.symbolId(
+                ResourceLocation.withDefaultNamespace("chest")))),
+                "Block-entity pages must not remain valid in the server catalog");
+        helper.assertTrue(SymbolCatalog.isKnown(new SymbolReference(BlockSymbolPages.symbolId(stone))),
+                "Generated material pages must be recognized by the server catalog");
+        helper.assertTrue(PageItem.isUsableWriting(PageItem.createCreativeBlockPage(stone)),
+                "A generated material page must be a usable authored page");
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                page("biome/plains"), page("biome/single"), block("stone"), page("feature/rocks"),
+                block("water"), page("feature/lava_lakes"), page("feature/huge_trees"),
+                page("feature/ravines")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), helper.getLevel().registryAccess());
+        List<AgeFeatureSelection.Choice> expected = List.of(
+                new AgeFeatureSelection.Choice(id("rocks"), Optional.of(stone)),
+                new AgeFeatureSelection.Choice(id("lava_lakes"), Optional.of(water)),
+                choice("huge_trees"), choice("ravines"));
+        helper.assertValueEqual(AgeFeatureSelection.resolved(plan), expected,
+                "Each material must attach only to the immediately following feature");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), expected,
+                "Block modifiers must survive the frozen-plan round trip");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void repeatedMaterialAndFeaturePagesRemainInWrittenPlan(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("stone"), block("stone"), page("feature/rocks"), page("feature/rocks")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(plan.writing(), writing,
+                "Binding must keep every repeated material and feature page in order");
+        helper.assertValueEqual(plan.symbols().size(), 5,
+                "The frozen plan must retain both material pages and both feature pages");
+        List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(choices.size(), 3,
+                "The first material gains an inferred feature; both authored features remain");
+        helper.assertValueEqual(choices.get(1), new AgeFeatureSelection.Choice(id("rocks"),
+                Optional.of(ResourceLocation.withDefaultNamespace("stone"))),
+                "The second material must modify the first authored Rocks page");
+        helper.assertValueEqual(choices.get(2).id(), id("rocks"),
+                "The repeated Rocks page must remain a second feature choice");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                "Repeated pages and their feature choices must survive a plan reload");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void repeatedUnmodifiedRocksChooseDistinctMaterials(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                page("feature/rocks"), page("feature/rocks"), page("feature/rocks"), page("feature/rocks")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), helper.getLevel().registryAccess());
+        List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(choices.size(), 4, "All four Rocks pages must survive binding");
+        helper.assertValueEqual(choices.stream().map(AgeFeatureSelection.Choice::material).distinct().count(), 4L,
+                "Each repeated unmodified Rocks page must receive a distinct material");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                "The four materials must remain stable after reloading the Age plan");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void incompatibleAndUnpairedMaterialPages(GameTestHelper helper) {
+        helper.assertTrue(AgeFeatureSelection.materialError(new AgeFeatureSelection.Choice(
+                        id("rocks"), Optional.of(ResourceLocation.withDefaultNamespace("torch"))))
+                        .contains("full solid block"),
+                "A non-full block must still be rejected if supplied by old writing");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("stone"), page("feature/surface_lakes"))), "source-fluid block");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("stone"), page("feature/trees"))), "cannot consume a material page");
+        for (String material : List.of("stone", "water")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                    block(material)));
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(87L), helper.getLevel().registryAccess());
+            List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(choices.size(), 1, "An unpaired material page must gain one feature");
+            helper.assertValueEqual(choices.getFirst().material(),
+                    Optional.of(ResourceLocation.withDefaultNamespace(material)),
+                    "The inferred feature must consume the authored material");
+            helper.assertTrue(material.equals("water")
+                            ? AgeFeatureSelection.isLake(choices.getFirst().id())
+                            : AgeFeatureSelection.isRock(choices.getFirst().id())
+                            || AgeFeatureSelection.floatingIslands(choices.getFirst().id())
+                            || AgeFeatureSelection.tendrils(choices.getFirst().id())
+                            || AgeFeatureSelection.spheres(choices.getFirst().id())
+                            || AgeFeatureSelection.spikes(choices.getFirst().id())
+                            || AgeFeatureSelection.obelisks(choices.getFirst().id()),
+                    "The inferred feature must accept the material type");
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                    "The inferred feature must be deterministic across a plan reload");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"), block("water"))),
+                "No compatible feature for material");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty", timeoutTicks = 600)
+    public static void runtimeAgeUsesSavedFeatureGenerator(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                page("biome/plains"), page("biome/single"), page("feature/caves"), page("feature/rocks")));
+        AgeReference reference = new AgeReference(UUID.randomUUID(), "Written Flowers");
+        var target = AgeDimensionService.resolve(player, reference, writing).orElseThrow();
+        AgeDefinition definition = AgeRegistrySavedData.get(helper.getLevel()).find(reference.id()).orElseThrow();
+        List<AgeFeatureSelection.Choice> expected = AgeFeatureSelection.resolved(definition.plan());
+        helper.assertValueEqual(expected.stream().map(AgeFeatureSelection.Choice::id).toList(),
+                List.of(id("caves"), id("rocks")), "Saved Age definition must retain the written decoration");
+        helper.assertTrue(expected.get(1).material().isPresent(),
+                "Unmodified rocks must receive a chosen material");
+        helper.runAfterDelay(1, () -> {
+            var level = helper.getLevel().getServer().getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "The authored feature Age must load");
+            helper.assertTrue(level.getChunkSource().getGenerator() instanceof AgeFeatureChunkGenerator,
+                    "Runtime world generation must use the feature-aware generator");
+            var generator = (AgeFeatureChunkGenerator) level.getChunkSource().getGenerator();
+            helper.assertValueEqual(generator.ageFeatures(), expected,
+                    "Runtime generation must receive the frozen authored feature selection");
+            helper.succeed();
+        });
+    }
+
+    @GameTest(template = "empty", timeoutTicks = 600)
+    public static void netherCaveBiomeUsesNetherRock(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                page("biome/nether_wastes"), page("biome/single")));
+        var target = AgeDimensionService.resolve(player,
+                new AgeReference(UUID.randomUUID(), "Nether Cave Materials"), writing).orElseThrow();
+        helper.runAfterDelay(1, () -> {
+            var level = helper.getLevel().getServer().getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "The Nether cave Age must load");
+            var chunk = level.getChunk(0, 0);
+            int[] rock = new int[2];
+            chunk.findBlocks(state -> state.is(Blocks.NETHERRACK) || state.is(Blocks.STONE)
+                            || state.is(Blocks.DEEPSLATE) || state.is(Blocks.DIRT)
+                            || state.is(Blocks.GRASS_BLOCK),
+                    (pos, state) -> {
+                        if (state.is(Blocks.NETHERRACK)) rock[0]++;
+                        else rock[1]++;
+                    });
+            helper.assertTrue(rock[0] > 0, "Nether cave terrain must contain netherrack");
+            helper.assertValueEqual(rock[1], 0,
+                    "Nether cave terrain must not retain stone, deepslate, dirt, or grass");
+            helper.succeed();
+        });
+    }
+
+    private static void rejects(GameTestHelper helper, OrderedWriting writing, String expected) {
+        try {
+            AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(87L), helper.getLevel().registryAccess());
+            helper.fail("Writing must reject " + expected);
+        } catch (IllegalArgumentException exception) {
+            helper.assertTrue(exception.getMessage().contains(expected), exception.getMessage());
+        }
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private static AgeFeatureSelection.Choice choice(String path) {
+        return new AgeFeatureSelection.Choice(id(path), java.util.Optional.empty());
+    }
+
+    private static WritingEntry page(String path) {
+        return WritingEntry.symbol(new SymbolReference(id(path)));
+    }
+
+    private static WritingEntry block(String path) {
+        return WritingEntry.symbol(new SymbolReference(BlockSymbolPages.symbolId(
+                ResourceLocation.withDefaultNamespace(path))));
+    }
+
+    private static WritingEntry panel() { return WritingEntry.linkPanel(); }
+}

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

@@ -0,0 +1,74 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.ResourceLocation;
+
+/** Frozen Legacy 0.13.7.06 deck cards and default activation costs, not effect implementations. */
+public final class InstabilityProviderCatalog {
+    public enum Deck {
+        BASIC(0), HARSH(2_500), DESTRUCTIVE(10_000), EATING(15_000), DEATH(20_000);
+
+        private final int entryCost;
+
+        Deck(int entryCost) { this.entryCost = entryCost; }
+        public int entryCost() { return entryCost; }
+    }
+
+    public record Card(ResourceLocation id, int cost) {
+        public Card {
+            if (cost <= 0) throw new IllegalArgumentException("Provider cost must be positive");
+        }
+    }
+
+    private static final List<List<Card>> DECKS = createDecks();
+
+    private InstabilityProviderCatalog() {}
+
+    public static List<Card> cards(Deck deck) { return DECKS.get(deck.ordinal()); }
+
+    public static boolean contains(ResourceLocation id) {
+        return DECKS.stream().flatMap(List::stream).anyMatch(card -> card.id().equals(id));
+    }
+
+    private static List<List<Card>> createDecks() {
+        List<List<Card>> decks = new ArrayList<>();
+        for (Deck ignored : Deck.values()) decks.add(new ArrayList<>());
+        add(decks, "blindness", 1000, 0, 0, 0, 1, 0);
+        add(decks, "blindness_global", 1500, 0, 0, 0, 0, 1);
+        add(decks, "enemyregen_global", 1000, 5, 2, 0, 0, 0);
+        add(decks, "enemyresist_global", 1000, 2, 1, 0, 0, 0);
+        add(decks, "fatigue", 500, 5, 0, 0, 0, 0);
+        add(decks, "fatigue_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "hunger", 500, 8, 2, 0, 0, 0);
+        add(decks, "hunger_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "nausea", 1000, 0, 0, 0, 1, 0);
+        add(decks, "nausea_global", 1500, 0, 0, 0, 0, 1);
+        add(decks, "poison", 500, 9, 3, 0, 0, 0);
+        add(decks, "poison_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "slow", 500, 6, 1, 0, 0, 0);
+        add(decks, "slow_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "weakness", 500, 8, 2, 0, 0, 0);
+        add(decks, "weakness_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "wither", 1000, 0, 1, 1, 2, 0);
+        add(decks, "wither_global", 2000, 0, 0, 1, 1, 1);
+        add(decks, "burning", 500, 0, 1, 0, 0, 0);
+        add(decks, "crumble", 2000, 0, 0, 6, 0, 0);
+        add(decks, "decayblue", 2000, 0, 0, 0, 2, 1);
+        add(decks, "decaypurple", 2000, 0, 0, 0, 2, 1);
+        add(decks, "decayred", 2000, 0, 0, 0, 2, 1);
+        add(decks, "decaywhite", 5000, 0, 0, 0, 1, 3);
+        add(decks, "explosions", 1000, 0, 0, 8, 0, 0);
+        add(decks, "lightning", 1000, 0, 4, 4, 0, 0);
+        add(decks, "meteors", 1000, 0, 0, 4, 0, 0);
+        return decks.stream().map(List::copyOf).toList();
+    }
+
+    private static void add(List<List<Card>> decks, String path, int cost, int... copies) {
+        Card card = new Card(ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path), cost);
+        for (Deck deck : Deck.values()) {
+            for (int copy = 0; copy < copies[deck.ordinal()]; copy++) decks.get(deck.ordinal()).add(card);
+        }
+    }
+}

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

@@ -0,0 +1,44 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+/** Legacy grammar ranks: each more-preferred rank group outweighs the next rarer group. */
+final class LegacyRankChoice {
+    private LegacyRankChoice() {}
+
+    record Option<T>(T value, int rank) {
+        Option {
+            if (value == null || rank < 0) throw new IllegalArgumentException("Invalid ranked choice");
+        }
+    }
+
+    static <T> T choose(Random random, List<Option<T>> options) {
+        if (options.isEmpty()) throw new IllegalArgumentException("No ranked choices");
+        Map<Integer, Integer> counts = new HashMap<>();
+        int highest = 0;
+        for (Option<T> option : options) {
+            counts.merge(option.rank(), 1, Integer::sum);
+            highest = Math.max(highest, option.rank());
+        }
+        Map<Integer, Integer> weights = new HashMap<>();
+        int weight = 1;
+        int previousTotal = 0;
+        for (int rank = highest; rank >= 0; rank--) {
+            int count = counts.getOrDefault(rank, 0);
+            if (weight != 1 && count > 0) weight = Math.max(weight, previousTotal / count + 1);
+            weights.put(rank, weight);
+            previousTotal = count * weight;
+            weight++;
+        }
+        int total = options.stream().mapToInt(option -> weights.get(option.rank())).sum();
+        int ticket = random.nextInt(total);
+        for (Option<T> option : options) {
+            ticket -= weights.get(option.rank());
+            if (ticket < 0) return option.value();
+        }
+        throw new IllegalStateException("Ranked choice ticket was not consumed");
+    }
+}

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

@@ -0,0 +1,60 @@
+package net.dnorberg.rivencraft.book;
+
+import com.mojang.serialization.Codec;
+import io.netty.buffer.ByteBuf;
+import java.util.List;
+import net.minecraft.ChatFormatting;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.chat.Component;
+
+/** Flags written into a Link Panel and carried by books assembled from it. */
+public record LinkProperties(int flags) {
+    public static final int DISARM = 1;
+    /** Retained only to read pre-0.4.7.1 test books; no longer generated or applied. */
+    public static final int GENERATE_PLATFORM = 2;
+    public static final int MAINTAIN_MOMENTUM = 4;
+    public static final int INTRA_LINKING = 8;
+    private static final int ALL_FLAGS = DISARM | GENERATE_PLATFORM | MAINTAIN_MOMENTUM | INTRA_LINKING;
+    public static final LinkProperties NONE = new LinkProperties(0);
+    public static final Codec<LinkProperties> CODEC = Codec.intRange(0, ALL_FLAGS).xmap(
+            LinkProperties::new, LinkProperties::flags);
+    public static final StreamCodec<ByteBuf, LinkProperties> STREAM_CODEC = StreamCodec.of(
+            (buffer, value) -> ByteBufCodecs.VAR_INT.encode(buffer, value.flags),
+            buffer -> new LinkProperties(ByteBufCodecs.VAR_INT.decode(buffer)));
+
+    public LinkProperties {
+        if ((flags & ~ALL_FLAGS) != 0 || flags < 0) {
+            throw new IllegalArgumentException("Unknown Link Panel flags: " + flags);
+        }
+    }
+
+    public boolean has(int flag) {
+        return (flags & flag) != 0;
+    }
+
+    /** Intra Linking only governs Linking Books; a Descriptive Book treats that panel as ordinary. */
+    public LinkProperties forDescriptiveBook() {
+        return new LinkProperties(flags & ~INTRA_LINKING);
+    }
+
+    public void appendTooltip(List<Component> lines) {
+        if (has(DISARM)) lines.add(propertyName("disarm"));
+        if (has(MAINTAIN_MOMENTUM)) lines.add(propertyName("maintain_momentum"));
+        if (has(INTRA_LINKING)) lines.add(propertyName("intra_linking"));
+    }
+
+    private static Component propertyName(String name) {
+        return Component.translatable("item.rivencraft.link_property." + name)
+                .withStyle(ChatFormatting.DARK_PURPLE);
+    }
+
+    public static Component name(int flag) {
+        return switch (flag) {
+            case DISARM -> propertyName("disarm");
+            case MAINTAIN_MOMENTUM -> propertyName("maintain_momentum");
+            case INTRA_LINKING -> propertyName("intra_linking");
+            default -> throw new IllegalArgumentException("Unknown link property flag: " + flag);
+        };
+    }
+}

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

@@ -25,7 +25,11 @@ public final class LinkingService {
     }
 
     public static LinkResult travel(ServerPlayer player, LinkTarget target) {
-        return travel(player, target, false);
+        return travel(player, target, LinkProperties.NONE);
+    }
+
+    public static LinkResult travel(ServerPlayer player, LinkTarget target, LinkProperties properties) {
+        return travel(player, target, false, properties);
     }
 
     public static Optional<Vec3> resolveDestination(ServerLevel level, BlockPos origin, boolean ageArrival) {
@@ -36,27 +40,36 @@ public final class LinkingService {
 
     /** Travels to an Age-style destination, which must have solid footing. */
     public static LinkResult travelWithFooting(ServerPlayer player, LinkTarget target) {
+        return travelWithFooting(player, target, LinkProperties.NONE);
+    }
+
+    public static LinkResult travelWithFooting(ServerPlayer player, LinkTarget target, LinkProperties properties) {
         ServerLevel destinationLevel = player.getServer().getLevel(target.location().dimension());
         if (destinationLevel == null) {
             return LinkResult.MISSING_DIMENSION;
         }
-
         Optional<Vec3> destination = resolveDestination(destinationLevel, target.location().pos(), true);
         if (destination.isEmpty()) {
             return LinkResult.NO_SAFE_DESTINATION;
         }
 
         Vec3 position = destination.get();
+        Vec3 momentum = player.getDeltaMovement();
+        if (properties.has(LinkProperties.DISARM)) dropInventoryAtSource(player);
         teleport(player, destinationLevel, position, target);
+        if (properties.has(LinkProperties.MAINTAIN_MOMENTUM)) player.setDeltaMovement(momentum);
         player.resetFallDistance();
         return LinkResult.SUCCESS;
     }
 
-    private static LinkResult travel(ServerPlayer player, LinkTarget target, boolean requiresFooting) {
+    private static LinkResult travel(ServerPlayer player, LinkTarget target, boolean requiresFooting,
+                                     LinkProperties properties) {
         ServerLevel destinationLevel = player.getServer().getLevel(target.location().dimension());
         if (destinationLevel == null) {
             return LinkResult.MISSING_DIMENSION;
         }
+        if (destinationLevel == player.level() && !properties.has(LinkProperties.INTRA_LINKING))
+            return LinkResult.INTRA_LINKING_REQUIRED;
 
         Optional<Vec3> destination = resolveDestination(destinationLevel, target.location().pos(), requiresFooting);
         if (destination.isEmpty()) {
@@ -64,11 +77,26 @@ public final class LinkingService {
         }
 
         Vec3 position = destination.get();
+        Vec3 momentum = player.getDeltaMovement();
+        if (properties.has(LinkProperties.DISARM)) dropInventoryAtSource(player);
         teleport(player, destinationLevel, position, target);
+        if (properties.has(LinkProperties.MAINTAIN_MOMENTUM)) player.setDeltaMovement(momentum);
         player.resetFallDistance();
         return LinkResult.SUCCESS;
     }
 
+    /** Drop each inventory stack as an item entity at the departure point. */
+    private static void dropInventoryAtSource(ServerPlayer player) {
+        var inventory = player.getInventory();
+        for (int slot = 0; slot < inventory.getContainerSize(); slot++) {
+            var stack = inventory.getItem(slot);
+            if (stack.isEmpty()) continue;
+            inventory.setItem(slot, net.minecraft.world.item.ItemStack.EMPTY);
+            player.drop(stack, false);
+        }
+        player.containerMenu.broadcastChanges();
+    }
+
     private static void teleport(
             ServerPlayer player,
             ServerLevel destinationLevel,
@@ -166,6 +194,7 @@ public final class LinkingService {
     public enum LinkResult {
         SUCCESS,
         MISSING_DIMENSION,
+        INTRA_LINKING_REQUIRED,
         NO_SAFE_DESTINATION
     }
 }

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

@@ -0,0 +1,87 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Opt-in regression for Legacy rank weights and deterministic random-Age branches. */
+@GameTestHolder("rivencraft_archive_grammar")
+@PrefixGameTestTemplate(false)
+public final class RandomAgeWeightGameTests {
+    private RandomAgeWeightGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void randomAgeChoicesRespectLegacyRanks(GameTestHelper helper) {
+        var terrain = List.of(new LegacyRankChoice.Option<>("normal", 1),
+                new LegacyRankChoice.Option<>("flat", 2),
+                new LegacyRankChoice.Option<>("amplified", 3),
+                new LegacyRankChoice.Option<>("island", 3),
+                new LegacyRankChoice.Option<>("cave", 3),
+                new LegacyRankChoice.Option<>("void", 3));
+        // Legacy's rank formula yields 6:5:1:1:1:1 for these six terrains.
+        for (int ticket = 0; ticket < 15; ticket++) {
+            final int selectedTicket = ticket;
+            Random fixed = new Random() {
+                @Override public int nextInt(int bound) {
+                    helper.assertValueEqual(bound, 15, "The terrain rank group must have 15 tickets");
+                    return selectedTicket;
+                }
+            };
+            String expected = ticket < 6 ? "normal" : ticket < 11 ? "flat"
+                    : terrain.get(ticket - 9).value();
+            helper.assertValueEqual(LegacyRankChoice.choose(fixed, terrain), expected,
+                    "A fixed ticket must map to its exact Legacy terrain weight");
+        }
+
+        Map<ResourceLocation, Integer> profiles = new HashMap<>();
+        Map<AgeTraits.Weather, Integer> weather = new HashMap<>();
+        Map<AgeSeasonMode, Integer> seasons = new HashMap<>();
+        for (long seed = 0; seed < 4_000; seed++) {
+            ResourceLocation profile = AgeRuntimeProfiles.select(seed);
+            helper.assertValueEqual(profile, AgeRuntimeProfiles.select(seed),
+                    "The same Age seed must choose the same terrain");
+            if (AgeRuntimeProfiles.profiles().size() == AgeGenerationProfiles.all().size())
+                helper.assertValueEqual(profile, AgeGenerationProfiles.select(seed),
+                        "The built-in-only fallback must agree with loaded profile selection");
+            profiles.merge(profile, 1, Integer::sum);
+            AgeTraits traits = AgeTraits.select(seed);
+            helper.assertValueEqual(traits, AgeTraits.select(seed),
+                    "The same Age seed must choose the same traits");
+            weather.merge(traits.weather(), 1, Integer::sum);
+            AgeSeasonMode season = AgeSeasonMode.select(null, seed, true);
+            helper.assertValueEqual(season, AgeSeasonMode.select(null, seed, true),
+                    "The same Age seed must choose the same season policy");
+            seasons.merge(season, 1, Integer::sum);
+        }
+        helper.assertTrue(profiles.getOrDefault(AgeGenerationProfiles.STANDARD, 0)
+                        > profiles.getOrDefault(AgeGenerationProfiles.FLAT, 0)
+                        && profiles.getOrDefault(AgeGenerationProfiles.FLAT, 0)
+                        > profiles.getOrDefault(AgeGenerationProfiles.VOID, 0),
+                "Normal terrain must be common, Flat intermediate, and Void rare");
+        helper.assertTrue(weather.getOrDefault(AgeTraits.Weather.NORMAL, 0)
+                        > weather.getOrDefault(AgeTraits.Weather.STORM, 0),
+                "Legacy's normal weather must be more common than a special weather mode");
+        helper.assertTrue(seasons.getOrDefault(AgeSeasonMode.SEASONS, 0)
+                        > seasons.getOrDefault(AgeSeasonMode.NO_SEASONS, 0)
+                        && seasons.getOrDefault(AgeSeasonMode.NO_SEASONS, 0)
+                        > seasons.getOrDefault(AgeSeasonMode.ETERNAL_WINTER, 0),
+                "Normal season cycling must be common, no seasons intermediate, and eternal seasons rare");
+        helper.assertTrue(AgeSeasonMode.select(null, 42L, false) == null,
+                "No season policy may be selected without Serene Seasons");
+        helper.assertValueEqual(AgeFeatureSelection.randomMaterialRank(ResourceLocation.parse("rivencraft:surface_lakes")),
+                1, "Surface Lakes must retain their Legacy common rank");
+        helper.assertValueEqual(AgeFeatureSelection.randomMaterialRank(ResourceLocation.parse("rivencraft:floating_islands")),
+                4, "Floating Islands must retain their Legacy rare rank");
+        helper.assertValueEqual(AgeStructureSelection.randomRank(ResourceLocation.parse("rivencraft:villages")),
+                1, "Villages must retain their Legacy common rank");
+        helper.assertValueEqual(AgeStructureSelection.randomRank(ResourceLocation.parse("rivencraft:trial_chambers")),
+                3, "Modern structures must use a rare rank");
+        helper.succeed();
+    }
+}

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

@@ -1,5 +1,7 @@
 package net.dnorberg.rivencraft.book;
 
+import net.dnorberg.rivencraft.registry.ModBlocks;
+
 import com.google.gson.JsonParser;
 import java.util.List;
 import java.util.UUID;
@@ -206,18 +208,14 @@ public final class TerrainWritingGameTests {
             helper.assertTrue(level.getChunkSource().getGenerator().getBiomeSource().possibleBiomes().stream()
                             .allMatch(biome -> biome.is(Biomes.THE_END)),
                     "The runtime sky-island generator must use the End biome page");
-            helper.assertValueEqual(AgeDimensionService.unload(server, age), AgeDimensionService.UnloadResult.UNLOADED,
+            helper.assertValueEqual(AgeGenerationPlan.load(age.plan().save()).biomeSelection(),
-                    "The island Age must unload");
+                    age.plan().biomeSelection(), "The authored End biome must survive a plan save/load round trip");
-            var reloaded = AgeDimensionService.ensureLoaded(server, age);
-            helper.assertTrue(reloaded != null && reloaded.getChunkSource().getGenerator().getBiomeSource()
-                            .possibleBiomes().stream().allMatch(biome -> biome.is(Biomes.THE_END)),
-                    "The authored End biome must survive runtime dimension reload");
             helper.succeed();
         });
     }
 
     @GameTest(template = "empty", timeoutTicks = 600)
-    public static void writtenTerrainFamiliesGenerateSafelyAndReload(GameTestHelper helper) {
+    public static void writtenTerrainFamiliesGenerateSafely(GameTestHelper helper) {
         var player = helper.makeMockServerPlayerInLevel();
         checkWrittenTerrain(helper, player, AgeGenerationProfiles.all(), 0);
     }
@@ -254,19 +252,13 @@ public final class TerrainWritingGameTests {
             helper.assertTrue(level != null, "The written Age must create a runtime dimension");
             assertGenerator(helper, level, age.plan().runtimeProfile());
             BlockPos spawn = target.location().pos();
-            helper.assertTrue(level.getBlockState(spawn.below()).is(Blocks.COBBLESTONE)
+            helper.assertTrue(level.getBlockState(spawn.below()).is(ModBlocks.CLOUD_PLATFORM.get())
                             && level.getBlockState(spawn).isAir()
                             && level.getBlockState(spawn.above()).isAir(),
                     "Every written terrain family must retain a safe arrival platform");
 
-            helper.assertValueEqual(AgeDimensionService.unload(server, age),
+            helper.assertValueEqual(AgeGenerationPlan.load(age.plan().save()).runtimeProfile(),
-                    AgeDimensionService.UnloadResult.UNLOADED,
+                    age.plan().runtimeProfile(), "The written terrain profile must survive plan persistence");
-                    "A written Age must unload without losing its plan");
-            var reloaded = AgeDimensionService.ensureLoaded(server, age);
-            helper.assertTrue(reloaded != null, "The written Age must reload from its frozen plan");
-            assertGenerator(helper, reloaded, age.plan().runtimeProfile());
-            helper.assertValueEqual(reloaded.dimensionType().effectsLocation(),
-                    level.dimensionType().effectsLocation(), "Reload must retain dimension effects");
             helper.runAfterDelay(1, () -> checkWrittenTerrain(helper, player, profiles, index + 1));
         });
     }

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(payload.source().pos(), payload.book(), payload.traits(),
-                    : new DescriptiveBookScreen(hand, payload.book(), payload.traits(), payload.writingSymbols()));
+                            payload.writingSymbols())
+                    : new DescriptiveBookScreen(hand, payload.book(), payload.traits(),
+                            payload.writingSymbols()));
         });
     }
 }

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

@@ -2,9 +2,12 @@ package net.dnorberg.rivencraft.client;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
+import net.dnorberg.rivencraft.registry.ModBlocks;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.client.renderer.ItemBlockRenderTypes;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.resources.ResourceLocation;
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.bus.api.SubscribeEvent;
@@ -32,6 +35,7 @@ public final class ClientEvents {
     public static void registerRenderers(EntityRenderersEvent.RegisterRenderers event) {
         event.registerBlockEntityRenderer(ModBlockEntities.BOOK_STAND.get(), BookStandRenderer::new);
         event.registerBlockEntityRenderer(ModBlockEntities.WRITING_DESK.get(), WritingDeskRenderer::new);
+        event.registerBlockEntityRenderer(ModBlockEntities.STAR_FISSURE.get(), StarFissureRenderer::new);
     }
 
     @SubscribeEvent
@@ -62,11 +66,19 @@ public final class ClientEvents {
 
     @SubscribeEvent
     public static void clientSetup(FMLClientSetupEvent event) {
-        event.enqueueWork(() -> ItemProperties.register(
+        event.enqueueWork(() -> {
-                ModItems.LINKING_BOOK.get(),
+            ItemProperties.register(
-                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "bound"),
+                    ModItems.LINKING_BOOK.get(),
-                (stack, level, entity, seed) -> stack.has(ModDataComponents.LINK_TARGET.get()) ? 1.0F : 0.0F
+                    ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "bound"),
-        ));
+                    (stack, level, entity, seed) -> stack.has(ModDataComponents.LINK_TARGET.get()) ? 1.0F : 0.0F
+            );
+            // Some renderers still query the block layer instead of the model's render_type hint.
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.SMALL_CRYSTAL_BUD.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.MEDIUM_CRYSTAL_BUD.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.LARGE_CRYSTAL_BUD.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.CRYSTAL_CLUSTER.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.CLOUD_PLATFORM.get(), RenderType.translucent());
+        });
         NeoForge.EVENT_BUS.addListener(ClientBookInteractionHandler::onRightClickItem);
         NeoForge.EVENT_BUS.addListener(ClientBookInteractionHandler::onRightClickBlock);
         NeoForge.EVENT_BUS.addListener(ClientBookExploreOverlay::onClientTickPre);

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/StarFissureRenderer.java

@@ -0,0 +1,22 @@
+package net.dnorberg.rivencraft.client;
+
+import net.dnorberg.rivencraft.block.entity.StarFissureBlockEntity;
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
+import net.minecraft.client.renderer.blockentity.TheEndPortalRenderer;
+
+/** Uses the modern end-portal starfield shader at Legacy's full-block face positions. */
+public final class StarFissureRenderer extends TheEndPortalRenderer<StarFissureBlockEntity> {
+    public StarFissureRenderer(BlockEntityRendererProvider.Context context) {
+        super(context);
+    }
+
+    @Override
+    protected float getOffsetUp() {
+        return 0.0F;
+    }
+
+    @Override
+    protected float getOffsetDown() {
+        return 1.0F;
+    }
+}

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

@@ -24,7 +24,7 @@ public final class SymbolPageItemRenderer extends BlockEntityWithoutLevelRendere
         ResourceLocation texture = switch (PageItem.content(stack).kind()) {
             case BLANK -> texture("page");
             case LINK_PANEL -> texture("page_link_panel");
-            case UNRESOLVED_SYMBOL -> texture("page_unresolved");
+            case UNRESOLVED_SYMBOL -> texture("page_symbol");
             case SYMBOL -> SymbolPageTextures.forItem(stack);
         };
         VertexConsumer vertices = buffers.getBuffer(RenderType.entityCutoutNoCull(texture));

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

@@ -69,9 +69,16 @@ 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)
+                : FALLBACK;
+    }
+
     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");
+        if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return FALLBACK;
         if (content.kind() != PageContent.Kind.SYMBOL) return FALLBACK;
         SymbolDisplayMetadata metadata = stack.get(ModDataComponents.PAGE_SYMBOL_DISPLAY.get());
         ResourceLocation id = content.symbol().orElseThrow().id();

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

@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.menu.BookBinderMenu;
 import net.dnorberg.rivencraft.network.SetBookBinderTitlePayload;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.EditBox;
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
@@ -106,14 +107,33 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
         }
         graphics.disableScissor();
         drawScrollEnds(graphics);
+        var severity = menu.grammarSeverity().orElse(null);
+        Component status = severity == WritingGrammar.Severity.FATAL
+                ? Component.translatable("screen.rivencraft.book_binder.status.fatal")
+                : severity == WritingGrammar.Severity.INSTABILITY
+                ? Component.translatable("screen.rivencraft.book_binder.status.unstable", menu.grammarInstability())
+                : severity == WritingGrammar.Severity.SEEDED_COMPLETION
+                ? Component.translatable("screen.rivencraft.book_binder.status.seeded") : null;
+        if (status != null) graphics.drawString(font, status, leftPos + 77, topPos + 30,
+                severity == WritingGrammar.Severity.FATAL ? 0xFFAA3030
+                        : severity == WritingGrammar.Severity.INSTABILITY ? 0xFF924F18 : 0xFF50624B, false);
         Component grammarTooltip = menu.grammarError().map(code -> Component.translatable(
                 "screen.rivencraft.book_binder.grammar." + code.name().toLowerCase(Locale.ROOT),
                 errorStripIndex + 1)).orElse(null);
-        if (menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty()
+        if (grammarTooltip != null && ((mouseX >= leftPos + 77 && mouseX < leftPos + 151)
-                && mouseX >= leftPos + 152 && mouseX < leftPos + 168
+                || (mouseX >= leftPos + 152 && mouseX < leftPos + 168))
                 && mouseY >= topPos + 27 && mouseY < topPos + 43
-                && grammarTooltip != null) {
+                && (status != null || menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty())) {
-            graphics.renderTooltip(font, grammarTooltip, mouseX, mouseY);
+            java.util.List<Component> details = new java.util.ArrayList<>();
+            if (status != null) details.add(status);
+            details.add(grammarTooltip);
+            if (menu.grammarInstability() > 0 && severity != WritingGrammar.Severity.INSTABILITY)
+                details.add(Component.translatable("screen.rivencraft.book_binder.status.unstable",
+                        menu.grammarInstability()));
+            if (menu.grammarIncompleteCount() > 0 && severity != WritingGrammar.Severity.SEEDED_COMPLETION)
+                details.add(Component.translatable("screen.rivencraft.book_binder.status.seeded_count",
+                        menu.grammarIncompleteCount()));
+            graphics.renderComponentTooltip(font, details, mouseX, mouseY);
             return;
         }
         if (mouseY >= topPos + STRIP_Y && mouseY < topPos + STRIP_Y + STRIP_HEIGHT) {
@@ -169,7 +189,8 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
             case SYMBOL, UNRESOLVED_SYMBOL -> graphics.blit(NotebookScreen.symbolTexture(page),
                     x + 1, y + 5, 24, 24, 0, 0, 128, 128, 128, 128);
         }
-        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()) {
+        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()
+                && !menu.grammarWarning()) {
             graphics.fill(x, y, x + PAGE_WIDTH, y + PAGE_HEIGHT, 0x55FF2020);
             graphics.renderOutline(x, y, PAGE_WIDTH, PAGE_HEIGHT, 0xFFFF3030);
         }

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;
@@ -52,6 +53,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private final OrderedWriting writing;
     private final List<SymbolDisplayMetadata> writingSymbols;
     private final boolean pageFree;
+    private final String author;
     private final InteractionHand hand;
     private final BlockPos bookStandPos;
     private DestinationPreviewRenderer preview;
@@ -71,6 +73,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
+        author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         this.hand = hand;
         bookStandPos = null;
     }
@@ -84,6 +87,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
         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 +167,26 @@ 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 && 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,7 +206,7 @@ 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);
         }
@@ -193,20 +217,41 @@ 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());
+        return Math.max(1, writing.entries().size() - 1);
     }
 
     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);
+            WritingGrammar.Result grammar = WritingGrammar.parse(writing);
+            boolean unresolved = writingSymbols.stream().anyMatch(display -> !display.resolved());
+            if (!grammar.canCreate() || unresolved) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.fatal"),
+                        x, top + 132, 110, UNRESOLVED_TEXT_COLOR);
+            } else if (grammar.writingInstability() > 0) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.unstable",
+                                grammar.writingInstability()), x, top + 132, 110);
+            }
+            if (grammar.firstIncomplete().isPresent()) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.seeded"),
+                        x, top + 145, 110);
+            }
             return;
         }
-        int detailsY = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
+        int nameEnd = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
-                x + 10, top + 52, 100) + 10;
+                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 +287,15 @@ 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;
+        graphics.enableScissor(left + 174, top + 26, left + 306, top + 172);
-        drawWrappedWithoutShadow(graphics, Component.translatable(display.nameTranslationKey()),
+        int textureSize = display.resolved() ? 128 : 16;
-                x, top + 39, 126, color);
+        graphics.blit(SymbolPageTextures.forDisplay(display), left + 177, top + 29,
-        drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
+                128, 128, 0, 0, textureSize, textureSize, textureSize, textureSize);
-                x, top + 64, 126, color);
+        if (!display.resolved()) {
+            drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
+                    x, top + 151, 126, UNRESOLVED_TEXT_COLOR);
+        }
+        graphics.disableScissor();
     }
 
     private void turnPage(int direction) {

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

@@ -8,11 +8,20 @@ import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.inventory.ClickType;
 
 /** Legacy Ink Mixer atlas with a server-synced, sixteen-use basin. */
 public final class InkMixerScreen extends AbstractContainerScreen<InkMixerMenu> {
     private static final ResourceLocation BACKGROUND = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "textures/gui/ink_mixer_legacy.png");
+    private static final int BASIN_X = 88;
+    private static final int BASIN_Y = 49;
+    private static final int BASIN_RADIUS = 30;
+    // Legacy's registered property colors: Disarm red, Momentum blue, Intra green.
+    private static final int[] PROPERTY_COLORS = {0xFFE84848, 0xFF5555FF, 0xFF55EF55};
+    private final int[] lastChances = new int[3];
+    private boolean basinClickPendingRelease;
+    private long lastAdditionTime;
 
     public InkMixerScreen(InkMixerMenu menu, Inventory inventory, Component title) {
         super(menu, inventory, title);
@@ -26,16 +35,14 @@ public final class InkMixerScreen extends AbstractContainerScreen<InkMixerMenu>
         renderBg(graphics, partialTick, mouseX, mouseY);
     }
     @Override protected void renderBg(GuiGraphics graphics, float partialTick, int mouseX, int mouseY) {
-        graphics.blit(BACKGROUND, leftPos, topPos, 0, 0, imageWidth, imageHeight, 256, 256);
+        // Legacy draws this inset behind the transparent center of the main atlas.
-        int centerX = leftPos + 88;
+        graphics.blit(BACKGROUND, leftPos + 54, topPos + 16, 179, 16, 66, 65, 256, 256);
-        int centerY = topPos + 49;
-        int fillTop = centerY + 26 - Math.round(menu.inkRemaining() / (float) InkVialItem.CAPACITY * 52);
         if (menu.inkRemaining() > 0) {
-            for (int y = Math.max(centerY - 26, fillTop); y <= centerY + 26; y++) {
+            // Ink is a full dark basin in Legacy, rather than a vertical meter.
-                int halfWidth = (int) Math.sqrt(26 * 26 - (y - centerY) * (y - centerY));
+            graphics.fill(leftPos + 54, topPos + 16, leftPos + 120, topPos + 81, 0xFF101014);
-                graphics.fill(centerX - halfWidth, y, centerX + halfWidth + 1, y + 1, 0xFF241228);
+            renderPropertyGlyph(graphics);
-            }
         }
+        graphics.blit(BACKGROUND, leftPos, topPos, 0, 0, imageWidth, imageHeight, 256, 256);
     }
     @Override protected void renderLabels(GuiGraphics graphics, int mouseX, int mouseY) {
         graphics.drawString(font, playerInventoryTitle, inventoryLabelX, inventoryLabelY, 0x404040, false);
@@ -43,10 +50,112 @@ public final class InkMixerScreen extends AbstractContainerScreen<InkMixerMenu>
     @Override public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         super.render(graphics, mouseX, mouseY, partialTick);
         renderTooltip(graphics, mouseX, mouseY);
-        int x = mouseX - (leftPos + 88);
+        if (overBasin(mouseX, mouseY)) {
-        int y = mouseY - (topPos + 49);
+            var lines = new java.util.ArrayList<Component>();
-        if (x * x + y * y <= 26 * 26)
+            lines.add(Component.translatable("screen.rivencraft.ink_mixer.ink",
-            graphics.renderTooltip(font, Component.translatable("screen.rivencraft.ink_mixer.ink",
+                    menu.inkRemaining(), InkVialItem.CAPACITY));
-                    menu.inkRemaining(), InkVialItem.CAPACITY), mouseX, mouseY);
+            lines.add(Component.translatable("screen.rivencraft.ink_mixer.additive_hint"));
+            for (int index = 0; index < 3; index++) {
+                int chance = menu.modifierChancePermille(index);
+                if (chance > 0) lines.add(Component.translatable("screen.rivencraft.ink_mixer.chance",
+                        switch (index) {
+                            case 0 -> Component.translatable("item.rivencraft.link_property.disarm");
+                            case 1 -> Component.translatable("item.rivencraft.link_property.maintain_momentum");
+                            default -> Component.translatable("item.rivencraft.link_property.intra_linking");
+                        }, chance / 10.0));
+            }
+            graphics.renderTooltip(font, lines, java.util.Optional.empty(), mouseX, mouseY);
+        }
+    }
+
+    @Override public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        if ((button == 0 || button == 1) && overBasin(mouseX, mouseY)
+                && !menu.getCarried().isEmpty()) {
+            slotClicked(menu.getSlot(InkMixerMenu.MODIFIER), InkMixerMenu.MODIFIER, button, ClickType.PICKUP);
+            basinClickPendingRelease = true;
+            return true;
+        }
+        return super.mouseClicked(mouseX, mouseY, button);
+    }
+
+    @Override public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        if (basinClickPendingRelease) {
+            basinClickPendingRelease = false;
+            return true;
+        }
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    private boolean overBasin(double mouseX, double mouseY) {
+        double x = mouseX - leftPos - BASIN_X;
+        double y = mouseY - topPos - BASIN_Y;
+        return x * x + y * y < BASIN_RADIUS * BASIN_RADIUS;
+    }
+
+    /** A GUI-scale projection of Legacy's colored, rotating D'ni ink effect. */
+    private void renderPropertyGlyph(GuiGraphics graphics) {
+        long now = System.currentTimeMillis();
+        int[] active = new int[3];
+        int count = 0;
+        int strongest = 0;
+        for (int index = 0; index < lastChances.length; index++) {
+            int chance = menu.modifierChancePermille(index);
+            if (chance > lastChances[index]) lastAdditionTime = now;
+            lastChances[index] = chance;
+            if (chance > 0) {
+                active[count++] = index;
+                strongest = Math.max(strongest, chance);
+            }
+        }
+        if (count == 0) {
+            lastAdditionTime = 0;
+            return;
+        }
+
+        double cycle = now / 1800.0;
+        int first = active[(int) cycle % count];
+        int second = active[((int) cycle + 1) % count];
+        double blend = (1.0 - Math.cos((cycle % 1.0) * Math.PI)) / 2.0;
+        int rgb = blendRgb(PROPERTY_COLORS[first], PROPERTY_COLORS[second], blend);
+        double pulse = Math.max(0.0, 1.0 - (now - lastAdditionTime) / 700.0);
+        int alpha = Math.clamp((int) (70 + strongest * 0.14 + pulse * 45), 0, 255);
+        int color = alpha << 24 | rgb;
+        int centerX = leftPos + BASIN_X;
+        int centerY = topPos + BASIN_Y;
+        double turn = now / 1200.0;
+
+        for (int spoke = 0; spoke < 4; spoke++) {
+            for (int step = 0; step <= 30; step++) {
+                double progress = step / 30.0;
+                double angle = turn + spoke * Math.PI / 2.0 + progress * 0.9;
+                double radius = 3.0 + progress * (15.0 + pulse * 3.0);
+                plot(graphics, centerX + Math.cos(angle) * radius,
+                        centerY + Math.sin(angle) * radius, color);
+            }
+        }
+        for (int step = 0; step < 96; step++) {
+            double angle = step * Math.PI / 48.0 + turn * 0.3;
+            plot(graphics, centerX + Math.cos(angle) * 19.0,
+                    centerY + Math.sin(angle) * 19.0, color);
+            if (strongest >= 990 && step % 2 == 0) {
+                plot(graphics, centerX + Math.cos(angle) * 23.0,
+                        centerY + Math.sin(angle) * 23.0, color);
+            }
+        }
+    }
+
+    private static int blendRgb(int first, int second, double amount) {
+        int red = (int) (((first >> 16) & 0xFF) * (1.0 - amount)
+                + ((second >> 16) & 0xFF) * amount);
+        int green = (int) (((first >> 8) & 0xFF) * (1.0 - amount)
+                + ((second >> 8) & 0xFF) * amount);
+        int blue = (int) ((first & 0xFF) * (1.0 - amount) + (second & 0xFF) * amount);
+        return red << 16 | green << 8 | blue;
+    }
+
+    private static void plot(GuiGraphics graphics, double x, double y, int color) {
+        int pixelX = (int) Math.round(x);
+        int pixelY = (int) Math.round(y);
+        graphics.fill(pixelX, pixelY, pixelX + 1, pixelY + 1, color);
     }
 }

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

@@ -8,7 +8,7 @@ import net.minecraft.resources.ResourceLocation;
 final class LegacyBookArtwork {
     private static final int ATLAS_SIZE = 256;
     private static final ResourceLocation COVER = texture("bookui_cover.png");
-    private static final ResourceLocation LEFT_PAGE = texture("bookui_pagel.png");
+    private static final ResourceLocation LEFT_PAGE = texture("notebook_pages.png");
     private static final ResourceLocation RIGHT_PANEL = texture("bookui_pager.png");
     private static final ResourceLocation RIGHT_FULL = texture("bookui_rpage_full.png");
 

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

@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.client.SymbolPageTextures;
 import net.dnorberg.rivencraft.menu.NotebookMenu;
 import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.PageContent;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.Button;
 import net.minecraft.client.gui.components.EditBox;
@@ -115,7 +116,8 @@ public final class NotebookScreen extends AbstractContainerScreen<NotebookMenu>
         if (index >= 0 && (button == 0 || button == 1)) {
             ItemStack page = menu.getSlot(index).getItem();
             if ((!page.isEmpty() && !matchesSearch(page))
-                    || (page.isEmpty() && !menu.getCarried().is(ModItems.PAGE.get()))) {
+                    || (page.isEmpty() && (!menu.getCarried().is(ModItems.PAGE.get())
+                            || PageItem.content(menu.getCarried()).kind() == PageContent.Kind.LINK_PANEL))) {
                 return true;
             }
             setFocused(null);

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

@@ -7,6 +7,7 @@ import java.util.Comparator;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.client.SymbolPageTextures;
 import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.menu.WritingDeskMenu;
 import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
@@ -329,7 +330,9 @@ public final class WritingDeskScreen extends AbstractContainerScreen<WritingDesk
         int surfaceY = (int) Math.floor(mouseY - topPos - 20);
         if ((button == 0 || button == 1) && !menu.getCarried().isEmpty()
                 && surfaceX >= 0 && surfaceX < 155 && surfaceY >= 0 && surfaceY < 164) {
-            if (menu.getCarried().is(ModItems.PAGE.get()) && surfaceX % 31 < 30 && surfaceY % 41 < 40) {
+            if (menu.getCarried().is(ModItems.PAGE.get())
+                    && PageItem.content(menu.getCarried()).kind() != PageContent.Kind.LINK_PANEL
+                    && surfaceX % 31 < 30 && surfaceY % 41 < 40) {
                 int index = (surfaceY / 41 + scrollRows) * 5 + surfaceX / 31;
                 List<DisplayPage> entries = filteredPages();
                 // Only displayed positions are addressable. Filtering never turns

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

@@ -1,10 +1,17 @@
 package net.dnorberg.rivencraft.command;
 
 import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import net.dnorberg.rivencraft.block.DecayBlock;
 import net.dnorberg.rivencraft.book.AgeDefinition;
+import net.dnorberg.rivencraft.book.AgeDecayProviders;
+import net.dnorberg.rivencraft.book.AgeHazardProviders;
+import net.dnorberg.rivencraft.book.AgeEnvironmentalProviders;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
 import net.minecraft.commands.Commands;
+import net.minecraft.commands.CommandSourceStack;
+import com.mojang.brigadier.builder.LiteralArgumentBuilder;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
 import net.neoforged.neoforge.event.RegisterCommandsEvent;
@@ -30,7 +37,38 @@ public final class RivencraftCommands {
                                         .executes(context -> unloadAge(
                                                 context.getSource(),
                                                 StringArgumentType.getString(context, "dimension")
-                                        ))))));
+                                        ))))
+                        .then(Commands.literal("decay")
+                                .then(Commands.literal("pulse")
+                                        .then(Commands.argument("color", StringArgumentType.word())
+                                                .suggests((context, builder) -> {
+                                                    for (DecayBlock.Color color : DecayBlock.Color.values()) {
+                                                        builder.suggest(color.getSerializedName());
+                                                    }
+                                                    return builder.buildFuture();
+                                                })
+                                                .then(Commands.argument("attempts", IntegerArgumentType.integer(1, 32))
+                                                        .executes(context -> pulseDecay(context.getSource(),
+                                                                StringArgumentType.getString(context, "color"),
+                                                                IntegerArgumentType.getInteger(context, "attempts")))))))
+                        .then(Commands.literal("hazard")
+                                .then(Commands.literal("pulse")
+                                        .then(Commands.literal("lightning")
+                                                .executes(context -> pulseHazard(context.getSource(), true)))
+                                        .then(Commands.literal("explosion")
+                                                .executes(context -> pulseHazard(context.getSource(), false)))))
+                        .then(environmentCommand())));
+    }
+
+    private static LiteralArgumentBuilder<CommandSourceStack> environmentCommand() {
+        return Commands.literal("environment")
+                .then(Commands.literal("pulse")
+                        .then(Commands.literal("meteor")
+                                .executes(context -> pulseEnvironment(context.getSource(), "meteor")))
+                        .then(Commands.literal("burning")
+                                .executes(context -> pulseEnvironment(context.getSource(), "burning")))
+                        .then(Commands.literal("erosion")
+                                .executes(context -> pulseEnvironment(context.getSource(), "erosion"))));
     }
 
     private static int listAges(net.minecraft.commands.CommandSourceStack source) {
@@ -43,6 +81,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();
@@ -78,4 +118,54 @@ public final class RivencraftCommands {
             }
         };
     }
+
+    private static int pulseDecay(net.minecraft.commands.CommandSourceStack source, String colorName, int attempts) {
+        DecayBlock.Color color;
+        try {
+            color = DecayBlock.Color.valueOf(colorName.toUpperCase(java.util.Locale.ROOT));
+        } catch (IllegalArgumentException exception) {
+            source.sendFailure(Component.literal("Unknown decay color: " + colorName));
+            return 0;
+        }
+        if (source.getPlayer() == null) {
+            source.sendFailure(Component.literal("Run this command as a player standing in an Age."));
+            return 0;
+        }
+        int changed = AgeDecayProviders.pulseForTesting(source.getPlayer(), color, attempts);
+        if (changed < 0) {
+            source.sendFailure(Component.literal("Enter a loaded Age and enable instability.world_mutation and instability_decay.enabled first."));
+            return 0;
+        }
+        source.sendSuccess(() -> Component.literal("Decay " + colorName + ": " + changed
+                + " block(s) converted in " + attempts + " bounded attempt(s)."), true);
+        return changed;
+    }
+
+    private static int pulseHazard(net.minecraft.commands.CommandSourceStack source, boolean lightning) {
+        if (source.getPlayer() == null) {
+            source.sendFailure(Component.literal("Run this command as a player standing in an Age."));
+            return 0;
+        }
+        int result = AgeHazardProviders.pulseForTesting(source.getPlayer(), lightning);
+        if (result < 0) source.sendFailure(Component.literal("Enter a loaded Age and enable instability_hazards.enabled first."));
+        else if (result == 0) source.sendFailure(Component.literal("Hazard is on cooldown or no safe loaded target is available."));
+        else source.sendSuccess(() -> Component.literal("Triggered one bounded "
+                + (lightning ? "lightning strike" : "explosion") + " in this Age."), true);
+        return Math.max(0, result);
+    }
+
+    private static int pulseEnvironment(CommandSourceStack source, String effect) {
+        if (source.getPlayer() == null) {
+            source.sendFailure(Component.literal("Run this command as a player standing in an Age."));
+            return 0;
+        }
+        int result = AgeEnvironmentalProviders.pulseForTesting(source.getPlayer(), effect);
+        if (result == -2) source.sendFailure(Component.literal(
+                "Burning is extinguished by rain or water. Move to a dry, sky-exposed spot and retry."));
+        else if (result < 0) source.sendFailure(Component.literal("Enter a loaded Age to test the environmental effect."));
+        else if (result == 0) source.sendFailure(Component.literal(
+                "No eligible target, effect disabled, or meteor on cooldown. For erosion, aim at a block beside source fluid."));
+        else source.sendSuccess(() -> Component.literal("Triggered " + effect + " in this Age."), true);
+        return Math.max(0, result);
+    }
 }

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/compat/TerraBlenderBiomes.java

@@ -0,0 +1,33 @@
+package net.dnorberg.rivencraft.compat;
+
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.fml.ModList;
+
+/** Optional boundary: core Age code never loads TerraBlender API classes. */
+public final class TerraBlenderBiomes {
+    private static final AtomicBoolean WARNED = new AtomicBoolean();
+    private TerraBlenderBiomes() {}
+
+    public static List<ResourceLocation> overworld(RegistryAccess registries) {
+        return collect(registries, false);
+    }
+
+    public static List<ResourceLocation> nether(RegistryAccess registries) {
+        return collect(registries, true);
+    }
+
+    private static List<ResourceLocation> collect(RegistryAccess registries, boolean nether) {
+        if (!ModList.get().isLoaded("terrablender")) return List.of();
+        try {
+            return TerraBlenderRegionAdapter.collect(registries, nether);
+        } catch (RuntimeException | LinkageError exception) {
+            if (WARNED.compareAndSet(false, true))
+                Rivencraft.LOGGER.warn("TerraBlender biome regions could not be read; using Rivencraft's biome pool", exception);
+            return List.of();
+        }
+    }
+}

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

@@ -0,0 +1,34 @@
+package net.dnorberg.rivencraft.compat;
+
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Set;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.biome.Biome;
+import terrablender.api.Region;
+import terrablender.api.RegionType;
+import terrablender.api.Regions;
+
+/** Loaded only after the optional TerraBlender mod is confirmed present. */
+final class TerraBlenderRegionAdapter {
+    private TerraBlenderRegionAdapter() {}
+
+    static List<ResourceLocation> collect(RegistryAccess registries, boolean nether) {
+        var biomes = registries.registryOrThrow(Registries.BIOME);
+        RegionType type = nether ? RegionType.NETHER : RegionType.OVERWORLD;
+        Set<ResourceLocation> ids = new LinkedHashSet<>();
+        for (Region region : Regions.get(type)) {
+            region.addBiomes(biomes, mapping -> {
+                ResourceKey<Biome> key = mapping.getSecond();
+                ResourceLocation id = key.location();
+                // Vanilla's default region is always present. Only additions from
+                // other mods extend an Age's existing deterministic biome pool.
+                if (!id.getNamespace().equals("minecraft") && biomes.containsKey(id)) ids.add(id);
+            });
+        }
+        return ids.stream().sorted().toList();
+    }
+}

src/main/java/net/dnorberg/rivencraft/compat/jei/RivencraftJeiPlugin.java

@@ -19,14 +19,20 @@ import mezz.jei.api.registration.IRecipeRegistration;
 import mezz.jei.api.registration.ISubtypeRegistration;
 import mezz.jei.api.registration.IExtraIngredientRegistration;
 import mezz.jei.api.ingredients.subtypes.IIngredientSubtypeInterpreter;
+import mezz.jei.api.ingredients.subtypes.UidContext;
 import mezz.jei.api.runtime.IJeiRuntime;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.book.LinkProperties;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.writing.InkModifierIngredients;
 import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.network.chat.Component;
+import net.minecraft.network.chat.MutableComponent;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.Items;
@@ -51,7 +57,8 @@ public final class RivencraftJeiPlugin implements IModPlugin {
                     PageContent content = PageItem.content(stack);
                     return switch (content.kind()) {
                         case BLANK -> "blank";
-                        case LINK_PANEL -> "link_panel";
+                        case LINK_PANEL -> "link_panel:" + stack.getOrDefault(
+                                ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE).flags();
                         case SYMBOL -> "symbol:" + content.symbol().orElseThrow().id();
                         case UNRESOLVED_SYMBOL -> "unresolved:" + content.symbol().orElseThrow().id();
                     };
@@ -61,7 +68,7 @@ public final class RivencraftJeiPlugin implements IModPlugin {
     @Override
     public void registerExtraIngredients(IExtraIngredientRegistration registration) {
         List<ItemStack> pages = new ArrayList<>();
-        pages.add(PageItem.createLinkPanelPage());
+        pages.addAll(PageItem.creativeLinkPanelPages());
         var connection = Minecraft.getInstance().getConnection();
         if (connection != null) {
             pages.addAll(PageItem.creativeSymbolPages(connection.registryAccess()));
@@ -74,6 +81,9 @@ public final class RivencraftJeiPlugin implements IModPlugin {
 
     @Override
     public void onRuntimeAvailable(IJeiRuntime runtime) {
+        // JEI discovers the base Page item as a blank stack; only authored pages belong in its list.
+        runtime.getIngredientVisibility().hideIngredients(VanillaTypes.ITEM_STACK,
+                List.of(new ItemStack(ModItems.PAGE.get())), List.of(UidContext.Ingredient));
         var connection = Minecraft.getInstance().getConnection();
         if (connection == null) return;
         Set<ResourceLocation> known = runtime.getIngredientManager().getAllItemStacks().stream()
@@ -99,17 +109,23 @@ public final class RivencraftJeiPlugin implements IModPlugin {
     @Override
     public void registerRecipes(IRecipeRegistration registration) {
         ItemStack panel = PageItem.createLinkPanelPage();
+        ItemStack symbolPage = PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "terrain/standard")));
         registration.addRecipes(WRITING, List.of(
                 new WritingGuide(List.of(new ItemStack(Items.PAPER), new ItemStack(ModItems.INK_VIAL.get())),
                         panel, "jei.rivencraft.writing.link_panel_hand"),
-                new WritingGuide(List.of(panel, new ItemStack(Items.PAPER), new ItemStack(ModItems.INK_VIAL.get())),
+                new WritingGuide(List.of(symbolPage, new ItemStack(Items.PAPER), new ItemStack(ModItems.INK_VIAL.get())),
-                        panel, "jei.rivencraft.writing.copy"),
+                        symbolPage, "jei.rivencraft.writing.copy"),
                 new WritingGuide(List.of(new ItemStack(Items.LEATHER), panel),
                         new ItemStack(ModItems.DESCRIPTIVE_BOOK.get()), "jei.rivencraft.writing.bind"),
                 new WritingGuide(List.of(panel, new ItemStack(Items.LEATHER)),
                         new ItemStack(ModItems.LINKING_BOOK.get()), "jei.rivencraft.writing.linking_book")
         ));
-        registration.addRecipes(INK_MIXER, List.of(new InkMixerGuide(panel)));
+        List<InkMixerGuide> mixerGuides = new ArrayList<>();
+        mixerGuides.add(new InkMixerGuide(panel, null));
+        InkModifierIngredients.builtIn().forEach(ingredient ->
+                mixerGuides.add(new InkMixerGuide(panel, ingredient)));
+        registration.addRecipes(INK_MIXER, mixerGuides);
     }
 
     @Override
@@ -120,7 +136,7 @@ public final class RivencraftJeiPlugin implements IModPlugin {
     }
 
     private record WritingGuide(List<ItemStack> inputs, ItemStack output, String instructionKey) {}
-    private record InkMixerGuide(ItemStack panel) {}
+    private record InkMixerGuide(ItemStack panel, InkModifierIngredients.Ingredient additive) {}
 
     private static final class InkMixerCategory extends AbstractRecipeCategory<InkMixerGuide> {
         InkMixerCategory(IGuiHelper guiHelper) {
@@ -134,6 +150,9 @@ public final class RivencraftJeiPlugin implements IModPlugin {
             builder.addInputSlot(2, 3).setStandardSlotBackground().addItemStack(new ItemStack(Items.PAPER));
             builder.addInputSlot(23, 3).setStandardSlotBackground()
                     .addItemStack(new ItemStack(ModItems.INK_VIAL.get()));
+            if (recipe.additive() != null)
+                builder.addInputSlot(44, 3).setStandardSlotBackground()
+                        .addItemStack(recipe.additive().item());
             builder.addOutputSlot(112, 3).setOutputSlotBackground().addItemStack(recipe.panel());
             builder.addOutputSlot(112, 46).setStandardSlotBackground()
                     .addItemStack(new ItemStack(Items.GLASS_BOTTLE));
@@ -142,8 +161,20 @@ public final class RivencraftJeiPlugin implements IModPlugin {
         @Override
         public void draw(InkMixerGuide recipe, IRecipeSlotsView slots, GuiGraphics graphics,
                          double mouseX, double mouseY) {
-            graphics.drawWordWrap(Minecraft.getInstance().font,
+            Component instructions = recipe.additive() == null
-                    Component.translatable("jei.rivencraft.ink_mixer.usage"), 2, 27, 104, 0x404040);
+                    ? Component.translatable("jei.rivencraft.ink_mixer.usage")
+                    : additiveInstructions(recipe.additive());
+            graphics.drawWordWrap(Minecraft.getInstance().font, instructions, 2, 27, 104, 0x404040);
+        }
+
+        private static Component additiveInstructions(InkModifierIngredients.Ingredient additive) {
+            MutableComponent effects = Component.empty();
+            for (InkModifierIngredients.Effect effect : additive.effects()) {
+                if (!effects.getSiblings().isEmpty()) effects.append(", ");
+                effects.append(Component.translatable("jei.rivencraft.ink_mixer.effect",
+                        LinkProperties.name(effect.flag()), Math.round(effect.chance() * 100)));
+            }
+            return Component.translatable("jei.rivencraft.ink_mixer.additive", effects);
         }
     }
 

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

@@ -17,6 +17,45 @@ 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;
+    private static final ModConfigSpec.BooleanValue INSTABILITY_ENABLED;
+    private static final ModConfigSpec.BooleanValue INSTABILITY_WORLD_MUTATION;
+    private static final ModConfigSpec.IntValue INSTABILITY_COOLDOWN;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_AGES;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_PROVIDERS;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_ACTIONS;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_LEVEL;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_CHUNKS;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_ENABLED;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_PLAYERS;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_NONPLAYERS;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_HOSTILES;
+    private static final ModConfigSpec.IntValue STATUS_EFFECTS_MAX_ACTIVE;
+    private static final ModConfigSpec.IntValue STATUS_EFFECTS_MAX_CANDIDATES;
+    private static final ModConfigSpec.IntValue STATUS_EFFECTS_MAX_DURATION;
+    private static final ModConfigSpec.BooleanValue DECAY_ENABLED;
+    private static final ModConfigSpec.IntValue DECAY_MAX_ATTEMPTS;
+    private static final ModConfigSpec.BooleanValue HAZARDS_ENABLED;
+    private static final ModConfigSpec.BooleanValue HAZARDS_BLOCK_DAMAGE;
+    private static final ModConfigSpec.BooleanValue HAZARDS_PLAYER_DAMAGE;
+    private static final ModConfigSpec.BooleanValue HAZARDS_FIRE;
+    private static final ModConfigSpec.IntValue HAZARDS_MIN_INTERVAL;
+    private static final ModConfigSpec.IntValue HAZARDS_MAX_CHUNKS;
+    private static final ModConfigSpec.IntValue HAZARDS_MAX_BLOCKS;
+    private static final ModConfigSpec.IntValue HAZARDS_MAX_ENTITIES;
+    private static final ModConfigSpec.IntValue HAZARDS_MAX_DAMAGE;
+    private static final ModConfigSpec.IntValue HAZARDS_EXPLOSION_RADIUS;
+    private static final ModConfigSpec.BooleanValue METEOR_ENABLED;
+    private static final ModConfigSpec.BooleanValue METEOR_BLOCK_DAMAGE;
+    private static final ModConfigSpec.BooleanValue METEOR_PLAYER_DAMAGE;
+    private static final ModConfigSpec.BooleanValue METEOR_FIRE;
+    private static final ModConfigSpec.IntValue METEOR_MAX_BLOCKS;
+    private static final ModConfigSpec.IntValue METEOR_MAX_ENTITIES;
+    private static final ModConfigSpec.IntValue METEOR_MAX_DAMAGE;
+    private static final ModConfigSpec.BooleanValue SCORCH_ENABLED;
+    private static final ModConfigSpec.BooleanValue SCORCH_PLAYERS;
+    private static final ModConfigSpec.IntValue SCORCH_MAX_TARGETS;
+    private static final ModConfigSpec.BooleanValue EROSION_ENABLED;
 
     static {
         ModConfigSpec.Builder builder = new ModConfigSpec.Builder();
@@ -33,6 +72,104 @@ 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();
+        builder.push("instability");
+        INSTABILITY_ENABLED = builder.comment("Run selected instability providers in loaded Ages. Disabling does not alter saved plans.")
+                .define("enabled", true);
+        INSTABILITY_WORLD_MUTATION = builder.comment("Allow selected instability providers to change blocks or create explosions, as in Legacy.")
+                .define("world_mutation", true);
+        INSTABILITY_COOLDOWN = builder.comment("Minimum ticks between instability runs for each loaded Age.")
+                .defineInRange("cooldown_ticks", 20, 20, 1200);
+        INSTABILITY_MAX_AGES = builder.comment("Maximum loaded Ages processed in one server tick.")
+                .defineInRange("max_ages_per_tick", 4, 1, 16);
+        INSTABILITY_MAX_PROVIDERS = builder.comment("Maximum provider handlers called in one Age run.")
+                .defineInRange("max_providers_per_age", 2, 1, 16);
+        INSTABILITY_MAX_ACTIONS = builder.comment("Shared effect-action budget for one Age run.")
+                .defineInRange("max_actions_per_age", 1, 1, 16);
+        INSTABILITY_MAX_LEVEL = builder.comment("Maximum effective level passed to an effect handler; saved levels are unchanged.")
+                .defineInRange("max_effect_level", 3, 1, 16);
+        INSTABILITY_MAX_CHUNKS = builder.comment("Maximum already-loaded candidate chunks inspected per Age run.")
+                .defineInRange("max_loaded_chunks", 16, 1, 64);
+        builder.pop();
+        builder.push("instability_status_effects");
+        STATUS_EFFECTS_ENABLED = builder.comment("Allow bounded instability status effects in loaded Ages.")
+                .define("enabled", true);
+        STATUS_EFFECTS_PLAYERS = builder.comment("Allow instability status effects on survival/adventure players.")
+                .define("affect_players", true);
+        STATUS_EFFECTS_NONPLAYERS = builder.comment("Allow general instability status effects on non-player living entities, as in Legacy.")
+                .define("affect_nonplayers", true);
+        STATUS_EFFECTS_HOSTILES = builder.comment("Allow regeneration and resistance on hostile mobs.")
+                .define("buff_hostiles", true);
+        STATUS_EFFECTS_MAX_ACTIVE = builder.comment("Maximum Rivencraft-owned active effect leases per Age.")
+                .defineInRange("max_active_per_age", 32, 1, 128);
+        STATUS_EFFECTS_MAX_CANDIDATES = builder.comment("Maximum living entities examined in one chosen loaded chunk.")
+                .defineInRange("max_candidates_per_attempt", 8, 1, 16);
+        STATUS_EFFECTS_MAX_DURATION = builder.comment("Maximum duration in ticks for one instability status effect.")
+                .defineInRange("max_duration_ticks", 200, 20, 200);
+        builder.pop();
+        builder.push("instability_decay");
+        DECAY_ENABLED = builder.comment("Allow destructive colored decay inside loaded Ages, as in Legacy. Also requires instability.world_mutation.")
+                .define("enabled", true);
+        DECAY_MAX_ATTEMPTS = builder.comment("Maximum six-neighbor decay conversion attempts per provider call; at most one block changes.")
+                .defineInRange("max_attempts_per_call", 4, 1, 6);
+        builder.pop();
+        builder.push("instability_hazards");
+        HAZARDS_ENABLED = builder.comment("Run Legacy lightning and explosion cards in loaded Ages.")
+                .define("enabled", true);
+        HAZARDS_BLOCK_DAMAGE = builder.comment("Allow explosions to destroy blocks. Also requires instability.world_mutation and mobGriefing.")
+                .define("block_damage", true);
+        HAZARDS_PLAYER_DAMAGE = builder.comment("Allow lightning and explosions to hurt survival/adventure players.")
+                .define("player_damage", true);
+        HAZARDS_FIRE = builder.comment("Allow lightning and explosions to ignite blocks when doFireTick is enabled.")
+                .define("fire", true);
+        HAZARDS_MIN_INTERVAL = builder.comment("Minimum game ticks between hazard events of each type in one Age.",
+                        "Renamed from min_interval_ticks so existing 200-tick test configs receive the Legacy-rate default.")
+                .defineInRange("minimum_gap_ticks", 20, 20, 12000);
+        HAZARDS_MAX_CHUNKS = builder.comment("Maximum already-loaded chunks sampled around Age players per hazard roll.")
+                .defineInRange("max_loaded_chunks", 81, 1, 169);
+        HAZARDS_MAX_BLOCKS = builder.comment("Maximum distinct blocks one instability explosion may destroy.")
+                .defineInRange("max_explosion_blocks", 16, 0, 64);
+        HAZARDS_MAX_ENTITIES = builder.comment("Maximum entities damaged by one hazard event.")
+                .defineInRange("max_damaged_entities", 8, 0, 32);
+        HAZARDS_MAX_DAMAGE = builder.comment("Maximum damage per entity from one hazard event.")
+                .defineInRange("max_entity_damage", 12, 0, 40);
+        HAZARDS_EXPLOSION_RADIUS = builder.comment("Explosion strength. Legacy used 3; capped to remain inside one loaded chunk.")
+                .defineInRange("explosion_radius", 3, 1, 3);
+        builder.pop();
+        builder.push("instability_meteor");
+        METEOR_ENABLED = builder.comment("Allow the active Legacy meteor card in loaded Ages.")
+                .define("enabled", true);
+        METEOR_BLOCK_DAMAGE = builder.comment("Allow meteor impacts to destroy blocks; also requires instability.world_mutation and mobGriefing.")
+                .define("block_damage", true);
+        METEOR_PLAYER_DAMAGE = builder.comment("Allow meteor impacts to hurt survival/adventure players.")
+                .define("player_damage", true);
+        METEOR_FIRE = builder.comment("Allow meteor impacts to ignite blocks when doFireTick is enabled.")
+                .define("fire", true);
+        METEOR_MAX_BLOCKS = builder.comment("Maximum blocks destroyed by one meteor impact.")
+                .defineInRange("max_impact_blocks", 24, 0, 64);
+        METEOR_MAX_ENTITIES = builder.comment("Maximum entities damaged by one meteor impact.")
+                .defineInRange("max_damaged_entities", 8, 0, 32);
+        METEOR_MAX_DAMAGE = builder.comment("Maximum damage per entity from one meteor impact.")
+                .defineInRange("max_entity_damage", 12, 0, 40);
+        builder.pop();
+        builder.push("instability_scorching");
+        SCORCH_ENABLED = builder.comment("Allow Legacy's active burning card to ignite sky-exposed entities.")
+                .define("enabled", true);
+        SCORCH_PLAYERS = builder.comment("Allow burning to affect survival/adventure players.")
+                .define("affect_players", true);
+        SCORCH_MAX_TARGETS = builder.comment("Maximum entities ignited per Age scheduler pass.")
+                .defineInRange("max_targets_per_pass", 4, 0, 16);
+        builder.pop();
+        builder.push("instability_erosion");
+        EROSION_ENABLED = builder.comment("Enable Legacy's dormant erosion effect for testing; no saved provider card is added.",
+                        "Ages with a destructive instability score may spread adjacent fluid into one safe block per pass.")
+                .define("enabled", true);
+        builder.pop();
         SPEC = builder.build();
     }
 
@@ -50,4 +187,47 @@ public final class RivencraftConfig {
     public static int linkPanelInkCost() {
         return LINK_PANEL_INK_COST.get();
     }
+
+    public static boolean autoWhitelistSereneAges() {
+        return AUTO_WHITELIST_SERENE_AGES.get();
+    }
+
+    public static boolean instabilityEnabled() { return INSTABILITY_ENABLED.get(); }
+    public static boolean instabilityWorldMutation() { return INSTABILITY_WORLD_MUTATION.get(); }
+    public static int instabilityCooldown() { return INSTABILITY_COOLDOWN.get(); }
+    public static int instabilityMaxAges() { return INSTABILITY_MAX_AGES.get(); }
+    public static int instabilityMaxProviders() { return INSTABILITY_MAX_PROVIDERS.get(); }
+    public static int instabilityMaxActions() { return INSTABILITY_MAX_ACTIONS.get(); }
+    public static int instabilityMaxLevel() { return INSTABILITY_MAX_LEVEL.get(); }
+    public static int instabilityMaxChunks() { return INSTABILITY_MAX_CHUNKS.get(); }
+    public static boolean statusEffectsEnabled() { return STATUS_EFFECTS_ENABLED.get(); }
+    public static boolean statusEffectsPlayers() { return STATUS_EFFECTS_PLAYERS.get(); }
+    public static boolean statusEffectsNonplayers() { return STATUS_EFFECTS_NONPLAYERS.get(); }
+    public static boolean statusEffectsHostiles() { return STATUS_EFFECTS_HOSTILES.get(); }
+    public static int statusEffectsMaxActive() { return STATUS_EFFECTS_MAX_ACTIVE.get(); }
+    public static int statusEffectsMaxCandidates() { return STATUS_EFFECTS_MAX_CANDIDATES.get(); }
+    public static int statusEffectsMaxDuration() { return STATUS_EFFECTS_MAX_DURATION.get(); }
+    public static boolean decayEnabled() { return DECAY_ENABLED.get(); }
+    public static int decayMaxAttempts() { return DECAY_MAX_ATTEMPTS.get(); }
+    public static boolean hazardsEnabled() { return HAZARDS_ENABLED.get(); }
+    public static boolean hazardsBlockDamage() { return HAZARDS_BLOCK_DAMAGE.get(); }
+    public static boolean hazardsPlayerDamage() { return HAZARDS_PLAYER_DAMAGE.get(); }
+    public static boolean hazardsFire() { return HAZARDS_FIRE.get(); }
+    public static int hazardsMinInterval() { return HAZARDS_MIN_INTERVAL.get(); }
+    public static int hazardsMaxChunks() { return HAZARDS_MAX_CHUNKS.get(); }
+    public static int hazardsMaxBlocks() { return HAZARDS_MAX_BLOCKS.get(); }
+    public static int hazardsMaxEntities() { return HAZARDS_MAX_ENTITIES.get(); }
+    public static int hazardsMaxDamage() { return HAZARDS_MAX_DAMAGE.get(); }
+    public static int hazardsExplosionRadius() { return HAZARDS_EXPLOSION_RADIUS.get(); }
+    public static boolean meteorEnabled() { return METEOR_ENABLED.get(); }
+    public static boolean meteorBlockDamage() { return METEOR_BLOCK_DAMAGE.get(); }
+    public static boolean meteorPlayerDamage() { return METEOR_PLAYER_DAMAGE.get(); }
+    public static boolean meteorFire() { return METEOR_FIRE.get(); }
+    public static int meteorMaxBlocks() { return METEOR_MAX_BLOCKS.get(); }
+    public static int meteorMaxEntities() { return METEOR_MAX_ENTITIES.get(); }
+    public static int meteorMaxDamage() { return METEOR_MAX_DAMAGE.get(); }
+    public static boolean scorchEnabled() { return SCORCH_ENABLED.get(); }
+    public static boolean scorchPlayers() { return SCORCH_PLAYERS.get(); }
+    public static int scorchMaxTargets() { return SCORCH_MAX_TARGETS.get(); }
+    public static boolean erosionEnabled() { return EROSION_ENABLED.get(); }
 }

src/main/java/net/dnorberg/rivencraft/gametest/BookBinderGameTests.java

@@ -6,6 +6,9 @@ import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
+import net.dnorberg.rivencraft.book.LinkProperties;
+import net.dnorberg.rivencraft.book.LinkTarget;
+import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.menu.BookBinderMenu;
 import net.dnorberg.rivencraft.registry.ModBlocks;
@@ -17,6 +20,7 @@ import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.GlobalPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.resources.ResourceLocation;
@@ -97,7 +101,6 @@ public final class BookBinderGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void conflictingGrammarKeepsBinderInputsRecoverable(GameTestHelper helper) {
         BookBinderBlockEntity binder = place(helper);
         binder.setTitle("Recoverable Duplicate");
@@ -105,21 +108,22 @@ public final class BookBinderGameTests {
         binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
         binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
         binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 5, terrainPage());
-        helper.assertFalse(binder.canAssemble(), "Duplicate terrain must not assemble a new Age");
+        helper.assertTrue(binder.canAssemble(), "Duplicate terrain must create an unstable Age");
-        int errorEntry = binder.writingGrammar().firstError().orElseThrow().index();
+        int errorEntry = binder.writingGrammar().firstWarning().orElseThrow().index();
         helper.assertValueEqual(errorEntry, 2, "Parser must identify the second authored symbol");
         helper.assertValueEqual(binder.writingStripIndex(errorEntry), 6,
-                "A grammar error must highlight the correct strip page despite empty positions");
+                "An instability warning must highlight the correct strip page despite empty positions");
-        helper.assertFalse(binder.consumeAssembly(), "Rejected grammar must not consume binder inputs");
+        helper.assertValueEqual(binder.writingGrammar().writingInstability(), 500,
+                "An extra controller must carry a persisted writing penalty");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
-                "Rejected grammar must leave the cover recoverable");
+                "Warning preview must not consume the cover");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
-                "Rejected grammar must leave the Link Panel recoverable");
+                "Warning preview must not consume the Link Panel");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 5).is(ModItems.PAGE.get()),
-                "Rejected grammar must leave the duplicate page removable");
+                "Unstable writing must remain editable before assembly");
         ItemStack removed = binder.takePage(5);
-        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to correct the duplicate page");
+        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to remove the duplicate page");
-        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must become assemblable");
+        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must remain assemblable");
         helper.succeed();
     }
 
@@ -133,7 +137,14 @@ public final class BookBinderGameTests {
         helper.assertFalse(binder.consumeAssembly(), "Failure must consume nothing");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
                 "Rejected assembly must preserve cover");
-        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        ItemStack flavoredPanel = PageItem.createLinkPanelPage();
+        flavoredPanel.set(ModDataComponents.LINK_PROPERTIES.get(),
+                new net.dnorberg.rivencraft.book.LinkProperties(
+                        net.dnorberg.rivencraft.book.LinkProperties.DISARM
+                                | net.dnorberg.rivencraft.book.LinkProperties.MAINTAIN_MOMENTUM
+                                | net.dnorberg.rivencraft.book.LinkProperties.INTRA_LINKING));
+        var expectedProperties = flavoredPanel.get(ModDataComponents.LINK_PROPERTIES.get()).forDescriptiveBook();
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, flavoredPanel);
         var player = helper.makeMockServerPlayerInLevel();
         player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
                 binder.getBlockPos().getZ() + 0.5);
@@ -143,6 +154,9 @@ public final class BookBinderGameTests {
         menu.clicked(BookBinderMenu.RESULT, 0, ClickType.PICKUP, player);
         ItemStack book = menu.getCarried();
         helper.assertTrue(book.is(ModItems.DESCRIPTIVE_BOOK.get()), "Result must be a Descriptive Book");
+        helper.assertValueEqual(book.get(ModDataComponents.LINK_PROPERTIES.get()),
+                expectedProperties,
+                "Binder must retain Disarm and Momentum but omit Intra Linking");
         AgeReference age = book.get(ModDataComponents.AGE_REFERENCE.get());
         helper.assertTrue(age != null, "Assembled book must already be a written Age book");
         OrderedWriting writing = book.get(ModDataComponents.BOOK_WRITING.get());
@@ -175,6 +189,50 @@ public final class BookBinderGameTests {
         helper.succeed();
     }
 
+    public static void panelOnlyBookRetainsApplicableModifiers(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Modified Random Age");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        ItemStack panel = PageItem.createLinkPanelPage();
+        panel.set(ModDataComponents.LINK_PROPERTIES.get(), new LinkProperties(
+                LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM | LinkProperties.INTRA_LINKING));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        menu.setCarried(panel);
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE),
+                "The link strip must accept the modified panel without symbol pages");
+        ItemStack result = menu.quickMoveStack(player, BookBinderMenu.RESULT);
+        helper.assertTrue(result.is(ModItems.DESCRIPTIVE_BOOK.get()),
+                "A Link Panel alone must create a random-Age Descriptive Book");
+        LinkProperties expected = new LinkProperties(LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM);
+        helper.assertValueEqual(result.get(ModDataComponents.LINK_PROPERTIES.get()), expected,
+                "The panel-only book must keep travel modifiers but omit Intra Linking");
+        ItemStack restored = ItemStack.parseOptional(helper.getLevel().registryAccess(),
+                (net.minecraft.nbt.CompoundTag) result.saveOptional(helper.getLevel().registryAccess()));
+        helper.assertValueEqual(restored.get(ModDataComponents.LINK_PROPERTIES.get()), expected,
+                "Panel-only book modifiers must survive save and reload");
+        BlockPos departure = player.blockPosition();
+        BlockPos destination = departure.offset(3, 0, 0);
+        helper.getLevel().setBlock(destination.below(), Blocks.STONE.defaultBlockState(), 3);
+        helper.getLevel().setBlock(destination, Blocks.AIR.defaultBlockState(), 3);
+        helper.getLevel().setBlock(destination.above(), Blocks.AIR.defaultBlockState(), 3);
+        player.getInventory().setItem(4, new ItemStack(Items.DIAMOND, 3));
+        LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), destination), 0.0F, 0.0F);
+        helper.assertValueEqual(LinkingService.travelWithFooting(player, target,
+                        restored.get(ModDataComponents.LINK_PROPERTIES.get()).forDescriptiveBook()),
+                LinkingService.LinkResult.SUCCESS,
+                "The panel-only book's properties must be accepted by grounded travel");
+        helper.assertTrue(player.getInventory().getItem(4).isEmpty(),
+                "Disarm must remove the carried items during panel-only book travel");
+        helper.assertTrue(helper.getLevel().getEntitiesOfClass(ItemEntity.class,
+                        new AABB(departure).inflate(5.0), entity -> entity.getItem().is(Items.DIAMOND))
+                        .stream().mapToInt(entity -> entity.getItem().getCount()).sum() >= 3,
+                "Disarm must drop the items at the departure location");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void linkPanelOnlyCreatesCompletedRandomAgeBook(GameTestHelper helper) {
         BookBinderBlockEntity binder = place(helper);

src/main/java/net/dnorberg/rivencraft/gametest/BookPageCapacityGameTests.java

@@ -0,0 +1,68 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class BookPageCapacityGameTests {
+    private BookPageCapacityGameTests() {}
+
+    private static ItemStack page(String path) {
+        return PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path)));
+    }
+
+    @GameTest(template = "empty")
+    public static void binderAndNotebookRetainPagesBeyondOldLimit(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.BOOK_BINDER.get().defaultBlockState(), 3);
+        BookBinderBlockEntity binder = (BookBinderBlockEntity) helper.getLevel().getBlockEntity(pos);
+        binder.setTitle("Long Age");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        for (int index = 0; index < 32; index++) {
+            helper.assertTrue(binder.insertPage(index, page("terrain/standard")),
+                    "Binder must accept page " + (index + 1));
+        }
+        binder.setItem(BookBinderBlockEntity.SIZE - 1, page("weather/normal"));
+        BookBinderBlockEntity restored = new BookBinderBlockEntity(pos, binder.getBlockState());
+        restored.setLevel(helper.getLevel());
+        restored.loadWithComponents(binder.saveWithoutMetadata(helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.nextPageIndex(), BookBinderBlockEntity.PAGE_COUNT,
+                "Binder must retain its highest valid page position after reload");
+        helper.assertTrue(restored.getItem(BookBinderBlockEntity.FIRST_PAGE + 31).is(ModItems.PAGE.get()),
+                "Page 32 must survive reload");
+        helper.assertTrue(restored.getItem(BookBinderBlockEntity.SIZE - 1).is(ModItems.PAGE.get()),
+                "The final fixed-slot page must survive reload");
+        helper.assertValueEqual(restored.writingGrammar().symbols().size(), 33,
+                "Grammar must retain all authored pages");
+
+        List<ItemStack> notebookPages = new ArrayList<>();
+        for (int index = 0; index < NotebookContents.MAX_PAGES; index++) notebookPages.add(ItemStack.EMPTY);
+        notebookPages.set(31, page("terrain/standard"));
+        notebookPages.set(NotebookContents.MAX_PAGES - 1, page("weather/normal"));
+        NotebookContents notebook = new NotebookContents(notebookPages);
+        helper.assertValueEqual(notebook.pages().size(), NotebookContents.MAX_PAGES,
+                "Notebook must retain its highest valid page position");
+        helper.assertValueEqual(notebook.pageCount(), 2,
+                "Sparse Notebook contents must retain both pages");
+        helper.succeed();
+    }
+}

src/main/java/net/dnorberg/rivencraft/gametest/CoreGameTests.java

@@ -1,8 +1,10 @@
 package net.dnorberg.rivencraft.gametest;
 
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.BiomeSymbolPages;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
 import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
@@ -87,6 +89,26 @@ public final class CoreGameTests {
         BookBinderGameTests.assemblyIsAtomicAndRetainsPageOrder(helper);
     }
 
+    @GameTest(template = "empty")
+    public static void panelOnlyBookModifiers(GameTestHelper helper) {
+        BookBinderGameTests.panelOnlyBookRetainsApplicableModifiers(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void biomePageNamespaces(GameTestHelper helper) {
+        helper.assertValueEqual(BiomeSymbolPages.symbolId(ResourceLocation.parse("minecraft:desert")),
+                ResourceLocation.parse("rivencraft:biome/desert"), "Vanilla biome page IDs must remain stable");
+        helper.assertFalse(BiomeSymbolPages.symbolId(ResourceLocation.parse("example:orchard"))
+                        .equals(BiomeSymbolPages.symbolId(ResourceLocation.parse("another:orchard"))),
+                "Equal biome paths from different mods must not share a page ID");
+        helper.assertFalse(BiomeSymbolPages.isPublicPageBiome(
+                        ResourceLocation.parse("terrablender:deferred_placeholder")),
+                "TerraBlender's internal staging biome must not appear as a creative or JEI page");
+        helper.assertTrue(BiomeSymbolPages.isPublicPageBiome(ResourceLocation.parse("biomesoplenty:orchard")),
+                "Real modded biome pages must remain visible");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void binderRejectsConflictingGrammar(GameTestHelper helper) {
         BookBinderGameTests.conflictingGrammarKeepsBinderInputsRecoverable(helper);
@@ -102,6 +124,11 @@ public final class CoreGameTests {
         InkMixerGameTests.linkPanelRequiresTakingOutputAndPersistsInk(helper);
     }
 
+    @GameTest(template = "empty")
+    public static void mixerModifierTransaction(GameTestHelper helper) {
+        InkMixerGameTests.modifierClickPersistsPreviewAndConsumesOnce(helper);
+    }
+
     @GameTest(template = "empty")
     public static void linkingBookRecipe(GameTestHelper helper) {
         LinkingBookRecipeGameTests.legacyRecipeRequiresExactlyLeatherAndLinkPanel(helper);

src/main/java/net/dnorberg/rivencraft/gametest/InkMixerGameTests.java

@@ -4,7 +4,6 @@ import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
 import net.dnorberg.rivencraft.menu.InkMixerMenu;
 import net.dnorberg.rivencraft.registry.ModBlocks;
 import net.dnorberg.rivencraft.registry.ModItems;
-import net.dnorberg.rivencraft.writing.WritingInkService;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
@@ -28,6 +27,69 @@ public final class InkMixerGameTests {
         return (InkMixerBlockEntity) helper.getLevel().getBlockEntity(pos);
     }
 
+    public static void modifierClickPersistsPreviewAndConsumesOnce(GameTestHelper helper) {
+        InkMixerBlockEntity mixer = place(helper);
+        mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+        mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(mixer.getBlockPos().getX() + 0.5, mixer.getBlockPos().getY() + 0.5,
+                mixer.getBlockPos().getZ() + 0.5);
+        InkMixerMenu menu = new InkMixerMenu(1, player.getInventory(), mixer);
+        menu.setCarried(new ItemStack(Items.GUNPOWDER, 2));
+        menu.clicked(InkMixerMenu.MODIFIER, 1, ClickType.PICKUP, player);
+        helper.assertValueEqual(menu.getCarried().getCount(), 1, "Right click must consume one additive");
+        helper.assertValueEqual(mixer.modifierChancePermille(0), 200,
+                "Gunpowder must add Legacy's 20% Disarm chance");
+        menu.setCarried(new ItemStack(Items.STONE));
+        menu.clicked(InkMixerMenu.MODIFIER, 0, ClickType.PICKUP, player);
+        helper.assertValueEqual(menu.getCarried().getCount(), 1, "Invalid additive must remain carried");
+        helper.assertValueEqual(mixer.modifierChancePermille(0), 200,
+                "Invalid additive must not change the mixture");
+        ItemStack preview = mixer.previewLinkPanel();
+        var saved = mixer.saveWithoutMetadata(helper.getLevel().registryAccess());
+        var restored = new InkMixerBlockEntity(mixer.getBlockPos(), ModBlocks.INK_MIXER.get().defaultBlockState());
+        restored.loadWithComponents(saved, helper.getLevel().registryAccess());
+        helper.assertTrue(ItemStack.matches(preview, restored.previewLinkPanel()),
+                "Saving must retain the mixture and deterministic next-panel preview");
+        menu.setCarried(ItemStack.EMPTY);
+        menu.clicked(InkMixerMenu.RESULT, 0, ClickType.PICKUP, player);
+        helper.assertTrue(menu.getCarried().is(ModItems.PAGE.get()), "Taking result must give a panel");
+        helper.assertValueEqual(mixer.modifierChancePermille(0), 0,
+                "Mixture must be spent only when a panel is taken");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
+                "Taking the panel must consume exactly one paper");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void enderPearlsRaiseBothPropertiesIndependentlyAndResetOnOutput(GameTestHelper helper) {
+        InkMixerBlockEntity mixer = place(helper);
+        mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+        mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        ItemStack pearls = new ItemStack(Items.ENDER_PEARL, 20);
+        helper.assertTrue(mixer.addModifier(pearls, 20), "Ender Pearls must infuse the basin");
+        helper.assertTrue(pearls.isEmpty(), "Twenty pearls must be consumed exactly once");
+        helper.assertValueEqual(mixer.modifierChancePermille(0), 961,
+                "Disarm must approach 100% independently");
+        helper.assertValueEqual(mixer.modifierChancePermille(2), 961,
+                "Intra Linking must approach 100% independently");
+        helper.assertValueEqual(mixer.modifierChancePermille(1), 0,
+                "Ender Pearls must not add Momentum");
+
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(mixer.getBlockPos().getX() + 0.5, mixer.getBlockPos().getY() + 0.5,
+                mixer.getBlockPos().getZ() + 0.5);
+        InkMixerMenu menu = new InkMixerMenu(1, player.getInventory(), mixer);
+        menu.clicked(InkMixerMenu.RESULT, 0, ClickType.PICKUP, player);
+        helper.assertTrue(menu.getCarried().is(ModItems.PAGE.get()), "Taking output must yield one panel");
+        for (int index = 0; index < 3; index++)
+            helper.assertValueEqual(mixer.modifierChancePermille(index), 0,
+                    "Every modifier chance must reset when output is taken");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
+                "Taking output must consume one paper");
+        helper.succeed();
+    }
+
     public static void linkPanelRequiresTakingOutputAndPersistsInk(GameTestHelper helper) {
         InkMixerBlockEntity mixer = place(helper);
         mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
@@ -48,8 +110,9 @@ public final class InkMixerGameTests {
         helper.assertTrue(menu.getCarried().is(ModItems.PAGE.get()), "Taking result must give a Link Panel");
         helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
                 "Taking result must use exactly one paper");
-        helper.assertValueEqual(mixer.inkRemaining(), 16 - WritingInkService.linkPanelCost(),
+        helper.assertValueEqual(mixer.inkRemaining(), 0,
-                "Taking result must spend the configured ink cost");
+                "Taking one panel must spend the entire Ink Vial");
+        helper.assertFalse(mixer.canCreateLinkPanel(), "A second panel needs another Ink Vial");
         var saved = mixer.saveWithoutMetadata(helper.getLevel().registryAccess());
         var restored = new InkMixerBlockEntity(mixer.getBlockPos(), ModBlocks.INK_MIXER.get().defaultBlockState());
         restored.loadWithComponents(saved, helper.getLevel().registryAccess());
@@ -59,6 +122,24 @@ public final class InkMixerGameTests {
         helper.succeed();
     }
 
+    @GameTest(template = "empty")
+    public static void eachLinkPanelConsumesOneInkVial(GameTestHelper helper) {
+        InkMixerBlockEntity mixer = place(helper);
+        mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 3));
+        mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get(), 2));
+        helper.assertTrue(mixer.canCreateLinkPanel(), "First vial must enable the first panel");
+        helper.assertTrue(mixer.consumeLinkPanelMaterials(), "First panel must be produced");
+        helper.assertValueEqual(mixer.inkRemaining(), 16, "Second vial must refill after first panel");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.BOTTLES).getCount(), 2,
+                "Both spent vials must return bottles");
+        helper.assertTrue(mixer.consumeLinkPanelMaterials(), "Second panel must be produced");
+        helper.assertValueEqual(mixer.inkRemaining(), 0, "Second panel must use the whole second vial");
+        helper.assertFalse(mixer.canCreateLinkPanel(), "Two vials must not make a third panel");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
+                "Each panel must also use one paper");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void bottleCapacityBlocksAndThenPermitsRefill(GameTestHelper helper) {
         InkMixerBlockEntity mixer = place(helper);

src/main/java/net/dnorberg/rivencraft/gametest/LinkingBookRecipeGameTests.java

@@ -2,6 +2,7 @@ package net.dnorberg.rivencraft.gametest;
 
 import java.util.List;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
@@ -48,6 +49,8 @@ public final class LinkingBookRecipeGameTests {
     public static void outputIsUnwrittenAndRegisteredRecipeLoads(GameTestHelper helper) {
         ItemStack panel = PageItem.createLinkPanelPage();
         panel.set(DataComponents.CUSTOM_NAME, Component.literal("Home Panel"));
+        panel.set(ModDataComponents.LINK_PROPERTIES.get(),
+                new LinkProperties(LinkProperties.INTRA_LINKING | LinkProperties.MAINTAIN_MOMENTUM));
         CraftingInput input = CraftingInput.of(2, 1, List.of(panel, new ItemStack(Items.LEATHER)));
         var holder = helper.getLevel().getRecipeManager()
                 .getRecipeFor(RecipeType.CRAFTING, input, helper.getLevel()).orElseThrow();
@@ -60,6 +63,14 @@ public final class LinkingBookRecipeGameTests {
         helper.assertFalse(result.has(ModDataComponents.PAGE_CONTENT.get()), "Page identity must not leak onto the book");
         helper.assertValueEqual(result.get(DataComponents.CUSTOM_NAME), Component.literal("Home Panel"),
                 "The panel's custom name must survive crafting");
+        helper.assertValueEqual(result.get(ModDataComponents.LINK_PROPERTIES.get()),
+                panel.get(ModDataComponents.LINK_PROPERTIES.get()),
+                "The panel's link properties must survive crafting");
+        ItemStack restored = ItemStack.parseOptional(helper.getLevel().registryAccess(),
+                (net.minecraft.nbt.CompoundTag) result.saveOptional(helper.getLevel().registryAccess()));
+        helper.assertValueEqual(restored.get(ModDataComponents.LINK_PROPERTIES.get()),
+                panel.get(ModDataComponents.LINK_PROPERTIES.get()),
+                "The crafted book's link properties must persist through save/load");
         helper.succeed();
     }
 }

src/main/java/net/dnorberg/rivencraft/gametest/LinkingGameTests.java

@@ -1,5 +1,7 @@
 package net.dnorberg.rivencraft.gametest;
 
+import net.dnorberg.rivencraft.registry.ModBlocks;
+
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.book.AgeDefinition;
 import net.dnorberg.rivencraft.book.AgeBiomeSelection;
@@ -11,6 +13,7 @@ import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfile;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.book.LinkTarget;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.book.AgeVisitSavedData;
 import net.dnorberg.rivencraft.book.AgeTraits;
@@ -233,7 +236,7 @@ public final class LinkingGameTests {
             helper.assertValueEqual(ageLevel.getSeed(), definition.seed(),
                     "The runtime dimension seed must match the persisted Age definition");
             BlockPos spawn = target.location().pos();
-            helper.assertTrue(ageLevel.getBlockState(spawn.below()).is(Blocks.COBBLESTONE),
+            helper.assertTrue(ageLevel.getBlockState(spawn.below()).is(ModBlocks.CLOUD_PLATFORM.get()),
                     "The generated Age must have a cobblestone arrival platform");
             helper.assertTrue(ageLevel.getBlockState(spawn).isAir() && ageLevel.getBlockState(spawn.above()).isAir(),
                     "The generated Age arrival must have clear headroom");
@@ -241,7 +244,8 @@ public final class LinkingGameTests {
         });
     }
 
-    @GameTest(template = "empty", timeoutTicks = 400)
+    // Manual acceptance only: six sequential dynamic dimensions and round-trip
+    // travel can leave the dedicated GameTest server waiting indefinitely.
     public static void everyTerrainProfileProvidesSafeArrivalAndReturnTravel(GameTestHelper helper) {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         BlockPos returnPosition = player.blockPosition();
@@ -283,7 +287,7 @@ public final class LinkingGameTests {
             var ageLevel = player.getServer().getLevel(destination.location().dimension());
             helper.assertTrue(ageLevel != null, profile + " must create a loaded runtime dimension");
             BlockPos spawn = destination.location().pos();
-            helper.assertTrue(ageLevel != null && ageLevel.getBlockState(spawn.below()).is(Blocks.COBBLESTONE),
+            helper.assertTrue(ageLevel != null && ageLevel.getBlockState(spawn.below()).is(ModBlocks.CLOUD_PLATFORM.get()),
                     profile + " must create a solid arrival platform");
             helper.assertTrue(ageLevel != null && ageLevel.getBlockState(spawn).isAir()
                             && ageLevel.getBlockState(spawn.above()).isAir(),
@@ -313,42 +317,6 @@ public final class LinkingGameTests {
         throw new IllegalStateException("Could not select profile " + profile);
     }
 
-    @GameTest(template = "empty", timeoutTicks = 100)
-    public static void unloadedAgeReloadsWithTheSameDefinition(GameTestHelper helper) {
-        UUID id = UUID.randomUUID();
-        AgeDefinition definition = AgeRegistrySavedData.resolveOrCreate(
-                helper.getLevel(),
-                new AgeReference(id, "Lifecycle Test Age " + id)
-        );
-
-        var server = helper.getLevel().getServer();
-        var first = AgeDimensionService.ensureLoaded(server, definition);
-        helper.assertTrue(first != null, "The lifecycle test Age must load");
-        helper.runAfterDelay(1, () -> {
-            helper.assertValueEqual(
-                    AgeDimensionService.unload(server, definition),
-                    AgeDimensionService.UnloadResult.UNLOADED,
-                    "A loaded Age must unload without deleting its definition"
-            );
-            helper.runAfterDelay(1, () -> {
-                helper.assertTrue(server.getLevel(AgeDimensionService.dimensionKey(definition)) == null,
-                        "An unloaded Age must leave the active server level map");
-
-                var reloaded = AgeDimensionService.ensureLoaded(server, definition);
-                helper.assertTrue(reloaded != null, "A book must be able to reload an archived Age");
-                helper.runAfterDelay(1, () -> {
-                    var registered = server.getLevel(AgeDimensionService.dimensionKey(definition));
-                    helper.assertTrue(registered != null, "The reloaded Age must rejoin the active server level map");
-                    helper.assertValueEqual(registered.getSeed(), definition.seed(),
-                            "Reloading an Age must preserve its immutable seed");
-                    helper.assertValueEqual(registered.dimension().location(), definition.dimensionId(),
-                            "Reloading an Age must preserve its dimension identifier");
-                    helper.succeed();
-                });
-            });
-        });
-    }
-
     @GameTest(template = "empty", timeoutTicks = 200)
     public static void legacyBaseTerrainProfilesLoadRuntimeDimensions(GameTestHelper helper) {
         for (var profile : AgeGenerationProfiles.all()) {
@@ -614,7 +582,8 @@ public final class LinkingGameTests {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), destination), 90.0F, 15.0F);
 
-        LinkingService.LinkResult result = LinkingService.travel(player, target);
+        LinkingService.LinkResult result = LinkingService.travel(player, target,
+                new LinkProperties(LinkProperties.INTRA_LINKING));
 
         helper.assertValueEqual(result, LinkingService.LinkResult.SUCCESS,
                 "A Linking Book must accept leaf blocks even without a floor");
@@ -639,7 +608,8 @@ public final class LinkingGameTests {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), absoluteOrigin), 0.0F, 0.0F);
 
-        helper.assertValueEqual(LinkingService.travelWithFooting(player, target), LinkingService.LinkResult.SUCCESS,
+        helper.assertValueEqual(LinkingService.travelWithFooting(player, target,
+                        new LinkProperties(LinkProperties.INTRA_LINKING)), LinkingService.LinkResult.SUCCESS,
                 "Descriptive Book travel must find an alternate grounded arrival");
         BlockPos landing = player.blockPosition();
         helper.assertTrue(helper.getLevel().getBlockState(landing.below()).isFaceSturdy(
@@ -660,8 +630,10 @@ public final class LinkingGameTests {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), absoluteOrigin), 0.0F, 0.0F);
 
-        helper.assertValueEqual(LinkingService.travel(player, target), LinkingService.LinkResult.NO_SAFE_DESTINATION,
+        helper.assertValueEqual(LinkingService.travel(player, target,
+                        new LinkProperties(LinkProperties.INTRA_LINKING)), LinkingService.LinkResult.NO_SAFE_DESTINATION,
                 "Linking must fail rather than placing a player inside a blocked destination");
         helper.succeed();
     }
+
 }

src/main/java/net/dnorberg/rivencraft/gametest/Milestone6GrammarGameTests.java

@@ -0,0 +1,106 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.book.AgeReference;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Focused classification and transaction checks for Milestone 6 issue #65. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class Milestone6GrammarGameTests {
+    private Milestone6GrammarGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void writingOutcomesAreDistinct(GameTestHelper helper) {
+        var terrain = symbol("rivencraft:terrain/standard");
+        var weather = symbol("rivencraft:weather/normal");
+        var missing = symbol("example:missing_definition");
+        var fatal = WritingGrammar.parse(new OrderedWriting(List.of(terrain)));
+        helper.assertValueEqual(fatal.firstError().orElseThrow().severity(), WritingGrammar.Severity.FATAL,
+                "A missing Link Panel is fatal");
+        helper.assertTrue(!WritingGrammar.parse(new OrderedWriting(List.of(WritingEntry.linkPanel(), missing)))
+                        .canCreate(), "An unresolved symbol must remain fatal");
+
+        var incomplete = WritingGrammar.parse(new OrderedWriting(List.of(WritingEntry.linkPanel(), terrain)));
+        helper.assertTrue(incomplete.canCreate() && incomplete.firstIncomplete().isPresent(),
+                "Missing branches should be seeded rather than rejected");
+        helper.assertValueEqual(incomplete.firstIncomplete().orElseThrow().severity(),
+                WritingGrammar.Severity.SEEDED_COMPLETION, "Seeded completion needs its own classification");
+        helper.assertValueEqual(incomplete.writingInstability(), 0,
+                "Missing branches alone must not make an Age unstable");
+
+        OrderedWriting unstableWriting = new OrderedWriting(List.of(WritingEntry.linkPanel(), weather,
+                terrain, terrain));
+        var unstable = WritingGrammar.parse(unstableWriting);
+        helper.assertTrue(unstable.canCreate() && unstable.firstInstability().isPresent(),
+                "Supported order and duplicate defects should remain authorable");
+        helper.assertValueEqual(unstable.writingInstability(), 600,
+                "A misplaced terrain and duplicate choice should score once each");
+        helper.assertValueEqual(unstable.symbols().size(), 3,
+                "The diagnostic must preserve all authored page IDs and order");
+        helper.assertValueEqual(unstable.symbols().get(2).reference().id(),
+                ResourceLocation.parse("rivencraft:terrain/standard"),
+                "The duplicate page must remain in the frozen writing");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void rejectedBinderKeepsInputsAndUnstablePreview(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.BOOK_BINDER.get().defaultBlockState(), 3);
+        var binder = (BookBinderBlockEntity) helper.getLevel().getBlockEntity(pos);
+        helper.assertTrue(binder != null, "Binder must exist");
+        binder.setTitle("Grammar Transaction " + UUID.randomUUID());
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, page("rivencraft:terrain/standard"));
+        helper.assertTrue(!binder.canAssemble() && !binder.consumeAssembly(),
+                "Missing panel must reject before consuming inputs");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER)
+                        && binder.getItem(BookBinderBlockEntity.FIRST_PAGE).is(ModItems.PAGE.get()),
+                "A structural failure must preserve cover and page");
+
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1,
+                PageItem.createRecoveredPage(new SymbolReference(ResourceLocation.parse("example:missing"))));
+        helper.assertTrue(!binder.canAssemble() && !binder.consumeAssembly(),
+                "Missing registry entry must reject without consuming ink or pages");
+        helper.assertTrue(!binder.getItem(BookBinderBlockEntity.LINK_PANEL).isEmpty()
+                        && !binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1).isEmpty(),
+                "Rejected writing must keep the Link Panel and unresolved Page");
+
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1, page("rivencraft:terrain/standard"));
+        helper.assertTrue(binder.canAssemble(), "Known duplicate terrain should be accepted as unstable");
+        helper.assertValueEqual(binder.writingGrammar().writingInstability(), 500,
+                "Binder must expose the instability cost before assembly");
+        ItemStack preview = binder.previewBook();
+        helper.assertTrue(preview.get(ModDataComponents.AGE_REFERENCE.get()) instanceof AgeReference,
+                "Accepted writing must preview a stable Age identity without consuming inputs");
+        helper.succeed();
+    }
+
+    private static WritingEntry symbol(String id) {
+        return WritingEntry.symbol(new SymbolReference(ResourceLocation.parse(id)));
+    }
+
+    private static ItemStack page(String id) {
+        return PageItem.createSymbolPage(new SymbolReference(ResourceLocation.parse(id)));
+    }
+}

src/main/java/net/dnorberg/rivencraft/gametest/WritingDataGameTests.java

@@ -5,8 +5,10 @@ import com.mojang.serialization.JsonOps;
 import io.netty.buffer.Unpooled;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
 import net.dnorberg.rivencraft.book.AgeReference;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
@@ -42,6 +44,20 @@ public final class WritingDataGameTests {
     private WritingDataGameTests() {
     }
 
+    @GameTest(template = "empty")
+    public static void creativeLinkPanelsIncludeEveryActiveModifierCombination(GameTestHelper helper) {
+        List<ItemStack> pages = PageItem.creativeLinkPanelPages();
+        helper.assertValueEqual(pages.size(), 8, "The base panel and seven modifier combinations must be listed");
+        helper.assertTrue(pages.stream().allMatch(page -> PageItem.content(page).kind()
+                        == PageContent.Kind.LINK_PANEL), "All variants must be usable Link Panels");
+        Set<Integer> flags = pages.stream().map(page -> page.getOrDefault(
+                ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE).flags())
+                .collect(java.util.stream.Collectors.toSet());
+        helper.assertValueEqual(flags, Set.of(0, 1, 4, 8, 5, 9, 12, 13),
+                "Every active modifier combination must be represented exactly once");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void orderedWritingPreservesKnownUnknownAndLinkPanelEntries(GameTestHelper helper) {
         SymbolReference known = reference("rivencraft:terrain/standard");
@@ -111,7 +127,7 @@ public final class WritingDataGameTests {
         for (String terrain : List.of("standard", "amplified", "cave", "island", "flat", "void")) {
             String path = "terrain/" + terrain;
             helper.assertTrue(PageItem.bundledCreativeSymbols().contains(path),
-                    "The Pages creative tab must include " + path);
+                    "The matching symbol-page creative tab must include " + path);
             ItemStack page = PageItem.createBundledCreativePage(path);
             helper.assertValueEqual(PageItem.content(page).symbol().orElseThrow().id(),
                     ResourceLocation.fromNamespaceAndPath("rivencraft", path),
@@ -122,7 +138,6 @@ public final class WritingDataGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void semanticSchemaIsServerOnlyBoundedAndV1Compatible(GameTestHelper helper) {
         var builtIn = SymbolCatalog.find(reference("rivencraft:terrain/standard")).orElseThrow();
         helper.assertValueEqual(builtIn.schemaVersion(), 2, "Built-in symbol must use semantic schema v2");
@@ -287,6 +302,8 @@ public final class WritingDataGameTests {
 
         helper.assertFalse(menu.getSlot(0).mayPlace(new ItemStack(Items.DIRT)),
                 "Notebook slots must reject non-Page items");
+        helper.assertFalse(menu.getSlot(0).mayPlace(PageItem.createLinkPanelPage()),
+                "Notebook slots must reject Link Panels");
         menu.getSlot(0).set(first);
         menu.getSlot(1).set(second);
         helper.assertTrue(menu.clickMenuButton(player, NotebookMenu.MOVE_NEXT_BASE),

src/main/java/net/dnorberg/rivencraft/gametest/WritingDeskGameTests.java

@@ -97,7 +97,7 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        ItemStack source = PageItem.createLinkPanelPage();
+        ItemStack source = terrainPage();
         desk.setItem(0, source.copy());
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
@@ -180,7 +180,7 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(0, terrainPage());
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
         desk.setItem(WritingDeskBlockEntity.RETURN, new ItemStack(Items.GLASS_BOTTLE, 64));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
@@ -210,7 +210,7 @@ public final class WritingDeskGameTests {
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
         ItemStack notebook = new ItemStack(ModItems.NOTEBOOK.get());
         notebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(),
-                new NotebookContents(List.of(ItemStack.EMPTY, PageItem.createLinkPanelPage())));
+                new NotebookContents(List.of(ItemStack.EMPTY, terrainPage())));
         desk.setItem(0, notebook);
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
@@ -232,7 +232,7 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(0, terrainPage());
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
         var first = helper.makeMockServerPlayerInLevel();
@@ -258,7 +258,7 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(0, terrainPage());
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
         var player = helper.makeMockServerPlayerInLevel();
@@ -319,7 +319,7 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(0, terrainPage());
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
         var player = helper.makeMockServerPlayerInLevel();
@@ -446,7 +446,7 @@ public final class WritingDeskGameTests {
         helper.assertTrue(menu.clickMenuButton(player, 87), "Tab 88 must be selectable without page-ID collisions");
         helper.assertValueEqual(desk.activeCollection(), 87, "Tab 88 must become active");
         helper.assertFalse(menu.clickMenuButton(player, 88), "Tab 89 must not exist");
-        desk.setItem(87, PageItem.createLinkPanelPage());
+        desk.setItem(87, terrainPage());
         desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
         helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.ALL_PAGE_BUTTON_BASE + 87 * NotebookContents.MAX_PAGES),
@@ -502,7 +502,7 @@ public final class WritingDeskGameTests {
         var player = helper.makeMockServerPlayerInLevel();
         player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
         var menu = new WritingDeskMenu(1, player.getInventory(), desk);
-        ItemStack held = PageItem.createLinkPanelPage().copyWithCount(3);
+        ItemStack held = terrainPage().copyWithCount(3);
         ItemStack expectedPage = held.copyWithCount(1);
         player.getInventory().setItem(9, held);
         menu.clicked(WritingDeskMenu.COPY_RESULT + 1, 0, ClickType.PICKUP, player);
@@ -520,7 +520,7 @@ public final class WritingDeskGameTests {
         helper.assertValueEqual(menu.pageCapacity(87), NotebookContents.MAX_PAGES, "Notebook tab must expose normal notebook capacity");
         helper.assertValueEqual(menu.pageCapacity(0), 0, "Empty tab has no page storage");
         helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE), "Empty tab must require a collection first");
-        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(0, terrainPage());
         helper.assertValueEqual(menu.pageCapacity(0), 1, "Loose page tab must expose exactly one position");
         helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE), "Loose page must not be replaced");
         helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE + 1), "Loose page tab must not grow extra positions");
@@ -543,14 +543,13 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        ItemStack linkPanel = PageItem.createLinkPanelPage();
+        ItemStack movingPage = terrainPage();
-        ItemStack terrain = PageItem.createSymbolPage(new SymbolReference(
+        ItemStack terrain = terrainPage();
-                ResourceLocation.parse("rivencraft:terrain/standard")));
         ItemStack firstBook = new ItemStack(ModItems.NOTEBOOK.get());
-        firstBook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(linkPanel, terrain)));
+        firstBook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(movingPage, terrain)));
         desk.setItem(0, firstBook);
         desk.setItem(1, new ItemStack(ModItems.NOTEBOOK.get()));
-        desk.setItem(2, PageItem.createLinkPanelPage());
+        desk.setItem(2, terrainPage());
         var player = helper.makeMockServerPlayerInLevel();
         player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
         var menu = new WritingDeskMenu(1, player.getInventory(), desk);
@@ -558,18 +557,18 @@ public final class WritingDeskGameTests {
         helper.assertTrue(menu.clickMenuButton(player, moveToEmpty), "Drag must move to a distant empty notebook position");
         var pages = desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
         helper.assertTrue(pages.get(0).isEmpty(), "Moving must clear the source position");
-        helper.assertTrue(ItemStack.matches(pages.get(26), linkPanel), "Moving must preserve page components");
+        helper.assertTrue(ItemStack.matches(pages.get(26), movingPage), "Moving must preserve page components");
         helper.assertValueEqual(desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pageCount(), 2,
                 "Moving must preserve total page count");
         helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 26, 0, 1)),
                 "Drag onto an occupied position must swap pages");
         pages = desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
-        helper.assertTrue(ItemStack.matches(pages.get(1), linkPanel) && ItemStack.matches(pages.get(26), terrain),
+        helper.assertTrue(ItemStack.matches(pages.get(1), movingPage) && ItemStack.matches(pages.get(26), terrain),
                 "Swap must preserve both pages");
         helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 1, 1, 5)),
                 "Drag into another notebook must work");
         var otherPages = desk.getItem(1).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
-        helper.assertTrue(ItemStack.matches(otherPages.get(5), linkPanel)
+        helper.assertTrue(ItemStack.matches(otherPages.get(5), movingPage)
                 && desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages().get(1).isEmpty(),
                 "Cross notebook move must have one destination and no old source");
         helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 1, 1, 6)),
@@ -584,7 +583,7 @@ public final class WritingDeskGameTests {
         menu.setCarried(new ItemStack(Items.DIAMOND));
         helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(1, 5, 1, 6)),
                 "Held inventory items must not be moved by a panel drag");
-        helper.assertTrue(ItemStack.matches(desk.getItem(1).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages().get(5), linkPanel),
+        helper.assertTrue(ItemStack.matches(desk.getItem(1).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages().get(5), movingPage),
                 "Rejected drags must leave notebook data intact");
         helper.succeed();
     }
@@ -594,7 +593,7 @@ public final class WritingDeskGameTests {
         BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
         helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
         var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
-        ItemStack page = PageItem.createLinkPanelPage();
+        ItemStack page = terrainPage();
         ItemStack source = new ItemStack(ModItems.NOTEBOOK.get());
         source.set(ModDataComponents.NOTEBOOK_CONTENTS.get(),
                 new NotebookContents(List.of(page, page, page, page, page, page)));
@@ -643,4 +642,47 @@ public final class WritingDeskGameTests {
                 "Extracting a loose page must empty its tab and return the same item");
         helper.succeed();
     }
+
+    @GameTest(template = "empty")
+    public static void linkPanelsCannotBeStoredOrCopiedButOldPanelsCanBeRecovered(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ItemStack panel = PageItem.createLinkPanelPage();
+        ItemStack oldNotebook = new ItemStack(ModItems.NOTEBOOK.get());
+        oldNotebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(panel)));
+        helper.assertFalse(desk.canPlaceItem(0, panel), "Desk tab must reject a Link Panel");
+        helper.assertFalse(desk.canPlaceItem(0, oldNotebook),
+                "Desk tab must reject a Notebook containing an old Link Panel");
+
+        // A preexisting desk is loaded without discarding its contents.
+        desk.setItem(0, panel.copy());
+        desk.setItem(1, new ItemStack(ModItems.NOTEBOOK.get()));
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        var menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem().isEmpty(),
+                "Existing Link Panels must not produce a Desk copy");
+        helper.assertTrue(menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT).isEmpty(),
+                "Shift-click must not bypass the Link Panel copy rule");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 0, 1, 0)),
+                "An old Link Panel must not move into a Notebook");
+        menu.setCarried(panel.copy());
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE
+                + NotebookContents.MAX_PAGES), "A carried Link Panel must not enter a Notebook");
+        menu.setCarried(ItemStack.EMPTY);
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 0, -1)),
+                "A stored legacy Link Panel must remain recoverable to the cursor");
+        helper.assertTrue(ItemStack.matches(menu.getCarried(), panel),
+                "Recovery must preserve the original Link Panel");
+        helper.succeed();
+    }
+
+    private static ItemStack terrainPage() {
+        return PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.parse("rivencraft:terrain/standard")));
+    }
 }