Apply authored biome distributions and expose biome pages (#33)

BUILDING.txt

@@ -74,9 +74,11 @@ Or, with mise:
 All required GameTests should pass before distributing a build.
 
 GameTests use `build/gametest-run/world`, separate from the normal development
-world. Before each run, Gradle removes that test world if it exceeds 512 MiB.
-Override the limit with `-PgameTestMaxWorldMiB=NUMBER`. A caller-supplied
-`-PgameTestRunDir` is never removed automatically.
+world. Gradle starts each default run with a fresh world and removes it after
+every run, whether tests pass or fail. The GameTest server always uses seed `0`,
+so retries regenerate a clean world with that seed. Logs and configuration are kept.
+A caller-supplied `-PgameTestRunDir`
+is never removed automatically.
 
 To run the suite in a fresh temporary directory instead, use:
 

README.md

@@ -77,6 +77,8 @@ 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.
 JEI is optional; vanilla crafting
 recipes and all writing interactions work without it. For a development client
 with JEI, run `./gradlew runClient -PwithJei=true`.
@@ -92,10 +94,14 @@ outputs a Descriptive Book once the title, cover, and Link Panel are present.
 Inputs are consumed only when the result is taken.
 
 The completed book receives its Age identity when assembled. With only a Link
-Panel, it describes a randomly generated Age. Its writing is stored on the
-book; the Descriptive Book screen's turned pages show ordered symbols and
-unresolved IDs. Until Milestone 5, symbols do not affect generation and written
-books use the same random Age fallback. The Descriptive Book screen follows
+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. 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
 preview is on the right, and clicks in the bottom corners turn pages. Ordered
 symbol pages appear before the final blank spread; their pictograms await

build.gradle

@@ -17,7 +17,7 @@ tasks.named('wrapper', Wrapper).configure {
 version = mod_version
 group = mod_group_id
 
-List<String> archivedGameTestSuites = ['linking', 'writing', 'desk', 'binder', 'mixer', 'recipe']
+List<String> archivedGameTestSuites = ['linking', '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,42 +177,52 @@ neoForge {
     }
 }
 
-// GameTests generate Ages, so their dedicated world can grow quickly across runs.
-// Never auto-delete a caller-supplied gameTestRunDir or a normal dev world.
-long gameTestWorldLimitMiB = providers.gradleProperty('gameTestMaxWorldMiB').orElse('512').get().toLong()
-if (gameTestWorldLimitMiB <= 0) {
-    throw new GradleException('gameTestMaxWorldMiB must be a positive number')
-}
+// Vanilla's GameTestServer uses a fixed world seed of 0. Every default run
+// regenerates its world; custom run directories are never managed here.
 boolean customGameTestRunDir = providers.gradleProperty('gameTestRunDir').isPresent()
-File dedicatedGameTestDir = layout.buildDirectory.dir('gametest-run').get().asFile.canonicalFile
-File dedicatedGameTestWorld = new File(dedicatedGameTestDir, 'world')
-def cleanOversizedGameTestWorld = tasks.register('cleanOversizedGameTestWorld') {
+File dedicatedGameTestBuildDir = layout.buildDirectory.get().asFile
+File dedicatedGameTestDir = layout.buildDirectory.dir('gametest-run').get().asFile
+def prepareGameTestWorld = tasks.register('prepareGameTestWorld') {
+    onlyIf { !customGameTestRunDir }
     doLast {
-        if (customGameTestRunDir) {
-            getLogger().lifecycle('Skipping automatic GameTest world cleanup for custom gameTestRunDir')
-            return
-        }
-
-        def worldDir = dedicatedGameTestWorld
-        if (!worldDir.isDirectory() || java.nio.file.Files.isSymbolicLink(worldDir.toPath())) {
-            return
-        }
-
-        def paths = java.nio.file.Files.walk(worldDir.toPath()).withCloseable { it.toList() }
-        long bytes = paths.sum(0L) { path ->
-            java.nio.file.Files.isRegularFile(path, java.nio.file.LinkOption.NOFOLLOW_LINKS)
-                    ? java.nio.file.Files.size(path) : 0L
-        }
-        long limit = gameTestWorldLimitMiB * 1024L * 1024L
-        if (bytes > limit) {
-            getLogger().lifecycle('Removing oversized GameTest world {} ({} MiB; limit {} MiB)',
-                    worldDir, Math.ceil(bytes / 1048576d) as long, gameTestWorldLimitMiB)
-            paths.toSorted(java.util.Comparator.reverseOrder()).each { java.nio.file.Files.delete(it) }
-        }
+        GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
+    }
+}
+def finishGameTestWorld = tasks.register('finishGameTestWorld') {
+    onlyIf { !customGameTestRunDir }
+    doLast {
+        GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
     }
 }
 tasks.named('runGameTestServer').configure {
-    dependsOn(cleanOversizedGameTestWorld)
+    dependsOn(prepareGameTestWorld)
+    finalizedBy(finishGameTestWorld)
+}
+
+class GameTestWorlds {
+    static void check(File buildDir, File runDir) {
+        [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 void clean(File buildDir, File runDir) {
+        check(buildDir, runDir)
+        [new File(runDir, 'world'), new File(runDir, 'failed-worlds')].each { root ->
+            if (root.exists()) {
+                java.nio.file.Files.walk(root.toPath()).withCloseable { paths ->
+                    paths.sorted(java.util.Comparator.reverseOrder()).forEach { path ->
+                        java.nio.file.Files.delete(path)
+                    }
+                }
+            }
+        }
+        java.nio.file.Files.deleteIfExists(new File(runDir, 'failed-seed.txt').toPath())
+        java.nio.file.Files.deleteIfExists(new File(runDir, '.last-gametest-succeeded').toPath())
+    }
 }
 
 // Sets up a dependency configuration called 'localRuntime'.

docs/AGE_PROFILES.md

@@ -30,15 +30,74 @@ 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 2–4 for Tiled/Grid or 2–6 for
+Tiny–Huge, capped by the number of eligible terrain biomes. Single uses one;
+Native uses its preset biome pool. These random-age maximums do not truncate
+authored pages: the Binder's 27 symbol-page positions bound an authored book.
+Native cannot be paired with explicit biome pages. Legacy filled Tiny–Huge to
+three; Rivencraft deliberately uses two so a pair of written biome pages stays
+exactly as written.
+The Pages creative tab offers pages for every registered vanilla biome.
+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.
+
 ## 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
-reroll those immutable values. An unloaded Age resolves its stored profile
-again when it loads, so intentional profile overrides affect its runtime
-resources and newly generated chunks.
+and rolled traits. For an **authored** Age, the generation plan also stores a
+copy of the resolved runtime profile: terrain shape, noise settings, biome
+preset, and dimension type. `/reload` cannot reinterpret that plan; an unloaded
+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: 17 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 19.
 
 ```shell
 ./gradlew runGameTestServer
 ```
 
-The remaining 47 Rivencraft tests are archived, not deleted. They cover
+The remaining 56 Rivencraft tests are archived, not deleted. They cover
 completed milestone details such as every Age terrain profile, Notebook and
 Desk surface interactions, refill edge cases, book assembly controls, and
 workstation break/drop behavior. Run only the relevant archive alongside the
@@ -17,11 +16,11 @@ core tests when investigating an issue:
 
 ```shell
 ./gradlew runGameTestServer -ParchivedGameTestSuites=desk
-./gradlew runGameTestServer -ParchivedGameTestSuites=linking,binder
+./gradlew runGameTestServer -ParchivedGameTestSuites=grammar,binder
 ```
 
-Available suite names are `linking`, `writing`, `desk`, `binder`, `mixer`, and
-`recipe`. Run all 64 Rivencraft tests (66 including NeoForge's two) before a
+Available suite names are `linking`, `writing`, `grammar`, `desk`, `binder`, `mixer`, and
+`recipe`. Run all 79 Rivencraft tests before a
 release or after broad cross-system changes:
 
 ```shell
@@ -34,9 +33,11 @@ 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. The Gradle task removes that **dedicated** world automatically if
-it exceeds 512 MiB; override the threshold with `-PgameTestMaxWorldMiB=128`,
-for example. Cleanup never targets a custom `-PgameTestRunDir` or a player
-world. A fresh test world can also help diagnose a slow or stalled worldgen
-run. The full suite should still be run before shipping changes in the
-archived systems.
+client save. Every default GameTest invocation starts with a fresh world.
+Minecraft 1.21.1's GameTest server uses the fixed seed `0`. Gradle deletes the
+world after every run, whether tests pass or fail. A forcibly killed run may
+leave `world` behind; the next run deletes it 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.

docs/SYMBOL_SEMANTICS.md

@@ -39,6 +39,6 @@ These are schema bounds, not claims that Legacy shipped numeric config ranges. S
 
 The server rejects a v2 definition with an unknown top-level or semantics field, missing/incorrectly typed field, unknown role or choice, malformed/non-canonical resource ID, or out-of-range/non-finite number. An invalid definition is logged with its file ID and excluded from the active catalog. Saved pages and books still retain that ID, allowing the player to recover them if the data pack is corrected. A reload atomically replaces the catalog rather than mutating saved writing.
 
-Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for future Age compilation, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only `SymbolDisplayMetadata` (ID, translation keys, category, resolved flag); semantic definitions are not serialized to it. This slice defines and validates meaning but does **not yet apply** written symbols to Age generation; issues #30 and #31 implement parsing and compilation.
+Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only `SymbolDisplayMetadata` (ID, translation keys, category, resolved flag); semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, but does **not yet apply** written symbols to Age generation; issue #31 adds compilation.
 
 The six built-in definitions demonstrate terrain, biome-controller, lighting, weather, celestial, and feature roles. A third-party pack may add its own definitions under its namespace. Use an explicit semantic role even when the display category has the same name; the two fields serve different purposes.

docs/WRITING_GRAMMAR.md

@@ -0,0 +1,13 @@
+# Ordered Descriptive Book grammar (Milestone 5, issue #30)
+
+`WritingGrammar` interprets the saved `OrderedWriting` on the server using only `SymbolCatalog`'s schema-v2 semantics. Client display metadata, page names, and supplied translations never determine an Age's meaning. The parser is pure: it returns immutable parsed entries and indexed diagnostics without changing a book or its pages.
+
+New Binder writing has at most one Link Panel plus 27 symbol pages. The Link Panel must be first. A Link-Panel-only book, or an older book with no writing component, keeps the existing random Age path. Any authored supported symbol makes the book a partial or complete grammar. From 0.4.3.0, the server compiles it into a persistent Age plan before consuming Binder inputs or generating chunks.
+
+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.
+
+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. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages now select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome, lighting, weather, celestial, and feature effects are retained in the plan but will be applied in issues #33–#35; instability remains Milestone 6 work.
+
+The Rivencraft Pages creative tab reads a generated index of bundled symbol definitions. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page automatically in the next build; no Java starter-page list needs updating. The server catalog still decides whether that page is valid for writing. External server data-pack symbols are not included in this bundled index.

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.1.5
+mod_version=0.4.5.3
 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

@@ -5,6 +5,9 @@ import java.util.List;
 import java.util.UUID;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
+import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
@@ -12,10 +15,16 @@ import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.writing.NotebookContents;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+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;
@@ -108,7 +117,88 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             if (!page.isEmpty() && (!validPage(page) || !PageItem.isUsableWriting(page) || page.getCount() != 1
                     || PageItem.content(page).kind() == PageContent.Kind.BLANK)) return false;
         }
-        return true;
+        OrderedWriting writing = currentWriting();
+        if (!writingGrammar().canCreate()) return false;
+        try {
+            if (level instanceof ServerLevel serverLevel) {
+                AgeRegistrySavedData.validateNewWriting(serverLevel, title, writing);
+            } else {
+                AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD,
+                        net.dnorberg.rivencraft.book.AgeTraits.select(0L), level.registryAccess());
+            }
+            return true;
+        } catch (IllegalArgumentException exception) {
+            return false;
+        }
+    }
+
+    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.isPresent()) {
+            var profileId = ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id();
+            if (!AgeRuntimeProfiles.profiles().containsKey(profileId)) {
+                diagnostics.add(new WritingGrammar.Diagnostic(WritingGrammar.Code.UNSUPPORTED_PROFILE,
+                        terrain.orElseThrow().index(), "Restore the Age profile " + profileId + " 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);
+    }
+
+    /** Map the parser's compact entry index back to the visible strip, including empty page positions. */
+    public int writingStripIndex(int grammarIndex) {
+        if (grammarIndex < 0) return -1;
+        int entryIndex = 0;
+        if (canPlaceItem(LINK_PANEL, items.get(LINK_PANEL))) {
+            if (grammarIndex == 0) return 0;
+            entryIndex++;
+        }
+        for (int slot = FIRST_PAGE; slot < SIZE; slot++) {
+            ItemStack page = items.get(slot);
+            if (!page.isEmpty() && PageItem.content(page).symbol().isPresent()) {
+                if (entryIndex == grammarIndex) return slot - FIRST_PAGE + 1;
+                entryIndex++;
+            }
+        }
+        return -1;
+    }
+
+    private OrderedWriting currentWriting() {
+        List<WritingEntry> entries = new ArrayList<>();
+        if (canPlaceItem(LINK_PANEL, items.get(LINK_PANEL))) entries.add(WritingEntry.linkPanel());
+        for (int slot = FIRST_PAGE; slot < SIZE; slot++) {
+            ItemStack page = items.get(slot);
+            if (!page.isEmpty()) PageItem.content(page).symbol().ifPresent(reference ->
+                    entries.add(WritingEntry.symbol(reference)));
+        }
+        return new OrderedWriting(entries);
     }
 
     public ItemStack previewBook() {
@@ -117,15 +207,9 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             pendingAgeId = UUID.randomUUID();
             setChanged();
         }
-        List<WritingEntry> entries = new ArrayList<>();
-        entries.add(WritingEntry.linkPanel());
-        for (int slot = FIRST_PAGE; slot < SIZE; slot++) {
-            ItemStack page = items.get(slot);
-            if (!page.isEmpty()) entries.add(WritingEntry.symbol(PageItem.content(page).symbol().orElseThrow()));
-        }
         ItemStack book = new ItemStack(ModItems.DESCRIPTIVE_BOOK.get());
         book.set(ModDataComponents.AGE_REFERENCE.get(), new AgeReference(pendingAgeId, title));
-        book.set(ModDataComponents.BOOK_WRITING.get(), new OrderedWriting(entries));
+        book.set(ModDataComponents.BOOK_WRITING.get(), currentWriting());
         book.set(DataComponents.CUSTOM_NAME, Component.literal(title));
         return book;
     }
@@ -135,7 +219,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
         if (!canAssemble()) return false;
         if (pendingAgeId == null) pendingAgeId = UUID.randomUUID();
         if (level instanceof ServerLevel serverLevel)
-            AgeRegistrySavedData.resolveOrCreate(serverLevel, new AgeReference(pendingAgeId, title));
+            AgeRegistrySavedData.resolveOrCreate(serverLevel, new AgeReference(pendingAgeId, title), currentWriting());
         items.get(COVER).shrink(1);
         if (items.get(COVER).isEmpty()) items.set(COVER, ItemStack.EMPTY);
         items.get(LINK_PANEL).shrink(1);

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

@@ -0,0 +1,139 @@
+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> eligible = eligible(registries, profile);
+        if (eligible.isEmpty()) throw new IllegalArgumentException("No eligible biomes for terrain " + profile.noiseSettings());
+        if (distribution == AgeTraits.BiomeDistribution.NATIVE) {
+            if (!authored.isEmpty()) throw new IllegalArgumentException("Native biome distribution cannot use biome pages");
+            return new AgeBiomeSelection(distribution, profile.terrain() == AgeRuntimeProfile.Terrain.FLAT
+                    ? List.of(ResourceLocation.withDefaultNamespace("plains")) : eligible);
+        }
+        List<ResourceLocation> selected = new ArrayList<>(authored);
+        Set<ResourceLocation> distinct = new LinkedHashSet<>(selected);
+        int minimum = minimum(distribution);
+        int target = minimum;
+        if (authored.isEmpty()) {
+            int maximum = Math.min(maximum(distribution), new LinkedHashSet<>(eligible).size());
+            if (maximum >= minimum) {
+                target += new Random(seed ^ 0x42494F4D45434F55L).nextInt(maximum - minimum + 1);
+            }
+        }
+        List<ResourceLocation> filler = new ArrayList<>(eligible);
+        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;
+        };
+    }
+
+    /** Random-age limits; authored biome pages are never truncated to this maximum. */
+    public static int maximum(AgeTraits.BiomeDistribution distribution) {
+        return switch (distribution) {
+            case NATIVE, SINGLE -> 1;
+            case TILED, GRID -> 4;
+            case TINY, SMALL, MEDIUM, LARGE, HUGE -> 6;
+        };
+    }
+}

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

@@ -16,12 +16,13 @@ public record AgeDefinition(
         long createdGameTime,
         ResourceLocation dimensionId,
         BlockPos spawn,
-        AgeTraits traits
+        AgeTraits traits,
+        AgeGenerationPlan plan
 ) {
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
     );
-    public static final int CURRENT_GENERATION_VERSION = 13;
+    public static final int CURRENT_GENERATION_VERSION = 16;
 
     public AgeDefinition {
         Objects.requireNonNull(id, "id");
@@ -29,6 +30,16 @@ public record AgeDefinition(
         Objects.requireNonNull(generationProfile, "generationProfile");
         Objects.requireNonNull(dimensionId, "dimensionId");
         Objects.requireNonNull(traits, "traits");
+        if (plan != null && plan.ageSeed() != seed) {
+            throw new IllegalArgumentException("Age plan seed does not match its Age definition");
+        }
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, null);
     }
 
     public static ResourceLocation dimensionId(UUID ageId) {
@@ -59,6 +70,6 @@ public record AgeDefinition(
 
     public AgeDefinition withSpawn(BlockPos spawn) {
         return new AgeDefinition(id, name, seed, generationProfile, generationVersion,
-                createdGameTime, dimensionId, spawn.immutable(), traits);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan);
     }
 }

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

@@ -6,10 +6,15 @@ 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;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.GlobalPos;
 import net.minecraft.core.Holder;
@@ -31,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;
@@ -59,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),
@@ -73,7 +80,12 @@ public final class AgeDimensionService {
     }
 
     public static Optional<LinkTarget> resolve(ServerPlayer player, AgeReference reference) {
-        AgeDefinition definition = AgeRegistrySavedData.resolveOrCreate(player.serverLevel(), reference);
+        return resolve(player, reference, OrderedWriting.EMPTY);
+    }
+
+    public static Optional<LinkTarget> resolve(ServerPlayer player, AgeReference reference,
+                                                OrderedWriting writing) {
+        AgeDefinition definition = AgeRegistrySavedData.resolveOrCreate(player.serverLevel(), reference, writing);
         ServerLevel level = ensureLoaded(player.getServer(), definition);
         if (level == null) {
             return Optional.empty();
@@ -100,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(),
@@ -148,6 +162,22 @@ 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);
         level.setDayTime(phaseTime);
@@ -261,13 +291,16 @@ public final class AgeDimensionService {
     }
 
     private static ChunkGenerator createGenerator(MinecraftServer server, AgeDefinition age) {
-        AgeRuntimeProfile profile = AgeRuntimeProfiles.resolve(age.generationProfile());
+        AgeRuntimeProfile profile = runtimeProfile(age);
+        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(
@@ -276,17 +309,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)));
     }
@@ -333,34 +362,86 @@ public final class AgeDimensionService {
     private static BiomeSource createBiomeSource(
             MinecraftServer server,
             AgeDefinition age,
-            net.minecraft.core.HolderGetter<net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList> biomeParameters,
-            ResourceKey<net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList> biomePreset
+            AgeRuntimeProfile profile
     ) {
-        List<net.minecraft.core.Holder.Reference<Biome>> biomes = server.registryAccess()
-                .lookupOrThrow(Registries.BIOME)
-                .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));
+        if (age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION) {
+            return legacyBiomeSource(server, age, profile);
         }
-        AgeTraits.BiomeDistribution distribution = age.traits().biomeDistribution();
-        if ((distribution == AgeTraits.BiomeDistribution.TILED
-                || distribution == AgeTraits.BiomeDistribution.GRID) && biomes.size() >= 2) {
-            List<net.minecraft.core.Holder.Reference<Biome>> selected = new java.util.ArrayList<>(biomes);
-            long salt = distribution == AgeTraits.BiomeDistribution.GRID
-                    ? 0x4752494442494F4DL
-                    : 0x54494C454442494FL;
-            Collections.shuffle(selected, new java.util.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
-            );
+        AgeBiomeSelection selection = age.plan() != null && age.plan().biomeSelection() != null
+                ? age.plan().biomeSelection()
+                : AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(OrderedWriting.EMPTY),
+                        age.traits(), profile, age.seed(), server.registryAccess());
+        var registry = server.registryAccess().lookupOrThrow(Registries.BIOME);
+        List<Holder<Biome>> biomes = new ArrayList<>();
+        List<ResourceLocation> fallbacks = AgeBiomeSelection.eligible(server.registryAccess(), profile);
+        Set<ResourceLocation> present = new LinkedHashSet<>();
+        for (ResourceLocation id : selection.biomes()) {
+            var holder = registry.get(ResourceKey.create(Registries.BIOME, id));
+            if (holder.isEmpty()) {
+                ResourceLocation fallback = fallbacks.stream().filter(candidate -> !present.contains(candidate))
+                        .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;
@@ -368,28 +449,25 @@ public final class AgeDimensionService {
             case HUGE -> 4;
             default -> -1;
         };
-        if (scaledBiomeScale >= 0 && biomes.size() >= 3) {
-            List<net.minecraft.core.Holder.Reference<Biome>> selected = new java.util.ArrayList<>(biomes);
+        if (scale >= 0 && all.size() >= 3) {
+            List<Holder.Reference<Biome>> selected = new ArrayList<>(all);
             long salt = distribution == AgeTraits.BiomeDistribution.TINY
-                    ? 0x54494E5942494F4DL
-                    : 0x5343414C45444249L;
-            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))),
-                    age.seed(),
-                    scaledBiomeScale
-            );
+                    ? 0x54494E5942494F4DL : 0x5343414C45444249L;
+            Collections.shuffle(selected, new Random(age.seed() ^ salt));
+            return new ScaledBiomeSource(HolderSet.direct(List.of(selected.get(0), selected.get(1), selected.get(2))),
+                    age.seed(), scale);
         }
-        return MultiNoiseBiomeSource.createFromPreset(
-                biomeParameters.getOrThrow(biomePreset));
+        var parameters = server.registryAccess().lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST);
+        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 = AgeRuntimeProfiles.resolve(age.generationProfile());
+        AgeRuntimeProfile profile = runtimeProfile(age);
         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(),

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

@@ -0,0 +1,175 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+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, AgeBiomeSelection biomeSelection) {
+    public static final int CURRENT_VERSION = 2;
+
+    public AgeGenerationPlan {
+        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))) {
+                throw new IllegalArgumentException("Resolved symbol does not match original page order");
+            }
+        }
+    }
+
+    /** 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,
+                                            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;
+        ResourceLocation terrain = parsed.symbols().stream()
+                .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
+                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
+                .findFirst().orElse(null);
+        // The seed-selected terrain remains the deterministic completion for a missing branch.
+        // An explicit terrain must resolve now, before Binder inputs can be consumed.
+        if (terrain != null && !AgeRuntimeProfiles.profiles().containsKey(terrain)) {
+            throw new IllegalArgumentException("Unsupported Age terrain profile " + terrain);
+        }
+        ResourceLocation selected = terrain == null ? seedProfile : terrain;
+        AgeRuntimeProfile profile = AgeRuntimeProfiles.profiles().get(selected);
+        if (profile == null) throw new IllegalArgumentException("Unsupported Age terrain profile " + selected);
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(parsed, traits, profile, ageSeed, registries);
+        return new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
+                parsed.symbols().stream().map(symbol -> new ResolvedSymbol(
+                        symbol.index(), symbol.reference(), symbol.semantics())).toList(),
+                profile, biomes);
+    }
+
+    public ResourceLocation authoredTerrain() {
+        return symbols.stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
+                .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
+                .findFirst().orElse(null);
+    }
+
+    public CompoundTag save() {
+        CompoundTag tag = new CompoundTag();
+        tag.putInt("Version", version);
+        tag.putLong("AgeSeed", ageSeed);
+        ListTag pages = new ListTag();
+        for (WritingEntry entry : writing.entries()) {
+            CompoundTag page = new CompoundTag();
+            page.putString("Kind", entry.kind().name());
+            entry.symbol().ifPresent(symbol -> page.putString("Symbol", symbol.id().toString()));
+            pages.add(page);
+        }
+        tag.put("Writing", pages);
+        ListTag resolved = new ListTag();
+        for (ResolvedSymbol symbol : symbols) {
+            CompoundTag item = new CompoundTag();
+            item.putInt("Index", symbol.index());
+            item.putString("Symbol", symbol.reference().id().toString());
+            item.putString("Role", symbol.semantics().role().name());
+            SymbolSemantics.Value value = symbol.semantics().value();
+            item.putString("Value", value instanceof SymbolSemantics.ResourceValue resource
+                    ? resource.id().toString() : value instanceof SymbolSemantics.ChoiceValue choice
+                    ? choice.id() : Double.toString(((SymbolSemantics.NumberValue) value).amount()));
+            resolved.add(item);
+        }
+        tag.put("Resolved", resolved);
+        CompoundTag profile = new CompoundTag();
+        profile.putInt("Version", runtimeProfile.schemaVersion());
+        profile.putString("Terrain", runtimeProfile.terrain().name());
+        profile.putString("Noise", runtimeProfile.noiseSettings().toString());
+        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;
+    }
+
+    public static AgeGenerationPlan load(CompoundTag tag) {
+        int version = tag.getInt("Version");
+        List<WritingEntry> pages = new ArrayList<>();
+        ListTag writingTags = tag.getList("Writing", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < writingTags.size(); index++) {
+            CompoundTag page = writingTags.getCompound(index);
+            pages.add(WritingEntry.Kind.valueOf(page.getString("Kind")) == WritingEntry.Kind.LINK_PANEL
+                    ? WritingEntry.linkPanel() : WritingEntry.symbol(new SymbolReference(
+                    ResourceLocation.parse(page.getString("Symbol")))));
+        }
+        List<ResolvedSymbol> resolved = new ArrayList<>();
+        ListTag resolvedTags = tag.getList("Resolved", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < resolvedTags.size(); index++) {
+            CompoundTag item = resolvedTags.getCompound(index);
+            SymbolSemantics.Role role = SymbolSemantics.Role.valueOf(item.getString("Role"));
+            String raw = item.getString("Value");
+            SymbolSemantics.Value value = switch (role) {
+                case TERRAIN, BIOME, FEATURE -> new SymbolSemantics.ResourceValue(ResourceLocation.parse(raw));
+                case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER ->
+                        new SymbolSemantics.NumberValue(Double.parseDouble(raw));
+                default -> new SymbolSemantics.ChoiceValue(raw);
+            };
+            resolved.add(new ResolvedSymbol(item.getInt("Index"),
+                    new SymbolReference(ResourceLocation.parse(item.getString("Symbol"))),
+                    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"))), selection);
+    }
+
+    public record ResolvedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {
+        public ResolvedSymbol {
+            Objects.requireNonNull(reference, "reference");
+            Objects.requireNonNull(semantics, "semantics");
+        }
+    }
+}

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

@@ -1,7 +1,11 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.UUID;
+import java.util.List;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
@@ -18,6 +22,54 @@ public final class AgePersistenceGameTests {
     private AgePersistenceGameTests() {
     }
 
+    @GameTest(template = "empty")
+    public static void authoredPlanRetainsResolvedMeaningAndAgeIdentity(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:weather/normal"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:celestial/normal_time"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:feature/caves")))
+        ));
+        UUID id = UUID.randomUUID();
+        AgeReference reference = new AgeReference(id, "Authored Plan " + id);
+        AgeDefinition created = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(), reference, writing);
+        helper.assertTrue(created.plan() != null, "Authored writing must create a frozen plan");
+        helper.assertValueEqual(created.plan().version(), AgeGenerationPlan.CURRENT_VERSION,
+                "The plan format must be explicitly versioned");
+        helper.assertValueEqual(created.plan().ageSeed(), created.seed(),
+                "The Age seed must be captured in the immutable plan");
+        helper.assertValueEqual(created.plan().writing(), writing, "The original page order must be retained");
+        helper.assertValueEqual(created.plan().symbols().size(), 5, "Every symbol must be resolved in order");
+        helper.assertValueEqual(created.generationProfile(), AgeGenerationProfiles.STANDARD,
+                "Authored terrain must replace the seed-selected random terrain");
+        helper.assertValueEqual(created.plan().runtimeProfile(), AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD),
+                "The plan must snapshot the runtime profile instead of looking it up after reload");
+
+        AgeDefinition sameId = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(id, "Renamed"), OrderedWriting.EMPTY);
+        helper.assertValueEqual(sameId, created, "The same Age UUID must never reroll from a later book");
+        AgeRegistrySavedData registry = AgeRegistrySavedData.get(helper.getLevel());
+        AgeDefinition restored = AgeRegistrySavedData.load(
+                registry.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess()).find(id).orElseThrow();
+        helper.assertValueEqual(restored, created, "The complete plan must survive a saved-data round trip");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void randomFallbackDoesNotCreateAuthoredPlan(GameTestHelper helper) {
+        AgeDefinition pageFree = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Page Free"), OrderedWriting.EMPTY);
+        AgeDefinition panelOnly = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Panel Only"),
+                new OrderedWriting(List.of(WritingEntry.linkPanel())));
+        helper.assertTrue(pageFree.plan() == null && panelOnly.plan() == null,
+                "Old and Link-Panel-only books must retain the random Age path");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void everyTraitCombinationRoundTripsWithoutRerolling(GameTestHelper helper) {
         ListTag entries = new ListTag();
@@ -89,6 +141,8 @@ public final class AgePersistenceGameTests {
                 "Definitions predating named dimensions must retain the UUID-derived dimension");
         helper.assertValueEqual(definition.traits(), AgeTraits.LEGACY_DEFAULTS,
                 "Definitions predating traits must receive stable legacy defaults");
+        helper.assertTrue(definition.plan() == null,
+                "Existing Ages must not be reinterpreted as authored plans during migration");
 
         CompoundTag serialized = migrated.save(new CompoundTag(), helper.getLevel().registryAccess());
         AgeDefinition reloaded = AgeRegistrySavedData.load(serialized, helper.getLevel().registryAccess())

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

@@ -5,8 +5,10 @@ import java.util.Map;
 import java.util.Optional;
 import java.util.UUID;
 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;
@@ -29,6 +31,7 @@ public final class AgeRegistrySavedData extends SavedData {
     private static final String SPAWN_Y_TAG = "SpawnY";
     private static final String SPAWN_Z_TAG = "SpawnZ";
     private static final String TRAITS_TAG = "Traits";
+    private static final String PLAN_TAG = "GenerationPlan";
     private static final String BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
     private static final String LIGHTING_TAG = "Lighting";
     private static final String WEATHER_TAG = "Weather";
@@ -49,8 +52,29 @@ public final class AgeRegistrySavedData extends SavedData {
 
     /** Resolves a book identity, creating its deterministic random definition exactly once. */
     public static AgeDefinition resolveOrCreate(ServerLevel level, AgeReference reference) {
+        return resolveOrCreate(level, reference, OrderedWriting.EMPTY);
+    }
+
+    public static AgeDefinition resolveOrCreate(ServerLevel level, AgeReference reference, OrderedWriting writing) {
         ServerLevel overworld = level.getServer().overworld();
-        return get(overworld).getOrCreate(reference, 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) {
@@ -78,7 +102,8 @@ public final class AgeRegistrySavedData extends SavedData {
         return updated;
     }
 
-    private AgeDefinition getOrCreate(AgeReference reference, long worldSeed, long createdGameTime) {
+    private AgeDefinition getOrCreate(AgeReference reference, OrderedWriting writing,
+                                      long worldSeed, long createdGameTime, RegistryAccess registries) {
         AgeDefinition existing = ages.get(reference.id());
         if (existing != null) {
             return existing;
@@ -87,16 +112,20 @@ public final class AgeRegistrySavedData extends SavedData {
         String name = normalizedName(reference.name());
         ResourceLocation dimensionId = availableDimensionId(name);
         long seed = ageSeed(worldSeed, dimensionId);
+        ResourceLocation seedProfile = AgeRuntimeProfiles.select(seed);
+        AgeTraits traits = AgeTraits.select(seed);
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile, traits, registries);
         AgeDefinition created = new AgeDefinition(
                 reference.id(),
                 name,
                 seed,
-                AgeRuntimeProfiles.select(seed),
+                plan == null || plan.authoredTerrain() == null ? seedProfile : plan.authoredTerrain(),
                 AgeDefinition.CURRENT_GENERATION_VERSION,
                 createdGameTime,
                 dimensionId,
                 null,
-                AgeTraits.select(seed)
+                traits,
+                plan
         );
         ages.put(created.id(), created);
         setDirty();
@@ -138,7 +167,9 @@ public final class AgeRegistrySavedData extends SavedData {
                     entry.getLong(CREATED_TIME_TAG),
                     dimensionId,
                     spawn,
-                    readTraits(entry)
+                    readTraits(entry),
+                    entry.contains(PLAN_TAG, CompoundTag.TAG_COMPOUND)
+                            ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null
             ));
         }
         return data;
@@ -171,6 +202,7 @@ public final class AgeRegistrySavedData extends SavedData {
                     traits.putFloat(CELESTIAL_ANGLE_TAG, age.traits().celestialAngle());
                     traits.putFloat(CELESTIAL_PHASE_TAG, age.traits().celestialPhase());
                     entry.put(TRAITS_TAG, traits);
+                    if (age.plan() != null) entry.put(PLAN_TAG, age.plan().save());
                     serializedAges.add(entry);
                 });
         tag.put(AGES_TAG, serializedAges);

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) {
-            requireRegistryEntry(registries, Registries.NOISE_SETTINGS, noise, id, "noise_settings");
+    /** Recheck frozen plans before loading: a removed registry entry must not crash or silently alter an Age. */
+    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");
-        return new AgeRuntimeProfile(schemaVersion, terrain, noise, biome, dimension);
+        requireRegistryEntry(registries, Registries.DIMENSION_TYPE, profile.dimensionType(), id, "dimension_type");
     }
 
     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/TerrainWritingGameTests.java

@@ -0,0 +1,338 @@
+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);
+        java.util.Set<Integer> counts = new java.util.HashSet<>();
+        for (long seed = 0; seed < 64; seed++) {
+            var random = AgeBiomeSelection.compile(randomWriting, traits, profile, seed, registries);
+            helper.assertTrue(random.biomes().size() >= 2 && random.biomes().size() <= 6,
+                    "Random Tiny ages must select between two and six distinct biomes");
+            helper.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");
+        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(AgeDimensionService.unload(server, age), AgeDimensionService.UnloadResult.UNLOADED,
+                    "The island Age must unload");
+            var reloaded = AgeDimensionService.ensureLoaded(server, age);
+            helper.assertTrue(reloaded != null && reloaded.getChunkSource().getGenerator().getBiomeSource()
+                            .possibleBiomes().stream().allMatch(biome -> biome.is(Biomes.THE_END)),
+                    "The authored End biome must survive runtime dimension reload");
+            helper.succeed();
+        });
+    }
+
+    @GameTest(template = "empty", timeoutTicks = 600)
+    public static void writtenTerrainFamiliesGenerateSafelyAndReload(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(AgeDimensionService.unload(server, age),
+                    AgeDimensionService.UnloadResult.UNLOADED,
+                    "A written Age must unload without losing its plan");
+            var reloaded = AgeDimensionService.ensureLoaded(server, age);
+            helper.assertTrue(reloaded != null, "The written Age must reload from its frozen plan");
+            assertGenerator(helper, reloaded, age.plan().runtimeProfile());
+            helper.assertValueEqual(reloaded.dimensionType().effectsLocation(),
+                    level.dimensionType().effectsLocation(), "Reload must retain dimension effects");
+            helper.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/BookBinderScreen.java

@@ -1,5 +1,6 @@
 package net.dnorberg.rivencraft.client.screen;
 
+import java.util.Locale;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.item.PageItem;
@@ -32,6 +33,7 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
 
     private EditBox titleInput;
     private int firstVisible;
+    private int lastGrammarErrorStripIndex = -1;
     private boolean stripClickPendingRelease;
 
     public BookBinderScreen(BookBinderMenu menu, Inventory inventory, Component title) {
@@ -86,6 +88,13 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
     @Override public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         super.render(graphics, mouseX, mouseY, partialTick);
         firstVisible = Math.min(firstVisible, maxFirstVisible());
+        int errorStripIndex = menu.grammarErrorStripIndex();
+        if (errorStripIndex != lastGrammarErrorStripIndex) {
+            if (errorStripIndex >= 0
+                    && (errorStripIndex < firstVisible || errorStripIndex >= firstVisible + VISIBLE_PAGES))
+                firstVisible = Math.clamp(errorStripIndex - VISIBLE_PAGES + 1, 0, maxFirstVisible());
+            lastGrammarErrorStripIndex = errorStripIndex;
+        }
         graphics.enableScissor(leftPos + STRIP_X + 8, topPos + STRIP_Y,
                 leftPos + STRIP_X + STRIP_WIDTH - 8, topPos + STRIP_Y + STRIP_HEIGHT);
         int count = visiblePageCount();
@@ -97,6 +106,16 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
         }
         graphics.disableScissor();
         drawScrollEnds(graphics);
+        Component grammarTooltip = menu.grammarError().map(code -> Component.translatable(
+                "screen.rivencraft.book_binder.grammar." + code.name().toLowerCase(Locale.ROOT),
+                errorStripIndex + 1)).orElse(null);
+        if (menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty()
+                && mouseX >= leftPos + 152 && mouseX < leftPos + 168
+                && mouseY >= topPos + 27 && mouseY < topPos + 43
+                && grammarTooltip != null) {
+            graphics.renderTooltip(font, grammarTooltip, mouseX, mouseY);
+            return;
+        }
         if (mouseY >= topPos + STRIP_Y && mouseY < topPos + STRIP_Y + STRIP_HEIGHT) {
             if (firstVisible > 0 && mouseX >= leftPos + STRIP_X && mouseX < leftPos + STRIP_X + 8)
                 graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book_binder.previous_pages"), mouseX, mouseY);
@@ -111,7 +130,9 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
             return;
         }
         int hovered = pageIndexAt(mouseX, mouseY);
-        if (hovered >= 0 && hovered < displayedPages() && !pageAtIndex(hovered).isEmpty())
+        if (hovered >= 0 && hovered == errorStripIndex && grammarTooltip != null)
+            graphics.renderTooltip(font, grammarTooltip, mouseX, mouseY);
+        else if (hovered >= 0 && hovered < displayedPages() && !pageAtIndex(hovered).isEmpty())
             graphics.renderTooltip(font, pageAtIndex(hovered), mouseX, mouseY);
         else renderTooltip(graphics, mouseX, mouseY);
     }
@@ -148,6 +169,10 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
             case SYMBOL, UNRESOLVED_SYMBOL -> graphics.blit(NotebookScreen.symbolTexture(page),
                     x + 1, y + 5, 24, 24, 0, 0, 128, 128, 128, 128);
         }
+        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()) {
+            graphics.fill(x, y, x + PAGE_WIDTH, y + PAGE_HEIGHT, 0x55FF2020);
+            graphics.renderOutline(x, y, PAGE_WIDTH, PAGE_HEIGHT, 0xFFFF3030);
+        }
     }
 
     private void drawScrollEnds(GuiGraphics graphics) {

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,13 @@ 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.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 +44,52 @@ 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) {
+        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

@@ -14,6 +14,7 @@ import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.writing.NotebookContents;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTest;
@@ -58,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");
@@ -86,12 +88,41 @@ public final class BookBinderGameTests {
         restored.loadWithComponents(saved, helper.getLevel().registryAccess());
         helper.assertValueEqual(PageItem.content(restored.getItem(BookBinderBlockEntity.FIRST_PAGE))
                 .symbol().orElseThrow(), missing, "Reload must preserve the removed data-pack symbol ID");
-        helper.assertFalse(restored.canAssemble(), "Missing symbol cannot create a new written Age");
+        restored.getItem(BookBinderBlockEntity.FIRST_PAGE).set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(),
+                SymbolCatalog.display(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))));
+        helper.assertFalse(restored.canAssemble(),
+                "Forged display metadata cannot make a missing symbol valid for a new Age");
         helper.assertTrue(restored.getItem(BookBinderBlockEntity.FIRST_PAGE).is(ModItems.PAGE.get()),
                 "Rejected writing must remain recoverable as a Page");
         helper.succeed();
     }
 
+    @GameTest(template = "empty")
+    public static void conflictingGrammarKeepsBinderInputsRecoverable(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Recoverable Duplicate");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 5, terrainPage());
+        helper.assertFalse(binder.canAssemble(), "Duplicate terrain must not assemble a new Age");
+        int errorEntry = binder.writingGrammar().firstError().orElseThrow().index();
+        helper.assertValueEqual(errorEntry, 2, "Parser must identify the second authored symbol");
+        helper.assertValueEqual(binder.writingStripIndex(errorEntry), 6,
+                "A grammar error must highlight the correct strip page despite empty positions");
+        helper.assertFalse(binder.consumeAssembly(), "Rejected grammar must not consume binder inputs");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
+                "Rejected grammar must leave the cover recoverable");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
+                "Rejected grammar must leave the Link Panel recoverable");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 5).is(ModItems.PAGE.get()),
+                "Rejected grammar must leave the duplicate page removable");
+        ItemStack removed = binder.takePage(5);
+        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to correct the duplicate page");
+        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must become assemblable");
+        helper.succeed();
+    }
+
     public static void assemblyIsAtomicAndRetainsPageOrder(GameTestHelper helper) {
         BookBinderBlockEntity binder = place(helper);
         binder.setTitle("A New Age");

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

@@ -47,6 +47,11 @@ public final class CoreGameTests {
         WritingDataGameTests.semanticSchemaIsServerOnlyBoundedAndV1Compatible(helper);
     }
 
+    @GameTest(template = "empty")
+    public static void orderedWritingGrammar(GameTestHelper helper) {
+        WritingGrammarGameTests.orderedGrammarAcceptsPartialWritingAndDiagnosesInvalidSequences(helper);
+    }
+
     @GameTest(template = "empty")
     public static void notebookPersistence(GameTestHelper helper) {
         WritingDataGameTests.notebookContentsPreserveOrderGapsNamesAndUnknownPages(helper);
@@ -82,6 +87,11 @@ public final class CoreGameTests {
         BookBinderGameTests.assemblyIsAtomicAndRetainsPageOrder(helper);
     }
 
+    @GameTest(template = "empty")
+    public static void binderRejectsConflictingGrammar(GameTestHelper helper) {
+        BookBinderGameTests.conflictingGrammarKeepsBinderInputsRecoverable(helper);
+    }
+
     @GameTest(template = "empty")
     public static void binderRejectsForgedAndReplayedActions(GameTestHelper helper) {
         BookBinderGameTests.forgedBinderActionsAndReplayedOutputCannotDuplicateBook(helper);

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;
@@ -418,46 +421,34 @@ public final class LinkingGameTests {
             }
             if (profile.equals(AgeGenerationProfiles.AMPLIFIED)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
-                helper.assertValueEqual(
-                        biomeSource.possibleBiomes().size(),
-                        2,
-                        "Tiled Biome Distribution must expose exactly two seeded biomes"
-                );
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
+                                && biomeSource.possibleBiomes().size() <= 4,
+                        "Random Tiled distribution must use two to four seeded biomes");
                 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");
-                helper.assertTrue(origin.equals(diagonalTile),
-                        "Diagonal 256-block Tiled squares must repeat the biome");
+                        "Adjacent 256-block Tiled squares must use different biomes");
             }
             if (profile.equals(AgeGenerationProfiles.ISLAND)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
-                helper.assertValueEqual(
-                        biomeSource.possibleBiomes().size(),
-                        2,
-                        "Grid Biome Distribution must expose exactly two seeded biomes"
-                );
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
+                                && biomeSource.possibleBiomes().size() <= 4,
+                        "Random Grid distribution must use two to four seeded biomes");
                 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");
-                helper.assertTrue(origin.equals(diagonalChunk),
-                        "Diagonal Grid chunks must repeat the biome");
+                        "Adjacent Grid chunks must use different biomes");
             }
             if (profile.equals(AgeGenerationProfiles.CAVE)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
                 helper.assertTrue(biomeSource instanceof net.dnorberg.rivencraft.world.ScaledBiomeSource,
                         "Tiny Biome Distribution must use the serializable scaled biome source");
-                helper.assertValueEqual(
-                        biomeSource.possibleBiomes().size(),
-                        3,
-                        "Tiny Biome Distribution must expose exactly three seeded biomes"
-                );
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
+                                && biomeSource.possibleBiomes().size() <= 3,
+                        "Random cave Tiny distribution must use two to three eligible 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) {
@@ -531,11 +522,9 @@ public final class LinkingGameTests {
             var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
             helper.assertTrue(biomeSource instanceof net.dnorberg.rivencraft.world.ScaledBiomeSource,
                     distribution + " Biome Distribution must use the serializable scaled biome source");
-            helper.assertValueEqual(
-                    biomeSource.possibleBiomes().size(),
-                    3,
-                    distribution + " Biome Distribution must expose exactly three seeded biomes"
-            );
+            helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
+                            && biomeSource.possibleBiomes().size() <= 6,
+                    distribution + " random distribution must use two to six seeded biomes");
             helper.assertValueEqual(
                     ((net.dnorberg.rivencraft.world.ScaledBiomeSource)biomeSource).scale(),
                     scale,
@@ -553,23 +542,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) {
-            seed++;
-        }
+        var plan = new AgeGenerationPlan(AgeGenerationPlan.CURRENT_VERSION, seed, OrderedWriting.EMPTY,
+                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 +565,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 Pages 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/gametest/WritingGrammarGameTests.java

@@ -0,0 +1,143 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Optional;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolCatalog;
+import net.dnorberg.rivencraft.writing.SymbolDefinition;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Issue #30: parsing must not mutate writing or trust client display metadata. */
+@GameTestHolder("rivencraft_archive_grammar")
+@PrefixGameTestTemplate(false)
+public final class WritingGrammarGameTests {
+    private WritingGrammarGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void orderedGrammarAcceptsPartialWritingAndDiagnosesInvalidSequences(GameTestHelper helper) {
+        SymbolReference terrain = ref("rivencraft:terrain/standard");
+        SymbolReference nativeBiomes = ref("rivencraft:biome/native");
+        SymbolReference weather = ref("rivencraft:weather/normal");
+        SymbolReference lighting = ref("rivencraft:lighting/normal");
+        SymbolReference celestial = ref("rivencraft:celestial/normal_time");
+        SymbolReference caves = ref("rivencraft:feature/caves");
+        SymbolReference plains = ref("test:biome/plains");
+        SymbolReference forest = ref("test:biome/forest");
+        SymbolReference single = ref("test:controller/single");
+        SymbolReference alternateTerrain = ref("test:terrain/alternate");
+        SymbolReference periodHalf = ref("test:period/half");
+        SymbolReference periodFull = ref("test:period/full");
+        SymbolReference displayOnly = ref("test:display_only");
+        Map<SymbolReference, SymbolDefinition> definitions = Map.of(
+                plains, definition(SymbolSemantics.Role.BIOME,
+                        new SymbolSemantics.ResourceValue(ResourceLocation.parse("minecraft:plains"))),
+                forest, definition(SymbolSemantics.Role.BIOME,
+                        new SymbolSemantics.ResourceValue(ResourceLocation.parse("minecraft:forest"))),
+                single, definition(SymbolSemantics.Role.BIOME_CONTROLLER,
+                        new SymbolSemantics.ChoiceValue("single")),
+                alternateTerrain, definition(SymbolSemantics.Role.TERRAIN,
+                        new SymbolSemantics.ResourceValue(ResourceLocation.parse("test:alternate"))),
+                periodHalf, definition(SymbolSemantics.Role.PERIOD_MODIFIER,
+                        new SymbolSemantics.NumberValue(0.5)),
+                periodFull, definition(SymbolSemantics.Role.PERIOD_MODIFIER,
+                        new SymbolSemantics.NumberValue(1.0)),
+                displayOnly, new SymbolDefinition(1, "symbol.test", "symbol.test.description",
+                        ResourceLocation.parse("test:display"), Optional.empty(), ""));
+        java.util.function.Function<SymbolReference, Optional<SymbolDefinition>> resolver = reference ->
+                Optional.ofNullable(definitions.get(reference)).or(() -> SymbolCatalog.find(reference));
+
+        helper.assertTrue(parse(resolver, WritingEntry.linkPanel()).randomFallback(),
+                "Link-Panel-only writing must retain the random Age path");
+        helper.assertTrue(WritingGrammar.parse(OrderedWriting.EMPTY, resolver).randomFallback(),
+                "Old page-free books must retain the random Age path");
+        OrderedWriting partial = writing(WritingEntry.linkPanel(), WritingEntry.symbol(terrain));
+        WritingGrammar.Result incomplete = WritingGrammar.parse(partial, resolver);
+        helper.assertTrue(incomplete.canCreate() && !incomplete.randomFallback(),
+                "Partial authored writing must remain valid, without pretending it is page-free");
+        helper.assertTrue(incomplete.diagnostics().stream().anyMatch(d -> d.code() == WritingGrammar.Code.INCOMPLETE),
+                "Missing branches must be reported for deterministic completion");
+        helper.assertValueEqual(partial.entries().size(), 2, "Parsing must not rewrite saved page order");
+
+        WritingGrammar.Result complete = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(plains), WritingEntry.symbol(single), WritingEntry.symbol(weather),
+                WritingEntry.symbol(lighting), WritingEntry.symbol(periodHalf), WritingEntry.symbol(celestial),
+                WritingEntry.symbol(caves));
+        helper.assertTrue(complete.canCreate(), "Legacy-ordered categories and prefix modifiers must parse");
+        helper.assertValueEqual(complete.symbols().size(), 8, "Parsed symbols must preserve every authored page");
+        helper.assertValueEqual(complete.symbols().get(1).reference(), plains,
+                "A biome page must precede the controller that consumes it");
+        helper.assertValueEqual(WritingGrammar.parse(writing(WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(plains), WritingEntry.symbol(single), WritingEntry.symbol(weather),
+                WritingEntry.symbol(lighting), WritingEntry.symbol(periodHalf), WritingEntry.symbol(celestial),
+                WritingEntry.symbol(caves)), resolver), complete,
+                "Identical ordered writing and server definitions must parse deterministically");
+
+        WritingGrammar.Result repeatedModifiers = parse(resolver, WritingEntry.linkPanel(),
+                WritingEntry.symbol(periodHalf), WritingEntry.symbol(periodFull), WritingEntry.symbol(celestial));
+        helper.assertTrue(repeatedModifiers.canCreate(), "Repeated period modifiers must remain legal");
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(terrain)), WritingGrammar.Code.DUPLICATE);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(alternateTerrain)), WritingGrammar.Code.CONFLICT);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+                WritingEntry.symbol(terrain)), WritingGrammar.Code.OUT_OF_ORDER);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
+                WritingEntry.symbol(periodHalf)), WritingGrammar.Code.MISPLACED_MODIFIER);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
+                WritingEntry.symbol(plains)), WritingGrammar.Code.OUT_OF_ORDER);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+                WritingEntry.symbol(nativeBiomes)), WritingGrammar.Code.CONFLICT);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+                WritingEntry.symbol(forest), WritingEntry.symbol(single)), WritingGrammar.Code.CONFLICT);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(caves),
+                WritingEntry.symbol(caves)), WritingGrammar.Code.DUPLICATE);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(ref("test:missing"))),
+                WritingGrammar.Code.UNRESOLVED);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(displayOnly)),
+                WritingGrammar.Code.UNSUPPORTED);
+        assertCode(helper, parse(resolver, WritingEntry.symbol(terrain)), WritingGrammar.Code.MISSING_PANEL);
+        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.linkPanel()),
+                WritingGrammar.Code.DUPLICATE_PANEL);
+
+        List<WritingEntry> oversized = new ArrayList<>();
+        for (int index = 0; index <= WritingGrammar.MAX_NEW_ENTRIES; index++)
+            oversized.add(WritingEntry.linkPanel());
+        assertCode(helper, WritingGrammar.parse(new OrderedWriting(oversized), resolver), WritingGrammar.Code.TOO_MANY);
+        helper.succeed();
+    }
+
+    private static SymbolReference ref(String id) {
+        return new SymbolReference(ResourceLocation.parse(id));
+    }
+
+    private static SymbolDefinition definition(SymbolSemantics.Role role, SymbolSemantics.Value value) {
+        return new SymbolDefinition(2, "symbol.test", "symbol.test.description",
+                ResourceLocation.parse("test:" + role.id()), Optional.of(new SymbolSemantics(role, value)), "");
+    }
+
+    private static OrderedWriting writing(WritingEntry... entries) {
+        return new OrderedWriting(List.of(entries));
+    }
+
+    private static WritingGrammar.Result parse(
+            java.util.function.Function<SymbolReference, Optional<SymbolDefinition>> resolver,
+            WritingEntry... entries) {
+        return WritingGrammar.parse(writing(entries), resolver);
+    }
+
+    private static void assertCode(GameTestHelper helper, WritingGrammar.Result result, WritingGrammar.Code code) {
+        helper.assertFalse(result.canCreate(), "Writing with " + code + " must not create a new Age");
+        helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
+                "Writing must report " + code + " rather than silently dropping a page");
+    }
+}

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

@@ -1,16 +1,27 @@
 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.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.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.world.item.Item;
 import net.minecraft.world.item.ItemStack;
@@ -18,6 +29,8 @@ import net.minecraft.world.item.TooltipFlag;
 
 /** One stackable Page item whose server-owned component identifies its writing state. */
 public final class PageItem extends Item {
+    private static final Map<String, SymbolDisplayMetadata> CREATIVE_SYMBOLS = loadCreativeSymbols();
+
     public PageItem(Properties properties) {
         super(properties);
     }
@@ -29,23 +42,65 @@ 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 ItemStack createCreativeStarterPage(String path) {
-        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);
+    public static List<String> bundledCreativeSymbols() {
+        return List.copyOf(CREATIVE_SYMBOLS.keySet());
+    }
+
+    /** 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);
+    }
+
+    /** Bundled symbols for the creative tab; the server still validates catalog membership on use. */
+    public static ItemStack createBundledCreativePage(String path) {
+        SymbolDisplayMetadata metadata = CREATIVE_SYMBOLS.get(path);
+        if (metadata == null) {
+            throw new IllegalArgumentException("Not a bundled symbol: " + path);
         }
-        SymbolReference reference = new SymbolReference(
-                net.minecraft.resources.ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path));
+        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(), new SymbolDisplayMetadata(
-                reference.id(), key, key + ".description",
-                net.minecraft.resources.ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path.split("/")[0]),
-                true, SymbolPoems.builtIn(reference.id())));
+        page.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(), metadata);
         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, SymbolDisplayMetadata> 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, SymbolDisplayMetadata> symbols = new LinkedHashMap<>();
+            json.entrySet().forEach(entry -> {
+                var id = net.minecraft.resources.ResourceLocation.parse(entry.getKey());
+                if (!id.getNamespace().equals(Rivencraft.MOD_ID)) {
+                    throw new IllegalStateException("Creative symbol is not a Rivencraft page: " + id);
+                }
+                symbols.put(id.getPath(), SymbolDefinition.parse(entry.getValue()).display(id));
+            });
+            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 +183,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()
-                ? Component.translatable(metadata.nameTranslationKey())
-                : Component.translatable("item.rivencraft.page.unresolved");
+        if (!metadata.resolved()) return Component.translatable("item.rivencraft.page.unresolved");
+        return reference.id().getNamespace().equals(Rivencraft.MOD_ID)
+                && reference.id().getPath().startsWith("biome/")
+                ? Component.translatableWithFallback(metadata.nameTranslationKey(),
+                        BiomeSymbolPages.fallbackName(reference.id()))
+                : Component.translatable(metadata.nameTranslationKey());
     }
 
 }

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

@@ -1,10 +1,12 @@
 package net.dnorberg.rivencraft.menu;
 
+import java.util.Optional;
 import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.registry.ModMenus;
 import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.world.Container;
 import net.minecraft.world.SimpleContainer;
@@ -32,6 +34,8 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     private final SimpleContainer result = new SimpleContainer(1);
     private final boolean clientSide;
     private int selectedPage = -1;
+    private int grammarErrorCode = -1;
+    private int grammarErrorStripIndex = -1;
 
     public BookBinderMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
         this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
@@ -47,6 +51,20 @@ public final class BookBinderMenu extends AbstractContainerMenu {
             @Override public int get() { return selectedPage; }
             @Override public void set(int value) { selectedPage = value; }
         });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarErrorCode : binder.writingGrammar().firstError()
+                        .map(error -> error.code().ordinal()).orElse(-1);
+            }
+            @Override public void set(int value) { grammarErrorCode = value; }
+        });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarErrorStripIndex : binder.writingGrammar().firstError()
+                        .map(error -> binder.writingStripIndex(error.index())).orElse(-1);
+            }
+            @Override public void set(int value) { grammarErrorStripIndex = value; }
+        });
         addSlot(new BinderSlot(BookBinderBlockEntity.COVER, 8, 27, 64));
         addSlot(new BinderSlot(BookBinderBlockEntity.LINK_PANEL, -1000, -1000, 1));
         addSlot(new BinderSlot(BookBinderBlockEntity.NOTEBOOK, -1000, -1000, 1));
@@ -66,6 +84,12 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     }
 
     public int selectedPage() { return selectedPage; }
+    public Optional<WritingGrammar.Code> grammarError() {
+        WritingGrammar.Code[] codes = WritingGrammar.Code.values();
+        return grammarErrorCode >= 0 && grammarErrorCode < codes.length
+                ? Optional.of(codes[grammarErrorCode]) : Optional.empty();
+    }
+    public int grammarErrorStripIndex() { return grammarErrorStripIndex; }
     public String title() { return binder == null ? "" : binder.title(); }
     public boolean setTitle(Player player, String title) {
         if (clientSide || !stillValid(player) || title == null

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

@@ -5,6 +5,8 @@ import net.dnorberg.rivencraft.book.LinkingService;
 import net.dnorberg.rivencraft.book.AgeReference;
 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.block.entity.BookStandBlockEntity;
 import net.dnorberg.rivencraft.client.ClientLinkPreviewHandler;
 import net.dnorberg.rivencraft.client.ClientBookInteractionHandler;
@@ -20,6 +22,7 @@ import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.component.DataComponents;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.GlobalPos;
@@ -115,7 +118,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) {
@@ -133,10 +138,27 @@ public final class ModNetworking {
             return;
         }
 
+        var grammar = WritingGrammar.parse(access.stack()
+                .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY));
+        if (!grammar.canCreate()) {
+            player.displayClientMessage(Component.translatable("message.rivencraft.descriptive_book.invalid_writing",
+                    grammar.firstError().orElseThrow().message()), true);
+            return;
+        }
+        try {
+            AgeRegistrySavedData.validateNewWriting(player.serverLevel(), title,
+                    access.stack().getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY));
+        } catch (IllegalArgumentException exception) {
+            player.displayClientMessage(Component.translatable("message.rivencraft.descriptive_book.invalid_writing",
+                    exception.getMessage()), true);
+            return;
+        }
+
         WRITING_BOOKS.add(access.stack());
         try {
             AgeReference reference = new AgeReference(UUID.randomUUID(), title);
-            if (AgeDimensionService.resolve(player, reference).isEmpty()) {
+            if (AgeDimensionService.resolve(player, reference, access.stack()
+                    .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY)).isEmpty()) {
                 player.displayClientMessage(Component.translatable("message.rivencraft.descriptive_book.unavailable"), true);
                 return;
             }

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

@@ -35,10 +35,7 @@ public final class ModCreativeTabs {
                     .displayItems((parameters, output) -> {
                         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));
-                        }
+                        PageItem.creativeSymbolPages(parameters.holders()).forEach(output::accept);
                     })
                     .build());
 

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) {
-            throw new IllegalArgumentException("Scaled biome distributions require at least three biomes");
+        if (biomes.size() < 2) {
+            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/WritingGrammar.java

@@ -0,0 +1,184 @@
+package net.dnorberg.rivencraft.writing;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
+import java.util.function.Function;
+import net.dnorberg.rivencraft.writing.SymbolSemantics.ChoiceValue;
+import net.dnorberg.rivencraft.writing.SymbolSemantics.Role;
+import net.minecraft.resources.ResourceLocation;
+
+/** Server-owned interpretation of ordered writing; compilation belongs to the next release slice. */
+public final class WritingGrammar {
+    // A newly assembled book has one Link Panel plus at most 27 page positions.
+    public static final int MAX_NEW_ENTRIES = NotebookContents.MAX_PAGES + 1;
+
+    private WritingGrammar() {}
+
+    public static Result parse(OrderedWriting writing) {
+        return parse(writing, SymbolCatalog::find);
+    }
+
+    /** The resolver must be the authoritative server catalog, never page display metadata. */
+    public static Result parse(OrderedWriting writing,
+                               Function<SymbolReference, Optional<SymbolDefinition>> resolver) {
+        Objects.requireNonNull(writing, "writing");
+        Objects.requireNonNull(resolver, "resolver");
+        List<ParsedSymbol> symbols = new ArrayList<>();
+        List<Diagnostic> diagnostics = new ArrayList<>();
+        if (writing.entries().size() > MAX_NEW_ENTRIES) {
+            diagnostics.add(new Diagnostic(Code.TOO_MANY, -1, "At most " + MAX_NEW_ENTRIES + " entries are allowed"));
+            return new Result(symbols, diagnostics);
+        }
+        if (writing.entries().isEmpty()) return new Result(symbols, diagnostics);
+
+        EnumMap<Role, ParsedSymbol> singular = new EnumMap<>(Role.class);
+        Set<ResourceLocation> features = new HashSet<>();
+        int panels = 0;
+        int lastStage = -1;
+        int biomeCount = 0;
+        for (int index = 0; index < writing.entries().size(); index++) {
+            WritingEntry entry = writing.entries().get(index);
+            if (entry.kind() == WritingEntry.Kind.LINK_PANEL) {
+                panels++;
+                if (panels > 1) diagnostics.add(new Diagnostic(Code.DUPLICATE_PANEL, index,
+                        "Use exactly one Link Panel"));
+                else if (index != 0) diagnostics.add(new Diagnostic(Code.PANEL_ORDER, index,
+                        "Move the Link Panel to the first position"));
+                continue;
+            }
+
+            SymbolReference reference = entry.symbol().orElseThrow();
+            Optional<SymbolDefinition> definition = resolver.apply(reference);
+            if (definition.isEmpty()) {
+                diagnostics.add(new Diagnostic(Code.UNRESOLVED, index,
+                        "Restore the data pack for " + reference.id() + " or remove this page"));
+                continue;
+            }
+            Optional<SymbolSemantics> semantics = definition.orElseThrow().semantics();
+            if (semantics.isEmpty()) {
+                diagnostics.add(new Diagnostic(Code.UNSUPPORTED, index,
+                        "Update " + reference.id() + " to semantic schema v2 or remove this page"));
+                continue;
+            }
+
+            Role role = semantics.orElseThrow().role();
+            ParsedSymbol parsed = new ParsedSymbol(index, reference, semantics.orElseThrow());
+            symbols.add(parsed);
+            if (singular(role)) {
+                ParsedSymbol previous = singular.putIfAbsent(role, parsed);
+                if (previous != null) {
+                    Code code = previous.semantics().value().equals(parsed.semantics().value())
+                            ? Code.DUPLICATE : Code.CONFLICT;
+                    diagnostics.add(new Diagnostic(code, index,
+                            "Remove this " + role.id() + " page; position " + (previous.index() + 1)
+                                    + " already supplies that category"));
+                    continue;
+                }
+            } else if (role == Role.FEATURE && !features.add(reference.id())) {
+                diagnostics.add(new Diagnostic(Code.DUPLICATE, index,
+                        "Remove the repeated feature page " + reference.id()));
+                continue;
+            }
+            if (role == Role.BIOME) biomeCount++;
+            int stage = stage(role);
+            if (stage < lastStage) {
+                diagnostics.add(new Diagnostic(modifier(role) ? Code.MISPLACED_MODIFIER : Code.OUT_OF_ORDER,
+                        index, "Move this " + role.id() + " page before later grammar categories"));
+            } else {
+                lastStage = stage;
+            }
+        }
+        if (panels == 0) diagnostics.add(new Diagnostic(Code.MISSING_PANEL, -1,
+                "Add a Link Panel as the first page"));
+        if (symbols.isEmpty()) return new Result(symbols, diagnostics);
+
+        ParsedSymbol controller = singular.get(Role.BIOME_CONTROLLER);
+        if (controller != null && controller.semantics().value() instanceof ChoiceValue choice
+                && choice.id().equals("native") && biomeCount > 0) {
+            diagnostics.add(new Diagnostic(Code.CONFLICT, controller.index(),
+                    "Native biome distribution cannot use authored biome pages"));
+        } else if (controller != null && controller.semantics().value() instanceof ChoiceValue choice
+                && choice.id().equals("single") && biomeCount > 1) {
+            diagnostics.add(new Diagnostic(Code.CONFLICT, controller.index(),
+                    "Single-biome distribution accepts only one authored biome page"));
+        }
+        for (Role required : List.of(Role.TERRAIN, Role.BIOME_CONTROLLER, Role.WEATHER,
+                Role.LIGHTING, Role.CELESTIAL)) {
+            if (!singular.containsKey(required)) diagnostics.add(new Diagnostic(Code.INCOMPLETE, -1,
+                    "The Age compiler will fill the missing " + required.id() + " branch from the Age seed"));
+        }
+        if (controller != null && controller.semantics().value() instanceof ChoiceValue choice) {
+            int minimum = switch (choice.id()) {
+                case "single" -> 1;
+                case "tiled", "grid" -> 2;
+                case "native" -> 0;
+                default -> 2;
+            };
+            if (biomeCount < minimum) diagnostics.add(new Diagnostic(Code.INCOMPLETE, -1,
+                    "The Age compiler will fill " + (minimum - biomeCount) + " missing biome page(s)"));
+        }
+        return new Result(symbols, diagnostics);
+    }
+
+    private static boolean singular(Role role) {
+        return switch (role) {
+            case TERRAIN, BIOME_CONTROLLER, WEATHER, LIGHTING, CELESTIAL -> true;
+            default -> false;
+        };
+    }
+
+    private static boolean modifier(Role role) {
+        return role == Role.PERIOD_MODIFIER || role == Role.ANGLE_MODIFIER || role == Role.PHASE_MODIFIER;
+    }
+
+    private static int stage(Role role) {
+        return switch (role) {
+            case TERRAIN -> 0;
+            case BIOME -> 1;
+            case BIOME_CONTROLLER -> 2;
+            case WEATHER -> 3;
+            case LIGHTING -> 4;
+            case PERIOD_MODIFIER, ANGLE_MODIFIER, PHASE_MODIFIER -> 5;
+            case CELESTIAL -> 6;
+            case FEATURE -> 7;
+        };
+    }
+
+    public enum Code {
+        TOO_MANY, MISSING_PANEL, PANEL_ORDER, DUPLICATE_PANEL, UNRESOLVED, UNSUPPORTED,
+        DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER, INCOMPLETE, UNSUPPORTED_PROFILE,
+        UNKNOWN_BIOME, UNSUPPORTED_BIOME
+    }
+
+    public record Diagnostic(Code code, int index, String message) {
+        public Diagnostic {
+            Objects.requireNonNull(code, "code");
+            Objects.requireNonNull(message, "message");
+        }
+
+        public boolean error() { return code != Code.INCOMPLETE; }
+    }
+
+    public record ParsedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {
+        public ParsedSymbol {
+            Objects.requireNonNull(reference, "reference");
+            Objects.requireNonNull(semantics, "semantics");
+        }
+    }
+
+    public record Result(List<ParsedSymbol> symbols, List<Diagnostic> diagnostics) {
+        public Result {
+            symbols = List.copyOf(symbols);
+            diagnostics = List.copyOf(diagnostics);
+        }
+
+        public boolean randomFallback() { return symbols.isEmpty() && diagnostics.isEmpty(); }
+        public boolean canCreate() { return diagnostics.stream().noneMatch(Diagnostic::error); }
+        public Optional<Diagnostic> firstError() { return diagnostics.stream().filter(Diagnostic::error).findFirst(); }
+    }
+}

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

@@ -34,6 +34,17 @@
   "screen.rivencraft.book_binder.previous_pages": "Scroll pages left (Left Arrow)",
   "screen.rivencraft.book_binder.next_pages": "Scroll pages right (Right Arrow)",
   "screen.rivencraft.book_binder.select_hint": "Right-click page to select",
+  "screen.rivencraft.book_binder.grammar.too_many": "Too many pages for a new Age; remove excess pages",
+  "screen.rivencraft.book_binder.grammar.missing_panel": "Add a Link Panel as the first page",
+  "screen.rivencraft.book_binder.grammar.panel_order": "Page %s: move the Link Panel to the first position",
+  "screen.rivencraft.book_binder.grammar.duplicate_panel": "Page %s: remove the extra Link Panel",
+  "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.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",
+  "screen.rivencraft.book_binder.grammar.misplaced_modifier": "Page %s: move this modifier before its celestial page",
   "screen.rivencraft.writing_desk.ink": "Ink: %s/%s",
   "screen.rivencraft.writing_desk.search": "Search",
   "screen.rivencraft.writing_desk.sort": "Sort pages by name (A–Z)",
@@ -58,6 +69,7 @@
   "message.rivencraft.descriptive_book.unwritten": "This Descriptive Book is unwritten",
   "message.rivencraft.descriptive_book.created": "Created Age: %s",
   "message.rivencraft.descriptive_book.unavailable": "That Age is unavailable",
+  "message.rivencraft.descriptive_book.invalid_writing": "Writing cannot create an Age: %s",
   "message.rivencraft.descriptive_book.unsafe": "No safe destination was found in that Age",
   "message.rivencraft.descriptive_book.linked_first": "Linked to %s — a Return Link was created",
   "message.rivencraft.descriptive_book.linked": "Linked to %s",
@@ -108,8 +120,51 @@
   "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.weather.normal": "Normal Weather",

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/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/tags/worldgen/biome/cave_biomes.json

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