Completed issue 71 and allowed village pages to be placed in illegal biomes adding +100 instability

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,17 @@ 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
-and randomly seeded, persistent vanilla-like Ages created from page-free
-Descriptive Books. Instability and full symbol-to-world grammar interpretation
-have not been ported yet.
+ordered-writing model. Linking Books and Descriptive Books create persistent
+Ages from either authored supported symbols or seeded random completion.
+Milestone 6 instability work is in progress: Ages persist frozen instability
+scores and provider plans, and the bounded runtime implements status effects,
+colored decay, lightning, explosions, meteors, burning, and erosion. The
+[Milestone 5 acceptance record](docs/MILESTONE_5_ACCEPTANCE.md) lists the
+supported grammar, optional integrations, and limits; the
+[instability runtime policy](docs/INSTABILITY_RUNTIME.md) records the current
+effects and modern safety boundaries.
 
 Milestone 4 now includes stackable blank Pages plus server-created symbol,
 unresolved-symbol, and baseline link-panel states. Page visuals follow the
@@ -117,14 +122,14 @@ 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;
 authored biome, environment, and supported feature pages also affect new Ages.
-Further symbol effects are scheduled for later Milestone 5 slices. The
+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
-Milestone 5. Link-panel-only books show their details in the enchantment-table
-font.
+symbol pages appear before the final blank spread with their runtime-rendered
+pictograms. Link-panel-only books use Rivencraft glyphs for their generated
+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()

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,7 +199,7 @@ 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.
@@ -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
-biomes for a multi-biome distribution.
+remains Plains. Void terrain defaults to The Void when no biome page is written,
+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

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

@@ -4,13 +4,13 @@ The Legacy-style front spread has the Age name and author on the left and the de
 
 The Binder records the taking player's name on the finished book; direct Age binding also records the binding player. Older books without this component display `Unknown author` rather than attributing them to whoever happens to open them. Link-Panel-only and older page-free books retain their random-Age glyph details and destination preview. On authored books, hovering the front-page name exposes the existing trait summary without filling the left page with text.
 
-The server resolves symbol display metadata from its current catalog and sends advisory grammar diagnostics with the book-opening payload. A missing data-pack symbol draws the unresolved page artwork and its original ID. An affected page displays a red `!` with the server's diagnostic on hover; separate writing-note pages show all diagnostics, including incomplete branches that the Age compiler filled. These UI notices do not alter or recompile the persisted Age plan. Symbol pages use the same bounded, runtime glyph composition as Page items and do not require Create, Ponder, or Immersive Portals.
+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, and the writing notes should explain the missing definition. Restore the pack and verify the page artwork returns without changing the saved Age.
+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

@@ -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`,
-`binder`, `mixer`, and `recipe`. Run all Rivencraft tests before a
+Available suite names are `linking`, `environment`, `writing`, `grammar`,
+`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
@@ -47,6 +52,27 @@ 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/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,11 @@
+# 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 for every occurrence, including a seed-generated controller. Mineshafts, Nether Fortresses, Strongholds, and Villages add +100 for the fourth and every later occurrence. By project balance decision, Bastions, Trial Chambers, Ancient Cities, Shipwrecks, Ocean Ruins, Pillager Outposts, Ruined Portals, Nether Fossils, Buried Treasure, and Trail Ruins follow that same rule. The first three occurrences and all other audited Legacy feature symbols have no direct page cost. An authored structure may override its vanilla biome eligibility; every structure-page occurrence forced into an unsupported selected biome adds +100. Seed completion still prefers compatible biomes and therefore avoids that cost when it can. Other modern-only features remain neutral. The frozen score selects a deterministic, persisted provider plan through the Milestone 6 runtime. Registered handlers apply that plan only inside loaded Rivencraft Ages and remain subject to the documented scheduler and effect-specific safety bounds.
+
+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 added the frozen provider selection; issues #67–#70 added the current handlers. See the [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.
+
+`/rivencraft age instability` inspects the Age containing the command source; an optional dimension ID inspects an unloaded or different registered Age. It reports immutable base score, stability bonus, runtime penalty, and effective score. The pinned Legacy tree defines player-death and player-presence bonus classes but does not register them as default providers, so Rivencraft leaves player-driven modifiers disabled: bonus and penalty are zero and effective equals base. There is therefore no mutable bonus save to migrate in this release. No death, PvP event, player identity, or dimension transition can transfer stability between Ages. Any future opt-in mechanic must persist separately from `Instability`, define caps and reset behavior, and must not rewrite the generation plan or frozen provider plan.

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,70 @@
+# Mystcraft Legacy instability audit (Milestone 6, issue #63)
+
+This is the behavior contract used to implement Milestone 6. It is pinned to [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 now persists frozen writing-instability scores and provider plans and runs the implemented providers through a bounded, Age-scoped scheduler. The audit remains authoritative for Legacy behavior; the linked runtime documents identify modern adaptations and remaining gaps.
+
+## 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. |
+
+The complete Legacy `instabilityModifier` audit found direct feature-page costs only for Mineshafts, Nether Fortresses, Strongholds, and Villages. Their first three occurrences cost zero; the fourth and every later occurrence adds 100. Every other Legacy feature class inherited `SymbolBase`'s zero modifier. Rivencraft applies that exact rule to the four matching pages. By project balance decision, Bastions, Trial Chambers, Ancient Cities, Shipwrecks, Ocean Ruins, Pillager Outposts, Ruined Portals, Nether Fossils, Buried Treasure, and Trail Ruins use the same repeat rule. Matching Legacy features such as Caves, Crystal Formations, Dense Ores, Dungeons, Floating Islands, Huge Trees, Deep/Surface Lakes, Obelisks, Ravines, Skylands, Spheres, Spikes, Star Fissures, and Tendrils have no direct page cost. Legacy could still derive instability later from excess profiled blocks, especially ores, but that separate 400-chunk profiling system is intentionally not ported. Other modern-only Rivencraft features remain neutral.
+
+Bright Lighting adds 500 for every authored occurrence. A generated Bright Lighting controller also adds 500. This is independent of the 500-point extra-controller cost, so two authored Bright Lighting pages produce 1,500 total: 500 for each symbol and 500 for the repeated controller.
+
+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)). | Implemented in #67 with server-only, Age-scoped entity targeting and rate limits. No effects run 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)). | Implemented in #68 as bounded world mutation with protected spawn/portal areas and configurable shutdown. Black/green/yellow remain excluded because they 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 current 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 persists the versioned score breakdown, and #66 derives and persists the provider/deck choice from that frozen score. The plan must not mutate an already-created Age when a data pack changes. Server-side settings may disable execution, but do not rewrite the saved authored score or provider plan.
+
+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. Issue #71 adds the audited Bright Lighting and repeat-structure modifiers described above. Missing branches are explicitly classified as zero-cost seeded completion; legal repeated feature/material pages are not automatically errors, though a fourth matching Legacy structure now receives its source-defined cost. **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.
+
+Legacy includes `PlayerKilledBonus` and `PlayerTrollPenalty` classes, but the pinned source contains no default provider registration for either. Rivencraft does not activate death, PvP, player-presence, or cross-dimension credit from dormant classes. Consequently #71 has no mutable per-Age bonus state to migrate, cap, reset, or persist: the stability bonus and runtime penalty are both zero, and the effective score equals the frozen base score. `/rivencraft age instability [dimension]` reports those four values and the disabled policy explicitly. This prevents unrelated players, deaths in other dimensions, and repeated deaths from changing an Age. A future opt-in policy must use separate versioned saved data and define its cap/reset rules before it can alter runtime selection.
+
+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 established a server-only scheduler with bounded per-Age actions, provider calls, levels, cooldowns, loaded-chunk candidates, and rotating active-Age admission. Issues #67–#70 registered the current status, decay, lightning, explosion, meteor, burning, and erosion handlers with protected spawn/link platforms, portal exclusions, and provider-specific damage or spread limits. Instability and world-mutating handlers are enabled by default for newly generated configs to match Legacy's active default; operators can disable them without changing a saved Age. The bounds and protection hooks are **Rivencraft safety adaptations**, not Legacy defaults. Score breakdown, selected effects, enablement, and budget suppression remain part of diagnostics issue #72. See the [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

@@ -5,6 +5,22 @@ The world-generation, dimension, registry, networking, and rendering APIs have
 changed substantially, so the work is divided into independently testable
 milestones.
 
+## Porting principles
+
+The primary goal is to reproduce verified Mystcraft Legacy behavior as closely
+as practical. Legacy source and the supplied 0.13.7.06 build are the behavioral
+reference for grammar, probabilities, ordering, defaults, visuals, and gameplay
+effects. A difference should be deliberate and documented rather than inferred
+from modern implementation convenience.
+
+Minecraft 1.21.1 has different world heights, registries, threading, networking,
+data-pack APIs, and server protection expectations. Where an exact port would be
+unsafe, technically impossible, or incompatible with current Minecraft,
+Rivencraft preserves the player-visible intent while using bounded modern
+mechanics. New features may extend Legacy when they fit Age writing and linking,
+but extensions must be identified separately from compatibility behavior and
+must not silently change existing saved Ages.
+
 ## Project tracking
 
 Gitea is the source of truth for project status:
@@ -34,14 +50,18 @@ 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,
-   dimension-type, and world-generation configuration. Optional integrations
-   may add composable biome regions and seasonal behavior. See the
+5. **Age grammar** — translate supported symbol combinations into modern biome,
+   noise, dimension-type, and world-generation configuration, with optional
+   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. **In
+   progress.** 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 +81,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
-path. Page-free books remain a useful deterministic fallback and test fixture
-after written symbol combinations become available.
+The writing system and Age grammar build on the existing page-free Age path.
+Page-free books remain a useful deterministic fallback and test fixture.
 
 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
-not interpret symbols into Age generation, which remains Milestone 5 work.
+contracts preserve unknown symbol identifiers and store author intent;
+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

@@ -40,10 +40,12 @@ For an eternal mode, Rivencraft sets Serene's per-Age saved clock to the midpoin
 
 - The Serene adapter uses Serene's internal saved season state because there is no public per-dimension season-freeze API. The real-client behavior above, including each eternal mode and No Seasons, still needs player verification. Serene's [temperature and precipitation hooks](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHooks.java) only cool eligible biomes.
 - Serene Seasons' [season tick](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHandler.java) advances from a dimension's day-time changes. A Rivencraft Age with a stopped celestial cycle may also have a stopped season; this needs an in-game check.
-- Rivencraft's non-Normal weather modes currently control weather in each Age independently. Their timing can conflict with Serene Seasons' weather-frequency changes. Ecliptic Seasons integration remains issue #39; simultaneous installation is not a supported target.
+- 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/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,20 +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, each optionally preceded by a compatible block-material page. 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 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. The minimum biome count 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. Audited Legacy symbol modifiers also add 500 for each Bright Lighting page and 100 for each Mineshafts, Nether Fortresses, Strongholds, or Villages occurrence after the third. Modern structures configured with the same rule are Bastions, Trial Chambers, Ancient Cities, Shipwrecks, Ocean Ruins, Pillager Outposts, Ruined Portals, Nether Fossils, Buried Treasure, and Trail Ruins. Every repeated structure page increases that structure's placement rate: probability-based structures multiply their chance, grid-based structures use a denser grid, and Strongholds add more positions to each ring and more positions overall. One page retains the vanilla placement rate. Authored structures can generate outside their vanilla biome set; each structure-page occurrence that requires this override adds 100 instability. Seed completion selects compatible biomes where possible. Other feature pages have no direct symbol cost. 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 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; 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.
 
 ## 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 Small 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, Rocks select a valid solid block and each lake page selects a valid source-fluid block from the registered pool. The selection is deterministic for an Age seed and feature ID, so all chunks in that Age use the same material 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 Small 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.
+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 immediately before Rocks to choose a rock material, or a Fluid Page immediately before Surface Lakes, Deep Lakes, or Small Lakes to choose a lake fluid. A material page left alone, placed before a different category, or attached to an incompatible feature is rejected. Both the feature and material ID are frozen in the saved plan, so future chunks retain their choice after restart. Existing chunks are not retroactively decorated. Custom structures, crystals, portals, and the Cave-terrain bug are outside this slice.
+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.
 
-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. 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.
+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,7 +36,7 @@ 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.10.1
+mod_version=0.5.8.4
 immersive_portals_version=6.0.7
 terrablender_version=4.1.0.8
 serene_seasons_version_id=B6nTjh4b

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

@@ -21,6 +21,11 @@ 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;
@@ -37,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);
@@ -52,11 +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;
@@ -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();
-        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;
-        }
+        return writingGrammar().canCreate();
     }
 
     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)) {
@@ -181,18 +168,21 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             // 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(
-                    diagnostic -> diagnostic.code() == WritingGrammar.Code.UNSUPPORTED_FEATURE)) {
+                    WritingGrammar.Diagnostic::error)) {
                 try {
                     AgeRegistrySavedData.validateNewWriting(serverLevel, title, currentWriting());
                 } catch (IllegalArgumentException exception) {
-                    if (exception.getMessage() != null && (exception.getMessage().startsWith("Feature ")
-                            || exception.getMessage().startsWith("Caves "))) {
-                        parsed.symbols().stream().filter(symbol -> symbol.semantics().role()
-                                        == SymbolSemantics.Role.FEATURE).findFirst().ifPresent(symbol ->
-                                diagnostics.add(new WritingGrammar.Diagnostic(
-                                        WritingGrammar.Code.UNSUPPORTED_FEATURE, symbol.index(),
-                                        exception.getMessage())));
-                    }
+                    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()));
                 }
             }
         }

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/book/AgeBiomeSelection.java

@@ -48,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
@@ -79,15 +80,20 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         int minimum = minimum(distribution);
         int target = minimum;
         if (authored.isEmpty()) {
-            // The terrain's available pool is the upper bound, including any
-            // compatible TerraBlender region biomes present at creation time.
+            // Legacy's BiomesAdv continuation/stop ranks are 2:3, which yield
+            // 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) {
-                target += new Random(seed ^ 0x42494F4D45434F55L).nextInt(maximum - minimum + 1);
-            }
+            Random countRandom = new Random(seed ^ 0x42494F4D45434F55L);
+            while (target < maximum && countRandom.nextInt(3) != 0) target++;
         }
-        List<ResourceLocation> filler = new ArrayList<>(availableBiomes);
+        completeStructureBiomes(writing, registries, availableBiomes, authored, distribution,
+                selected, distinct, seed);
+        target = Math.max(target, distinct.size());
+        // 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;
@@ -100,6 +106,59 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         return new AgeBiomeSelection(distribution, selected);
     }
 
+    /** Seed-completed biome branches must be able to host every authored structure page. */
+    private static void completeStructureBiomes(WritingGrammar.Result writing, RegistryAccess registries,
+                                                List<ResourceLocation> available,
+                                                List<ResourceLocation> authored,
+                                                AgeTraits.BiomeDistribution distribution,
+                                                List<ResourceLocation> selected,
+                                                Set<ResourceLocation> distinct,
+                                                long seed) {
+        List<Set<ResourceLocation>> requirements = writing.symbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
+                .filter(AgeStructureSelection::feature)
+                .filter(feature -> !AgeStructureSelection.dungeons(feature))
+                .distinct()
+                .map(feature -> AgeStructureSelection.compatibleBiomes(feature, registries))
+                .filter(requirement -> !requirement.isEmpty())
+                .toList();
+        if (requirements.isEmpty()) return;
+
+        if (distribution == AgeTraits.BiomeDistribution.SINGLE) {
+            if (!authored.isEmpty()) return;
+            List<ResourceLocation> candidates = available.stream()
+                    .filter(candidate -> requirements.stream().allMatch(requirement -> requirement.contains(candidate)))
+                    .toList();
+            if (candidates.isEmpty()) return;
+            ResourceLocation selectedBiome = deterministicChoice(candidates, seed, 0x5354525543544249L);
+            selected.clear();
+            distinct.clear();
+            selected.add(selectedBiome);
+            distinct.add(selectedBiome);
+            return;
+        }
+
+        for (int index = 0; index < requirements.size(); index++) {
+            Set<ResourceLocation> requirement = requirements.get(index);
+            if (selected.stream().anyMatch(requirement::contains)) continue;
+            List<ResourceLocation> candidates = available.stream()
+                    .filter(requirement::contains)
+                    .filter(candidate -> !distinct.contains(candidate))
+                    .toList();
+            if (candidates.isEmpty()) continue;
+            ResourceLocation selectedBiome = deterministicChoice(candidates, seed, 0x5354525543544249L + index);
+            selected.add(selectedBiome);
+            distinct.add(selectedBiome);
+        }
+    }
+
+    private static ResourceLocation deterministicChoice(List<ResourceLocation> choices, long seed, long salt) {
+        List<ResourceLocation> shuffled = new ArrayList<>(choices);
+        java.util.Collections.shuffle(shuffled, new Random(seed ^ salt));
+        return shuffled.getFirst();
+    }
+
     public static List<ResourceLocation> eligible(RegistryAccess registries, AgeRuntimeProfile profile) {
         var registry = registries.lookupOrThrow(Registries.BIOME);
         if (isCave(profile)) {

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,6 +1,7 @@
 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;
@@ -19,7 +20,10 @@ public record AgeDefinition(
         BlockPos spawn,
         AgeTraits traits,
         AgeGenerationPlan plan,
-        @Nullable AgeSeasonMode seasonMode
+        @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"
@@ -32,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");
         }
@@ -41,14 +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, 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);
+                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) {
@@ -79,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, seasonMode);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode,
+                randomFeatures, instability, instabilityPlan);
     }
 }

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

@@ -13,8 +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;
@@ -39,6 +41,7 @@ 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;
@@ -98,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(
@@ -219,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);
                 }
@@ -302,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),
@@ -309,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(
@@ -319,7 +331,7 @@ 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);
@@ -327,9 +339,11 @@ public final class AgeDimensionService {
                 Registries.NOISE_SETTINGS, profile.noiseSettings());
         NoiseGeneratorSettings baseSettings = noiseSettings.getOrThrow(settingsKey).value();
         Holder<NoiseGeneratorSettings> settings = Holder.direct(withBiomeMaterialRules(baseSettings));
-        List<AgeFeatureSelection.Choice> features = AgeFeatureSelection.resolved(age.plan());
-        return features.isEmpty() ? new NoiseBasedChunkGenerator(biomeSource, settings)
-                : new AgeFeatureChunkGenerator(biomeSource, settings, features, age.seed());
+        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

@@ -3,11 +3,17 @@ 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;
@@ -20,6 +26,16 @@ 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) {
@@ -34,11 +50,15 @@ public final class AgeFeatureSelection {
     }
 
     public static List<Choice> compile(WritingGrammar.Result writing, AgeRuntimeProfile profile,
-                                       AgeBiomeSelection biomes, RegistryAccess registries) {
+                                       AgeBiomeSelection biomes, RegistryAccess registries, long ageSeed) {
         List<Choice> choices = choices(writing.symbols().stream()
-                .map(symbol -> symbol.semantics()).toList());
+                .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()
@@ -50,10 +70,15 @@ public final class AgeFeatureSelection {
         return choices;
     }
 
-    private static List<Choice> choices(List<SymbolSemantics> symbols) {
+    private static List<Choice> choices(List<SymbolSemantics> symbols, AgeRuntimeProfile profile, long ageSeed) {
         List<Choice> choices = new ArrayList<>();
         ResourceLocation pendingMaterial = null;
-        for (SymbolSemantics semantics : symbols) {
+        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) {
@@ -62,29 +87,182 @@ public final class AgeFeatureSelection {
                 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();
-        return choices(plan.symbols().stream().map(symbol -> symbol.semantics()).toList()).stream()
-                .map(choice -> choice.material().isPresent() || !isRock(choice.id()) && !isLake(choice.id())
-                        ? choice : new Choice(choice.id(), Optional.of(randomMaterial(plan.ageSeed(), choice.id()))))
-                .toList();
+        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);
     }
 
-    private static ResourceLocation randomMaterial(long ageSeed, ResourceLocation feature) {
-        var category = isRock(feature) ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
-        List<ResourceLocation> pool = BlockSymbolPages.availableBlocks(category).stream()
-                .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList();
+    /** 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);
-        long mixed = ageSeed ^ (long) feature.hashCode() * 0x9E3779B97F4A7C15L;
-        mixed = (mixed ^ mixed >>> 30) * 0xBF58476D1CE4E5B9L;
-        mixed = (mixed ^ mixed >>> 27) * 0x94D049BB133111EBL;
-        return pool.get(Math.floorMod(mixed ^ mixed >>> 31, pool.size()));
+        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";
@@ -118,7 +296,7 @@ public final class AgeFeatureSelection {
         if (block.isEmpty() || block.orElseThrow() == Blocks.AIR) {
             return "Feature " + choice.id() + " references missing block material " + material;
         }
-        if (isRock(choice.id())) {
+        if (solidFeature(choice.id())) {
             if (!BlockSymbolPages.isRockMaterial(block.orElseThrow())) {
                 return "Feature " + choice.id() + " needs a full solid block without a block entity: " + material;
             }
@@ -133,25 +311,64 @@ public final class AgeFeatureSelection {
     }
 
     public static boolean isRock(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "rocks"));
+        return is(choice, "rocks");
     }
 
     public static boolean isLake(ResourceLocation choice) {
-        return choice.getNamespace().equals("rivencraft") && List.of(
-                "surface_lakes", "deep_lakes", "lava_lakes").contains(choice.getPath());
+        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) {
-        return choice.getNamespace().equals("rivencraft")
-                && List.of("flowers", "trees", "huge_trees").contains(choice.getPath());
+        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 choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "caves"));
+        return is(choice, "caves");
     }
 
     public static boolean ravines(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "ravines"));
+        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) {
@@ -173,6 +390,7 @@ public final class AgeFeatureSelection {
             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) {
-    public static final int CURRENT_VERSION = 2;
+                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection,
+                                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) {
-            throw new IllegalArgumentException("Version 2 Age plan requires a biome selection snapshot");
+        if (version >= 2 && biomeSelection == null) {
+            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,23 +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);
-        AgeFeatureSelection.compile(parsed, profile, biomes, 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);
@@ -106,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());
@@ -162,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(
-            STANDARD, AMPLIFIED, ISLAND, CAVE, FLAT, VOID
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> RANDOM_PROFILES = List.of(
+            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,175 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.resources.ResourceLocation;
+
+/** 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;
+    private static final int BRIGHT_LIGHTING_COST = 500;
+    private static final int EXCESS_LEGACY_STRUCTURE_COST = 100;
+    private static final int FORCED_STRUCTURE_BIOME_COST = 100;
+    private static final Map<ResourceLocation, String> COUNTED_STRUCTURES = Map.ofEntries(
+            Map.entry(id("mineshafts"), "Mineshafts"),
+            Map.entry(id("nether_fortresses"), "Nether Fortresses"),
+            Map.entry(id("strongholds"), "Strongholds"),
+            Map.entry(id("villages"), "Villages"),
+            Map.entry(id("bastions"), "Bastions"),
+            Map.entry(id("trial_chambers"), "Trial Chambers"),
+            Map.entry(id("ancient_cities"), "Ancient Cities"),
+            Map.entry(id("shipwrecks"), "Shipwrecks"),
+            Map.entry(id("ocean_ruins"), "Ocean Ruins"),
+            Map.entry(id("pillager_outposts"), "Pillager Outposts"),
+            Map.entry(id("ruined_portals"), "Ruined Portals"),
+            Map.entry(id("nether_fossils"), "Nether Fossils"),
+            Map.entry(id("buried_treasure"), "Buried Treasure"),
+            Map.entry(id("trail_ruins"), "Trail Ruins")
+    );
+
+    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, RegistryAccess registries) {
+        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()));
+            }
+            addAuditedSymbolCosts(plan, registries, contributions);
+        }
+        // A missing lighting controller is seed-completed. Legacy runs the generated
+        // symbol's own modifier, so a generated Bright Lighting choice still costs 500.
+        if (traits.lighting() == AgeTraits.Lighting.BRIGHT && (plan == null || plan.symbols().stream()
+                .noneMatch(symbol -> symbol.semantics().role()
+                        == net.dnorberg.rivencraft.writing.SymbolSemantics.Role.LIGHTING))) {
+            contributions.add(new Contribution("bright_lighting", -1, BRIGHT_LIGHTING_COST,
+                    "Seeded bright lighting"));
+        }
+        return new AgeInstability(CURRENT_VERSION,
+                contributions.stream().mapToInt(Contribution::points).sum(), contributions);
+    }
+
+    private static void addAuditedSymbolCosts(AgeGenerationPlan plan, RegistryAccess registries,
+                                              List<Contribution> contributions) {
+        Map<ResourceLocation, Integer> structureCounts = new HashMap<>();
+        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.symbols()) {
+            if (symbol.semantics().role()
+                    == net.dnorberg.rivencraft.writing.SymbolSemantics.Role.LIGHTING
+                    && symbol.semantics().value()
+                    instanceof net.dnorberg.rivencraft.writing.SymbolSemantics.ChoiceValue choice
+                    && choice.id().equals("bright")) {
+                contributions.add(new Contribution("bright_lighting", symbol.index(), BRIGHT_LIGHTING_COST,
+                        "Authored bright lighting"));
+                continue;
+            }
+            if (symbol.semantics().role()
+                    != net.dnorberg.rivencraft.writing.SymbolSemantics.Role.FEATURE
+                    || !(symbol.semantics().value()
+                    instanceof net.dnorberg.rivencraft.writing.SymbolSemantics.ResourceValue resource)) continue;
+            String name = COUNTED_STRUCTURES.get(resource.id());
+            if (name == null) continue;
+            int count = structureCounts.merge(resource.id(), 1, Integer::sum);
+            if (!AgeStructureSelection.biomeCompatible(resource.id(), plan.biomeSelection(), registries)) {
+                contributions.add(new Contribution("forced_biome_" + resource.id().getPath(), symbol.index(),
+                        FORCED_STRUCTURE_BIOME_COST,
+                        name + " occurrence " + count + " is forced into an unsupported biome"));
+            }
+            int cost = featureCost(resource.id(), count);
+            if (cost > 0) {
+                contributions.add(new Contribution("excess_" + resource.id().getPath(), symbol.index(),
+                        cost,
+                        name + " occurrence " + count + " exceeds Legacy's first three free occurrences"));
+            }
+        }
+    }
+
+    static int featureCost(ResourceLocation feature, int occurrence) {
+        if (occurrence < 1) throw new IllegalArgumentException("Feature occurrence must be positive");
+        return COUNTED_STRUCTURES.containsKey(feature) && occurrence > 3
+                ? EXCESS_LEGACY_STRUCTURE_COST : 0;
+    }
+
+    /** Current totals exposed to diagnostics. Player-driven mutable bonuses are deliberately disabled. */
+    public Totals totals() {
+        return new Totals(score, 0, 0, score);
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath("rivencraft", path);
+    }
+
+    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");
+            }
+        }
+    }
+
+    public record Totals(int baseScore, int stabilityBonus, int instabilityPenalty, int effectiveScore) {
+        public Totals {
+            if (baseScore < 0 || stabilityBonus < 0 || instabilityPenalty < 0
+                    || effectiveScore != Math.max(0, baseScore + instabilityPenalty - stabilityBonus)) {
+                throw new IllegalArgumentException("Invalid instability totals");
+            }
+        }
+    }
+}

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;
@@ -55,6 +56,202 @@ 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.getLevel().registryAccess());
+        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 auditedSymbolCostsAreCountedAndAgeScoped(GameTestHelper helper) {
+        List<String> legacyStructures = List.of("mineshafts", "nether_fortresses", "strongholds", "villages");
+        for (String structure : legacyStructures) {
+            AgeDefinition three = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                    new AgeReference(UUID.randomUUID(), "Three " + structure), structureWriting(structure, 3));
+            AgeDefinition four = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                    new AgeReference(UUID.randomUUID(), "Four " + structure), structureWriting(structure, 4));
+            helper.assertValueEqual(three.instability().score(), 0,
+                    "The first three " + structure + " pages retain Legacy's zero cost");
+            helper.assertValueEqual(four.instability().score(), 100,
+                    "The fourth " + structure + " page must add Legacy's 100-point cost");
+            helper.assertTrue(four.instability().breakdown().stream().anyMatch(part ->
+                            part.reason().equals("excess_" + structure) && part.pageIndex() == 8),
+                    "The excess structure cost must identify its authored page");
+        }
+        for (String structure : List.of("bastions", "trial_chambers", "ancient_cities", "shipwrecks",
+                "ocean_ruins", "pillager_outposts", "ruined_portals", "nether_fossils", "buried_treasure",
+                "trail_ruins")) {
+            ResourceLocation id = ResourceLocation.fromNamespaceAndPath("rivencraft", structure);
+            helper.assertTrue(AgeInstability.featureCost(id, 1) == 0
+                            && AgeInstability.featureCost(id, 3) == 0
+                            && AgeInstability.featureCost(id, 4) == 100
+                            && AgeInstability.featureCost(id, 5) == 100,
+                    structure + " must follow the selected Legacy Mineshaft repeat rule");
+        }
+        helper.assertValueEqual(AgeInstability.featureCost(
+                        ResourceLocation.parse("rivencraft:trial_chambers"), 4), 100,
+                "Modern repeated structures must use the same deterministic scoring path");
+        helper.assertValueEqual(AgeInstability.featureCost(ResourceLocation.parse("rivencraft:dungeons"), 4), 0,
+                "A Legacy-neutral feature must remain neutral when repeated");
+
+        OrderedWriting duplicateBright = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/bright"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/bright")))
+        ));
+        AgeDefinition bright = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Double Bright"), duplicateBright);
+        helper.assertValueEqual(bright.instability().score(), 1500,
+                "Each Bright Lighting page costs 500 and the extra controller costs another 500");
+        helper.assertValueEqual(bright.instability().breakdown().stream()
+                        .filter(part -> part.reason().equals("bright_lighting")).count(), 2L,
+                "Every authored Bright Lighting occurrence must retain its own cost");
+
+        AgeInstability.Totals totals = bright.instability().totals();
+        helper.assertValueEqual(totals.baseScore(), 1500, "Diagnostics must expose the immutable base score");
+        helper.assertTrue(totals.stabilityBonus() == 0 && totals.instabilityPenalty() == 0
+                        && totals.effectiveScore() == totals.baseScore(),
+                "Dormant player bonus classes must not create mutable, cross-Age credit");
+        AgeDefinition restored = AgeRegistrySavedData.load(
+                AgeRegistrySavedData.get(helper.getLevel()).save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess()).find(bright.id()).orElseThrow();
+        helper.assertValueEqual(restored.instability().totals(), totals,
+                "The base/adjustment diagnostic must remain identical after reload");
+        helper.succeed();
+    }
+
+    private static OrderedWriting structureWriting(String structure, int count) {
+        boolean nether = structure.equals("nether_fortresses");
+        List<WritingEntry> entries = new java.util.ArrayList<>(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse(
+                        nether ? "rivencraft:terrain/cave" : "rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse(
+                        nether ? "rivencraft:biome/nether_wastes" : "rivencraft:biome/plains"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/single"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal")))
+        ));
+        for (int index = 0; index < count; index++) {
+            entries.add(WritingEntry.symbol(new SymbolReference(
+                    ResourceLocation.parse("rivencraft:feature/" + structure))));
+        }
+        return new OrderedWriting(entries);
+    }
+
+    @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 +263,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 +367,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

@@ -33,7 +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";
@@ -88,6 +91,15 @@ public final class AgeRegistrySavedData extends SavedData {
         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))
@@ -122,6 +134,9 @@ public final class AgeRegistrySavedData extends SavedData {
         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, registries);
+        AgeInstabilityPlan instabilityPlan = AgeInstabilityPlan.select(instability, seed);
         AgeDefinition created = new AgeDefinition(
                 reference.id(),
                 name,
@@ -131,9 +146,13 @@ public final class AgeRegistrySavedData extends SavedData {
                 createdGameTime,
                 dimensionId,
                 null,
-                AgeEnvironmentCompiler.apply(plan, traits),
+                effectiveTraits,
                 plan,
-                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons"))
+                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();
@@ -166,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)),
@@ -179,7 +211,10 @@ public final class AgeRegistrySavedData extends SavedData {
                     entry.contains(PLAN_TAG, CompoundTag.TAG_COMPOUND)
                             ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null,
                     entry.contains(SEASON_MODE_TAG, CompoundTag.TAG_STRING)
-                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null
+                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null,
+                    readRandomFeatures(entry),
+                    instability,
+                    instabilityPlan
             ));
         }
         return data;
@@ -213,13 +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

@@ -6,6 +6,7 @@ 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;
@@ -59,26 +60,33 @@ public final class AgeRuntimeProfiles {
         if (PROFILES.isEmpty()) {
             return AgeGenerationProfiles.select(seed);
         }
-        java.util.List<ResourceLocation> ids = PROFILES.keySet().stream().sorted().toList();
-        return ids.get(Math.floorMod(Long.hashCode(seed), ids.size()));
+        List<LegacyRankChoice.Option<ResourceLocation>> profiles = PROFILES.keySet().stream().sorted()
+                .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.symbols().stream().anyMatch(symbol ->
+        if (parsed.activeSymbols().stream().anyMatch(symbol ->
                 symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)) return selected;
-        List<ResourceLocation> features = parsed.symbols().stream()
+        List<ResourceLocation> features = parsed.activeSymbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
-        if (features.isEmpty() || PROFILES.isEmpty()) return selected;
+        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)) return selected;
+                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.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()));

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

@@ -2,6 +2,7 @@ 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;
 
@@ -19,7 +20,13 @@ public enum AgeSeasonMode {
     /** An omitted page is selected once when an Age is created with Serene installed. */
     public static AgeSeasonMode select(AgeGenerationPlan plan, long ageSeed, boolean sereneInstalled) {
         if (hasAuthoredPage(plan)) return from(plan);
-        return sereneInstalled ? values()[new Random(ageSeed ^ RANDOM_SALT).nextInt(values().length)] : null;
+        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. */
@@ -28,7 +35,7 @@ public enum AgeSeasonMode {
     }
 
     public static boolean hasAuthoredPage(AgeGenerationPlan plan) {
-        return plan != null && plan.symbols().stream()
+        return plan != null && plan.activeSymbols().stream()
                 .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON);
     }
 
@@ -42,7 +49,7 @@ public enum AgeSeasonMode {
 
     public static AgeSeasonMode from(AgeGenerationPlan plan) {
         if (plan == null) return SEASONS;
-        return plan.symbols().stream()
+        return plan.activeSymbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON)
                 .map(symbol -> valueOf(((SymbolSemantics.ChoiceValue) symbol.semantics().value())
                         .id().toUpperCase(Locale.ROOT)))

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,181 @@
+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.mixin.StructurePlacementAccessor;
+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.minecraft.world.level.levelgen.structure.placement.ConcentricRingsStructurePlacement;
+import net.minecraft.world.level.levelgen.structure.placement.RandomSpreadStructurePlacement;
+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();
+    }
+
+    @GameTest(template = "empty")
+    public static void repeatedStructurePagesIncreasePlacementFrequency(GameTestHelper helper) {
+        var lookup = helper.getLevel().registryAccess().lookupOrThrow(Registries.STRUCTURE_SET);
+
+        RandomSpreadStructurePlacement oneVillage = (RandomSpreadStructurePlacement) lookup
+                .getOrThrow(BuiltinStructureSets.VILLAGES).value().placement();
+        RandomSpreadStructurePlacement twoVillages = (RandomSpreadStructurePlacement) AgeStructureSelection
+                .filteredLookup(lookup, repeated("villages", 2)).getOrThrow(BuiltinStructureSets.VILLAGES)
+                .value().placement();
+        helper.assertTrue(oneVillage.spacing() == 34 && twoVillages.spacing() == 24,
+                "A second Village page must approximately double density by reducing grid spacing");
+
+        RandomSpreadStructurePlacement oneMineshaft = (RandomSpreadStructurePlacement) lookup
+                .getOrThrow(BuiltinStructureSets.MINESHAFTS).value().placement();
+        RandomSpreadStructurePlacement twoMineshafts = (RandomSpreadStructurePlacement) AgeStructureSelection
+                .filteredLookup(lookup, repeated("mineshafts", 2)).getOrThrow(BuiltinStructureSets.MINESHAFTS)
+                .value().placement();
+        float oneFrequency = ((StructurePlacementAccessor) oneMineshaft).rivencraft$frequency();
+        float twoFrequency = ((StructurePlacementAccessor) twoMineshafts).rivencraft$frequency();
+        helper.assertTrue(oneMineshaft.spacing() == 1 && twoMineshafts.spacing() == 1
+                        && Math.abs(twoFrequency - oneFrequency * 2.0F) < 0.000001F,
+                "A second Mineshaft page must double its per-chunk probability");
+
+        ConcentricRingsStructurePlacement oneStronghold = (ConcentricRingsStructurePlacement) lookup
+                .getOrThrow(BuiltinStructureSets.STRONGHOLDS).value().placement();
+        ConcentricRingsStructurePlacement twoStrongholds = (ConcentricRingsStructurePlacement) AgeStructureSelection
+                .filteredLookup(lookup, repeated("strongholds", 2)).getOrThrow(BuiltinStructureSets.STRONGHOLDS)
+                .value().placement();
+        helper.assertTrue(twoStrongholds.distance() == oneStronghold.distance()
+                        && twoStrongholds.spread() == oneStronghold.spread() * 2
+                        && twoStrongholds.count() == oneStronghold.count() * 2,
+                "A second Stronghold page must double positions per ring and total positions");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void repeatedStructuresConstrainSeedCompletedBiomes(GameTestHelper helper) {
+        OrderedWriting fourVillages = new OrderedWriting(new java.util.ArrayList<>(java.util.stream.Stream.concat(
+                java.util.stream.Stream.of(WritingEntry.linkPanel()),
+                java.util.stream.IntStream.range(0, 4).mapToObj(ignored -> page("feature/villages")))
+                .toList()));
+        try {
+            AgeRegistrySavedData.validateNewWriting(helper.getLevel(), "four", fourVillages);
+        } catch (IllegalArgumentException exception) {
+            helper.fail("Four Village pages without explicit biome pages must use compatible seeded completion: "
+                    + exception.getMessage());
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void authoredVillagesOverrideBiomeWithInstability(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                page("terrain/standard"), page("biome/the_end"), page("biome/single"),
+                page("feature/villages"), page("feature/villages")));
+        AgeDefinition age;
+        try {
+            age = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                    new AgeReference(java.util.UUID.randomUUID(), "Forced End Villages"), writing);
+        } catch (IllegalArgumentException exception) {
+            helper.fail("Authored Villages must be allowed outside vanilla Village biomes: "
+                    + exception.getMessage());
+            return;
+        }
+        helper.assertValueEqual(age.instability().score(), 200,
+                "Each of two Villages forced into The End biome must add 100 instability");
+        helper.assertValueEqual(age.instability().breakdown().stream()
+                        .filter(part -> part.reason().equals("forced_biome_villages")).count(), 2L,
+                "Every forced Village occurrence must retain its own instability contribution");
+        helper.succeed();
+    }
+
+    private static List<AgeFeatureSelection.Choice> repeated(String feature, int count) {
+        return java.util.stream.IntStream.range(0, count)
+                .mapToObj(ignored -> new AgeFeatureSelection.Choice(id(feature), Optional.<ResourceLocation>empty()))
+                .toList();
+    }
+
+    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,275 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+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.dnorberg.rivencraft.mixin.StructurePlacementAccessor;
+import net.minecraft.core.Holder;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.HolderOwner;
+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.Structure;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
+import net.minecraft.world.level.levelgen.structure.placement.ConcentricRingsStructurePlacement;
+import net.minecraft.world.level.levelgen.structure.placement.RandomSpreadStructurePlacement;
+import net.minecraft.world.level.levelgen.structure.placement.StructurePlacement;
+
+/** 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;
+        // Authored structures intentionally override vanilla biome eligibility. An
+        // incompatible selection is legal writing and receives instability instead.
+        return null;
+    }
+
+    private static boolean placedExists(RegistryAccess registries, ResourceLocation id) {
+        return registries.lookupOrThrow(Registries.PLACED_FEATURE)
+                .get(ResourceKey.create(Registries.PLACED_FEATURE, id)).isPresent();
+    }
+
+    static Set<ResourceLocation> compatibleBiomes(ResourceLocation feature, RegistryAccess registries) {
+        ResourceLocation structureSet = setId(feature);
+        if (structureSet == null) return Set.of();
+        return registries.lookupOrThrow(Registries.STRUCTURE_SET)
+                .get(ResourceKey.create(Registries.STRUCTURE_SET, structureSet)).stream()
+                .flatMap(holder -> holder.value().structures().stream())
+                .flatMap(entry -> entry.structure().value().biomes().stream())
+                .flatMap(holder -> holder.unwrapKey().stream())
+                .map(ResourceKey::location)
+                .collect(java.util.stream.Collectors.toUnmodifiableSet());
+    }
+
+    public static boolean biomeCompatible(ResourceLocation feature, AgeBiomeSelection biomes,
+                                          RegistryAccess registries) {
+        Set<ResourceLocation> compatible = compatibleBiomes(feature, registries);
+        return compatible.isEmpty() || biomes.biomes().stream().anyMatch(compatible::contains);
+    }
+
+    /** True when this exact registered structure belongs to an authored structure page. */
+    public static boolean authoredStructure(Structure structure, RegistryAccess registries,
+                                            List<AgeFeatureSelection.Choice> choices) {
+        Set<ResourceLocation> enabled = enabledSets(choices).keySet();
+        var sets = registries.lookupOrThrow(Registries.STRUCTURE_SET);
+        return enabled.stream().map(id -> ResourceKey.create(Registries.STRUCTURE_SET, id))
+                .flatMap(key -> sets.get(key).stream())
+                .flatMap(holder -> holder.value().structures().stream())
+                .anyMatch(entry -> entry.structure().value() == structure);
+    }
+
+    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)
+                .filter(id -> dungeons(id) || biomeCompatible(id, biomes, registries))
+                .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 Map<ResourceLocation, Integer> enabledSets(List<AgeFeatureSelection.Choice> choices) {
+        Map<ResourceLocation, Integer> counts = new HashMap<>();
+        choices.stream().filter(choice -> feature(choice.id()) && !dungeons(choice.id()))
+                .forEach(choice -> counts.merge(setId(choice.id()), 1, Integer::sum));
+        return Map.copyOf(counts);
+    }
+
+    public static Stream<Holder<StructureSet>> allowedSets(Stream<Holder<StructureSet>> sets,
+                                                            List<AgeFeatureSelection.Choice> choices) {
+        Map<ResourceLocation, Integer> enabled = enabledSets(choices);
+        return sets.filter(holder -> holder.unwrapKey()
+                        .map(key -> allowed(key.location(), enabled.keySet())).orElse(false))
+                .map(holder -> scaledHolder(holder, enabled));
+    }
+
+    public static HolderLookup<StructureSet> filteredLookup(HolderLookup<StructureSet> lookup,
+                                                             List<AgeFeatureSelection.Choice> choices) {
+        Map<ResourceLocation, Integer> enabled = enabledSets(choices);
+        Map<ResourceKey<StructureSet>, Holder.Reference<StructureSet>> scaled = new HashMap<>();
+        return new HolderLookup<>() {
+            @Override
+            public Optional<Holder.Reference<StructureSet>> get(ResourceKey<StructureSet> key) {
+                if (!allowed(key.location(), enabled.keySet())) return Optional.empty();
+                return lookup.get(key).map(holder -> scaled.computeIfAbsent(key,
+                        ignored -> scaledReference(holder, enabled.getOrDefault(key.location(), 1))));
+            }
+
+            @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.keySet()))
+                        .map(holder -> scaled.computeIfAbsent(holder.key(),
+                                ignored -> scaledReference(holder,
+                                        enabled.getOrDefault(holder.key().location(), 1))));
+            }
+
+            @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);
+    }
+
+    private static Holder<StructureSet> scaledHolder(Holder<StructureSet> holder,
+                                                      Map<ResourceLocation, Integer> enabled) {
+        int occurrences = holder.unwrapKey().map(key -> enabled.getOrDefault(key.location(), 1)).orElse(1);
+        return occurrences == 1 ? holder : Holder.direct(scaled(holder.value(), occurrences));
+    }
+
+    private static Holder.Reference<StructureSet> scaledReference(Holder.Reference<StructureSet> holder,
+                                                                   int occurrences) {
+        if (occurrences == 1) return holder;
+        return new ScaledReference(holder.key(), scaled(holder.value(), occurrences));
+    }
+
+    static StructureSet scaled(StructureSet set, int occurrences) {
+        if (occurrences < 1) throw new IllegalArgumentException("Structure occurrence count must be positive");
+        if (occurrences == 1) return set;
+        StructurePlacement placement = set.placement();
+        StructurePlacementAccessor base = (StructurePlacementAccessor) placement;
+        if (placement instanceof RandomSpreadStructurePlacement random) {
+            float originalFrequency = base.rivencraft$frequency();
+            float frequency = Math.min(1.0F, originalFrequency * occurrences);
+            double frequencyFactor = originalFrequency > 0.0F ? frequency / originalFrequency : 1.0;
+            double spacingFactor = occurrences / frequencyFactor;
+            int spacing = Math.max(1, (int) Math.round(random.spacing() / Math.sqrt(spacingFactor)));
+            int separation = spacing == 1 ? 0 : Math.min(spacing - 1,
+                    (int) Math.round((double) random.separation() * spacing / random.spacing()));
+            return new StructureSet(set.structures(), new RandomSpreadStructurePlacement(
+                    base.rivencraft$locateOffset(), base.rivencraft$frequencyReductionMethod(), frequency,
+                    base.rivencraft$salt(), base.rivencraft$exclusionZone(), spacing, separation,
+                    random.spreadType()));
+        }
+        if (placement instanceof ConcentricRingsStructurePlacement rings) {
+            int count = saturatedMultiply(rings.count(), occurrences, 4095);
+            int spread = Math.min(count, saturatedMultiply(rings.spread(), occurrences, 1023));
+            return new StructureSet(set.structures(), new ConcentricRingsStructurePlacement(
+                    base.rivencraft$locateOffset(), base.rivencraft$frequencyReductionMethod(),
+                    base.rivencraft$frequency(), base.rivencraft$salt(), base.rivencraft$exclusionZone(),
+                    rings.distance(), spread, count, rings.preferredBiomes()));
+        }
+        return set;
+    }
+
+    private static int saturatedMultiply(int value, int multiplier, int maximum) {
+        return (int) Math.min(maximum, (long) value * multiplier);
+    }
+
+    private static final class ScaledReference extends Holder.Reference<StructureSet> {
+        private static final HolderOwner<StructureSet> OWNER = new HolderOwner<>() {};
+
+        private ScaledReference(ResourceKey<StructureSet> key, StructureSet value) {
+            super(Type.STAND_ALONE, OWNER, key, value);
+        }
+    }
+}

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());
-        Lighting lighting = randomChoice(random, Lighting.values());
-        Weather weather = randomChoice(random, Weather.values());
+        BiomeDistribution biomeDistribution = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(BiomeDistribution.NATIVE, 1),
+                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

@@ -91,8 +91,10 @@ public final class EnvironmentWritingGameTests {
                 AgeSeasonMode.NO_SEASONS, "The Age's seasonal policy must survive reload");
         OrderedWriting conflict = new OrderedWriting(List.of(WritingEntry.linkPanel(),
                 page("season/no_seasons"), page("season/eternal_winter")));
-        helper.assertFalse(WritingGrammar.parse(conflict).canCreate(),
-                "Only one seasonal page may be used in an Age");
+        helper.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();
     }
 

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

@@ -7,12 +7,14 @@ 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;
@@ -21,7 +23,7 @@ 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.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
 @PrefixGameTestTemplate(false)
 public final class FeatureWritingGameTests {
     private FeatureWritingGameTests() {}
@@ -31,7 +33,16 @@ public final class FeatureWritingGameTests {
         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/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) {
@@ -57,7 +68,16 @@ public final class FeatureWritingGameTests {
         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())) continue;
+            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(),
@@ -92,11 +112,207 @@ public final class FeatureWritingGameTests {
                 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).contains(choice("flowers")),
+                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");
@@ -146,7 +362,45 @@ public final class FeatureWritingGameTests {
     }
 
     @GameTest(template = "empty")
-    public static void incompatibleAndMisplacedBlockPagesAreRejected(GameTestHelper helper) {
+    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"),
@@ -155,8 +409,30 @@ public final class FeatureWritingGameTests {
                 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");
-        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
-                block("stone"))), "immediately before a compatible feature");
+        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();
     }
 
@@ -185,6 +461,32 @@ public final class FeatureWritingGameTests {
         });
     }
 
+    @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,

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/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;
@@ -250,7 +252,7 @@ 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");

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

@@ -93,9 +93,9 @@ public final class ClientBookInteractionHandler {
             }
             minecraft.setScreen(payload.fromStand()
                     ? new DescriptiveBookScreen(payload.source().pos(), payload.book(), payload.traits(),
-                            payload.writingSymbols(), payload.diagnostics())
+                            payload.writingSymbols())
                     : new DescriptiveBookScreen(hand, payload.book(), payload.traits(),
-                            payload.writingSymbols(), payload.diagnostics()));
+                            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(
-                ModItems.LINKING_BOOK.get(),
-                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "bound"),
-                (stack, level, entity, seed) -> stack.has(ModDataComponents.LINK_TARGET.get()) ? 1.0F : 0.0F
-        ));
+        event.enqueueWork(() -> {
+            ItemProperties.register(
+                    ModItems.LINKING_BOOK.get(),
+                    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/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

@@ -73,12 +73,12 @@ public final class SymbolPageTextures {
     public static ResourceLocation forDisplay(SymbolDisplayMetadata display) {
         return display.resolved()
                 ? forSymbol(display.id(), display.poem(), false)
-                : texture("item/page_unresolved");
+                : 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()
-                && mouseX >= leftPos + 152 && mouseX < leftPos + 168
+        if (grammarTooltip != null && ((mouseX >= leftPos + 77 && mouseX < leftPos + 151)
+                || (mouseX >= leftPos + 152 && mouseX < leftPos + 168))
                 && mouseY >= topPos + 27 && mouseY < topPos + 43
-                && grammarTooltip != null) {
-            graphics.renderTooltip(font, grammarTooltip, mouseX, mouseY);
+                && (status != null || menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty())) {
+            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

@@ -45,7 +45,6 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private static final int LINK_PANEL_Y = 20;
     private static final int LINK_PANEL_WIDTH = 132;
     private static final int LINK_PANEL_HEIGHT = 83;
-    private static final int DIAGNOSTICS_PER_PAGE = 2;
     private static final Component EXPLORE_ICON = Component.literal("👁");
 
     private final AgeReference age;
@@ -53,7 +52,6 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private final AgeTraits traits;
     private final OrderedWriting writing;
     private final List<SymbolDisplayMetadata> writingSymbols;
-    private final List<WritingGrammar.Diagnostic> diagnostics;
     private final boolean pageFree;
     private final String author;
     private final InteractionHand hand;
@@ -67,15 +65,13 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private boolean movingToExploreOverlay;
 
     public DescriptiveBookScreen(InteractionHand hand, ItemStack book, @Nullable AgeTraits traits,
-                                 List<SymbolDisplayMetadata> writingSymbols,
-                                 List<WritingGrammar.Diagnostic> diagnostics) {
+                                 List<SymbolDisplayMetadata> writingSymbols) {
         super(book.getHoverName());
         age = book.get(ModDataComponents.AGE_REFERENCE.get());
         generationProfile = book.get(ModDataComponents.AGE_GENERATION_PROFILE.get());
         this.traits = traits;
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
-        this.diagnostics = List.copyOf(diagnostics);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
         author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         this.hand = hand;
@@ -83,15 +79,13 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     }
 
     public DescriptiveBookScreen(BlockPos bookStandPos, ItemStack book, @Nullable AgeTraits traits,
-                                 List<SymbolDisplayMetadata> writingSymbols,
-                                 List<WritingGrammar.Diagnostic> diagnostics) {
+                                 List<SymbolDisplayMetadata> writingSymbols) {
         super(book.getHoverName());
         age = book.get(ModDataComponents.AGE_REFERENCE.get());
         generationProfile = book.get(ModDataComponents.AGE_GENERATION_PROFILE.get());
         this.traits = traits;
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
-        this.diagnostics = List.copyOf(diagnostics);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
         author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         hand = InteractionHand.MAIN_HAND;
@@ -173,13 +167,6 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             else if (pageIndex < pageCount() && mouseX >= left + 293 && mouseX < left + 320)
                 graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.next_page"), mouseX, mouseY);
         }
-        if (pageIndex > 0 && pageIndex < writing.entries().size()
-                && mouseX >= left + 285 && mouseX < left + 306
-                && mouseY >= top + 149 && mouseY < top + 169) {
-            diagnostics.stream().filter(diagnostic -> diagnostic.index() == pageIndex)
-                    .findFirst().ifPresent(diagnostic -> graphics.renderTooltip(font,
-                            Component.literal(diagnostic.message()), mouseX, mouseY));
-        }
         if (pageIndex == 0 && age != null && !pageFree && traits != null
                 && mouseX >= left + 38 && mouseX < left + 154
                 && mouseY >= top + 38 && mouseY < top + 67) {
@@ -222,9 +209,6 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         } else if (pageIndex < writing.entries().size()) {
             LegacyBookArtwork.drawFullPage(graphics, left, top);
             renderWrittenPage(graphics, left, top);
-        } else if (!diagnostics.isEmpty()) {
-            LegacyBookArtwork.drawFullPage(graphics, left, top);
-            renderDiagnosticsPage(graphics, left, top);
         }
         String counter = pageIndex + "/" + pageCount();
         graphics.drawString(font, counter, left + 165 - font.width(counter) / 2,
@@ -233,9 +217,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
 
     private int pageCount() {
         // Older page-free Descriptive Books do not have a BOOK_WRITING component.
-        int authoredPages = Math.max(1, writing.entries().size() - 1);
-        return authoredPages + (diagnostics.isEmpty() ? 0
-                : (diagnostics.size() + DIAGNOSTICS_PER_PAGE - 1) / DIAGNOSTICS_PER_PAGE);
+        return Math.max(1, writing.entries().size() - 1);
     }
 
     private void renderFirstPageText(GuiGraphics graphics, int left, int top) {
@@ -245,6 +227,22 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                     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 nameEnd = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
@@ -298,28 +296,6 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                     x, top + 151, 126, UNRESOLVED_TEXT_COLOR);
         }
         graphics.disableScissor();
-        if (diagnostics.stream().anyMatch(diagnostic -> diagnostic.index() == pageIndex)) {
-            graphics.drawString(font, "!", left + 293, top + 153, UNRESOLVED_TEXT_COLOR, false);
-        }
-    }
-
-    private void renderDiagnosticsPage(GuiGraphics graphics, int left, int top) {
-        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.writing_notes"),
-                left + 176, top + 35, 126);
-        int start = (pageIndex - Math.max(1, writing.entries().size() - 1) - 1) * DIAGNOSTICS_PER_PAGE;
-        int y = top + 52;
-        graphics.enableScissor(left + 174, top + 50, left + 306, top + 173);
-        for (int index = start; index < Math.min(start + DIAGNOSTICS_PER_PAGE, diagnostics.size()); index++) {
-            WritingGrammar.Diagnostic diagnostic = diagnostics.get(index);
-            int color = diagnostic.error() ? UNRESOLVED_TEXT_COLOR : BOOK_TEXT_COLOR;
-            Component label = diagnostic.index() < 0
-                    ? Component.translatable("screen.rivencraft.age.writing_general")
-                    : Component.translatable("screen.rivencraft.age.writing_page", diagnostic.index() + 1);
-            y = drawWrappedWithoutShadow(graphics, label, left + 176, y, 126, color) + 3;
-            y = drawWrappedWithoutShadow(graphics, Component.literal(diagnostic.message()),
-                    left + 176, y, 126, color) + 10;
-        }
-        graphics.disableScissor();
     }
 
     private void turnPage(int direction) {

src/main/java/net/dnorberg/rivencraft/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/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;
@@ -20,6 +27,17 @@ public final class RivencraftCommands {
                 .then(Commands.literal("age")
                         .then(Commands.literal("list")
                                 .executes(context -> listAges(context.getSource())))
+                        .then(Commands.literal("instability")
+                                .executes(context -> inspectInstability(context.getSource(),
+                                        context.getSource().getLevel().dimension().location().toString()))
+                                .then(Commands.argument("dimension", StringArgumentType.string())
+                                        .suggests((context, builder) -> {
+                                            AgeRegistrySavedData.get(context.getSource().getLevel()).definitions()
+                                                    .forEach(age -> builder.suggest(age.dimensionId().toString()));
+                                            return builder.buildFuture();
+                                        })
+                                        .executes(context -> inspectInstability(context.getSource(),
+                                                StringArgumentType.getString(context, "dimension")))))
                         .then(Commands.literal("unload")
                                 .then(Commands.argument("dimension", StringArgumentType.string())
                                         .suggests((context, builder) -> {
@@ -30,7 +48,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) {
@@ -80,4 +129,76 @@ public final class RivencraftCommands {
             }
         };
     }
+
+    private static int inspectInstability(CommandSourceStack source, String requestedDimension) {
+        ResourceLocation dimension = ResourceLocation.tryParse(requestedDimension);
+        if (dimension == null) {
+            source.sendFailure(Component.literal("Invalid dimension id: " + requestedDimension));
+            return 0;
+        }
+        AgeDefinition age = AgeRegistrySavedData.get(source.getLevel()).findByDimension(dimension).orElse(null);
+        if (age == null) {
+            source.sendFailure(Component.literal("Unknown Rivencraft Age: " + dimension));
+            return 0;
+        }
+        var totals = age.instability().totals();
+        source.sendSuccess(() -> Component.literal(age.name() + " — " + age.dimensionId()), false);
+        source.sendSuccess(() -> Component.literal("Instability: base " + totals.baseScore()
+                + ", stability bonus " + totals.stabilityBonus()
+                + ", penalty " + totals.instabilityPenalty()
+                + ", effective " + totals.effectiveScore()), false);
+        source.sendSuccess(() -> Component.literal("Mutable player bonuses: disabled (no active Legacy registration)"),
+                false);
+        return totals.effectiveScore();
+    }
+
+    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/jei/RivencraftJeiPlugin.java

@@ -68,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()));

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

@@ -18,6 +18,44 @@ public final class RivencraftConfig {
     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();
@@ -40,6 +78,98 @@ public final class RivencraftConfig {
                 "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();
     }
 
@@ -61,4 +191,43 @@ public final class RivencraftConfig {
     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

@@ -101,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");
@@ -109,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");
-        int errorEntry = binder.writingGrammar().firstError().orElseThrow().index();
+        helper.assertTrue(binder.canAssemble(), "Duplicate terrain must create an unstable Age");
+        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");
-        helper.assertFalse(binder.consumeAssembly(), "Rejected grammar must not consume binder inputs");
+                "An instability warning must highlight the correct strip page despite empty positions");
+        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(binder.canAssemble(), "Corrected partial writing must become assemblable");
+        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to remove the duplicate page");
+        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must remain assemblable");
         helper.succeed();
     }
 

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

@@ -101,6 +101,11 @@ public final class CoreGameTests {
         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();
     }
 

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;
@@ -234,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");
@@ -242,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();
@@ -284,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(),

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");
@@ -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");

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

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
+import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeTraits;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolDefinition;
@@ -23,7 +26,6 @@ import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 public final class WritingGrammarGameTests {
     private WritingGrammarGameTests() {}
 
-    @GameTest(template = "empty")
     public static void orderedGrammarAcceptsPartialWritingAndDiagnosesInvalidSequences(GameTestHelper helper) {
         SymbolReference terrain = ref("rivencraft:terrain/standard");
         SymbolReference nativeBiomes = ref("rivencraft:biome/native");
@@ -85,22 +87,47 @@ public final class WritingGrammarGameTests {
         WritingGrammar.Result repeatedModifiers = parse(resolver, WritingEntry.linkPanel(),
                 WritingEntry.symbol(periodHalf), WritingEntry.symbol(periodFull), WritingEntry.symbol(celestial));
         helper.assertTrue(repeatedModifiers.canCreate(), "Repeated period modifiers must remain legal");
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
                 WritingEntry.symbol(terrain)), WritingGrammar.Code.DUPLICATE);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
-                WritingEntry.symbol(alternateTerrain)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+        WritingGrammar.Result replacedTerrain = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(alternateTerrain));
+        assertPenalty(helper, replacedTerrain, WritingGrammar.Code.CONFLICT);
+        helper.assertValueEqual(replacedTerrain.activeSymbols().getFirst().reference(), alternateTerrain,
+                "The last supported controller must supply the effective terrain");
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
                 WritingEntry.symbol(terrain)), WritingGrammar.Code.OUT_OF_ORDER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
                 WritingEntry.symbol(periodHalf)), WritingGrammar.Code.MISPLACED_MODIFIER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
                 WritingEntry.symbol(plains)), WritingGrammar.Code.OUT_OF_ORDER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
                 WritingEntry.symbol(nativeBiomes)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
-                WritingEntry.symbol(forest), WritingEntry.symbol(single)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(caves),
-                WritingEntry.symbol(caves)), WritingGrammar.Code.DUPLICATE);
+        WritingGrammar.Result extraBiomes = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+                WritingEntry.symbol(forest), WritingEntry.symbol(single));
+        assertPenalty(helper, extraBiomes, WritingGrammar.Code.CONFLICT);
+        helper.assertValueEqual(extraBiomes.activeSymbols().stream().filter(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.BIOME).count(), 1L,
+                "Single-biome distribution must consume only one authored biome");
+        OrderedWriting repaired = writing(WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+                WritingEntry.symbol(terrain), WritingEntry.symbol(ref("rivencraft:terrain/flat")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(repaired, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(plan.authoredTerrain(), ResourceLocation.parse("rivencraft:flat"),
+                "The last terrain controller must win without deleting earlier pages");
+        helper.assertValueEqual(plan.writingInstability(), 600,
+                "An extra controller and repaired ordering must be counted once each");
+        helper.assertValueEqual(plan.symbols().size(), 3,
+                "The saved plan must retain all authored pages, including the extra controller");
+        AgeGenerationPlan loaded = AgeGenerationPlan.load(plan.save());
+        helper.assertValueEqual(loaded.writingInstability(), 600,
+                "Writing instability must survive a saved-plan round trip");
+        helper.assertValueEqual(loaded.activeSymbolIndices(), plan.activeSymbolIndices(),
+                "The effective writing order must not reroll on load");
+        WritingGrammar.Result repeatedFeatures = parse(resolver, WritingEntry.linkPanel(),
+                WritingEntry.symbol(caves), WritingEntry.symbol(caves));
+        helper.assertTrue(repeatedFeatures.canCreate(), "Repeated feature pages must remain authorable");
+        helper.assertValueEqual(repeatedFeatures.symbols().size(), 2,
+                "Repeated feature pages must remain separate ordered symbols");
         assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(ref("test:missing"))),
                 WritingGrammar.Code.UNRESOLVED);
         assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(displayOnly)),
@@ -140,4 +167,11 @@ public final class WritingGrammarGameTests {
         helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
                 "Writing must report " + code + " rather than silently dropping a page");
     }
+
+    private static void assertPenalty(GameTestHelper helper, WritingGrammar.Result result, WritingGrammar.Code code) {
+        helper.assertTrue(result.canCreate(), "Known writing defect " + code + " must not block Age creation");
+        helper.assertTrue(result.writingInstability() > 0, "Known writing defect must contribute instability");
+        helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
+                "Writing must report " + code + " rather than silently dropping a page");
+    }
 }

src/main/java/net/dnorberg/rivencraft/item/PageItem.java

@@ -102,6 +102,7 @@ public final class PageItem extends Item {
         Set<String> bundled = CREATIVE_SYMBOLS.keySet();
         registries.lookupOrThrow(Registries.BIOME).listElements()
                 .map(holder -> holder.key().location())
+                .filter(BiomeSymbolPages::isPublicPageBiome)
                 .filter(id -> !bundled.contains(BiomeSymbolPages.symbolId(id).getPath()))
                 .sorted()
                 .forEach(id -> pages.add(createCreativeBiomePage(id)));
@@ -210,6 +211,27 @@ public final class PageItem extends Item {
         return create(PageContent.LINK_PANEL);
     }
 
+    /** Every Link Panel modifier combination the Ink Mixer can produce. */
+    public static List<ItemStack> creativeLinkPanelPages() {
+        int[] flags = {
+                0,
+                LinkProperties.DISARM,
+                LinkProperties.MAINTAIN_MOMENTUM,
+                LinkProperties.INTRA_LINKING,
+                LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM,
+                LinkProperties.DISARM | LinkProperties.INTRA_LINKING,
+                LinkProperties.MAINTAIN_MOMENTUM | LinkProperties.INTRA_LINKING,
+                LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM | LinkProperties.INTRA_LINKING
+        };
+        List<ItemStack> pages = new ArrayList<>(flags.length);
+        for (int flag : flags) {
+            ItemStack page = createLinkPanelPage();
+            if (flag != 0) page.set(ModDataComponents.LINK_PROPERTIES.get(), new LinkProperties(flag));
+            pages.add(page);
+        }
+        return pages;
+    }
+
     /** Restores saved unknown references without granting them validity for new writing operations. */
     public static ItemStack createRecoveredPage(SymbolReference reference) {
         return create(PageContent.unresolved(reference));

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

@@ -23,11 +23,11 @@ import net.minecraft.world.item.Items;
 /** Fixed, ordered binder slots and a server-owned virtual result. */
 public final class BookBinderMenu extends AbstractContainerMenu {
     public static final int RESULT = BookBinderBlockEntity.SIZE;
-    public static final int SELECT_BASE = 100;
-    public static final int MOVE_PREVIOUS = 200;
-    public static final int MOVE_NEXT = 201;
-    public static final int IMPORT_NOTEBOOK = 202;
-    public static final int STRIP_CLICK_BASE = 300;
+    public static final int SELECT_BASE = 1000;
+    public static final int MOVE_PREVIOUS = 2000;
+    public static final int MOVE_NEXT = 2001;
+    public static final int IMPORT_NOTEBOOK = 2002;
+    public static final int STRIP_CLICK_BASE = 3000;
     private static final int PLAYER_START = RESULT + 1;
 
     private final BookBinderBlockEntity binder;
@@ -38,6 +38,9 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     private int selectedPage = -1;
     private int grammarErrorCode = -1;
     private int grammarErrorStripIndex = -1;
+    private int grammarInstability;
+    private int grammarIncompleteCount;
+    private WritingGrammar.Result serverGrammar;
 
     public BookBinderMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
         this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
@@ -56,18 +59,34 @@ public final class BookBinderMenu extends AbstractContainerMenu {
         });
         addDataSlot(new DataSlot() {
             @Override public int get() {
-                return clientSide || binder == null ? grammarErrorCode : binder.writingGrammar().firstError()
-                        .map(error -> error.code().ordinal()).orElse(-1);
+                return clientSide || binder == null ? grammarErrorCode : binderDiagnostic()
+                        .map(diagnostic -> diagnostic.code().ordinal()).orElse(-1);
             }
             @Override public void set(int value) { grammarErrorCode = value; }
         });
         addDataSlot(new DataSlot() {
             @Override public int get() {
-                return clientSide || binder == null ? grammarErrorStripIndex : binder.writingGrammar().firstError()
-                        .map(error -> binder.writingStripIndex(error.index())).orElse(-1);
+                return clientSide || binder == null ? grammarErrorStripIndex : binderDiagnostic()
+                        .map(diagnostic -> binder.writingStripIndex(diagnostic.index())).orElse(-1);
             }
             @Override public void set(int value) { grammarErrorStripIndex = value; }
         });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarInstability
+                        : serverGrammar().writingInstability();
+            }
+            @Override public void set(int value) { grammarInstability = value; }
+        });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarIncompleteCount
+                        : (int) serverGrammar().diagnostics().stream()
+                        .filter(diagnostic -> diagnostic.severity()
+                                == WritingGrammar.Severity.SEEDED_COMPLETION).count();
+            }
+            @Override public void set(int value) { grammarIncompleteCount = value; }
+        });
         addSlot(new BinderSlot(BookBinderBlockEntity.COVER, 8, 27, 64));
         addSlot(new BinderSlot(BookBinderBlockEntity.LINK_PANEL, -1000, -1000, 1));
         addSlot(new BinderSlot(BookBinderBlockEntity.NOTEBOOK, -1000, -1000, 1));
@@ -87,11 +106,27 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     }
 
     public int selectedPage() { return selectedPage; }
+    private WritingGrammar.Result serverGrammar() {
+        if (serverGrammar == null) serverGrammar = binder.writingGrammar();
+        return serverGrammar;
+    }
+    private Optional<WritingGrammar.Diagnostic> binderDiagnostic() {
+        WritingGrammar.Result grammar = serverGrammar();
+        return grammar.firstError().or(grammar::firstInstability).or(grammar::firstIncomplete);
+    }
     public Optional<WritingGrammar.Code> grammarError() {
         WritingGrammar.Code[] codes = WritingGrammar.Code.values();
         return grammarErrorCode >= 0 && grammarErrorCode < codes.length
                 ? Optional.of(codes[grammarErrorCode]) : Optional.empty();
     }
+    public boolean grammarWarning() {
+        return grammarSeverity().orElse(null) == WritingGrammar.Severity.INSTABILITY;
+    }
+    public Optional<WritingGrammar.Severity> grammarSeverity() {
+        return grammarError().map(WritingGrammar.Code::severity);
+    }
+    public int grammarInstability() { return grammarInstability; }
+    public int grammarIncompleteCount() { return grammarIncompleteCount; }
     public int grammarErrorStripIndex() { return grammarErrorStripIndex; }
     public String title() { return binder == null ? "" : binder.title(); }
     public boolean setTitle(Player player, String title) {
@@ -218,6 +253,7 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     }
 
     @Override public void broadcastChanges() {
+        serverGrammar = null;
         refreshResult();
         super.broadcastChanges();
     }

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

@@ -40,11 +40,9 @@ public final class NotebookMenu extends AbstractContainerMenu {
         this.openedHotbarSlot = inventory.selected;
         this.contents = new NotebookContainer(inventory, hand);
 
-        for (int row = 0; row < 3; row++) {
-            for (int column = 0; column < 9; column++) {
-                // The client draws these pages on a filtered, scrollable surface instead.
-                addSlot(new PageSlot(contents, column + row * 9, -1000, -1000));
-            }
+        for (int page = 0; page < NOTEBOOK_SLOTS; page++) {
+            // The client draws these pages on a filtered, scrollable surface instead.
+            addSlot(new PageSlot(contents, page, -1000, -1000));
         }
         for (int row = 0; row < 3; row++) {
             for (int column = 0; column < 9; column++) {

src/main/java/net/dnorberg/rivencraft/mixin/AgeDungeonPlacementMixin.java

@@ -0,0 +1,30 @@
+package net.dnorberg.rivencraft.mixin;
+
+import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Redirect;
+
+/** Suppresses biome-default monster rooms only in new Rivencraft Ages. */
+@Mixin(ChunkGenerator.class)
+public abstract class AgeDungeonPlacementMixin {
+    @Redirect(method = "applyBiomeDecoration", at = @At(value = "INVOKE",
+            target = "Lnet/minecraft/world/level/levelgen/placement/PlacedFeature;placeWithBiomeCheck(Lnet/minecraft/world/level/WorldGenLevel;Lnet/minecraft/world/level/chunk/ChunkGenerator;Lnet/minecraft/util/RandomSource;Lnet/minecraft/core/BlockPos;)Z"))
+    private boolean rivencraft$gateAmbientDungeons(PlacedFeature feature, WorldGenLevel level,
+                                                     ChunkGenerator generator, RandomSource random, BlockPos pos) {
+        if ((Object) this instanceof AgeFeatureChunkGenerator || (Object) this instanceof AgeFlatChunkGenerator) {
+            ResourceLocation id = level.registryAccess().registryOrThrow(Registries.PLACED_FEATURE).getKey(feature);
+            if (ResourceLocation.withDefaultNamespace("monster_room").equals(id)
+                    || ResourceLocation.withDefaultNamespace("monster_room_deep").equals(id)) return false;
+        }
+        return feature.placeWithBiomeCheck(level, generator, random, pos);
+    }
+}

src/main/java/net/dnorberg/rivencraft/mixin/AgeStructureBiomeMixin.java

@@ -0,0 +1,37 @@
+package net.dnorberg.rivencraft.mixin;
+
+import java.util.List;
+import java.util.Optional;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.dnorberg.rivencraft.book.AgeStructureSelection;
+import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.structure.Structure;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+/** Lets explicitly authored structures generate outside their vanilla biome sets. */
+@Mixin(Structure.class)
+public abstract class AgeStructureBiomeMixin {
+    @Shadow
+    protected abstract Optional<Structure.GenerationStub> findGenerationPoint(
+            Structure.GenerationContext context);
+
+    @Inject(method = "findValidGenerationPoint", at = @At("HEAD"), cancellable = true)
+    private void rivencraft$allowAuthoredStructureBiome(Structure.GenerationContext context,
+                                                         CallbackInfoReturnable<Optional<Structure.GenerationStub>> cir) {
+        ChunkGenerator generator = context.chunkGenerator();
+        List<AgeFeatureSelection.Choice> features;
+        if (generator instanceof AgeFeatureChunkGenerator age) features = age.ageFeatures();
+        else if (generator instanceof AgeFlatChunkGenerator age) features = age.ageFeatures();
+        else return;
+        if (AgeStructureSelection.authoredStructure((Structure) (Object) this,
+                context.registryAccess(), features)) {
+            cir.setReturnValue(findGenerationPoint(context));
+        }
+    }
+}

src/main/java/net/dnorberg/rivencraft/mixin/StructurePlacementAccessor.java

@@ -0,0 +1,26 @@
+package net.dnorberg.rivencraft.mixin;
+
+import java.util.Optional;
+import net.minecraft.core.Vec3i;
+import net.minecraft.world.level.levelgen.structure.placement.StructurePlacement;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+/** Exposes immutable placement settings so per-Age structure density can preserve vanilla behavior. */
+@Mixin(StructurePlacement.class)
+public interface StructurePlacementAccessor {
+    @Accessor("locateOffset")
+    Vec3i rivencraft$locateOffset();
+
+    @Accessor("frequencyReductionMethod")
+    StructurePlacement.FrequencyReductionMethod rivencraft$frequencyReductionMethod();
+
+    @Accessor("frequency")
+    float rivencraft$frequency();
+
+    @Accessor("salt")
+    int rivencraft$salt();
+
+    @Accessor("exclusionZone")
+    Optional<StructurePlacement.ExclusionZone> rivencraft$exclusionZone();
+}

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

@@ -59,7 +59,7 @@ public final class ModNetworking {
     }
 
     public static void register(RegisterPayloadHandlersEvent event) {
-        PayloadRegistrar registrar = event.registrar("14");
+        PayloadRegistrar registrar = event.registrar("15");
         registrar.playToServer(RequestDescriptiveBookScreenPayload.TYPE, RequestDescriptiveBookScreenPayload.STREAM_CODEC,
                 ModNetworking::requestDescriptiveBookScreen);
         registrar.playToClient(OpenDescriptiveBookScreenPayload.TYPE, OpenDescriptiveBookScreenPayload.STREAM_CODEC,
@@ -120,15 +120,12 @@ public final class ModNetworking {
                 .filter(entry -> entry.kind() == WritingEntry.Kind.SYMBOL)
                 .map(entry -> SymbolCatalog.display(entry.symbol().orElseThrow()))
                 .toList();
-        // Diagnostics are advisory display data from the authoritative server catalog.
-        // Opening a book never recompiles or changes its persisted Age plan.
-        var diagnostics = WritingGrammar.parse(writing).diagnostics();
         PacketDistributor.sendToPlayer(player, new OpenDescriptiveBookScreenPayload(
                 payload.fromStand(), payload.offhand(),
                 GlobalPos.of(player.level().dimension(), payload.standPos()), access.stack().copy(),
                 definition == null ? null : definition.plan() != null && definition.plan().biomeSelection() != null
                         ? definition.traits().withBiomeDistribution(definition.plan().biomeSelection().distribution())
-                        : definition.traits(), writingSymbols, diagnostics));
+                        : definition.traits(), writingSymbols));
     }
 
     private static void bindDescriptiveBook(BindDescriptiveBookPayload payload, IPayloadContext context) {

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

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

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

@@ -5,6 +5,7 @@ import net.dnorberg.rivencraft.block.entity.BookStandBlockEntity;
 import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
 import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
+import net.dnorberg.rivencraft.block.entity.StarFissureBlockEntity;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.neoforged.bus.api.IEventBus;
@@ -28,6 +29,9 @@ public final class ModBlockEntities {
     public static final DeferredHolder<BlockEntityType<?>, BlockEntityType<InkMixerBlockEntity>> INK_MIXER =
             BLOCK_ENTITIES.register("ink_mixer", () -> BlockEntityType.Builder
                     .of(InkMixerBlockEntity::new, ModBlocks.INK_MIXER.get()).build(null));
+    public static final DeferredHolder<BlockEntityType<?>, BlockEntityType<StarFissureBlockEntity>> STAR_FISSURE =
+            BLOCK_ENTITIES.register("star_fissure", () -> BlockEntityType.Builder
+                    .of(StarFissureBlockEntity::new, ModBlocks.STAR_FISSURE.get()).build(null));
 
     private ModBlockEntities() {
     }

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

@@ -5,7 +5,14 @@ import net.dnorberg.rivencraft.block.BookStandBlock;
 import net.dnorberg.rivencraft.block.BookBinderBlock;
 import net.dnorberg.rivencraft.block.WritingDeskBlock;
 import net.dnorberg.rivencraft.block.InkMixerBlock;
+import net.dnorberg.rivencraft.block.BuddingCrystalBlock;
+import net.dnorberg.rivencraft.block.StarFissureBlock;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.dnorberg.rivencraft.block.CloudPlatformBlock;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.material.MapColor;
 import net.minecraft.world.level.block.state.BlockBehaviour;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.neoforge.registries.DeferredBlock;
@@ -31,6 +38,32 @@ public final class ModBlocks {
             "ink_mixer", InkMixerBlock::new,
             BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion()
     );
+    public static final DeferredBlock<Block> CRYSTAL_BLOCK = BLOCKS.registerBlock("crystal_block",
+            Block::new, BlockBehaviour.Properties.ofFullCopy(Blocks.AMETHYST_BLOCK).mapColor(MapColor.COLOR_BLUE));
+    public static final DeferredBlock<BuddingCrystalBlock> BUDDING_CRYSTAL = BLOCKS.registerBlock("budding_crystal",
+            BuddingCrystalBlock::new, BlockBehaviour.Properties.ofFullCopy(Blocks.BUDDING_AMETHYST)
+                    .mapColor(MapColor.COLOR_BLUE));
+    public static final DeferredBlock<AmethystClusterBlock> CRYSTAL_CLUSTER = BLOCKS.registerBlock("crystal_cluster",
+            properties -> new AmethystClusterBlock(7.0F, 3.0F, properties),
+            BlockBehaviour.Properties.ofFullCopy(Blocks.AMETHYST_CLUSTER));
+    public static final DeferredBlock<AmethystClusterBlock> LARGE_CRYSTAL_BUD = BLOCKS.registerBlock("large_crystal_bud",
+            properties -> new AmethystClusterBlock(5.0F, 3.0F, properties),
+            BlockBehaviour.Properties.ofFullCopy(Blocks.LARGE_AMETHYST_BUD));
+    public static final DeferredBlock<AmethystClusterBlock> MEDIUM_CRYSTAL_BUD = BLOCKS.registerBlock("medium_crystal_bud",
+            properties -> new AmethystClusterBlock(4.0F, 3.0F, properties),
+            BlockBehaviour.Properties.ofFullCopy(Blocks.MEDIUM_AMETHYST_BUD));
+    public static final DeferredBlock<AmethystClusterBlock> SMALL_CRYSTAL_BUD = BLOCKS.registerBlock("small_crystal_bud",
+            properties -> new AmethystClusterBlock(3.0F, 4.0F, properties),
+            BlockBehaviour.Properties.ofFullCopy(Blocks.SMALL_AMETHYST_BUD));
+    public static final DeferredBlock<StarFissureBlock> STAR_FISSURE = BLOCKS.registerBlock("star_fissure",
+            StarFissureBlock::new, BlockBehaviour.Properties.ofFullCopy(Blocks.END_PORTAL)
+                    .lightLevel(state -> 6));
+    public static final DeferredBlock<DecayBlock> DECAY = BLOCKS.registerBlock("decay",
+            DecayBlock::new, BlockBehaviour.Properties.ofFullCopy(Blocks.STONE)
+                    .strength(5.0F, 10.0F).noLootTable());
+    public static final DeferredBlock<CloudPlatformBlock> CLOUD_PLATFORM = BLOCKS.registerBlock("cloud_platform",
+            CloudPlatformBlock::new, BlockBehaviour.Properties.ofFullCopy(Blocks.WHITE_STAINED_GLASS)
+                    .strength(1.5F).noOcclusion().noLootTable());
 
     private ModBlocks() {
     }

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

@@ -31,6 +31,13 @@ public final class ModCreativeTabs {
                         output.accept(ModItems.WRITING_DESK.get());
                         output.accept(ModItems.INK_MIXER.get());
                         output.accept(ModItems.BOOK_BINDER.get());
+                        output.accept(ModItems.CRYSTAL_BLOCK.get());
+                        output.accept(ModItems.BUDDING_CRYSTAL.get());
+                        output.accept(ModItems.CRYSTAL_CLUSTER.get());
+                        output.accept(ModItems.LARGE_CRYSTAL_BUD.get());
+                        output.accept(ModItems.MEDIUM_CRYSTAL_BUD.get());
+                        output.accept(ModItems.SMALL_CRYSTAL_BUD.get());
+                        output.accept(ModItems.CRYSTAL_SHARD.get());
                     })
                     .build());
 
@@ -38,7 +45,8 @@ public final class ModCreativeTabs {
             CREATIVE_TABS.register("rivencraft_link_pages", () -> CreativeModeTab.builder()
                     .title(Component.translatable("itemGroup.rivencraft.pages.link"))
                     .icon(PageItem::createLinkPanelPage)
-                    .displayItems((parameters, output) -> output.accept(PageItem.createLinkPanelPage()))
+                    .displayItems((parameters, output) ->
+                            PageItem.creativeLinkPanelPages().forEach(output::accept))
                     .build());
 
     private static final List<String> CATEGORY_ORDER = List.of(

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

@@ -43,6 +43,13 @@ public final class ModItems {
     public static final DeferredItem<BlockItem> WRITING_DESK = ITEMS.registerSimpleBlockItem(ModBlocks.WRITING_DESK);
     public static final DeferredItem<BlockItem> BOOK_BINDER = ITEMS.registerSimpleBlockItem(ModBlocks.BOOK_BINDER);
     public static final DeferredItem<BlockItem> INK_MIXER = ITEMS.registerSimpleBlockItem(ModBlocks.INK_MIXER);
+    public static final DeferredItem<BlockItem> CRYSTAL_BLOCK = ITEMS.registerSimpleBlockItem(ModBlocks.CRYSTAL_BLOCK);
+    public static final DeferredItem<BlockItem> BUDDING_CRYSTAL = ITEMS.registerSimpleBlockItem(ModBlocks.BUDDING_CRYSTAL);
+    public static final DeferredItem<BlockItem> CRYSTAL_CLUSTER = ITEMS.registerSimpleBlockItem(ModBlocks.CRYSTAL_CLUSTER);
+    public static final DeferredItem<BlockItem> LARGE_CRYSTAL_BUD = ITEMS.registerSimpleBlockItem(ModBlocks.LARGE_CRYSTAL_BUD);
+    public static final DeferredItem<BlockItem> MEDIUM_CRYSTAL_BUD = ITEMS.registerSimpleBlockItem(ModBlocks.MEDIUM_CRYSTAL_BUD);
+    public static final DeferredItem<BlockItem> SMALL_CRYSTAL_BUD = ITEMS.registerSimpleBlockItem(ModBlocks.SMALL_CRYSTAL_BUD);
+    public static final DeferredItem<Item> CRYSTAL_SHARD = ITEMS.registerSimpleItem("crystal_shard");
 
     private ModItems() {
     }

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

@@ -14,6 +14,8 @@ public final class ModSounds {
             DeferredRegister.create(Registries.SOUND_EVENT, Rivencraft.MOD_ID);
 
     public static final DeferredHolder<SoundEvent, SoundEvent> LINK = register("linking.link");
+    public static final DeferredHolder<SoundEvent, SoundEvent> LINK_FISSURE = register("linking.link-fissure");
+    public static final DeferredHolder<SoundEvent, SoundEvent> METEOR_ROAR = register("entity.meteor.roar");
 
     private ModSounds() {
     }

src/main/java/net/dnorberg/rivencraft/world/AgeDenseOreGameTests.java

@@ -0,0 +1,99 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.book.AgeBiomeSelection;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
+import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
+import net.dnorberg.rivencraft.book.AgeTraits;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.minecraft.core.Holder;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.levelgen.feature.ConfiguredFeature;
+import net.minecraft.world.level.levelgen.feature.Feature;
+import net.minecraft.world.level.levelgen.feature.configurations.OreConfiguration;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import net.minecraft.world.level.levelgen.structure.templatesystem.BlockMatchTest;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Dense Ores remains authored-only and discovers ore configurations without a namespace allow-list. */
+@GameTestHolder("rivencraft_archive_generation")
+@PrefixGameTestTemplate(false)
+public final class AgeDenseOreGameTests {
+    private AgeDenseOreGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void denseOresPageCompilesAndPersists(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        helper.assertTrue(PageItem.bundledCreativeSymbols().contains("feature/dense_ores"),
+                "Dense Ores must appear in the Creative and JEI page feed");
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                page("terrain/standard"), page("biome/plains"), page("biome/single"),
+                page("feature/dense_ores")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 55L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(55L), registries);
+        helper.assertValueEqual(AgeFeatureSelection.resolved(plan).stream()
+                        .map(AgeFeatureSelection.Choice::id).toList(), List.of(AgeDenseOres.ID),
+                "Dense Ores must be saved as an authored feature");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())),
+                AgeFeatureSelection.resolved(plan), "Dense Ores must survive Age-plan reload");
+        for (long seed = 0; seed < 32; seed++) {
+            helper.assertTrue(AgeFeatureSelection.randomChoices(seed,
+                            AgeRuntimeProfiles.resolve(id("standard")), registries).stream()
+                            .noneMatch(choice -> choice.id().equals(AgeDenseOres.ID)),
+                    "Random Ages must not roll an authored-only Dense Ores page");
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void denseOresRejectsUnsuitableTerrainAndBiome(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        helper.assertTrue(AgeDenseOres.error(AgeRuntimeProfiles.resolve(id("flat")), null, registries)
+                        .contains("noise terrain"), "Flat terrain must reject Dense Ores");
+        helper.assertTrue(AgeDenseOres.error(AgeRuntimeProfiles.resolve(id("void")), null, registries)
+                        .contains("noise terrain"), "Void terrain must reject Dense Ores");
+        helper.assertTrue(AgeDenseOres.error(AgeRuntimeProfiles.resolve(id("standard")),
+                        new AgeBiomeSelection(AgeTraits.BiomeDistribution.SINGLE,
+                                List.of(ResourceLocation.withDefaultNamespace("the_end"))), registries)
+                        .contains("biome with registered ore"),
+                "A biome without ore placements must not accept a no-op Dense Ores page");
+        helper.assertTrue(AgeDenseOres.error(AgeRuntimeProfiles.resolve(id("cave")),
+                new AgeBiomeSelection(AgeTraits.BiomeDistribution.SINGLE,
+                        List.of(ResourceLocation.withDefaultNamespace("nether_wastes"))), registries) == null,
+                "Nether ore placements must qualify for a Cave Age");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void recognizesOreTargetsButNotStoneBlobs(GameTestHelper helper) {
+        helper.assertTrue(AgeDenseOres.isOre(ore(Blocks.IRON_ORE.defaultBlockState())),
+                "Any namespace's OreConfiguration yielding an ore block must qualify");
+        helper.assertTrue(!AgeDenseOres.isOre(ore(Blocks.STONE.defaultBlockState())),
+                "Ordinary stone replacement must not be doubled as an ore");
+        helper.succeed();
+    }
+
+    private static Holder<PlacedFeature> ore(net.minecraft.world.level.block.state.BlockState output) {
+        var config = new OreConfiguration(new BlockMatchTest(Blocks.STONE), output, 8);
+        var feature = new ConfiguredFeature<>(Feature.ORE, config);
+        return Holder.direct(new PlacedFeature(Holder.direct(feature), List.of()));
+    }
+
+    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/world/AgeDenseOres.java

@@ -0,0 +1,101 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.TreeMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.book.AgeBiomeSelection;
+import net.dnorberg.rivencraft.book.AgeRuntimeProfile;
+import net.minecraft.core.BlockPos;
+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.TagKey;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.feature.configurations.OreConfiguration;
+import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.neoforge.common.Tags;
+
+/** Replays eligible biome ore placements once per authored Dense Ores page. */
+public final class AgeDenseOres {
+    public static final ResourceLocation ID = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "dense_ores");
+    public static final TagKey<PlacedFeature> EXTRA_ORES = TagKey.create(Registries.PLACED_FEATURE, ID);
+
+    private AgeDenseOres() {}
+
+    public static String error(AgeRuntimeProfile profile, AgeBiomeSelection biomes, RegistryAccess registries) {
+        if (profile.terrain() != AgeRuntimeProfile.Terrain.NOISE)
+            return "Dense Ores needs noise terrain with replaceable underground stone or netherrack";
+        if (biomes == null) return null;
+        var registry = registries.lookupOrThrow(Registries.BIOME);
+        boolean eligible = biomes.biomes().stream()
+                .map(id -> registry.get(ResourceKey.create(Registries.BIOME, id)))
+                .flatMap(java.util.Optional::stream)
+                .anyMatch(holder -> oreFeatures(holder).stream().anyMatch(AgeDenseOres::isOre));
+        return eligible ? null : "Dense Ores needs at least one biome with registered ore placements";
+    }
+
+    /** Vanilla-style and modded OreConfiguration targets, or an explicit opt-in tag. */
+    public static boolean isOre(Holder<PlacedFeature> holder) {
+        if (holder.is(EXTRA_ORES)) return true;
+        if (!(holder.value().feature().value().config() instanceof OreConfiguration ore)) return false;
+        return ore.targetStates.stream().anyMatch(target -> isOreBlock(target.state));
+    }
+
+    private static boolean isOreBlock(BlockState state) {
+        if (state.is(Tags.Blocks.ORES)) return true;
+        // Some third-party ores omit the common tag; require an ore configuration
+        // as well so similarly named decorative features cannot be selected.
+        String path = BuiltInRegistries.BLOCK.getKey(state.getBlock()).getPath();
+        return path.endsWith("_ore") || path.contains("_ore_");
+    }
+
+    private static java.util.List<Holder<PlacedFeature>> oreFeatures(Holder<Biome> biome) {
+        // A mod may register its ore in a non-vanilla decoration step. Its
+        // configuration and output, not its stage or namespace, decide eligibility.
+        return biome.value().getGenerationSettings().features().stream()
+                .flatMap(net.minecraft.core.HolderSet::stream).toList();
+    }
+
+    public static void place(WorldGenLevel level, ChunkAccess chunk, ChunkGenerator generator,
+                             long ageSeed, int occurrence) {
+        Set<Holder<Biome>> biomes = new HashSet<>();
+        ChunkPos.rangeClosed(chunk.getPos(), 1).forEach(pos -> {
+            for (var section : level.getChunk(pos.x, pos.z).getSections())
+                section.getBiomes().getAll(biomes::add);
+        });
+        biomes.retainAll(generator.getBiomeSource().possibleBiomes());
+        Map<ResourceLocation, PlacedFeature> ores = new TreeMap<>();
+        for (Holder<Biome> biome : biomes) {
+            for (Holder<PlacedFeature> feature : oreFeatures(biome)) {
+                if (!isOre(feature)) continue;
+                feature.unwrapKey().ifPresent(key -> ores.putIfAbsent(key.location(), feature.value()));
+            }
+        }
+        BlockPos origin = new BlockPos(chunk.getPos().getMinBlockX(), level.getMinBuildHeight(),
+                chunk.getPos().getMinBlockZ());
+        for (var entry : ores.entrySet()) {
+            long seed = mix(ageSeed ^ (long) origin.getX() * 341873128712L
+                    ^ (long) origin.getZ() * 132897987541L
+                    ^ (long) entry.getKey().hashCode() * 0x9E3779B97F4A7C15L
+                    ^ (long) occurrence * 0xD1B54A32D192ED03L);
+            entry.getValue().placeWithBiomeCheck(level, generator, RandomSource.create(seed), origin);
+        }
+    }
+
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+}

src/main/java/net/dnorberg/rivencraft/world/AgeFeatureChunkGenerator.java

@@ -3,14 +3,21 @@ package net.dnorberg.rivencraft.world;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.CompletableFuture;
 import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.dnorberg.rivencraft.book.AgeStructureSelection;
+import net.minecraft.core.HolderLookup;
 import net.minecraft.world.level.levelgen.Heightmap;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.core.registries.BuiltInRegistries;
 import net.minecraft.core.QuartPos;
+import net.minecraft.tags.BiomeTags;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.util.RandomSource;
@@ -22,6 +29,7 @@ import net.minecraft.world.level.biome.BiomeManager;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
 import net.minecraft.world.level.chunk.ProtoChunk;
 import net.minecraft.world.level.levelgen.GenerationStep;
 import net.minecraft.world.level.levelgen.LegacyRandomSource;
@@ -29,10 +37,12 @@ import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
 import net.minecraft.world.level.levelgen.NoiseGeneratorSettings;
 import net.minecraft.world.level.levelgen.RandomState;
 import net.minecraft.world.level.levelgen.WorldgenRandom;
+import net.minecraft.world.level.levelgen.blending.Blender;
 import net.minecraft.world.level.levelgen.carver.CarvingContext;
 import net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver;
 import net.minecraft.world.level.levelgen.placement.BiomeFilter;
 import net.minecraft.world.level.levelgen.placement.PlacedFeature;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
 import net.minecraft.world.level.levelgen.placement.RarityFilter;
 import net.minecraft.world.level.levelgen.feature.ConfiguredFeature;
 import net.minecraft.world.level.levelgen.feature.Feature;
@@ -47,26 +57,93 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator {
             instance.group(BiomeSource.CODEC.fieldOf("biome_source").forGetter(generator -> generator.getBiomeSource()),
                     NoiseGeneratorSettings.CODEC.fieldOf("settings").forGetter(generator -> generator.settings),
                     AgeFeatureSelection.Choice.CODEC.listOf().fieldOf("age_features").forGetter(generator -> generator.features),
-                    Codec.LONG.fieldOf("age_seed").forGetter(generator -> generator.ageSeed))
+                    Codec.LONG.fieldOf("age_seed").forGetter(generator -> generator.ageSeed),
+                    Codec.BOOL.optionalFieldOf("nether_cave_materials", false).forGetter(generator -> generator.netherCaveMaterials),
+                    ResourceLocation.CODEC.listOf().optionalFieldOf("nether_biomes", List.of())
+                            .forGetter(generator -> generator.netherBiomeIds))
                     .apply(instance, AgeFeatureChunkGenerator::new));
 
     private final Holder<NoiseGeneratorSettings> settings;
     private final List<AgeFeatureSelection.Choice> features;
     private final long ageSeed;
+    private final boolean netherCaveMaterials;
+    private final List<ResourceLocation> netherBiomeIds;
 
     public AgeFeatureChunkGenerator(BiomeSource biomes, Holder<NoiseGeneratorSettings> settings,
-                                    List<AgeFeatureSelection.Choice> features, long ageSeed) {
+                                    List<AgeFeatureSelection.Choice> features, long ageSeed,
+                                    boolean netherCaveMaterials, List<ResourceLocation> netherBiomeIds) {
         super(biomes, settings);
         this.settings = settings;
         this.features = List.copyOf(features);
         this.ageSeed = ageSeed;
+        this.netherCaveMaterials = netherCaveMaterials;
+        this.netherBiomeIds = List.copyOf(netherBiomeIds);
     }
 
     public List<AgeFeatureSelection.Choice> ageFeatures() { return features; }
 
+    @Override
+    public void buildSurface(WorldGenRegion level, StructureManager structures, RandomState random, ChunkAccess chunk) {
+        super.buildSurface(level, structures, random, chunk);
+        if (!netherCaveMaterials) return;
+        Set<ResourceLocation> netherIds = Set.copyOf(netherBiomeIds);
+        // The Cave noise router starts with stone even in Nether biomes. Surface rules
+        // only touch exposed layers, so convert the base rock (and any Overworld soil)
+        // before carvers, ores, and biome decorations run. Never change adjacent biomes.
+        chunk.findBlocks(AgeFeatureChunkGenerator::isOverworldCaveMaterial, (pos, state) -> {
+            Holder<net.minecraft.world.level.biome.Biome> biome = chunk.getNoiseBiome(
+                    QuartPos.fromBlock(pos.getX()), QuartPos.fromBlock(pos.getY()), QuartPos.fromBlock(pos.getZ()));
+            if (biome.is(BiomeTags.IS_NETHER)
+                    || biome.unwrapKey().map(key -> netherIds.contains(key.location())).orElse(false)) {
+                chunk.setBlockState(pos, Blocks.NETHERRACK.defaultBlockState(), false);
+            }
+        });
+    }
+
+    private static boolean isOverworldCaveMaterial(net.minecraft.world.level.block.state.BlockState state) {
+        return state.is(Blocks.STONE) || state.is(Blocks.DEEPSLATE) || state.is(Blocks.TUFF)
+                || state.is(Blocks.DIRT) || state.is(Blocks.GRASS_BLOCK);
+    }
+
     @Override
     protected MapCodec<? extends ChunkGenerator> codec() { return CODEC; }
 
+    @Override
+    public ChunkGeneratorStructureState createState(HolderLookup<StructureSet> sets, RandomState random, long seed) {
+        return ChunkGeneratorStructureState.createForNormal(random, seed, getBiomeSource(),
+                AgeStructureSelection.filteredLookup(sets, features));
+    }
+
+    @Override
+    public CompletableFuture<ChunkAccess> fillFromNoise(Blender blender, RandomState random,
+                                                         StructureManager structures, ChunkAccess chunk) {
+        CompletableFuture<ChunkAccess> filled = super.fillFromNoise(blender, random, structures, chunk);
+        if (features.stream().noneMatch(choice -> AgeFeatureSelection.floatingIslands(choice.id())
+                || AgeFeatureSelection.tendrils(choice.id())
+                || AgeFeatureSelection.spheres(choice.id())
+                || AgeFeatureSelection.skylands(choice.id()))) return filled;
+        return filled.thenApply(result -> {
+            // Legacy's Skylands primer filter removes base terrain before large
+            // features add their own blocks to the chunk.
+            if (features.stream().anyMatch(choice -> AgeFeatureSelection.skylands(choice.id())))
+                SkylandsFeature.filter(result, ageSeed);
+            Map<ResourceLocation, Integer> occurrences = new HashMap<>();
+            for (AgeFeatureSelection.Choice choice : features) {
+                if (!AgeFeatureSelection.floatingIslands(choice.id())
+                        && !AgeFeatureSelection.tendrils(choice.id())
+                        && !AgeFeatureSelection.spheres(choice.id())) continue;
+                int occurrence = occurrences.merge(choice.id(), 1, Integer::sum) - 1;
+                long featureSeed = ageSeed ^ (long) occurrence * 0x9E3779B97F4A7C15L;
+                if (AgeFeatureSelection.floatingIslands(choice.id()))
+                    FloatingIslandFeature.generate(result, getBiomeSource(), random, featureSeed, choice);
+                else if (AgeFeatureSelection.tendrils(choice.id()))
+                    TendrilFeature.generate(result, featureSeed, choice);
+                else SpheresFeature.generate(result, featureSeed, choice);
+            }
+            return result;
+        });
+    }
+
     @Override
     public void applyCarvers(WorldGenRegion level, long seed, RandomState random, BiomeManager biomes,
                              StructureManager structures, ChunkAccess chunk, GenerationStep.Carving step) {
@@ -116,8 +193,30 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator {
         int x = chunk.getPos().getMinBlockX();
         int z = chunk.getPos().getMinBlockZ();
         BlockPos origin = new BlockPos(x, level.getMinBuildHeight(), z);
+        Map<AgeFeatureSelection.Choice, Integer> occurrences = new HashMap<>();
+        Map<ResourceLocation, Integer> spikeOccurrences = new HashMap<>();
+        int obeliskOccurrence = 0;
+        int crystalOccurrence = 0;
         for (int index = 0; index < features.size(); index++) {
             AgeFeatureSelection.Choice choice = features.get(index);
+            int occurrence = occurrences.merge(choice, 1, Integer::sum) - 1;
+            if (AgeFeatureSelection.spikes(choice.id())) {
+                SpikesFeature.generate(level, chunk, ageSeed, choice,
+                        spikeOccurrences.merge(choice.id(), 1, Integer::sum) - 1);
+                continue;
+            }
+            if (AgeFeatureSelection.obelisks(choice.id())) {
+                ObelisksFeature.generate(level, chunk, ageSeed, choice, obeliskOccurrence++);
+                continue;
+            }
+            if (choice.id().equals(AgeFeatureSelection.CRYSTAL_FORMATIONS)) {
+                CrystalFormationsFeature.generate(level, chunk, ageSeed, crystalOccurrence++);
+                continue;
+            }
+            if (choice.id().equals(AgeDenseOres.ID)) {
+                AgeDenseOres.place(level, chunk, this, ageSeed, occurrence);
+                continue;
+            }
             if (AgeFeatureSelection.surfaceVegetation(choice.id())) {
                 int surface = chunk.getHeight(Heightmap.Types.WORLD_SURFACE_WG, 8, 8);
                 if (!AgeFeatureSelection.supportsSurfaceVegetation(
@@ -148,7 +247,8 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator {
                             ? RarityFilter.onAverageOnceEvery(12) : modifier)
                     .toList());
             long seed = ageSeed ^ (long) x * 341873128712L ^ (long) z * 132897987541L
-                    ^ (long) choice.hashCode() * 0x9E3779B97F4A7C15L;
+                    ^ (long) choice.hashCode() * 0x9E3779B97F4A7C15L
+                    ^ (long) occurrence * 0xD1B54A32D192ED03L;
             authored.place(level, this, RandomSource.create(seed), origin);
         }
     }

src/main/java/net/dnorberg/rivencraft/world/AgeFlatChunkGenerator.java

@@ -1,19 +1,26 @@
 package net.dnorberg.rivencraft.world;
 
+import com.mojang.serialization.Codec;
 import com.mojang.serialization.MapCodec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 import java.util.stream.Stream;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.dnorberg.rivencraft.book.AgeStructureSelection;
 import net.minecraft.Util;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
 import net.minecraft.core.HolderLookup;
 import net.minecraft.core.HolderSet;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.WorldGenRegion;
 import net.minecraft.world.level.LevelHeightAccessor;
 import net.minecraft.world.level.NoiseColumn;
 import net.minecraft.world.level.StructureManager;
+import net.minecraft.world.level.WorldGenLevel;
 import net.minecraft.world.level.biome.BiomeManager;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.block.Blocks;
@@ -32,17 +39,30 @@ import net.minecraft.world.level.levelgen.structure.StructureSet;
 public final class AgeFlatChunkGenerator extends ChunkGenerator {
     public static final MapCodec<AgeFlatChunkGenerator> CODEC = RecordCodecBuilder.mapCodec(instance ->
             instance.group(BiomeSource.CODEC.fieldOf("biome_source").forGetter(generator -> generator.biomeSource),
-                    FlatLevelGeneratorSettings.CODEC.fieldOf("settings").forGetter(AgeFlatChunkGenerator::settings))
+                    FlatLevelGeneratorSettings.CODEC.fieldOf("settings").forGetter(AgeFlatChunkGenerator::settings),
+                    AgeFeatureSelection.Choice.CODEC.listOf().optionalFieldOf("age_features", List.of())
+                            .forGetter(generator -> generator.features),
+                    Codec.LONG.optionalFieldOf("age_seed", 0L).forGetter(generator -> generator.ageSeed))
                     .apply(instance, AgeFlatChunkGenerator::new));
 
     private final FlatLevelGeneratorSettings settings;
+    private final List<AgeFeatureSelection.Choice> features;
+    private final long ageSeed;
 
     public AgeFlatChunkGenerator(BiomeSource biomeSource, FlatLevelGeneratorSettings settings) {
+        this(biomeSource, settings, List.of(), 0L);
+    }
+
+    public AgeFlatChunkGenerator(BiomeSource biomeSource, FlatLevelGeneratorSettings settings,
+                                 List<AgeFeatureSelection.Choice> features, long ageSeed) {
         super(biomeSource, Util.memoize(settings::adjustGenerationSettings));
         this.settings = settings;
+        this.features = List.copyOf(features);
+        this.ageSeed = ageSeed;
     }
 
     public FlatLevelGeneratorSettings settings() { return settings; }
+    public List<AgeFeatureSelection.Choice> ageFeatures() { return features; }
 
     @Override
     protected MapCodec<? extends ChunkGenerator> codec() { return CODEC; }
@@ -52,7 +72,8 @@ public final class AgeFlatChunkGenerator extends ChunkGenerator {
         Stream<Holder<StructureSet>> entries = settings.structureOverrides()
                 .map(HolderSet::stream)
                 .orElseGet(() -> structures.listElements().map(holder -> (Holder<StructureSet>) holder));
-        return ChunkGeneratorStructureState.createForFlat(random, seed, biomeSource, entries);
+        return ChunkGeneratorStructureState.createForFlat(random, seed, biomeSource,
+                AgeStructureSelection.allowedSets(entries, features));
     }
 
     @Override
@@ -82,9 +103,37 @@ public final class AgeFlatChunkGenerator extends ChunkGenerator {
                 }
             }
         }
+        if (features.stream().anyMatch(choice -> AgeFeatureSelection.skylands(choice.id())))
+            SkylandsFeature.filter(chunk, ageSeed);
+        Map<ResourceLocation, Integer> occurrences = new HashMap<>();
+        for (AgeFeatureSelection.Choice choice : features) {
+            if (!AgeFeatureSelection.floatingIslands(choice.id())
+                    && !AgeFeatureSelection.tendrils(choice.id())
+                    && !AgeFeatureSelection.spheres(choice.id())) continue;
+            int occurrence = occurrences.merge(choice.id(), 1, Integer::sum) - 1;
+            long featureSeed = ageSeed ^ (long) occurrence * 0x9E3779B97F4A7C15L;
+            if (AgeFeatureSelection.floatingIslands(choice.id()))
+                FloatingIslandFeature.generate(chunk, biomeSource, random, featureSeed, choice);
+            else if (AgeFeatureSelection.tendrils(choice.id()))
+                TendrilFeature.generate(chunk, featureSeed, choice);
+            else SpheresFeature.generate(chunk, featureSeed, choice);
+        }
         return CompletableFuture.completedFuture(chunk);
     }
 
+    @Override
+    public void applyBiomeDecoration(WorldGenLevel level, ChunkAccess chunk, StructureManager structures) {
+        super.applyBiomeDecoration(level, chunk, structures);
+        int spikeOccurrence = 0;
+        int obeliskOccurrence = 0;
+        for (AgeFeatureSelection.Choice choice : features) {
+            if (AgeFeatureSelection.spikes(choice.id()))
+                SpikesFeature.generate(level, chunk, ageSeed, choice, spikeOccurrence++);
+            if (AgeFeatureSelection.obelisks(choice.id()))
+                ObelisksFeature.generate(level, chunk, ageSeed, choice, obeliskOccurrence++);
+        }
+    }
+
     @Override
     public int getBaseHeight(int x, int z, Heightmap.Types type, LevelHeightAccessor level, RandomState random) {
         List<BlockState> layers = settings.getLayers();
@@ -106,6 +155,8 @@ public final class AgeFlatChunkGenerator extends ChunkGenerator {
     @Override public void applyCarvers(WorldGenRegion level, long seed, RandomState random, BiomeManager biomes,
                                        StructureManager structures, ChunkAccess chunk, GenerationStep.Carving step) { }
     @Override public void spawnOriginalMobs(WorldGenRegion level) { }
+    // Keep vanilla FlatLevelSource's generator API values. Actual layer
+    // placement uses chunk.getMinBuildHeight() above, not this metadata value.
     @Override public int getMinY() { return 0; }
     @Override public int getGenDepth() { return 384; }
     @Override public int getSeaLevel() { return -63; }