Map Star Fissures to modern world minimum Y (#58)

Add the writable symbol, adapt Legacy's branching solid cave-node geometry across all terrain types, and test authored and random Age selection.

README.md

@@ -21,9 +21,23 @@ The spent vial returns a glass bottle. Server owners can adjust the symbol-copy
 and link-panel costs in the `writing` section of `rivencraft-server.toml`.
 The Ink Mixer now offers a Legacy-style station for producing Link Panels:
 insert paper and Ink Vials, then take a Link Panel from the result slot. Each
-vial fills its 16-unit basin and returns a glass bottle; no server tick is
-needed. The earlier paper-in-one-hand method remains available. Ink modifier
-ingredients and link properties are planned for Milestone 5.
+vial fills its 16-unit basin and returns a glass bottle; taking one Link Panel
+uses the full vial. No server tick is needed. The earlier paper-in-one-hand
+method still uses the configurable link-panel ink cost. Ink Mixer
+additives can roll Disarm, Maintain Momentum, and Intra Linking onto a Link
+Panel. Descriptive Books retain Disarm and Momentum; Intra Linking is only
+meaningful for same-dimension travel with a Linking Book.
+TerraBlender 1.21.1 integration is optional: registered modded biomes receive
+Biome pages, with cave and Nether biomes in a separate Cave Biome creative tab.
+TerraBlender Overworld/Nether regions extend compatible Age
+biome pools. See [the compatibility matrix](docs/TERRABLENDER_COMPATIBILITY.md)
+for supported versions and in-game verification.
+Serene Seasons 1.21.1 can maintain separate season progress in an Age dimension.
+Rivencraft automatically whitelists loaded Ages without a restart when Serene is installed;
+season pages can instead opt an Age out or hold it in one season.
+See [the optional compatibility guide](docs/SERENE_SEASONS_COMPATIBILITY.md)
+for the supported manual configuration and current limits; Rivencraft does not
+require Serene Seasons or GlitchCore.
 The Writing Desk can copy a selected written page from its collection tabs.
 The Writing Desk is now craftable from planks, a glass bottle, and a feather.
 It occupies two adjacent blocks, with one shared inventory; loaded paper and
@@ -79,6 +93,9 @@ With JEI installed, Rivencraft displays the Ink Mixer operation in its own
 category and the hand-use, copying, binding, and Linking Book crafting flows in a Writing category.
 The Link Panel and individual symbol Pages, including registered vanilla biome
 pages, appear as separately searchable JEI ingredients.
+Creative inventory separates Link Pages and each symbol category into their own
+tabs, including distinct Biome and Biome Generation tabs. Blank Pages are hidden
+from creative inventory and JEI.
 JEI is optional; vanilla crafting
 recipes and all writing interactions work without it. For a development client
 with JEI, run `./gradlew runClient -PwithJei=true`.
@@ -99,7 +116,8 @@ into a versioned, server-owned Age plan. The plan freezes the Age seed, resolved
 symbol meanings, page order, and runtime profile, so later data-pack changes do
 not reinterpret an existing Age. An authored terrain page selects its runtime
 profile. Built-in pages cover Standard, Amplified, Cave, Island, Flat, and Void;
-other symbol effects are scheduled for later Milestone 5 slices. The
+authored biome, environment, and supported feature pages also affect new Ages.
+Further symbol effects are scheduled for later Milestone 5 slices. 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

build.gradle

@@ -17,7 +17,7 @@ tasks.named('wrapper', Wrapper).configure {
 version = mod_version
 group = mod_group_id
 
-List<String> archivedGameTestSuites = ['linking', 'writing', 'grammar', 'desk', 'binder', 'mixer', 'recipe']
+List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'desk', 'binder', 'mixer', 'recipe']
 List<String> selectedArchivedGameTestSuites = providers.gradleProperty('withArchivedGameTests')
         .map { it.toBoolean() }.orElse(false).get() ? archivedGameTestSuites
         : providers.gradleProperty('archivedGameTestSuites').orElse('').get()
@@ -91,6 +91,11 @@ repositories {
         content { includeGroup 'curse.maven' }
     }
     maven { url = 'https://maven.bai.lol' }
+    maven {
+        name = 'TerraBlenderMaven'
+        url = 'https://maven.minecraftforge.net/releases/'
+        content { includeGroup 'com.github.glitchfiend' }
+    }
     maven {
         url = 'https://api.modrinth.com/maven'
         content { includeGroup 'maven.modrinth' }
@@ -238,6 +243,19 @@ dependencies {
     // Keep them on the compile classpath without forcing either mod at runtime.
     compileOnly "net.createmod.ponder:ponder-neoforge:${ponder_version}+mc${minecraft_version}"
     compileOnly "maven.modrinth:immersive-portals-neoforge:${immersive_portals_version}"
+    // TerraBlender's region API is only used by the guarded compat adapter.
+    compileOnly "com.github.glitchfiend:TerraBlender-neoforge:${minecraft_version}-${terrablender_version}"
+    if (providers.gradleProperty('withTerraBlender').map { it.toBoolean() }.orElse(false).get()) {
+        localRuntime "com.github.glitchfiend:TerraBlender-neoforge:${minecraft_version}-${terrablender_version}"
+    }
+    // The optional compatibility adapter uses Serene's dimension config API.
+    // Neither mod is a required dependency of the published Rivencraft jar.
+    compileOnly "maven.modrinth:e0bNACJD:${serene_seasons_version_id}"
+    compileOnly "maven.modrinth:s3dmwKy5:${glitchcore_version_id}"
+    if (providers.gradleProperty('withSereneSeasons').map { it.toBoolean() }.orElse(false).get()) {
+        localRuntime "maven.modrinth:e0bNACJD:${serene_seasons_version_id}"
+        localRuntime "maven.modrinth:s3dmwKy5:${glitchcore_version_id}"
+    }
     implementation "curse.maven:dynamicdimension-ar-edition-1469680:${dynamic_dimensions_file_id}"
     implementation "lol.bai:badpackets:neo-${badpackets_version}"
     // JEI integration is isolated in its plugin and absent from the published runtime dependencies.

docs/AGE_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
@@ -47,14 +194,16 @@ in the Binder. Bundled controls are Native, Single, Tiled, Grid, and Tiny throug
 Huge regions. Single needs one distinct biome; Tiled/Grid and Tiny–Huge need
 two. An authored book receives seeded filler only when it falls below that
 minimum, while extra authored pages are retained as weighted entries. A book
-with no biome pages selects a seeded count from 2–4 for Tiled/Grid or 2–6 for
-Tiny–Huge, capped by the number of eligible terrain biomes. Single uses one;
-Native uses its preset biome pool. These random-age maximums do not truncate
+with no biome pages selects a seeded count from two up to the number of
+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.
 Native cannot be paired with explicit biome pages. Legacy filled Tiny–Huge to
 three; Rivencraft deliberately uses two so a pair of written biome pages stays
 exactly as written.
-The Pages creative tab offers pages for every registered vanilla biome.
+The Biome Pages creative tab offers pages for every registered vanilla biome.
 Hand-authored symbol definitions take precedence; the remaining vanilla pages
 are generated from the biome registry, so they do not each need a JSON file.
 Custom/modded biomes still require a data-pack symbol definition.
@@ -70,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
@@ -79,6 +235,28 @@ eligible fallback for that load; restoring the biome recovers the original
 selection. Generation-version-15 Ages keep their prior registry-wide biome
 selection algorithm instead of being silently regenerated.
 
+## Written environment
+
+Lighting pages select Normal, Dark, or Bright lighting for the new Age. A Sky
+page selects Minecraft's Overworld, Nether, or End sky effects; the chosen
+effects also determine the destination preview backdrop. Overworld sky tint
+continues to come from the destination biome. A written sky changes only that
+Age's dimension type, not the source world or other Ages.
+
+Normal, Fast, Slow, Off, Always, and Storm weather pages use the existing Age
+weather controller. Zero, Half, Full, and Double Length pages set the day-cycle
+period, and Nadir, Rising, Zenith, and Setting pages set its initial phase.
+Repeated numeric modifiers combine in written order. A Zero Length Age keeps
+the nonzero minimum clock rate that avoids client skybox bounce. Pages for
+Cloudy, forced Rain, and Snow are not offered: vanilla precipitation rendering
+cannot reproduce those Legacy distinctions yet, and Snow remains planned for
+the optional season integrations. A data pack that supplies these unsupported
+weather choices receives a binding error rather than a false success.
+
+The category creative tabs and optional JEI page ingredients use the same generated
+index of bundled environment symbols. Existing Age definitions and page-free
+random Ages retain their saved or seeded environment unchanged.
+
 ## Persistence and reload behavior
 
 An Age permanently stores its selected profile ID, generation version, seed,

docs/ASSET_PROVENANCE.md

@@ -25,6 +25,10 @@ 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`, `budding_crystal.png` | `assets/mystcraft/textures/blocks/crystal.png` | Legacy 0.13.7.06 local extraction | Exact 16×16 blue tile reused for both solid crystal blocks |
+| `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 |
 
 Mystcraft Legacy identifies XCompWiz as its project developer and includes the
 full LGPL v3 text in its root `LICENSE` file. Rivencraft's root `LICENSE`

docs/DESCRIPTIVE_BOOK_PRESENTATION.md

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

docs/GAMETESTS.md

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

docs/INK_MIXER_MODIFIER_AUDIT.md

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

docs/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/SERENE_SEASONS_COMPATIBILITY.md

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

docs/TERRABLENDER_COMPATIBILITY.md

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

docs/WRITING_DATA.md

@@ -34,10 +34,9 @@ Invalid definitions are logged and excluded by the server. Menus and future
 page synchronization must obtain resolved display metadata from the server;
 clients never make a symbol valid by naming it.
 
-Rivencraft ships a small catalog covering terrain, biomes, lighting, weather,
-celestial behavior, and features. Its v2 semantics prepare for the full
-Legacy-inspired grammar; writing still uses random Age fallback until the
-parser and compiler are implemented.
+Rivencraft ships a catalog covering terrain, biomes, lighting, weather,
+sky, celestial behavior, and features. The parser and compiler apply supported
+schema-v2 pages to newly created Ages; omitted branches retain seeded defaults.
 
 ## Persistent writing
 
@@ -54,9 +53,7 @@ book copies its writing and Age reference; merely copying it never creates a
 new Age. The Book Binder creates the Age when its finished output is taken.
 The Descriptive Book screen can inspect the ordered pages by turning them from
 the bottom corners and identifies unresolved IDs using server-provided symbol
-metadata. Until Milestone 5, the
-saved symbols are informational only: Age creation uses the existing random
-fallback and does not apply them to generation.
+metadata. Page-free books continue to use random Age generation.
 
 Removing a data pack never removes its IDs from saved writing. A missing ID is
 resolved as client-safe **Unresolved Symbol** display metadata while retaining
@@ -108,7 +105,8 @@ 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
 `OrderedWriting` plus the Age reference on the book. Link-Panel-only books
-create random Ages. A written symbol does **not** yet change that generation.
+create random Ages. Supported written pages change the corresponding Age
+generation branch; missing branches use seeded defaults.
 Inputs, title, and pending Age identity survive Binder save/load; breaking the
 Binder returns stored inputs. The completed book retains both its writing and
 Age identity through item save/load and copying.

docs/WRITING_GRAMMAR.md

@@ -4,10 +4,22 @@
 
 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.
 
-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; zero or more period, angle, or phase modifiers; one celestial page; then zero or more distinct features. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, lighting, 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.
+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.
 
-Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains the seed-selected profile and traits for missing branches. The minimum is zero for Native, one for Single, and two for Tiled/Grid and Tiny–Huge. Native cannot consume authored biome pages; Single accepts only one. Unknown IDs, schema-v1 display-only symbols, wrong ordering, misplaced modifiers, duplicates, conflicts, missing/extra Link Panels, and oversized writing are errors. The Binder disables output and exposes the first error on the result-slot tooltip. When that error belongs to a page, its thumbnail is tinted and outlined red, the strip scrolls to it, and hovering it shows the diagnostic. This maps the parser's compact entry position back through any empty page positions. Rejected inputs remain removable. Binding an unwritten Descriptive Book rechecks its server-owned writing and reports the first error without creating an Age. A terrain symbol whose profile is unavailable is also rejected before Binder inputs are consumed.
+Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains seed-selected traits for missing branches. An omitted terrain page uses a seed-selected profile compatible with authored feature pages, so changing the Age name cannot accidentally select Flat, Void, or Cave terrain for Rocks or Lakes. If no profile can support the writing, binding still rejects it. 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.
 
-The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the Age seed, and a copy of the selected runtime profile. An explicit terrain page replaces the random terrain selection; an omitted terrain uses the seed-selected profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages now 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, lighting, weather, celestial, and feature effects are retained in the plan but will be applied in issues #33–#35; instability remains Milestone 6 work.
+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 Rivencraft Pages creative tab reads a generated index of bundled symbol definitions. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page automatically in the next build; no Java starter-page list needs updating. The server catalog still decides whether that page is valid for writing. External server data-pack symbols are not included in this bundled index.
+## Supported feature pages (issue #35)
+
+Feature pages come after the celestial section. Their order is retained in the plan and in decoration placement. The Caves page adds a second, Age-seeded vanilla cave-carving pass to Noise terrain, including Standard, Amplified, Island, and Cave terrain. It chooses the vanilla Overworld or Nether cave carver from the source biome. This is separate from the Milestone 7 issue about Cave **terrain** generation. Flat and Void terrain have no suitable solid noise body and reject Caves with a binder diagnostic.
+
+Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and 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.
+
+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. Portals and the Cave-terrain bug remain separate work.
+
+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. Link Pages have a separate tab. Blank Pages appear in neither the creative tabs nor JEI's ingredient list. The server catalog still decides whether a page is valid for writing. External server data-pack symbols are not included in this bundled index.

gradle.properties

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

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

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

src/main/java/net/dnorberg/rivencraft/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/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

@@ -24,7 +24,7 @@ import net.minecraft.core.NonNullList;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceKey;
 import net.dnorberg.rivencraft.book.AgeBiomeSelection;
-import net.minecraft.tags.BiomeTags;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
 import net.minecraft.core.component.DataComponents;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
@@ -151,7 +151,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             var selectedProfile = terrain.isPresent()
                     ? ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id()
                     : level instanceof ServerLevel serverLevel
-                    ? AgeRegistrySavedData.previewGenerationProfile(serverLevel, title)
+                    ? AgeRegistrySavedData.previewGenerationProfile(serverLevel, title, currentWriting())
                     : AgeGenerationProfiles.STANDARD;
             var runtimeProfile = AgeRuntimeProfiles.profiles().get(selectedProfile);
             boolean cave = runtimeProfile != null && AgeBiomeSelection.isCave(runtimeProfile);
@@ -162,12 +162,39 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
                         if (holder.isEmpty()) {
                             diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNKNOWN_BIOME,
                                     symbol.index(), "Restore biome " + id + " or remove this page"));
-                        } else if (cave && !holder.orElseThrow().is(AgeBiomeSelection.CAVE_BIOMES)
-                                && !holder.orElseThrow().is(BiomeTags.IS_NETHER)) {
+                        } else if (cave && !AgeBiomeSelection.isCaveBiome(level.registryAccess(),
+                                holder.orElseThrow())) {
                             diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNSUPPORTED_BIOME,
                                     symbol.index(), "Cave Ages require cave or Nether biomes; remove " + id));
                         }
                     });
+            if (runtimeProfile != null) {
+                parsed.symbols().stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                        .forEach(symbol -> {
+                            var id = ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id();
+                            String error = AgeFeatureSelection.error(id, runtimeProfile, level.registryAccess());
+                            if (error != null) diagnostics.add(new WritingGrammar.Diagnostic(
+                                    WritingGrammar.Code.UNSUPPORTED_FEATURE, symbol.index(), error));
+                        });
+            }
+            // Compile against the actual title-derived Age seed as a final compatibility
+            // check. This also pinpoints biome-pool conflicts that cannot be inferred from
+            // an individual feature page alone (for example Trees with only Nether biomes).
+            if (level instanceof ServerLevel serverLevel && diagnostics.stream().noneMatch(
+                    diagnostic -> diagnostic.code() == WritingGrammar.Code.UNSUPPORTED_FEATURE)) {
+                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())));
+                    }
+                }
+            }
         }
         return new WritingGrammar.Result(parsed.symbols(), diagnostics);
     }
@@ -210,6 +237,11 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
         ItemStack book = new ItemStack(ModItems.DESCRIPTIVE_BOOK.get());
         book.set(ModDataComponents.AGE_REFERENCE.get(), new AgeReference(pendingAgeId, title));
         book.set(ModDataComponents.BOOK_WRITING.get(), currentWriting());
+        if (items.get(LINK_PANEL).has(ModDataComponents.LINK_PROPERTIES.get())) {
+            var properties = items.get(LINK_PANEL).get(ModDataComponents.LINK_PROPERTIES.get())
+                    .forDescriptiveBook();
+            if (properties.flags() != 0) book.set(ModDataComponents.LINK_PROPERTIES.get(), properties);
+        }
         book.set(DataComponents.CUSTOM_NAME, Component.literal(title));
         return book;
     }

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

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

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

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

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

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

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

@@ -7,6 +7,7 @@ import java.util.List;
 import java.util.Random;
 import java.util.Set;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
 import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.Holder;
@@ -47,7 +48,8 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
             distribution = AgeTraits.BiomeDistribution.SINGLE;
         }
         if (controller.isEmpty() && !authored.isEmpty()) {
-            if (distribution == AgeTraits.BiomeDistribution.NATIVE
+            if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID
+                    || distribution == AgeTraits.BiomeDistribution.NATIVE
                     || (distribution == AgeTraits.BiomeDistribution.SINGLE && authored.size() > 1)) {
                 distribution = authored.size() == 1 ? AgeTraits.BiomeDistribution.SINGLE
                         : authored.size() == 2 ? AgeTraits.BiomeDistribution.TILED
@@ -59,29 +61,36 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         for (ResourceLocation id : authored) {
             Holder.Reference<Biome> holder = registry.get(ResourceKey.create(Registries.BIOME, id))
                     .orElseThrow(() -> new IllegalArgumentException("Unknown biome " + id + "; restore its data pack or remove its page"));
-            if (cave && !holder.is(CAVE_BIOMES) && !holder.is(BiomeTags.IS_NETHER)) {
+            if (cave && !isCaveBiome(registries, holder)) {
                 throw new IllegalArgumentException("Biome " + id
-                        + " is not a cave or Nether biome; use #rivencraft:cave_biomes or #minecraft:is_nether");
+                        + " is not a cave or Nether biome; use #rivencraft:cave_biomes, #minecraft:is_nether,"
+                        + " or a TerraBlender Nether region");
             }
         }
-        List<ResourceLocation> eligible = eligible(registries, profile);
-        if (eligible.isEmpty()) throw new IllegalArgumentException("No eligible biomes for terrain " + profile.noiseSettings());
+        List<ResourceLocation> availableBiomes = eligible(registries, profile);
+        if (availableBiomes.isEmpty()) throw new IllegalArgumentException("No eligible biomes for terrain " + profile.noiseSettings());
         if (distribution == AgeTraits.BiomeDistribution.NATIVE) {
             if (!authored.isEmpty()) throw new IllegalArgumentException("Native biome distribution cannot use biome pages");
             return new AgeBiomeSelection(distribution, profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
-                    ? List.of(ResourceLocation.withDefaultNamespace("plains")) : eligible);
+                    ? List.of(ResourceLocation.withDefaultNamespace("plains"))
+                    : isCave(profile) ? availableBiomes : presetBiomes(registries, profile));
         }
         List<ResourceLocation> selected = new ArrayList<>(authored);
         Set<ResourceLocation> distinct = new LinkedHashSet<>(selected);
         int minimum = minimum(distribution);
         int target = minimum;
         if (authored.isEmpty()) {
-            int maximum = Math.min(maximum(distribution), new LinkedHashSet<>(eligible).size());
+            // The terrain's available pool is the upper bound, including any
+            // compatible TerraBlender region biomes present at creation time.
+            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);
             }
         }
-        List<ResourceLocation> filler = new ArrayList<>(eligible);
+        // 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;
@@ -99,14 +108,26 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         if (isCave(profile)) {
             List<ResourceLocation> tagged = registry.listElements().filter(holder -> holder.is(CAVE_BIOMES))
                     .map(holder -> holder.key().location()).sorted().toList();
-            if (!tagged.isEmpty()) return tagged;
-            return List.of("minecraft:deep_dark", "minecraft:dripstone_caves", "minecraft:lush_caves")
+            List<ResourceLocation> vanilla = !tagged.isEmpty() ? tagged : List.of("minecraft:deep_dark", "minecraft:dripstone_caves", "minecraft:lush_caves")
                     .stream().map(ResourceLocation::parse)
                     .filter(id -> registry.get(ResourceKey.create(Registries.BIOME, id)).isPresent()).toList();
+            List<ResourceLocation> nether = registry.listElements().filter(holder -> holder.is(BiomeTags.IS_NETHER))
+                    .map(holder -> holder.key().location()).toList();
+            return merge(merge(vanilla, nether), TerraBlenderBiomes.nether(registries));
         }
         if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID) {
             return List.of(ResourceLocation.withDefaultNamespace("the_void"));
         }
+        ResourceLocation preset = profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
+                ? ResourceLocation.withDefaultNamespace("overworld") : profile.biomePreset();
+        List<ResourceLocation> nativeBiomes = presetBiomes(registries, profile);
+        return merge(nativeBiomes, preset.equals(ResourceLocation.withDefaultNamespace("nether"))
+                ? TerraBlenderBiomes.nether(registries) : TerraBlenderBiomes.overworld(registries));
+    }
+
+    private static List<ResourceLocation> presetBiomes(RegistryAccess registries, AgeRuntimeProfile profile) {
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+            return List.of(ResourceLocation.withDefaultNamespace("the_void"));
         ResourceLocation preset = profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
                 ? ResourceLocation.withDefaultNamespace("overworld") : profile.biomePreset();
         var parameters = registries.lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST)
@@ -116,6 +137,15 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
                 .sorted(Comparator.naturalOrder()).toList();
     }
 
+    public static boolean isCaveBiome(RegistryAccess registries, Holder.Reference<Biome> holder) {
+        return holder.is(CAVE_BIOMES) || holder.is(BiomeTags.IS_NETHER)
+                || TerraBlenderBiomes.nether(registries).contains(holder.key().location());
+    }
+
+    private static List<ResourceLocation> merge(List<ResourceLocation> vanilla, List<ResourceLocation> additions) {
+        return java.util.stream.Stream.concat(vanilla.stream(), additions.stream()).distinct().sorted().toList();
+    }
+
     public static boolean isCave(AgeRuntimeProfile profile) {
         return profile.terrain() == AgeRuntimeProfile.Terrain.NOISE
                 && profile.noiseSettings().equals(ResourceLocation.withDefaultNamespace("caves"));
@@ -128,12 +158,4 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         };
     }
 
-    /** Random-age limits; authored biome pages are never truncated to this maximum. */
-    public static int maximum(AgeTraits.BiomeDistribution distribution) {
-        return switch (distribution) {
-            case NATIVE, SINGLE -> 1;
-            case TILED, GRID -> 4;
-            case TINY, SMALL, MEDIUM, LARGE, HUGE -> 6;
-        };
-    }
 }

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

@@ -1,10 +1,12 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.Objects;
+import java.util.List;
 import java.util.UUID;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.core.BlockPos;
 import net.minecraft.resources.ResourceLocation;
+import org.jetbrains.annotations.Nullable;
 
 /** Immutable, server-owned generation definition for one Age. */
 public record AgeDefinition(
@@ -17,7 +19,9 @@ public record AgeDefinition(
         ResourceLocation dimensionId,
         BlockPos spawn,
         AgeTraits traits,
-        AgeGenerationPlan plan
+        AgeGenerationPlan plan,
+        @Nullable AgeSeasonMode seasonMode,
+        List<AgeFeatureSelection.Choice> randomFeatures
 ) {
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
@@ -30,6 +34,10 @@ public record AgeDefinition(
         Objects.requireNonNull(generationProfile, "generationProfile");
         Objects.requireNonNull(dimensionId, "dimensionId");
         Objects.requireNonNull(traits, "traits");
+        randomFeatures = List.copyOf(randomFeatures);
+        if (plan != null && !randomFeatures.isEmpty()) {
+            throw new IllegalArgumentException("Authored Ages cannot also have random features");
+        }
         if (plan != null && plan.ageSeed() != seed) {
             throw new IllegalArgumentException("Age plan seed does not match its Age definition");
         }
@@ -39,7 +47,22 @@ public record AgeDefinition(
                          int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                          BlockPos spawn, AgeTraits traits) {
         this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, null);
+                dimensionId, spawn, traits, null, null, List.of());
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, null, List.of());
+    }
+
+    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());
     }
 
     public static ResourceLocation dimensionId(UUID ageId) {
@@ -70,6 +93,6 @@ public record AgeDefinition(
 
     public AgeDefinition withSpawn(BlockPos spawn) {
         return new AgeDefinition(id, name, seed, generationProfile, generationVersion,
-                createdGameTime, dimensionId, spawn.immutable(), traits, plan);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode, randomFeatures);
     }
 }

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

@@ -14,6 +14,7 @@ import java.util.Comparator;
 import java.util.Random;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.compat.ImmersivePortalsChunkLoaders;
+import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.GlobalPos;
@@ -37,6 +38,8 @@ import net.minecraft.world.level.biome.FixedBiomeSource;
 import net.minecraft.world.level.biome.MultiNoiseBiomeSource;
 import net.dnorberg.rivencraft.world.ScaledBiomeSource;
 import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.StarFissureFeature;
 import net.minecraft.world.level.chunk.ChunkGenerator;
 import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
 import net.minecraft.world.level.dimension.DimensionType;
@@ -73,6 +76,7 @@ public final class AgeDimensionService {
                 );
                 if (level != null) {
                     applyCelestialClock(level, age);
+                    SereneSeasonsCompatibility.registerAge(server, age);
                 }
             }
             synchronizeImmersivePortals(server);
@@ -95,6 +99,13 @@ public final class AgeDimensionService {
         if (spawn == null) {
             applyInitialCelestialPhase(level, definition);
             spawn = createSafeSpawn(level, definition);
+            if (AgeFeatureSelection.resolved(definition.plan()).stream()
+                    .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES))
+                    || definition.randomFeatures().stream()
+                    .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES))) {
+                StarFissureFeature.generate(level, definition.seed(), spawn,
+                        AgeBiomeSelection.isCave(runtimeProfile(definition)));
+            }
             definition = AgeRegistrySavedData.get(level).setSpawn(definition.id(), spawn);
         }
         return Optional.of(new LinkTarget(
@@ -109,6 +120,7 @@ public final class AgeDimensionService {
         ServerLevel existing = server.getLevel(key);
         if (existing != null) {
             applyCelestialClock(existing, definition);
+            SereneSeasonsCompatibility.registerAge(server, definition);
             return existing;
         }
 
@@ -124,6 +136,7 @@ public final class AgeDimensionService {
             Rivencraft.LOGGER.error("Failed to load Age {} as {}", definition.id(), definition.dimensionId());
         } else {
             applyCelestialClock(loaded, definition);
+            SereneSeasonsCompatibility.registerAge(server, definition);
             synchronizeImmersivePortals(server);
         }
         return loaded;
@@ -180,6 +193,10 @@ public final class AgeDimensionService {
 
     private static void applyInitialCelestialPhase(ServerLevel level, AgeDefinition age) {
         long phaseTime = (long)(age.traits().celestialPhase() * Level.TICKS_PER_DAY);
+        if (AgeEnvironmentCompiler.hasWrittenPhase(age.plan())) {
+            // Legacy's Nadir is midnight, while vanilla day time zero is sunrise.
+            phaseTime = (phaseTime + 18_000L) % Level.TICKS_PER_DAY;
+        }
         level.setDayTime(phaseTime);
     }
 
@@ -293,6 +310,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),
@@ -300,7 +319,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(
@@ -310,14 +329,17 @@ public final class AgeDimensionService {
             );
             settings.updateLayers();
             return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
-                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings, features, age.seed());
         }
 
         var noiseSettings = server.registryAccess().lookupOrThrow(Registries.NOISE_SETTINGS);
         ResourceKey<NoiseGeneratorSettings> settingsKey = ResourceKey.create(
                 Registries.NOISE_SETTINGS, profile.noiseSettings());
         NoiseGeneratorSettings baseSettings = noiseSettings.getOrThrow(settingsKey).value();
-        return new NoiseBasedChunkGenerator(biomeSource, Holder.direct(withBiomeMaterialRules(baseSettings)));
+        Holder<NoiseGeneratorSettings> settings = Holder.direct(withBiomeMaterialRules(baseSettings));
+        return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
+                ? new NoiseBasedChunkGenerator(biomeSource, settings)
+                : new AgeFeatureChunkGenerator(biomeSource, settings, features, age.seed());
     }
 
     private static NoiseGeneratorSettings withBiomeMaterialRules(NoiseGeneratorSettings base) {
@@ -482,7 +504,7 @@ public final class AgeDimensionService {
                 base.height(),
                 base.logicalHeight(),
                 base.infiniburn(),
-                base.effectsLocation(),
+                AgeEnvironmentCompiler.skyEffects(age.plan(), base.effectsLocation()),
                 ambientLight,
                 base.monsterSettings()
         );

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

@@ -0,0 +1,90 @@
+package net.dnorberg.rivencraft.book;
+
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
+
+/** Resolves written environment pages without changing the seeded page-free Age path. */
+public final class AgeEnvironmentCompiler {
+    private AgeEnvironmentCompiler() {}
+
+    public static AgeTraits apply(AgeGenerationPlan plan, AgeTraits seeded) {
+        if (plan == null) return seeded;
+
+        AgeTraits.Lighting lighting = seeded.lighting();
+        AgeTraits.Weather weather = seeded.weather();
+        double period = seeded.celestialPeriod();
+        float phase = seeded.celestialPhase();
+        boolean normalTime = plan.symbols().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()) {
+            SymbolSemantics semantics = symbol.semantics();
+            switch (semantics.role()) {
+                case LIGHTING -> lighting = AgeTraits.Lighting.valueOf(
+                        ((SymbolSemantics.ChoiceValue) semantics.value()).id().toUpperCase(java.util.Locale.ROOT));
+                case WEATHER -> {
+                    String choice = ((SymbolSemantics.ChoiceValue) semantics.value()).id();
+                    if (choice.equals("snow")) {
+                        throw new IllegalArgumentException("Always Snow requires optional season integration");
+                    }
+                    if (choice.equals("cloudy") || choice.equals("rain")) {
+                        throw new IllegalArgumentException(choice + " weather needs precipitation rendering support");
+                    }
+                    weather = AgeTraits.Weather.valueOf(choice.toUpperCase(java.util.Locale.ROOT));
+                }
+                case PERIOD_MODIFIER -> {
+                    double next = ((SymbolSemantics.NumberValue) semantics.value()).amount();
+                    period = writtenPeriod ? (period + next) / 2.0D : next;
+                    writtenPeriod = true;
+                }
+                case PHASE_MODIFIER -> {
+                    float next = (float) ((SymbolSemantics.NumberValue) semantics.value()).amount();
+                    phaseDegrees = writtenPhase ? circularMidpoint(phaseDegrees, next) : next;
+                    writtenPhase = true;
+                }
+                case ANGLE_MODIFIER -> throw new IllegalArgumentException(
+                        "Sun angle pages require a custom sky renderer and are not supported yet");
+                default -> { }
+            }
+        }
+        if (writtenPhase) phase = phaseDegrees / 360.0F;
+        return new AgeTraits(plan.biomeSelection() == null ? seeded.biomeDistribution()
+                : plan.biomeSelection().distribution(), lighting, weather, period,
+                seeded.celestialAngle(), phase);
+    }
+
+    /** 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()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SKY)
+                .map(symbol -> ((SymbolSemantics.ChoiceValue) symbol.semantics().value()).id())
+                .map(choice -> switch (choice) {
+                    case "overworld" -> BuiltinDimensionTypes.OVERWORLD_EFFECTS;
+                    case "nether" -> BuiltinDimensionTypes.NETHER_EFFECTS;
+                    case "end" -> BuiltinDimensionTypes.END_EFFECTS;
+                    default -> throw new IllegalArgumentException("Unsupported sky effect " + choice);
+                }).findFirst().orElse(fallback);
+    }
+
+    public static boolean hasWrittenPhase(AgeGenerationPlan plan) {
+        return plan != null && plan.symbols().stream()
+                .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.PHASE_MODIFIER);
+    }
+
+    public static int previewSkyColor(ResourceLocation effects, int biomeSkyColor) {
+        if (effects.equals(BuiltinDimensionTypes.NETHER_EFFECTS)) return 0xFF6B2725;
+        if (effects.equals(BuiltinDimensionTypes.END_EFFECTS)) return 0xFF211835;
+        return biomeSkyColor;
+    }
+
+    private static float circularMidpoint(float current, float next) {
+        float difference = (next - current + 540.0F) % 360.0F - 180.0F;
+        return (current + difference / 2.0F + 360.0F) % 360.0F;
+    }
+}

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

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

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

@@ -65,10 +65,14 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         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);
-        return new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
+        AgeFeatureSelection.compile(parsed, 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);
+        AgeEnvironmentCompiler.apply(plan, traits);
+        AgeSeasonMode.validate(plan);
+        return plan;
     }
 
     public ResourceLocation authoredTerrain() {
@@ -137,7 +141,7 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
             SymbolSemantics.Role role = SymbolSemantics.Role.valueOf(item.getString("Role"));
             String raw = item.getString("Value");
             SymbolSemantics.Value value = switch (role) {
-                case TERRAIN, BIOME, FEATURE -> new SymbolSemantics.ResourceValue(ResourceLocation.parse(raw));
+                case TERRAIN, BIOME, BLOCK, FEATURE -> new SymbolSemantics.ResourceValue(ResourceLocation.parse(raw));
                 case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER ->
                         new SymbolSemantics.NumberValue(Double.parseDouble(raw));
                 default -> new SymbolSemantics.ChoiceValue(raw);

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

@@ -30,7 +30,7 @@ public final class AgePersistenceGameTests {
                 WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:weather/normal"))),
                 WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal"))),
                 WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:celestial/normal_time"))),
-                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:feature/caves")))
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:feature/flowers")))
         ));
         UUID id = UUID.randomUUID();
         AgeReference reference = new AgeReference(id, "Authored Plan " + id);
@@ -66,7 +66,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();
     }
 

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

@@ -15,6 +15,7 @@ import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
 import net.minecraft.util.datafix.DataFixTypes;
 import net.minecraft.world.level.saveddata.SavedData;
+import net.neoforged.fml.ModList;
 
 /** Server-wide persistent mapping from stable book UUIDs to immutable Age definitions. */
 public final class AgeRegistrySavedData extends SavedData {
@@ -32,6 +33,8 @@ 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 BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
     private static final String LIGHTING_TAG = "Lighting";
     private static final String WEATHER_TAG = "Weather";
@@ -66,15 +69,20 @@ public final class AgeRegistrySavedData extends SavedData {
         ServerLevel overworld = level.getServer().overworld();
         AgeRegistrySavedData data = get(overworld);
         long seed = ageSeed(overworld.getSeed(), data.availableDimensionId(normalizedName(name)));
-        AgeGenerationPlan.compile(writing, seed, AgeRuntimeProfiles.select(seed), AgeTraits.select(seed),
+        AgeGenerationPlan.compile(writing, seed,
+                AgeRuntimeProfiles.selectForWriting(seed, writing, overworld.registryAccess()), AgeTraits.select(seed),
                 overworld.registryAccess());
     }
 
     public static ResourceLocation previewGenerationProfile(ServerLevel level, String name) {
+        return previewGenerationProfile(level, name, OrderedWriting.EMPTY);
+    }
+
+    public static ResourceLocation previewGenerationProfile(ServerLevel level, String name, OrderedWriting writing) {
         ServerLevel overworld = level.getServer().overworld();
         AgeRegistrySavedData data = get(overworld);
         long seed = ageSeed(overworld.getSeed(), data.availableDimensionId(normalizedName(name)));
-        return AgeRuntimeProfiles.select(seed);
+        return AgeRuntimeProfiles.selectForWriting(seed, writing, overworld.registryAccess());
     }
 
     public Optional<AgeDefinition> find(UUID ageId) {
@@ -112,7 +120,7 @@ public final class AgeRegistrySavedData extends SavedData {
         String name = normalizedName(reference.name());
         ResourceLocation dimensionId = availableDimensionId(name);
         long seed = ageSeed(worldSeed, dimensionId);
-        ResourceLocation seedProfile = AgeRuntimeProfiles.select(seed);
+        ResourceLocation seedProfile = AgeRuntimeProfiles.selectForWriting(seed, writing, registries);
         AgeTraits traits = AgeTraits.select(seed);
         AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile, traits, registries);
         AgeDefinition created = new AgeDefinition(
@@ -124,8 +132,11 @@ public final class AgeRegistrySavedData extends SavedData {
                 createdGameTime,
                 dimensionId,
                 null,
-                traits,
-                plan
+                AgeEnvironmentCompiler.apply(plan, traits),
+                plan,
+                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons")),
+                plan == null ? AgeFeatureSelection.randomChoices(seed,
+                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of()
         );
         ages.put(created.id(), created);
         setDirty();
@@ -169,7 +180,10 @@ public final class AgeRegistrySavedData extends SavedData {
                     spawn,
                     readTraits(entry),
                     entry.contains(PLAN_TAG, CompoundTag.TAG_COMPOUND)
-                            ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null
+                            ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null,
+                    entry.contains(SEASON_MODE_TAG, CompoundTag.TAG_STRING)
+                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null,
+                    readRandomFeatures(entry)
             ));
         }
         return data;
@@ -203,12 +217,35 @@ 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());
                     serializedAges.add(entry);
                 });
         tag.put(AGES_TAG, serializedAges);
         return tag;
     }
 
+    private static List<AgeFeatureSelection.Choice> readRandomFeatures(CompoundTag age) {
+        ListTag tags = age.getList(RANDOM_FEATURES_TAG, CompoundTag.TAG_COMPOUND);
+        List<AgeFeatureSelection.Choice> features = new java.util.ArrayList<>();
+        for (int index = 0; index < tags.size(); index++) {
+            CompoundTag item = tags.getCompound(index);
+            features.add(new AgeFeatureSelection.Choice(ResourceLocation.parse(item.getString("Id")),
+                    item.contains("Material", CompoundTag.TAG_STRING)
+                            ? Optional.of(ResourceLocation.parse(item.getString("Material"))) : Optional.empty()));
+        }
+        return List.copyOf(features);
+    }
+
     private static AgeTraits readTraits(CompoundTag age) {
         if (!age.contains(TRAITS_TAG, CompoundTag.TAG_COMPOUND)) {
             return AgeTraits.LEGACY_DEFAULTS;

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

@@ -5,8 +5,12 @@ import com.google.gson.GsonBuilder;
 import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import java.util.Map;
+import java.util.List;
 import java.util.concurrent.ConcurrentHashMap;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.resources.ResourceKey;
@@ -59,6 +63,31 @@ public final class AgeRuntimeProfiles {
         return ids.get(Math.floorMod(Long.hashCode(seed), ids.size()));
     }
 
+    /** 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 ->
+                symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)) return selected;
+        List<ResourceLocation> features = parsed.symbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
+        boolean hasMaterial = parsed.symbols().stream().anyMatch(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.BLOCK);
+        if ((features.isEmpty() && !hasMaterial) || PROFILES.isEmpty()) return selected;
+        AgeRuntimeProfile initial = PROFILES.get(selected);
+        if (initial != null && features.stream().allMatch(id ->
+                AgeFeatureSelection.error(id, initial, registries) == null)
+                && AgeFeatureSelection.supportsUnpairedMaterials(parsed, initial)) return selected;
+        List<ResourceLocation> compatible = PROFILES.entrySet().stream()
+                .filter(entry -> features.stream().allMatch(id ->
+                        AgeFeatureSelection.error(id, entry.getValue(), registries) == null)
+                        && AgeFeatureSelection.supportsUnpairedMaterials(parsed, entry.getValue()))
+                .map(Map.Entry::getKey).sorted().toList();
+        return compatible.isEmpty() ? selected
+                : compatible.get(Math.floorMod(Long.hashCode(seed), compatible.size()));
+    }
+
     static AgeRuntimeProfile parse(ResourceLocation id, JsonElement json, RegistryAccess registries) {
         JsonObject object = json.getAsJsonObject();
         int schemaVersion = object.has("schema_version") ? object.get("schema_version").getAsInt() : 1;

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

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

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

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

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

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

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

@@ -0,0 +1,197 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.stream.Collectors;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.SymbolCatalog;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.core.BlockPos;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Issue #34: written environment effects and the shared creative/JEI page feed. */
+@GameTestHolder("rivencraft_archive_environment")
+@PrefixGameTestTemplate(false)
+public final class EnvironmentWritingGameTests {
+    private EnvironmentWritingGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void caveBiomesHaveSeparateCreativePages(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        var biomePages = PageItem.creativeSymbolPages(registries,
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "biome"));
+        var cavePages = PageItem.creativeSymbolPages(registries,
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "cave_biome"));
+        helper.assertTrue(PageItem.bundledCreativeCategories().contains(
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "cave_biome")),
+                "The cave biome creative tab must be registered");
+        helper.assertTrue(biomePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/desert")), "Biome pages must remain in the Biome tab");
+        helper.assertTrue(cavePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/lush_caves")), "Cave biomes need their own tab");
+        helper.assertTrue(cavePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/crimson_forest")), "Nether biomes belong in the Cave tab");
+        helper.assertFalse(biomePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/lush_caves")), "Cave biomes must leave the general Biome tab");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void environmentPagesEnterCreativeAndJeiFeed(GameTestHelper helper) {
+        Set<String> expected = Set.of(
+                "lighting/normal", "lighting/dark", "lighting/bright",
+                "sky/overworld", "sky/nether", "sky/end",
+                "weather/normal", "weather/fast", "weather/slow", "weather/off",
+                "weather/always", "weather/storm", "celestial/normal_time",
+                "season/no_seasons", "season/seasons", "season/eternal_winter",
+                "season/eternal_summer", "season/eternal_fall", "season/eternal_spring",
+                "period/zero", "period/half", "period/full", "period/double",
+                "phase/nadir", "phase/rising", "phase/zenith", "phase/setting");
+        Set<String> creative = PageItem.creativeSymbolPages(helper.getLevel().registryAccess()).stream()
+                .map(PageItem::content)
+                .filter(content -> content.symbol().isPresent())
+                .map(content -> content.symbol().orElseThrow().id().getPath())
+                .collect(Collectors.toSet());
+        helper.assertTrue(PageItem.bundledCreativeSymbols().containsAll(expected)
+                        && creative.containsAll(expected),
+                "Every supported environment page must enter the creative index JEI also consumes");
+        for (String path : expected) {
+            var id = ResourceLocation.fromNamespaceAndPath("rivencraft", path);
+            helper.assertTrue(SymbolCatalog.isKnown(new SymbolReference(id))
+                            && PageItem.isUsableWriting(PageItem.createBundledCreativePage(path)),
+                    "Environment page must resolve as valid writing: " + path);
+        }
+        helper.assertFalse(creative.contains("weather/snow") || creative.contains("weather/cloudy")
+                        || creative.contains("weather/rain"),
+                "Unsupported precipitation variants must not appear as working pages");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void seasonalPagesAreExclusiveAndPersist(GameTestHelper helper) {
+        OrderedWriting noSeasons = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(), page("season/no_seasons")));
+        var plan = AgeGenerationPlan.compile(noSeasons, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeSeasonMode.from(plan), AgeSeasonMode.NO_SEASONS,
+                "No Seasons must compile without an installed season mod");
+        helper.assertValueEqual(AgeSeasonMode.from(AgeGenerationPlan.load(plan.save())),
+                AgeSeasonMode.NO_SEASONS, "The Age's seasonal policy must survive reload");
+        OrderedWriting conflict = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                page("season/no_seasons"), page("season/eternal_winter")));
+        helper.assertFalse(WritingGrammar.parse(conflict).canCreate(),
+                "Only one seasonal page may be used in an Age");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void omittedSeasonPageSelectsOnlyWhenSereneIsPresent(GameTestHelper helper) {
+        helper.assertTrue(AgeSeasonMode.select(null, 42L, false) == null,
+                "An Age made without Serene must not receive a random seasonal modifier");
+        AgeSeasonMode selected = AgeSeasonMode.select(null, 42L, true);
+        helper.assertValueEqual(selected, AgeSeasonMode.select(null, 42L, true),
+                "The same Age seed must select the same seasonal modifier");
+        helper.assertTrue(selected != null, "Serene must select a mode when no season page is authored");
+        AgeDefinition age = new AgeDefinition(UUID.randomUUID(), "Season Test", 42L,
+                AgeGenerationProfiles.STANDARD, AgeDefinition.CURRENT_GENERATION_VERSION, 0L,
+                AgeDefinition.dimensionId(UUID.randomUUID()), null, AgeTraits.select(42L), null, selected);
+        helper.assertValueEqual(AgeSeasonMode.from(age.withSpawn(BlockPos.ZERO)), selected,
+                "Updating an Age spawn must preserve the chosen seasonal modifier");
+        OrderedWriting explicit = new OrderedWriting(List.of(WritingEntry.linkPanel(), page("season/no_seasons")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(explicit, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeSeasonMode.select(plan, 42L, true), AgeSeasonMode.NO_SEASONS,
+                "An authored season page must override random selection");
+        AgeReference reference = new AgeReference(UUID.randomUUID(), "Season Persistence");
+        AgeRegistrySavedData data = AgeRegistrySavedData.get(helper.getLevel());
+        AgeRegistrySavedData.resolveOrCreate(helper.getLevel(), reference);
+        CompoundTag saved = data.save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag entries = saved.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            if (entry.getUUID("Id").equals(reference.id())) {
+                entry.putString("SeasonMode", selected.name());
+                break;
+            }
+        }
+        AgeDefinition restored = AgeRegistrySavedData.load(saved, helper.getLevel().registryAccess())
+                .find(reference.id()).orElseThrow();
+        helper.assertValueEqual(restored.seasonMode(), selected,
+                "The selected seasonal modifier must survive Age data reload");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void writtenEnvironmentPersistsAndPageFreeAgesStaySeeded(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                page("terrain/standard"), page("weather/off"), page("lighting/dark"),
+                page("sky/end"), page("period/zero"), page("phase/rising"),
+                page("celestial/normal_time")));
+        AgeTraits seeded = AgeTraits.select(42L);
+        var plan = AgeGenerationPlan.compile(writing, 42L, AgeGenerationProfiles.STANDARD,
+                seeded, helper.getLevel().registryAccess());
+        var effective = AgeEnvironmentCompiler.apply(plan, seeded);
+        helper.assertValueEqual(effective.lighting(), AgeTraits.Lighting.DARK,
+                "Written Dark Lighting must override the seeded lighting");
+        helper.assertValueEqual(effective.weather(), AgeTraits.Weather.OFF,
+                "Written No Weather must override the seeded weather");
+        helper.assertTrue(effective.hasStoppedCelestialCycle(),
+                "A written Zero Length page must stop the celestial cycle");
+        helper.assertValueEqual(effective.celestialPhase(), 0.25F,
+                "Written Rising phase must be stored as a quarter turn");
+        helper.assertValueEqual(AgeEnvironmentCompiler.skyEffects(plan, BuiltinDimensionTypes.OVERWORLD_EFFECTS),
+                BuiltinDimensionTypes.END_EFFECTS, "Written End Sky must select the End sky effects");
+        helper.assertValueEqual(AgeEnvironmentCompiler.previewSkyColor(BuiltinDimensionTypes.END_EFFECTS, 0xFF77AAFF),
+                0xFF211835, "End sky preview must not retain an Overworld biome's blue tint");
+        helper.assertValueEqual(AgeEnvironmentCompiler.previewSkyColor(BuiltinDimensionTypes.NETHER_EFFECTS, 0xFF77AAFF),
+                0xFF6B2725, "Nether sky preview must use its red tint");
+        helper.assertValueEqual(AgeEnvironmentCompiler.previewSkyColor(BuiltinDimensionTypes.OVERWORLD_EFFECTS, 0xFF77AAFF),
+                0xFF77AAFF, "Overworld sky preview must retain the destination biome tint");
+        helper.assertValueEqual(AgeEnvironmentCompiler.apply(AgeGenerationPlan.load(plan.save()), seeded), effective,
+                "Written environment values must survive a plan save/load round trip");
+        helper.assertValueEqual(AgeEnvironmentCompiler.apply(null, seeded), seeded,
+                "Page-free Ages must retain their seeded environment without recompilation");
+
+        var player = helper.makeMockServerPlayerInLevel();
+        var reference = new AgeReference(UUID.randomUUID(), "Written Environment");
+        var target = AgeDimensionService.resolve(player, reference, writing).orElseThrow();
+        var definition = AgeRegistrySavedData.get(helper.getLevel()).find(reference.id()).orElseThrow();
+        helper.assertValueEqual(definition.traits(), AgeEnvironmentCompiler.apply(
+                        definition.plan(), AgeTraits.select(definition.seed())),
+                "The effective authored environment must persist with the Age definition");
+        helper.runAfterDelay(1, () -> {
+            var level = helper.getLevel().getServer().getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "Written environment Age must load");
+            helper.assertFalse(level.dimensionType().hasSkyLight(), "Dark Lighting must remove skylight");
+            helper.assertValueEqual(level.dimensionType().effectsLocation(), BuiltinDimensionTypes.END_EFFECTS,
+                    "The runtime Age must render the written End sky");
+            helper.assertValueEqual(level.getDayTimePerTick(), Float.MIN_VALUE,
+                    "Zero Length must use the non-bouncing stopped clock");
+            helper.assertTrue(Math.floorMod(level.getDayTime(), 24_000L) < 5L,
+                    "Legacy Rising phase must begin at vanilla sunrise");
+            level.setWeatherParameters(0, 6_000, true, true);
+            helper.runAfterDelay(2, () -> {
+                helper.assertFalse(level.isRaining() || level.isThundering(),
+                        "Written No Weather must clear rain and thunder in this Age");
+                helper.succeed();
+            });
+        });
+    }
+
+    private static WritingEntry page(String path) {
+        return WritingEntry.symbol(new SymbolReference(ResourceLocation.fromNamespaceAndPath("rivencraft", path)));
+    }
+}

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

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

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

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

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

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

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

@@ -147,16 +147,42 @@ public final class TerrainWritingGameTests {
         var randomWriting = net.dnorberg.rivencraft.writing.WritingGrammar.parse(OrderedWriting.EMPTY);
         var traits = new AgeTraits(AgeTraits.BiomeDistribution.TINY, AgeTraits.Lighting.NORMAL,
                 AgeTraits.Weather.NORMAL, 1.0D, 0.0F, 0.0F);
+        int availableBiomeCount = new java.util.LinkedHashSet<>(AgeBiomeSelection.eligible(registries, profile)).size();
         java.util.Set<Integer> counts = new java.util.HashSet<>();
         for (long seed = 0; seed < 64; seed++) {
             var random = AgeBiomeSelection.compile(randomWriting, traits, profile, seed, registries);
-            helper.assertTrue(random.biomes().size() >= 2 && random.biomes().size() <= 6,
-                    "Random Tiny ages must select between two and six distinct biomes");
+            helper.assertTrue(random.biomes().size() >= 2 && random.biomes().size() <= availableBiomeCount,
+                    "Random Tiny ages must not exceed their available biome pool");
             helper.assertValueEqual(random, AgeBiomeSelection.compile(randomWriting, traits, profile, seed, registries),
                     "The random count and chosen biomes must be deterministic for an Age seed");
             counts.add(random.biomes().size());
         }
         helper.assertTrue(counts.size() > 1, "Random Ages must vary their biome count across seeds");
+        if (availableBiomeCount > 6) {
+            helper.assertTrue(counts.stream().anyMatch(count -> count > 6),
+                    "The available biome pool, not the old fixed cap, must bound random Ages");
+        }
+
+        var tiledTraits = new AgeTraits(AgeTraits.BiomeDistribution.TILED, AgeTraits.Lighting.NORMAL,
+                AgeTraits.Weather.NORMAL, 1.0D, 0.0F, 0.0F);
+        if (availableBiomeCount > 4) {
+            boolean exceededOldCap = false;
+            for (long seed = 0; seed < 64; seed++) {
+                var random = AgeBiomeSelection.compile(randomWriting, tiledTraits, profile, seed, registries);
+                helper.assertTrue(random.biomes().size() >= 2 && random.biomes().size() <= availableBiomeCount,
+                        "Random Tiled ages must not exceed their available biome pool");
+                exceededOldCap |= random.biomes().size() > 4;
+            }
+            helper.assertTrue(exceededOldCap, "Tiled Ages must also be able to exceed the old fixed cap");
+        }
+
+        var caveProfile = AgeRuntimeProfiles.resolve(AgeGenerationProfiles.CAVE);
+        int caveBiomeCount = new java.util.LinkedHashSet<>(AgeBiomeSelection.eligible(registries, caveProfile)).size();
+        for (long seed = 0; seed < 64; seed++) {
+            var random = AgeBiomeSelection.compile(randomWriting, traits, caveProfile, seed, registries);
+            helper.assertTrue(random.biomes().size() >= 2 && random.biomes().size() <= caveBiomeCount,
+                    "Random Cave ages must use the cave biome pool as their upper bound");
+        }
         helper.succeed();
     }
 
@@ -180,18 +206,14 @@ public final class TerrainWritingGameTests {
             helper.assertTrue(level.getChunkSource().getGenerator().getBiomeSource().possibleBiomes().stream()
                             .allMatch(biome -> biome.is(Biomes.THE_END)),
                     "The runtime sky-island generator must use the End biome page");
-            helper.assertValueEqual(AgeDimensionService.unload(server, age), AgeDimensionService.UnloadResult.UNLOADED,
-                    "The island Age must unload");
-            var reloaded = AgeDimensionService.ensureLoaded(server, age);
-            helper.assertTrue(reloaded != null && reloaded.getChunkSource().getGenerator().getBiomeSource()
-                            .possibleBiomes().stream().allMatch(biome -> biome.is(Biomes.THE_END)),
-                    "The authored End biome must survive runtime dimension reload");
+            helper.assertValueEqual(AgeGenerationPlan.load(age.plan().save()).biomeSelection(),
+                    age.plan().biomeSelection(), "The authored End biome must survive a plan save/load round trip");
             helper.succeed();
         });
     }
 
     @GameTest(template = "empty", timeoutTicks = 600)
-    public static void writtenTerrainFamiliesGenerateSafelyAndReload(GameTestHelper helper) {
+    public static void writtenTerrainFamiliesGenerateSafely(GameTestHelper helper) {
         var player = helper.makeMockServerPlayerInLevel();
         checkWrittenTerrain(helper, player, AgeGenerationProfiles.all(), 0);
     }
@@ -233,14 +255,8 @@ public final class TerrainWritingGameTests {
                             && level.getBlockState(spawn.above()).isAir(),
                     "Every written terrain family must retain a safe arrival platform");
 
-            helper.assertValueEqual(AgeDimensionService.unload(server, age),
-                    AgeDimensionService.UnloadResult.UNLOADED,
-                    "A written Age must unload without losing its plan");
-            var reloaded = AgeDimensionService.ensureLoaded(server, age);
-            helper.assertTrue(reloaded != null, "The written Age must reload from its frozen plan");
-            assertGenerator(helper, reloaded, age.plan().runtimeProfile());
-            helper.assertValueEqual(reloaded.dimensionType().effectsLocation(),
-                    level.dimensionType().effectsLocation(), "Reload must retain dimension effects");
+            helper.assertValueEqual(AgeGenerationPlan.load(age.plan().save()).runtimeProfile(),
+                    age.plan().runtimeProfile(), "The written terrain profile must survive plan persistence");
             helper.runAfterDelay(1, () -> checkWrittenTerrain(helper, player, profiles, index + 1));
         });
     }

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

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

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

@@ -2,9 +2,12 @@ package net.dnorberg.rivencraft.client;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
+import net.dnorberg.rivencraft.registry.ModBlocks;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.client.renderer.ItemBlockRenderTypes;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.resources.ResourceLocation;
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.bus.api.SubscribeEvent;
@@ -32,6 +35,7 @@ public final class ClientEvents {
     public static void registerRenderers(EntityRenderersEvent.RegisterRenderers event) {
         event.registerBlockEntityRenderer(ModBlockEntities.BOOK_STAND.get(), BookStandRenderer::new);
         event.registerBlockEntityRenderer(ModBlockEntities.WRITING_DESK.get(), WritingDeskRenderer::new);
+        event.registerBlockEntityRenderer(ModBlockEntities.STAR_FISSURE.get(), StarFissureRenderer::new);
     }
 
     @SubscribeEvent
@@ -62,11 +66,18 @@ 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());
+        });
         NeoForge.EVENT_BUS.addListener(ClientBookInteractionHandler::onRightClickItem);
         NeoForge.EVENT_BUS.addListener(ClientBookInteractionHandler::onRightClickBlock);
         NeoForge.EVENT_BUS.addListener(ClientBookExploreOverlay::onClientTickPre);

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

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

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

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

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

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

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

@@ -52,6 +52,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     private final OrderedWriting writing;
     private final List<SymbolDisplayMetadata> writingSymbols;
     private final boolean pageFree;
+    private final String author;
     private final InteractionHand hand;
     private final BlockPos bookStandPos;
     private DestinationPreviewRenderer preview;
@@ -71,6 +72,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
+        author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         this.hand = hand;
         bookStandPos = null;
     }
@@ -84,6 +86,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
         this.writingSymbols = List.copyOf(writingSymbols);
         pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
+        author = book.get(ModDataComponents.BOOK_AUTHOR.get());
         hand = InteractionHand.MAIN_HAND;
         this.bookStandPos = bookStandPos.immutable();
     }
@@ -163,6 +166,26 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             else if (pageIndex < pageCount() && mouseX >= left + 293 && mouseX < left + 320)
                 graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.next_page"), mouseX, mouseY);
         }
+        if (pageIndex == 0 && age != null && !pageFree && traits != null
+                && mouseX >= left + 38 && mouseX < left + 154
+                && mouseY >= top + 38 && mouseY < top + 67) {
+            graphics.renderComponentTooltip(font, List.of(
+                    Component.translatable("screen.rivencraft.age.trait.biomes",
+                            traitName("biome_distribution", traits.biomeDistribution())),
+                    Component.translatable("screen.rivencraft.age.trait.lighting",
+                            traitName("lighting", traits.lighting())),
+                    Component.translatable("screen.rivencraft.age.trait.weather",
+                            traitName("weather", traits.weather())),
+                    Component.translatable("screen.rivencraft.age.trait.day_length",
+                            traits.hasStoppedCelestialCycle()
+                                    ? Component.translatable("trait.rivencraft.day_length.stopped")
+                                    : Component.literal(String.format(Locale.ROOT, "%.2fx", traits.celestialPeriod()))),
+                    Component.translatable("screen.rivencraft.age.trait.celestial_angle",
+                            Component.literal(String.format(Locale.ROOT, "%.0f°", traits.celestialAngle()))),
+                    Component.translatable("screen.rivencraft.age.trait.celestial_phase",
+                            Component.literal(String.format(Locale.ROOT, "%.0f%%", traits.celestialPhase() * 100.0F)))
+            ), mouseX, mouseY);
+        }
     }
 
     private void renderBook(GuiGraphics graphics, float partialTick) {
@@ -182,7 +205,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             graphics.enableScissor(left + 38, top + 38, left + 154, top + 174);
             renderFirstPageText(graphics, left, top);
             graphics.disableScissor();
-        } else if (pageIndex < pageCount()) {
+        } else if (pageIndex < writing.entries().size()) {
             LegacyBookArtwork.drawFullPage(graphics, left, top);
             renderWrittenPage(graphics, left, top);
         }
@@ -193,20 +216,25 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
 
     private int pageCount() {
         // Older page-free Descriptive Books do not have a BOOK_WRITING component.
-        return Math.max(1, writing.entries().size());
+        return Math.max(1, writing.entries().size() - 1);
     }
 
     private void renderFirstPageText(GuiGraphics graphics, int left, int top) {
         int x = left + 40;
-        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.title"),
-                x, top + 40, 110);
         if (age == null) {
+            drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.title"),
+                    x, top + 40, 110);
             drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.name_prompt"),
                     x, top + 52, 110);
             return;
         }
-        int detailsY = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
-                x + 10, top + 52, 100) + 10;
+        int nameEnd = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
+                x, top + 40, 110);
+        int detailsY = drawWrappedWithoutShadow(graphics,
+                author == null || author.isBlank()
+                        ? Component.translatable("screen.rivencraft.age.unknown_author")
+                        : Component.literal(author), x + 10, nameEnd + 2, 100) + 10;
+        if (!pageFree) return;
         if (generationProfile != null) {
             Component profileName = generationProfile.getNamespace().equals("rivencraft")
                     ? Component.translatable("generator.rivencraft." + generationProfile.getPath())
@@ -242,13 +270,15 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                 .filter(candidate -> candidate.kind() == WritingEntry.Kind.SYMBOL).count() - 1;
         SymbolDisplayMetadata display = symbolIndex < writingSymbols.size()
                 ? writingSymbols.get(symbolIndex) : SymbolDisplayMetadata.unresolved(entry.symbol().orElseThrow());
-        int color = display.resolved() ? BOOK_TEXT_COLOR : UNRESOLVED_TEXT_COLOR;
-        drawWrappedWithoutShadow(graphics, Component.translatable(display.nameTranslationKey()),
-                x, top + 39, 126, color);
-        drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
-                x, top + 64, 126, color);
-        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.pages_not_applied"),
-                x, top + 137, 126);
+        graphics.enableScissor(left + 174, top + 26, left + 306, top + 172);
+        int textureSize = display.resolved() ? 128 : 16;
+        graphics.blit(SymbolPageTextures.forDisplay(display), left + 177, top + 29,
+                128, 128, 0, 0, textureSize, textureSize, textureSize, textureSize);
+        if (!display.resolved()) {
+            drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
+                    x, top + 151, 126, UNRESOLVED_TEXT_COLOR);
+        }
+        graphics.disableScissor();
     }
 
     private void turnPage(int direction) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -6,6 +6,9 @@ import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
+import net.dnorberg.rivencraft.book.LinkProperties;
+import net.dnorberg.rivencraft.book.LinkTarget;
+import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.menu.BookBinderMenu;
 import net.dnorberg.rivencraft.registry.ModBlocks;
@@ -17,6 +20,7 @@ import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.GlobalPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.resources.ResourceLocation;
@@ -133,7 +137,14 @@ public final class BookBinderGameTests {
         helper.assertFalse(binder.consumeAssembly(), "Failure must consume nothing");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
                 "Rejected assembly must preserve cover");
-        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        ItemStack flavoredPanel = PageItem.createLinkPanelPage();
+        flavoredPanel.set(ModDataComponents.LINK_PROPERTIES.get(),
+                new net.dnorberg.rivencraft.book.LinkProperties(
+                        net.dnorberg.rivencraft.book.LinkProperties.DISARM
+                                | net.dnorberg.rivencraft.book.LinkProperties.MAINTAIN_MOMENTUM
+                                | net.dnorberg.rivencraft.book.LinkProperties.INTRA_LINKING));
+        var expectedProperties = flavoredPanel.get(ModDataComponents.LINK_PROPERTIES.get()).forDescriptiveBook();
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, flavoredPanel);
         var player = helper.makeMockServerPlayerInLevel();
         player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
                 binder.getBlockPos().getZ() + 0.5);
@@ -143,6 +154,9 @@ public final class BookBinderGameTests {
         menu.clicked(BookBinderMenu.RESULT, 0, ClickType.PICKUP, player);
         ItemStack book = menu.getCarried();
         helper.assertTrue(book.is(ModItems.DESCRIPTIVE_BOOK.get()), "Result must be a Descriptive Book");
+        helper.assertValueEqual(book.get(ModDataComponents.LINK_PROPERTIES.get()),
+                expectedProperties,
+                "Binder must retain Disarm and Momentum but omit Intra Linking");
         AgeReference age = book.get(ModDataComponents.AGE_REFERENCE.get());
         helper.assertTrue(age != null, "Assembled book must already be a written Age book");
         OrderedWriting writing = book.get(ModDataComponents.BOOK_WRITING.get());
@@ -175,6 +189,50 @@ public final class BookBinderGameTests {
         helper.succeed();
     }
 
+    public static void panelOnlyBookRetainsApplicableModifiers(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Modified Random Age");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        ItemStack panel = PageItem.createLinkPanelPage();
+        panel.set(ModDataComponents.LINK_PROPERTIES.get(), new LinkProperties(
+                LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM | LinkProperties.INTRA_LINKING));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        menu.setCarried(panel);
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE),
+                "The link strip must accept the modified panel without symbol pages");
+        ItemStack result = menu.quickMoveStack(player, BookBinderMenu.RESULT);
+        helper.assertTrue(result.is(ModItems.DESCRIPTIVE_BOOK.get()),
+                "A Link Panel alone must create a random-Age Descriptive Book");
+        LinkProperties expected = new LinkProperties(LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM);
+        helper.assertValueEqual(result.get(ModDataComponents.LINK_PROPERTIES.get()), expected,
+                "The panel-only book must keep travel modifiers but omit Intra Linking");
+        ItemStack restored = ItemStack.parseOptional(helper.getLevel().registryAccess(),
+                (net.minecraft.nbt.CompoundTag) result.saveOptional(helper.getLevel().registryAccess()));
+        helper.assertValueEqual(restored.get(ModDataComponents.LINK_PROPERTIES.get()), expected,
+                "Panel-only book modifiers must survive save and reload");
+        BlockPos departure = player.blockPosition();
+        BlockPos destination = departure.offset(3, 0, 0);
+        helper.getLevel().setBlock(destination.below(), Blocks.STONE.defaultBlockState(), 3);
+        helper.getLevel().setBlock(destination, Blocks.AIR.defaultBlockState(), 3);
+        helper.getLevel().setBlock(destination.above(), Blocks.AIR.defaultBlockState(), 3);
+        player.getInventory().setItem(4, new ItemStack(Items.DIAMOND, 3));
+        LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), destination), 0.0F, 0.0F);
+        helper.assertValueEqual(LinkingService.travelWithFooting(player, target,
+                        restored.get(ModDataComponents.LINK_PROPERTIES.get()).forDescriptiveBook()),
+                LinkingService.LinkResult.SUCCESS,
+                "The panel-only book's properties must be accepted by grounded travel");
+        helper.assertTrue(player.getInventory().getItem(4).isEmpty(),
+                "Disarm must remove the carried items during panel-only book travel");
+        helper.assertTrue(helper.getLevel().getEntitiesOfClass(ItemEntity.class,
+                        new AABB(departure).inflate(5.0), entity -> entity.getItem().is(Items.DIAMOND))
+                        .stream().mapToInt(entity -> entity.getItem().getCount()).sum() >= 3,
+                "Disarm must drop the items at the departure location");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void linkPanelOnlyCreatesCompletedRandomAgeBook(GameTestHelper helper) {
         BookBinderBlockEntity binder = place(helper);

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

@@ -1,8 +1,10 @@
 package net.dnorberg.rivencraft.gametest;
 
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.BiomeSymbolPages;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
 import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
@@ -87,6 +89,21 @@ public final class CoreGameTests {
         BookBinderGameTests.assemblyIsAtomicAndRetainsPageOrder(helper);
     }
 
+    @GameTest(template = "empty")
+    public static void panelOnlyBookModifiers(GameTestHelper helper) {
+        BookBinderGameTests.panelOnlyBookRetainsApplicableModifiers(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void biomePageNamespaces(GameTestHelper helper) {
+        helper.assertValueEqual(BiomeSymbolPages.symbolId(ResourceLocation.parse("minecraft:desert")),
+                ResourceLocation.parse("rivencraft:biome/desert"), "Vanilla biome page IDs must remain stable");
+        helper.assertFalse(BiomeSymbolPages.symbolId(ResourceLocation.parse("example:orchard"))
+                        .equals(BiomeSymbolPages.symbolId(ResourceLocation.parse("another:orchard"))),
+                "Equal biome paths from different mods must not share a page ID");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void binderRejectsConflictingGrammar(GameTestHelper helper) {
         BookBinderGameTests.conflictingGrammarKeepsBinderInputsRecoverable(helper);
@@ -102,6 +119,11 @@ public final class CoreGameTests {
         InkMixerGameTests.linkPanelRequiresTakingOutputAndPersistsInk(helper);
     }
 
+    @GameTest(template = "empty")
+    public static void mixerModifierTransaction(GameTestHelper helper) {
+        InkMixerGameTests.modifierClickPersistsPreviewAndConsumesOnce(helper);
+    }
+
     @GameTest(template = "empty")
     public static void linkingBookRecipe(GameTestHelper helper) {
         LinkingBookRecipeGameTests.legacyRecipeRequiresExactlyLeatherAndLinkPanel(helper);

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

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

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

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

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

@@ -11,6 +11,7 @@ import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfile;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.book.LinkTarget;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.book.AgeVisitSavedData;
 import net.dnorberg.rivencraft.book.AgeTraits;
@@ -313,42 +314,6 @@ public final class LinkingGameTests {
         throw new IllegalStateException("Could not select profile " + profile);
     }
 
-    @GameTest(template = "empty", timeoutTicks = 100)
-    public static void unloadedAgeReloadsWithTheSameDefinition(GameTestHelper helper) {
-        UUID id = UUID.randomUUID();
-        AgeDefinition definition = AgeRegistrySavedData.resolveOrCreate(
-                helper.getLevel(),
-                new AgeReference(id, "Lifecycle Test Age " + id)
-        );
-
-        var server = helper.getLevel().getServer();
-        var first = AgeDimensionService.ensureLoaded(server, definition);
-        helper.assertTrue(first != null, "The lifecycle test Age must load");
-        helper.runAfterDelay(1, () -> {
-            helper.assertValueEqual(
-                    AgeDimensionService.unload(server, definition),
-                    AgeDimensionService.UnloadResult.UNLOADED,
-                    "A loaded Age must unload without deleting its definition"
-            );
-            helper.runAfterDelay(1, () -> {
-                helper.assertTrue(server.getLevel(AgeDimensionService.dimensionKey(definition)) == null,
-                        "An unloaded Age must leave the active server level map");
-
-                var reloaded = AgeDimensionService.ensureLoaded(server, definition);
-                helper.assertTrue(reloaded != null, "A book must be able to reload an archived Age");
-                helper.runAfterDelay(1, () -> {
-                    var registered = server.getLevel(AgeDimensionService.dimensionKey(definition));
-                    helper.assertTrue(registered != null, "The reloaded Age must rejoin the active server level map");
-                    helper.assertValueEqual(registered.getSeed(), definition.seed(),
-                            "Reloading an Age must preserve its immutable seed");
-                    helper.assertValueEqual(registered.dimension().location(), definition.dimensionId(),
-                            "Reloading an Age must preserve its dimension identifier");
-                    helper.succeed();
-                });
-            });
-        });
-    }
-
     @GameTest(template = "empty", timeoutTicks = 200)
     public static void legacyBaseTerrainProfilesLoadRuntimeDimensions(GameTestHelper helper) {
         for (var profile : AgeGenerationProfiles.all()) {
@@ -421,9 +386,11 @@ public final class LinkingGameTests {
             }
             if (profile.equals(AgeGenerationProfiles.AMPLIFIED)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
+                int availableBiomes = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
+                        AgeRuntimeProfiles.resolve(profile)).size();
                 helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                                && biomeSource.possibleBiomes().size() <= 4,
-                        "Random Tiled distribution must use two to four seeded biomes");
+                                && biomeSource.possibleBiomes().size() <= availableBiomes,
+                        "Random Tiled distribution must stay within the available biome pool");
                 var origin = biomeSource.getNoiseBiome(0, 0, 0, null);
                 var eastTile = biomeSource.getNoiseBiome(64, 0, 0, null);
                 helper.assertFalse(origin.equals(eastTile),
@@ -431,9 +398,11 @@ public final class LinkingGameTests {
             }
             if (profile.equals(AgeGenerationProfiles.ISLAND)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
+                int availableBiomes = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
+                        AgeRuntimeProfiles.resolve(profile)).size();
                 helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                                && biomeSource.possibleBiomes().size() <= 4,
-                        "Random Grid distribution must use two to four seeded biomes");
+                                && biomeSource.possibleBiomes().size() <= availableBiomes,
+                        "Random Grid distribution must stay within the available biome pool");
                 var origin = biomeSource.getNoiseBiome(0, 0, 0, null);
                 var insideOriginChunk = biomeSource.getNoiseBiome(3, 0, 3, null);
                 var eastChunk = biomeSource.getNoiseBiome(4, 0, 0, null);
@@ -444,11 +413,13 @@ public final class LinkingGameTests {
             }
             if (profile.equals(AgeGenerationProfiles.CAVE)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
+                int caveBiomeCount = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
+                        AgeRuntimeProfiles.resolve(profile)).size();
                 helper.assertTrue(biomeSource instanceof net.dnorberg.rivencraft.world.ScaledBiomeSource,
                         "Tiny Biome Distribution must use the serializable scaled biome source");
                 helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                                && biomeSource.possibleBiomes().size() <= 3,
-                        "Random cave Tiny distribution must use two to three eligible biomes");
+                                && biomeSource.possibleBiomes().size() <= caveBiomeCount,
+                        "Random cave Tiny distribution must use only eligible cave biomes");
                 java.util.Set<net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome>> sampled =
                         new java.util.HashSet<>();
                 for (int x = -32; x <= 32; x += 4) {
@@ -520,11 +491,13 @@ public final class LinkingGameTests {
                 continue;
             }
             var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
+            int availableBiomes = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
+                    AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD)).size();
             helper.assertTrue(biomeSource instanceof net.dnorberg.rivencraft.world.ScaledBiomeSource,
                     distribution + " Biome Distribution must use the serializable scaled biome source");
             helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                            && biomeSource.possibleBiomes().size() <= 6,
-                    distribution + " random distribution must use two to six seeded biomes");
+                            && biomeSource.possibleBiomes().size() <= availableBiomes,
+                    distribution + " random distribution must stay within the available biome pool");
             helper.assertValueEqual(
                     ((net.dnorberg.rivencraft.world.ScaledBiomeSource)biomeSource).scale(),
                     scale,
@@ -606,7 +579,8 @@ public final class LinkingGameTests {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), destination), 90.0F, 15.0F);
 
-        LinkingService.LinkResult result = LinkingService.travel(player, target);
+        LinkingService.LinkResult result = LinkingService.travel(player, target,
+                new LinkProperties(LinkProperties.INTRA_LINKING));
 
         helper.assertValueEqual(result, LinkingService.LinkResult.SUCCESS,
                 "A Linking Book must accept leaf blocks even without a floor");
@@ -631,7 +605,8 @@ public final class LinkingGameTests {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), absoluteOrigin), 0.0F, 0.0F);
 
-        helper.assertValueEqual(LinkingService.travelWithFooting(player, target), LinkingService.LinkResult.SUCCESS,
+        helper.assertValueEqual(LinkingService.travelWithFooting(player, target,
+                        new LinkProperties(LinkProperties.INTRA_LINKING)), LinkingService.LinkResult.SUCCESS,
                 "Descriptive Book travel must find an alternate grounded arrival");
         BlockPos landing = player.blockPosition();
         helper.assertTrue(helper.getLevel().getBlockState(landing.below()).isFaceSturdy(
@@ -652,8 +627,10 @@ public final class LinkingGameTests {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         LinkTarget target = new LinkTarget(GlobalPos.of(helper.getLevel().dimension(), absoluteOrigin), 0.0F, 0.0F);
 
-        helper.assertValueEqual(LinkingService.travel(player, target), LinkingService.LinkResult.NO_SAFE_DESTINATION,
+        helper.assertValueEqual(LinkingService.travel(player, target,
+                        new LinkProperties(LinkProperties.INTRA_LINKING)), LinkingService.LinkResult.NO_SAFE_DESTINATION,
                 "Linking must fail rather than placing a player inside a blocked destination");
         helper.succeed();
     }
+
 }

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

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

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

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

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

@@ -99,8 +99,11 @@ public final class WritingGrammarGameTests {
                 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 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)),

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

@@ -4,6 +4,7 @@ import java.util.List;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeVisitSavedData;
 import net.dnorberg.rivencraft.book.LinkTarget;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.config.RivencraftConfig;
@@ -54,7 +55,9 @@ public final class DescriptiveBookItem extends Item {
 
         ServerLevel sourceLevel = player.serverLevel();
         var sourcePosition = player.blockPosition();
-        LinkingService.LinkResult result = LinkingService.travelWithFooting(player, ageTarget);
+        LinkProperties properties = stack.getOrDefault(ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE)
+                .forDescriptiveBook();
+        LinkingService.LinkResult result = LinkingService.travelWithFooting(player, ageTarget, properties);
         if (result != LinkingService.LinkResult.SUCCESS) {
             player.displayClientMessage(Component.translatable("message.rivencraft.descriptive_book.unsafe"), true);
             return false;
@@ -109,5 +112,7 @@ public final class DescriptiveBookItem extends Item {
                 ? Component.translatable("item.rivencraft.descriptive_book.unwritten")
                 : Component.translatable("item.rivencraft.descriptive_book.age", age.name());
         tooltipComponents.add(status.withStyle(ChatFormatting.GRAY));
+        stack.getOrDefault(ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE)
+                .forDescriptiveBook().appendTooltip(tooltipComponents);
     }
 }

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

@@ -4,6 +4,7 @@ import java.util.List;
 import net.dnorberg.rivencraft.book.LinkTarget;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
 import net.dnorberg.rivencraft.book.LinkingService;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModSounds;
 import net.minecraft.ChatFormatting;
@@ -49,7 +50,8 @@ public final class LinkingBookItem extends Item {
 
         Level sourceLevel = player.level();
         BlockPos sourcePosition = player.blockPosition();
-        LinkingService.LinkResult result = LinkingService.travel(player, target);
+        LinkProperties properties = stack.getOrDefault(ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE);
+        LinkingService.LinkResult result = LinkingService.travel(player, target, properties);
         if (result == LinkingService.LinkResult.SUCCESS) {
             sourceLevel.playSound(null, sourcePosition, ModSounds.LINK.get(), SoundSource.PLAYERS,
                     0.8F, sourceLevel.random.nextFloat() * 0.2F + 0.9F);
@@ -65,9 +67,11 @@ public final class LinkingBookItem extends Item {
             return InteractionResultHolder.success(stack);
         }
 
-        String errorKey = result == LinkingService.LinkResult.MISSING_DIMENSION
-                ? "message.rivencraft.linking_book.missing_dimension"
-                : "message.rivencraft.linking_book.unsafe";
+        String errorKey = switch (result) {
+            case MISSING_DIMENSION -> "message.rivencraft.linking_book.missing_dimension";
+            case INTRA_LINKING_REQUIRED -> "message.rivencraft.linking_book.intra_required";
+            default -> "message.rivencraft.linking_book.unsafe";
+        };
         player.displayClientMessage(Component.translatable(errorKey), true);
         return InteractionResultHolder.fail(stack);
     }
@@ -85,9 +89,11 @@ public final class LinkingBookItem extends Item {
             TooltipFlag tooltipFlag
     ) {
         LinkTarget target = stack.get(ModDataComponents.LINK_TARGET.get());
+        LinkProperties properties = stack.getOrDefault(ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE);
         if (target == null) {
             tooltipComponents.add(Component.translatable("item.rivencraft.linking_book.unbound")
                     .withStyle(ChatFormatting.GRAY));
+            properties.appendTooltip(tooltipComponents);
             return;
         }
 
@@ -101,6 +107,7 @@ public final class LinkingBookItem extends Item {
                         position.getZ()
                 )
                 .withStyle(ChatFormatting.GRAY));
+        properties.appendTooltip(tooltipComponents);
     }
 
     public static String destinationName(ServerLevel level) {

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

@@ -8,28 +8,45 @@ import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.ArrayList;
+import java.util.LinkedHashSet;
 import java.util.Set;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.book.AgeBiomeSelection;
+import net.dnorberg.rivencraft.book.LinkProperties;
+import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolDefinition;
 import net.dnorberg.rivencraft.writing.BiomeSymbolPages;
+import net.dnorberg.rivencraft.writing.BlockSymbolPages;
 import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.minecraft.ChatFormatting;
 import net.minecraft.core.component.DataComponents;
 import net.minecraft.core.HolderLookup;
+import net.minecraft.core.RegistryAccess;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.BiomeTags;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
 
 /** One stackable Page item whose server-owned component identifies its writing state. */
 public final class PageItem extends Item {
-    private static final Map<String, SymbolDisplayMetadata> CREATIVE_SYMBOLS = loadCreativeSymbols();
+    private static final ResourceLocation BIOME_GENERATION_CATEGORY =
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome_generation");
+    private static final ResourceLocation CAVE_BIOME_CATEGORY =
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "cave_biome");
+    private static final ResourceLocation BIOME_CATEGORY =
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome");
+    private static final Map<String, CreativeSymbol> CREATIVE_SYMBOLS = loadCreativeSymbols();
+
+    private record CreativeSymbol(SymbolDisplayMetadata display, ResourceLocation creativeCategory) {}
 
     public PageItem(Properties properties) {
         super(properties);
@@ -46,26 +63,102 @@ public final class PageItem extends Item {
         return List.copyOf(CREATIVE_SYMBOLS.keySet());
     }
 
+    /** Bundled categories become separate creative tabs without a Java page list. */
+    public static List<ResourceLocation> bundledCreativeCategories() {
+        LinkedHashSet<ResourceLocation> categories = CREATIVE_SYMBOLS.values().stream()
+                .map(CreativeSymbol::creativeCategory)
+                .collect(java.util.stream.Collectors.toCollection(LinkedHashSet::new));
+        categories.add(BlockSymbolPages.CATEGORY);
+        categories.add(BlockSymbolPages.FLUID_CATEGORY);
+        categories.add(CAVE_BIOME_CATEGORY);
+        return List.copyOf(categories);
+    }
+
+    public static ItemStack bundledCreativeCategoryIcon(ResourceLocation category) {
+        if (category.equals(CAVE_BIOME_CATEGORY)) {
+            return createCreativeBiomePage(ResourceLocation.withDefaultNamespace("lush_caves"));
+        }
+        if (category.equals(BlockSymbolPages.CATEGORY) || category.equals(BlockSymbolPages.FLUID_CATEGORY)) {
+            return createCreativeBlockPage(ResourceLocation.withDefaultNamespace(
+                    category.equals(BlockSymbolPages.FLUID_CATEGORY) ? "water" : "stone"));
+        }
+        return CREATIVE_SYMBOLS.entrySet().stream()
+                .filter(entry -> entry.getValue().creativeCategory().equals(category))
+                .findFirst()
+                .map(entry -> createBundledCreativePage(entry.getKey()))
+                .orElseThrow(() -> new IllegalArgumentException("No bundled pages for category " + category));
+    }
+
     /** Exact symbol-page variants offered in the creative tab and to optional ingredient viewers. */
     public static List<ItemStack> creativeSymbolPages(HolderLookup.Provider registries) {
+        List<ItemStack> pages = creativeBundledAndBiomePages(registries);
+        BlockSymbolPages.availableBlocks().forEach(id -> pages.add(createCreativeBlockPage(id)));
+        return List.copyOf(pages);
+    }
+
+    private static List<ItemStack> creativeBundledAndBiomePages(HolderLookup.Provider registries) {
         List<ItemStack> pages = new ArrayList<>();
         CREATIVE_SYMBOLS.keySet().forEach(id -> pages.add(createBundledCreativePage(id)));
         Set<String> bundled = CREATIVE_SYMBOLS.keySet();
         registries.lookupOrThrow(Registries.BIOME).listElements()
                 .map(holder -> holder.key().location())
-                .filter(id -> id.getNamespace().equals("minecraft"))
-                .filter(id -> !bundled.contains("biome/" + id.getPath()))
+                .filter(id -> !bundled.contains(BiomeSymbolPages.symbolId(id).getPath()))
                 .sorted()
                 .forEach(id -> pages.add(createCreativeBiomePage(id)));
-        return List.copyOf(pages);
+        return pages;
+    }
+
+    public static List<ItemStack> creativeSymbolPages(HolderLookup.Provider registries,
+                                                      ResourceLocation category) {
+        if (category.equals(BlockSymbolPages.CATEGORY) || category.equals(BlockSymbolPages.FLUID_CATEGORY)) {
+            return BlockSymbolPages.availableBlocks(category).stream()
+                    .map(PageItem::createCreativeBlockPage).toList();
+        }
+        Set<ResourceLocation> caveBiomes = category.equals(BIOME_CATEGORY) || category.equals(CAVE_BIOME_CATEGORY)
+                ? caveBiomeIds(registries) : Set.of();
+        return creativeBundledAndBiomePages(registries).stream()
+                .filter(page -> category.equals(creativeCategory(page, caveBiomes)))
+                .toList();
+    }
+
+    public static ResourceLocation creativeCategory(ItemStack page, HolderLookup.Provider registries) {
+        return creativeCategory(page, caveBiomeIds(registries));
+    }
+
+    private static ResourceLocation creativeCategory(ItemStack page, Set<ResourceLocation> caveBiomes) {
+        ResourceLocation category = creativeCategory(page);
+        if (!category.equals(BIOME_CATEGORY)) return category;
+        ResourceLocation symbolId = content(page).symbol().orElseThrow().id();
+        ResourceLocation biomeId = BiomeSymbolPages.biomeId(symbolId);
+        return caveBiomes.contains(biomeId) ? CAVE_BIOME_CATEGORY : category;
+    }
+
+    private static Set<ResourceLocation> caveBiomeIds(HolderLookup.Provider registries) {
+        LinkedHashSet<ResourceLocation> ids = new LinkedHashSet<>();
+        registries.lookupOrThrow(Registries.BIOME).listElements()
+                .filter(holder -> holder.is(AgeBiomeSelection.CAVE_BIOMES) || holder.is(BiomeTags.IS_NETHER))
+                .forEach(holder -> ids.add(holder.key().location()));
+        if (registries instanceof RegistryAccess access) ids.addAll(TerraBlenderBiomes.nether(access));
+        return ids;
+    }
+
+    public static ResourceLocation creativeCategory(ItemStack page) {
+        SymbolDisplayMetadata metadata = page.get(ModDataComponents.PAGE_SYMBOL_DISPLAY.get());
+        if (metadata == null) throw new IllegalArgumentException("Page has no symbol display metadata");
+        if (metadata.id().getNamespace().equals(Rivencraft.MOD_ID)) {
+            CreativeSymbol bundled = CREATIVE_SYMBOLS.get(metadata.id().getPath());
+            if (bundled != null) return bundled.creativeCategory();
+        }
+        return metadata.category();
     }
 
     /** Bundled symbols for the creative tab; the server still validates catalog membership on use. */
     public static ItemStack createBundledCreativePage(String path) {
-        SymbolDisplayMetadata metadata = CREATIVE_SYMBOLS.get(path);
-        if (metadata == null) {
+        CreativeSymbol symbol = CREATIVE_SYMBOLS.get(path);
+        if (symbol == null) {
             throw new IllegalArgumentException("Not a bundled symbol: " + path);
         }
+        SymbolDisplayMetadata metadata = symbol.display();
         SymbolReference reference = new SymbolReference(metadata.id());
         ItemStack page = create(PageContent.symbol(reference));
         page.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), metadata);
@@ -79,7 +172,14 @@ public final class PageItem extends Item {
         return page;
     }
 
-    private static Map<String, SymbolDisplayMetadata> loadCreativeSymbols() {
+    public static ItemStack createCreativeBlockPage(ResourceLocation blockId) {
+        var symbolId = BlockSymbolPages.symbolId(blockId);
+        ItemStack page = create(PageContent.symbol(new SymbolReference(symbolId)));
+        page.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), BlockSymbolPages.definition(blockId).display(symbolId));
+        return page;
+    }
+
+    private static Map<String, CreativeSymbol> loadCreativeSymbols() {
         String resource = "/assets/rivencraft/creative_symbol_pages.json";
         try (var stream = PageItem.class.getResourceAsStream(resource)) {
             if (stream == null) {
@@ -87,13 +187,18 @@ public final class PageItem extends Item {
             }
             var json = JsonParser.parseReader(new InputStreamReader(stream, StandardCharsets.UTF_8))
                     .getAsJsonObject();
-            Map<String, SymbolDisplayMetadata> symbols = new LinkedHashMap<>();
+            Map<String, CreativeSymbol> symbols = new LinkedHashMap<>();
             json.entrySet().forEach(entry -> {
                 var id = net.minecraft.resources.ResourceLocation.parse(entry.getKey());
                 if (!id.getNamespace().equals(Rivencraft.MOD_ID)) {
                     throw new IllegalStateException("Creative symbol is not a Rivencraft page: " + id);
                 }
-                symbols.put(id.getPath(), SymbolDefinition.parse(entry.getValue()).display(id));
+                SymbolDefinition definition = SymbolDefinition.parse(entry.getValue());
+                ResourceLocation creativeCategory = definition.semantics()
+                        .filter(semantics -> semantics.role() == SymbolSemantics.Role.BIOME_CONTROLLER)
+                        .map(ignored -> BIOME_GENERATION_CATEGORY)
+                        .orElse(definition.category());
+                symbols.put(id.getPath(), new CreativeSymbol(definition.display(id), creativeCategory));
             });
             return Collections.unmodifiableMap(symbols);
         } catch (java.io.IOException exception) {
@@ -105,6 +210,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));
@@ -153,6 +279,8 @@ public final class PageItem extends Item {
         if (content.kind() == PageContent.Kind.LINK_PANEL) {
             tooltipComponents.add(Component.translatable("item.rivencraft.page.link_panel.description")
                     .withStyle(ChatFormatting.GRAY));
+            stack.getOrDefault(ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE)
+                    .appendTooltip(tooltipComponents);
             return;
         }
         SymbolReference reference = content.symbol().orElseThrow();
@@ -188,6 +316,10 @@ public final class PageItem extends Item {
                 && reference.id().getPath().startsWith("biome/")
                 ? Component.translatableWithFallback(metadata.nameTranslationKey(),
                         BiomeSymbolPages.fallbackName(reference.id()))
+                : reference.id().getNamespace().equals(Rivencraft.MOD_ID)
+                && reference.id().getPath().startsWith("block/")
+                ? Component.translatableWithFallback(metadata.nameTranslationKey(),
+                        BlockSymbolPages.fallbackName(BlockSymbolPages.blockId(reference.id())))
                 : Component.translatable(metadata.nameTranslationKey());
     }
 

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

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

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

@@ -10,6 +10,7 @@ import net.minecraft.world.SimpleContainer;
 import net.minecraft.world.entity.player.Inventory;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.ClickType;
 import net.minecraft.world.inventory.DataSlot;
 import net.minecraft.world.inventory.Slot;
 import net.minecraft.world.item.ItemStack;
@@ -17,13 +18,15 @@ import net.minecraft.world.item.Items;
 
 /** Server-owned virtual output; taking it spends paper and the configured ink cost once. */
 public final class InkMixerMenu extends AbstractContainerMenu {
-    public static final int RESULT = InkMixerBlockEntity.SIZE;
+    public static final int MODIFIER = InkMixerBlockEntity.SIZE;
+    public static final int RESULT = MODIFIER + 1;
     private static final int PLAYER_START = RESULT + 1;
     private final InkMixerBlockEntity mixer;
     private final Container inputs;
     private final SimpleContainer result = new SimpleContainer(1);
     private final boolean clientSide;
     private int inkRemaining;
+    private final int[] modifierChances = new int[3];
 
     public InkMixerMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
         this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
@@ -39,9 +42,19 @@ public final class InkMixerMenu extends AbstractContainerMenu {
             @Override public int get() { return clientSide ? inkRemaining : mixer.inkRemaining(); }
             @Override public void set(int value) { inkRemaining = value; }
         });
+        for (int index = 0; index < modifierChances.length; index++) {
+            final int chanceIndex = index;
+            addDataSlot(new DataSlot() {
+                @Override public int get() {
+                    return clientSide ? modifierChances[chanceIndex] : mixer.modifierChancePermille(chanceIndex);
+                }
+                @Override public void set(int value) { modifierChances[chanceIndex] = value; }
+            });
+        }
         addSlot(new MixerSlot(InkMixerBlockEntity.INK, 8, 27));
         addSlot(new MixerSlot(InkMixerBlockEntity.PAPER, 8, 48));
         addSlot(new MixerSlot(InkMixerBlockEntity.BOTTLES, 152, 27));
+        addSlot(new ModifierSlot(79, 40));
         addSlot(new ResultSlot(152, 48));
         for (int row = 0; row < 3; row++)
             for (int column = 0; column < 9; column++)
@@ -52,6 +65,24 @@ public final class InkMixerMenu extends AbstractContainerMenu {
     }
 
     public int inkRemaining() { return inkRemaining; }
+    public int modifierChancePermille(int index) { return modifierChances[index]; }
+
+    @Override public void clicked(int slotId, int button, ClickType clickType, Player player) {
+        if (slotId == MODIFIER) {
+            if (!clientSide && stillValid(player) && clickType == ClickType.PICKUP
+                    && (button == 0 || button == 1)) {
+                ItemStack carried = getCarried();
+                int amount = button == 1 ? 1 : carried.getCount();
+                if (mixer.addModifier(carried, amount)) {
+                    setCarried(carried);
+                    refreshResult();
+                    broadcastChanges();
+                }
+            }
+            return;
+        }
+        super.clicked(slotId, button, clickType, player);
+    }
 
     @Override public boolean stillValid(Player player) {
         return mixer != null && mixer.stillValid(player);
@@ -64,8 +95,7 @@ public final class InkMixerMenu extends AbstractContainerMenu {
 
     private void refreshResult() {
         if (clientSide) return;
-        ItemStack preview = mixer != null && mixer.canCreateLinkPanel()
-                ? PageItem.createLinkPanelPage() : ItemStack.EMPTY;
+        ItemStack preview = mixer == null ? ItemStack.EMPTY : mixer.previewLinkPanel();
         if (!ItemStack.matches(result.getItem(0), preview)) result.setItem(0, preview);
     }
 
@@ -87,7 +117,7 @@ public final class InkMixerMenu extends AbstractContainerMenu {
         ItemStack source = slot.getItem();
         ItemStack original = source.copy();
         boolean moved;
-        if (index < RESULT) moved = moveItemStackTo(source, PLAYER_START, slots.size(), true);
+        if (index < MODIFIER) moved = moveItemStackTo(source, PLAYER_START, slots.size(), true);
         else if (source.is(ModItems.INK_VIAL.get()))
             moved = moveItemStackTo(source, InkMixerBlockEntity.INK, InkMixerBlockEntity.INK + 1, false);
         else if (source.is(Items.PAPER))
@@ -105,6 +135,12 @@ public final class InkMixerMenu extends AbstractContainerMenu {
         @Override public boolean mayPlace(ItemStack stack) { return inputs.canPlaceItem(getContainerSlot(), stack); }
     }
 
+    private static final class ModifierSlot extends Slot {
+        ModifierSlot(int x, int y) { super(new SimpleContainer(1), 0, x, y); }
+        @Override public boolean mayPlace(ItemStack stack) { return false; }
+        @Override public boolean mayPickup(Player player) { return false; }
+    }
+
     private final class ResultSlot extends Slot {
         ResultSlot(int x, int y) { super(result, 0, x, y); }
         @Override public boolean mayPlace(ItemStack stack) { return false; }

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

@@ -5,6 +5,8 @@ import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.registry.ModMenus;
 import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.item.PageItem;
 import net.minecraft.core.NonNullList;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.world.Container;
@@ -82,6 +84,7 @@ public final class NotebookMenu extends AbstractContainerMenu {
             }
         } else {
             if (!source.is(ModItems.PAGE.get())
+                    || PageItem.content(source).kind() == PageContent.Kind.LINK_PANEL
                     || !moveItemStackTo(source, 0, PLAYER_INVENTORY_START, false)) {
                 return ItemStack.EMPTY;
             }
@@ -135,7 +138,10 @@ public final class NotebookMenu extends AbstractContainerMenu {
             super(container, slot, x, y);
         }
 
-        @Override public boolean mayPlace(ItemStack stack) { return stack.is(ModItems.PAGE.get()); }
+        @Override public boolean mayPlace(ItemStack stack) {
+            return stack.is(ModItems.PAGE.get())
+                    && PageItem.content(stack).kind() != PageContent.Kind.LINK_PANEL;
+        }
         @Override public int getMaxStackSize() { return 1; }
     }
 

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

@@ -180,7 +180,7 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
     private boolean placeCarriedPage(int collectionIndex, int pageIndex) {
         // Resolve the actual storage position on the server, never a filtered list index.
         ItemStack carried = getCarried();
-        if (clientSide || !carried.is(ModItems.PAGE.get())) return false;
+        if (clientSide || !storablePage(carried)) return false;
         ItemStack collection = desk.getItem(collectionIndex);
         if (collection.is(ModItems.NOTEBOOK.get())) {
             var pages = new java.util.ArrayList<>(collection.getOrDefault(
@@ -215,12 +215,14 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
         if (sourceNotebook && (sourcePage >= sourcePages.size() || sourcePages.get(sourcePage).isEmpty())) return false;
         ItemStack moving = sourceNotebook ? sourcePages.get(sourcePage) : sourceBook;
         if (moving.getCount() != 1) return false;
+        if (!storablePage(moving)) return false;
         if (!targetNotebook && targetBook.getCount() != 1) return false;
         var targetPages = targetNotebook ? sourceCollection == targetCollection ? sourcePages
                 : new java.util.ArrayList<>(targetBook.getOrDefault(
                         ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages()) : null;
         if (targetNotebook) while (targetPages.size() <= targetPage) targetPages.add(ItemStack.EMPTY);
         ItemStack displaced = targetNotebook ? targetPages.get(targetPage) : targetBook;
+        if (!displaced.isEmpty() && !storablePage(displaced)) return false;
         if (targetNotebook) targetPages.set(targetPage, moving);
         if (sourceNotebook) {
             sourcePages.set(sourcePage, displaced);
@@ -256,6 +258,7 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
             setCarried(moving);
         } else {
             if (targetSlot >= WritingDeskBlockEntity.COLLECTIONS && targetSlot < PLAYER_START) return false;
+            if (targetSlot < WritingDeskBlockEntity.COLLECTIONS && !storablePage(moving)) return false;
             Slot target = slots.get(targetSlot);
             if (!target.isActive() || !target.mayPlace(moving)) return false;
             ItemStack current = target.getItem();
@@ -340,10 +343,15 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
         if (moving.is(Items.PAPER))
             return moveItemStackTo(moving, WritingDeskBlockEntity.PAPER,
                     WritingDeskBlockEntity.PAPER + 1, false);
-        if (moving.is(ModItems.PAGE.get())) return moveItemStackTo(moving, firstVisibleTab, firstVisibleTab + VISIBLE_TABS, false);
+        if (storablePage(moving)) return moveItemStackTo(moving, firstVisibleTab, firstVisibleTab + VISIBLE_TABS, false);
         return false;
     }
 
+    private static boolean storablePage(ItemStack stack) {
+        return stack.is(ModItems.PAGE.get())
+                && PageItem.content(stack).kind() != PageContent.Kind.LINK_PANEL;
+    }
+
     private ItemStack selectedSource() {
         if (selectedSymbol != null) {
             SymbolReference reference = new SymbolReference(selectedSymbol);
@@ -375,6 +383,7 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
         ItemStack source = selectedSource();
         return blockEntity != null && source.is(ModItems.PAGE.get())
                 && PageItem.content(source).kind() != PageContent.Kind.BLANK
+                && PageItem.content(source).kind() != PageContent.Kind.LINK_PANEL
                 && PageItem.isUsableWriting(source) && blockEntity.canConsumeCopyMaterials();
     }
 

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/network/ModNetworking.java

@@ -7,10 +7,12 @@ import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeGenerationPlan;
 import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeEnvironmentCompiler;
 import net.dnorberg.rivencraft.block.entity.BookStandBlockEntity;
 import net.dnorberg.rivencraft.client.ClientLinkPreviewHandler;
 import net.dnorberg.rivencraft.client.ClientBookInteractionHandler;
 import net.dnorberg.rivencraft.client.ClientAgeCelestialAngles;
+import net.dnorberg.rivencraft.client.ClientSereneAgeWhitelist;
 import net.dnorberg.rivencraft.client.ClientWritingDeskCatalog;
 import net.dnorberg.rivencraft.event.AgeCelestialAngleSync;
 import net.dnorberg.rivencraft.item.DescriptiveBookItem;
@@ -57,7 +59,7 @@ public final class ModNetworking {
     }
 
     public static void register(RegisterPayloadHandlersEvent event) {
-        PayloadRegistrar registrar = event.registrar("13");
+        PayloadRegistrar registrar = event.registrar("15");
         registrar.playToServer(RequestDescriptiveBookScreenPayload.TYPE, RequestDescriptiveBookScreenPayload.STREAM_CODEC,
                 ModNetworking::requestDescriptiveBookScreen);
         registrar.playToClient(OpenDescriptiveBookScreenPayload.TYPE, OpenDescriptiveBookScreenPayload.STREAM_CODEC,
@@ -77,6 +79,8 @@ public final class ModNetworking {
                 ClientLinkPreviewHandler::handle);
         registrar.playToClient(AgeCelestialAnglePayload.TYPE, AgeCelestialAnglePayload.STREAM_CODEC,
                 ClientAgeCelestialAngles::handle);
+        registrar.playToClient(SereneAgeWhitelistPayload.TYPE, SereneAgeWhitelistPayload.STREAM_CODEC,
+                ClientSereneAgeWhitelist::handle);
         registrar.playToClient(WritingDeskCatalogPayload.TYPE, WritingDeskCatalogPayload.STREAM_CODEC,
                 ClientWritingDeskCatalog::handle);
         registrar.playToServer(SetBookBinderTitlePayload.TYPE, SetBookBinderTitlePayload.STREAM_CODEC,
@@ -110,8 +114,9 @@ public final class ModNetworking {
         // Requests run on the same server thread as Age creation. A request queued
         // during generation can only open the finished book, never a stale client copy.
         player.inventoryMenu.broadcastChanges();
-        List<SymbolDisplayMetadata> writingSymbols = access.stack()
-                .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY).entries().stream()
+        OrderedWriting writing = access.stack()
+                .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
+        List<SymbolDisplayMetadata> writingSymbols = writing.entries().stream()
                 .filter(entry -> entry.kind() == WritingEntry.Kind.SYMBOL)
                 .map(entry -> SymbolCatalog.display(entry.symbol().orElseThrow()))
                 .toList();
@@ -164,6 +169,7 @@ public final class ModNetworking {
             }
 
             access.stack().set(ModDataComponents.AGE_REFERENCE.get(), reference);
+            access.stack().set(ModDataComponents.BOOK_AUTHOR.get(), player.getGameProfile().getName());
             AgeRegistrySavedData.get(player.serverLevel()).find(reference.id()).ifPresent(definition ->
                     access.stack().set(ModDataComponents.AGE_GENERATION_PROFILE.get(), definition.generationProfile()));
             access.stack().set(DataComponents.CUSTOM_NAME, Component.literal(title));
@@ -313,15 +319,10 @@ public final class ModNetworking {
         }
     }
 
-    /** Vanilla Nether and End renderers do not use their biomes' blue Overworld sky tint. */
+    /** Sky effects, not dimension IDs, decide the backdrop for custom Ages. */
     private static int previewSkyColor(ServerLevel level, BlockPos origin) {
-        if (level.dimension().equals(Level.NETHER)) {
-            return 0xFF6B2725;
-        }
-        if (level.dimension().equals(Level.END)) {
-            return 0xFF211835;
-        }
-        return level.getBiome(origin).value().getSkyColor();
+        return AgeEnvironmentCompiler.previewSkyColor(level.dimensionType().effectsLocation(),
+                level.getBiome(origin).value().getSkyColor());
     }
 
     private static InteractionHand hand(boolean offhand) {

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

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

src/main/java/net/dnorberg/rivencraft/registry/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,12 @@ 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.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 +36,26 @@ 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));
 
     private ModBlocks() {
     }

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

@@ -3,6 +3,7 @@ package net.dnorberg.rivencraft.registry;
 import com.mojang.serialization.MapCodec;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.world.level.chunk.ChunkGenerator;
 import net.neoforged.bus.api.IEventBus;
@@ -13,7 +14,10 @@ public final class ModChunkGenerators {
     private static final DeferredRegister<MapCodec<? extends ChunkGenerator>> GENERATORS =
             DeferredRegister.create(Registries.CHUNK_GENERATOR, Rivencraft.MOD_ID);
 
-    static { GENERATORS.register("age_flat", () -> AgeFlatChunkGenerator.CODEC); }
+    static {
+        GENERATORS.register("age_flat", () -> AgeFlatChunkGenerator.CODEC);
+        GENERATORS.register("age_features", () -> AgeFeatureChunkGenerator.CODEC);
+    }
 
     private ModChunkGenerators() { }
 

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

@@ -1,9 +1,15 @@
 package net.dnorberg.rivencraft.registry;
 
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.item.CreativeModeTab;
 import net.neoforged.bus.api.IEventBus;
 import net.neoforged.neoforge.registries.DeferredHolder;
@@ -25,20 +31,50 @@ 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());
 
-    public static final DeferredHolder<CreativeModeTab, CreativeModeTab> PAGES =
-            CREATIVE_TABS.register("rivencraft_pages", () -> CreativeModeTab.builder()
-                    .title(Component.translatable("itemGroup.rivencraft.pages"))
+    public static final DeferredHolder<CreativeModeTab, CreativeModeTab> LINK_PAGES =
+            CREATIVE_TABS.register("rivencraft_link_pages", () -> CreativeModeTab.builder()
+                    .title(Component.translatable("itemGroup.rivencraft.pages.link"))
                     .icon(PageItem::createLinkPanelPage)
-                    .displayItems((parameters, output) -> {
-                        output.accept(ModItems.PAGE.get());
-                        output.accept(PageItem.createLinkPanelPage());
-                        PageItem.creativeSymbolPages(parameters.holders()).forEach(output::accept);
-                    })
+                    .displayItems((parameters, output) ->
+                            PageItem.creativeLinkPanelPages().forEach(output::accept))
                     .build());
 
+    private static final List<String> CATEGORY_ORDER = List.of(
+            "terrain", "biome", "cave_biome", "biome_generation", "weather", "season", "lighting", "sky", "celestial", "block", "fluid", "feature");
+
+    public static final Map<ResourceLocation, DeferredHolder<CreativeModeTab, CreativeModeTab>> SYMBOL_PAGES =
+            registerSymbolPageTabs();
+
+    private static Map<ResourceLocation, DeferredHolder<CreativeModeTab, CreativeModeTab>> registerSymbolPageTabs() {
+        List<ResourceLocation> categories = new ArrayList<>(PageItem.bundledCreativeCategories());
+        categories.sort(Comparator.comparingInt((ResourceLocation id) -> {
+            int index = CATEGORY_ORDER.indexOf(id.getPath());
+            return index < 0 ? CATEGORY_ORDER.size() : index;
+        }).thenComparing(ResourceLocation::toString));
+        Map<ResourceLocation, DeferredHolder<CreativeModeTab, CreativeModeTab>> tabs = new LinkedHashMap<>();
+        for (ResourceLocation category : categories) {
+            String key = "rivencraft_pages_" + category.getNamespace() + "_" + category.getPath().replace('/', '_');
+            tabs.put(category, CREATIVE_TABS.register(key, () -> CreativeModeTab.builder()
+                    .title(Component.translatableWithFallback("itemGroup.rivencraft.pages." + category.getPath(),
+                            "Rivencraft " + category.getPath() + " Pages"))
+                    .icon(() -> PageItem.bundledCreativeCategoryIcon(category))
+                    .displayItems((parameters, output) -> PageItem.creativeSymbolPages(parameters.holders(), category)
+                            .forEach(output::accept))
+                    .build()));
+        }
+        return Map.copyOf(tabs);
+    }
+
     private ModCreativeTabs() {
     }
 

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

@@ -2,6 +2,7 @@ package net.dnorberg.rivencraft.registry;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.book.LinkTarget;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.NotebookContents;
@@ -26,6 +27,12 @@ public final class ModDataComponents {
                     .networkSynchronized(LinkTarget.STREAM_CODEC)
                     .cacheEncoding()
                     .build());
+    public static final DeferredHolder<DataComponentType<?>, DataComponentType<LinkProperties>> LINK_PROPERTIES =
+            DATA_COMPONENTS.register("link_properties", () -> DataComponentType.<LinkProperties>builder()
+                    .persistent(LinkProperties.CODEC)
+                    .networkSynchronized(LinkProperties.STREAM_CODEC)
+                    .cacheEncoding()
+                    .build());
     public static final DeferredHolder<DataComponentType<?>, DataComponentType<AgeReference>> AGE_REFERENCE =
             DATA_COMPONENTS.register("age_reference", () -> DataComponentType.<AgeReference>builder()
                     .persistent(AgeReference.CODEC)
@@ -68,6 +75,12 @@ public final class ModDataComponents {
                     .networkSynchronized(OrderedWriting.STREAM_CODEC)
                     .cacheEncoding()
                     .build());
+    public static final DeferredHolder<DataComponentType<?>, DataComponentType<String>> BOOK_AUTHOR =
+            DATA_COMPONENTS.register("book_author", () -> DataComponentType.<String>builder()
+                    .persistent(Codec.STRING)
+                    .networkSynchronized(ByteBufCodecs.STRING_UTF8)
+                    .cacheEncoding()
+                    .build());
     public static final DeferredHolder<DataComponentType<?>, DataComponentType<Integer>> INK_REMAINING =
             DATA_COMPONENTS.register("ink_remaining", () -> DataComponentType.<Integer>builder()
                     .persistent(Codec.intRange(0, 16))

src/main/java/net/dnorberg/rivencraft/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,7 @@ 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");
 
     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.MOD_ID)
+@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

@@ -0,0 +1,222 @@
+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 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.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.StructureManager;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.server.level.WorldGenRegion;
+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;
+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;
+import net.minecraft.world.level.levelgen.feature.LakeFeature;
+import net.minecraft.world.level.levelgen.feature.configurations.BlockStateConfiguration;
+import net.minecraft.world.level.levelgen.feature.stateproviders.BlockStateProvider;
+import net.minecraft.world.level.block.Blocks;
+
+/** Adds frozen authored decorations after vanilla's biome features, without changing shared biome registries. */
+public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator {
+    public static final MapCodec<AgeFeatureChunkGenerator> CODEC = RecordCodecBuilder.mapCodec(instance ->
+            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))
+                    .apply(instance, AgeFeatureChunkGenerator::new));
+
+    private final Holder<NoiseGeneratorSettings> settings;
+    private final List<AgeFeatureSelection.Choice> features;
+    private final long ageSeed;
+
+    public AgeFeatureChunkGenerator(BiomeSource biomes, Holder<NoiseGeneratorSettings> settings,
+                                    List<AgeFeatureSelection.Choice> features, long ageSeed) {
+        super(biomes, settings);
+        this.settings = settings;
+        this.features = List.copyOf(features);
+        this.ageSeed = ageSeed;
+    }
+
+    public List<AgeFeatureSelection.Choice> ageFeatures() { return features; }
+
+    @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) {
+        super.applyCarvers(level, seed, random, biomes, structures, chunk, step);
+        if (step != GenerationStep.Carving.AIR || features.stream().noneMatch(choice ->
+                AgeFeatureSelection.caves(choice.id()) || AgeFeatureSelection.ravines(choice.id()))) return;
+        var noiseChunk = chunk.getOrCreateNoiseChunk(ignored -> {
+            throw new IllegalStateException("Vanilla carver did not initialize the Age noise chunk");
+        });
+        var context = new CarvingContext(this, level.registryAccess(), chunk.getHeightAccessorForGeneration(),
+                noiseChunk, random, settings.value().surfaceRule());
+        var mask = ((ProtoChunk) chunk).getOrCreateCarvingMask(step);
+        var carvers = level.registryAccess().lookupOrThrow(Registries.CONFIGURED_CARVER);
+        var sourceRandom = new WorldgenRandom(new LegacyRandomSource(0L));
+        ChunkPos target = chunk.getPos();
+        BiomeManager sourceBiomes = biomes.withDifferentSource((qx, qy, qz) ->
+                getBiomeSource().getNoiseBiome(qx, qy, qz, random.sampler()));
+        for (AgeFeatureSelection.Choice choice : features) {
+            if (!AgeFeatureSelection.caves(choice.id()) && !AgeFeatureSelection.ravines(choice.id())) continue;
+            for (int dx = -8; dx <= 8; dx++) {
+                for (int dz = -8; dz <= 8; dz++) {
+                    ChunkPos source = new ChunkPos(target.x + dx, target.z + dz);
+                    var biome = getBiomeSource().getNoiseBiome(QuartPos.fromBlock(source.getMinBlockX()), 0,
+                            QuartPos.fromBlock(source.getMinBlockZ()), random.sampler());
+                    if (AgeFeatureSelection.ravines(choice.id())
+                            && biome.is(net.minecraft.tags.BiomeTags.IS_NETHER)) continue;
+                    ResourceLocation carverId = ResourceLocation.withDefaultNamespace(
+                            AgeFeatureSelection.ravines(choice.id()) ? "canyon"
+                                    : biome.is(net.minecraft.tags.BiomeTags.IS_NETHER) ? "nether_cave" : "cave");
+                    ConfiguredWorldCarver<?> carver = carvers.getOrThrow(
+                            ResourceKey.create(Registries.CONFIGURED_CARVER, carverId)).value();
+                    sourceRandom.setLargeFeatureSeed(ageSeed ^ (AgeFeatureSelection.ravines(choice.id())
+                            ? 0x524156494E45534CL : 0x4341564553464541L), source.x, source.z);
+                    if (carver.isStartChunk(sourceRandom)) {
+                        carver.carve(context, chunk, sourceBiomes::getBiome, sourceRandom,
+                                noiseChunk.aquifer(), source, mask);
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public void applyBiomeDecoration(WorldGenLevel level, ChunkAccess chunk, StructureManager structures) {
+        super.applyBiomeDecoration(level, chunk, structures);
+        var registry = level.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE);
+        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(
+                        level.getBiome(new BlockPos(x + 8, surface, z + 8)))) continue;
+            }
+            ResourceLocation key = AgeFeatureSelection.placedFeature(choice.id());
+            if (key == null) continue; // Carvers are applied before decoration.
+            PlacedFeature vanilla = registry.getOrThrow(ResourceKey.create(Registries.PLACED_FEATURE, key)).value();
+            // Vanilla's biome filter only admits a feature already in that biome's list. An
+            // authored page intentionally adds it, so preserve all other vanilla placement rules.
+            Holder<ConfiguredFeature<?, ?>> configured = vanilla.feature();
+            if (choice.material().isPresent()) {
+                var material = BuiltInRegistries.BLOCK.get(choice.material().orElseThrow()).defaultBlockState();
+                if (AgeFeatureSelection.isRock(choice.id())) {
+                    configured = Holder.direct(new ConfiguredFeature<>(Feature.FOREST_ROCK,
+                            new BlockStateConfiguration(material)));
+                } else if (AgeFeatureSelection.isLake(choice.id())) {
+                    configured = Holder.direct(new ConfiguredFeature<>(Feature.LAKE,
+                            new LakeFeature.Configuration(BlockStateProvider.simple(material),
+                                    BlockStateProvider.simple(Blocks.STONE))));
+                }
+            }
+            PlacedFeature authored = new PlacedFeature(configured, vanilla.placement().stream()
+                    .filter(modifier -> !(modifier instanceof BiomeFilter))
+                    .map(modifier -> AgeFeatureSelection.isLake(choice.id())
+                            && !choice.id().getPath().equals("deep_lakes")
+                            && modifier instanceof RarityFilter
+                            ? RarityFilter.onAverageOnceEvery(12) : modifier)
+                    .toList());
+            long seed = ageSeed ^ (long) x * 341873128712L ^ (long) z * 132897987541L
+                    ^ (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; }

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

@@ -0,0 +1,82 @@
+package net.dnorberg.rivencraft.world;
+
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/** A surface crystal mound with budding hearts and initially seeded buds. */
+final class CrystalFormationsFeature {
+    private static final long SALT = 0x4352595354414C53L;
+    private static final int CHANCE = 15; // Legacy's authored crystal formation frequency.
+
+    private CrystalFormationsFeature() {}
+
+    record Site(int x, int z, long seed) {}
+
+    static Site site(long ageSeed, ChunkPos chunk, int occurrence) {
+        long seed = mix(ageSeed ^ SALT ^ (long) chunk.x * 341873128712L
+                ^ (long) chunk.z * 132897987541L ^ (long) occurrence * 0x9E3779B97F4A7C15L);
+        RandomSource random = RandomSource.create(seed);
+        if (random.nextInt(CHANCE) != 0) return null;
+        return new Site(chunk.getMinBlockX() + 5 + random.nextInt(6),
+                chunk.getMinBlockZ() + 5 + random.nextInt(6), seed);
+    }
+
+    static void generate(WorldGenLevel level, ChunkAccess chunk, long ageSeed, int occurrence) {
+        Site site = site(ageSeed, chunk.getPos(), occurrence);
+        if (site == null) return;
+        RandomSource random = RandomSource.create(site.seed() ^ 0x42554444494E474CL);
+        int y = level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, site.x(), site.z());
+        if (y <= level.getMinBuildHeight() + 1 || y + 4 >= level.getMaxBuildHeight()) return;
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                int x = site.x() + dx;
+                int z = site.z() + dz;
+                if (Math.abs(level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, x, z) - y) > 1) return;
+                BlockState floor = level.getBlockState(pos.set(x, y - 1, z));
+                if (!floor.isFaceSturdy(level, pos, Direction.UP) || !floor.getFluidState().isEmpty()
+                        || floor.hasBlockEntity()) return;
+                for (int h = 0; h < 4; h++) {
+                    BlockState existing = level.getBlockState(pos.set(x, y + h, z));
+                    if (!existing.isAir() && !existing.canBeReplaced()) return;
+                }
+            }
+        }
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                boolean center = dx == 0 && dz == 0;
+                int height = center ? 3 : random.nextInt(3) == 0 ? 2 : 1;
+                for (int h = 0; h < height; h++) {
+                    boolean budding = h == height - 1 && (center || random.nextBoolean());
+                    level.setBlock(pos.set(site.x() + dx, y + h, site.z() + dz),
+                            budding ? ModBlocks.BUDDING_CRYSTAL.get().defaultBlockState()
+                                    : ModBlocks.CRYSTAL_BLOCK.get().defaultBlockState(), 2);
+                }
+                if (buddingTop(level.getBlockState(pos.set(site.x() + dx, y + height - 1, site.z() + dz)))
+                        && random.nextBoolean()) {
+                    level.setBlock(pos.set(site.x() + dx, y + height, site.z() + dz),
+                            ModBlocks.SMALL_CRYSTAL_BUD.get().defaultBlockState()
+                                    .setValue(AmethystClusterBlock.FACING, Direction.UP), 2);
+                }
+            }
+        }
+    }
+
+    private static boolean buddingTop(BlockState state) {
+        return state.is(ModBlocks.BUDDING_CRYSTAL);
+    }
+
+    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/CrystalFormationsGameTests.java

@@ -0,0 +1,75 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.List;
+import java.util.Objects;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.BuddingCrystalBlock;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
+import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeTraits;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.minecraft.core.Direction;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.Blocks;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class CrystalFormationsGameTests {
+    private CrystalFormationsGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void authoredCrystalPageAndGrowth(GameTestHelper helper) {
+        var page = PageItem.createBundledCreativePage("feature/crystal_formations");
+        helper.assertTrue(PageItem.isUsableWriting(page), "Crystal Formations page must be writable");
+        var plan = AgeGenerationPlan.compile(new OrderedWriting(List.of(
+                        WritingEntry.linkPanel(),
+                        WritingEntry.symbol(new SymbolReference(ResourceLocation.fromNamespaceAndPath(
+                                Rivencraft.MOD_ID, "terrain/standard"))),
+                        WritingEntry.symbol(new SymbolReference(ResourceLocation.fromNamespaceAndPath(
+                                Rivencraft.MOD_ID, "feature/crystal_formations"))))),
+                57L, AgeGenerationProfiles.STANDARD, AgeTraits.select(57L),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeFeatureSelection.resolved(plan).getFirst().id(),
+                AgeFeatureSelection.CRYSTAL_FORMATIONS, "Page must compile to the crystal feature");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())),
+                AgeFeatureSelection.resolved(plan), "Crystal choice must survive saving");
+        helper.assertValueEqual(BuddingCrystalBlock.nextStage(Blocks.AIR.defaultBlockState(), Direction.UP),
+                ModBlocks.SMALL_CRYSTAL_BUD.get(), "Air must begin the blue bud sequence");
+        helper.assertValueEqual(BuddingCrystalBlock.nextStage(
+                        ModBlocks.SMALL_CRYSTAL_BUD.get().defaultBlockState()
+                                .setValue(AmethystClusterBlock.FACING, Direction.UP), Direction.UP),
+                ModBlocks.MEDIUM_CRYSTAL_BUD.get(), "Small buds must grow into medium buds");
+        helper.assertValueEqual(BuddingCrystalBlock.nextStage(
+                        ModBlocks.MEDIUM_CRYSTAL_BUD.get().defaultBlockState()
+                                .setValue(AmethystClusterBlock.FACING, Direction.UP), Direction.UP),
+                ModBlocks.LARGE_CRYSTAL_BUD.get(), "Medium buds must grow into large buds");
+        helper.assertValueEqual(BuddingCrystalBlock.nextStage(
+                        ModBlocks.LARGE_CRYSTAL_BUD.get().defaultBlockState()
+                                .setValue(AmethystClusterBlock.FACING, Direction.UP), Direction.UP),
+                ModBlocks.CRYSTAL_CLUSTER.get(), "Large buds must grow into shard-bearing clusters");
+        helper.assertTrue(BuddingCrystalBlock.nextStage(
+                        ModBlocks.LARGE_CRYSTAL_BUD.get().defaultBlockState()
+                                .setValue(AmethystClusterBlock.FACING, Direction.NORTH), Direction.UP) == null,
+                "Growth must not change a bud facing away from its budding block");
+        helper.assertTrue(ModBlocks.BUDDING_CRYSTAL.get().defaultBlockState().isRandomlyTicking(),
+                "Budding crystals must receive random growth ticks");
+        var site = CrystalFormationsFeature.site(57L, new ChunkPos(10, -3), 0);
+        helper.assertTrue(Objects.equals(site, CrystalFormationsFeature.site(57L, new ChunkPos(10, -3), 0)),
+                "Formation placement must be deterministic per Age and chunk");
+        helper.assertTrue(java.util.stream.IntStream.range(0, 100).anyMatch(x ->
+                        CrystalFormationsFeature.site(57L, new ChunkPos(x, -3), 0) != null),
+                "Authored crystal formations must have reachable placement sites");
+        helper.succeed();
+    }
+}

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

@@ -0,0 +1,100 @@
+package net.dnorberg.rivencraft.world;
+
+import net.dnorberg.rivencraft.book.AgeBiomeSelection;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.QuartPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.tags.BiomeTags;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.RandomState;
+
+/** Adds rare, high island clusters to an existing noise terrain before its surface is built. */
+final class FloatingIslandFeature {
+    private static final long SALT = 0x464C4F4154494E47L;
+    private static final int SOURCE_RANGE = 3;
+    private static final int CHANCE = 128;
+
+    private FloatingIslandFeature() {}
+
+    static void generate(ChunkAccess chunk, BiomeSource biomes, RandomState noise, long ageSeed,
+                         AgeFeatureSelection.Choice choice) {
+        ChunkPos target = chunk.getPos();
+        BlockState material = choice.material().map(id -> BuiltInRegistries.BLOCK.get(id).defaultBlockState())
+                .orElse(null);
+        for (int sourceX = target.x - SOURCE_RANGE; sourceX <= target.x + SOURCE_RANGE; sourceX++) {
+            for (int sourceZ = target.z - SOURCE_RANGE; sourceZ <= target.z + SOURCE_RANGE; sourceZ++) {
+                RandomSource random = random(ageSeed, sourceX, sourceZ);
+                if (random.nextInt(CHANCE) != 0) continue;
+                int centerX = sourceX * 16 + random.nextInt(16);
+                int centerZ = sourceZ * 16 + random.nextInt(16);
+                int centerY = Math.min(chunk.getMaxBuildHeight() - 30, 168 + random.nextInt(48));
+                if (centerY < chunk.getMinBuildHeight() + 24) continue;
+                int radiusX = 24 + random.nextInt(18);
+                int radiusZ = 24 + random.nextInt(18);
+                fill(chunk, biomes, noise, ageSeed, material, centerX, centerY, centerZ, radiusX, radiusZ);
+            }
+        }
+    }
+
+    private static void fill(ChunkAccess chunk, BiomeSource biomes, RandomState noise, long ageSeed,
+                             BlockState material,
+                             int centerX, int centerY, int centerZ, int radiusX, int radiusZ) {
+        int originX = chunk.getPos().getMinBlockX();
+        int originZ = chunk.getPos().getMinBlockZ();
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int localX = 0; localX < 16; localX++) {
+            int worldX = originX + localX;
+            double dx = (worldX - centerX) / (double) radiusX;
+            for (int localZ = 0; localZ < 16; localZ++) {
+                int worldZ = originZ + localZ;
+                double dz = (worldZ - centerZ) / (double) radiusZ;
+                double distance = dx * dx + dz * dz;
+                if (distance >= 1.0) continue;
+
+                // Coordinate noise keeps adjacent chunks seamless without sharing mutable RNG state.
+                long detail = mix(ageSeed ^ (long) centerX * 341873128712L
+                        ^ (long) centerZ * 132897987541L ^ (long) worldX * 42317861L
+                        ^ (long) worldZ * 374761393L);
+                int top = centerY + (int) Math.round(3 * (1 - distance)) + (int) Math.floorMod(detail, 3) - 1;
+                int depth = Math.max(1, (int) Math.round(3 + 17 * Math.pow(1 - distance, 1.5)));
+                var biome = biomes.getNoiseBiome(QuartPos.fromBlock(worldX), QuartPos.fromBlock(top),
+                        QuartPos.fromBlock(worldZ), noise.sampler());
+                BlockState base = material != null ? material
+                        : biome.is(BiomeTags.IS_NETHER) ? Blocks.NETHERRACK.defaultBlockState()
+                        : biome.is(BiomeTags.IS_END) ? Blocks.END_STONE.defaultBlockState()
+                        : Blocks.STONE.defaultBlockState();
+                BlockState soil = biome.is(BiomeTags.IS_NETHER) || biome.is(BiomeTags.IS_END)
+                        || biome.is(AgeBiomeSelection.CAVE_BIOMES) ? base : Blocks.DIRT.defaultBlockState();
+                BlockState cap = soil == base ? base : Blocks.GRASS_BLOCK.defaultBlockState();
+                for (int y = Math.max(top - depth, chunk.getMinBuildHeight()); y <= top; y++) {
+                    pos.set(worldX, y, worldZ);
+                    if (!chunk.getBlockState(pos).isAir()) continue;
+                    BlockState state = y == top ? cap : y >= top - 3 ? soil : base;
+                    chunk.setBlockState(pos, state, false);
+                    surface.update(localX, y, localZ, state);
+                    floor.update(localX, y, localZ, state);
+                }
+            }
+        }
+    }
+
+    private static RandomSource random(long ageSeed, int x, int z) {
+        return RandomSource.create(mix(ageSeed ^ SALT ^ (long) x * 341873128712L
+                ^ (long) z * 132897987541L));
+    }
+
+    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/ObelisksFeature.java

@@ -0,0 +1,95 @@
+package net.dnorberg.rivencraft.world;
+
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/** Rare one-chunk obelisk adapted from Legacy's 4x4 plinth and 2x12x2 shaft. */
+final class ObelisksFeature {
+    private static final long SALT = 0x4F42454C49534B53L;
+    private static final int CHANCE = 128;
+    private static final int BASE = 4;
+    private static final int HEIGHT = 12;
+
+    private ObelisksFeature() {}
+
+    record Site(int x, int z) {}
+
+    static Site site(long ageSeed, ChunkPos chunk, int occurrence) {
+        RandomSource random = RandomSource.create(mix(ageSeed ^ SALT
+                ^ (long) chunk.x * 341873128712L ^ (long) chunk.z * 132897987541L
+                ^ (long) occurrence * 0x9E3779B97F4A7C15L));
+        if (random.nextInt(CHANCE) != 0) return null;
+        return new Site(chunk.getMinBlockX() + 4 + random.nextInt(8),
+                chunk.getMinBlockZ() + 4 + random.nextInt(8));
+    }
+
+    static void generate(WorldGenLevel level, ChunkAccess chunk, long ageSeed,
+                         AgeFeatureSelection.Choice choice, int occurrence) {
+        Site site = site(ageSeed, chunk.getPos(), occurrence);
+        if (site == null || choice.material().isEmpty()) return;
+        BlockState material = BuiltInRegistries.BLOCK.get(choice.material().orElseThrow()).defaultBlockState();
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        int minSurface = Integer.MAX_VALUE;
+        int maxSurface = Integer.MIN_VALUE;
+        int[][] surface = new int[BASE][BASE];
+        for (int dx = 0; dx < BASE; dx++) {
+            for (int dz = 0; dz < BASE; dz++) {
+                int x = site.x() + dx;
+                int z = site.z() + dz;
+                int y = level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, x, z);
+                if (y <= level.getMinBuildHeight() + 1) return;
+                BlockState ground = level.getBlockState(pos.set(x, y - 1, z));
+                if (!ground.isFaceSturdy(level, pos, Direction.UP)
+                        || !ground.getFluidState().isEmpty() || ground.hasBlockEntity()) return;
+                surface[dx][dz] = y;
+                minSurface = Math.min(minSurface, y);
+                maxSurface = Math.max(maxSurface, y);
+            }
+        }
+        if (maxSurface - minSurface > 2 || maxSurface + HEIGHT >= level.getMaxBuildHeight()) return;
+        for (int dx = 0; dx < BASE; dx++) {
+            for (int dz = 0; dz < BASE; dz++) {
+                for (int y = surface[dx][dz]; y <= maxSurface; y++) {
+                    if (!open(level.getBlockState(pos.set(site.x() + dx, y, site.z() + dz)))) return;
+                }
+            }
+        }
+        for (int dx = 1; dx <= 2; dx++) {
+            for (int dz = 1; dz <= 2; dz++) {
+                for (int y = maxSurface + 1; y <= maxSurface + HEIGHT; y++) {
+                    if (!open(level.getBlockState(pos.set(site.x() + dx, y, site.z() + dz)))) return;
+                }
+            }
+        }
+        for (int dx = 0; dx < BASE; dx++) {
+            for (int dz = 0; dz < BASE; dz++) {
+                for (int y = surface[dx][dz]; y <= maxSurface; y++)
+                    level.setBlock(pos.set(site.x() + dx, y, site.z() + dz), material, 2);
+            }
+        }
+        for (int dx = 1; dx <= 2; dx++) {
+            for (int dz = 1; dz <= 2; dz++) {
+                for (int y = maxSurface + 1; y <= maxSurface + HEIGHT; y++)
+                    level.setBlock(pos.set(site.x() + dx, y, site.z() + dz), material, 2);
+            }
+        }
+    }
+
+    private static boolean open(BlockState state) {
+        return state.getFluidState().isEmpty() && (state.isAir() || state.canBeReplaced());
+    }
+
+    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/ObelisksGameTests.java

@@ -0,0 +1,110 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.List;
+import java.util.Optional;
+import net.dnorberg.rivencraft.Rivencraft;
+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.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Obelisks must retain ordered materials and generate a stable Legacy-sized shape. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class ObelisksGameTests {
+    private ObelisksGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void authoredObelisksKeepTheirMaterialAndTerrainRules(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        helper.assertTrue(PageItem.bundledCreativeSymbols().contains("feature/obelisks"),
+                "Obelisks must appear in the Creative and JEI symbol feed");
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(), page("terrain/standard"),
+                block("obsidian"), page("feature/obelisks"), page("feature/obelisks")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 56L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(56L), registries);
+        var choices = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(choices.size(), 2, "Repeated Obelisks pages must remain separate");
+        helper.assertValueEqual(choices.getFirst().material(),
+                Optional.of(ResourceLocation.withDefaultNamespace("obsidian")),
+                "A preceding Block page must set the first obelisk material");
+        helper.assertTrue(choices.getLast().material().isPresent()
+                        && AgeFeatureSelection.materialError(choices.getLast()) == null,
+                "An unmodified Obelisks page must choose a valid material");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                "Obelisk materials and order must survive Age-plan reload");
+        for (String terrain : List.of("standard", "amplified", "island", "flat"))
+            helper.assertTrue(AgeFeatureSelection.error(id("obelisks"),
+                    AgeRuntimeProfiles.resolve(id(terrain)), registries) == null,
+                    "Obelisks should be valid on exposed " + terrain + " terrain");
+        for (String terrain : List.of("void", "cave"))
+            helper.assertTrue(AgeFeatureSelection.error(id("obelisks"),
+                    AgeRuntimeProfiles.resolve(id(terrain)), registries) != null,
+                    "Obelisks must reject " + terrain + " terrain without an exposed surface");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void randomAgesOnlyChooseObelisksOnSupportedTerrain(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        boolean selected = false;
+        for (long seed = 0; seed < 128; seed++) {
+            selected |= AgeFeatureSelection.randomChoices(seed,
+                    AgeRuntimeProfiles.resolve(id("standard")), registries).stream()
+                    .anyMatch(choice -> AgeFeatureSelection.obelisks(choice.id()));
+            for (String terrain : List.of("void", "cave"))
+                helper.assertTrue(AgeFeatureSelection.randomChoices(seed,
+                                AgeRuntimeProfiles.resolve(id(terrain)), registries).stream()
+                                .noneMatch(choice -> AgeFeatureSelection.obelisks(choice.id())),
+                        "Random " + terrain + " Ages must not gain Obelisks");
+        }
+        helper.assertTrue(selected, "Random surface Ages should be able to select Obelisks");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void obeliskSitesAreSeededAndStayInsideTheirChunk(GameTestHelper helper) {
+        ChunkPos chunk = new ChunkPos(123, -45);
+        int selected = 0;
+        for (long seed = 0; seed < 2048; seed++) {
+            ObelisksFeature.Site site = ObelisksFeature.site(seed, chunk, 0);
+            helper.assertTrue(java.util.Objects.equals(ObelisksFeature.site(seed, chunk, 0), site),
+                    "An Age seed must reproduce the same obelisk site");
+            if (site == null) continue;
+            selected++;
+            helper.assertTrue(site.x() >= chunk.getMinBlockX() + 4
+                            && site.x() + 3 < chunk.getMaxBlockX(),
+                    "The full 4x4 plinth must remain inside its source chunk");
+            helper.assertTrue(site.z() >= chunk.getMinBlockZ() + 4
+                            && site.z() + 3 < chunk.getMaxBlockZ(),
+                    "The full 4x4 plinth must remain inside its source chunk");
+        }
+        helper.assertTrue(selected > 0 && selected < 64,
+                "The 1-in-128 roll should remain rare but reachable");
+        helper.succeed();
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private static WritingEntry page(String path) {
+        return WritingEntry.symbol(new SymbolReference(id(path)));
+    }
+
+    private static WritingEntry block(String path) {
+        return WritingEntry.symbol(new SymbolReference(net.dnorberg.rivencraft.writing.BlockSymbolPages.symbolId(
+                ResourceLocation.withDefaultNamespace(path))));
+    }
+}

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

@@ -0,0 +1,90 @@
+package net.dnorberg.rivencraft.world;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ * Subtractive Skylands terrain filter adapted from Mystcraft Legacy's
+ * SymbolSkylands (LGPL-3.0-or-later). Legacy keeps solid terrain above a
+ * seven-octave cutoff near Y=76 and discards liquid above that cutoff.
+ */
+final class SkylandsFeature {
+    private static final long SALT = 0x534B594C414E4453L;
+    private static final int BASE_CUTOFF = 76;
+    private static final BlockState AIR = Blocks.AIR.defaultBlockState();
+
+    private SkylandsFeature() {}
+
+    static void filter(ChunkAccess chunk, long ageSeed) {
+        int originX = chunk.getPos().getMinBlockX();
+        int originZ = chunk.getPos().getMinBlockZ();
+        int minY = chunk.getMinBuildHeight();
+        int maxY = chunk.getMaxBuildHeight();
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int localX = 0; localX < 16; localX++) {
+            for (int localZ = 0; localZ < 16; localZ++) {
+                int cutoff = cutoff(ageSeed, originX + localX, originZ + localZ);
+                for (int y = minY; y < maxY; y++) {
+                    pos.set(originX + localX, y, originZ + localZ);
+                    BlockState state = chunk.getBlockState(pos);
+                    if (!removes(state, y, cutoff)) continue;
+                    chunk.setBlockState(pos, AIR, false);
+                    surface.update(localX, y, localZ, AIR);
+                    floor.update(localX, y, localZ, AIR);
+                }
+            }
+        }
+    }
+
+    static boolean removes(BlockState state, int y, int cutoff) {
+        return !state.isAir() && (y <= cutoff || state.liquid());
+    }
+
+    static int cutoff(long ageSeed, int x, int z) {
+        double variation = 0.0D;
+        int cellSize = 128;
+        double amplitude = 12.0D;
+        for (int octave = 0; octave < 7; octave++) {
+            variation += valueNoise(ageSeed ^ SALT ^ (long) octave * 0x9E3779B97F4A7C15L,
+                    x, z, cellSize) * amplitude;
+            cellSize /= 2;
+            amplitude /= 2.0D;
+        }
+        return BASE_CUTOFF + (int) Math.round(variation);
+    }
+
+    private static double valueNoise(long seed, int x, int z, int cellSize) {
+        int cellX = Math.floorDiv(x, cellSize);
+        int cellZ = Math.floorDiv(z, cellSize);
+        double u = smooth((x - cellX * cellSize) / (double) cellSize);
+        double v = smooth((z - cellZ * cellSize) / (double) cellSize);
+        double north = lerp(value(seed, cellX, cellZ), value(seed, cellX + 1, cellZ), u);
+        double south = lerp(value(seed, cellX, cellZ + 1), value(seed, cellX + 1, cellZ + 1), u);
+        return lerp(north, south, v);
+    }
+
+    private static double value(long seed, int x, int z) {
+        long hash = mix(seed ^ (long) x * 0xD1B54A32D192ED03L
+                ^ (long) z * 0xABC98388FB8FAC03L);
+        return (hash >>> 11) * 0x1.0p-52 - 1.0D;
+    }
+
+    private static double smooth(double value) {
+        return value * value * (3.0D - 2.0D * value);
+    }
+
+    private static double lerp(double first, double second, double amount) {
+        return first + (second - first) * amount;
+    }
+
+    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/SkylandsFeatureGameTests.java

@@ -0,0 +1,31 @@
+package net.dnorberg.rivencraft.world;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.world.level.block.Blocks;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Checks the Legacy-style filter independently of a slow dimension-generation test. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class SkylandsFeatureGameTests {
+    private SkylandsFeatureGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void skylandsOnlyKeepsUpperSolidTerrain(GameTestHelper helper) {
+        int cutoff = SkylandsFeature.cutoff(707L, 32, -48);
+        helper.assertValueEqual(SkylandsFeature.cutoff(707L, 32, -48), cutoff,
+                "Skylands cutoff must be deterministic for an Age seed and world column");
+        helper.assertTrue(SkylandsFeature.removes(Blocks.STONE.defaultBlockState(), cutoff, cutoff),
+                "Solid terrain at the cutoff must be removed");
+        helper.assertFalse(SkylandsFeature.removes(Blocks.STONE.defaultBlockState(), cutoff + 1, cutoff),
+                "Solid terrain above the cutoff must remain");
+        helper.assertTrue(SkylandsFeature.removes(Blocks.WATER.defaultBlockState(), cutoff + 1, cutoff),
+                "Liquids above the cutoff must be removed");
+        helper.assertFalse(SkylandsFeature.removes(Blocks.AIR.defaultBlockState(), cutoff - 1, cutoff),
+                "Air must remain air");
+        helper.succeed();
+    }
+}

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

@@ -0,0 +1,127 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.Random;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ * Solid, wandering sphere nodes adapted from Mystcraft Legacy's MapGenSpheresMyst
+ * (Mystcraft contributors, LGPL-3.0-or-later, commit 9bc8ddc). NeoForge chunk
+ * writes and seed mixing are Rivencraft-specific.
+ */
+final class SpheresFeature {
+    private static final int SOURCE_RANGE = 8;
+    private static final long SALT = 0x53504845524553L;
+
+    private SpheresFeature() {}
+
+    static void generate(ChunkAccess chunk, long ageSeed, AgeFeatureSelection.Choice choice) {
+        BlockState material = choice.material()
+                .map(id -> BuiltInRegistries.BLOCK.get(id).defaultBlockState())
+                .orElse(Blocks.COBBLESTONE.defaultBlockState());
+        ChunkPos target = chunk.getPos();
+        Random master = new Random(ageSeed ^ SALT);
+        long xSeed = master.nextLong();
+        long zSeed = master.nextLong();
+        for (int sx = target.x - SOURCE_RANGE; sx <= target.x + SOURCE_RANGE; sx++) {
+            for (int sz = target.z - SOURCE_RANGE; sz <= target.z + SOURCE_RANGE; sz++) {
+                Random source = new Random((long) sx * xSeed ^ (long) sz * zSeed ^ ageSeed ^ SALT);
+                if (source.nextFloat() > 0.05F) continue;
+                double x = sx * 16 + source.nextInt(16);
+                double y = source.nextInt(source.nextInt(192) + 1) + 32;
+                double z = sz * 16 + source.nextInt(16);
+                trace(chunk, material, source.nextLong(), x, y, z,
+                        1.0F + source.nextFloat() * 4.0F, 0, 0, -1, -1);
+            }
+        }
+    }
+
+    private static void trace(ChunkAccess chunk, BlockState material, long seed,
+                              double x, double y, double z, float radius, float yaw, float pitch,
+                              int step, int length) {
+        Random random = new Random(seed);
+        if (length <= 0) {
+            int maximum = SOURCE_RANGE * 16 - 16;
+            length = maximum - random.nextInt(maximum / 4);
+        }
+        boolean singleNode = step == -1;
+        if (singleNode) step = length / 2;
+        int splitAt = random.nextInt(length / 2) + length / 4;
+        boolean slowPitch = random.nextInt(6) == 0;
+        float yawDrift = 0;
+        float pitchDrift = 0;
+        double middleX = chunk.getPos().getMinBlockX() + 8;
+        double middleZ = chunk.getPos().getMinBlockZ() + 8;
+        for (; step < length; step++) {
+            double nodeRadius = 1.5D + Math.sin(step * Math.PI / length) * radius;
+            float horizontal = Mth.cos(pitch);
+            x += Mth.cos(yaw) * horizontal;
+            y += Mth.sin(pitch);
+            z += Mth.sin(yaw) * horizontal;
+            pitch *= slowPitch ? 0.92F : 0.7F;
+            pitch += pitchDrift * 0.1F;
+            yaw += yawDrift * 0.1F;
+            pitchDrift = pitchDrift * 0.9F
+                    + (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F;
+            yawDrift = yawDrift * 0.75F
+                    + (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F;
+            if (!singleNode && step == splitAt && radius > 1.0F) {
+                trace(chunk, material, random.nextLong(), x, y, z,
+                        random.nextFloat() * 0.5F + 0.5F, yaw - Mth.HALF_PI, pitch / 3, step, length);
+                trace(chunk, material, random.nextLong(), x, y, z,
+                        random.nextFloat() * 0.5F + 0.5F, yaw + Mth.HALF_PI, pitch / 3, step, length);
+                return;
+            }
+            if (!singleNode && random.nextInt(4) == 0) continue;
+            double dx = x - middleX;
+            double dz = z - middleZ;
+            double remaining = length - step;
+            double reach = radius + 18;
+            if (dx * dx + dz * dz - remaining * remaining > reach * reach) return;
+            if (Math.abs(dx) <= 16 + nodeRadius * 2 && Math.abs(dz) <= 16 + nodeRadius * 2)
+                fillNode(chunk, material, x, y, z, nodeRadius);
+            if (singleNode) break;
+        }
+    }
+
+    private static void fillNode(ChunkAccess chunk, BlockState material,
+                                 double centerX, double centerY, double centerZ, double radius) {
+        int originX = chunk.getPos().getMinBlockX();
+        int originZ = chunk.getPos().getMinBlockZ();
+        int minX = Math.max(0, Mth.floor(centerX - radius) - originX - 1);
+        int maxX = Math.min(16, Mth.floor(centerX + radius) - originX + 2);
+        int minZ = Math.max(0, Mth.floor(centerZ - radius) - originZ - 1);
+        int maxZ = Math.min(16, Mth.floor(centerZ + radius) - originZ + 2);
+        int minY = Math.max(chunk.getMinBuildHeight() + 1, Mth.floor(centerY - radius) - 1);
+        int maxY = Math.min(chunk.getMaxBuildHeight(), Mth.floor(centerY + radius) + 2);
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int worldY = minY; worldY < maxY; worldY++) {
+            double dy = (worldY + 0.5D - centerY) / radius;
+            for (int localZ = minZ; localZ < maxZ; localZ++) {
+                double dz = (originZ + localZ + 0.5D - centerZ) / radius;
+                for (int localX = minX; localX < maxX; localX++) {
+                    double dx = (originX + localX + 0.5D - centerX) / radius;
+                    if (!insideSphere(dx, dy, dz)) continue;
+                    pos.set(originX + localX, worldY, originZ + localZ);
+                    if (chunk.getBlockState(pos).is(Blocks.BEDROCK)) continue;
+                    chunk.setBlockState(pos, material, false);
+                    surface.update(localX, worldY, localZ, material);
+                    floor.update(localX, worldY, localZ, material);
+                }
+            }
+        }
+    }
+
+    static boolean insideSphere(double dx, double dy, double dz) {
+        return dx * dx + dy * dy + dz * dz < 1.0D;
+    }
+}

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

@@ -0,0 +1,65 @@
+package net.dnorberg.rivencraft.world;
+
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ * Rare surface spikes adapted from Mystcraft Legacy's WorldGenSpikesAdv
+ * (Mystcraft contributors, LGPL-3.0-or-later, commit 9bc8ddc). The footprint
+ * is kept in one chunk to avoid generation-order seams.
+ */
+final class SpikesFeature {
+    private static final long SALT = 0x5350494B4553L;
+
+    private SpikesFeature() {}
+
+    static void generate(WorldGenLevel level, ChunkAccess chunk, long ageSeed,
+                         AgeFeatureSelection.Choice choice, int occurrence) {
+        int originX = chunk.getPos().getMinBlockX();
+        int originZ = chunk.getPos().getMinBlockZ();
+        RandomSource random = RandomSource.create(ageSeed ^ SALT
+                ^ (long) originX * 341873128712L ^ (long) originZ * 132897987541L
+                ^ (long) occurrence * 0x9E3779B97F4A7C15L);
+        if (random.nextInt(18) != 0) return;
+        BlockState material = choice.material()
+                .map(id -> BuiltInRegistries.BLOCK.get(id).defaultBlockState())
+                .orElse(Blocks.STONE.defaultBlockState());
+        // Keep the entire footprint in this chunk; neighboring decoration order
+        // must not decide whether a spike exists or cut it at a chunk border.
+        int x = originX + 4 + random.nextInt(8);
+        int z = originZ + 4 + random.nextInt(8);
+        int y = level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, x, z);
+        int height = 6 + random.nextInt(32);
+        int width = 1 + random.nextInt(4);
+        if (y < level.getMinBuildHeight() + 1 || y + height >= level.getMaxBuildHeight()) return;
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        if (!level.isEmptyBlock(pos.set(x, y, z))) return;
+        for (int px = x - width; px <= x + width; px++) {
+            for (int pz = z - width; pz <= z + width; pz++) {
+                if (!insideFootprint(px - x, pz - z, width)) continue;
+                if (!level.getBlockState(pos.set(px, y - 1, pz)).isSolid()) return;
+            }
+        }
+        for (int px = x - width; px <= x + width; px++) {
+            for (int pz = z - width; pz <= z + width; pz++) {
+                if (!insideFootprint(px - x, pz - z, width)) continue;
+                int top = y + 1 + random.nextInt(random.nextInt(height) + 1);
+                for (int py = y; py < top; py++) {
+                    pos.set(px, py, pz);
+                    if (level.isEmptyBlock(pos)) level.setBlock(pos, material, 2);
+                }
+            }
+        }
+    }
+
+    static boolean insideFootprint(int dx, int dz, int width) {
+        return dx * dx + dz * dz <= width * width + 1;
+    }
+}

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

@@ -0,0 +1,86 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ * Ports the footprint and carving of Mystcraft's WorldGenMystStarFissure.
+ * The original is LGPL-3.0, copyright XCompWiz and Mystcraft contributors.
+ */
+public final class StarFissureFeature {
+    private static final long SALT = 0x5354415246495353L;
+
+    private StarFissureFeature() {}
+
+    /** Legacy chooses a point 8–23 blocks inside/after the spawn chunk, then grows the rift along +Z. */
+    public static List<BlockPos> footprint(long ageSeed, BlockPos spawn) {
+        long chunkX = spawn.getX() >> 4;
+        long chunkZ = spawn.getZ() >> 4;
+        Random random = new Random(ageSeed ^ SALT ^ chunkX ^ (chunkZ << 32));
+        int originX = ((int) chunkX << 4) + random.nextInt(16) + 8;
+        int originZ = ((int) chunkZ << 4) + random.nextInt(16) + 8;
+        int length = random.nextInt(8) + 10;
+        int[][] intervals = new int[length][2];
+        List<BlockPos> columns = new ArrayList<>();
+        addRow(columns, originX, originZ, 0, 0, 0);
+        for (int row = 1; row < length; row++) {
+            int range = length + Math.min(row, length - row) + 1;
+            int right = (random.nextInt(range) - (range >> 1) + intervals[row - 1][1]) / 2;
+            int left = (random.nextInt(range) - (range >> 1) + intervals[row - 1][0]) / 2;
+            if (left > right) {
+                int swap = left;
+                left = right;
+                right = swap;
+            }
+            left = Math.min(left, intervals[row - 1][1]);
+            right = Math.max(right, intervals[row - 1][0]);
+            intervals[row][0] = left;
+            intervals[row][1] = right;
+            addRow(columns, originX, originZ, row, left, right);
+        }
+        return List.copyOf(columns);
+    }
+
+    private static void addRow(List<BlockPos> columns, int originX, int originZ, int row, int left, int right) {
+        for (int x = left; x <= right; x++) {
+            // Footprint is a 2D column map; this placeholder Y is never used
+            // for placement. generate() resolves the real floor from the level.
+            columns.add(new BlockPos(originX + x, 0, originZ + row * 2));
+            columns.add(new BlockPos(originX + x, 0, originZ + row * 2 + 1));
+        }
+    }
+
+    public static void generate(ServerLevel level, long ageSeed, BlockPos spawn, boolean caveTerrain) {
+        List<BlockPos> columns = footprint(ageSeed, spawn);
+        // Legacy's y=0 was its minimum build height. The equivalent in 1.21.1
+        // is the dimension's minimum Y, including the bedrock layer itself.
+        int floorY = level.getMinBuildHeight();
+        BlockPos.MutableBlockPos mutable = new BlockPos.MutableBlockPos();
+        for (BlockPos column : columns) {
+            int top = level.getHeight(Heightmap.Types.WORLD_SURFACE, column.getX(), column.getZ());
+            if (caveTerrain) {
+                // Cave terrain has a bedrock roof. Open the fissure into the
+                // cavern, but never punch through its upper boundary.
+                for (int y = Math.max(spawn.getY(), floorY + 1); y < top; y++) {
+                    if (level.getBlockState(mutable.set(column.getX(), y, column.getZ())).is(Blocks.BEDROCK)) {
+                        top = y;
+                        break;
+                    }
+                }
+            }
+            // Clear the full column first, including water. Place the portal
+            // last so an existing fluid cannot occupy its block during carving.
+            for (int y = floorY + 1; y < top; y++) {
+                level.setBlock(mutable.set(column.getX(), y, column.getZ()), Blocks.AIR.defaultBlockState(), 2);
+            }
+            level.setBlock(mutable.set(column.getX(), floorY, column.getZ()),
+                    ModBlocks.STAR_FISSURE.get().defaultBlockState(), 2);
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+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.registry.ModBlocks;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.minecraft.core.BlockPos;
+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;
+
+/** Pure selection and footprint checks; runtime carving is left to the in-game visual check. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class StarFissureGameTests {
+    private StarFissureGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void authoredFissureIsWritableAndSaved(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        helper.assertTrue(PageItem.bundledCreativeSymbols().contains("feature/star_fissures"),
+                "Star Fissures must appear in the creative and JEI page feed");
+        helper.assertTrue(PageItem.isUsableWriting(PageItem.createBundledCreativePage("feature/star_fissures")),
+                "The page must be usable in an authored book");
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                page("terrain/standard"), page("feature/star_fissures")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 58L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(58L), registries);
+        var resolved = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(resolved.size(), 1, "One authored fissure must remain one feature choice");
+        helper.assertValueEqual(resolved.getFirst().id(), AgeFeatureSelection.STAR_FISSURES,
+                "The authored feature must be a Star Fissure");
+        helper.assertTrue(resolved.getFirst().material().isEmpty(), "Star Fissures consume no material page");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), resolved,
+                "The feature must survive Age-plan save and load");
+        helper.assertTrue(ModBlocks.STAR_FISSURE.get().defaultBlockState() != null,
+                "The non-obtainable star portal block must be registered");
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "cave", "void"))
+            helper.assertTrue(AgeFeatureSelection.error(AgeFeatureSelection.STAR_FISSURES,
+                            AgeRuntimeProfiles.resolve(id(terrain)), registries) == null,
+                    "Legacy fissures can appear on " + terrain + " terrain");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void randomFissuresAndSpawnFootprintAreStable(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        int selected = 0;
+        for (long seed = 0; seed < 128; seed++) {
+            boolean standard = hasRandomFissure(seed, AgeGenerationProfiles.STANDARD, registries);
+            if (standard) selected++;
+            for (String terrain : List.of("cave", "void"))
+                helper.assertValueEqual(hasRandomFissure(seed, id(terrain), registries), standard,
+                        "Legacy small-feature selection must not depend on terrain");
+        }
+        helper.assertTrue(selected > 0 && selected < 128,
+                "The weighted Legacy grammar should select fissures in some, not all, random Ages");
+        BlockPos spawn = new BlockPos(0, 64, 0);
+        var footprint = StarFissureFeature.footprint(58L, spawn);
+        helper.assertValueEqual(footprint, StarFissureFeature.footprint(58L, spawn),
+                "The Age seed and spawn must reproduce the same fissure");
+        int minZ = footprint.stream().mapToInt(BlockPos::getZ).min().orElseThrow();
+        int maxZ = footprint.stream().mapToInt(BlockPos::getZ).max().orElseThrow();
+        helper.assertTrue(minZ >= 8 && minZ <= 23,
+                "Legacy starts 8–23 blocks past the spawn chunk's Z edge");
+        helper.assertTrue(maxZ - minZ + 1 >= 20 && maxZ - minZ + 1 <= 34,
+                "Legacy's rift spans 10–17 paired Z rows");
+        for (int z = minZ; z <= maxZ; z++) {
+            int row = z;
+            var xs = footprint.stream().filter(pos -> pos.getZ() == row)
+                    .mapToInt(BlockPos::getX).sorted().toArray();
+            helper.assertTrue(xs.length > 0, "Every Z row must contain portal tiles");
+            for (int i = 1; i < xs.length; i++)
+                helper.assertValueEqual(xs[i], xs[i - 1] + 1,
+                        "Each jagged Legacy row remains contiguous");
+        }
+        helper.succeed();
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private static boolean hasRandomFissure(long seed, ResourceLocation terrain,
+                                             net.minecraft.core.RegistryAccess registries) {
+        return AgeFeatureSelection.randomChoices(seed, AgeRuntimeProfiles.resolve(terrain), registries).stream()
+                .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES));
+    }
+
+    private static WritingEntry page(String path) {
+        return WritingEntry.symbol(new SymbolReference(id(path)));
+    }
+}

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

@@ -0,0 +1,150 @@
+package net.dnorberg.rivencraft.world;
+
+import java.util.Random;
+import net.dnorberg.rivencraft.book.AgeFeatureSelection;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.util.Mth;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.levelgen.Heightmap;
+
+/**
+ * Winding solid volumes adapted from Mystcraft Legacy's SymbolTendrils and
+ * MapGenCavesMyst (LGPL-3.0-or-later). Generation stays inside the target chunk,
+ * while source-chunk seeds make the same tendril meet seamlessly at its borders.
+ */
+final class TendrilFeature {
+    private static final long SALT = 0x54454E4452494C53L;
+    private static final int SOURCE_RANGE = 8;
+    private static final int SOURCE_RATE = 15;
+    private static final int SOURCE_SIZE = 18;
+
+    private TendrilFeature() {}
+
+    static void generate(ChunkAccess chunk, long ageSeed, AgeFeatureSelection.Choice choice) {
+        BlockState material = choice.material()
+                .map(id -> BuiltInRegistries.BLOCK.get(id).defaultBlockState())
+                .orElse(Blocks.OAK_LOG.defaultBlockState());
+        ChunkPos target = chunk.getPos();
+        Random master = new Random(ageSeed ^ SALT);
+        long xSeed = master.nextLong();
+        long zSeed = master.nextLong();
+        for (int sourceX = target.x - SOURCE_RANGE; sourceX <= target.x + SOURCE_RANGE; sourceX++) {
+            for (int sourceZ = target.z - SOURCE_RANGE; sourceZ <= target.z + SOURCE_RANGE; sourceZ++) {
+                Random source = new Random((long) sourceX * xSeed ^ (long) sourceZ * zSeed ^ ageSeed ^ SALT);
+                int nodes = source.nextInt(source.nextInt(source.nextInt(SOURCE_SIZE) + 1) + 1);
+                if (source.nextInt(SOURCE_RATE) != 0) continue;
+                for (int node = 0; node < nodes; node++) {
+                    double x = sourceX * 16 + source.nextInt(16);
+                    double y = source.nextInt(source.nextInt(120) + 8);
+                    double z = sourceZ * 16 + source.nextInt(16);
+                    int branches = 1;
+                    if (source.nextInt(4) == 0) {
+                        trace(chunk, material, source.nextLong(), x, y, z,
+                                1.0F + source.nextFloat() * 6.0F, 0.0F, 0.0F, -1, -1, 0.5D);
+                        branches += source.nextInt(4);
+                    }
+                    for (int branch = 0; branch < branches; branch++) {
+                        float yaw = source.nextFloat() * Mth.TWO_PI;
+                        float pitch = (source.nextFloat() - 0.5F) / 4.0F;
+                        float radius = source.nextFloat() * 2.0F + source.nextFloat();
+                        if (source.nextInt(10) == 0)
+                            radius *= source.nextFloat() * source.nextFloat() * 3.0F + 1.0F;
+                        trace(chunk, material, source.nextLong(), x, y, z,
+                                radius, yaw, pitch, 0, 0, 1.0D);
+                    }
+                }
+            }
+        }
+    }
+
+    private static void trace(ChunkAccess chunk, BlockState material, long seed,
+                              double x, double y, double z, float radius, float yaw, float pitch,
+                              int step, int length, double verticalScale) {
+        Random random = new Random(seed);
+        if (length <= 0) {
+            int maximum = SOURCE_RANGE * 16 - 16;
+            length = maximum - random.nextInt(maximum / 4);
+        }
+        boolean singleNode = step == -1;
+        if (singleNode) step = length / 2;
+        int splitAt = random.nextInt(length / 2) + length / 4;
+        boolean slowPitch = random.nextInt(6) == 0;
+        float yawDrift = 0.0F;
+        float pitchDrift = 0.0F;
+        double middleX = chunk.getPos().getMinBlockX() + 8;
+        double middleZ = chunk.getPos().getMinBlockZ() + 8;
+
+        for (; step < length; step++) {
+            double horizontalRadius = 1.5D + Math.sin(step * Math.PI / length) * radius;
+            double verticalRadius = horizontalRadius * verticalScale;
+            float horizontalMotion = Mth.cos(pitch);
+            x += Mth.cos(yaw) * horizontalMotion;
+            y += Mth.sin(pitch);
+            z += Mth.sin(yaw) * horizontalMotion;
+            pitch *= slowPitch ? 0.92F : 0.7F;
+            pitch += pitchDrift * 0.1F;
+            yaw += yawDrift * 0.1F;
+            pitchDrift = pitchDrift * 0.9F
+                    + (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 2.0F;
+            yawDrift = yawDrift * 0.75F
+                    + (random.nextFloat() - random.nextFloat()) * random.nextFloat() * 4.0F;
+
+            if (!singleNode && step == splitAt && radius > 1.0F) {
+                trace(chunk, material, random.nextLong(), x, y, z, random.nextFloat() * 0.5F + 0.5F,
+                        yaw - Mth.HALF_PI, pitch / 3.0F, step, length, 1.0D);
+                trace(chunk, material, random.nextLong(), x, y, z, random.nextFloat() * 0.5F + 0.5F,
+                        yaw + Mth.HALF_PI, pitch / 3.0F, step, length, 1.0D);
+                return;
+            }
+            if (!singleNode && random.nextInt(4) == 0) continue;
+            double distanceX = x - middleX;
+            double distanceZ = z - middleZ;
+            double remaining = length - step;
+            double reach = radius + 18.0D;
+            if (distanceX * distanceX + distanceZ * distanceZ - remaining * remaining > reach * reach)
+                return;
+            if (x >= middleX - 16.0D - horizontalRadius * 2.0D
+                    && x <= middleX + 16.0D + horizontalRadius * 2.0D
+                    && z >= middleZ - 16.0D - horizontalRadius * 2.0D
+                    && z <= middleZ + 16.0D + horizontalRadius * 2.0D) {
+                fillNode(chunk, material, x, y, z, horizontalRadius, verticalRadius);
+            }
+            if (singleNode) break;
+        }
+    }
+
+    private static void fillNode(ChunkAccess chunk, BlockState material, double centerX, double centerY,
+                                 double centerZ, double horizontalRadius, double verticalRadius) {
+        int originX = chunk.getPos().getMinBlockX();
+        int originZ = chunk.getPos().getMinBlockZ();
+        int minX = Math.max(0, Mth.floor(centerX - horizontalRadius) - originX - 1);
+        int maxX = Math.min(16, Mth.floor(centerX + horizontalRadius) - originX + 2);
+        int minZ = Math.max(0, Mth.floor(centerZ - horizontalRadius) - originZ - 1);
+        int maxZ = Math.min(16, Mth.floor(centerZ + horizontalRadius) - originZ + 2);
+        int minY = Math.max(chunk.getMinBuildHeight() + 1, Mth.floor(centerY - verticalRadius) - 1);
+        int maxY = Math.min(chunk.getMaxBuildHeight(), Mth.floor(centerY + verticalRadius) + 2);
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        BlockPos.MutableBlockPos pos = new BlockPos.MutableBlockPos();
+        for (int worldY = minY; worldY < maxY; worldY++) {
+            double dy = (worldY + 0.5D - centerY) / verticalRadius;
+            if (dy <= -0.7D || dy * dy >= 1.0D) continue;
+            for (int localZ = minZ; localZ < maxZ; localZ++) {
+                double dz = (originZ + localZ + 0.5D - centerZ) / horizontalRadius;
+                for (int localX = minX; localX < maxX; localX++) {
+                    double dx = (originX + localX + 0.5D - centerX) / horizontalRadius;
+                    if (dx * dx + dy * dy + dz * dz >= 1.0D) continue;
+                    pos.set(originX + localX, worldY, originZ + localZ);
+                    if (chunk.getBlockState(pos).is(Blocks.BEDROCK)) continue;
+                    chunk.setBlockState(pos, material, false);
+                    surface.update(localX, worldY, localZ, material);
+                    floor.update(localX, worldY, localZ, material);
+                }
+            }
+        }
+    }
+}

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

@@ -6,14 +6,27 @@ import java.util.Optional;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.resources.ResourceLocation;
 
-/** Built-in fallback pages for registered vanilla biomes without hand-authored symbol JSON. */
+/** Registry-derived pages for biomes without hand-authored symbol JSON. */
 public final class BiomeSymbolPages {
     private static final ResourceLocation CATEGORY = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome");
 
     private BiomeSymbolPages() { }
 
     public static ResourceLocation symbolId(ResourceLocation biomeId) {
-        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome/" + biomeId.getPath());
+        // Preserve old vanilla page IDs, while keeping modded namespaces distinct.
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome/"
+                + (biomeId.getNamespace().equals("minecraft") ? "" : biomeId.getNamespace() + "/")
+                + biomeId.getPath());
+    }
+
+    public static ResourceLocation biomeId(ResourceLocation symbolId) {
+        String path = symbolId.getPath();
+        if (!symbolId.getNamespace().equals(Rivencraft.MOD_ID) || !path.startsWith("biome/"))
+            throw new IllegalArgumentException("Not a biome symbol: " + symbolId);
+        path = path.substring("biome/".length());
+        int separator = path.indexOf('/');
+        return separator < 0 ? ResourceLocation.withDefaultNamespace(path)
+                : ResourceLocation.fromNamespaceAndPath(path.substring(0, separator), path.substring(separator + 1));
     }
 
     public static SymbolDefinition definition(ResourceLocation biomeId) {
@@ -24,8 +37,11 @@ public final class BiomeSymbolPages {
                 .map(part -> part.substring(0, 1).toUpperCase(Locale.ROOT) + part.substring(1))
                 .reduce("", String::concat);
         if (glyphWord.isEmpty()) glyphWord = "World";
+        if (glyphWord.length() > 48) glyphWord = glyphWord.substring(0, 48);
         return new SymbolDefinition(SymbolDefinition.CURRENT_SCHEMA_VERSION,
-                "symbol.rivencraft.biome." + path,
+                biomeId.getNamespace().equals("minecraft")
+                        ? "symbol.rivencraft.biome." + path
+                        : "biome." + biomeId.getNamespace() + "." + path.replace('/', '.'),
                 "symbol.rivencraft.biome.generated.description",
                 CATEGORY,
                 Optional.of(new SymbolSemantics(SymbolSemantics.Role.BIOME,
@@ -35,9 +51,14 @@ public final class BiomeSymbolPages {
 
     public static String fallbackName(ResourceLocation symbolId) {
         String path = symbolId.getPath().substring("biome/".length());
-        return Arrays.stream(path.split("_"))
+        int separator = path.indexOf('/');
+        String namespace = separator < 0 ? "" : path.substring(0, separator);
+        if (separator >= 0) path = path.substring(separator + 1);
+        String label = path.replace('/', '_');
+        String name = Arrays.stream(label.split("_"))
                 .filter(part -> !part.isEmpty())
                 .map(part -> part.substring(0, 1).toUpperCase(Locale.ROOT) + part.substring(1))
                 .reduce((left, right) -> left + " " + right).orElse("Unknown") + " Biome";
+        return namespace.isEmpty() ? name : name + " (" + namespace + ")";
     }
 }

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

@@ -0,0 +1,97 @@
+package net.dnorberg.rivencraft.writing;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Optional;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.EmptyBlockGetter;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.EntityBlock;
+import net.minecraft.world.level.block.state.BlockState;
+
+/** Registry-derived material pages; binding validates the material for its consumer. */
+public final class BlockSymbolPages {
+    public static final ResourceLocation CATEGORY = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "block");
+    public static final ResourceLocation FLUID_CATEGORY = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "fluid");
+
+    private BlockSymbolPages() {}
+
+    public static ResourceLocation symbolId(ResourceLocation blockId) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID,
+                "block/" + blockId.getNamespace() + "/" + blockId.getPath());
+    }
+
+    public static ResourceLocation blockId(ResourceLocation symbolId) {
+        String path = symbolId.getPath();
+        if (!path.startsWith("block/")) return null;
+        String rest = path.substring("block/".length());
+        int separator = rest.indexOf('/');
+        return separator < 1 ? null : ResourceLocation.tryParse(
+                rest.substring(0, separator) + ":" + rest.substring(separator + 1));
+    }
+
+    public static java.util.List<ResourceLocation> availableBlocks() {
+        return BuiltInRegistries.BLOCK.keySet().stream()
+                .filter(id -> isRockMaterial(BuiltInRegistries.BLOCK.get(id))
+                        || isFluidMaterial(BuiltInRegistries.BLOCK.get(id)))
+                .sorted().toList();
+    }
+
+    public static java.util.List<ResourceLocation> availableBlocks(ResourceLocation category) {
+        if (!category.equals(CATEGORY) && !category.equals(FLUID_CATEGORY)) return java.util.List.of();
+        return availableBlocks().stream().filter(id -> category(id).equals(category)).toList();
+    }
+
+    public static ResourceLocation category(ResourceLocation blockId) {
+        return isFluidMaterial(BuiltInRegistries.BLOCK.get(blockId)) ? FLUID_CATEGORY : CATEGORY;
+    }
+
+    public static boolean isRockMaterial(Block block) {
+        if (excluded(block)) return false;
+        BlockState state = block.defaultBlockState();
+        return state.getFluidState().isEmpty()
+                && state.isCollisionShapeFullBlock(EmptyBlockGetter.INSTANCE, BlockPos.ZERO);
+    }
+
+    public static boolean isFluidMaterial(Block block) {
+        if (excluded(block)) return false;
+        var fluid = block.defaultBlockState().getFluidState();
+        // A waterlogged coral or seagrass block contains water, but is not a fluid block.
+        return fluid.isSource() && fluid.createLegacyBlock().getBlock() == block;
+    }
+
+    private static boolean excluded(Block block) {
+        return block == Blocks.AIR || block == Blocks.CAVE_AIR || block == Blocks.VOID_AIR
+                || block instanceof EntityBlock || block.defaultBlockState().hasBlockEntity();
+    }
+
+    public static SymbolDefinition definition(ResourceLocation blockId) {
+        String path = blockId.getPath().replace('/', '_');
+        String word = Arrays.stream(path.split("_"))
+                .map(part -> part.replaceAll("[^A-Za-z]", ""))
+                .filter(part -> !part.isEmpty())
+                .map(part -> part.substring(0, 1).toUpperCase(Locale.ROOT) + part.substring(1))
+                .reduce("", String::concat);
+        if (word.isEmpty()) word = "Stone";
+        // A modded registry path can be arbitrarily long; poems have a bounded codec.
+        if (word.length() > 48) word = word.substring(0, 48);
+        return new SymbolDefinition(SymbolDefinition.CURRENT_SCHEMA_VERSION,
+                "block." + blockId.getNamespace() + "." + path,
+                "symbol.rivencraft.block.generated.description", category(blockId),
+                Optional.of(new SymbolSemantics(SymbolSemantics.Role.BLOCK,
+                        new SymbolSemantics.ResourceValue(blockId))),
+                "Modifier Constraint " + word + " Form");
+    }
+
+    public static String fallbackName(ResourceLocation blockId) {
+        return Arrays.stream(blockId.getPath().replace('/', '_').split("_"))
+                .filter(part -> !part.isEmpty())
+                .map(part -> part.substring(0, 1).toUpperCase(Locale.ROOT) + part.substring(1))
+                .reduce((left, right) -> left + " " + right).orElse("Unknown")
+                + (category(blockId).equals(FLUID_CATEGORY) ? " Fluid" : " Material");
+    }
+}