Organize creative pages and stabilize GameTests

BUILDING.txt

@@ -75,9 +75,9 @@ All required GameTests should pass before distributing a build.
 
 GameTests use `build/gametest-run/world`, separate from the normal development
 world. Gradle starts each default run with a fresh world and removes it after
-a successful run. Failed worlds are retained under
+every run, whether tests pass or fail. The GameTest server always uses seed `0`,
-`build/gametest-run/failed-worlds/` for inspection until the next successful
+so retries regenerate a clean world with that seed. Logs and configuration are kept.
-run. Logs and configuration are kept. A caller-supplied `-PgameTestRunDir`
+A caller-supplied `-PgameTestRunDir`
 is never removed automatically.
 
 To run the suite in a fresh temporary directory instead, use:

README.md

@@ -77,6 +77,11 @@ larger ordered collection of Pages between desks and the binder.
 
 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`.
@@ -96,7 +101,8 @@ Panel, it describes a randomly generated Age. Authored writing is compiled once
 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; other symbol effects are scheduled for later Milestone 5 slices. The
+profile. Built-in pages cover Standard, Amplified, Cave, Island, Flat, and Void;
+other 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()
@@ -38,6 +38,35 @@ sourceSets.main.resources {
     exclude("src/generated/**/.cache") // datagen cache files
 }
 
+// Generate the client-safe creative-page index from bundled symbol definitions.
+// New built-in symbols then appear in the Pages tab without another Java list.
+abstract class GenerateCreativeSymbolIndex extends DefaultTask {
+    @InputDirectory abstract DirectoryProperty getSymbolsDir()
+    @OutputDirectory abstract DirectoryProperty getIndexDir()
+
+    @TaskAction void generate() {
+        File root = symbolsDir.get().asFile
+        def definitions = new LinkedHashMap<String, Object>()
+        java.nio.file.Files.walk(root.toPath()).withCloseable { paths ->
+            paths.filter { java.nio.file.Files.isRegularFile(it) && it.toString().endsWith('.json') }
+                    .sorted().forEach { source ->
+                        String path = root.toPath().relativize(source).toString()
+                                .replace('\\', '/').replaceAll(/\.json$/, '')
+                        definitions["rivencraft:${path}"] = new groovy.json.JsonSlurper().parse(source.toFile())
+                    }
+        }
+        File index = new File(indexDir.get().asFile, 'assets/rivencraft/creative_symbol_pages.json')
+        index.parentFile.mkdirs()
+        index.text = groovy.json.JsonOutput.prettyPrint(groovy.json.JsonOutput.toJson(definitions)) + '\n'
+    }
+}
+
+def generateCreativeSymbolIndex = tasks.register('generateCreativeSymbolIndex', GenerateCreativeSymbolIndex) {
+    symbolsDir.set(layout.projectDirectory.dir('src/main/resources/data/rivencraft/rivencraft/symbols'))
+    indexDir.set(layout.buildDirectory.dir('generated/resources/creativeSymbols'))
+}
+sourceSets.main.resources.srcDir generateCreativeSymbolIndex
+
 // Archived suites use separate namespaces but share the same empty structure.
 tasks.named('processResources', ProcessResources).configure {
     archivedGameTestSuites.each { suite ->
@@ -148,67 +177,38 @@ neoForge {
     }
 }
 
-// Every default run gets a fresh world. Failed worlds stay available until a
+// Vanilla's GameTestServer uses a fixed world seed of 0. Every default run
-// successful run; caller-supplied directories are never managed here.
+// regenerates its world; custom run directories are never managed here.
 boolean customGameTestRunDir = providers.gradleProperty('gameTestRunDir').isPresent()
 File dedicatedGameTestBuildDir = layout.buildDirectory.get().asFile
 File dedicatedGameTestDir = layout.buildDirectory.dir('gametest-run').get().asFile
-File dedicatedGameTestWorld = new File(dedicatedGameTestDir, 'world')
-File gameTestSuccessMarker = new File(dedicatedGameTestDir, '.last-gametest-succeeded')
 def prepareGameTestWorld = tasks.register('prepareGameTestWorld') {
     onlyIf { !customGameTestRunDir }
     doLast {
-        java.nio.file.Files.deleteIfExists(gameTestSuccessMarker.toPath())
+        GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
-        File preserved = GameTestWorlds.preserve(dedicatedGameTestBuildDir, dedicatedGameTestDir)
-        if (preserved != null) logger.lifecycle('Preserved GameTest world for inspection at {}', preserved)
     }
 }
 def finishGameTestWorld = tasks.register('finishGameTestWorld') {
     onlyIf { !customGameTestRunDir }
     doLast {
-        if (gameTestSuccessMarker.exists()) {
+        GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
-            GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
-            java.nio.file.Files.delete(gameTestSuccessMarker.toPath())
-        } else {
-            File preserved = GameTestWorlds.preserve(dedicatedGameTestBuildDir, dedicatedGameTestDir)
-            if (preserved != null) logger.lifecycle('Preserved GameTest world for inspection at {}', preserved)
-        }
     }
 }
 tasks.named('runGameTestServer').configure {
     dependsOn(prepareGameTestWorld)
     finalizedBy(finishGameTestWorld)
-    doLast {
-        if (!customGameTestRunDir) {
-            GameTestWorlds.check(dedicatedGameTestBuildDir, dedicatedGameTestDir)
-            java.nio.file.Files.createFile(gameTestSuccessMarker.toPath())
-        }
-    }
 }
 
 class GameTestWorlds {
     static void check(File buildDir, File runDir) {
-        [buildDir, runDir, new File(runDir, 'world'), new File(runDir, 'failed-worlds')].each { path ->
+        [buildDir, runDir, new File(runDir, 'world'), new File(runDir, 'failed-worlds'),
+         new File(runDir, 'failed-seed.txt'), new File(runDir, '.last-gametest-succeeded')].each { path ->
             if (java.nio.file.Files.isSymbolicLink(path.toPath())) {
                 throw new GradleException("Refusing to manage a symlinked GameTest path: ${path}")
             }
         }
     }
 
-    static File preserve(File buildDir, File runDir) {
-        File world = new File(runDir, 'world')
-        if (!world.exists()) return null
-        check(buildDir, runDir)
-        if (!world.isDirectory()) throw new GradleException("Expected a GameTest world directory: ${world}")
-        File failures = new File(runDir, 'failed-worlds')
-        java.nio.file.Files.createDirectories(failures.toPath())
-        String snapshot = java.time.format.DateTimeFormatter.ofPattern('yyyyMMdd-HHmmss-SSS')
-                .format(java.time.LocalDateTime.now()) + '-' + java.util.UUID.randomUUID()
-        File destination = new File(failures, snapshot)
-        java.nio.file.Files.move(world.toPath(), destination.toPath())
-        return destination
-    }
-
     static void clean(File buildDir, File runDir) {
         check(buildDir, runDir)
         [new File(runDir, 'world'), new File(runDir, 'failed-worlds')].each { root ->
@@ -220,6 +220,8 @@ class GameTestWorlds {
                 }
             }
         }
+        java.nio.file.Files.deleteIfExists(new File(runDir, 'failed-seed.txt').toPath())
+        java.nio.file.Files.deleteIfExists(new File(runDir, '.last-gametest-succeeded').toPath())
     }
 }
 

docs/AGE_PROFILES.md

@@ -30,15 +30,98 @@ resources and can be overridden by a higher-priority pack. The example under
 directory. Valid custom profiles join the stable, sorted pool used when a new
 Age rolls its base terrain; the selected ID is then persisted with that Age.
 
+Each built-in profile now has a matching `terrain/<name>` Symbol Page. Put one
+of those pages after the Link Panel in a Book Binder to select that terrain
+instead of the seed-selected random profile. Standard, Amplified, and Cave use
+their corresponding registered noise settings; Island uses Minecraft's
+floating-islands noise settings; Flat and Void use flat-source generators.
+The Cave and Island pages are Rivencraft terrain choices based on existing
+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.
+
+## Written biome selection (generation version 16)
+
+Biome pages follow the terrain page and precede the distribution-control page
+in the Binder. Bundled controls are Native, Single, Tiled, Grid, and Tiny through
+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 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 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.
+
+Standard, Amplified, and Sky Island terrain fill from the vanilla Overworld
+biome preset, including its underground Lush Caves, Dripstone Caves, and Deep
+Dark biomes. Standard terrain therefore keeps Overworld-style cave generation,
+and cave biome pages can also be written explicitly. Sky islands can use an
+explicitly authored End biome page.
+Cave terrain fills only from `#rivencraft:cave_biomes` (Lush Caves, Dripstone
+Caves, and Deep Dark by default); explicitly authored Nether biome pages are
+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.
+
+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
+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,
-and rolled traits. `/reload` replaces the profile definitions but does not
+and rolled traits. For an **authored** Age, the generation plan also stores a
-reroll those immutable values. An unloaded Age resolves its stored profile
+copy of the resolved runtime profile: terrain shape, noise settings, biome
-again when it loads, so intentional profile overrides affect its runtime
+preset, and dimension type. `/reload` cannot reinterpret that plan; an unloaded
-resources and newly generated chunks.
+authored Age uses the saved profile snapshot when it loads, even if the defining
+symbol or profile JSON has since changed. An older, page-free Age has no plan
+and continues to resolve its saved profile ID at load time.
 
-A profile removed after an Age was created resolves to `rivencraft:standard`.
+Registered noise, biome-preset, and dimension-type IDs are validated when
+profiles load. Before loading an authored Age, the saved references are checked
+again. If a data pack supplying one has been removed, the dimension stays
+unloaded and the log identifies the missing resource; the Age's plan is not
+silently replaced. Restore the pack to load that Age. A custom dimension type
+retains its own skylight capability: normal lighting cannot make a Nether-style
+type skylit.
+
+A profile removed after a page-free Age was created resolves to `rivencraft:standard`.
 The legacy `rivencraft:random_vanilla` alias also resolves to `standard`.
 Rivencraft logs this fallback. Invalid built-in overrides do not replace the
 required built-in definitions; a reload fails if a required built-in profile

docs/GAMETESTS.md

@@ -1,15 +1,14 @@
 # GameTest suites
 
-The default dedicated-server run is a small smoke suite: 19 Rivencraft tests
+The default dedicated-server run is a small smoke suite: 23 Rivencraft tests
 cover core linking, deterministic Age definition, writing persistence, legacy
 data migration, workstation transactions, and forged/replayed menu actions.
-NeoForge currently adds two of its own tests, so the runner reports 21.
 
 ```shell
 ./gradlew runGameTestServer
 ```
 
-The remaining 49 Rivencraft tests are archived, not deleted. They cover
+The remaining 58 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
@@ -20,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
+Available suite names are `linking`, `environment`, `writing`, `grammar`, `desk`,
-`recipe`. Run all 68 Rivencraft tests (70 including NeoForge's two) before a
+`binder`, `mixer`, and `recipe`. Run all 81 Rivencraft tests before a
 release or after broad cross-system changes:
 
 ```shell
@@ -34,12 +33,32 @@ Immersive Portals. The core suite delegates to the original regression methods
 for its selected cases, so the two suites do not maintain duplicate test logic.
 
 GameTest Ages are created in `build/gametest-run/world`, not in a development
-client save. Every default GameTest invocation starts with a fresh world. If
+client save. Every default GameTest invocation starts with a fresh world.
-tests fail, Gradle moves the world under `build/gametest-run/failed-worlds/`
+Minecraft 1.21.1's GameTest server uses the fixed seed `0`. Gradle deletes the
-for inspection. A retry starts fresh but keeps those failed worlds; the next
+world after every run, whether tests pass or fail. A forcibly killed run may
-successful run removes them and its own world. A forcibly killed run may leave
+leave `world` behind; the next run deletes it before starting.
-`world` behind; the next run preserves it as a failure snapshot before starting.
 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.
+
+## 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.

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,
+Rivencraft ships a catalog covering terrain, biomes, lighting, weather,
-celestial behavior, and features. Its v2 semantics prepare for the full
+sky, celestial behavior, and features. The parser and compiler apply supported
-Legacy-inspired grammar; writing still uses random Age fallback until the
+schema-v2 pages to newly created Ages; omitted branches retain seeded defaults.
-parser and compiler are implemented.
 
 ## 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
+metadata. Page-free books continue to use random Age generation.
-saved symbols are informational only: Age creation uses the existing random
-fallback and does not apply them to 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,8 +4,10 @@
 
 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. 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, two for Tiled/Grid, and three for 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 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.
 
-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. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON. 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 replaces the random terrain selection; an omitted terrain uses the seed-selected profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages now affect new Ages; feature effects remain issue #35 work, and instability remains Milestone 6 work.
+
+The 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. Link Pages have a separate tab. Blank Pages appear in neither the creative tabs nor JEI's ingredient list. The server catalog still decides whether a page is valid for writing. External server data-pack symbols are not included in this bundled index.

gradle.properties

@@ -36,7 +36,7 @@ mod_name=Rivencraft
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=LGPL-3.0-or-later
 # The mod version. Rivencraft uses the x.y.z.b policy documented in README.md.
-mod_version=0.4.3.0
+mod_version=0.4.6.2
 immersive_portals_version=6.0.7
 # 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.

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

@@ -10,6 +10,7 @@ import net.dnorberg.rivencraft.registry.ModSounds;
 import net.dnorberg.rivencraft.registry.ModBlocks;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
 import net.dnorberg.rivencraft.registry.ModBiomeSources;
+import net.dnorberg.rivencraft.registry.ModChunkGenerators;
 import net.dnorberg.rivencraft.event.BookStandConversionHandler;
 import net.dnorberg.rivencraft.event.AgeCelestialAngleSync;
 import net.dnorberg.rivencraft.event.AgeLifecycleEvents;
@@ -40,6 +41,7 @@ public final class Rivencraft {
         modEventBus.addListener(ModNetworking::register);
         ModDataComponents.register(modEventBus);
         ModBiomeSources.register(modEventBus);
+        ModChunkGenerators.register(modEventBus);
         ModBlocks.register(modEventBus);
         ModBlockEntities.register(modEventBus);
         ModItems.register(modEventBus);

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

@@ -21,6 +21,10 @@ import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.HolderLookup;
 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.minecraft.core.component.DataComponents;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.network.chat.Component;
@@ -116,7 +120,12 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
         OrderedWriting writing = currentWriting();
         if (!writingGrammar().canCreate()) return false;
         try {
-            AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD);
+            if (level instanceof ServerLevel serverLevel) {
+                AgeRegistrySavedData.validateNewWriting(serverLevel, title, writing);
+            } else {
+                AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD,
+                        net.dnorberg.rivencraft.book.AgeTraits.select(0L), level.registryAccess());
+            }
             return true;
         } catch (IllegalArgumentException exception) {
             return false;
@@ -126,15 +135,40 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
     public WritingGrammar.Result writingGrammar() {
         WritingGrammar.Result parsed = WritingGrammar.parse(currentWriting());
         if (!parsed.canCreate()) return parsed;
+        List<WritingGrammar.Diagnostic> diagnostics = new ArrayList<>(parsed.diagnostics());
         var terrain = parsed.symbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                 .findFirst();
-        if (terrain.isEmpty()) return parsed;
+        if (terrain.isPresent()) {
-        var profile = ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id();
+            var profileId = ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id();
-        if (AgeRuntimeProfiles.profiles().containsKey(profile)) return parsed;
+            if (!AgeRuntimeProfiles.profiles().containsKey(profileId)) {
-        List<WritingGrammar.Diagnostic> diagnostics = new ArrayList<>(parsed.diagnostics());
+                diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNSUPPORTED_PROFILE,
-        diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNSUPPORTED_PROFILE,
+                        terrain.orElseThrow().index(), "Restore the Age profile " + profileId + " or remove this page"));
-                terrain.orElseThrow().index(), "Restore the Age profile " + profile + " or remove this page"));
+            }
+        }
+        if (level != null) {
+            var biomes = level.registryAccess().lookupOrThrow(Registries.BIOME);
+            var selectedProfile = terrain.isPresent()
+                    ? ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id()
+                    : level instanceof ServerLevel serverLevel
+                    ? AgeRegistrySavedData.previewGenerationProfile(serverLevel, title)
+                    : AgeGenerationProfiles.STANDARD;
+            var runtimeProfile = AgeRuntimeProfiles.profiles().get(selectedProfile);
+            boolean cave = runtimeProfile != null && AgeBiomeSelection.isCave(runtimeProfile);
+            parsed.symbols().stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.BIOME)
+                    .forEach(symbol -> {
+                        var id = ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id();
+                        var holder = biomes.get(ResourceKey.create(Registries.BIOME, id));
+                        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)) {
+                            diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNSUPPORTED_BIOME,
+                                    symbol.index(), "Cave Ages require cave or Nether biomes; remove " + id));
+                        }
+                    });
+        }
         return new WritingGrammar.Result(parsed.symbols(), diagnostics);
     }
 

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

@@ -0,0 +1,134 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Random;
+import java.util.Set;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.core.Holder;
+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.tags.BiomeTags;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.MultiNoiseBiomeSource;
+import net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList;
+
+/** Frozen biome pool and controller for an authored Age. Repeated IDs are intentional weights. */
+public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<ResourceLocation> biomes) {
+    public static final TagKey<Biome> CAVE_BIOMES = TagKey.create(Registries.BIOME,
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "cave_biomes"));
+
+    public AgeBiomeSelection {
+        if (distribution == null) throw new IllegalArgumentException("Missing biome distribution");
+        biomes = List.copyOf(biomes);
+        if (biomes.isEmpty()) throw new IllegalArgumentException("An Age biome pool cannot be empty");
+    }
+
+    public static AgeBiomeSelection compile(WritingGrammar.Result writing, AgeTraits traits,
+                                             AgeRuntimeProfile profile, long seed, RegistryAccess registries) {
+        List<ResourceLocation> authored = writing.symbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.BIOME)
+                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
+        var controller = writing.symbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.BIOME_CONTROLLER)
+                .map(symbol -> ((SymbolSemantics.ChoiceValue) symbol.semantics().value()).id())
+                .findFirst();
+        AgeTraits.BiomeDistribution distribution = controller
+                .map(value -> AgeTraits.BiomeDistribution.valueOf(value.toUpperCase(java.util.Locale.ROOT)))
+                .orElse(traits.biomeDistribution());
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID && controller.isEmpty() && authored.isEmpty()) {
+            distribution = AgeTraits.BiomeDistribution.SINGLE;
+        }
+        if (controller.isEmpty() && !authored.isEmpty()) {
+            if (distribution == AgeTraits.BiomeDistribution.NATIVE
+                    || (distribution == AgeTraits.BiomeDistribution.SINGLE && authored.size() > 1)) {
+                distribution = authored.size() == 1 ? AgeTraits.BiomeDistribution.SINGLE
+                        : authored.size() == 2 ? AgeTraits.BiomeDistribution.TILED
+                        : AgeTraits.BiomeDistribution.MEDIUM;
+            }
+        }
+        var registry = registries.lookupOrThrow(Registries.BIOME);
+        boolean cave = isCave(profile);
+        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)) {
+                throw new IllegalArgumentException("Biome " + id
+                        + " is not a cave or Nether biome; use #rivencraft:cave_biomes or #minecraft:is_nether");
+            }
+        }
+        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")) : availableBiomes);
+        }
+        List<ResourceLocation> selected = new ArrayList<>(authored);
+        Set<ResourceLocation> distinct = new LinkedHashSet<>(selected);
+        int minimum = minimum(distribution);
+        int target = minimum;
+        if (authored.isEmpty()) {
+            // The terrain's available pool is the upper bound. For Cave terrain,
+            // eligible() returns the cave tag; other terrains use their preset.
+            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<>(availableBiomes);
+        java.util.Collections.shuffle(filler, new Random(seed ^ 0x42494F4D45504F4FL));
+        for (ResourceLocation id : filler) {
+            if (distinct.size() >= target) break;
+            if (distinct.add(id)) selected.add(id);
+        }
+        if (distinct.size() < minimum) {
+            throw new IllegalArgumentException(distribution + " requires " + minimum
+                    + " distinct biomes; supply more biome pages for this terrain");
+        }
+        return new AgeBiomeSelection(distribution, selected);
+    }
+
+    public static List<ResourceLocation> eligible(RegistryAccess registries, AgeRuntimeProfile profile) {
+        var registry = registries.lookupOrThrow(Registries.BIOME);
+        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")
+                    .stream().map(ResourceLocation::parse)
+                    .filter(id -> registry.get(ResourceKey.create(Registries.BIOME, id)).isPresent()).toList();
+        }
+        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)
+                .getOrThrow(ResourceKey.create(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST, preset));
+        return MultiNoiseBiomeSource.createFromPreset(parameters).possibleBiomes().stream()
+                .map(holder -> holder.unwrapKey().orElseThrow().location())
+                .sorted(Comparator.naturalOrder()).toList();
+    }
+
+    public static boolean isCave(AgeRuntimeProfile profile) {
+        return profile.terrain() == AgeRuntimeProfile.Terrain.NOISE
+                && profile.noiseSettings().equals(ResourceLocation.withDefaultNamespace("caves"));
+    }
+
+    public static int minimum(AgeTraits.BiomeDistribution distribution) {
+        return switch (distribution) {
+            case NATIVE, SINGLE -> 1;
+            case TILED, GRID, TINY, SMALL, MEDIUM, LARGE, HUGE -> 2;
+        };
+    }
+
+}

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

@@ -22,7 +22,7 @@ public record AgeDefinition(
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
     );
-    public static final int CURRENT_GENERATION_VERSION = 14;
+    public static final int CURRENT_GENERATION_VERSION = 16;
 
     public AgeDefinition {
         Objects.requireNonNull(id, "id");

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

@@ -6,8 +6,12 @@ import dev.galacticraft.dynamicdimensions.api.event.DimensionRemovedCallback;
 import dev.galacticraft.dynamicdimensions.api.event.DynamicDimensionLoadCallback;
 import java.util.Optional;
 import java.util.List;
-import java.util.Comparator;
+import java.util.ArrayList;
+import java.util.LinkedHashSet;
+import java.util.Set;
 import java.util.Collections;
+import java.util.Comparator;
+import java.util.Random;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.compat.ImmersivePortalsChunkLoaders;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
@@ -32,12 +36,13 @@ import net.minecraft.world.level.biome.CheckerboardColumnBiomeSource;
 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.minecraft.world.level.chunk.ChunkGenerator;
 import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
 import net.minecraft.world.level.dimension.DimensionType;
-import net.minecraft.world.level.levelgen.FlatLevelSource;
 import net.minecraft.world.level.levelgen.Heightmap;
 import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
+import net.minecraft.world.level.levelgen.FlatLevelSource;
 import net.minecraft.world.level.levelgen.NoiseGeneratorSettings;
 import net.minecraft.world.level.levelgen.SurfaceRules;
 import net.minecraft.world.level.levelgen.flat.FlatLevelGeneratorSettings;
@@ -60,6 +65,7 @@ public final class AgeDimensionService {
         DynamicDimensionLoadCallback.register((server, loader) -> {
             ServerLevel overworld = server.overworld();
             for (AgeDefinition age : AgeRegistrySavedData.get(overworld).definitions()) {
+                if (!canLoadProfile(server, age)) continue;
                 ServerLevel level = loader.loadDynamicDimension(
                         age.dimensionId(),
                         createGenerator(server, age),
@@ -106,6 +112,8 @@ public final class AgeDimensionService {
             return existing;
         }
 
+        if (!canLoadProfile(server, definition)) return null;
+
         ServerLevel overworld = server.overworld();
         ServerLevel loaded = DynamicDimensionRegistry.from(server).loadDynamicDimension(
                 definition.dimensionId(),
@@ -154,8 +162,28 @@ public final class AgeDimensionService {
         }
     }
 
+    private static boolean canLoadProfile(MinecraftServer server, AgeDefinition age) {
+        try {
+            AgeRuntimeProfiles.validateReferences(server.registryAccess(), age.generationProfile(), runtimeProfile(age));
+            return true;
+        } catch (IllegalArgumentException exception) {
+            Rivencraft.LOGGER.error("Cannot load Age {} ({}): {}. Restore its data pack; saved Age data is unchanged.",
+                    age.id(), age.dimensionId(), exception.getMessage());
+            return false;
+        }
+    }
+
+    private static AgeRuntimeProfile runtimeProfile(AgeDefinition age) {
+        return age.plan() == null ? AgeRuntimeProfiles.resolve(age.generationProfile())
+                : age.plan().runtimeProfile();
+    }
+
     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);
     }
 
@@ -267,14 +295,16 @@ public final class AgeDimensionService {
     }
 
     private static ChunkGenerator createGenerator(MinecraftServer server, AgeDefinition age) {
-        AgeRuntimeProfile profile = age.plan() == null ? AgeRuntimeProfiles.resolve(age.generationProfile())
+        AgeRuntimeProfile profile = runtimeProfile(age);
-                : age.plan().runtimeProfile();
+        BiomeSource biomeSource = createBiomeSource(server, age, profile);
         if (profile.terrain() == AgeRuntimeProfile.Terrain.FLAT) {
-            return new FlatLevelSource(FlatLevelGeneratorSettings.getDefault(
+            var settings = FlatLevelGeneratorSettings.getDefault(
                     server.registryAccess().lookupOrThrow(Registries.BIOME),
                     server.registryAccess().lookupOrThrow(Registries.STRUCTURE_SET),
                     server.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE)
-            ));
+            );
+            return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
         }
         if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID) {
             FlatLevelGeneratorSettings settings = new FlatLevelGeneratorSettings(
@@ -283,17 +313,13 @@ public final class AgeDimensionService {
                     List.of()
             );
             settings.updateLayers();
-            return new FlatLevelSource(settings);
+            return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
         }
 
-        var biomeParameters = server.registryAccess()
-                .lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST);
         var noiseSettings = server.registryAccess().lookupOrThrow(Registries.NOISE_SETTINGS);
         ResourceKey<NoiseGeneratorSettings> settingsKey = ResourceKey.create(
                 Registries.NOISE_SETTINGS, profile.noiseSettings());
-        ResourceKey<net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList> biomePreset =
-                ResourceKey.create(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST, profile.biomePreset());
-        BiomeSource biomeSource = createBiomeSource(server, age, biomeParameters, biomePreset);
         NoiseGeneratorSettings baseSettings = noiseSettings.getOrThrow(settingsKey).value();
         return new NoiseBasedChunkGenerator(biomeSource, Holder.direct(withBiomeMaterialRules(baseSettings)));
     }
@@ -340,34 +366,86 @@ public final class AgeDimensionService {
     private static BiomeSource createBiomeSource(
             MinecraftServer server,
             AgeDefinition age,
-            net.minecraft.core.HolderGetter<net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList> biomeParameters,
+            AgeRuntimeProfile profile
-            ResourceKey<net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList> biomePreset
     ) {
-        List<net.minecraft.core.Holder.Reference<Biome>> biomes = server.registryAccess()
+        if (age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION) {
-                .lookupOrThrow(Registries.BIOME)
+            return legacyBiomeSource(server, age, profile);
-                .listElements()
-                .sorted(Comparator.comparing(holder -> holder.key().location().toString()))
-                .toList();
-        if (age.traits().biomeDistribution() == AgeTraits.BiomeDistribution.SINGLE && !biomes.isEmpty()) {
-            int index = Math.floorMod(Long.hashCode(age.seed() ^ 0x53494E474C454249L), biomes.size());
-            return new FixedBiomeSource(biomes.get(index));
         }
-        AgeTraits.BiomeDistribution distribution = age.traits().biomeDistribution();
+        AgeBiomeSelection selection = age.plan() != null && age.plan().biomeSelection() != null
-        if ((distribution == AgeTraits.BiomeDistribution.TILED
+                ? age.plan().biomeSelection()
-                || distribution == AgeTraits.BiomeDistribution.GRID) && biomes.size() >= 2) {
+                : AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(OrderedWriting.EMPTY),
-            List<net.minecraft.core.Holder.Reference<Biome>> selected = new java.util.ArrayList<>(biomes);
+                        age.traits(), profile, age.seed(), server.registryAccess());
-            long salt = distribution == AgeTraits.BiomeDistribution.GRID
+        var registry = server.registryAccess().lookupOrThrow(Registries.BIOME);
-                    ? 0x4752494442494F4DL
+        List<Holder<Biome>> biomes = new ArrayList<>();
-                    : 0x54494C454442494FL;
+        List<ResourceLocation> fallbacks = AgeBiomeSelection.eligible(server.registryAccess(), profile);
-            Collections.shuffle(selected, new java.util.Random(age.seed() ^ salt));
+        Set<ResourceLocation> present = new LinkedHashSet<>();
-            return new CheckerboardColumnBiomeSource(
+        for (ResourceLocation id : selection.biomes()) {
-                    HolderSet.direct(List.of(selected.get(0), selected.get(1))),
+            var holder = registry.get(ResourceKey.create(Registries.BIOME, id));
-                    distribution == AgeTraits.BiomeDistribution.GRID
+            if (holder.isEmpty()) {
-                            ? GRID_BIOME_SCALE
+                ResourceLocation fallback = fallbacks.stream().filter(candidate -> !present.contains(candidate))
-                            : TILED_BIOME_SCALE
+                        .findFirst().orElse(fallbacks.getFirst());
-            );
+                Rivencraft.LOGGER.warn("Age {} biome {} is unavailable; using {} for this load. Restore its data pack to recover the authored biome.",
+                        age.id(), id, fallback);
+                holder = registry.get(ResourceKey.create(Registries.BIOME, fallback));
+            }
+            Holder.Reference<Biome> resolved = holder.orElseThrow();
+            biomes.add(resolved);
+            present.add(resolved.key().location());
+        }
+        for (ResourceLocation fallback : fallbacks) {
+            if (present.size() >= AgeBiomeSelection.minimum(selection.distribution())) break;
+            if (present.add(fallback)) biomes.add(registry.getOrThrow(
+                    ResourceKey.create(Registries.BIOME, fallback)));
+        }
+        AgeTraits.BiomeDistribution distribution = selection.distribution();
+        if (distribution == AgeTraits.BiomeDistribution.NATIVE && !AgeBiomeSelection.isCave(profile)
+                && profile.terrain() == AgeRuntimeProfile.Terrain.NOISE) {
+            var parameters = server.registryAccess()
+                    .lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST);
+            var preset = ResourceKey.create(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST, profile.biomePreset());
+            return MultiNoiseBiomeSource.createFromPreset(parameters.getOrThrow(preset));
+        }
+        if (distribution == AgeTraits.BiomeDistribution.SINGLE || biomes.size() == 1) {
+            return new FixedBiomeSource(biomes.getFirst());
+        }
+        if (distribution == AgeTraits.BiomeDistribution.TILED || distribution == AgeTraits.BiomeDistribution.GRID) {
+            return new CheckerboardColumnBiomeSource(HolderSet.direct(biomes),
+                    distribution == AgeTraits.BiomeDistribution.GRID ? GRID_BIOME_SCALE : TILED_BIOME_SCALE);
         }
         int scaledBiomeScale = switch (distribution) {
+            case NATIVE, TINY -> 0;
+            case SMALL -> 1;
+            case MEDIUM -> 2;
+            case LARGE -> 3;
+            case HUGE -> 4;
+            default -> -1;
+        };
+        if (biomes.size() >= 2) {
+            return new ScaledBiomeSource(HolderSet.direct(biomes), age.seed(), scaledBiomeScale);
+        }
+        return new CheckerboardColumnBiomeSource(HolderSet.direct(biomes), GRID_BIOME_SCALE);
+    }
+
+    /** Preserve the exact selection algorithm for Ages created before biome pools were frozen. */
+    private static BiomeSource legacyBiomeSource(MinecraftServer server, AgeDefinition age, AgeRuntimeProfile profile) {
+        var registry = server.registryAccess().lookupOrThrow(Registries.BIOME);
+        List<Holder.Reference<Biome>> all = registry.listElements()
+                .sorted(Comparator.comparing(holder -> holder.key().location().toString())).toList();
+        AgeTraits.BiomeDistribution distribution = age.traits().biomeDistribution();
+        if (distribution == AgeTraits.BiomeDistribution.SINGLE && !all.isEmpty()) {
+            int index = Math.floorMod(Long.hashCode(age.seed() ^ 0x53494E474C454249L), all.size());
+            return new FixedBiomeSource(all.get(index));
+        }
+        if ((distribution == AgeTraits.BiomeDistribution.TILED || distribution == AgeTraits.BiomeDistribution.GRID)
+                && all.size() >= 2) {
+            List<Holder.Reference<Biome>> selected = new ArrayList<>(all);
+            long salt = distribution == AgeTraits.BiomeDistribution.GRID
+                    ? 0x4752494442494F4DL : 0x54494C454442494FL;
+            Collections.shuffle(selected, new Random(age.seed() ^ salt));
+            return new CheckerboardColumnBiomeSource(HolderSet.direct(List.of(selected.get(0), selected.get(1))),
+                    distribution == AgeTraits.BiomeDistribution.GRID ? GRID_BIOME_SCALE : TILED_BIOME_SCALE);
+        }
+        int scale = switch (distribution) {
             case TINY -> 0;
             case SMALL -> 1;
             case MEDIUM -> 2;
@@ -375,29 +453,25 @@ public final class AgeDimensionService {
             case HUGE -> 4;
             default -> -1;
         };
-        if (scaledBiomeScale >= 0 && biomes.size() >= 3) {
+        if (scale >= 0 && all.size() >= 3) {
-            List<net.minecraft.core.Holder.Reference<Biome>> selected = new java.util.ArrayList<>(biomes);
+            List<Holder.Reference<Biome>> selected = new ArrayList<>(all);
             long salt = distribution == AgeTraits.BiomeDistribution.TINY
-                    ? 0x54494E5942494F4DL
+                    ? 0x54494E5942494F4DL : 0x5343414C45444249L;
-                    : 0x5343414C45444249L;
+            Collections.shuffle(selected, new Random(age.seed() ^ salt));
-            Collections.shuffle(selected, new java.util.Random(age.seed() ^ salt));
+            return new ScaledBiomeSource(HolderSet.direct(List.of(selected.get(0), selected.get(1), selected.get(2))),
-            return new ScaledBiomeSource(
+                    age.seed(), scale);
-                    HolderSet.direct(List.of(selected.get(0), selected.get(1), selected.get(2))),
-                    age.seed(),
-                    scaledBiomeScale
-            );
         }
-        return MultiNoiseBiomeSource.createFromPreset(
+        var parameters = server.registryAccess().lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST);
-                biomeParameters.getOrThrow(biomePreset));
+        return MultiNoiseBiomeSource.createFromPreset(parameters.getOrThrow(ResourceKey.create(
+                Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST, profile.biomePreset())));
     }
 
     private static DimensionType createDimensionType(MinecraftServer server, AgeDefinition age) {
-        AgeRuntimeProfile profile = age.plan() == null ? AgeRuntimeProfiles.resolve(age.generationProfile())
+        AgeRuntimeProfile profile = runtimeProfile(age);
-                : age.plan().runtimeProfile();
         DimensionType base = server.registryAccess().lookupOrThrow(Registries.DIMENSION_TYPE)
                 .getOrThrow(ResourceKey.create(Registries.DIMENSION_TYPE, profile.dimensionType())).value();
         AgeTraits.Lighting lighting = age.traits().lighting();
-        boolean hasSkyLight = lighting != AgeTraits.Lighting.DARK;
+        boolean hasSkyLight = base.hasSkyLight() && lighting != AgeTraits.Lighting.DARK;
         float ambientLight = lighting == AgeTraits.Lighting.BRIGHT ? 0.25F : 0.0F;
         return new DimensionType(
                 base.fixedTime(),
@@ -412,7 +486,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/AgeGenerationPlan.java

@@ -10,21 +10,28 @@ import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
+import net.minecraft.nbt.StringTag;
+import net.minecraft.core.RegistryAccess;
 import net.minecraft.resources.ResourceLocation;
 
 /** A frozen interpretation of authored pages. Later slices consume its resolved branches. */
 public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
-                                AgeRuntimeProfile runtimeProfile) {
+                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
-    public static final int CURRENT_VERSION = 1;
+    public static final int CURRENT_VERSION = 2;
 
     public AgeGenerationPlan {
-        if (version != CURRENT_VERSION) throw new IllegalArgumentException("Unsupported Age plan version " + version);
+        if (version < 1 || version > CURRENT_VERSION) {
+            throw new IllegalArgumentException("Unsupported Age plan version " + version);
+        }
         Objects.requireNonNull(writing, "writing");
         symbols = List.copyOf(symbols);
         Objects.requireNonNull(runtimeProfile, "runtimeProfile");
         if (runtimeProfile.schemaVersion() != AgeRuntimeProfile.CURRENT_SCHEMA_VERSION) {
             throw new IllegalArgumentException("Unsupported runtime profile snapshot version");
         }
+        if (version == CURRENT_VERSION && biomeSelection == null) {
+            throw new IllegalArgumentException("Version 2 Age plan requires a biome selection snapshot");
+        }
         for (ResolvedSymbol symbol : symbols) {
             if (symbol.index() < 0 || symbol.index() >= writing.entries().size()
                     || !symbol.reference().equals(writing.entries().get(symbol.index()).symbol().orElse(null))) {
@@ -33,8 +40,15 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         }
     }
 
+    /** Existing version 1 plans retain their original biome behavior on reload. */
+    public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
+                             AgeRuntimeProfile runtimeProfile) {
+        this(version, ageSeed, writing, symbols, runtimeProfile, null);
+    }
+
     /** No plan is made for old page-free books or Link-Panel-only random Ages. */
-    public static AgeGenerationPlan compile(OrderedWriting writing, long ageSeed, ResourceLocation seedProfile) {
+    public static AgeGenerationPlan compile(OrderedWriting writing, long ageSeed, ResourceLocation seedProfile,
+                                            AgeTraits traits, RegistryAccess registries) {
         WritingGrammar.Result parsed = WritingGrammar.parse(writing);
         if (!parsed.canCreate()) throw new IllegalArgumentException(parsed.firstError().orElseThrow().message());
         if (parsed.randomFallback()) return null;
@@ -50,10 +64,13 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         ResourceLocation selected = terrain == null ? seedProfile : terrain;
         AgeRuntimeProfile profile = AgeRuntimeProfiles.profiles().get(selected);
         if (profile == null) throw new IllegalArgumentException("Unsupported Age terrain profile " + selected);
-        return new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(parsed, traits, profile, ageSeed, registries);
+        AgeGenerationPlan plan = new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
                 parsed.symbols().stream().map(symbol -> new ResolvedSymbol(
                         symbol.index(), symbol.reference(), symbol.semantics())).toList(),
-                profile);
+                profile, biomes);
+        AgeEnvironmentCompiler.apply(plan, traits);
+        return plan;
     }
 
     public ResourceLocation authoredTerrain() {
@@ -94,6 +111,14 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         profile.putString("Biomes", runtimeProfile.biomePreset().toString());
         profile.putString("Dimension", runtimeProfile.dimensionType().toString());
         tag.put("RuntimeProfile", profile);
+        if (biomeSelection != null) {
+            CompoundTag biomeTag = new CompoundTag();
+            biomeTag.putString("Distribution", biomeSelection.distribution().name());
+            ListTag biomeIds = new ListTag();
+            biomeSelection.biomes().forEach(id -> biomeIds.add(StringTag.valueOf(id.toString())));
+            biomeTag.put("Ids", biomeIds);
+            tag.put("BiomeSelection", biomeTag);
+        }
         return tag;
     }
 
@@ -124,12 +149,23 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
                     new SymbolSemantics(role, value)));
         }
         CompoundTag profile = tag.getCompound("RuntimeProfile");
+        AgeBiomeSelection selection = null;
+        if (version >= 2) {
+            CompoundTag biomeTag = tag.getCompound("BiomeSelection");
+            ListTag biomeIds = biomeTag.getList("Ids", CompoundTag.TAG_STRING);
+            List<ResourceLocation> ids = new ArrayList<>();
+            for (int index = 0; index < biomeIds.size(); index++) {
+                ids.add(ResourceLocation.parse(biomeIds.getString(index)));
+            }
+            selection = new AgeBiomeSelection(AgeTraits.BiomeDistribution.valueOf(
+                    biomeTag.getString("Distribution")), ids);
+        }
         return new AgeGenerationPlan(version, tag.getLong("AgeSeed"), new OrderedWriting(pages), resolved,
                 new AgeRuntimeProfile(profile.getInt("Version"),
                         AgeRuntimeProfile.Terrain.valueOf(profile.getString("Terrain")),
                         ResourceLocation.parse(profile.getString("Noise")),
                         ResourceLocation.parse(profile.getString("Biomes")),
-                        ResourceLocation.parse(profile.getString("Dimension"))));
+                        ResourceLocation.parse(profile.getString("Dimension"))), selection);
     }
 
     public record ResolvedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {

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

@@ -8,6 +8,7 @@ import java.util.List;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.HolderLookup;
+import net.minecraft.core.RegistryAccess;
 import net.minecraft.nbt.CompoundTag;
 import net.minecraft.nbt.ListTag;
 import net.minecraft.resources.ResourceLocation;
@@ -56,7 +57,24 @@ public final class AgeRegistrySavedData extends SavedData {
 
     public static AgeDefinition resolveOrCreate(ServerLevel level, AgeReference reference, OrderedWriting writing) {
         ServerLevel overworld = level.getServer().overworld();
-        return get(overworld).getOrCreate(reference, writing, overworld.getSeed(), overworld.getGameTime());
+        return get(overworld).getOrCreate(reference, writing, overworld.getSeed(), overworld.getGameTime(),
+                overworld.registryAccess());
+    }
+
+    /** Validate with the same name-derived seed and terrain completion used when the Age is created. */
+    public static void validateNewWriting(ServerLevel level, String name, OrderedWriting writing) {
+        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),
+                overworld.registryAccess());
+    }
+
+    public static ResourceLocation previewGenerationProfile(ServerLevel level, String name) {
+        ServerLevel overworld = level.getServer().overworld();
+        AgeRegistrySavedData data = get(overworld);
+        long seed = ageSeed(overworld.getSeed(), data.availableDimensionId(normalizedName(name)));
+        return AgeRuntimeProfiles.select(seed);
     }
 
     public Optional<AgeDefinition> find(UUID ageId) {
@@ -85,7 +103,7 @@ public final class AgeRegistrySavedData extends SavedData {
     }
 
     private AgeDefinition getOrCreate(AgeReference reference, OrderedWriting writing,
-                                      long worldSeed, long createdGameTime) {
+                                      long worldSeed, long createdGameTime, RegistryAccess registries) {
         AgeDefinition existing = ages.get(reference.id());
         if (existing != null) {
             return existing;
@@ -95,7 +113,8 @@ public final class AgeRegistrySavedData extends SavedData {
         ResourceLocation dimensionId = availableDimensionId(name);
         long seed = ageSeed(worldSeed, dimensionId);
         ResourceLocation seedProfile = AgeRuntimeProfiles.select(seed);
-        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile);
+        AgeTraits traits = AgeTraits.select(seed);
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile, traits, registries);
         AgeDefinition created = new AgeDefinition(
                 reference.id(),
                 name,
@@ -105,7 +124,7 @@ public final class AgeRegistrySavedData extends SavedData {
                 createdGameTime,
                 dimensionId,
                 null,
-                AgeTraits.select(seed),
+                AgeEnvironmentCompiler.apply(plan, traits),
                 plan
         );
         ages.put(created.id(), created);

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

@@ -70,14 +70,19 @@ public final class AgeRuntimeProfiles {
         ResourceLocation noise = location(object, "noise_settings", "minecraft:overworld");
         ResourceLocation biome = location(object, "biome_preset", "minecraft:overworld");
         ResourceLocation dimension = location(object, "dimension_type", "minecraft:overworld");
+        AgeRuntimeProfile profile = new AgeRuntimeProfile(schemaVersion, terrain, noise, biome, dimension);
+        validateReferences(registries, id, profile);
+        return profile;
+    }
 
-        if (terrain == AgeRuntimeProfile.Terrain.NOISE) {
+    /** Recheck frozen plans before loading: a removed registry entry must not crash or silently alter an Age. */
-            requireRegistryEntry(registries, Registries.NOISE_SETTINGS, noise, id, "noise_settings");
+    public static void validateReferences(RegistryAccess registries, ResourceLocation id, AgeRuntimeProfile profile) {
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.NOISE) {
+            requireRegistryEntry(registries, Registries.NOISE_SETTINGS, profile.noiseSettings(), id, "noise_settings");
             requireRegistryEntry(registries, Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST,
-                    biome, id, "biome_preset");
+                    profile.biomePreset(), id, "biome_preset");
         }
-        requireRegistryEntry(registries, Registries.DIMENSION_TYPE, dimension, id, "dimension_type");
+        requireRegistryEntry(registries, Registries.DIMENSION_TYPE, profile.dimensionType(), id, "dimension_type");
-        return new AgeRuntimeProfile(schemaVersion, terrain, noise, biome, dimension);
     }
 
     private static String requiredString(JsonObject object, String name) {

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

@@ -63,6 +63,10 @@ public record AgeTraits(
         return celestialPeriod == STOPPED_CELESTIAL_PERIOD;
     }
 
+    public AgeTraits withBiomeDistribution(BiomeDistribution distribution) {
+        return new AgeTraits(distribution, lighting, weather, celestialPeriod, celestialAngle, celestialPhase);
+    }
+
     public static <E extends Enum<E>> E parseOrDefault(String value, E fallback) {
         try {
             @SuppressWarnings("unchecked")

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

@@ -0,0 +1,154 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashSet;
+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.registry.ModCreativeTabs;
+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.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+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 symbolCategoriesPartitionCreativePages(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        var allPages = PageItem.creativeSymbolPages(registries);
+        Set<ResourceLocation> collected = new HashSet<>();
+        helper.assertTrue(ModCreativeTabs.SYMBOL_PAGES.keySet().containsAll(PageItem.bundledCreativeCategories()),
+                "Every bundled page category must receive a creative tab");
+        for (ResourceLocation category : PageItem.bundledCreativeCategories()) {
+            var categoryPages = PageItem.creativeSymbolPages(registries, category);
+            helper.assertFalse(categoryPages.isEmpty(), "Every category tab must contain pages: " + category);
+            for (var page : categoryPages) {
+                helper.assertValueEqual(PageItem.creativeCategory(page), category,
+                        "Category tabs must not mix symbol pages");
+                helper.assertTrue(collected.add(PageItem.content(page).symbol().orElseThrow().id()),
+                        "A symbol page must appear in exactly one category tab");
+            }
+        }
+        helper.assertValueEqual(collected.size(), allPages.size(),
+                "Category tabs must contain every bundled and generated biome page");
+        var biomePages = PageItem.creativeSymbolPages(registries,
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "biome"));
+        var generationPages = PageItem.creativeSymbolPages(registries,
+                ResourceLocation.fromNamespaceAndPath("rivencraft", "biome_generation"));
+        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.assertFalse(biomePages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/tiny")), "Biome generation types must leave the Biome tab");
+        helper.assertTrue(generationPages.stream().anyMatch(page -> PageItem.content(page).symbol().orElseThrow()
+                        .id().getPath().equals("biome/tiny")), "Biome generation types need their own tab");
+        helper.assertTrue(allPages.stream().noneMatch(page -> PageItem.content(page).kind() == PageContent.Kind.BLANK),
+                "Blank pages must not enter the creative or JEI symbol-page feed");
+        helper.assertValueEqual(PageItem.content(PageItem.createLinkPanelPage()).kind(), PageContent.Kind.LINK_PANEL,
+                "Link pages must stay separate from symbol categories");
+        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",
+                "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 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/TerrainWritingGameTests.java

@@ -0,0 +1,354 @@
+package net.dnorberg.rivencraft.book;
+
+import com.google.gson.JsonParser;
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolCatalog;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.minecraft.core.BlockPos;
+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.block.Blocks;
+import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
+import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.minecraft.world.level.levelgen.NoiseBasedChunkGenerator;
+import net.minecraft.world.level.biome.Biomes;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Issue #32: authored terrain must drive actual runtime generation and survive reload. */
+@GameTestHolder("rivencraft_archive_linking")
+@PrefixGameTestTemplate(false)
+public final class TerrainWritingGameTests {
+    private TerrainWritingGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void seedSelectedCavePreflightRejectsSurfaceBiome(GameTestHelper helper) {
+        String candidate = null;
+        for (int index = 0; index < 1000; index++) {
+            String name = "Cave preflight " + index;
+            if (AgeRegistrySavedData.previewGenerationProfile(helper.getLevel(), name)
+                    .equals(AgeGenerationProfiles.CAVE)) {
+                candidate = name;
+                break;
+            }
+        }
+        helper.assertTrue(candidate != null, "A deterministic name must select Cave terrain");
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/plains")))));
+        boolean rejected = false;
+        try {
+            AgeRegistrySavedData.validateNewWriting(helper.getLevel(), candidate, writing);
+        } catch (IllegalArgumentException exception) {
+            rejected = exception.getMessage().contains("not a cave or Nether biome");
+        }
+        helper.assertTrue(rejected, "The preflight must use the actual seed-selected terrain profile");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty", timeoutTicks = 600)
+    public static void caveBiomePagesControlGeneratedPool(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        helper.assertTrue(PageItem.bundledCreativeSymbols().contains("biome/desert"),
+                "Desert must remain in the bundled creative page index");
+        var creativePages = PageItem.creativeSymbolPages(helper.getLevel().registryAccess());
+        helper.assertTrue(creativePages.stream().anyMatch(page -> PageItem.content(page).symbol()
+                        .map(symbol -> symbol.id().equals(ResourceLocation.parse("rivencraft:biome/desert")))
+                        .orElse(false))
+                        && creativePages.stream().anyMatch(page -> PageItem.content(page).symbol()
+                        .map(symbol -> symbol.id().equals(ResourceLocation.parse("rivencraft:biome/jungle")))
+                        .orElse(false)),
+                "Both bundled and registry-generated biome pages must be available to creative and JEI");
+        var jungle = ResourceLocation.withDefaultNamespace("jungle");
+        helper.assertTrue(SymbolCatalog.isKnown(new SymbolReference(ResourceLocation.parse("rivencraft:biome/jungle")))
+                        && PageItem.isUsableWriting(PageItem.createCreativeBiomePage(jungle)),
+                "A generated Jungle page must be usable as server-authored writing");
+        helper.getLevel().registryAccess().lookupOrThrow(Registries.BIOME).listElements()
+                .map(holder -> holder.key().location())
+                .filter(id -> id.getNamespace().equals("minecraft"))
+                .forEach(id -> helper.assertTrue(SymbolCatalog.isKnown(new SymbolReference(
+                                ResourceLocation.fromNamespaceAndPath("rivencraft", "biome/" + id.getPath()))),
+                        "Every registered vanilla biome must have a usable symbol page: " + id));
+        var overworldPool = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
+                AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD));
+        helper.assertTrue(overworldPool.containsAll(List.of(Biomes.LUSH_CAVES.location(),
+                        Biomes.DRIPSTONE_CAVES.location(), Biomes.DEEP_DARK.location())),
+                "Standard terrain must retain the vanilla Overworld underground cave biomes");
+        OrderedWriting standardCaveWriting = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/dripstone_caves"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/single")))));
+        helper.assertValueEqual(AgeGenerationPlan.compile(standardCaveWriting, 45L,
+                        AgeGenerationProfiles.STANDARD, AgeTraits.select(45L), helper.getLevel().registryAccess())
+                        .biomeSelection().biomes(), List.of(Biomes.DRIPSTONE_CAVES.location()),
+                "A standard Age must accept an explicitly written cave biome");
+        OrderedWriting writing = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/cave"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/lush_caves"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/nether_wastes"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/tiled")))));
+        var reference = new AgeReference(UUID.randomUUID(), "Written Cave Biomes");
+        var target = AgeDimensionService.resolve(player, reference, writing).orElseThrow();
+        var age = AgeRegistrySavedData.get(helper.getLevel()).find(reference.id()).orElseThrow();
+        var selection = age.plan().biomeSelection();
+        helper.assertValueEqual(selection.distribution(), AgeTraits.BiomeDistribution.TILED,
+                "The authored distribution must override the random trait");
+        helper.assertValueEqual(selection.biomes(), List.of(Biomes.LUSH_CAVES.location(), Biomes.NETHER_WASTES.location()),
+                "An authored cave pool must include only its selected cave and Nether biomes");
+        helper.assertValueEqual(AgeGenerationPlan.load(age.plan().save()).biomeSelection(), selection,
+                "Biome IDs, count and distribution must survive a plan save/reload");
+        helper.runAfterDelay(1, () -> {
+            var level = helper.getLevel().getServer().getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "The cave Age must load");
+            helper.assertValueEqual(level.getChunkSource().getGenerator().getBiomeSource().possibleBiomes().size(), 2,
+                    "The runtime generator must expose both authored biomes");
+            helper.succeed();
+        });
+    }
+
+    @GameTest(template = "empty")
+    public static void authoredBiomeMinimumAndRandomAgeRange(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        var profile = AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD);
+        OrderedWriting twoBiomeTiny = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/plains"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/desert"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/tiny")))));
+        var written = AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(twoBiomeTiny),
+                AgeTraits.select(42L), profile, 42L, registries);
+        helper.assertValueEqual(written.biomes(), List.of(Biomes.PLAINS.location(), Biomes.DESERT.location()),
+                "Two authored Tiny biomes must not acquire a third random biome");
+        var biomeRegistry = registries.lookupOrThrow(Registries.BIOME);
+        var scaled = new net.dnorberg.rivencraft.world.ScaledBiomeSource(net.minecraft.core.HolderSet.direct(
+                biomeRegistry.getOrThrow(Biomes.PLAINS), biomeRegistry.getOrThrow(Biomes.DESERT)), 42L, 0);
+        helper.assertValueEqual(scaled.possibleBiomes().size(), 2,
+                "The Tiny runtime biome source must accept exactly two authored biomes");
+
+        OrderedWriting oneBiomeTiny = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/plains"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/tiny")))));
+        var partial = AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(oneBiomeTiny),
+                AgeTraits.select(42L), profile, 42L, registries);
+        helper.assertValueEqual(partial.biomes().size(), 2,
+                "One authored Tiny biome must receive only the missing second biome");
+        helper.assertValueEqual(partial.biomes().getFirst(), Biomes.PLAINS.location(),
+                "Random completion must preserve the authored biome first");
+
+        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() <= 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();
+    }
+
+    @GameTest(template = "empty", timeoutTicks = 600)
+    public static void skyIslandAllowsExplicitEndBiome(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        OrderedWriting writing = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/island"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/the_end"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:biome/single")))));
+        var reference = new AgeReference(UUID.randomUUID(), "End Island Biome");
+        var target = AgeDimensionService.resolve(player, reference, writing).orElseThrow();
+        var age = AgeRegistrySavedData.get(helper.getLevel()).find(reference.id()).orElseThrow();
+        helper.assertValueEqual(age.plan().biomeSelection().biomes(), List.of(Biomes.THE_END.location()),
+                "A sky island may use an explicitly authored End biome");
+        helper.runAfterDelay(1, () -> {
+            var server = helper.getLevel().getServer();
+            var level = server.getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "The island Age must load");
+            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(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 writtenTerrainFamiliesGenerateSafely(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        checkWrittenTerrain(helper, player, AgeGenerationProfiles.all(), 0);
+    }
+
+    private static void checkWrittenTerrain(GameTestHelper helper,
+                                            net.minecraft.server.level.ServerPlayer player,
+                                            List<ResourceLocation> profiles, int index) {
+        if (index >= profiles.size()) {
+            helper.succeed();
+            return;
+        }
+        var server = helper.getLevel().getServer();
+        ResourceLocation profileId = profiles.get(index);
+        SymbolReference symbol = new SymbolReference(ResourceLocation.fromNamespaceAndPath(
+                "rivencraft", "terrain/" + profileId.getPath()));
+        var semantics = SymbolCatalog.find(symbol).orElseThrow().semantics().orElseThrow();
+        helper.assertValueEqual(semantics.role(), SymbolSemantics.Role.TERRAIN,
+                "A built-in terrain page must have terrain semantics");
+        helper.assertValueEqual(((SymbolSemantics.ResourceValue) semantics.value()).id(), profileId,
+                "A terrain page must point at its matching profile");
+
+        OrderedWriting writing = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(), WritingEntry.symbol(symbol)));
+        AgeReference reference = new AgeReference(UUID.randomUUID(),
+                "Written " + profileId.getPath() + " " + UUID.randomUUID());
+        var target = AgeDimensionService.resolve(player, reference, writing).orElseThrow();
+        AgeDefinition age = AgeRegistrySavedData.get(helper.getLevel()).find(reference.id()).orElseThrow();
+        helper.assertValueEqual(age.generationProfile(), profileId,
+                "Written terrain must override the random profile chosen from the seed");
+        helper.assertValueEqual(age.plan().runtimeProfile(), AgeRuntimeProfiles.profiles().get(profileId),
+                "The selected noise and dimension-type resources must be frozen in the plan");
+        helper.runAfterDelay(1, () -> {
+            var level = server.getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "The written Age must create a runtime dimension");
+            assertGenerator(helper, level, age.plan().runtimeProfile());
+            BlockPos spawn = target.location().pos();
+            helper.assertTrue(level.getBlockState(spawn.below()).is(Blocks.COBBLESTONE)
+                            && level.getBlockState(spawn).isAir()
+                            && level.getBlockState(spawn.above()).isAir(),
+                    "Every written terrain family must retain a safe arrival platform");
+
+            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));
+        });
+    }
+
+    @GameTest(template = "empty")
+    public static void missingRegistryResourcesRejectProfileAndPreserveAge(GameTestHelper helper) {
+        ResourceLocation missing = ResourceLocation.parse("rivencraft:missing_noise");
+        var json = JsonParser.parseString("""
+                {"schema_version":1,"terrain":"noise","noise_settings":"rivencraft:missing_noise",
+                 "biome_preset":"minecraft:overworld","dimension_type":"minecraft:overworld"}
+                """);
+        boolean rejected = false;
+        try {
+            AgeRuntimeProfiles.parse(missing, json, helper.getLevel().registryAccess());
+        } catch (IllegalArgumentException exception) {
+            rejected = exception.getMessage().contains("noise_settings")
+                    && exception.getMessage().contains(missing.toString());
+        }
+        helper.assertTrue(rejected, "A profile with missing noise settings needs an actionable rejection");
+
+        long seed = 42L;
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))));
+        AgeRuntimeProfile broken = new AgeRuntimeProfile(1, AgeRuntimeProfile.Terrain.NOISE,
+                missing, ResourceLocation.parse("minecraft:overworld"),
+                ResourceLocation.parse("minecraft:overworld"));
+        AgeGenerationPlan plan = new AgeGenerationPlan(1, seed, writing,
+                List.of(new AgeGenerationPlan.ResolvedSymbol(1,
+                        writing.entries().get(1).symbol().orElseThrow(),
+                        new SymbolSemantics(SymbolSemantics.Role.TERRAIN,
+                                new SymbolSemantics.ResourceValue(AgeGenerationProfiles.STANDARD)))), broken);
+        AgeDefinition age = new AgeDefinition(UUID.randomUUID(), "Missing Resource", seed,
+                AgeGenerationProfiles.STANDARD, AgeDefinition.CURRENT_GENERATION_VERSION,
+                helper.getLevel().getGameTime(),
+                ResourceLocation.parse("rivencraft:gametest/missing_resource_" + UUID.randomUUID()),
+                null, AgeTraits.select(seed), plan);
+        helper.assertTrue(AgeDimensionService.ensureLoaded(helper.getLevel().getServer(), age) == null,
+                "A removed resource must not silently turn an authored Age into a different terrain");
+        helper.assertValueEqual(age.plan(), plan, "Failed loading must not mutate the saved plan");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void dimensionTypeSnapshotKeepsNetherSkylightRules(GameTestHelper helper) {
+        var profile = AgeRuntimeProfiles.parse(ResourceLocation.parse("rivencraft:gametest_nether"),
+                JsonParser.parseString("""
+                        {"schema_version":1,"terrain":"noise","noise_settings":"minecraft:nether",
+                         "biome_preset":"minecraft:nether","dimension_type":"minecraft:the_nether"}
+                        """), helper.getLevel().registryAccess());
+        long seed = 99L;
+        OrderedWriting writing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:feature/caves")))));
+        var parsed = net.dnorberg.rivencraft.writing.WritingGrammar.parse(writing);
+        AgeGenerationPlan plan = new AgeGenerationPlan(1, seed, writing,
+                parsed.symbols().stream().map(symbol -> new AgeGenerationPlan.ResolvedSymbol(
+                        symbol.index(), symbol.reference(), symbol.semantics())).toList(), profile);
+        AgeDefinition age = new AgeDefinition(UUID.randomUUID(), "Nether Type Snapshot", seed,
+                ResourceLocation.parse("rivencraft:gametest_nether"), AgeDefinition.CURRENT_GENERATION_VERSION,
+                helper.getLevel().getGameTime(),
+                ResourceLocation.parse("rivencraft:gametest/nether_type_" + UUID.randomUUID()),
+                null, AgeTraits.LEGACY_DEFAULTS, plan);
+        var level = AgeDimensionService.ensureLoaded(helper.getLevel().getServer(), age);
+        helper.assertTrue(level != null, "A valid custom dimension-type snapshot must load");
+        helper.assertFalse(level.dimensionType().hasSkyLight(),
+                "Normal lighting must not add skylight to a Nether-style dimension type");
+        helper.assertValueEqual(level.dimensionType().effectsLocation(), BuiltinDimensionTypes.NETHER_EFFECTS,
+                "The authored profile's dimension effects must reach the runtime Age");
+        helper.succeed();
+    }
+
+    private static void assertGenerator(GameTestHelper helper, net.minecraft.server.level.ServerLevel level,
+                                        AgeRuntimeProfile profile) {
+        var generator = level.getChunkSource().getGenerator();
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.NOISE) {
+            helper.assertTrue(generator instanceof NoiseBasedChunkGenerator,
+                    "Noise terrain must use a noise-based chunk generator");
+            var expected = level.registryAccess().lookupOrThrow(Registries.NOISE_SETTINGS).getOrThrow(
+                    ResourceKey.create(Registries.NOISE_SETTINGS, profile.noiseSettings())).value();
+            helper.assertValueEqual(((NoiseBasedChunkGenerator) generator).generatorSettings().value().noiseSettings(),
+                    expected.noiseSettings(), "Written noise settings must be applied to the generator");
+        } else {
+            helper.assertTrue(generator instanceof AgeFlatChunkGenerator,
+                    "Flat and Void terrain must use a flat-source generator");
+            if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID) {
+                helper.assertTrue(generator.getBiomeSource().possibleBiomes().stream()
+                                .allMatch(biome -> biome.is(net.minecraft.world.level.biome.Biomes.THE_VOID)),
+                        "Void terrain must use the Void biome");
+            }
+        }
+        var expectedType = level.registryAccess().lookupOrThrow(Registries.DIMENSION_TYPE).getOrThrow(
+                ResourceKey.create(Registries.DIMENSION_TYPE, profile.dimensionType())).value();
+        helper.assertValueEqual(level.dimensionType().effectsLocation(), expectedType.effectsLocation(),
+                "The profile's dimension-type effects must be applied");
+    }
+}

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

@@ -247,8 +247,6 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                 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);
     }
 
     private void turnPage(int direction) {

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

@@ -1,6 +1,9 @@
 package net.dnorberg.rivencraft.compat.jei;
 
 import java.util.List;
+import java.util.ArrayList;
+import java.util.Set;
+import java.util.stream.Collectors;
 import mezz.jei.api.IModPlugin;
 import mezz.jei.api.JeiPlugin;
 import mezz.jei.api.constants.VanillaTypes;
@@ -13,8 +16,14 @@ import mezz.jei.api.recipe.category.AbstractRecipeCategory;
 import mezz.jei.api.registration.IRecipeCatalystRegistration;
 import mezz.jei.api.registration.IRecipeCategoryRegistration;
 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.writing.PageContent;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiGraphics;
@@ -36,6 +45,55 @@ public final class RivencraftJeiPlugin implements IModPlugin {
         return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "jei_writing");
     }
 
+    @Override
+    public void registerItemSubtypes(ISubtypeRegistration registration) {
+        registration.registerSubtypeInterpreter(ModItems.PAGE.get(),
+                (IIngredientSubtypeInterpreter<ItemStack>) (stack, context) -> {
+                    PageContent content = PageItem.content(stack);
+                    return switch (content.kind()) {
+                        case BLANK -> "blank";
+                        case LINK_PANEL -> "link_panel";
+                        case SYMBOL -> "symbol:" + content.symbol().orElseThrow().id();
+                        case UNRESOLVED_SYMBOL -> "unresolved:" + content.symbol().orElseThrow().id();
+                    };
+                });
+    }
+
+    @Override
+    public void registerExtraIngredients(IExtraIngredientRegistration registration) {
+        List<ItemStack> pages = new ArrayList<>();
+        pages.add(PageItem.createLinkPanelPage());
+        var connection = Minecraft.getInstance().getConnection();
+        if (connection != null) {
+            pages.addAll(PageItem.creativeSymbolPages(connection.registryAccess()));
+        } else {
+            PageItem.bundledCreativeSymbols().stream().map(PageItem::createBundledCreativePage)
+                    .forEach(pages::add);
+        }
+        registration.addExtraItemStacks(pages);
+    }
+
+    @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()
+                .filter(stack -> stack.is(ModItems.PAGE.get()))
+                .map(PageItem::content)
+                .filter(content -> content.kind() == PageContent.Kind.SYMBOL)
+                .map(content -> content.symbol().orElseThrow().id())
+                .collect(Collectors.toSet());
+        List<ItemStack> missing = PageItem.creativeSymbolPages(connection.registryAccess()).stream()
+                .filter(stack -> !known.contains(PageItem.content(stack).symbol().orElseThrow().id()))
+                .toList();
+        if (!missing.isEmpty()) {
+            runtime.getIngredientManager().addIngredientsAtRuntime(VanillaTypes.ITEM_STACK, missing);
+        }
+    }
+
     @Override
     public void registerCategories(IRecipeCategoryRegistration registration) {
         IGuiHelper guiHelper = registration.getJeiHelpers().getGuiHelper();

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

@@ -59,6 +59,7 @@ public final class BookBinderGameTests {
         binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
         var saved = binder.saveWithoutMetadata(helper.getLevel().registryAccess());
         var restored = new BookBinderBlockEntity(binder.getBlockPos(), binder.getBlockState());
+        restored.setLevel(helper.getLevel());
         restored.loadWithComponents(saved, helper.getLevel().registryAccess());
         helper.assertValueEqual(restored.title(), "Ordered Age", "Title must persist");
         helper.assertTrue(restored.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER), "Cover must persist");

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

@@ -2,6 +2,8 @@ package net.dnorberg.rivencraft.gametest;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.book.AgeDefinition;
+import net.dnorberg.rivencraft.book.AgeBiomeSelection;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
 import net.dnorberg.rivencraft.book.AgeReference;
@@ -12,6 +14,7 @@ import net.dnorberg.rivencraft.book.LinkTarget;
 import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.book.AgeVisitSavedData;
 import net.dnorberg.rivencraft.book.AgeTraits;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.compat.PreviewBackendSelector;
 import net.dnorberg.rivencraft.config.RivencraftClientConfig;
 import net.dnorberg.rivencraft.item.DescriptiveBookItem;
@@ -310,42 +313,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()) {
@@ -418,46 +385,40 @@ public final class LinkingGameTests {
             }
             if (profile.equals(AgeGenerationProfiles.AMPLIFIED)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
-                helper.assertValueEqual(
+                int availableBiomes = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
-                        biomeSource.possibleBiomes().size(),
+                        AgeRuntimeProfiles.resolve(profile)).size();
-                        2,
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                        "Tiled Biome Distribution must expose exactly two 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);
-                var diagonalTile = biomeSource.getNoiseBiome(64, 0, 64, null);
                 helper.assertFalse(origin.equals(eastTile),
-                        "Adjacent 256-block Tiled squares must alternate biomes");
+                        "Adjacent 256-block Tiled squares must use different biomes");
-                helper.assertTrue(origin.equals(diagonalTile),
-                        "Diagonal 256-block Tiled squares must repeat the biome");
             }
             if (profile.equals(AgeGenerationProfiles.ISLAND)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
-                helper.assertValueEqual(
+                int availableBiomes = AgeBiomeSelection.eligible(helper.getLevel().registryAccess(),
-                        biomeSource.possibleBiomes().size(),
+                        AgeRuntimeProfiles.resolve(profile)).size();
-                        2,
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                        "Grid Biome Distribution must expose exactly two 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);
-                var diagonalChunk = biomeSource.getNoiseBiome(4, 0, 4, null);
                 helper.assertTrue(origin.equals(insideOriginChunk),
                         "Grid biomes must remain constant inside each 16-block chunk");
                 helper.assertFalse(origin.equals(eastChunk),
-                        "Adjacent Grid chunks must alternate biomes");
+                        "Adjacent Grid chunks must use different biomes");
-                helper.assertTrue(origin.equals(diagonalChunk),
-                        "Diagonal Grid chunks must repeat the biome");
             }
             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.assertValueEqual(
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                        biomeSource.possibleBiomes().size(),
+                                && biomeSource.possibleBiomes().size() <= caveBiomeCount,
-                        3,
+                        "Random cave Tiny distribution must use only eligible cave biomes");
-                        "Tiny Biome Distribution must expose exactly three seeded 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) {
@@ -529,13 +490,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.assertValueEqual(
+            helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                    biomeSource.possibleBiomes().size(),
+                            && biomeSource.possibleBiomes().size() <= availableBiomes,
-                    3,
+                    distribution + " random distribution must stay within the available biome pool");
-                    distribution + " Biome Distribution must expose exactly three seeded biomes"
-            );
             helper.assertValueEqual(
                     ((net.dnorberg.rivencraft.world.ScaledBiomeSource)biomeSource).scale(),
                     scale,
@@ -553,23 +514,10 @@ public final class LinkingGameTests {
             net.minecraft.resources.ResourceKey<net.minecraft.world.level.biome.Biome> biome,
             net.minecraft.world.level.block.Block expectedBlock
     ) {
-        var biomeRegistry = helper.getLevel().registryAccess().lookupOrThrow(net.minecraft.core.registries.Registries.BIOME);
-        var sortedBiomes = biomeRegistry.listElements()
-                .sorted(java.util.Comparator.comparing(holder -> holder.key().location().toString()))
-                .toList();
-        int targetIndex = -1;
-        for (int index = 0; index < sortedBiomes.size(); index++) {
-            if (sortedBiomes.get(index).is(biome)) {
-                targetIndex = index;
-                break;
-            }
-        }
-        helper.assertTrue(targetIndex >= 0, "The requested material-test biome must be registered");
-
         long seed = 0L;
-        while (Math.floorMod(Long.hashCode(seed ^ 0x53494E474C454249L), sortedBiomes.size()) != targetIndex) {
+        var plan = new AgeGenerationPlan(AgeGenerationPlan.CURRENT_VERSION, seed, OrderedWriting.EMPTY,
-            seed++;
+                java.util.List.of(), AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD),
-        }
+                new AgeBiomeSelection(AgeTraits.BiomeDistribution.SINGLE, java.util.List.of(biome.location())));
         UUID id = UUID.randomUUID();
         AgeDefinition definition = new AgeDefinition(
                 id,
@@ -589,7 +537,8 @@ public final class LinkingGameTests {
                         1.0D,
                         0.0F,
                         0.0F
-                )
+                ),
+                plan
         );
         var level = AgeDimensionService.ensureLoaded(helper.getLevel().getServer(), definition);
         helper.assertTrue(level != null, biome.location() + " material test Age must load");

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

@@ -106,6 +106,22 @@ public final class WritingDataGameTests {
         helper.succeed();
     }
 
+    @GameTest(template = "empty")
+    public static void creativePagesIncludeEveryBuiltInTerrain(GameTestHelper helper) {
+        for (String terrain : List.of("standard", "amplified", "cave", "island", "flat", "void")) {
+            String path = "terrain/" + terrain;
+            helper.assertTrue(PageItem.bundledCreativeSymbols().contains(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),
+                    "The creative starter page must contain the matching terrain symbol");
+            helper.assertTrue(page.get(ModDataComponents.PAGE_SYMBOL_DISPLAY.get()).resolved(),
+                    "The creative starter page must have display metadata before catalog reload");
+        }
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void semanticSchemaIsServerOnlyBoundedAndV1Compatible(GameTestHelper helper) {
         var builtIn = SymbolCatalog.find(reference("rivencraft:terrain/standard")).orElseThrow();

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

@@ -1,23 +1,43 @@
 package net.dnorberg.rivencraft.item;
 
+import com.google.gson.JsonParser;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.Collections;
+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.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.SymbolDisplayMetadata;
 import net.dnorberg.rivencraft.writing.SymbolReference;
-import net.dnorberg.rivencraft.writing.SymbolPoems;
+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.registries.Registries;
 import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
 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 ResourceLocation BIOME_GENERATION_CATEGORY =
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome_generation");
+    private static final Map<String, CreativeSymbol> CREATIVE_SYMBOLS = loadCreativeSymbols();
+
+    private record CreativeSymbol(SymbolDisplayMetadata display, ResourceLocation creativeCategory) {}
+
     public PageItem(Properties properties) {
         super(properties);
     }
@@ -29,23 +49,103 @@ public final class PageItem extends Item {
         return create(PageContent.symbol(reference));
     }
 
-    /** Fixed starter examples for the creative tab; the server still validates catalog membership on use. */
+    public static List<String> bundledCreativeSymbols() {
-    public static ItemStack createCreativeStarterPage(String path) {
+        return List.copyOf(CREATIVE_SYMBOLS.keySet());
-        if (!List.of("terrain/standard", "biome/native", "lighting/normal", "weather/normal",
+    }
-                "celestial/normal_time", "feature/caves").contains(path)) {
+
-            throw new IllegalArgumentException("Not a starter symbol: " + path);
+    /** Bundled categories become separate creative tabs without a Java page list. */
+    public static List<ResourceLocation> bundledCreativeCategories() {
+        return List.copyOf(CREATIVE_SYMBOLS.values().stream()
+                .map(CreativeSymbol::creativeCategory)
+                .collect(java.util.stream.Collectors.toCollection(LinkedHashSet::new)));
+    }
+
+    public static ItemStack bundledCreativeCategoryIcon(ResourceLocation category) {
+        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 = 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()))
+                .sorted()
+                .forEach(id -> pages.add(createCreativeBiomePage(id)));
+        return List.copyOf(pages);
+    }
+
+    public static List<ItemStack> creativeSymbolPages(HolderLookup.Provider registries,
+                                                      ResourceLocation category) {
+        return creativeSymbolPages(registries).stream()
+                .filter(page -> category.equals(creativeCategory(page)))
+                .toList();
+    }
+
+    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();
         }
-        SymbolReference reference = new SymbolReference(
+        return metadata.category();
-                net.minecraft.resources.ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path));
+    }
+
+    /** Bundled symbols for the creative tab; the server still validates catalog membership on use. */
+    public static ItemStack createBundledCreativePage(String path) {
+        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));
-        String key = "symbol.rivencraft." + path.replace('/', '.');
+        page.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), metadata);
-        page.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), new SymbolDisplayMetadata(
-                reference.id(), key, key + ".description",
-                net.minecraft.resources.ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path.split("/")[0]),
-                true, SymbolPoems.builtIn(reference.id())));
         return page;
     }
 
+    public static ItemStack createCreativeBiomePage(net.minecraft.resources.ResourceLocation biomeId) {
+        var symbolId = BiomeSymbolPages.symbolId(biomeId);
+        ItemStack page = create(PageContent.symbol(new SymbolReference(symbolId)));
+        page.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), BiomeSymbolPages.definition(biomeId).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) {
+                throw new IllegalStateException("Missing generated creative symbol index " + resource);
+            }
+            var json = JsonParser.parseReader(new InputStreamReader(stream, StandardCharsets.UTF_8))
+                    .getAsJsonObject();
+            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);
+                }
+                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) {
+            throw new IllegalStateException("Could not read generated creative symbol index " + resource, exception);
+        }
+    }
+
     public static ItemStack createLinkPanelPage() {
         return create(PageContent.LINK_PANEL);
     }
@@ -128,9 +228,12 @@ public final class PageItem extends Item {
     private static Component symbolName(ItemStack stack, SymbolReference reference) {
         SymbolDisplayMetadata metadata = stack.getOrDefault(
                 ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), SymbolCatalog.display(reference));
-        return metadata.resolved()
+        if (!metadata.resolved()) return Component.translatable("item.rivencraft.page.unresolved");
-                ? Component.translatable(metadata.nameTranslationKey())
+        return reference.id().getNamespace().equals(Rivencraft.MOD_ID)
-                : Component.translatable("item.rivencraft.page.unresolved");
+                && reference.id().getPath().startsWith("biome/")
+                ? Component.translatableWithFallback(metadata.nameTranslationKey(),
+                        BiomeSymbolPages.fallbackName(reference.id()))
+                : Component.translatable(metadata.nameTranslationKey());
     }
 
 }

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

@@ -7,6 +7,7 @@ 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;
@@ -118,7 +119,9 @@ public final class ModNetworking {
         PacketDistributor.sendToPlayer(player, new OpenDescriptiveBookScreenPayload(
                 payload.fromStand(), payload.offhand(),
                 GlobalPos.of(player.level().dimension(), payload.standPos()), access.stack().copy(),
-                definition == null ? null : definition.traits(), writingSymbols));
+                definition == null ? null : definition.plan() != null && definition.plan().biomeSelection() != null
+                        ? definition.traits().withBiomeDistribution(definition.plan().biomeSelection().distribution())
+                        : definition.traits(), writingSymbols));
     }
 
     private static void bindDescriptiveBook(BindDescriptiveBookPayload payload, IPayloadContext context) {
@@ -144,9 +147,8 @@ public final class ModNetworking {
             return;
         }
         try {
-            AgeGenerationPlan.compile(access.stack()
+            AgeRegistrySavedData.validateNewWriting(player.serverLevel(), title,
-                    .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY),
+                    access.stack().getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY));
-                    0L, AgeGenerationProfiles.STANDARD);
         } catch (IllegalArgumentException exception) {
             player.displayClientMessage(Component.translatable("message.rivencraft.descriptive_book.invalid_writing",
                     exception.getMessage()), true);
@@ -312,15 +314,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 AgeEnvironmentCompiler.previewSkyColor(level.dimensionType().effectsLocation(),
-            return 0xFF6B2725;
+                level.getBiome(origin).value().getSkyColor());
-        }
-        if (level.dimension().equals(Level.END)) {
-            return 0xFF211835;
-        }
-        return level.getBiome(origin).value().getSkyColor();
     }
 
     private static InteractionHand hand(boolean offhand) {

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

@@ -0,0 +1,21 @@
+package net.dnorberg.rivencraft.registry;
+
+import com.mojang.serialization.MapCodec;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.neoforged.bus.api.IEventBus;
+import net.neoforged.neoforge.registries.DeferredRegister;
+
+/** Serializable generators for Age profiles. */
+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); }
+
+    private ModChunkGenerators() { }
+
+    public static void register(IEventBus bus) { GENERATORS.register(bus); }
+}

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;
@@ -28,20 +34,39 @@ public final class ModCreativeTabs {
                     })
                     .build());
 
-    public static final DeferredHolder<CreativeModeTab, CreativeModeTab> PAGES =
+    public static final DeferredHolder<CreativeModeTab, CreativeModeTab> LINK_PAGES =
-            CREATIVE_TABS.register("rivencraft_pages", () -> CreativeModeTab.builder()
+            CREATIVE_TABS.register("rivencraft_link_pages", () -> CreativeModeTab.builder()
-                    .title(Component.translatable("itemGroup.rivencraft.pages"))
+                    .title(Component.translatable("itemGroup.rivencraft.pages.link"))
                     .icon(PageItem::createLinkPanelPage)
-                    .displayItems((parameters, output) -> {
+                    .displayItems((parameters, output) -> output.accept(PageItem.createLinkPanelPage()))
-                        output.accept(ModItems.PAGE.get());
-                        output.accept(PageItem.createLinkPanelPage());
-                        for (String id : new String[] {"terrain/standard", "biome/native", "lighting/normal",
-                                "weather/normal", "celestial/normal_time", "feature/caves"}) {
-                            output.accept(PageItem.createCreativeStarterPage(id));
-                        }
-                    })
                     .build());
 
+    private static final List<String> CATEGORY_ORDER = List.of(
+            "terrain", "biome", "biome_generation", "weather", "lighting", "sky", "celestial", "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/world/AgeFlatChunkGenerator.java

@@ -0,0 +1,112 @@
+package net.dnorberg.rivencraft.world;
+
+import com.mojang.serialization.MapCodec;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Stream;
+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.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.biome.BiomeManager;
+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.chunk.ChunkGenerator;
+import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
+import net.minecraft.world.level.levelgen.GenerationStep;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.blending.Blender;
+import net.minecraft.world.level.levelgen.flat.FlatLevelGeneratorSettings;
+import net.minecraft.world.level.levelgen.structure.StructureSet;
+
+/** Vanilla flat layers with a serializable authored biome source instead of a fixed biome. */
+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))
+                    .apply(instance, AgeFlatChunkGenerator::new));
+
+    private final FlatLevelGeneratorSettings settings;
+
+    public AgeFlatChunkGenerator(BiomeSource biomeSource, FlatLevelGeneratorSettings settings) {
+        super(biomeSource, Util.memoize(settings::adjustGenerationSettings));
+        this.settings = settings;
+    }
+
+    public FlatLevelGeneratorSettings settings() { return settings; }
+
+    @Override
+    protected MapCodec<? extends ChunkGenerator> codec() { return CODEC; }
+
+    @Override
+    public ChunkGeneratorStructureState createState(HolderLookup<StructureSet> structures, RandomState random, long seed) {
+        Stream<Holder<StructureSet>> entries = settings.structureOverrides()
+                .map(HolderSet::stream)
+                .orElseGet(() -> structures.listElements().map(holder -> (Holder<StructureSet>) holder));
+        return ChunkGeneratorStructureState.createForFlat(random, seed, biomeSource, entries);
+    }
+
+    @Override
+    public void buildSurface(WorldGenRegion level, StructureManager structures, RandomState random, ChunkAccess chunk) { }
+
+    @Override
+    public int getSpawnHeight(LevelHeightAccessor level) {
+        return level.getMinBuildHeight() + Math.min(level.getHeight(), settings.getLayers().size());
+    }
+
+    @Override
+    public CompletableFuture<ChunkAccess> fillFromNoise(Blender blender, RandomState random,
+                                                         StructureManager structures, ChunkAccess chunk) {
+        List<BlockState> layers = settings.getLayers();
+        BlockPos.MutableBlockPos position = new BlockPos.MutableBlockPos();
+        Heightmap floor = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.OCEAN_FLOOR_WG);
+        Heightmap surface = chunk.getOrCreateHeightmapUnprimed(Heightmap.Types.WORLD_SURFACE_WG);
+        for (int i = 0; i < Math.min(chunk.getHeight(), layers.size()); i++) {
+            BlockState state = layers.get(i);
+            if (state == null) continue;
+            int y = chunk.getMinBuildHeight() + i;
+            for (int x = 0; x < 16; x++) {
+                for (int z = 0; z < 16; z++) {
+                    chunk.setBlockState(position.set(x, y, z), state, false);
+                    floor.update(x, y, z, state);
+                    surface.update(x, y, z, state);
+                }
+            }
+        }
+        return CompletableFuture.completedFuture(chunk);
+    }
+
+    @Override
+    public int getBaseHeight(int x, int z, Heightmap.Types type, LevelHeightAccessor level, RandomState random) {
+        List<BlockState> layers = settings.getLayers();
+        for (int i = Math.min(layers.size(), level.getHeight()) - 1; i >= 0; i--) {
+            BlockState state = layers.get(i);
+            if (state != null && type.isOpaque().test(state)) return level.getMinBuildHeight() + i + 1;
+        }
+        return level.getMinBuildHeight();
+    }
+
+    @Override
+    public NoiseColumn getBaseColumn(int x, int z, LevelHeightAccessor level, RandomState random) {
+        return new NoiseColumn(level.getMinBuildHeight(), settings.getLayers().stream()
+                .limit(level.getHeight()).map(state -> state == null ? Blocks.AIR.defaultBlockState() : state)
+                .toArray(BlockState[]::new));
+    }
+
+    @Override public void addDebugScreenInfo(List<String> info, RandomState random, BlockPos position) { }
+    @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) { }
+    @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/ScaledBiomeSource.java

@@ -24,8 +24,8 @@ public final class ScaledBiomeSource extends BiomeSource {
     private final int cellWidth;
 
     public ScaledBiomeSource(HolderSet<Biome> biomes, long seed, int scale) {
-        if (biomes.size() < 3) {
+        if (biomes.size() < 2) {
-            throw new IllegalArgumentException("Scaled biome distributions require at least three biomes");
+            throw new IllegalArgumentException("Scaled biome distributions require at least two biomes");
         }
         this.biomes = biomes;
         this.seed = seed;

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

@@ -0,0 +1,43 @@
+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.resources.ResourceLocation;
+
+/** Built-in fallback pages for registered vanilla 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());
+    }
+
+    public static SymbolDefinition definition(ResourceLocation biomeId) {
+        String path = biomeId.getPath();
+        String glyphWord = 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 (glyphWord.isEmpty()) glyphWord = "World";
+        return new SymbolDefinition(SymbolDefinition.CURRENT_SCHEMA_VERSION,
+                "symbol.rivencraft.biome." + path,
+                "symbol.rivencraft.biome.generated.description",
+                CATEGORY,
+                Optional.of(new SymbolSemantics(SymbolSemantics.Role.BIOME,
+                        new SymbolSemantics.ResourceValue(biomeId))),
+                "Nature Form " + glyphWord + " Biome");
+    }
+
+    public static String fallbackName(ResourceLocation symbolId) {
+        String path = symbolId.getPath().substring("biome/".length());
+        return Arrays.stream(path.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";
+    }
+}

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

@@ -8,6 +8,8 @@ import java.util.Map;
 import java.util.Optional;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.Registries;
 import net.minecraft.server.packs.resources.ResourceManager;
 import net.minecraft.server.packs.resources.SimpleJsonResourceReloadListener;
 import net.minecraft.util.profiling.ProfilerFiller;
@@ -23,7 +25,7 @@ public final class SymbolCatalog {
     }
 
     public static void register(AddReloadListenerEvent event) {
-        event.addListener(new Loader());
+        event.addListener(new Loader(event.getRegistryAccess()));
     }
 
     public static Optional<SymbolDefinition> find(SymbolReference reference) {
@@ -46,8 +48,11 @@ public final class SymbolCatalog {
     }
 
     private static final class Loader extends SimpleJsonResourceReloadListener {
-        private Loader() {
+        private final RegistryAccess registries;
+
+        private Loader(RegistryAccess registries) {
             super(GSON, DIRECTORY);
+            this.registries = registries;
         }
 
         @Override
@@ -62,6 +67,11 @@ public final class SymbolCatalog {
                     Rivencraft.LOGGER.error("Ignoring invalid writing symbol {}: {}", id, exception.getMessage());
                 }
             });
+            registries.lookupOrThrow(Registries.BIOME).listElements()
+                    .map(holder -> holder.key().location())
+                    .filter(id -> id.getNamespace().equals("minecraft"))
+                    .forEach(id -> loaded.putIfAbsent(BiomeSymbolPages.symbolId(id),
+                            BiomeSymbolPages.definition(id)));
             symbols = Map.copyOf(loaded);
             Rivencraft.LOGGER.info("Loaded {} writing symbols", loaded.size());
         }

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

@@ -10,6 +10,11 @@ public final class SymbolPoems {
         if (!id.getNamespace().equals("rivencraft")) return "";
         return switch (id.getPath()) {
             case "terrain/standard" -> "Terrain Form Tradition Flow";
+            case "terrain/amplified" -> "Terrain Form Tradition Spur";
+            case "terrain/cave" -> "Terrain Transform Void Flow";
+            case "terrain/island" -> "Terrain Transform Form Celestial";
+            case "terrain/flat" -> "Terrain Form Inhibit Motion";
+            case "terrain/void" -> "Terrain Form Infinite Void";
             case "biome/native" -> "Constraint Nature Tradition Sustain";
             case "lighting/normal" -> "Ethereal Dynamic Cycle Balance";
             case "weather/normal" -> "Sustain Dynamic Tradition Balance";

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

@@ -77,6 +77,7 @@ public record SymbolSemantics(Role role, Value value) {
                 "native", "single", "tiled", "grid", "tiny", "small", "medium", "large", "huge"),
         BIOME("biome", Kind.RESOURCE),
         LIGHTING("lighting", Kind.CHOICE, "normal", "dark", "bright"),
+        SKY("sky", Kind.CHOICE, "overworld", "nether", "end"),
         WEATHER("weather", Kind.CHOICE,
                 "normal", "fast", "slow", "off", "always", "cloudy", "rain", "snow", "storm"),
         CELESTIAL("celestial", Kind.CHOICE, "normal_time"),

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

@@ -69,6 +69,12 @@ public final class WritingGrammar {
             Role role = semantics.orElseThrow().role();
             ParsedSymbol parsed = new ParsedSymbol(index, reference, semantics.orElseThrow());
             symbols.add(parsed);
+            if (role == Role.ANGLE_MODIFIER || role == Role.WEATHER
+                    && parsed.semantics().value() instanceof ChoiceValue choice
+                    && Set.of("snow", "cloudy", "rain").contains(choice.id())) {
+                diagnostics.add(new Diagnostic(Code.UNSUPPORTED_ENVIRONMENT, index,
+                        "This environment effect needs renderer or precipitation support"));
+            }
             if (singular(role)) {
                 ParsedSymbol previous = singular.putIfAbsent(role, parsed);
                 if (previous != null) {
@@ -117,7 +123,7 @@ public final class WritingGrammar {
                 case "single" -> 1;
                 case "tiled", "grid" -> 2;
                 case "native" -> 0;
-                default -> 3;
+                default -> 2;
             };
             if (biomeCount < minimum) diagnostics.add(new Diagnostic(Code.INCOMPLETE, -1,
                     "The Age compiler will fill " + (minimum - biomeCount) + " missing biome page(s)"));
@@ -127,7 +133,7 @@ public final class WritingGrammar {
 
     private static boolean singular(Role role) {
         return switch (role) {
-            case TERRAIN, BIOME_CONTROLLER, WEATHER, LIGHTING, CELESTIAL -> true;
+            case TERRAIN, BIOME_CONTROLLER, WEATHER, LIGHTING, SKY, CELESTIAL -> true;
             default -> false;
         };
     }
@@ -143,15 +149,17 @@ public final class WritingGrammar {
             case BIOME_CONTROLLER -> 2;
             case WEATHER -> 3;
             case LIGHTING -> 4;
-            case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER -> 5;
+            case SKY -> 5;
-            case CELESTIAL -> 6;
+            case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER -> 6;
-            case FEATURE -> 7;
+            case CELESTIAL -> 7;
+            case FEATURE -> 8;
         };
     }
 
     public enum Code {
         TOO_MANY, MISSING_PANEL, PANEL_ORDER, DUPLICATE_PANEL, UNRESOLVED, UNSUPPORTED,
-        DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER, INCOMPLETE, UNSUPPORTED_PROFILE
+        DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER, INCOMPLETE, UNSUPPORTED_PROFILE,
+        UNKNOWN_BIOME, UNSUPPORTED_BIOME, UNSUPPORTED_ENVIRONMENT
     }
 
     public record Diagnostic(Code code, int index, String message) {

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

@@ -41,6 +41,7 @@
   "screen.rivencraft.book_binder.grammar.unresolved": "Page %s: missing symbol definition; restore its data pack or remove it",
   "screen.rivencraft.book_binder.grammar.unsupported": "Page %s: this symbol needs semantic schema v2; update its data pack or remove it",
   "screen.rivencraft.book_binder.grammar.unsupported_profile": "Page %s: its Age profile is unavailable; restore the data pack or remove this page",
+  "screen.rivencraft.book_binder.grammar.unsupported_environment": "Page %s: this weather or sky effect is not supported yet",
   "screen.rivencraft.book_binder.grammar.duplicate": "Page %s: remove the duplicate symbol",
   "screen.rivencraft.book_binder.grammar.conflict": "Page %s: replace the conflicting symbol",
   "screen.rivencraft.book_binder.grammar.out_of_order": "Page %s: move this symbol before later categories",
@@ -87,7 +88,6 @@
   "screen.rivencraft.age.pages": "Pages",
   "screen.rivencraft.age.details": "Details",
   "screen.rivencraft.age.pages_count": "Writing %s/%s",
-  "screen.rivencraft.age.pages_not_applied": "Symbols not applied yet",
   "screen.rivencraft.age.trait.biomes": "Biomes: %s",
   "screen.rivencraft.age.trait.lighting": "Lighting: %s",
   "screen.rivencraft.age.trait.weather": "Weather: %s",
@@ -120,14 +120,93 @@
   "symbol.rivencraft.unresolved.description": "Missing symbol: %s",
   "symbol.rivencraft.terrain.standard": "Standard Terrain",
   "symbol.rivencraft.terrain.standard.description": "A familiar continental terrain foundation.",
+  "symbol.rivencraft.terrain.amplified": "Amplified Terrain",
+  "symbol.rivencraft.terrain.amplified.description": "Tall, sharply varied Overworld terrain.",
+  "symbol.rivencraft.terrain.cave": "Cave Terrain",
+  "symbol.rivencraft.terrain.cave.description": "An enclosed cave-shaped world with a sheltered arrival.",
+  "symbol.rivencraft.terrain.island": "Island Terrain",
+  "symbol.rivencraft.terrain.island.description": "Floating-island terrain above the void.",
+  "symbol.rivencraft.terrain.flat": "Flat Terrain",
+  "symbol.rivencraft.terrain.flat.description": "A level Overworld-style landscape.",
+  "symbol.rivencraft.terrain.void": "Void Terrain",
+  "symbol.rivencraft.terrain.void.description": "An empty world with a safe arrival platform.",
   "symbol.rivencraft.biome.native": "Native Biomes",
   "symbol.rivencraft.biome.native.description": "Use the terrain profile's native biome climate.",
+  "symbol.rivencraft.biome.the_end": "The End Biome",
+  "symbol.rivencraft.biome.the_end.description": "Use the End biome in a written Age, including sky islands.",
+  "symbol.rivencraft.biome.lush_caves": "Lush Caves Biome",
+  "symbol.rivencraft.biome.lush_caves.description": "Add lush cave regions to a cave Age.",
+  "symbol.rivencraft.biome.dripstone_caves": "Dripstone Caves Biome",
+  "symbol.rivencraft.biome.dripstone_caves.description": "Add dripstone cave regions to a cave Age.",
+  "symbol.rivencraft.biome.deep_dark": "Deep Dark Biome",
+  "symbol.rivencraft.biome.deep_dark.description": "Add deep dark regions to a cave Age.",
+  "symbol.rivencraft.biome.nether_wastes": "Nether Wastes Biome",
+  "symbol.rivencraft.biome.nether_wastes.description": "Add Nether Wastes regions to a cave Age.",
+  "symbol.rivencraft.biome.plains": "Plains Biome",
+  "symbol.rivencraft.biome.plains.description": "Add plains regions to a written Age.",
+  "symbol.rivencraft.biome.forest": "Forest Biome",
+  "symbol.rivencraft.biome.forest.description": "Add forest regions to a written Age.",
+  "symbol.rivencraft.biome.desert": "Desert Biome",
+  "symbol.rivencraft.biome.desert.description": "Add desert regions to a written Age.",
+  "symbol.rivencraft.biome.generated.description": "Selects this biome for a written Age.",
+  "symbol.rivencraft.biome.single": "Single Biome",
+  "symbol.rivencraft.biome.single.description": "Use one biome across the Age.",
+  "symbol.rivencraft.biome.tiled": "Tiled Biomes",
+  "symbol.rivencraft.biome.tiled.description": "Alternate selected biomes in large tiles.",
+  "symbol.rivencraft.biome.grid": "Grid Biomes",
+  "symbol.rivencraft.biome.grid.description": "Alternate selected biomes in smaller grid cells.",
+  "symbol.rivencraft.biome.tiny": "Tiny Biome Regions",
+  "symbol.rivencraft.biome.tiny.description": "Distribute selected biomes in tiny regions.",
+  "symbol.rivencraft.biome.small": "Small Biome Regions",
+  "symbol.rivencraft.biome.small.description": "Distribute selected biomes in small regions.",
+  "symbol.rivencraft.biome.medium": "Medium Biome Regions",
+  "symbol.rivencraft.biome.medium.description": "Distribute selected biomes in medium regions.",
+  "symbol.rivencraft.biome.large": "Large Biome Regions",
+  "symbol.rivencraft.biome.large.description": "Distribute selected biomes in large regions.",
+  "symbol.rivencraft.biome.huge": "Huge Biome Regions",
+  "symbol.rivencraft.biome.huge.description": "Distribute selected biomes in huge regions.",
   "symbol.rivencraft.lighting.normal": "Normal Lighting",
   "symbol.rivencraft.lighting.normal.description": "Use normal skylight and ambient brightness.",
+  "symbol.rivencraft.lighting.dark": "Dark Lighting",
+  "symbol.rivencraft.lighting.dark.description": "Remove skylight from this Age.",
+  "symbol.rivencraft.lighting.bright": "Bright Lighting",
+  "symbol.rivencraft.lighting.bright.description": "Increase this Age's ambient brightness.",
+  "symbol.rivencraft.sky.overworld": "Overworld Sky",
+  "symbol.rivencraft.sky.overworld.description": "Use the Overworld sky and biome sky tint.",
+  "symbol.rivencraft.sky.nether": "Nether Sky",
+  "symbol.rivencraft.sky.nether.description": "Use the Nether sky and red preview background.",
+  "symbol.rivencraft.sky.end": "End Sky",
+  "symbol.rivencraft.sky.end.description": "Use the End sky and dark preview background.",
   "symbol.rivencraft.weather.normal": "Normal Weather",
   "symbol.rivencraft.weather.normal.description": "Use the normal weather cycle.",
+  "symbol.rivencraft.weather.fast": "Fast Weather",
+  "symbol.rivencraft.weather.fast.description": "Change weather more quickly.",
+  "symbol.rivencraft.weather.slow": "Slow Weather",
+  "symbol.rivencraft.weather.slow.description": "Change weather more slowly.",
+  "symbol.rivencraft.weather.off": "No Weather",
+  "symbol.rivencraft.weather.off.description": "Keep the Age clear.",
+  "symbol.rivencraft.weather.always": "Always Weather",
+  "symbol.rivencraft.weather.always.description": "Keep the Age rainy.",
+  "symbol.rivencraft.weather.storm": "Storm Weather",
+  "symbol.rivencraft.weather.storm.description": "Keep the Age rainy and thundering.",
   "symbol.rivencraft.celestial.normal_time": "Normal Time",
   "symbol.rivencraft.celestial.normal_time.description": "Use a normal-length celestial cycle.",
+  "symbol.rivencraft.period.zero": "Zero Length",
+  "symbol.rivencraft.period.zero.description": "Stop the celestial cycle at its written phase.",
+  "symbol.rivencraft.period.half": "Half Length",
+  "symbol.rivencraft.period.half.description": "Use a half-length celestial cycle.",
+  "symbol.rivencraft.period.full": "Full Length",
+  "symbol.rivencraft.period.full.description": "Use a normal-length celestial cycle.",
+  "symbol.rivencraft.period.double": "Double Length",
+  "symbol.rivencraft.period.double.description": "Use a double-length celestial cycle.",
+  "symbol.rivencraft.phase.nadir": "Nadir Phase",
+  "symbol.rivencraft.phase.nadir.description": "Set the celestial phase to nadir.",
+  "symbol.rivencraft.phase.rising": "Rising Phase",
+  "symbol.rivencraft.phase.rising.description": "Set the celestial phase to rising.",
+  "symbol.rivencraft.phase.zenith": "Zenith Phase",
+  "symbol.rivencraft.phase.zenith.description": "Set the celestial phase to zenith.",
+  "symbol.rivencraft.phase.setting": "Setting Phase",
+  "symbol.rivencraft.phase.setting.description": "Set the celestial phase to setting.",
   "symbol.rivencraft.feature.caves": "Caves",
   "symbol.rivencraft.feature.caves.description": "Describe underground cave features.",
   "generator.rivencraft.standard": "Standard",
@@ -151,5 +230,13 @@
   "jei.rivencraft.writing.bind": "At a Book Binder, name the Age and add a cover plus Link Panel. Optional symbol Pages follow the panel.",
   "jei.rivencraft.writing.linking_book": "Craft one Link Panel Page with leather to make an unwritten Linking Book. Open it to name and bind it.",
   "itemGroup.rivencraft": "Rivencraft",
-  "itemGroup.rivencraft.pages": "Rivencraft Pages"
+  "itemGroup.rivencraft.pages.link": "Rivencraft Link Pages",
+  "itemGroup.rivencraft.pages.terrain": "Rivencraft Terrain Pages",
+  "itemGroup.rivencraft.pages.biome": "Rivencraft Biome Pages",
+  "itemGroup.rivencraft.pages.biome_generation": "Rivencraft Biome Generation Pages",
+  "itemGroup.rivencraft.pages.weather": "Rivencraft Weather Pages",
+  "itemGroup.rivencraft.pages.lighting": "Rivencraft Lighting Pages",
+  "itemGroup.rivencraft.pages.sky": "Rivencraft Sky Pages",
+  "itemGroup.rivencraft.pages.celestial": "Rivencraft Celestial Pages",
+  "itemGroup.rivencraft.pages.feature": "Rivencraft Feature Pages"
 }

src/main/resources/data/rivencraft/rivencraft/symbols/biome/deep_dark.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.deep_dark",
+  "description": "symbol.rivencraft.biome.deep_dark.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:deep_dark" },
+  "poem": "Dark Cavern Silence Depth"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/desert.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.desert",
+  "description": "symbol.rivencraft.biome.desert.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:desert" },
+  "poem": "Sand Sun Heat Dry"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/dripstone_caves.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.dripstone_caves",
+  "description": "symbol.rivencraft.biome.dripstone_caves.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:dripstone_caves" },
+  "poem": "Stone Cavern Point Water"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/forest.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.forest",
+  "description": "symbol.rivencraft.biome.forest.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:forest" },
+  "poem": "Trees Land Shade Growth"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/grid.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.grid","description":"symbol.rivencraft.biome.grid.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"grid"},"poem":"Constraint Nature Pattern Grid"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/huge.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.huge","description":"symbol.rivencraft.biome.huge.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"huge"},"poem":"Constraint Nature Region Huge"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/large.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.large","description":"symbol.rivencraft.biome.large.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"large"},"poem":"Constraint Nature Region Large"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/lush_caves.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.lush_caves",
+  "description": "symbol.rivencraft.biome.lush_caves.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:lush_caves" },
+  "poem": "Growth Cavern Moss Water"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/medium.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.medium","description":"symbol.rivencraft.biome.medium.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"medium"},"poem":"Constraint Nature Region Medium"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/nether_wastes.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.nether_wastes",
+  "description": "symbol.rivencraft.biome.nether_wastes.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:nether_wastes" },
+  "poem": "Fire Cavern Waste Heat"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/plains.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.plains",
+  "description": "symbol.rivencraft.biome.plains.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:plains" },
+  "poem": "Grass Land Open Wind"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/single.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.single","description":"symbol.rivencraft.biome.single.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"single"},"poem":"Constraint Nature Solitary Form"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/small.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.small","description":"symbol.rivencraft.biome.small.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"small"},"poem":"Constraint Nature Region Small"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/the_end.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.biome.the_end",
+  "description": "symbol.rivencraft.biome.the_end.description",
+  "category": "rivencraft:biome",
+  "semantics": { "role": "biome", "value": "minecraft:the_end" },
+  "poem": "Island Void Sky Eternity"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/tiled.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.tiled","description":"symbol.rivencraft.biome.tiled.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"tiled"},"poem":"Constraint Nature Pattern Tile"}

src/main/resources/data/rivencraft/rivencraft/symbols/biome/tiny.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.biome.tiny","description":"symbol.rivencraft.biome.tiny.description","category":"rivencraft:biome","semantics":{"role":"biome_controller","value":"tiny"},"poem":"Constraint Nature Region Tiny"}

src/main/resources/data/rivencraft/rivencraft/symbols/lighting/bright.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.lighting.bright","description":"symbol.rivencraft.lighting.bright.description","category":"rivencraft:lighting","semantics":{"role":"lighting","value":"bright"},"poem":"Ethereal Sustain Cycle Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/lighting/dark.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.lighting.dark","description":"symbol.rivencraft.lighting.dark.description","category":"rivencraft:lighting","semantics":{"role":"lighting","value":"dark"},"poem":"Ethereal Void Cycle Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/period/double.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.period.double","description":"symbol.rivencraft.period.double.description","category":"rivencraft:celestial","semantics":{"role":"period_modifier","value":2.0},"poem":"Transform Time Cycle Dynamic"}

src/main/resources/data/rivencraft/rivencraft/symbols/period/full.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.period.full","description":"symbol.rivencraft.period.full.description","category":"rivencraft:celestial","semantics":{"role":"period_modifier","value":1.0},"poem":"Transform Time Cycle Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/period/half.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.period.half","description":"symbol.rivencraft.period.half.description","category":"rivencraft:celestial","semantics":{"role":"period_modifier","value":0.5},"poem":"Transform Time Cycle Constraint"}

src/main/resources/data/rivencraft/rivencraft/symbols/period/zero.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.period.zero","description":"symbol.rivencraft.period.zero.description","category":"rivencraft:celestial","semantics":{"role":"period_modifier","value":0.0},"poem":"Transform Time Void Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/phase/nadir.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.phase.nadir","description":"symbol.rivencraft.phase.nadir.description","category":"rivencraft:celestial","semantics":{"role":"phase_modifier","value":0.0},"poem":"Transform Time Void Tradition"}

src/main/resources/data/rivencraft/rivencraft/symbols/phase/rising.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.phase.rising","description":"symbol.rivencraft.phase.rising.description","category":"rivencraft:celestial","semantics":{"role":"phase_modifier","value":90.0},"poem":"Transform Time Flow Tradition"}

src/main/resources/data/rivencraft/rivencraft/symbols/phase/setting.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.phase.setting","description":"symbol.rivencraft.phase.setting.description","category":"rivencraft:celestial","semantics":{"role":"phase_modifier","value":270.0},"poem":"Transform Time Nature Tradition"}

src/main/resources/data/rivencraft/rivencraft/symbols/phase/zenith.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.phase.zenith","description":"symbol.rivencraft.phase.zenith.description","category":"rivencraft:celestial","semantics":{"role":"phase_modifier","value":180.0},"poem":"Transform Time Ethereal Tradition"}

src/main/resources/data/rivencraft/rivencraft/symbols/sky/end.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.sky.end","description":"symbol.rivencraft.sky.end.description","category":"rivencraft:sky","semantics":{"role":"sky","value":"end"},"poem":"Ethereal Void Sky Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/sky/nether.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.sky.nether","description":"symbol.rivencraft.sky.nether.description","category":"rivencraft:sky","semantics":{"role":"sky","value":"nether"},"poem":"Ethereal Void Sky Transform"}

src/main/resources/data/rivencraft/rivencraft/symbols/sky/overworld.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.sky.overworld","description":"symbol.rivencraft.sky.overworld.description","category":"rivencraft:sky","semantics":{"role":"sky","value":"overworld"},"poem":"Ethereal Nature Sky Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/terrain/amplified.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.terrain.amplified",
+  "description": "symbol.rivencraft.terrain.amplified.description",
+  "category": "rivencraft:terrain",
+  "semantics": { "role": "terrain", "value": "rivencraft:amplified" },
+  "poem": "Terrain Form Tradition Spur"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/terrain/cave.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.terrain.cave",
+  "description": "symbol.rivencraft.terrain.cave.description",
+  "category": "rivencraft:terrain",
+  "semantics": { "role": "terrain", "value": "rivencraft:cave" },
+  "poem": "Terrain Transform Void Flow"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/terrain/flat.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.terrain.flat",
+  "description": "symbol.rivencraft.terrain.flat.description",
+  "category": "rivencraft:terrain",
+  "semantics": { "role": "terrain", "value": "rivencraft:flat" },
+  "poem": "Terrain Form Inhibit Motion"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/terrain/island.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.terrain.island",
+  "description": "symbol.rivencraft.terrain.island.description",
+  "category": "rivencraft:terrain",
+  "semantics": { "role": "terrain", "value": "rivencraft:island" },
+  "poem": "Terrain Transform Form Celestial"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/terrain/void.json

@@ -0,0 +1,8 @@
+{
+  "schema_version": 2,
+  "name": "symbol.rivencraft.terrain.void",
+  "description": "symbol.rivencraft.terrain.void.description",
+  "category": "rivencraft:terrain",
+  "semantics": { "role": "terrain", "value": "rivencraft:void" },
+  "poem": "Terrain Form Infinite Void"
+}

src/main/resources/data/rivencraft/rivencraft/symbols/weather/always.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.weather.always","description":"symbol.rivencraft.weather.always.description","category":"rivencraft:weather","semantics":{"role":"weather","value":"always"},"poem":"Sustain Flow Cycle Tradition"}

src/main/resources/data/rivencraft/rivencraft/symbols/weather/fast.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.weather.fast","description":"symbol.rivencraft.weather.fast.description","category":"rivencraft:weather","semantics":{"role":"weather","value":"fast"},"poem":"Sustain Dynamic Flow Transform"}

src/main/resources/data/rivencraft/rivencraft/symbols/weather/off.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.weather.off","description":"symbol.rivencraft.weather.off.description","category":"rivencraft:weather","semantics":{"role":"weather","value":"off"},"poem":"Sustain Void Flow Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/weather/slow.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.weather.slow","description":"symbol.rivencraft.weather.slow.description","category":"rivencraft:weather","semantics":{"role":"weather","value":"slow"},"poem":"Sustain Dynamic Flow Balance"}

src/main/resources/data/rivencraft/rivencraft/symbols/weather/storm.json

@@ -0,0 +1 @@
+{"schema_version":2,"name":"symbol.rivencraft.weather.storm","description":"symbol.rivencraft.weather.storm.description","category":"rivencraft:weather","semantics":{"role":"weather","value":"storm"},"poem":"Sustain Nature Flow Dynamic"}

src/main/resources/data/rivencraft/tags/worldgen/biome/cave_biomes.json

@@ -0,0 +1,8 @@
+{
+  "replace": false,
+  "values": [
+    "minecraft:lush_caves",
+    "minecraft:dripstone_caves",
+    "minecraft:deep_dark"
+  ]
+}