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

BUILDING.txt

@@ -0,0 +1,127 @@
+Rivencraft Build Instructions
+============================
+
+These instructions apply when source code, models, textures, data, or other
+resources have been changed.
+
+Requirements
+------------
+
+- Java 21 JDK
+- A working Gradle wrapper
+- The project dependencies available in the Gradle cache, or network access
+  for Gradle to download them
+
+The project targets Minecraft 1.21.1 and NeoForge 21.1.251.
+
+1. Open the project directory
+--------------------------------
+
+    cd /path/to/rivencraft
+
+2. Check the changed files
+--------------------------
+
+Confirm that model, texture, and other resource files are inside
+`src/main/resources`. Java source files belong under `src/main/java`.
+
+For example, block models are normally stored under:
+
+    src/main/resources/assets/rivencraft/models/block/
+
+Resource files placed under `src/main/resources` are automatically included in
+the finished mod JAR by Gradle.
+
+3. Update the version when appropriate
+---------------------------------------
+
+Rivencraft uses the version format `x.y.z.b`:
+
+- `x`: major release
+- `y`: milestone completion
+- `z`: release slice
+- `b`: bug fixes and additional work within that slice
+
+Edit `mod_version` in `gradle.properties` before creating a new release. Do
+not reuse a version that has already been published.
+
+4. Build the mod
+----------------
+
+From the project directory, run:
+
+    ./gradlew build --offline
+
+If the required dependencies are not cached locally, remove `--offline`:
+
+    ./gradlew build
+
+On systems using mise-managed Java and Gradle, use:
+
+    mise exec -- ./gradlew build --offline
+
+5. Run the automated tests
+--------------------------
+
+To build and run the GameTest suite:
+
+    ./gradlew build runGameTestServer --offline
+
+Or, with mise:
+
+    mise exec -- ./gradlew build runGameTestServer --offline
+
+All required GameTests should pass before distributing a build.
+
+GameTests use `build/gametest-run/world`, separate from the normal development
+world. Gradle starts each default run with a fresh world and removes it after
+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:
+
+    test_dir=$(mktemp -d /tmp/rivencraft-gametest.XXXXXX)
+    ./gradlew runGameTestServer --offline -PgameTestRunDir="$test_dir"
+
+With mise, prefix the second command with `mise exec --`.
+
+6. Locate and inspect the JAR
+-----------------------------
+
+Build outputs are written to:
+
+    build/libs/
+
+The filename uses the configured version, for example:
+
+    build/libs/rivencraft-0.3.6.9.jar
+
+To verify that changed resource files are packaged:
+
+    unzip -l build/libs/rivencraft-VERSION.jar | rg 'models|textures|data'
+
+Replace `VERSION` with the actual version number.
+
+To create a checksum for distribution:
+
+    sha256sum build/libs/rivencraft-VERSION.jar
+
+7. Stop the Gradle daemon when finished
+----------------------------------------
+
+This is optional, but useful after a long test run:
+
+    ./gradlew --stop
+
+Release checklist
+-----------------
+
+- Confirm the version was incremented when required.
+- Confirm the build completed successfully.
+- Confirm all required GameTests passed.
+- Confirm changed resources are present in the JAR.
+- Generate and record the SHA-256 checksum.
+- Test the JAR in the target Minecraft 1.21.1 NeoForge instance.
+- Publish the JAR only after client-side testing is complete.

NOTICE

@@ -12,6 +12,13 @@ The Notebook page atlas is copied from Legacy's assets/mystcraft/gui/bookui_page
 under the same license.
 The Writing Desk item texture is copied from Legacy's
 assets/mystcraft/textures/items/writingdesk.png under the same license.
+The Writing Desk block texture is copied from Legacy's
+assets/mystcraft/textures/entity/desk.png under the same license.
+The Writing Desk GUI atlas is copied from Legacy's assets/mystcraft/gui/writingdesk.png
+under the same license; desk wood and inlay textures are cropped from desk.png.
+The Ink Mixer GUI atlas and block textures are copied from Legacy's
+assets/mystcraft/gui/inkmixer.png and textures/blocks/inkmixer_*.png under
+the same license. Rivencraft's block model is original and uses those textures.
 
 The initial build layout is derived from the official NeoForge 1.21.1
 ModDevGradle MDK: https://github.com/NeoForgeMDKs/MDK-1.21.1-ModDevGradle

README.md

@@ -4,8 +4,8 @@ Rivencraft is a clean, incremental port of the ideas and gameplay of
 [Mystcraft Legacy](https://github.com/Mystcraft/Mystcraft-Legacy) to Minecraft
 1.21.1 on NeoForge.
 
-The bootstrap, books/linking, and Ages milestones are complete. Milestone 4 is
+The bootstrap, books/linking, Ages, and writing-system milestones are complete.
-building the writing system on a data-pack symbol catalog and persistent
+The writing system uses a data-pack symbol catalog and persistent
 ordered-writing model. The project currently provides functional Linking Books
 and randomly seeded, persistent vanilla-like Ages created from page-free
 Descriptive Books. Instability and full symbol-to-world grammar interpretation
@@ -14,27 +14,112 @@ have not been ported yet.
 Milestone 4 now includes stackable blank Pages plus server-created symbol,
 unresolved-symbol, and baseline link-panel states. Page visuals follow the
 legacy runtime-composition rules. Craft an Ink Vial from two black dye, a glass
-bottle, and a water bucket; the bucket is returned. Hold a blank Page in one
+bottle, and a water bucket; the bucket is returned. Hold vanilla paper in one
 hand and use the Ink Vial in the other to prepare a baseline Link Panel Page.
 Each vial holds 16 ink units, and the default link-panel cost is two units.
 The spent vial returns a glass bottle. Server owners can adjust the symbol-copy
 and link-panel costs in the `writing` section of `rivencraft-server.toml`.
-Symbol-page transcription will become available through the Writing Desk.
+The Ink Mixer now offers a Legacy-style station for producing Link Panels:
+insert paper and Ink Vials, then take a Link Panel from the result slot. Each
+vial fills its 16-unit basin and returns a glass bottle; no server tick is
+needed. The earlier paper-in-one-hand method remains available. Ink modifier
+ingredients and link properties are planned for Milestone 5.
+The Writing Desk can copy a selected written page from its collection tabs.
 The Writing Desk is now craftable from planks, a glass bottle, and a feather.
-Its four collection tabs, ink/source/page work slots, and inventory persist
+It occupies two adjacent blocks, with one shared inventory; loaded paper and
+the selected page appear on its Legacy-inspired model.
+Desks placed before 0.3.6.1 keep their old one-block footprint until broken
+and placed again; leave an adjacent space when replacing one.
+Its 88 collection tabs, paper input, ink vial input, empty glass-bottle return,
+16-unit ink meter, and inventory persist
 through world saves; breaking it drops stored contents. The desk screen is a
-functional foundation styled after Legacy's left tabs, central writing surface,
+functional foundation using Legacy's original desk and scrollbar textures.
-and right inventory. Transcription controls are not implemented yet.
+Four tabs are visible at once; the controls above and below them move by four
+(1–4, 5–8, through 85–88). Each viewer can browse a different group. Existing
+four-tab desks retain their collections and supplies when upgraded.
+With a notebook selected, pick up a Page from your inventory and click an empty
+position on the left surface to store one page there. Clear search/filter/sort
+and turn off `ALL` to place pages at specific positions; occupied positions are
+never overwritten. A notebook tab exposes all 27 notebook positions (scroll to
+reach the rest); a loose-page tab exposes only its one occupied position.
+Empty tabs have no page storage until a notebook or page is put in the tab slot.
+Click a page on the desk surface to select it for copying. Drag a page from one
+notebook position to an empty position to move it, or onto another page to swap
+their positions. This also works between notebooks shown in the `ALL` view.
+Drag a page out of the panel to turn it back into an item. Drop it over a player
+inventory slot or desk tab to place it there; a tab with a notebook adds it to
+the first open position. Dropping elsewhere leaves the page on the cursor for
+normal inventory placement. The source notebook or tab loses the page only after
+a valid drop.
+Put vanilla paper in the
+upper-left slot and Ink Vials in the upper-right; a copy appears in the
+lower-left result slot when the selected page is valid. Taking it consumes one
+paper and, by default, one ink. An available vial refills an empty ink meter
+when inserted or when copying uses its last ink, and returns a vanilla glass
+bottle to the lower-right slot. Removing a bottle also retries a blocked refill.
+Refilling waits if that slot is full or contains another item. The `AZ` control sorts
+visible pages by name; `ALL` shows pages held across every desk tab. Search and
+category filtering narrow the view without granting new pages, and cross-tab
+copy selection is checked by the server.
+Selecting a stored page on the desk surface shows its Legacy-proportioned
+portrait preview and name above the player inventory.
+
+## Book Binder
+
+For a new survival Age: craft an Ink Vial, an Ink Mixer, a Writing Desk, and a Book Binder.
+Put vanilla paper and an Ink Vial in the Ink Mixer to make a Link Panel
+Page. Place leather (or an empty Notebook) and the Link Panel in the Book Binder,
+enter an Age name, and take the finished Descriptive Book. Written symbol Pages
+are optional; without them, the book creates a random Age. To duplicate a Page
+you already own, store it in a Writing Desk tab, select it, supply paper and ink,
+and take the copied Page from the output. A Notebook can hold and transfer a
+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`.
+
+Craft a Book Binder from three iron ingots and five planks. Put leather or an
+empty Notebook in the left cover slot. Enter a title, then place a Link Panel
+Page first in the horizontal page strip. Click a page in the strip with a
+written Page on the cursor to insert it before that position; click it with an
+empty cursor to take it out. The arrows or mouse wheel scroll through up to
+27 written Pages. Clicking the strip with a filled Notebook imports its Pages
+at that position and leaves the emptied Notebook on the cursor. The right slot
+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. 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
+Milestone 5. Link-panel-only books show their details in the enchantment-table
+font.
 
 ## Linking Book
 
-Craft a Linking Book from a vanilla book and an ender pearl, then use it in the
+Craft an unwritten Linking Book from one Link Panel Page and one leather in any
-air. An unbound book opens a screen where it can be named and bound to the
+two crafting-grid positions. An unbound book opens a screen where it can be named and bound to the
 current location. A bound book opens its destination screen and travels when
 its preview panel is clicked. The destination is stored on the item and
 survives inventory and world saves. Travel only succeeds if the target
 dimension is loaded and a non-fluid, passable landing position can be found
 nearby.
+The Linking Book uses the same Legacy page layout and bottom-corner page turns
+as the Descriptive Book, but without the Descriptive Book's gold cover edges.
+Both screens play Minecraft's book-page-turn sound when a page is turned.
 
 Successful book travel plays Mystcraft Legacy's original linking sound at both
 the departure and arrival locations.
@@ -110,6 +195,10 @@ known upstream limits are documented in
 ```
 
 The built mod is written to `build/libs/`.
+The default dedicated-server GameTest run is deliberately small. Use
+`./gradlew runGameTestServer -PwithArchivedGameTests=true` for the complete
+regression suite before a release or when investigating a related issue. See
+[docs/GAMETESTS.md](docs/GAMETESTS.md).
 
 ## Versioning
 

build.gradle

@@ -17,6 +17,18 @@ tasks.named('wrapper', Wrapper).configure {
 version = mod_version
 group = mod_group_id
 
+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()
+                .split(',').collect { it.trim() }.findAll { !it.isEmpty() }
+if (!archivedGameTestSuites.containsAll(selectedArchivedGameTestSuites)) {
+    throw new GradleException("Unknown archived GameTest suite. Choose from: ${archivedGameTestSuites.join(', ')}")
+}
+String enabledGameTestNamespaces = ([mod_id] + selectedArchivedGameTestSuites.collect {
+    "rivencraft_archive_${it}"
+}).join(',')
+
 sourceSets.main.resources {
     // Include resources generated by data generators.
     srcDir('src/generated/resources')
@@ -26,7 +38,53 @@ 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 ->
+        from('src/main/resources/data/rivencraft/structure/empty.nbt') {
+            into "data/rivencraft_archive_${suite}/structure"
+        }
+    }
+}
+
 repositories {
+    maven {
+        name = 'JaredsMaven'
+        url = 'https://maven.blamejared.com'
+        content {
+            includeGroup 'mezz.jei'
+            includeGroup 'net.mezzdev.config'
+        }
+    }
     maven { url = 'https://maven.createmod.net' }
     maven {
         url = 'https://www.cursemaven.com'
@@ -78,7 +136,10 @@ neoForge {
         // The gametest system is also enabled by default for other run configs under the /test command.
         gameTestServer {
             type = "gameTestServer"
-            systemProperty 'neoforge.enabledGameTestNamespaces', project.mod_id
+            // Keep generated test Ages separate from worlds used by the dev client/server.
+            gameDirectory = project.file(project.findProperty('gameTestRunDir')
+                    ?: layout.buildDirectory.dir('gametest-run').get().asFile)
+            systemProperty 'neoforge.enabledGameTestNamespaces', enabledGameTestNamespaces
         }
 
         data {
@@ -116,6 +177,54 @@ neoForge {
     }
 }
 
+// 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 dedicatedGameTestBuildDir = layout.buildDirectory.get().asFile
+File dedicatedGameTestDir = layout.buildDirectory.dir('gametest-run').get().asFile
+def prepareGameTestWorld = tasks.register('prepareGameTestWorld') {
+    onlyIf { !customGameTestRunDir }
+    doLast {
+        GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
+    }
+}
+def finishGameTestWorld = tasks.register('finishGameTestWorld') {
+    onlyIf { !customGameTestRunDir }
+    doLast {
+        GameTestWorlds.clean(dedicatedGameTestBuildDir, dedicatedGameTestDir)
+    }
+}
+tasks.named('runGameTestServer').configure {
+    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'.
 // This configuration should be used instead of 'runtimeOnly' to declare
 // a dependency that will be present for runtime testing but that is
@@ -131,12 +240,12 @@ dependencies {
     compileOnly "maven.modrinth:immersive-portals-neoforge:${immersive_portals_version}"
     implementation "curse.maven:dynamicdimension-ar-edition-1469680:${dynamic_dimensions_file_id}"
     implementation "lol.bai:badpackets:neo-${badpackets_version}"
-    // Example optional mod dependency with JEI
+    // JEI integration is isolated in its plugin and absent from the published runtime dependencies.
-    // The JEI API is declared for compile time use, while the full JEI artifact is used at runtime
+    compileOnly "mezz.jei:jei-${minecraft_version}-neoforge-api:${jei_version}"
-    // compileOnly "mezz.jei:jei-${mc_version}-common-api:${jei_version}"
+    // Opt in to JEI for a dev client with -PwithJei=true.
-    // compileOnly "mezz.jei:jei-${mc_version}-neoforge-api:${jei_version}"
+    if (providers.gradleProperty('withJei').map { it.toBoolean() }.orElse(false).get()) {
-    // We add the full version to localRuntime, not runtimeOnly, so that we do not publish a dependency on it
+        localRuntime "mezz.jei:jei-${minecraft_version}-neoforge:${jei_version}"
-    // localRuntime "mezz.jei:jei-${mc_version}-neoforge:${jei_version}"
+    }
 
     // Example mod dependency using a mod jar from ./libs with a flat dir repository
     // This maps to ./libs/coolmod-${mc_version}-${coolmod_version}.jar

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
+and rolled traits. For an **authored** Age, the generation plan also stores a
-reroll those immutable values. An unloaded Age resolves its stored profile
+copy of the resolved runtime profile: terrain shape, noise settings, biome
-again when it loads, so intentional profile overrides affect its runtime
+preset, and dimension type. `/reload` cannot reinterpret that plan; an unloaded
-resources and newly generated chunks.
+authored Age uses the saved profile snapshot when it loads, even if the defining
+symbol or profile JSON has since changed. An older, page-free Age has no plan
+and continues to resolve its saved profile ID at load time.
 
-A profile removed after an Age was created resolves to `rivencraft:standard`.
+Registered noise, biome-preset, and dimension-type IDs are validated when
+profiles load. Before loading an authored Age, the saved references are checked
+again. If a data pack supplying one has been removed, the dimension stays
+unloaded and the log identifies the missing resource; the Age's plan is not
+silently replaced. Restore the pack to load that Age. A custom dimension type
+retains its own skylight capability: normal lighting cannot make a Nether-style
+type skylit.
+
+A profile removed after a page-free Age was created resolves to `rivencraft:standard`.
 The legacy `rivencraft:random_vanilla` alias also resolves to `standard`.
 Rivencraft logs this fallback. Invalid built-in overrides do not replace the
 required built-in definitions; a reload fails if a required built-in profile

docs/ASSET_PROVENANCE.md

@@ -8,10 +8,23 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | --- | --- | --- | --- |
 | `assets/rivencraft/textures/item/page.png` | `assets/mystcraft/textures/items/page_background.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
 | `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Notebook draws the native 30×40 page at atlas coordinates `(156, 0)` |
+| `assets/rivencraft/textures/gui/bookui_cover.png` | `assets/mystcraft/gui/bookui_cover.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared book cover, with gold edges drawn only for Descriptive Books |
+| `assets/rivencraft/textures/gui/bookui_pagel.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; turned left page |
+| `assets/rivencraft/textures/gui/bookui_pager.png` | `assets/mystcraft/gui/bookui_pager.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; link-panel frame on the first right page |
+| `assets/rivencraft/textures/gui/bookui_rpage_full.png` | `assets/mystcraft/gui/bookui_rpage_full.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; full right written page |
 | `assets/rivencraft/textures/item/writing_desk.png` | `assets/mystcraft/textures/items/writingdesk.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
+| `assets/rivencraft/textures/block/writing_desk.png` | `assets/mystcraft/textures/entity/desk.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
+| `assets/rivencraft/textures/gui/writing_desk_legacy.png` | `assets/mystcraft/gui/writingdesk.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; full desk panel, tabs, and cycling controls at original atlas coordinates |
+| `assets/rivencraft/textures/gui/scrollbar.png` | `assets/mystcraft/gui/scrollbar.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; tiled track and normal/pressed thumb |
+| `assets/rivencraft/textures/block/book_binder.png` | `assets/mystcraft/textures/entity/bookbinder/bookbinder.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Book Binder model uses this body texture |
+| `assets/rivencraft/textures/block/book_binder_press.png` | `assets/mystcraft/textures/entity/bookbinder/press_part.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Book Binder model uses this press texture |
+| `assets/rivencraft/textures/gui/book_binder_legacy.png` | `assets/mystcraft/gui/pagebinder.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Book Binder GUI uses the original 176×181 panel |
+| `assets/rivencraft/textures/gui/ink_mixer_legacy.png` | `assets/mystcraft/gui/inkmixer.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Ink Mixer GUI uses the original 176×181 panel |
+| `assets/rivencraft/textures/block/ink_mixer_top.png`, `ink_mixer_side.png`, `ink_mixer_bottom.png` | `assets/mystcraft/textures/blocks/inkmixer_top.png`, `inkmixer_side.png`, `inkmixer_bottom.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Rivencraft supplies its own block model |
 | `assets/rivencraft/textures/item/linking_book_unwritten.png` | `assets/mystcraft/textures/items/unlinked.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
 | `assets/rivencraft/textures/item/page_link_panel.png` | `page_background.png` and `PageBuilder.BasicPageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Reproduces the legacy 160 px scale, black panel at `(25,30)`–`(135,75)`, and 128 px resample |
-| `assets/rivencraft/textures/item/page_symbol*.png` and `page_unresolved.png` | `page_background.png`, `textures/symbolcomponents.png`, `WordData`, `ModSymbols`, and `PageBuilder.PageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Static 1.21.1 renditions of the legacy runtime-composed four-word symbol pages; `normal_time` uses the legacy Full Length poem |
+| `assets/rivencraft/textures/gui/symbolcomponents.png` | `assets/mystcraft/textures/symbolcomponents.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Byte-identical shared 512×512 component sheet for client-side page composition |
+| Runtime-composed symbol pages (`SymbolPageTextures`) | `page_background.png`, `textures/symbolcomponents.png`, `WordData`, `ModSymbols`, and `PageBuilder.PageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Replaces the six pre-generated symbol PNGs; layers four poem words on the shared page background and caches bounded client textures |
 
 Mystcraft Legacy identifies XCompWiz as its project developer and includes the
 full LGPL v3 text in its root `LICENSE` file. Rivencraft's root `LICENSE`

docs/GAMETESTS.md

@@ -0,0 +1,43 @@
+# GameTest suites
+
+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.
+
+```shell
+./gradlew runGameTestServer
+```
+
+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
+core tests when investigating an issue:
+
+```shell
+./gradlew runGameTestServer -ParchivedGameTestSuites=desk
+./gradlew runGameTestServer -ParchivedGameTestSuites=grammar,binder
+```
+
+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
+./gradlew runGameTestServer -PwithArchivedGameTests=true
+```
+
+Each archive is selected by its `rivencraft_archive_<suite>` GameTest namespace.
+The suites share the normal empty test structure and do not need Create, Ponder, or
+Immersive Portals. The core suite delegates to the original regression methods
+for its selected cases, so the two suites do not maintain duplicate test logic.
+
+GameTest Ages are created in `build/gametest-run/world`, not in a development
+client save. Every default GameTest invocation starts with a fresh world.
+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/LEGACY_AGE_GRAMMAR_AUDIT.md

@@ -0,0 +1,58 @@
+# Mystcraft Legacy Age grammar audit (milestone 5, issue #28)
+
+Reference: [Mystcraft-Legacy commit `9bc8ddc`](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae), whose [build properties](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/build.properties) identify version 0.13.7.06. The user-provided local Minecraft 1.12.2 extraction (`mystcraft-1.12.2-0.13.7.06`) has the same version in `mcmod.info`; its `assets/mystcraft/textures/symbolcomponents.png` is byte-identical to the source checkout. That extraction contains compiled classes and assets, but no shipped `.cfg` or `.java` files. Source-linked behavioral claims below use the corresponding GitHub Java source. This is a behavior specification, not a code port. Any later adapted code needs its own copyright/provenance record under [PORTING.md](PORTING.md).
+
+## What Legacy actually does
+
+Legacy's [root rule](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/GrammarRules.java#L62) produces, in order: terrain, biome controller, weather, lighting, optional spawning, suns, moons, starfields, doodads, visuals, small/medium/large features, and effects. Each symbol declares the rule it can satisfy and any preceding modifier tokens it needs in [SymbolRules](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/SymbolRules.java). The written page order therefore matters: modifiers appear before their consumer, while missing grammar branches can be generated. The [grammar tree](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/grammar/GrammarTree.java#L158-L222) connects authored terminals and inserts missing branches; [AgeData](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/agedata/AgeData.java#L230-L258) does this on first link with an Age-seeded RNG. Weighted rule *ranks* choose generated symbols; a `null` rank is not randomly generated, though such a rule can connect authored pages ([GrammarGenerator](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/grammar/GrammarGenerator.java#L28-L112)).
+
+Legacy does **not** reject a book just because it omits terrain, biome, weather, or lighting. It fills the gaps. It also has separate instability accounting for dangling/excess symbols; this audit records those as diagnostics, not as milestone 5 generation effects ([AgeController](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java#L196-L247)).
+
+## Symbol-to-Rivencraft mapping
+
+| Legacy category and symbols | Existing Rivencraft path | Milestone 5 disposition |
+| --- | --- | --- |
+| `TerrainNormal`, `TerrainAmplified`, `TerrainFlat`, `TerrainVoid`, `TerrainNether`, `TerrainEnd`; terrain and sea block modifiers | `AgeProfile` selects noise/flat/void and registered noise settings; random profiles already persist per Age | Compile supported terrain shapes into profile/resources. Nether/End and material modifiers require explicit compatible data-pack resources; do not claim exact 1.12 terrain parity. |
+| `BioConNative`, `Single`, `Tiled`, `Grid`, `Tiny`, `Small`, `Medium`, `Large`, `Huge`, plus biome pages | `AgeTraits.BiomeDistribution` has all nine modes; `AgeDimensionService` has sources for these modes | Map modes, consume authored biome IDs in order, then deterministically fill required minimums. Native uses the profile's modern biome preset, not the old `BiomeProvider`. |
+| `LightingNormal`, `Dark`, `Bright` | `AgeTraits.Lighting`, dimension type construction | Compile the choice to a stable dimension type/light behavior. Exact Legacy 1.12 brightness-table rendering is not guaranteed by NeoForge's dimension-type fields. |
+| `WeatherNorm`, `Fast`, `Slow`, `Off`, `On`, `Cloudy`, `Rain`, `Snow`, `Storm` | `AgeTraits.Weather` has matching names except Legacy `On` maps to `ALWAYS` | Compile weather semantics separately from biome selection. `Snow` must remain deferred until optional season integration; do not silently substitute another weather mode. |
+| Suns, moons, starfields; angle, phase, period, color/gradient/sunset modifiers | One `celestialPeriod`, `celestialAngle`, `celestialPhase` on `AgeTraits` | Compile only the representable single-cycle subset first. Multiple celestial bodies, independent periods, custom stars, gradients and sunsets need a richer definition and renderer, not flattening into one value. |
+| Sky/fog/cloud/grass/foliage/water colors, natural variants, horizon, rainbow | Existing sky/dimension visuals and preview | Require an explicit modern client/biome-color design; metadata-only symbol pages must not pretend to change rendering. |
+| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile and vanilla data-pack generation | Compile only features for which registered 1.21.1 placed features/structures exist. Defer bespoke structures and polish to milestone 7. |
+| `EnvAccel`, explosions, lightning, meteors, scorching; PvP and dummy suppression pages | No equivalent Age-definition effect | Defer environmental hazards/instability effects to milestone 6, PvP rule to a separately scoped server policy; retain authored IDs without fake behavior. |
+
+The Legacy symbol list and page names come from [ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L129-L240) and [SymbolRules](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/SymbolRules.java#L19-L137). Rivencraft's [catalog](../src/main/java/net/dnorberg/rivencraft/writing/SymbolCatalog.java) currently holds display metadata only; its built-in set is just standard terrain, native biomes, normal weather, normal lighting, normal time, and caves. [OrderedWriting](../src/main/java/net/dnorberg/rivencraft/writing/OrderedWriting.java) preserves page order, but no compiler yet connects it to [AgeTraits](../src/main/java/net/dnorberg/rivencraft/book/AgeTraits.java) or [Age profiles](AGE_PROFILES.md).
+
+## Symbol-page artwork: `symbolcomponents.png`
+
+Legacy does not allocate one image tile to each complete Age symbol. The [default word image source](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/api/java/com/xcompwiz/mystcraft/api/word/DrawableWord.java#L24-L75) is `mystcraft:textures/symbolcomponents.png`, a 512×512 RGBA sheet. It has an 8×8 grid of 64×64 component cells. For zero-based component index `n`, source pixels begin at `x = (n % 8) * 64`, `y = (n / 8) * 64`. [GuiUtils.drawComponent](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/client/gui/GuiUtils.java#L131-L152) uses that mapping for GUI drawing; [PageBuilder.PageSprite.stitchWord](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/client/render/PageBuilder.java#L287-L331) uses it when composing an item sprite. Cell `0` is the missing-word/question-mark fallback. Each component may be tinted and its alpha layered with the other components of a word.
+
+The complete lookup chain for a unique page is:
+
+1. [WordData.init](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/api/java/com/xcompwiz/mystcraft/api/word/WordData.java#L96-L166) registers a list of component indices for each named word (for example, `Nature` uses `5, 6, 8, 10, 11, 12, 15, 16, 17, 22`). [DrawableWord](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/api/java/com/xcompwiz/mystcraft/api/word/DrawableWord.java#L26-L75) also permits per-component colors and an alternate image source. Unregistered words get a deterministic component list from their lowercase name hash ([DrawableWordManager](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/words/DrawableWordManager.java#L34-L56)).
+2. [ModSymbols.registerSymbol](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L105-L116) assigns four poem words to each Age symbol. For example, `LightingNormal` is `Ethereal, Dynamic, Cycle, Balance` ([registration](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L184-L186)). The poem, not the symbol ID, selects the component layers.
+3. [PageBuilder.PageSprite](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/client/render/PageBuilder.java#L232-L279) draws those words above, right, below, and left of the page center, respectively. Their target rectangles on its 160×160 working image are `(48,0)`, `(96,48)`, `(48,96)`, `(0,48)`, each 64×64 ([getPageTarget](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/client/render/PageBuilder.java#L360-L378)). It scales the composed image to a 128×128 item sprite. [GuiUtils.drawSymbol](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/client/gui/GuiUtils.java#L74-L96) renders the same four-word arrangement directly in book/workstation GUIs.
+
+For Rivencraft, keep **symbol semantics** (`SymbolReference`/catalog ID) separate from **page artwork** (four ordered word names, their component indices/colors, and the shared sheet). Existing built-in page images are static renditions of this process ([asset provenance](ASSET_PROVENANCE.md)); future symbol pages can compose it at build time or in a client-only renderer. Unknown words and missing symbols need distinct fallbacks, and data-pack-only symbols must remain usable without silently borrowing another symbol's image. Do not copy the Legacy renderer wholesale: its texture-atlas and GUI APIs target 1.12.2.
+
+## Verified numeric defaults and bounds
+
+These values are from code, **not** a supposed shipped `.cfg`: the inspected Legacy repository contains no default configuration file with numeric min/max fields for age grammar. [MystConfig](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/config/MystConfig.java) supplies typed config helpers, while symbol enablement uses a Boolean `<symbol>.enabled` option ([SymbolManager](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/SymbolManager.java#L91-L107)). Do not label Rivencraft's present numeric range as a Legacy config range.
+
+| Parameter | Legacy source value/rule | Implementation consequence |
+| --- | --- | --- |
+| Period pages | `Zero=0`, `Half=0.5`, `Full=1`, `Double=2` ([ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L194-L201)); repeated period modifiers average pairwise ([SymbolLength](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/modifiers/SymbolLength.java#L25-L37)) | Authored basic values have min 0 and max 2; no arbitrary continuous written range is established. A sun without a period uses `0.8 + 0.4 * nextDouble()`—`[0.8, 1.2)`—before conversion to ticks ([SymbolSunNormal](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolSunNormal.java#L47-L73)). Rivencraft's random nonzero `[0.2, 2.0)` is its own existing policy. |
+| Angle pages | North/East/South/West = `0/90/180/270` degrees ([ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L187-L190)); repeated values use shortest-arc averaging ([ModifierUtils](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/api/java/com/xcompwiz/mystcraft/api/symbol/ModifierUtils.java#L54-L73)) | Canonical angle is `[0, 360)`; consumers may seed a random angle if omitted. |
+| Phase pages | Nadir/Rising/Zenith/Setting = `0/90/180/270` degrees ([ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L198-L201)); the sun divides by 360 ([SymbolSunNormal](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolSunNormal.java#L65-L73)) | Written phase is `[0, 360)` degrees, represented by Rivencraft as `[0, 1)` turns. |
+| Biome count | Grammar requires one page for `Single`, `Tiled`, `Grid`; `Tiny`–`Huge` have two explicit biome slots plus a biome-list branch ([SymbolRules](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/SymbolRules.java#L91-L99)). `Single` fills to 1 ([source](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolBiomeControllerSingle.java#L22-L37)), `Tiled`/`Grid` to 2 ([source](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolBiomeControllerTiled.java#L25-L38)), and `Tiny`–`Huge` to 3 ([source](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolBiomeControllerLarge.java#L61-L84)) | These are **minimums**, not maximums. `Native` uses vanilla's provider and has no authored biome-list requirement ([source](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolBiomeControllerNative.java#L34-L44)). Preserve additional authored biomes where the chosen controller can accept them. |
+| Weather normal | Rain duration/base `12000/12000`, cooldown/base `168000/12000`; thunder duration/base `12000/3600`, cooldown/base `168000/12000` ticks ([SymbolWeatherNormal](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/symbol/symbols/SymbolWeatherNormal.java#L25-L36)) | These are source constants, not configurable min/max bounds. Other weather controllers need individual review before parity claims. |
+
+## Compilation and fallback contract for the next issues
+
+1. A Link-Panel-only book, a legacy page-free book, and any book with no effective supported Age symbols retain the current seed-derived random Age path. Preserve the saved writing untouched.
+2. A supported partial sequence is **not** invalid: complete missing required branches deterministically from the Age seed, then compile the result. Authored symbols take precedence over generated fillers. This follows Legacy's grammar tree, rather than requiring a full hand-written list.
+3. Unknown/unresolved IDs, unsupported-but-known effects, misplaced modifiers, duplicates, and conflicts must be reported distinctly. Do not silently apply a different effect or discard an authored page. A first compiler may use the existing random Age path for combinations it cannot represent, with an explicit diagnostic; it must never claim such a book was successfully compiled.
+4. Grammar diagnostics are not instability. Milestone 5 decides recognition, ordering, completion, and whether a supported combination can compile. Milestone 6 may use dangling/excess/conflict diagnostics for instability effects. Milestone 7 owns bespoke structures and polish.
+5. Freeze the completed, effective generation definition with the Age identity before creating chunks. Keep page order and original IDs for display/migration, and keep seeded completion deterministic across reloads. New symbol behavior belongs in versioned server data, not the schema-1 display catalog.
+
+The mapping is intentionally narrower than all Legacy symbols. The exact rule and compiler schema are follow-up issues #29–#31; terrain, biome, environment, and feature implementations are #32–#35. No generation behavior or release version changes in this audit.

docs/PORTING.md

@@ -33,11 +33,14 @@ acceptance issue and all required implementation issues are complete.
    lifecycle management, data-pack integration, and optional destination
    renderer compatibility. **Complete.** See
    [Milestone 3](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/8).
-4. **Writing system** — pages, symbols, notebooks, desks, and book assembly.
+4. **Writing system** — pages, notebooks, desks, book assembly, and the baseline
-   **In progress.**
+   Ink Mixer for Link Panels. Symbol effects are deferred until Milestone 5.
+   **Complete.** See [Milestone 4](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/9)
+   and [writing-system data and migration](WRITING_DATA.md).
 5. **Age grammar** — translate symbol combinations into modern biome, noise,
    dimension-type, and world-generation configuration. Optional integrations
-   may add composable biome regions and seasonal behavior.
+   may add composable biome regions and seasonal behavior. See the
+   [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md).
 6. **Instability** — deterministic validation and server-safe effects.
 7. **Structures and polish** — libraries, crystals, portals, recipes, models,
    sounds, advancements, compatibility, and migration tests.
@@ -62,10 +65,13 @@ The writing system and Age grammar will build on the existing page-free Age
 path. Page-free books remain a useful deterministic fallback and test fixture
 after written symbol combinations become available.
 
-Milestone 4 begins with a versioned, data-pack-defined symbol catalog and an
+Milestone 4 delivered a versioned, data-pack-defined symbol catalog and an
 immutable ordered-writing model. See [WRITING_DATA.md](WRITING_DATA.md). These
 contracts preserve unknown symbol identifiers and store author intent; they do
 not interpret symbols into Age generation, which remains Milestone 5 work.
+The Ink Mixer is included in Milestone 4 after book assembly; it
+uses paper and Ink Vials to make baseline Link Panels. Adding modifier
+ingredients and symbol-driven link properties belongs to Milestone 5.
 
 ## Provenance rules
 

docs/PREVIEW_COMPATIBILITY.md

@@ -66,7 +66,7 @@ unstable in a particular graphics or mod configuration.
 
 For preview-related releases:
 
-1. Run `./gradlew runGameTestServer` to verify the complete selection matrix,
+1. Run `./gradlew runGameTestServer -PwithArchivedGameTests=true` to verify the complete selection matrix,
    core Age creation, persistence, and travel without optional renderers.
 2. Open held Linking and Descriptive Books once with each available backend.
 3. Open both book types from a Book Stand and confirm Explore is disabled.
@@ -75,4 +75,3 @@ For preview-related releases:
    preview loader remains active.
 5. With Ponder, reopen different destinations and confirm the previous
    snapshot does not bleed into the next one.
-

docs/SYMBOL_SEMANTICS.md

@@ -0,0 +1,44 @@
+# Server-authoritative symbol semantics (schema v2)
+
+Milestone 5 issue #29 adds typed meaning to the existing data-pack symbol catalog. Put definitions at `data/<namespace>/rivencraft/symbols/<path>.json`; the file ID becomes the stable symbol ID. For example, `data/example/rivencraft/symbols/terrain/highlands.json` defines `example:terrain/highlands`:
+
+```json
+{
+  "schema_version": 2,
+  "name": "symbol.example.terrain.highlands",
+  "description": "symbol.example.terrain.highlands.description",
+  "category": "example:terrain",
+  "semantics": {
+    "role": "terrain",
+    "value": "example:highlands"
+  },
+  "poem": "Terrain Form Tradition Flow"
+}
+```
+
+`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that a later compiler must resolve and validate. A syntactically valid resource ID alone does not guarantee the profile or feature exists.
+
+`poem` is optional, client-safe artwork metadata: exactly four alphabetic words, ordered top, right, bottom, left. The client layers their glyphs from the shared Legacy component sheet at runtime. GUI thumbnails use the full transparent artwork over their page backgrounds; item icons use the same artwork reduced from 16 to 13 pixels across, over the page texture. Unregistered words use a stable generated component combination; when a symbol has no poem, the six original built-in IDs retain their Legacy poems and other IDs produce four stable fallback words. This affects appearance only, never Age generation. Generated images are cached up to 256 entries and discarded on resource reload.
+
+The Writing Desk's 88 collection tabs use Legacy's number components, chiefly the bottom row of `symbolcomponents.png`, rather than word sigils. Legacy's `ModWords.constructNumber` combines four unit marks (1–4) with four five-step marks (5–20) to form 1–24 and uses a separate zero mark. Rivencraft extends these marks positionally in base 25 for tabs 25–88 (for example, 25 is 1 followed by 0). Hovering still reveals the decimal number for accessibility. The former arbitrary-word glyph generator remains useful for rendering text: on page-free Descriptive Books, the generated Age description now appears as a sequence of layered word glyphs instead of Minecraft's enchantment font. The Age name stays readable.
+
+| Role | Value type and allowed values |
+| --- | --- |
+| `terrain` | Canonical namespaced Age profile ID. |
+| `biome_controller` | `native`, `single`, `tiled`, `grid`, `tiny`, `small`, `medium`, `large`, or `huge`. |
+| `biome` | Canonical namespaced biome ID. |
+| `lighting` | `normal`, `dark`, or `bright`. |
+| `weather` | `normal`, `fast`, `slow`, `off`, `always`, `cloudy`, `rain`, `snow`, or `storm`. |
+| `celestial` | `normal_time` (the first representable single-cycle behavior). |
+| `period_modifier` | JSON number in `[0, 2]`; zero is stopped time. |
+| `angle_modifier` | JSON number in `[0, 360)` degrees. |
+| `phase_modifier` | JSON number in `[0, 360)` degrees; the compiler will convert to turns. |
+| `feature` | Canonical namespaced feature-effect ID; future generation mapping must recognize it. |
+
+These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, special structures, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field.
+
+The server rejects a v2 definition with an unknown top-level or semantics field, missing/incorrectly typed field, unknown role or choice, malformed/non-canonical resource ID, or out-of-range/non-finite number. An invalid definition is logged with its file ID and excluded from the active catalog. Saved pages and books still retain that ID, allowing the player to recover them if the data pack is corrected. A reload atomically replaces the catalog rather than mutating saved writing.
+
+Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only `SymbolDisplayMetadata` (ID, translation keys, category, resolved flag); semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, but does **not yet apply** written symbols to Age generation; issue #31 adds compilation.
+
+The six built-in definitions demonstrate terrain, biome-controller, lighting, weather, celestial, and feature roles. A third-party pack may add its own definitions under its namespace. Use an explicit semantic role even when the display category has the same name; the two fields serve different purposes.

docs/WRITING_DATA.md

@@ -1,9 +1,11 @@
 # Writing and symbol data
 
 Milestone 4 stores what a player wrote without deciding what that writing does
-to an Age. Milestone 5 owns grammar validation, symbol interaction, instability,
+to an Age. Milestone 5 owns grammar validation and symbol interaction,
 and translation into biome, noise, dimension-type, and other world-generation
-configuration.
+configuration. Milestone 6 owns instability effects. See the
+[Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source-backed
+Milestone 5 contract.
 
 ## Symbol catalog
 
@@ -25,13 +27,17 @@ Schema version 1 contains display metadata only:
 
 `name` and `description` are translation keys, not arbitrary formatted text or
 executable behavior. `category` is a namespaced organizational identifier.
+Milestone 5 adds [server-authoritative schema v2 semantics](SYMBOL_SEMANTICS.md)
+with a typed role and bounded value. Existing v1 definitions remain readable
+but display-only; updating an ID to v2 never rewrites saved pages or books.
 Invalid definitions are logged and excluded by the server. Menus and future
 page synchronization must obtain resolved display metadata from the server;
 clients never make a symbol valid by naming it.
 
 Rivencraft ships a small catalog covering terrain, biomes, lighting, weather,
-celestial behavior, and features. It exists to exercise the complete writing
+celestial behavior, and features. Its v2 semantics prepare for the full
-workflow before Milestone 5 implements the full legacy grammar.
+Legacy-inspired grammar; writing still uses random Age fallback until the
+parser and compiler are implemented.
 
 ## Persistent writing
 
@@ -40,6 +46,18 @@ a symbol reference or a baseline link-panel marker. `OrderedWriting` retains up
 to 256 entries in exact player-authored order. All three contracts have both
 persistent codecs and bounded network codecs.
 
+Assembled Descriptive Books store `OrderedWriting` schema version 1 alongside
+their Age reference. Books assembled in 0.3.7.2 saved writing as a bare list;
+that form still loads as version 1 without reordering or dropping unknown IDs.
+Older page-free books without writing continue to work unchanged. Copying a
+book copies its writing and Age reference; merely copying it never creates a
+new Age. The Book Binder creates the Age when its finished output is taken.
+The Descriptive Book screen can inspect the ordered pages by turning them from
+the bottom corners and identifies unresolved IDs using server-provided symbol
+metadata. Until Milestone 5, the
+saved symbols are informational only: Age creation uses the existing random
+fallback and does not apply them to generation.
+
 Removing a data pack never removes its IDs from saved writing. A missing ID is
 resolved as client-safe **Unresolved Symbol** display metadata while retaining
 the original namespaced ID for diagnostics and later restoration. This is
@@ -53,11 +71,11 @@ unresolved symbol, and baseline link panel. Symbol and unresolved-symbol pages
 retain their namespaced symbol reference; unresolved pages can be inspected and
 removed but are rejected as usable writing until their data pack returns.
 
-Only server-side writing operations may turn a blank page into a known symbol
+Only server-side writing operations may create a known symbol page or link
-page or link panel. The shared `PageItem` creation and validation gates reject
+panel from vanilla paper. The shared `PageItem` creation and validation gates
-new pages for identifiers absent from the server catalog. Later Writing Desk
+reject new pages for identifiers absent from the server catalog. The Writing
-and Book Binder packets must call these gates rather than accepting page
+Desk refuses to copy an unresolved page, and the Book Binder keeps such a page
-contents supplied by a client.
+removable but will not assemble a book from it until its symbol resolves again.
 
 The item model uses server-assigned custom-model data derived from the symbol
 identifier. Built-in pages reproduce Mystcraft Legacy's four-word poem
@@ -72,6 +90,29 @@ placement. The surface draws the native 30×40 portrait page region from
 Legacy's book UI atlas; symbols are layered at a uniform scale, while the
 square item models remain unchanged in inventories.
 
+A Notebook holds 27 ordered positions. Its pages, names, gaps, and unresolved
+IDs are saved on the item, so moving the Notebook between an inventory, Desk,
+and Binder does not rearrange them. A loose Page in a Desk tab exposes just one
+position; a Notebook exposes all 27. The Desk has 88 persistent collection
+tabs, shown four at a time. Use the up/down tab controls to move by four, put
+paper and Ink Vials in their input slots, select a stored page, and take the
+copy from the virtual output. Taking it spends one paper and the configured
+symbol-copy ink cost. The `AZ`, `ALL`, search, and category controls only change
+which stored pages are displayed; the server rechecks the actual source before
+copying. Moving a page within the Desk or dragging it into the inventory removes
+the original only when the destination accepts it.
+
+The Book Binder takes a leather or empty-Notebook cover, an Age title, one Link
+Panel, and optionally up to 27 ordered written Pages. A filled Notebook can be
+imported at a chosen strip position; the empty Notebook remains recoverable.
+The preview result is virtual. Taking the completed Descriptive Book commits the
+inputs once, creates its Age identity, and saves schema-versioned
+`OrderedWriting` plus the Age reference on the book. Link-Panel-only books
+create random Ages. A written symbol does **not** yet change that generation.
+Inputs, title, and pending Age identity survive Binder save/load; breaking the
+Binder returns stored inputs. The completed book retains both its writing and
+Age identity through item save/load and copying.
+
 ## Ink and baseline link panels
 
 An Ink Vial is crafted from two black dye, a glass bottle, and a water bucket.
@@ -82,9 +123,41 @@ used to craft another. The animated item texture comes from Mystcraft Legacy.
 
 The server config sets ink costs independently for symbol copying (default one
 unit) and baseline link-panel preparation (default two units). To prepare a
-panel, hold a blank Page in one hand and use an Ink Vial in the other. The
+panel, hold vanilla paper in one hand and use an Ink Vial in the other. The
-server checks the held items, blank state, and sufficient ink before consuming
+server checks the held items and sufficient ink before consuming
-anything. A stack of blank Pages yields exactly one Link Panel Page per use;
+anything. A stack of paper yields exactly one Link Panel Page per use;
 if the inventory is full, the result is dropped instead of deleted. Symbol
-copying will be implemented by the Writing Desk. Link-property modifiers are
+copying is implemented by the Writing Desk: it previews a copy of the selected
+resolved page, then spends paper and ink only when that copy is taken. The
+desk's 16-unit ink meter refills from an Ink Vial when needed and returns a
+vanilla glass bottle. Link-property modifiers are
 deferred beyond this baseline flow.
+
+The Ink Mixer is the station version of Link Panel preparation. Put paper and
+Ink Vials in its inputs and take the Link Panel from its virtual output. Its
+16-unit basin refills only when needed and only if the glass-bottle output has
+space. The basin and inputs persist through save/load; breaking the Mixer
+returns stored items. A Link Panel plus leather also crafts an unwritten
+Linking Book. JEI, when installed, displays the Mixer operation and the
+writing, binding, and Linking Book crafting flows; it is not required to play.
+
+## Migration and validation
+
+The 0.3.7.2 bare-list `OrderedWriting` form reads as schema version 1 without
+changing entry order. Descriptive Books with no writing component keep their
+existing Age behavior. Old eight-slot Desks migrate their four collections,
+ink supply, paper, bottle return, and legacy output into the 88-tab layout;
+saved inputs are never silently discarded. Missing symbol IDs survive page,
+Notebook, Binder, and assembled-book persistence instead of being substituted
+or erased.
+
+The core and archived dedicated-server [GameTests](GAMETESTS.md) together
+exercise codec and item round-trips, legacy data,
+workstation NBT reload, break drops, full-inventory refusal, forged menu IDs,
+and replayed output requests. World saves and chunk unloads use the same block
+entity NBT persistence path as those reload tests. This does not replace a
+manual smoke test of loading an older world before updating a production save.
+
+Milestone 4 stops at preserving author intent and offering a playable random
+Age fallback. Milestone 5 will define symbol grammar and validation, translate
+valid writing into actual Age generation, and introduce symbol and ink modifiers.

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

@@ -22,6 +22,7 @@ neo_version=21.1.251
 ponder_version=1.0.82
 dynamic_dimensions_file_id=7707789
 badpackets_version=0.8.2
+jei_version=19.57.0.449
 # The loader version range can only use the major version of FML as bounds
 loader_version_range=[1,)
 
@@ -35,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.3.5.0
+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

@@ -5,10 +5,12 @@ import net.dnorberg.rivencraft.registry.ModCreativeTabs;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.registry.ModMenus;
+import net.dnorberg.rivencraft.registry.ModRecipeSerializers;
 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;
@@ -39,10 +41,12 @@ 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);
         ModMenus.register(modEventBus);
+        ModRecipeSerializers.register(modEventBus);
         ModSounds.register(modEventBus);
         ModCreativeTabs.register(modEventBus);
         NeoForge.EVENT_BUS.addListener(BookStandConversionHandler::onRightClickBlock);

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

@@ -0,0 +1,66 @@
+package net.dnorberg.rivencraft.block;
+
+import com.mojang.serialization.MapCodec;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.menu.BookBinderMenu;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.Containers;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.SimpleMenuProvider;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.context.BlockPlaceContext;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.RenderShape;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.BlockStateProperties;
+import net.minecraft.world.level.block.state.properties.DirectionProperty;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.phys.BlockHitResult;
+
+public final class BookBinderBlock extends BaseEntityBlock {
+    public static final MapCodec<BookBinderBlock> CODEC = simpleCodec(BookBinderBlock::new);
+    public static final DirectionProperty FACING = BlockStateProperties.HORIZONTAL_FACING;
+
+    public BookBinderBlock(Properties properties) {
+        super(properties);
+        registerDefaultState(stateDefinition.any().setValue(FACING, Direction.NORTH));
+    }
+
+    @Override public MapCodec<? extends BaseEntityBlock> codec() { return CODEC; }
+    @Override protected void createBlockStateDefinition(StateDefinition.Builder<net.minecraft.world.level.block.Block, BlockState> builder) {
+        builder.add(FACING);
+    }
+    @Override public BlockState getStateForPlacement(BlockPlaceContext context) {
+        Direction facing = context.getHorizontalDirection().getOpposite();
+        return defaultBlockState().setValue(FACING, facing);
+    }
+    @Override protected RenderShape getRenderShape(BlockState state) { return RenderShape.MODEL; }
+    @Override public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        return new BookBinderBlockEntity(pos, state);
+    }
+    @Override protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos,
+                                                          Player player, BlockHitResult hit) {
+        if (!level.isClientSide && player instanceof ServerPlayer serverPlayer
+                && level.getBlockEntity(pos) instanceof BookBinderBlockEntity binder) {
+            serverPlayer.openMenu(new SimpleMenuProvider(
+                    (id, inventory, ignored) -> new BookBinderMenu(id, inventory, binder),
+                    Component.translatable("container.rivencraft.book_binder")),
+                    buffer -> buffer.writeBlockPos(pos));
+        }
+        return InteractionResult.sidedSuccess(level.isClientSide);
+    }
+    @Override protected void onRemove(BlockState state, Level level, BlockPos pos,
+                                      BlockState replacement, boolean moving) {
+        if (!state.is(replacement.getBlock()) && !level.isClientSide
+                && level.getBlockEntity(pos) instanceof BookBinderBlockEntity binder) {
+            Containers.dropContents(level, pos, binder);
+            level.updateNeighbourForOutputSignal(pos, this);
+        }
+        super.onRemove(state, level, pos, replacement, moving);
+    }
+}

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

@@ -0,0 +1,52 @@
+package net.dnorberg.rivencraft.block;
+
+import com.mojang.serialization.MapCodec;
+import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
+import net.dnorberg.rivencraft.menu.InkMixerMenu;
+import net.minecraft.core.BlockPos;
+import net.minecraft.network.chat.Component;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.Containers;
+import net.minecraft.world.InteractionResult;
+import net.minecraft.world.SimpleMenuProvider;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.RenderShape;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.phys.BlockHitResult;
+
+public final class InkMixerBlock extends BaseEntityBlock {
+    public static final MapCodec<InkMixerBlock> CODEC = simpleCodec(InkMixerBlock::new);
+
+    public InkMixerBlock(Properties properties) { super(properties); }
+
+    @Override protected MapCodec<? extends BaseEntityBlock> codec() { return CODEC; }
+    @Override protected RenderShape getRenderShape(BlockState state) { return RenderShape.MODEL; }
+    @Override public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        return new InkMixerBlockEntity(pos, state);
+    }
+
+    @Override protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos,
+                                                          Player player, BlockHitResult hit) {
+        if (!level.isClientSide && player instanceof ServerPlayer serverPlayer
+                && level.getBlockEntity(pos) instanceof InkMixerBlockEntity mixer) {
+            serverPlayer.openMenu(new SimpleMenuProvider(
+                    (id, inventory, ignored) -> new InkMixerMenu(id, inventory, mixer),
+                    Component.translatable("container.rivencraft.ink_mixer")),
+                    buffer -> buffer.writeBlockPos(pos));
+        }
+        return InteractionResult.sidedSuccess(level.isClientSide);
+    }
+
+    @Override protected void onRemove(BlockState state, Level level, BlockPos pos,
+                                      BlockState replacement, boolean moving) {
+        if (!state.is(replacement.getBlock()) && !level.isClientSide
+                && level.getBlockEntity(pos) instanceof InkMixerBlockEntity mixer) {
+            Containers.dropContents(level, pos, mixer);
+            level.updateNeighbourForOutputSignal(pos, this);
+        }
+        super.onRemove(state, level, pos, replacement, moving);
+    }
+}

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

@@ -3,7 +3,9 @@ package net.dnorberg.rivencraft.block;
 import com.mojang.serialization.MapCodec;
 import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
 import net.dnorberg.rivencraft.menu.WritingDeskMenu;
+import net.dnorberg.rivencraft.writing.WritingDeskCatalog;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
 import net.minecraft.network.chat.Component;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.world.Containers;
@@ -18,45 +20,72 @@ import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.block.state.StateDefinition;
 import net.minecraft.world.level.block.state.properties.BlockStateProperties;
 import net.minecraft.world.level.block.state.properties.DirectionProperty;
+import net.minecraft.world.level.block.state.properties.BooleanProperty;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.entity.LivingEntity;
+import org.jetbrains.annotations.Nullable;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.phys.BlockHitResult;
 
 public final class WritingDeskBlock extends BaseEntityBlock {
     public static final MapCodec<WritingDeskBlock> CODEC = simpleCodec(WritingDeskBlock::new);
     public static final DirectionProperty FACING = BlockStateProperties.HORIZONTAL_FACING;
+    public static final BooleanProperty EXTENSION = BooleanProperty.create("extension");
 
     public WritingDeskBlock(Properties properties) {
         super(properties);
-        registerDefaultState(stateDefinition.any().setValue(FACING, net.minecraft.core.Direction.NORTH));
+        registerDefaultState(stateDefinition.any().setValue(FACING, Direction.NORTH).setValue(EXTENSION, false));
     }
 
     @Override public MapCodec<? extends BaseEntityBlock> codec() { return CODEC; }
     @Override protected void createBlockStateDefinition(StateDefinition.Builder<net.minecraft.world.level.block.Block, BlockState> builder) {
-        builder.add(FACING);
+        builder.add(FACING, EXTENSION);
     }
     @Override public BlockState getStateForPlacement(BlockPlaceContext context) {
-        return defaultBlockState().setValue(FACING, context.getHorizontalDirection().getOpposite());
+        Direction facing = context.getHorizontalDirection().getOpposite();
+        BlockPos extension = context.getClickedPos().relative(facing.getClockWise());
+        return context.getLevel().getBlockState(extension).canBeReplaced(context)
+                ? defaultBlockState().setValue(FACING, facing) : null;
+    }
+    @Override public void setPlacedBy(Level level, BlockPos pos, BlockState state,
+                                      @Nullable LivingEntity placer, ItemStack stack) {
+        super.setPlacedBy(level, pos, state, placer, stack);
+        level.setBlock(pos.relative(state.getValue(FACING).getClockWise()),
+                state.setValue(EXTENSION, true), 3);
     }
     @Override protected RenderShape getRenderShape(BlockState state) { return RenderShape.MODEL; }
     @Override public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
-        return new WritingDeskBlockEntity(pos, state);
+        return state.getValue(EXTENSION) ? null : new WritingDeskBlockEntity(pos, state);
     }
     @Override protected InteractionResult useWithoutItem(BlockState state, Level level, BlockPos pos,
                                                           Player player, BlockHitResult hit) {
+        BlockPos controller = state.getValue(EXTENSION)
+                ? pos.relative(state.getValue(FACING).getCounterClockWise()) : pos;
         if (!level.isClientSide && player instanceof ServerPlayer serverPlayer
-                && level.getBlockEntity(pos) instanceof WritingDeskBlockEntity desk) {
+                && level.getBlockEntity(controller) instanceof WritingDeskBlockEntity desk) {
             serverPlayer.openMenu(new SimpleMenuProvider(
                     (id, inventory, ignored) -> new WritingDeskMenu(id, inventory, desk),
                     Component.translatable("container.rivencraft.writing_desk")),
-                    buffer -> buffer.writeBlockPos(pos));
+                    buffer -> {
+                        buffer.writeBlockPos(controller);
+                        WritingDeskCatalog.write(buffer, WritingDeskCatalog.available(desk));
+                    });
         }
         return InteractionResult.sidedSuccess(level.isClientSide);
     }
     @Override protected void onRemove(BlockState state, Level level, BlockPos pos, BlockState replacement, boolean moving) {
-        if (!state.is(replacement.getBlock()) && !level.isClientSide
+        if (!state.is(replacement.getBlock())) {
-                && level.getBlockEntity(pos) instanceof WritingDeskBlockEntity desk) {
+            if (!level.isClientSide && !state.getValue(EXTENSION)
-            Containers.dropContents(level, pos, desk);
+                    && level.getBlockEntity(pos) instanceof WritingDeskBlockEntity desk) {
-            level.updateNeighbourForOutputSignal(pos, this);
+                Containers.dropContents(level, pos, desk);
+                level.updateNeighbourForOutputSignal(pos, this);
+            }
+            BlockPos other = pos.relative(state.getValue(FACING).getClockWise(),
+                    state.getValue(EXTENSION) ? -1 : 1);
+            BlockState otherState = level.getBlockState(other);
+            if (otherState.is(this) && otherState.getValue(EXTENSION) != state.getValue(EXTENSION)) {
+                level.setBlock(other, net.minecraft.world.level.block.Blocks.AIR.defaultBlockState(), 35);
+            }
         }
         super.onRemove(state, level, pos, replacement, moving);
     }

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

@@ -0,0 +1,335 @@
+package net.dnorberg.rivencraft.block.entity;
+
+import java.util.ArrayList;
+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;
+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;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ClientGamePacketListener;
+import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket;
+import net.minecraft.world.Container;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.server.level.ServerLevel;
+
+/** Persistent inputs for a binder; the assembled output is never stored here. */
+public final class BookBinderBlockEntity extends BlockEntity implements Container {
+    public static final int COVER = 0;
+    public static final int LINK_PANEL = 1;
+    public static final int NOTEBOOK = 2;
+    public static final int FIRST_PAGE = 3;
+    public static final int PAGE_COUNT = NotebookContents.MAX_PAGES;
+    public static final int SIZE = FIRST_PAGE + PAGE_COUNT;
+    public static final int MAX_TITLE_LENGTH = 32;
+
+    private NonNullList<ItemStack> items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+    private String title = "";
+    private UUID pendingAgeId;
+
+    public BookBinderBlockEntity(BlockPos pos, BlockState state) {
+        super(ModBlockEntities.BOOK_BINDER.get(), pos, state);
+    }
+
+    public String title() { return title; }
+
+    public void setTitle(String value) {
+        String normalized = value == null ? "" : value.strip();
+        if (normalized.length() > MAX_TITLE_LENGTH) normalized = normalized.substring(0, MAX_TITLE_LENGTH);
+        if (!normalized.equals(title)) {
+            title = normalized;
+            setChanged();
+        }
+    }
+
+    public static boolean validCover(ItemStack stack) {
+        return stack.is(Items.LEATHER) || stack.is(ModItems.NOTEBOOK.get())
+                && stack.getOrDefault(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pageCount() == 0;
+    }
+
+    private static boolean validPage(ItemStack stack) {
+        return stack.is(ModItems.PAGE.get()) && PageItem.content(stack).kind() != PageContent.Kind.LINK_PANEL;
+    }
+
+    @Override public int getContainerSize() { return SIZE; }
+    @Override public boolean isEmpty() { return items.stream().allMatch(ItemStack::isEmpty); }
+    @Override public ItemStack getItem(int slot) { return items.get(slot); }
+    @Override public ItemStack removeItem(int slot, int amount) {
+        ItemStack removed = ContainerHelper.removeItem(items, slot, amount);
+        if (!removed.isEmpty()) setChanged();
+        return removed;
+    }
+    @Override public ItemStack removeItemNoUpdate(int slot) { return ContainerHelper.takeItem(items, slot); }
+    @Override public void setItem(int slot, ItemStack stack) {
+        items.set(slot, stack);
+        if (stack.getCount() > getMaxStackSize()) stack.setCount(getMaxStackSize());
+        setChanged();
+    }
+    @Override public boolean canPlaceItem(int slot, ItemStack stack) {
+        return switch (slot) {
+            case COVER -> validCover(stack);
+            case LINK_PANEL -> stack.is(ModItems.PAGE.get())
+                    && PageItem.content(stack).kind() == PageContent.Kind.LINK_PANEL;
+            case NOTEBOOK -> stack.is(ModItems.NOTEBOOK.get());
+            default -> slot >= FIRST_PAGE && slot < SIZE && validPage(stack);
+        };
+    }
+    @Override public boolean stillValid(Player player) {
+        return level != null && level.isLoaded(worldPosition) && level.getBlockEntity(worldPosition) == this
+                && player.distanceToSqr(worldPosition.getX() + 0.5, worldPosition.getY() + 0.5,
+                        worldPosition.getZ() + 0.5) <= 64.0;
+    }
+
+    /** All checks precede any mutation so a failed assembly leaves every input intact. */
+    public boolean canAssemble() {
+        if (title.isBlank() || !validCover(items.get(COVER))
+                || !canPlaceItem(LINK_PANEL, items.get(LINK_PANEL))
+                || items.get(LINK_PANEL).getCount() != 1) return false;
+        for (int slot = FIRST_PAGE; slot < SIZE; slot++) {
+            ItemStack page = items.get(slot);
+            if (!page.isEmpty() && (!validPage(page) || !PageItem.isUsableWriting(page) || page.getCount() != 1
+                    || PageItem.content(page).kind() == PageContent.Kind.BLANK)) return false;
+        }
+        OrderedWriting writing = currentWriting();
+        if (!writingGrammar().canCreate()) return false;
+        try {
+            if (level instanceof ServerLevel serverLevel) {
+                AgeRegistrySavedData.validateNewWriting(serverLevel, title, writing);
+            } else {
+                AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD,
+                        net.dnorberg.rivencraft.book.AgeTraits.select(0L), level.registryAccess());
+            }
+            return true;
+        } catch (IllegalArgumentException exception) {
+            return false;
+        }
+    }
+
+    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() {
+        if (!canAssemble()) return ItemStack.EMPTY;
+        if (pendingAgeId == null) {
+            pendingAgeId = UUID.randomUUID();
+            setChanged();
+        }
+        ItemStack book = new ItemStack(ModItems.DESCRIPTIVE_BOOK.get());
+        book.set(ModDataComponents.AGE_REFERENCE.get(), new AgeReference(pendingAgeId, title));
+        book.set(ModDataComponents.BOOK_WRITING.get(), currentWriting());
+        book.set(DataComponents.CUSTOM_NAME, Component.literal(title));
+        return book;
+    }
+
+    /** Called once, on the server, after the output can be delivered. */
+    public boolean consumeAssembly() {
+        if (!canAssemble()) return false;
+        if (pendingAgeId == null) pendingAgeId = UUID.randomUUID();
+        if (level instanceof ServerLevel serverLevel)
+            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);
+        if (items.get(LINK_PANEL).isEmpty()) items.set(LINK_PANEL, ItemStack.EMPTY);
+        for (int slot = FIRST_PAGE; slot < SIZE; slot++) items.set(slot, ItemStack.EMPTY);
+        title = "";
+        pendingAgeId = null;
+        setChanged();
+        return true;
+    }
+
+    public int nextPageIndex() {
+        for (int index = PAGE_COUNT - 1; index >= 0; index--) {
+            if (!items.get(FIRST_PAGE + index).isEmpty()) return index + 1;
+        }
+        return 0;
+    }
+
+    /** Insert before a displayed page, shifting later pages as Legacy's strip does. */
+    public boolean insertPage(int index, ItemStack page) {
+        int end = nextPageIndex();
+        if (index < 0 || index > end || end >= PAGE_COUNT || page.getCount() != 1
+                || !validPage(page)) return false;
+        for (int current = end; current > index; current--)
+            items.set(FIRST_PAGE + current, items.get(FIRST_PAGE + current - 1));
+        items.set(FIRST_PAGE + index, page.copy());
+        setChanged();
+        return true;
+    }
+
+    /** Take a page back to the cursor, closing the gap in the displayed order. */
+    public ItemStack takePage(int index) {
+        int end = nextPageIndex();
+        if (index < 0 || index >= end || items.get(FIRST_PAGE + index).isEmpty()) return ItemStack.EMPTY;
+        ItemStack removed = items.get(FIRST_PAGE + index);
+        for (int current = index; current < end - 1; current++)
+            items.set(FIRST_PAGE + current, items.get(FIRST_PAGE + current + 1));
+        items.set(FIRST_PAGE + end - 1, ItemStack.EMPTY);
+        setChanged();
+        return removed;
+    }
+
+    /** Move every Notebook page as one transaction, leaving its empty cover in the input slot. */
+    public boolean importNotebook() {
+        ItemStack notebook = items.get(NOTEBOOK);
+        ItemStack emptied = importNotebookFromStack(notebook, nextPageIndex());
+        if (emptied.isEmpty()) return false;
+        items.set(NOTEBOOK, emptied);
+        setChanged();
+        return true;
+    }
+
+    /** Import a Notebook from either its stored slot or the player's cursor. */
+    public ItemStack importNotebookFromStack(ItemStack notebook, int index) {
+        if (!notebook.is(ModItems.NOTEBOOK.get()) || notebook.getCount() != 1) return ItemStack.EMPTY;
+        List<ItemStack> pages = notebook.getOrDefault(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages();
+        if (pages.isEmpty()) return ItemStack.EMPTY;
+        int end = nextPageIndex();
+        if (index < 0 || index > end) return ItemStack.EMPTY;
+        ItemStack linkPanel = ItemStack.EMPTY;
+        List<ItemStack> writing = new ArrayList<>();
+        for (ItemStack page : pages) {
+            if (page.isEmpty()) continue;
+            if (!page.is(ModItems.PAGE.get()) || page.getCount() != 1) return ItemStack.EMPTY;
+            if (PageItem.content(page).kind() == PageContent.Kind.LINK_PANEL) {
+                if (!linkPanel.isEmpty() || !items.get(LINK_PANEL).isEmpty()) return ItemStack.EMPTY;
+                linkPanel = page;
+            } else if (validPage(page)) writing.add(page);
+            else return ItemStack.EMPTY;
+        }
+        if (end + writing.size() > PAGE_COUNT || writing.isEmpty() && linkPanel.isEmpty()) return ItemStack.EMPTY;
+        if (!linkPanel.isEmpty()) items.set(LINK_PANEL, linkPanel.copy());
+        for (int current = end - 1; current >= index; current--)
+            items.set(FIRST_PAGE + current + writing.size(), items.get(FIRST_PAGE + current));
+        for (ItemStack page : writing) items.set(FIRST_PAGE + index++, page.copy());
+        ItemStack emptyNotebook = notebook.copy();
+        emptyNotebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY);
+        setChanged();
+        return emptyNotebook;
+    }
+
+    @Override public void clearContent() {
+        items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+        title = "";
+        pendingAgeId = null;
+        setChanged();
+    }
+    @Override protected void loadAdditional(CompoundTag tag, HolderLookup.Provider registries) {
+        super.loadAdditional(tag, registries);
+        items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+        ContainerHelper.loadAllItems(tag, items, registries);
+        title = tag.getString("Title");
+        pendingAgeId = tag.hasUUID("PendingAgeId") ? tag.getUUID("PendingAgeId") : null;
+    }
+    @Override protected void saveAdditional(CompoundTag tag, HolderLookup.Provider registries) {
+        super.saveAdditional(tag, registries);
+        ContainerHelper.saveAllItems(tag, items, registries);
+        tag.putString("Title", title);
+        if (pendingAgeId != null) tag.putUUID("PendingAgeId", pendingAgeId);
+    }
+    @Override public Packet<ClientGamePacketListener> getUpdatePacket() {
+        return ClientboundBlockEntityDataPacket.create(this);
+    }
+    @Override public CompoundTag getUpdateTag(HolderLookup.Provider registries) {
+        return saveWithoutMetadata(registries);
+    }
+    @Override public void setChanged() {
+        super.setChanged();
+        if (level != null && !level.isClientSide) {
+            level.sendBlockUpdated(worldPosition, getBlockState(), getBlockState(), 2);
+        }
+    }
+}

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

@@ -0,0 +1,121 @@
+package net.dnorberg.rivencraft.block.entity;
+
+import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.writing.InkVialExchange;
+import net.dnorberg.rivencraft.registry.ModBlockEntities;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.WritingInkService;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.NonNullList;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.world.Container;
+import net.minecraft.world.ContainerHelper;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+
+/** Baseline Link Panel mixer. Modifier ingredients belong to the symbol/ink-effects milestone. */
+public final class InkMixerBlockEntity extends BlockEntity implements Container {
+    public static final int INK = 0;
+    public static final int PAPER = 1;
+    public static final int BOTTLES = 2;
+    public static final int SIZE = 3;
+
+    private NonNullList<ItemStack> items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+    private int inkRemaining;
+
+    public InkMixerBlockEntity(BlockPos pos, BlockState state) {
+        super(ModBlockEntities.INK_MIXER.get(), pos, state);
+    }
+
+    public int inkRemaining() { return inkRemaining; }
+
+    @Override public int getContainerSize() { return SIZE; }
+    @Override public boolean isEmpty() { return items.stream().allMatch(ItemStack::isEmpty); }
+    @Override public ItemStack getItem(int slot) { return items.get(slot); }
+    @Override public ItemStack removeItem(int slot, int amount) {
+        ItemStack removed = ContainerHelper.removeItem(items, slot, amount);
+        if (!removed.isEmpty()) {
+            setChanged();
+            if (slot == BOTTLES) refillEmptyBasin();
+        }
+        return removed;
+    }
+    @Override public ItemStack removeItemNoUpdate(int slot) { return ContainerHelper.takeItem(items, slot); }
+    @Override public void setItem(int slot, ItemStack stack) {
+        items.set(slot, stack);
+        if (stack.getCount() > getMaxStackSize()) stack.setCount(getMaxStackSize());
+        setChanged();
+        if (slot == INK || slot == BOTTLES) refillEmptyBasin();
+    }
+    @Override public boolean canPlaceItem(int slot, ItemStack stack) {
+        return switch (slot) {
+            case INK -> stack.is(ModItems.INK_VIAL.get());
+            case PAPER -> stack.is(Items.PAPER);
+            default -> false;
+        };
+    }
+    @Override public boolean stillValid(Player player) {
+        return level != null && level.isLoaded(worldPosition) && level.getBlockEntity(worldPosition) == this
+                && player.distanceToSqr(worldPosition.getX() + 0.5, worldPosition.getY() + 0.5,
+                        worldPosition.getZ() + 0.5) <= 64.0;
+    }
+
+    /** No server tick: refill only when ink, bottle space, or consumption changes. */
+    private void refillEmptyBasin() {
+        if (level != null && !level.isClientSide && inkRemaining == 0) {
+            int addedInk = InkVialExchange.exchange(items, INK, BOTTLES);
+            if (addedInk > 0) {
+                inkRemaining = addedInk;
+                setChanged();
+            }
+        }
+    }
+
+    public boolean canCreateLinkPanel() {
+        if (!items.get(PAPER).is(Items.PAPER)) return false;
+        int cost = WritingInkService.linkPanelCost();
+        return InkVialExchange.canPay(items, INK, BOTTLES, inkRemaining, cost);
+    }
+
+    /** Commit inputs only when a virtual output is actually taken. */
+    public boolean consumeLinkPanelMaterials() {
+        if (!canCreateLinkPanel()) return false;
+        int cost = WritingInkService.linkPanelCost();
+        if (inkRemaining < cost) {
+            inkRemaining += InkVialExchange.exchange(items, INK, BOTTLES);
+        }
+        inkRemaining -= cost;
+        items.get(PAPER).shrink(1);
+        if (items.get(PAPER).isEmpty()) items.set(PAPER, ItemStack.EMPTY);
+        setChanged();
+        if (inkRemaining == 0) refillEmptyBasin();
+        return true;
+    }
+
+    @Override public void setLevel(Level level) {
+        super.setLevel(level);
+        refillEmptyBasin();
+    }
+    @Override public void clearContent() {
+        items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+        inkRemaining = 0;
+        setChanged();
+    }
+    @Override protected void loadAdditional(CompoundTag tag, HolderLookup.Provider registries) {
+        super.loadAdditional(tag, registries);
+        items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+        ContainerHelper.loadAllItems(tag, items, registries);
+        inkRemaining = Math.clamp(tag.getInt("InkRemaining"), 0, InkVialItem.CAPACITY);
+        refillEmptyBasin();
+    }
+    @Override protected void saveAdditional(CompoundTag tag, HolderLookup.Provider registries) {
+        super.saveAdditional(tag, registries);
+        ContainerHelper.saveAllItems(tag, items, registries);
+        tag.putInt("InkRemaining", inkRemaining);
+    }
+}

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

@@ -1,34 +1,54 @@
 package net.dnorberg.rivencraft.block.entity;
 
+import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.writing.InkVialExchange;
+import net.dnorberg.rivencraft.writing.WritingInkService;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.HolderLookup;
 import net.minecraft.core.NonNullList;
 import net.minecraft.nbt.CompoundTag;
+import net.minecraft.network.protocol.Packet;
+import net.minecraft.network.protocol.game.ClientGamePacketListener;
+import net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket;
 import net.minecraft.world.Container;
 import net.minecraft.world.ContainerHelper;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.Level;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
 
-/** The four Legacy-like collection tabs and four work slots are owned by the block, not its viewers. */
+/** Collection tabs, paper, ink vials and empty-vial return are owned by the block. */
 public final class WritingDeskBlockEntity extends BlockEntity implements Container {
-    public static final int COLLECTIONS = 4;
+    public static final int COLLECTIONS = 88;
-    public static final int INK = 4;
+    public static final int INK = COLLECTIONS;
-    public static final int SOURCE = 5;
+    public static final int RETURN = INK + 1;
-    public static final int PAPER = 6;
+    public static final int PAPER = INK + 2;
-    public static final int OUTPUT = 7;
+    /** Unused by new desks; retained so old saves cannot silently lose slot contents. */
-    public static final int SIZE = 8;
+    public static final int LEGACY_OUTPUT = INK + 3;
+    public static final int SIZE = INK + 4;
     private NonNullList<ItemStack> items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
     private int activeCollection;
+    private int inkRemaining;
+    private ItemStack displayPage = ItemStack.EMPTY;
 
     public WritingDeskBlockEntity(BlockPos pos, BlockState state) {
         super(ModBlockEntities.WRITING_DESK.get(), pos, state);
     }
 
     public int activeCollection() { return activeCollection; }
+    public int inkRemaining() { return inkRemaining; }
+    public ItemStack displayPage() { return displayPage; }
+    public void setDisplayPage(ItemStack page) {
+        ItemStack next = page.isEmpty() ? ItemStack.EMPTY : page.copyWithCount(1);
+        if (!ItemStack.matches(displayPage, next)) {
+            displayPage = next;
+            setChanged();
+        }
+    }
     public void setActiveCollection(int index) {
         if (index >= 0 && index < COLLECTIONS && activeCollection != index) {
             activeCollection = index;
@@ -41,14 +61,20 @@ public final class WritingDeskBlockEntity extends BlockEntity implements Contain
     @Override public ItemStack getItem(int slot) { return items.get(slot); }
     @Override public ItemStack removeItem(int slot, int amount) {
         ItemStack removed = ContainerHelper.removeItem(items, slot, amount);
-        if (!removed.isEmpty()) setChanged();
+        if (!removed.isEmpty()) {
+            if (slot < COLLECTIONS) displayPage = ItemStack.EMPTY;
+            setChanged();
+            if (slot == RETURN) refillEmptyInkBar();
+        }
         return removed;
     }
     @Override public ItemStack removeItemNoUpdate(int slot) { return ContainerHelper.takeItem(items, slot); }
     @Override public void setItem(int slot, ItemStack stack) {
         items.set(slot, stack);
         if (stack.getCount() > getMaxStackSize()) stack.setCount(getMaxStackSize());
+        if (slot < COLLECTIONS) displayPage = ItemStack.EMPTY;
         setChanged();
+        if (slot == INK || slot == RETURN) refillEmptyInkBar();
     }
     @Override public boolean stillValid(Player player) {
         return level != null && level.isLoaded(worldPosition)
@@ -60,26 +86,91 @@ public final class WritingDeskBlockEntity extends BlockEntity implements Contain
         if (slot < COLLECTIONS) return stack.is(ModItems.NOTEBOOK.get()) || stack.is(ModItems.PAGE.get());
         return switch (slot) {
             case INK -> stack.is(ModItems.INK_VIAL.get());
-            case SOURCE -> stack.is(ModItems.PAGE.get()) || stack.is(ModItems.NOTEBOOK.get());
+            case RETURN -> false;
-            case PAPER -> stack.is(ModItems.PAGE.get());
+            case PAPER -> stack.is(Items.PAPER);
-            case OUTPUT -> false;
+            case LEGACY_OUTPUT -> false;
             default -> false;
         };
     }
+
+    /** Consume one vial only when the empty meter can return its glass bottle. */
+    private void refillEmptyInkBar() {
+        if (level != null && !level.isClientSide && inkRemaining == 0) {
+            int addedInk = InkVialExchange.exchange(items, INK, RETURN);
+            if (addedInk > 0) {
+                inkRemaining = addedInk;
+                setChanged();
+            }
+        }
+    }
+
+    /** The output is virtual; inputs are committed only after a result can be given to a player. */
+    public boolean canConsumeCopyMaterials() {
+        ItemStack paper = items.get(PAPER);
+        if (!canPlaceItem(PAPER, paper) || paper.isEmpty()) return false;
+        int cost = WritingInkService.symbolCopyCost();
+        return InkVialExchange.canPay(items, INK, RETURN, inkRemaining, cost);
+    }
+
+    public boolean consumeCopyMaterials() {
+        if (!canConsumeCopyMaterials()) return false;
+        int cost = WritingInkService.symbolCopyCost();
+        if (inkRemaining < cost) {
+            inkRemaining += InkVialExchange.exchange(items, INK, RETURN);
+        }
+        inkRemaining -= cost;
+        removeItem(PAPER, 1);
+        setChanged();
+        if (inkRemaining == 0) refillEmptyInkBar();
+        return true;
+    }
+    @Override public void setLevel(Level level) {
+        super.setLevel(level);
+        refillEmptyInkBar();
+    }
     @Override public void clearContent() {
-        items.clear();
         items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
+        inkRemaining = 0;
+        displayPage = ItemStack.EMPTY;
         setChanged();
     }
     @Override protected void loadAdditional(CompoundTag tag, HolderLookup.Provider registries) {
         super.loadAdditional(tag, registries);
         items = NonNullList.withSize(SIZE, ItemStack.EMPTY);
         ContainerHelper.loadAllItems(tag, items, registries);
+        // Pre-88-tab desks stored materials in slots 4..7. Move them once;
+        // never interpret those stacks as newly added collection tabs.
+        if (tag.getInt("InventoryVersion") < 1) {
+            for (int i = 0; i < 4; i++) {
+                items.set(INK + i, items.get(4 + i));
+                items.set(4 + i, ItemStack.EMPTY);
+            }
+        }
         activeCollection = Math.clamp(tag.getInt("ActiveCollection"), 0, COLLECTIONS - 1);
+        inkRemaining = Math.clamp(tag.getInt("InkRemaining"), 0, InkVialItem.CAPACITY);
+        displayPage = tag.contains("DisplayPage", CompoundTag.TAG_COMPOUND)
+                ? ItemStack.parse(registries, tag.getCompound("DisplayPage")).orElse(ItemStack.EMPTY)
+                : ItemStack.EMPTY;
+        refillEmptyInkBar();
     }
     @Override protected void saveAdditional(CompoundTag tag, HolderLookup.Provider registries) {
         super.saveAdditional(tag, registries);
         ContainerHelper.saveAllItems(tag, items, registries);
+        tag.putInt("InventoryVersion", 1);
         tag.putInt("ActiveCollection", activeCollection);
+        tag.putInt("InkRemaining", inkRemaining);
+        if (!displayPage.isEmpty()) tag.put("DisplayPage", displayPage.save(registries));
+    }
+    @Override public Packet<ClientGamePacketListener> getUpdatePacket() {
+        return ClientboundBlockEntityDataPacket.create(this);
+    }
+    @Override public CompoundTag getUpdateTag(HolderLookup.Provider registries) {
+        return saveWithoutMetadata(registries);
+    }
+    @Override public void setChanged() {
+        super.setChanged();
+        if (level != null && !level.isClientSide) {
+            level.sendBlockUpdated(worldPosition, getBlockState(), getBlockState(), 2);
+        }
     }
 }

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,
+            AgeRuntimeProfile profile
-            ResourceKey<net.minecraft.world.level.biome.MultiNoiseBiomeSourceParameterList> biomePreset
     ) {
-        List<net.minecraft.core.Holder.Reference<Biome>> biomes = server.registryAccess()
+        if (age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION) {
-                .lookupOrThrow(Registries.BIOME)
+            return legacyBiomeSource(server, age, profile);
-                .listElements()
-                .sorted(Comparator.comparing(holder -> holder.key().location().toString()))
-                .toList();
-        if (age.traits().biomeDistribution() == AgeTraits.BiomeDistribution.SINGLE && !biomes.isEmpty()) {
-            int index = Math.floorMod(Long.hashCode(age.seed() ^ 0x53494E474C454249L), biomes.size());
-            return new FixedBiomeSource(biomes.get(index));
         }
-        AgeTraits.BiomeDistribution distribution = age.traits().biomeDistribution();
+        AgeBiomeSelection selection = age.plan() != null && age.plan().biomeSelection() != null
-        if ((distribution == AgeTraits.BiomeDistribution.TILED
+                ? age.plan().biomeSelection()
-                || distribution == AgeTraits.BiomeDistribution.GRID) && biomes.size() >= 2) {
+                : AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(OrderedWriting.EMPTY),
-            List<net.minecraft.core.Holder.Reference<Biome>> selected = new java.util.ArrayList<>(biomes);
+                        age.traits(), profile, age.seed(), server.registryAccess());
-            long salt = distribution == AgeTraits.BiomeDistribution.GRID
+        var registry = server.registryAccess().lookupOrThrow(Registries.BIOME);
-                    ? 0x4752494442494F4DL
+        List<Holder<Biome>> biomes = new ArrayList<>();
-                    : 0x54494C454442494FL;
+        List<ResourceLocation> fallbacks = AgeBiomeSelection.eligible(server.registryAccess(), profile);
-            Collections.shuffle(selected, new java.util.Random(age.seed() ^ salt));
+        Set<ResourceLocation> present = new LinkedHashSet<>();
-            return new CheckerboardColumnBiomeSource(
+        for (ResourceLocation id : selection.biomes()) {
-                    HolderSet.direct(List.of(selected.get(0), selected.get(1))),
+            var holder = registry.get(ResourceKey.create(Registries.BIOME, id));
-                    distribution == AgeTraits.BiomeDistribution.GRID
+            if (holder.isEmpty()) {
-                            ? GRID_BIOME_SCALE
+                ResourceLocation fallback = fallbacks.stream().filter(candidate -> !present.contains(candidate))
-                            : TILED_BIOME_SCALE
+                        .findFirst().orElse(fallbacks.getFirst());
-            );
+                Rivencraft.LOGGER.warn("Age {} biome {} is unavailable; using {} for this load. Restore its data pack to recover the authored biome.",
+                        age.id(), id, fallback);
+                holder = registry.get(ResourceKey.create(Registries.BIOME, fallback));
+            }
+            Holder.Reference<Biome> resolved = holder.orElseThrow();
+            biomes.add(resolved);
+            present.add(resolved.key().location());
+        }
+        for (ResourceLocation fallback : fallbacks) {
+            if (present.size() >= AgeBiomeSelection.minimum(selection.distribution())) break;
+            if (present.add(fallback)) biomes.add(registry.getOrThrow(
+                    ResourceKey.create(Registries.BIOME, fallback)));
+        }
+        AgeTraits.BiomeDistribution distribution = selection.distribution();
+        if (distribution == AgeTraits.BiomeDistribution.NATIVE && !AgeBiomeSelection.isCave(profile)
+                && profile.terrain() == AgeRuntimeProfile.Terrain.NOISE) {
+            var parameters = server.registryAccess()
+                    .lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST);
+            var preset = ResourceKey.create(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST, profile.biomePreset());
+            return MultiNoiseBiomeSource.createFromPreset(parameters.getOrThrow(preset));
+        }
+        if (distribution == AgeTraits.BiomeDistribution.SINGLE || biomes.size() == 1) {
+            return new FixedBiomeSource(biomes.getFirst());
+        }
+        if (distribution == AgeTraits.BiomeDistribution.TILED || distribution == AgeTraits.BiomeDistribution.GRID) {
+            return new CheckerboardColumnBiomeSource(HolderSet.direct(biomes),
+                    distribution == AgeTraits.BiomeDistribution.GRID ? GRID_BIOME_SCALE : TILED_BIOME_SCALE);
         }
         int scaledBiomeScale = switch (distribution) {
+            case NATIVE, TINY -> 0;
+            case SMALL -> 1;
+            case MEDIUM -> 2;
+            case LARGE -> 3;
+            case HUGE -> 4;
+            default -> -1;
+        };
+        if (biomes.size() >= 2) {
+            return new ScaledBiomeSource(HolderSet.direct(biomes), age.seed(), scaledBiomeScale);
+        }
+        return new CheckerboardColumnBiomeSource(HolderSet.direct(biomes), GRID_BIOME_SCALE);
+    }
+
+    /** Preserve the exact selection algorithm for Ages created before biome pools were frozen. */
+    private static BiomeSource legacyBiomeSource(MinecraftServer server, AgeDefinition age, AgeRuntimeProfile profile) {
+        var registry = server.registryAccess().lookupOrThrow(Registries.BIOME);
+        List<Holder.Reference<Biome>> all = registry.listElements()
+                .sorted(Comparator.comparing(holder -> holder.key().location().toString())).toList();
+        AgeTraits.BiomeDistribution distribution = age.traits().biomeDistribution();
+        if (distribution == AgeTraits.BiomeDistribution.SINGLE && !all.isEmpty()) {
+            int index = Math.floorMod(Long.hashCode(age.seed() ^ 0x53494E474C454249L), all.size());
+            return new FixedBiomeSource(all.get(index));
+        }
+        if ((distribution == AgeTraits.BiomeDistribution.TILED || distribution == AgeTraits.BiomeDistribution.GRID)
+                && all.size() >= 2) {
+            List<Holder.Reference<Biome>> selected = new ArrayList<>(all);
+            long salt = distribution == AgeTraits.BiomeDistribution.GRID
+                    ? 0x4752494442494F4DL : 0x54494C454442494FL;
+            Collections.shuffle(selected, new Random(age.seed() ^ salt));
+            return new CheckerboardColumnBiomeSource(HolderSet.direct(List.of(selected.get(0), selected.get(1))),
+                    distribution == AgeTraits.BiomeDistribution.GRID ? GRID_BIOME_SCALE : TILED_BIOME_SCALE);
+        }
+        int scale = switch (distribution) {
             case TINY -> 0;
             case SMALL -> 1;
             case MEDIUM -> 2;
@@ -368,28 +449,25 @@ public final class AgeDimensionService {
             case HUGE -> 4;
             default -> -1;
         };
-        if (scaledBiomeScale >= 0 && biomes.size() >= 3) {
+        if (scale >= 0 && all.size() >= 3) {
-            List<net.minecraft.core.Holder.Reference<Biome>> selected = new java.util.ArrayList<>(biomes);
+            List<Holder.Reference<Biome>> selected = new ArrayList<>(all);
             long salt = distribution == AgeTraits.BiomeDistribution.TINY
-                    ? 0x54494E5942494F4DL
+                    ? 0x54494E5942494F4DL : 0x5343414C45444249L;
-                    : 0x5343414C45444249L;
+            Collections.shuffle(selected, new Random(age.seed() ^ salt));
-            Collections.shuffle(selected, new java.util.Random(age.seed() ^ salt));
+            return new ScaledBiomeSource(HolderSet.direct(List.of(selected.get(0), selected.get(1), selected.get(2))),
-            return new ScaledBiomeSource(
+                    age.seed(), scale);
-                    HolderSet.direct(List.of(selected.get(0), selected.get(1), selected.get(2))),
-                    age.seed(),
-                    scaledBiomeScale
-            );
         }
-        return MultiNoiseBiomeSource.createFromPreset(
+        var parameters = server.registryAccess().lookupOrThrow(Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST);
-                biomeParameters.getOrThrow(biomePreset));
+        return MultiNoiseBiomeSource.createFromPreset(parameters.getOrThrow(ResourceKey.create(
+                Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST, profile.biomePreset())));
     }
 
     private static DimensionType createDimensionType(MinecraftServer server, AgeDefinition age) {
-        AgeRuntimeProfile profile = 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) {
+    /** Recheck frozen plans before loading: a removed registry entry must not crash or silently alter an Age. */
-            requireRegistryEntry(registries, Registries.NOISE_SETTINGS, noise, id, "noise_settings");
+    public static void validateReferences(RegistryAccess registries, ResourceLocation id, AgeRuntimeProfile profile) {
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.NOISE) {
+            requireRegistryEntry(registries, Registries.NOISE_SETTINGS, profile.noiseSettings(), id, "noise_settings");
             requireRegistryEntry(registries, Registries.MULTI_NOISE_BIOME_SOURCE_PARAMETER_LIST,
-                    biome, id, "biome_preset");
+                    profile.biomePreset(), id, "biome_preset");
         }
-        requireRegistryEntry(registries, Registries.DIMENSION_TYPE, dimension, id, "dimension_type");
+        requireRegistryEntry(registries, Registries.DIMENSION_TYPE, profile.dimensionType(), id, "dimension_type");
-        return new AgeRuntimeProfile(schemaVersion, terrain, noise, biome, dimension);
     }
 
     private static String requiredString(JsonObject object, String name) {

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

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

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

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

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

@@ -13,8 +13,14 @@ import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent;
 import net.neoforged.neoforge.common.NeoForge;
 import net.neoforged.neoforge.client.event.EntityRenderersEvent;
 import net.neoforged.neoforge.client.event.RegisterMenuScreensEvent;
+import net.neoforged.neoforge.client.event.RegisterClientReloadListenersEvent;
+import net.neoforged.neoforge.client.extensions.common.IClientItemExtensions;
+import net.neoforged.neoforge.client.extensions.common.RegisterClientExtensionsEvent;
+import net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer;
 import net.dnorberg.rivencraft.client.screen.NotebookScreen;
 import net.dnorberg.rivencraft.client.screen.WritingDeskScreen;
+import net.dnorberg.rivencraft.client.screen.BookBinderScreen;
+import net.dnorberg.rivencraft.client.screen.InkMixerScreen;
 import net.dnorberg.rivencraft.registry.ModMenus;
 
 @EventBusSubscriber(modid = Rivencraft.MOD_ID, value = Dist.CLIENT)
@@ -25,12 +31,33 @@ public final class ClientEvents {
     @SubscribeEvent
     public static void registerRenderers(EntityRenderersEvent.RegisterRenderers event) {
         event.registerBlockEntityRenderer(ModBlockEntities.BOOK_STAND.get(), BookStandRenderer::new);
+        event.registerBlockEntityRenderer(ModBlockEntities.WRITING_DESK.get(), WritingDeskRenderer::new);
     }
 
     @SubscribeEvent
     public static void registerScreens(RegisterMenuScreensEvent event) {
         event.register(ModMenus.NOTEBOOK.get(), NotebookScreen::new);
         event.register(ModMenus.WRITING_DESK.get(), WritingDeskScreen::new);
+        event.register(ModMenus.BOOK_BINDER.get(), BookBinderScreen::new);
+        event.register(ModMenus.INK_MIXER.get(), InkMixerScreen::new);
+    }
+
+    @SubscribeEvent
+    public static void registerPageItemRenderer(RegisterClientExtensionsEvent event) {
+        event.registerItem(new IClientItemExtensions() {
+            private final SymbolPageItemRenderer renderer = new SymbolPageItemRenderer();
+
+            @Override
+            public BlockEntityWithoutLevelRenderer getCustomRenderer() {
+                return renderer;
+            }
+        }, ModItems.PAGE.get());
+    }
+
+    @SubscribeEvent
+    public static void registerPageTextureReload(RegisterClientReloadListenersEvent event) {
+        event.registerReloadListener((net.minecraft.server.packs.resources.ResourceManagerReloadListener)
+                manager -> SymbolPageTextures.clear());
     }
 
     @SubscribeEvent

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

@@ -0,0 +1,20 @@
+package net.dnorberg.rivencraft.client;
+
+import net.dnorberg.rivencraft.menu.WritingDeskMenu;
+import net.dnorberg.rivencraft.network.WritingDeskCatalogPayload;
+import net.minecraft.client.Minecraft;
+import net.neoforged.neoforge.network.handling.IPayloadContext;
+
+public final class ClientWritingDeskCatalog {
+    private ClientWritingDeskCatalog() {}
+
+    public static void handle(WritingDeskCatalogPayload payload, IPayloadContext context) {
+        context.enqueueWork(() -> {
+            var player = Minecraft.getInstance().player;
+            if (player != null && player.containerMenu instanceof WritingDeskMenu menu
+                    && menu.containerId == payload.containerId()) {
+                menu.setCatalog(payload.symbols());
+            }
+        });
+    }
+}

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

@@ -0,0 +1,47 @@
+package net.dnorberg.rivencraft.client;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.blaze3d.vertex.VertexConsumer;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+
+/** Flat page model whose symbol artwork is resolved from the stack at render time. */
+public final class SymbolPageItemRenderer extends BlockEntityWithoutLevelRenderer {
+    public SymbolPageItemRenderer() {
+        super(Minecraft.getInstance().getBlockEntityRenderDispatcher(), Minecraft.getInstance().getEntityModels());
+    }
+
+    @Override
+    public void renderByItem(ItemStack stack, ItemDisplayContext context, PoseStack pose,
+                             MultiBufferSource buffers, int light, int overlay) {
+        ResourceLocation texture = switch (PageItem.content(stack).kind()) {
+            case BLANK -> texture("page");
+            case LINK_PANEL -> texture("page_link_panel");
+            case UNRESOLVED_SYMBOL -> texture("page_unresolved");
+            case SYMBOL -> SymbolPageTextures.forItem(stack);
+        };
+        VertexConsumer vertices = buffers.getBuffer(RenderType.entityCutoutNoCull(texture));
+        var matrix = pose.last().pose();
+        vertex(vertices, matrix, 0, 0, 0, 1, light, overlay);
+        vertex(vertices, matrix, 1, 0, 1, 1, light, overlay);
+        vertex(vertices, matrix, 1, 1, 1, 0, light, overlay);
+        vertex(vertices, matrix, 0, 1, 0, 0, light, overlay);
+    }
+
+    private static void vertex(VertexConsumer vertices, org.joml.Matrix4f matrix,
+                               float x, float y, float u, float v, int light, int overlay) {
+        vertices.addVertex(matrix, x, y, 0.5F).setColor(255, 255, 255, 255)
+                .setUv(u, v).setOverlay(overlay).setLight(light).setNormal(0, 0, 1);
+    }
+
+    private static ResourceLocation texture(String name) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "textures/item/" + name + ".png");
+    }
+}

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

@@ -0,0 +1,240 @@
+package net.dnorberg.rivencraft.client;
+
+import com.mojang.blaze3d.platform.NativeImage;
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.LinkedHashMap;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Random;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
+import net.dnorberg.rivencraft.writing.SymbolPoems;
+import net.dnorberg.rivencraft.writing.SymbolNumerals;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.renderer.texture.DynamicTexture;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.packs.resources.ResourceManager;
+import net.minecraft.world.item.ItemStack;
+
+/** Client-only, bounded cache of Legacy-style page compositions; no per-symbol PNGs. */
+public final class SymbolPageTextures {
+    private static final int SIZE = 128;
+    private static final int GLYPH = 51;
+    // A 16 px item icon displays a 13 px symbol: three pixels narrower overall.
+    private static final int ITEM_SYMBOL_SIZE = 13;
+    private static final int ICON_SIZE = 16;
+    private static final int CACHE_LIMIT = 256;
+    private static final ResourceLocation BASE = texture("item/page");
+    private static final ResourceLocation COMPONENTS = texture("gui/symbolcomponents");
+    private static final ResourceLocation FALLBACK = texture("item/page_symbol");
+    private static final Map<String, ResourceLocation> CACHE = new LinkedHashMap<>(16, .75F, true);
+    private static final Map<String, int[]> WORD_CACHE = new LinkedHashMap<>(16, .75F, true);
+    private static NativeImage base;
+    private static NativeImage components;
+    private static int nextId;
+
+    // WordData from Mystcraft Legacy 0.13.7.06. Other words get a stable generated glyph.
+    private static final Map<String, int[]> WORDS = Map.ofEntries(
+            Map.entry("Terrain", new int[] {6,10,12,13,16,19,24,25,27}),
+            Map.entry("Form", new int[] {4,6,8,9,10,11,13,14,16,23}),
+            Map.entry("Tradition", new int[] {4,6,7,8,9,14,17,18,20}),
+            Map.entry("Flow", new int[] {4,7,12,13,17,18}),
+            Map.entry("Constraint", new int[] {5,6,9,11,13,20,22,23}),
+            Map.entry("Nature", new int[] {5,6,8,10,11,12,15,16,17,22}),
+            Map.entry("Sustain", new int[] {6,16,19,20,21,23}),
+            Map.entry("Ethereal", new int[] {4,6,8,13,14,16,18,21,23}),
+            Map.entry("Dynamic", new int[] {4,5,6,12,13,17,18,22,23}),
+            Map.entry("Cycle", new int[] {4,5,7,16,17,18}),
+            Map.entry("Balance", new int[] {4,6,9,10,16,19}),
+            Map.entry("Transform", new int[] {4,5,6,8,11,14,18,20,21}),
+            Map.entry("Time", new int[] {4,5,7,12,13,19,20,21,22,23}),
+            Map.entry("System", new int[] {10,12,14,15,16,20,21,22}),
+            Map.entry("Void", new int[] {4,5,6,16,17,18,23})
+    );
+
+    private SymbolPageTextures() {}
+
+    /** Transparent full-size artwork for GUI thumbnails drawn over their own page background. */
+    public static ResourceLocation forPage(ItemStack stack) {
+        return forPage(stack, false);
+    }
+
+    /** Full page texture with artwork reduced by three pixels at 16 px item-icon scale. */
+    public static ResourceLocation forItem(ItemStack stack) {
+        return forPage(stack, true);
+    }
+
+    private static ResourceLocation forPage(ItemStack stack, boolean item) {
+        PageContent content = PageItem.content(stack);
+        if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return texture("item/page_unresolved");
+        if (content.kind() != PageContent.Kind.SYMBOL) return FALLBACK;
+        SymbolDisplayMetadata metadata = stack.get(ModDataComponents.PAGE_SYMBOL_DISPLAY.get());
+        ResourceLocation id = content.symbol().orElseThrow().id();
+        return forSymbol(id, metadata == null ? "" : metadata.poem(), item);
+    }
+
+    private static ResourceLocation forSymbol(ResourceLocation id, String poem, boolean item) {
+        if (poem.length() > 96 || !poem.matches("[A-Za-z]+(?: [A-Za-z]+){3}")) poem = "";
+        if (poem.isEmpty()) poem = SymbolPoems.builtIn(id);
+        String key = id + "|" + poem + (item ? "|item" : "|thumbnail");
+        ResourceLocation cached = CACHE.get(key);
+        if (cached != null) return cached;
+        try {
+            loadSources(Minecraft.getInstance().getResourceManager());
+            NativeImage image = compose(id, poem, item);
+            ResourceLocation location = ResourceLocation.fromNamespaceAndPath(
+                    Rivencraft.MOD_ID, "generated/page_" + nextId++);
+            Minecraft.getInstance().getTextureManager().register(location, new DynamicTexture(image));
+            CACHE.put(key, location);
+            if (CACHE.size() > CACHE_LIMIT) {
+                String eldest = CACHE.keySet().iterator().next();
+                Minecraft.getInstance().getTextureManager().release(CACHE.remove(eldest));
+            }
+            return location;
+        } catch (IOException exception) {
+            Rivencraft.LOGGER.error("Could not compose symbol page {}", id, exception);
+            return FALLBACK;
+        }
+    }
+
+    public static void clear() {
+        var textures = Minecraft.getInstance().getTextureManager();
+        CACHE.values().forEach(textures::release);
+        CACHE.clear();
+        WORD_CACHE.clear();
+        if (base != null) base.close();
+        if (components != null) components.close();
+        base = null;
+        components = null;
+    }
+
+    private static void loadSources(ResourceManager manager) throws IOException {
+        if (base != null && components != null) return;
+        try (InputStream page = manager.getResourceOrThrow(BASE).open();
+             InputStream sheet = manager.getResourceOrThrow(COMPONENTS).open()) {
+            base = NativeImage.read(page);
+            components = NativeImage.read(sheet);
+        }
+    }
+
+    private static NativeImage compose(ResourceLocation id, String poem, boolean item) {
+        // GUI variants have no parchment layer, so their untouched pixels must be transparent.
+        NativeImage image = new NativeImage(SIZE, SIZE, true);
+        if (item) {
+            for (int y = 0; y < SIZE; y++) for (int x = 0; x < SIZE; x++) {
+                image.setPixelRGBA(x, y, base.getPixelRGBA(x * base.getWidth() / SIZE,
+                        y * base.getHeight() / SIZE));
+            }
+        }
+        String[] words = poem.isBlank() ? generatedWords(id) : poem.split(" ");
+        int[] offsetsX = {38, 77, 38, 0};
+        int[] offsetsY = {0, 38, 77, 38};
+        int glyphSize = item ? GLYPH * ITEM_SYMBOL_SIZE / ICON_SIZE : GLYPH;
+        for (int word = 0; word < 4; word++) {
+            int originX = item ? scaleForItem(offsetsX[word]) : offsetsX[word];
+            int originY = item ? scaleForItem(offsetsY[word]) : offsetsY[word];
+            for (int component : glyphs(words[word])) {
+                for (int y = 0; y < glyphSize; y++) for (int x = 0; x < glyphSize; x++) {
+                    int pixel = components.getPixelRGBA((component % 8) * 64 + x * 64 / glyphSize,
+                            (component / 8) * 64 + y * 64 / glyphSize);
+                    int alpha = pixel >>> 24;
+                    if (alpha != 0) image.blendPixel(originX + x, originY + y,
+                            (alpha << 24) | 0x001A212B);
+                }
+            }
+        }
+        return image;
+    }
+
+    private static int scaleForItem(int coordinate) {
+        return SIZE / 2 + Math.round((coordinate - SIZE / 2F) * ITEM_SYMBOL_SIZE / ICON_SIZE);
+    }
+
+    private static String[] generatedWords(ResourceLocation id) {
+        String stem = id.toString();
+        return new String[] {stem + 'a', stem + 'b', stem + 'c', stem + 'd'};
+    }
+
+    private static int[] glyphs(String word) {
+        int[] known = WORDS.get(word);
+        if (known != null) return known;
+        String key = word.toLowerCase(Locale.ROOT);
+        int[] cached = WORD_CACHE.get(key);
+        if (cached != null) return cached;
+        Random random = new Random(key.hashCode());
+        int[] components = new int[random.nextInt(10) + 3];
+        for (int index = 0; index < components.length; index++) components[index] = random.nextInt(20) + 4;
+        WORD_CACHE.put(key, components);
+        if (WORD_CACHE.size() > CACHE_LIMIT) WORD_CACHE.remove(WORD_CACHE.keySet().iterator().next());
+        return components;
+    }
+
+    /** Draw a word as a layered Legacy glyph, or a number with Legacy's number components. */
+    public static void drawWordGlyph(GuiGraphics graphics, String word, int x, int y, int size) {
+        if (word.matches("[0-9]+")) {
+            try {
+                drawNumeral(graphics, Integer.parseInt(word), x, y, size);
+                return;
+            } catch (NumberFormatException ignored) {
+                // Oversized numerals still receive a stable word glyph.
+            }
+        }
+        graphics.setColor(0.13F, 0.10F, 0.08F, 1F);
+        for (int component : glyphs(word)) drawComponent(graphics, component, x, y, size);
+        graphics.setColor(1F, 1F, 1F, 1F);
+    }
+
+    /** Legacy's single-number marks; numbers above 24 use positional base 25. */
+    public static void drawNumeral(GuiGraphics graphics, int number, int x, int y, int size) {
+        int[] digits = SymbolNumerals.digitsFor(number);
+        int digitSize = digits.length == 1 ? size : Math.max(8, size * 3 / 4);
+        graphics.setColor(0.13F, 0.10F, 0.08F, 1F);
+        for (int digit : digits) {
+            for (int component : SymbolNumerals.componentsForDigit(digit))
+                drawComponent(graphics, component, x, y + (size - digitSize) / 2, digitSize);
+            x += digitSize + 1;
+        }
+        graphics.setColor(1F, 1F, 1F, 1F);
+    }
+
+    /** Render translated prose as a sequence of word glyphs within a fixed-width book page. */
+    public static int drawGlyphText(GuiGraphics graphics, String text, int x, int y, int maxWidth) {
+        int cursor = x;
+        boolean drew = false;
+        for (String word : text.split("[^\\p{L}\\p{N}]+")) {
+            if (word.isEmpty()) continue;
+            int width = word.matches("[0-9]+") ? numeralWidth(word, 12) : 12;
+            if (cursor != x && cursor + width > x + maxWidth) {
+                cursor = x;
+                y += 13;
+            }
+            drawWordGlyph(graphics, word, cursor, y, 12);
+            cursor += width + 3;
+            drew = true;
+        }
+        return y + (drew ? 13 : 0);
+    }
+
+    private static int numeralWidth(String word, int size) {
+        try {
+            int count = SymbolNumerals.digitsFor(Integer.parseInt(word)).length;
+            return count == 1 ? size : count * (size * 3 / 4 + 1) - 1;
+        } catch (NumberFormatException ignored) {
+            return size;
+        }
+    }
+
+    private static void drawComponent(GuiGraphics graphics, int component, int x, int y, int size) {
+        graphics.blit(COMPONENTS, x, y, size, size,
+                (component % 8) * 64, (component / 8) * 64, 64, 64, 512, 512);
+    }
+
+    private static ResourceLocation texture(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "textures/" + path + ".png");
+    }
+}

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

@@ -0,0 +1,55 @@
+package net.dnorberg.rivencraft.client;
+
+import com.mojang.blaze3d.vertex.PoseStack;
+import com.mojang.math.Axis;
+import net.dnorberg.rivencraft.block.WritingDeskBlock;
+import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.renderer.MultiBufferSource;
+import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
+import net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider;
+import net.minecraft.world.item.ItemDisplayContext;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Visible selected page and loaded paper, as on the Legacy desk. */
+public final class WritingDeskRenderer implements BlockEntityRenderer<WritingDeskBlockEntity> {
+    public WritingDeskRenderer(BlockEntityRendererProvider.Context context) {}
+
+    @Override public void render(WritingDeskBlockEntity desk, float partialTick, PoseStack pose,
+                                 MultiBufferSource buffers, int light, int overlay) {
+        int paper = desk.getItem(WritingDeskBlockEntity.PAPER).getCount();
+        ItemStack page = desk.displayPage();
+        if (paper == 0 && page.isEmpty()) return;
+        pose.pushPose();
+        pose.translate(0.5, 0, 0.5);
+        pose.mulPose(Axis.YP.rotationDegrees(
+                180.0F - desk.getBlockState().getValue(WritingDeskBlock.FACING).toYRot()));
+        if (paper > 0) {
+            ItemStack sheet = new ItemStack(Items.PAPER);
+            int layers = Math.min(4, 1 + paper / 16);
+            for (int i = 0; i < layers; i++) {
+                drawFlat(desk, sheet, pose, buffers, light, overlay, 1.22, 0.27 + i * 0.008, -0.14, 0.55F);
+            }
+        }
+        if (!page.isEmpty()) {
+            drawFlat(desk, page, pose, buffers, light, overlay, 1.0, 0.572, 0.0, 0.8F);
+        }
+        pose.popPose();
+    }
+
+    private static void drawFlat(WritingDeskBlockEntity desk, ItemStack stack, PoseStack pose,
+                                 MultiBufferSource buffers, int light, int overlay,
+                                 double x, double y, double z, float scale) {
+        pose.pushPose();
+        pose.translate(x, y, z);
+        pose.mulPose(Axis.XP.rotationDegrees(90));
+        pose.scale(scale, scale, scale);
+        Minecraft.getInstance().getItemRenderer().renderStatic(stack, ItemDisplayContext.FIXED,
+                light, overlay, pose, buffers, desk.getLevel(), 0);
+        pose.popPose();
+    }
+
+    @Override public boolean shouldRenderOffScreen(WritingDeskBlockEntity blockEntity) { return true; }
+    @Override public int getViewDistance() { return 64; }
+}

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

@@ -0,0 +1,258 @@
+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;
+import net.dnorberg.rivencraft.menu.BookBinderMenu;
+import net.dnorberg.rivencraft.network.SetBookBinderTitlePayload;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.item.ItemStack;
+import net.neoforged.neoforge.network.PacketDistributor;
+import org.lwjgl.glfw.GLFW;
+
+/** Legacy-sized binder: cover and result flank a scrolling strip of full page thumbnails. */
+public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMenu> {
+    private static final ResourceLocation BACKGROUND = ResourceLocation.fromNamespaceAndPath(
+            Rivencraft.MOD_ID, "textures/gui/book_binder_legacy.png");
+    private static final ResourceLocation PAGE_ATLAS = ResourceLocation.fromNamespaceAndPath(
+            Rivencraft.MOD_ID, "textures/gui/notebook_pages.png");
+    private static final int STRIP_X = 7;
+    private static final int STRIP_Y = 45;
+    private static final int STRIP_WIDTH = 162;
+    private static final int STRIP_HEIGHT = 40;
+    private static final int PAGE_WIDTH = 26;
+    private static final int PAGE_HEIGHT = 34;
+    private static final int PAGE_STEP = 28;
+    private static final int VISIBLE_PAGES = 5;
+
+    private EditBox titleInput;
+    private int firstVisible;
+    private int lastGrammarErrorStripIndex = -1;
+    private boolean stripClickPendingRelease;
+
+    public BookBinderScreen(BookBinderMenu menu, Inventory inventory, Component title) {
+        super(menu, inventory, title);
+        imageWidth = 176;
+        imageHeight = 181;
+        inventoryLabelX = 8;
+        inventoryLabelY = 87;
+    }
+
+    @Override public boolean isPauseScreen() { return false; }
+
+    @Override protected void init() {
+        super.init();
+        titleInput = new EditBox(font, leftPos + 9, topPos + 10, 112, 12,
+                Component.translatable("screen.rivencraft.book_binder.title"));
+        titleInput.setBordered(false);
+        titleInput.setTextColor(0xFFFFFFFF);
+        titleInput.setMaxLength(BookBinderBlockEntity.MAX_TITLE_LENGTH);
+        titleInput.setValue(menu.title());
+        titleInput.setHint(Component.translatable("screen.rivencraft.book_binder.title_hint"));
+        titleInput.setResponder(value -> PacketDistributor.sendToServer(
+                new SetBookBinderTitlePayload(menu.containerId, value)));
+        addRenderableWidget(titleInput);
+    }
+
+    @Override public void renderBackground(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+        renderBg(graphics, partialTick, mouseX, mouseY);
+    }
+
+    @Override protected void renderBg(GuiGraphics graphics, float partialTick, int mouseX, int mouseY) {
+        graphics.blit(BACKGROUND, leftPos, topPos, 0, 0, imageWidth, imageHeight, 256, 256);
+        if (menu.getSlot(BookBinderBlockEntity.LINK_PANEL).getItem().isEmpty()) {
+            float fade = (System.currentTimeMillis() % 4000L) / 2000F;
+            if (fade > 1F) fade = 2F - fade;
+            graphics.blit(BACKGROUND, leftPos + 27, topPos + 26,
+                    18, 18, 176, 0, 30, 40, 256, 256);
+            graphics.setColor(1F, 0.3F, 0.3F, 0.8F * fade);
+            graphics.blit(BACKGROUND, leftPos + 27, topPos + 26,
+                    18, 18, 176, 0, 30, 40, 256, 256);
+            graphics.setColor(1F, 1F, 1F, 1F);
+        }
+        graphics.fill(leftPos + 7, topPos + 9, leftPos + 123, topPos + 23, 0xFF000000);
+        graphics.renderOutline(leftPos + 7, topPos + 9, 116, 14,
+                titleInput == null || titleInput.getValue().isBlank() ? 0xFFFF3030 : 0xFFA0A0A0);
+    }
+
+    @Override protected void renderLabels(GuiGraphics graphics, int mouseX, int mouseY) {
+        graphics.drawString(font, playerInventoryTitle, inventoryLabelX, inventoryLabelY, 0xFF404040, false);
+    }
+
+    @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();
+        for (int visible = 0; visible < VISIBLE_PAGES; visible++) {
+            int index = firstVisible + visible;
+            if (index >= count) break;
+            drawPage(graphics, pageAtIndex(index), index,
+                    leftPos + 16 + visible * PAGE_STEP, topPos + STRIP_Y + 3);
+        }
+        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);
+            else if (firstVisible < maxFirstVisible() && mouseX >= leftPos + STRIP_X + STRIP_WIDTH - 8
+                    && mouseX < leftPos + STRIP_X + STRIP_WIDTH)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book_binder.next_pages"), mouseX, mouseY);
+        }
+        if (pageAtIndex(0).isEmpty() && mouseX >= leftPos + 27 && mouseX < leftPos + 45
+                && mouseY >= topPos + 26 && mouseY < topPos + 44) {
+            graphics.renderTooltip(font,
+                    Component.translatable("screen.rivencraft.book_binder.missing_panel"), mouseX, mouseY);
+            return;
+        }
+        int hovered = pageIndexAt(mouseX, mouseY);
+        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);
+    }
+
+    private ItemStack pageAtIndex(int index) {
+        return menu.getSlot(index == 0 ? BookBinderBlockEntity.LINK_PANEL
+                : BookBinderBlockEntity.FIRST_PAGE + index - 1).getItem();
+    }
+
+    private int displayedPages() {
+        for (int index = BookBinderBlockEntity.PAGE_COUNT; index >= 1; index--)
+            if (!pageAtIndex(index).isEmpty()) return index + 1;
+        return pageAtIndex(0).isEmpty() ? 0 : 1;
+    }
+
+    private int maxFirstVisible() {
+        return Math.max(0, visiblePageCount() - VISIBLE_PAGES);
+    }
+
+    private int visiblePageCount() {
+        return Math.min(BookBinderBlockEntity.PAGE_COUNT + 1,
+                displayedPages() + (menu.getCarried().isEmpty() ? 0 : 1));
+    }
+
+    private void drawPage(GuiGraphics graphics, ItemStack page, int index, int x, int y) {
+        graphics.blit(PAGE_ATLAS, x, y, PAGE_WIDTH, PAGE_HEIGHT, 156, 0, 30, 40, 256, 256);
+        if (page.isEmpty()) {
+            graphics.fill(x, y, x + PAGE_WIDTH, y + PAGE_HEIGHT, 0xAA000000);
+            return;
+        }
+        switch (PageItem.content(page).kind()) {
+            case BLANK -> { }
+            case LINK_PANEL -> graphics.fill(x + 5, y + 6, x + 22, y + 17, 0xFF000000);
+            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) {
+        int x = leftPos + STRIP_X;
+        int y = topPos + STRIP_Y;
+        graphics.fill(x, y, x + 8, y + STRIP_HEIGHT,
+                firstVisible == 0 ? 0x33000000 : 0xAA000000);
+        graphics.fill(x + STRIP_WIDTH - 8, y, x + STRIP_WIDTH, y + STRIP_HEIGHT,
+                firstVisible >= maxFirstVisible() ? 0x33000000 : 0xAA000000);
+    }
+
+    private int pageIndexAt(double mouseX, double mouseY) {
+        int localX = (int) mouseX - leftPos;
+        int localY = (int) mouseY - topPos;
+        if (localX < STRIP_X + 8 || localX >= STRIP_X + STRIP_WIDTH - 8
+                || localY < STRIP_Y || localY >= STRIP_Y + STRIP_HEIGHT) return -1;
+        int visible = (localX - 16) / PAGE_STEP;
+        if (visible < 0 || visible >= VISIBLE_PAGES) return -1;
+        return Math.min(firstVisible + visible, BookBinderBlockEntity.PAGE_COUNT);
+    }
+
+    @Override public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        int localX = (int) mouseX - leftPos;
+        int localY = (int) mouseY - topPos;
+        if ((button == 0 || button == 1) && localY >= STRIP_Y && localY < STRIP_Y + STRIP_HEIGHT
+                && localX >= STRIP_X && localX < STRIP_X + STRIP_WIDTH) {
+            stripClickPendingRelease = true;
+            if (localX < STRIP_X + 8) firstVisible = Math.max(0, firstVisible - 1);
+            else if (localX >= STRIP_X + STRIP_WIDTH - 8)
+                firstVisible = Math.min(maxFirstVisible(), firstVisible + 1);
+            else {
+                int index = pageIndexAt(mouseX, mouseY);
+                if (index >= 0 && index <= displayedPages()
+                        && (index < displayedPages() || !menu.getCarried().isEmpty()))
+                    clickStrip(index);
+            }
+            return true;
+        }
+        return super.mouseClicked(mouseX, mouseY, button);
+    }
+
+    private void clickStrip(int index) {
+        if (minecraft != null && minecraft.gameMode != null)
+            minecraft.gameMode.handleInventoryButtonClick(menu.containerId,
+                    BookBinderMenu.STRIP_CLICK_BASE + index);
+    }
+
+    @Override public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        if (stripClickPendingRelease) {
+            stripClickPendingRelease = false;
+            return true;
+        }
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    @Override public boolean mouseScrolled(double mouseX, double mouseY, double scrollX, double scrollY) {
+        if (mouseX >= leftPos + STRIP_X && mouseX < leftPos + STRIP_X + STRIP_WIDTH
+                && mouseY >= topPos + STRIP_Y && mouseY < topPos + STRIP_Y + STRIP_HEIGHT) {
+            firstVisible = Math.clamp(firstVisible - (int) Math.signum(scrollY), 0, maxFirstVisible());
+            return true;
+        }
+        return super.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
+    }
+
+    @Override public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (titleInput != null && titleInput.isFocused()) {
+            if (keyCode == 256) {
+                setFocused(null);
+                titleInput.setFocused(false);
+            } else titleInput.keyPressed(keyCode, scanCode, modifiers);
+            return true;
+        }
+        if (keyCode == GLFW.GLFW_KEY_LEFT && firstVisible > 0) {
+            firstVisible--;
+            return true;
+        }
+        if (keyCode == GLFW.GLFW_KEY_RIGHT && firstVisible < maxFirstVisible()) {
+            firstVisible++;
+            return true;
+        }
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
+}

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

@@ -1,8 +1,11 @@
 package net.dnorberg.rivencraft.client.screen;
 
+import java.util.List;
+import java.util.Locale;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeTraits;
 import net.dnorberg.rivencraft.client.ClientBookExploreOverlay;
+import net.dnorberg.rivencraft.client.SymbolPageTextures;
 import net.dnorberg.rivencraft.network.UseDescriptiveBookPayload;
 import net.dnorberg.rivencraft.network.BindDescriptiveBookPayload;
 import net.dnorberg.rivencraft.network.ModNetworking;
@@ -10,62 +13,77 @@ import net.dnorberg.rivencraft.network.RequestLinkPreviewPayload;
 import net.dnorberg.rivencraft.network.LinkPreviewPayload;
 import net.dnorberg.rivencraft.network.ReleaseLinkPreviewPayload;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
+import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.dnorberg.rivencraft.client.preview.DestinationPreviewRenderer;
 import net.dnorberg.rivencraft.client.preview.DestinationPreviewRenderers;
 import net.minecraft.core.BlockPos;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.resources.sounds.SimpleSoundInstance;
 import net.minecraft.client.gui.components.Button;
 import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.components.Tooltip;
 import net.minecraft.network.chat.Component;
 import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundEvents;
 import net.minecraft.util.FormattedCharSequence;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.InteractionHand;
 import net.neoforged.neoforge.network.PacketDistributor;
+import org.lwjgl.glfw.GLFW;
 import org.jetbrains.annotations.Nullable;
 
-import java.util.Locale;
-
 public final class DescriptiveBookScreen extends Screen implements ExplorableBookScreen {
     private static final int BOOK_TEXT_COLOR = 0xFF3B281B;
-    private static final ResourceLocation BOOK_TEXTURE = ResourceLocation.fromNamespaceAndPath(
+    private static final int UNRESOLVED_TEXT_COLOR = 0xFF9B302C;
-            "rivencraft", "textures/gui/linking_book.png"
-    );
     private static final int BOOK_WIDTH = 327;
     private static final int BOOK_HEIGHT = 199;
-    private static final int TEXTURE_WIDTH = 512;
+    private static final int LINK_PANEL_X = 173;
-    private static final int TEXTURE_HEIGHT = 312;
+    private static final int LINK_PANEL_Y = 20;
-    private static final int LINK_PANEL_X = 28;
+    private static final int LINK_PANEL_WIDTH = 132;
-    private static final int LINK_PANEL_Y = 35;
+    private static final int LINK_PANEL_HEIGHT = 83;
-    private static final int LINK_PANEL_WIDTH = 126;
-    private static final int LINK_PANEL_HEIGHT = 86;
     private static final Component EXPLORE_ICON = Component.literal("👁");
 
     private final AgeReference age;
     private final ResourceLocation generationProfile;
     private final AgeTraits traits;
+    private final OrderedWriting writing;
+    private final List<SymbolDisplayMetadata> writingSymbols;
+    private final boolean pageFree;
     private final InteractionHand hand;
     private final BlockPos bookStandPos;
     private DestinationPreviewRenderer preview;
     private EditBox titleInput;
     private Button exploreButton;
+    private Button createButton;
+    private Button cancelButton;
+    private int pageIndex;
     private boolean movingToExploreOverlay;
 
-    public DescriptiveBookScreen(InteractionHand hand, ItemStack book, @Nullable AgeTraits traits) {
+    public DescriptiveBookScreen(InteractionHand hand, ItemStack book, @Nullable AgeTraits traits,
+                                 List<SymbolDisplayMetadata> writingSymbols) {
         super(book.getHoverName());
         age = book.get(ModDataComponents.AGE_REFERENCE.get());
         generationProfile = book.get(ModDataComponents.AGE_GENERATION_PROFILE.get());
         this.traits = traits;
+        writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
+        this.writingSymbols = List.copyOf(writingSymbols);
+        pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
         this.hand = hand;
         bookStandPos = null;
     }
 
-    public DescriptiveBookScreen(BlockPos bookStandPos, ItemStack book, @Nullable AgeTraits traits) {
+    public DescriptiveBookScreen(BlockPos bookStandPos, ItemStack book, @Nullable AgeTraits traits,
+                                 List<SymbolDisplayMetadata> writingSymbols) {
         super(book.getHoverName());
         age = book.get(ModDataComponents.AGE_REFERENCE.get());
         generationProfile = book.get(ModDataComponents.AGE_GENERATION_PROFILE.get());
         this.traits = traits;
+        writing = book.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY);
+        this.writingSymbols = List.copyOf(writingSymbols);
+        pageFree = writing.entries().stream().noneMatch(entry -> entry.kind() == WritingEntry.Kind.SYMBOL);
         hand = InteractionHand.MAIN_HAND;
         this.bookStandPos = bookStandPos.immutable();
     }
@@ -75,19 +93,22 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         int left = (width - BOOK_WIDTH) / 2;
         int top = (height - BOOK_HEIGHT) / 2;
         if (age == null) {
-            int rightPage = left + 177;
+            int leftPage = left + 40;
-            titleInput = new EditBox(font, rightPage, top + 69, 124, 20,
+            titleInput = new EditBox(font, leftPage, top + 69, 110, 20,
                     Component.translatable("screen.rivencraft.age.title"));
             titleInput.setMaxLength(ModNetworking.MAX_BOOK_TITLE_LENGTH);
             titleInput.setHint(Component.translatable("screen.rivencraft.age.title_hint"));
             addRenderableWidget(titleInput);
             setInitialFocus(titleInput);
-            addRenderableWidget(Button.builder(Component.translatable("screen.rivencraft.age.create"), button -> createAge())
+            createButton = addRenderableWidget(Button.builder(Component.translatable("screen.rivencraft.age.create"), button -> createAge())
-                    .bounds(rightPage, top + 100, 59, 20)
+                    .bounds(leftPage, top + 100, 53, 20)
                     .build());
-            addRenderableWidget(Button.builder(Component.translatable("gui.cancel"), button -> onClose())
+            cancelButton = addRenderableWidget(Button.builder(Component.translatable("gui.cancel"), button -> onClose())
-                    .bounds(rightPage + 65, top + 100, 59, 20)
+                    .bounds(leftPage + 57, top + 100, 53, 20)
                     .build());
+            titleInput.visible = pageIndex == 0;
+            createButton.visible = pageIndex == 0;
+            cancelButton.visible = pageIndex == 0;
         } else {
             boolean requestPreview = preview == null;
             if (requestPreview) {
@@ -96,8 +117,10 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             if (preview.supportsExploration()) {
                 exploreButton = addRenderableWidget(Button.builder(
                                 EXPLORE_ICON, button -> enterExploreOverlay())
-                        .bounds(left + 81, top + 145, 20, 20).build());
+                        .bounds(left + 229, top + 145, 20, 20)
+                        .tooltip(Tooltip.create(Component.translatable("screen.rivencraft.book.explore"))).build());
                 exploreButton.active = bookStandPos == null;
+                exploreButton.visible = pageIndex == 0;
             }
             if (requestPreview) {
                 PacketDistributor.sendToServer(new RequestLinkPreviewPayload(
@@ -132,50 +155,111 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         renderBook(graphics, partialTick);
         super.render(graphics, mouseX, mouseY, partialTick);
+        int left = (width - BOOK_WIDTH) / 2;
+        int top = (height - BOOK_HEIGHT) / 2;
+        if (mouseY >= top + 164 && mouseY < top + 195) {
+            if (pageIndex > 0 && mouseX >= left + 7 && mouseX < left + 35)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.previous_page"), mouseX, mouseY);
+            else if (pageIndex < pageCount() && mouseX >= left + 293 && mouseX < left + 320)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.next_page"), mouseX, mouseY);
+        }
     }
 
     private void renderBook(GuiGraphics graphics, float partialTick) {
         int left = (width - BOOK_WIDTH) / 2;
         int top = (height - BOOK_HEIGHT) / 2;
-        graphics.blit(BOOK_TEXTURE, left, top, BOOK_WIDTH, BOOK_HEIGHT, 0, 0,
+        LegacyBookArtwork.drawCover(graphics, left, top, true);
-                TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_WIDTH, TEXTURE_HEIGHT);
 
+        if (pageIndex > 0) {
+            LegacyBookArtwork.drawLeftPage(graphics, left, top);
+        }
+        if (pageIndex == 0) {
+            if (age != null && preview != null) {
+                preview.render(graphics, left + LINK_PANEL_X, top + LINK_PANEL_Y,
+                        LINK_PANEL_WIDTH, LINK_PANEL_HEIGHT, partialTick);
+            }
+            LegacyBookArtwork.drawPanelPage(graphics, left, top);
+            graphics.enableScissor(left + 38, top + 38, left + 154, top + 174);
+            renderFirstPageText(graphics, left, top);
+            graphics.disableScissor();
+        } else if (pageIndex < pageCount()) {
+            LegacyBookArtwork.drawFullPage(graphics, left, top);
+            renderWrittenPage(graphics, left, top);
+        }
+        String counter = pageIndex + "/" + pageCount();
+        graphics.drawString(font, counter, left + 165 - font.width(counter) / 2,
+                top + 185, 0xFF000000, false);
+    }
+
+    private int pageCount() {
+        // Older page-free Descriptive Books do not have a BOOK_WRITING component.
+        return Math.max(1, writing.entries().size());
+    }
+
+    private void renderFirstPageText(GuiGraphics graphics, int left, int top) {
+        int x = left + 40;
+        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.title"),
+                x, top + 40, 110);
         if (age == null) {
             drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.name_prompt"),
-                    left + 177, top + 45, 124);
+                    x, top + 52, 110);
-        } else {
+            return;
-            preview.render(graphics, left + LINK_PANEL_X, top + LINK_PANEL_Y, LINK_PANEL_WIDTH, LINK_PANEL_HEIGHT, partialTick);
-            int detailsY = drawWrappedWithoutShadow(
-                    graphics, Component.literal(age.name()), left + 177, top + 43, 124) + 3;
-            detailsY = Math.max(detailsY, top + 72);
-            if (generationProfile != null) {
-                Component profileName = generationProfile.getNamespace().equals("rivencraft")
-                        ? Component.translatable("generator.rivencraft." + generationProfile.getPath())
-                        : Component.literal(generationProfile.toString());
-                detailsY = drawWrappedWithoutShadow(graphics,
-                        Component.translatable("screen.rivencraft.age.generator", profileName),
-                        left + 177, detailsY, 124) + 2;
-            }
-            if (traits != null) {
-                detailsY = drawTrait(graphics, "biomes", traitName("biome_distribution", traits.biomeDistribution()),
-                        left + 177, detailsY);
-                detailsY = drawTrait(graphics, "lighting", traitName("lighting", traits.lighting()),
-                        left + 177, detailsY);
-                detailsY = drawTrait(graphics, "weather", traitName("weather", traits.weather()),
-                        left + 177, detailsY);
-                Component dayLength = traits.hasStoppedCelestialCycle()
-                        ? Component.translatable("trait.rivencraft.day_length.stopped")
-                        : Component.literal(String.format(Locale.ROOT, "%.2fx", traits.celestialPeriod()));
-                detailsY = drawTrait(graphics, "day_length", dayLength, left + 177, detailsY);
-                detailsY = drawTrait(graphics, "celestial_angle",
-                        Component.literal(String.format(Locale.ROOT, "%.0f°", traits.celestialAngle())),
-                        left + 177, detailsY);
-                drawTrait(graphics, "celestial_phase",
-                        Component.literal(String.format(Locale.ROOT, "%.0f%%", traits.celestialPhase() * 100.0F)),
-                        left + 177, detailsY);
-            }
         }
+        int detailsY = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),
+                x + 10, top + 52, 100) + 10;
+        if (generationProfile != null) {
+            Component profileName = generationProfile.getNamespace().equals("rivencraft")
+                    ? Component.translatable("generator.rivencraft." + generationProfile.getPath())
+                    : Component.literal(generationProfile.toString());
+            detailsY = drawDescription(graphics,
+                    Component.translatable("screen.rivencraft.age.generator", profileName),
+                    x, detailsY, 110) + 2;
+        }
+        if (traits != null) {
+            detailsY = drawTrait(graphics, "biomes", traitName("biome_distribution", traits.biomeDistribution()), x, detailsY);
+            detailsY = drawTrait(graphics, "lighting", traitName("lighting", traits.lighting()), x, detailsY);
+            detailsY = drawTrait(graphics, "weather", traitName("weather", traits.weather()), x, detailsY);
+            Component dayLength = traits.hasStoppedCelestialCycle()
+                    ? Component.translatable("trait.rivencraft.day_length.stopped")
+                    : Component.literal(String.format(Locale.ROOT, "%.2fx", traits.celestialPeriod()));
+            detailsY = drawTrait(graphics, "day_length", dayLength, x, detailsY);
+            detailsY = drawTrait(graphics, "celestial_angle",
+                    Component.literal(String.format(Locale.ROOT, "%.0f°", traits.celestialAngle())), x, detailsY);
+            drawTrait(graphics, "celestial_phase",
+                    Component.literal(String.format(Locale.ROOT, "%.0f%%", traits.celestialPhase() * 100.0F)), x, detailsY);
+        }
+    }
 
+    private void renderWrittenPage(GuiGraphics graphics, int left, int top) {
+        WritingEntry entry = writing.entries().get(pageIndex);
+        int x = left + 176;
+        if (entry.kind() == WritingEntry.Kind.LINK_PANEL) {
+            drawWrappedWithoutShadow(graphics, Component.translatable("item.rivencraft.page.link_panel"),
+                    x, top + 39, 126);
+            return;
+        }
+        int symbolIndex = (int) writing.entries().subList(0, pageIndex + 1).stream()
+                .filter(candidate -> candidate.kind() == WritingEntry.Kind.SYMBOL).count() - 1;
+        SymbolDisplayMetadata display = symbolIndex < writingSymbols.size()
+                ? writingSymbols.get(symbolIndex) : SymbolDisplayMetadata.unresolved(entry.symbol().orElseThrow());
+        int color = display.resolved() ? BOOK_TEXT_COLOR : UNRESOLVED_TEXT_COLOR;
+        drawWrappedWithoutShadow(graphics, Component.translatable(display.nameTranslationKey()),
+                x, top + 39, 126, color);
+        drawWrappedWithoutShadow(graphics, Component.literal(display.id().toString()),
+                x, top + 64, 126, color);
+        drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.pages_not_applied"),
+                x, top + 137, 126);
+    }
+
+    private void turnPage(int direction) {
+        int nextPage = Math.max(0, Math.min(pageCount(), pageIndex + direction));
+        if (nextPage == pageIndex) return;
+        pageIndex = nextPage;
+        minecraft.getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.BOOK_PAGE_TURN, 1.0F, 0.65F));
+        if (titleInput != null) titleInput.visible = pageIndex == 0;
+        if (createButton != null) createButton.visible = pageIndex == 0;
+        if (cancelButton != null) cancelButton.visible = pageIndex == 0;
+        if (exploreButton != null) exploreButton.visible = pageIndex == 0;
     }
 
     @Override
@@ -201,14 +285,25 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
             resetExploration();
             return true;
         }
-        if (age != null && button == 0) {
+        if (button == 0) {
-            int panelLeft = (width - BOOK_WIDTH) / 2 + LINK_PANEL_X;
+            int left = (width - BOOK_WIDTH) / 2;
-            int panelTop = (height - BOOK_HEIGHT) / 2 + LINK_PANEL_Y;
+            int top = (height - BOOK_HEIGHT) / 2;
-            if (mouseX >= panelLeft && mouseX < panelLeft + LINK_PANEL_WIDTH
+            if (pageIndex == 0 && age != null
-                    && mouseY >= panelTop && mouseY < panelTop + LINK_PANEL_HEIGHT) {
+                    && mouseX >= left + LINK_PANEL_X && mouseX < left + LINK_PANEL_X + LINK_PANEL_WIDTH
+                    && mouseY >= top + LINK_PANEL_Y && mouseY < top + LINK_PANEL_Y + LINK_PANEL_HEIGHT) {
                 link();
                 return true;
             }
+            if (mouseY >= top + 164 && mouseY < top + 195) {
+                if (pageIndex > 0 && mouseX >= left + 7 && mouseX < left + 35) {
+                    turnPage(-1);
+                    return true;
+                }
+                if (pageIndex < pageCount() && mouseX >= left + 293 && mouseX < left + 320) {
+                    turnPage(1);
+                    return true;
+                }
+            }
         }
         return super.mouseClicked(mouseX, mouseY, button);
     }
@@ -224,6 +319,10 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
 
     @Override
     public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (titleInput == null || !titleInput.isFocused()) {
+            if (keyCode == GLFW.GLFW_KEY_LEFT && pageIndex > 0) { turnPage(-1); return true; }
+            if (keyCode == GLFW.GLFW_KEY_RIGHT && pageIndex < pageCount()) { turnPage(1); return true; }
+        }
         return preview != null && preview.keyPressed(keyCode, scanCode)
                 || super.keyPressed(keyCode, scanCode, modifiers);
     }
@@ -268,7 +367,7 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
         int top = (height - BOOK_HEIGHT) / 2;
         graphics.drawCenteredString(font,
                 Component.translatable("screen.rivencraft.book.return_from_explore"),
-                left + 91, top + 154, BOOK_TEXT_COLOR);
+                left + 239, top + 154, BOOK_TEXT_COLOR);
     }
 
     @Override
@@ -316,8 +415,14 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     }
 
     private int drawTrait(GuiGraphics graphics, String key, Component value, int x, int y) {
-        return drawWrappedWithoutShadow(graphics,
+        return drawDescription(graphics,
-                Component.translatable("screen.rivencraft.age.trait." + key, value), x, y, 124) + 2;
+                Component.translatable("screen.rivencraft.age.trait." + key, value), x, y, 110) + 2;
+    }
+
+    private int drawDescription(GuiGraphics graphics, Component text, int x, int y, int maxWidth) {
+        return pageFree && age != null
+                ? SymbolPageTextures.drawGlyphText(graphics, text.getString(), x, y, maxWidth)
+                : drawWrappedWithoutShadow(graphics, text, x, y, maxWidth);
     }
 
     private static Component traitName(String group, Enum<?> value) {
@@ -326,8 +431,12 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
     }
 
     private int drawWrappedWithoutShadow(GuiGraphics graphics, Component text, int x, int y, int maxWidth) {
+        return drawWrappedWithoutShadow(graphics, text, x, y, maxWidth, BOOK_TEXT_COLOR);
+    }
+
+    private int drawWrappedWithoutShadow(GuiGraphics graphics, Component text, int x, int y, int maxWidth, int color) {
         for (FormattedCharSequence line : font.split(text, maxWidth)) {
-            graphics.drawString(font, line, x, y, BOOK_TEXT_COLOR, false);
+            graphics.drawString(font, line, x, y, color, false);
             y += font.lineHeight;
         }
         return y;

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

@@ -0,0 +1,52 @@
+package net.dnorberg.rivencraft.client.screen;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.menu.InkMixerMenu;
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.player.Inventory;
+
+/** Legacy Ink Mixer atlas with a server-synced, sixteen-use basin. */
+public final class InkMixerScreen extends AbstractContainerScreen<InkMixerMenu> {
+    private static final ResourceLocation BACKGROUND = ResourceLocation.fromNamespaceAndPath(
+            Rivencraft.MOD_ID, "textures/gui/ink_mixer_legacy.png");
+
+    public InkMixerScreen(InkMixerMenu menu, Inventory inventory, Component title) {
+        super(menu, inventory, title);
+        imageWidth = 176;
+        imageHeight = 181;
+        inventoryLabelY = 87;
+    }
+
+    @Override public boolean isPauseScreen() { return false; }
+    @Override public void renderBackground(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+        renderBg(graphics, partialTick, mouseX, mouseY);
+    }
+    @Override protected void renderBg(GuiGraphics graphics, float partialTick, int mouseX, int mouseY) {
+        graphics.blit(BACKGROUND, leftPos, topPos, 0, 0, imageWidth, imageHeight, 256, 256);
+        int centerX = leftPos + 88;
+        int centerY = topPos + 49;
+        int fillTop = centerY + 26 - Math.round(menu.inkRemaining() / (float) InkVialItem.CAPACITY * 52);
+        if (menu.inkRemaining() > 0) {
+            for (int y = Math.max(centerY - 26, fillTop); y <= centerY + 26; y++) {
+                int halfWidth = (int) Math.sqrt(26 * 26 - (y - centerY) * (y - centerY));
+                graphics.fill(centerX - halfWidth, y, centerX + halfWidth + 1, y + 1, 0xFF241228);
+            }
+        }
+    }
+    @Override protected void renderLabels(GuiGraphics graphics, int mouseX, int mouseY) {
+        graphics.drawString(font, playerInventoryTitle, inventoryLabelX, inventoryLabelY, 0x404040, false);
+    }
+    @Override public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+        super.render(graphics, mouseX, mouseY, partialTick);
+        renderTooltip(graphics, mouseX, mouseY);
+        int x = mouseX - (leftPos + 88);
+        int y = mouseY - (topPos + 49);
+        if (x * x + y * y <= 26 * 26)
+            graphics.renderTooltip(font, Component.translatable("screen.rivencraft.ink_mixer.ink",
+                    menu.inkRemaining(), InkVialItem.CAPACITY), mouseX, mouseY);
+    }
+}

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

@@ -0,0 +1,48 @@
+package net.dnorberg.rivencraft.client.screen;
+
+import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.resources.ResourceLocation;
+
+/** Original Mystcraft Legacy book atlases and page composition (LGPL-3.0,
+ * copyright XCompWiz, revision 9bc8ddc061845df0cd5ea47f4fdef773cff786ae). */
+final class LegacyBookArtwork {
+    private static final int ATLAS_SIZE = 256;
+    private static final ResourceLocation COVER = texture("bookui_cover.png");
+    private static final ResourceLocation LEFT_PAGE = texture("bookui_pagel.png");
+    private static final ResourceLocation RIGHT_PANEL = texture("bookui_pager.png");
+    private static final ResourceLocation RIGHT_FULL = texture("bookui_rpage_full.png");
+
+    private LegacyBookArtwork() {}
+
+    static void drawCover(GuiGraphics graphics, int left, int top, boolean gilded) {
+        blit(graphics, COVER, left, top + 7, 34, 192, 152, 0);
+        blit(graphics, COVER, left + 34, top + 7, 103, 192, 49, 0);
+        blit(graphics, COVER, left + 137, top + 7, 4, 192, 45, 0);
+        blit(graphics, COVER, left + 141, top + 7, 186, 192, 0, 0);
+        if (gilded) {
+            blit(graphics, COVER, left, top + 7, 34, 192, 186, 0);
+            blit(graphics, COVER, left + 293, top + 7, 34, 192, 186, 0);
+        }
+    }
+
+    static void drawLeftPage(GuiGraphics graphics, int left, int top) {
+        blit(graphics, LEFT_PAGE, left + 7, top, 156, 195, 0, 0);
+    }
+
+    static void drawPanelPage(GuiGraphics graphics, int left, int top) {
+        blit(graphics, RIGHT_PANEL, left + 163, top, 156, 195, 0, 0);
+    }
+
+    static void drawFullPage(GuiGraphics graphics, int left, int top) {
+        blit(graphics, RIGHT_FULL, left + 163, top, 156, 195, 0, 0);
+    }
+
+    private static ResourceLocation texture(String filename) {
+        return ResourceLocation.fromNamespaceAndPath("rivencraft", "textures/gui/" + filename);
+    }
+
+    private static void blit(GuiGraphics graphics, ResourceLocation texture, int x, int y,
+                             int width, int height, int u, int v) {
+        graphics.blit(texture, x, y, width, height, u, v, width, height, ATLAS_SIZE, ATLAS_SIZE);
+    }
+}

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

@@ -16,28 +16,28 @@ import net.dnorberg.rivencraft.item.LinkingBookItem;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.Button;
 import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.components.Tooltip;
 import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.resources.sounds.SimpleSoundInstance;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.component.DataComponents;
 import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.network.chat.contents.TranslatableContents;
+import net.minecraft.sounds.SoundEvents;
 import net.minecraft.util.FormattedCharSequence;
 import net.minecraft.world.InteractionHand;
 import net.minecraft.world.item.ItemStack;
 import net.neoforged.neoforge.network.PacketDistributor;
+import org.lwjgl.glfw.GLFW;
 
 public final class LinkingBookScreen extends Screen implements ExplorableBookScreen {
     private static final int BOOK_TEXT_COLOR = 0xFF3B281B;
-    private static final ResourceLocation BOOK_TEXTURE = ResourceLocation.fromNamespaceAndPath(
-            "rivencraft", "textures/gui/linking_book.png"
-    );
     private static final int BOOK_WIDTH = 327;
     private static final int BOOK_HEIGHT = 199;
-    private static final int TEXTURE_WIDTH = 512;
+    private static final int PREVIEW_X = 173;
-    private static final int TEXTURE_HEIGHT = 312;
+    private static final int PREVIEW_Y = 20;
-    private static final int PREVIEW_X = 28;
+    private static final int PREVIEW_WIDTH = 132;
-    private static final int PREVIEW_Y = 35;
+    private static final int PREVIEW_HEIGHT = 83;
-    private static final int PREVIEW_WIDTH = 126;
-    private static final int PREVIEW_HEIGHT = 86;
     private static final Component EXPLORE_ICON = Component.literal("👁");
 
     private final InteractionHand hand;
@@ -47,6 +47,9 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
     private DestinationPreviewRenderer preview;
     private EditBox titleInput;
     private Button exploreButton;
+    private Button bindButton;
+    private Button cancelButton;
+    private int pageIndex;
     private boolean movingToExploreOverlay;
 
     public LinkingBookScreen(InteractionHand hand, ItemStack book) {
@@ -70,19 +73,22 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
         int left = (width - BOOK_WIDTH) / 2;
         int top = (height - BOOK_HEIGHT) / 2;
         if (target == null) {
-            int rightPage = left + 177;
+            int leftPage = left + 40;
-            titleInput = new EditBox(font, rightPage, top + 69, 124, 20,
+            titleInput = new EditBox(font, leftPage, top + 69, 110, 20,
                     Component.translatable("screen.rivencraft.book.title"));
             titleInput.setMaxLength(ModNetworking.MAX_BOOK_TITLE_LENGTH);
             titleInput.setHint(Component.translatable("screen.rivencraft.book.title_hint"));
             addRenderableWidget(titleInput);
             setInitialFocus(titleInput);
-            addRenderableWidget(Button.builder(Component.translatable("screen.rivencraft.book.bind"), button -> bind())
+            bindButton = addRenderableWidget(Button.builder(Component.translatable("screen.rivencraft.book.bind"), button -> bind())
-                    .bounds(rightPage, top + 100, 59, 20)
+                    .bounds(leftPage, top + 100, 53, 20)
                     .build());
-            addRenderableWidget(Button.builder(Component.translatable("gui.cancel"), button -> onClose())
+            cancelButton = addRenderableWidget(Button.builder(Component.translatable("gui.cancel"), button -> onClose())
-                    .bounds(rightPage + 65, top + 100, 59, 20)
+                    .bounds(leftPage + 57, top + 100, 53, 20)
                     .build());
+            titleInput.visible = pageIndex == 0;
+            bindButton.visible = pageIndex == 0;
+            cancelButton.visible = pageIndex == 0;
         } else {
             boolean requestPreview = preview == null;
             if (requestPreview) {
@@ -91,8 +97,10 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
             if (preview.supportsExploration()) {
                 exploreButton = addRenderableWidget(Button.builder(
                                 EXPLORE_ICON, button -> enterExploreOverlay())
-                        .bounds(left + 81, top + 145, 20, 20).build());
+                        .bounds(left + 229, top + 145, 20, 20)
+                        .tooltip(Tooltip.create(Component.translatable("screen.rivencraft.book.explore"))).build());
                 exploreButton.active = bookStandPos == null;
+                exploreButton.visible = pageIndex == 0;
             }
             if (requestPreview) {
                 PacketDistributor.sendToServer(new RequestLinkPreviewPayload(
@@ -128,33 +136,55 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
     public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         renderBook(graphics, partialTick);
         super.render(graphics, mouseX, mouseY, partialTick);
+        int left = (width - BOOK_WIDTH) / 2;
+        int top = (height - BOOK_HEIGHT) / 2;
+        if (mouseY >= top + 164 && mouseY < top + 195) {
+            if (pageIndex > 0 && mouseX >= left + 7 && mouseX < left + 35)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.previous_page"), mouseX, mouseY);
+            else if (pageIndex == 0 && mouseX >= left + 293 && mouseX < left + 320)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.book.next_page"), mouseX, mouseY);
+        }
     }
 
     private void renderBook(GuiGraphics graphics, float partialTick) {
         int left = (width - BOOK_WIDTH) / 2;
         int top = (height - BOOK_HEIGHT) / 2;
-        graphics.blit(BOOK_TEXTURE, left, top, BOOK_WIDTH, BOOK_HEIGHT, 0, 0,
+        LegacyBookArtwork.drawCover(graphics, left, top, false);
-                TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_WIDTH, TEXTURE_HEIGHT);
+        if (pageIndex > 0) {
-
+            LegacyBookArtwork.drawLeftPage(graphics, left, top);
-        if (target == null) {
-            drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.book.name_prompt"),
-                    left + 177, top + 45, 124);
         } else {
-            int previewLeft = left + PREVIEW_X;
+            if (target != null && preview != null) {
-            int previewTop = top + PREVIEW_Y;
+                preview.render(graphics, left + PREVIEW_X, top + PREVIEW_Y,
-            preview.render(graphics, previewLeft, previewTop, PREVIEW_WIDTH, PREVIEW_HEIGHT, partialTick);
+                        PREVIEW_WIDTH, PREVIEW_HEIGHT, partialTick);
-
+            }
-            int rightCenter = left + 239;
+            LegacyBookArtwork.drawPanelPage(graphics, left, top);
-            drawWrappedWithoutShadow(graphics, title, left + 177, top + 43, 124);
+            graphics.enableScissor(left + 38, top + 38, left + 154, top + 174);
-            BlockPos pos = target.location().pos();
+            if (target == null) {
-            drawCenteredWithoutShadow(graphics,
+                drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.book.name_prompt"),
-                    LinkingBookItem.destinationName(book, target), rightCenter, top + 76);
+                        left + 40, top + 43, 110);
-            drawCenteredWithoutShadow(graphics,
+            } else {
-                    Component.literal(pos.getX() + ", " + pos.getY() + ", " + pos.getZ()), rightCenter, top + 89);
+                int x = left + 40;
-            drawCenteredWithoutShadow(graphics,
+                Component customName = book.get(DataComponents.CUSTOM_NAME);
-                    Component.translatable("screen.rivencraft.book.click_to_link"), rightCenter, top + 119);
+                boolean returnLink = customName != null
+                        && customName.getContents() instanceof TranslatableContents translated
+                        && translated.getKey().equals("item.rivencraft.linking_book.return");
+                if (!returnLink) {
+                    drawWrappedWithoutShadow(graphics, title, x, top + 40, 110);
+                }
+                int destinationY = returnLink ? top + 40 : top + 58;
+                drawWrappedWithoutShadow(graphics, LinkingBookItem.destinationName(book, target),
+                        x + 10, destinationY, 100);
+                BlockPos pos = target.location().pos();
+                drawWrappedWithoutShadow(graphics,
+                        Component.literal(pos.getX() + ", " + pos.getY() + ", " + pos.getZ()),
+                        x, destinationY + 28, 110);
+            }
+            graphics.disableScissor();
         }
 
+        String counter = pageIndex + "/1";
+        graphics.drawString(font, counter, left + 165 - font.width(counter) / 2,
+                top + 185, 0xFF000000, false);
     }
 
     @Override
@@ -163,18 +193,39 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
             resetExploration();
             return true;
         }
-        if (target != null && button == 0) {
+        if (button == 0) {
-            int left = (width - BOOK_WIDTH) / 2 + PREVIEW_X;
+            int left = (width - BOOK_WIDTH) / 2;
-            int top = (height - BOOK_HEIGHT) / 2 + PREVIEW_Y;
+            int top = (height - BOOK_HEIGHT) / 2;
-            if (mouseX >= left && mouseX < left + PREVIEW_WIDTH
+            if (pageIndex == 0 && target != null
-                    && mouseY >= top && mouseY < top + PREVIEW_HEIGHT) {
+                    && mouseX >= left + PREVIEW_X && mouseX < left + PREVIEW_X + PREVIEW_WIDTH
+                    && mouseY >= top + PREVIEW_Y && mouseY < top + PREVIEW_Y + PREVIEW_HEIGHT) {
                 link();
                 return true;
             }
+            if (mouseY >= top + 164 && mouseY < top + 195) {
+                if (pageIndex > 0 && mouseX >= left + 7 && mouseX < left + 35) {
+                    turnPage(0);
+                    return true;
+                }
+                if (pageIndex == 0 && mouseX >= left + 293 && mouseX < left + 320) {
+                    turnPage(1);
+                    return true;
+                }
+            }
         }
         return super.mouseClicked(mouseX, mouseY, button);
     }
 
+    private void turnPage(int page) {
+        if (pageIndex == page) return;
+        pageIndex = page;
+        minecraft.getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.BOOK_PAGE_TURN, 1.0F, 0.65F));
+        if (titleInput != null) titleInput.visible = pageIndex == 0;
+        if (bindButton != null) bindButton.visible = pageIndex == 0;
+        if (cancelButton != null) cancelButton.visible = pageIndex == 0;
+        if (exploreButton != null) exploreButton.visible = pageIndex == 0;
+    }
+
     @Override
     public void removed() {
         if (preview != null && !movingToExploreOverlay) {
@@ -197,6 +248,10 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
 
     @Override
     public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (titleInput == null || !titleInput.isFocused()) {
+            if (keyCode == GLFW.GLFW_KEY_LEFT && pageIndex > 0) { turnPage(0); return true; }
+            if (keyCode == GLFW.GLFW_KEY_RIGHT && pageIndex == 0) { turnPage(1); return true; }
+        }
         return preview != null && preview.keyPressed(keyCode, scanCode)
                 || super.keyPressed(keyCode, scanCode, modifiers);
     }
@@ -247,7 +302,7 @@ public final class LinkingBookScreen extends Screen implements ExplorableBookScr
         int top = (height - BOOK_HEIGHT) / 2;
         drawCenteredWithoutShadow(graphics,
                 Component.translatable("screen.rivencraft.book.return_from_explore"),
-                left + 91, top + 154);
+                left + 239, top + 154);
     }
 
     @Override

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

@@ -3,6 +3,7 @@ package net.dnorberg.rivencraft.client.screen;
 import java.util.Locale;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.client.SymbolPageTextures;
 import net.dnorberg.rivencraft.menu.NotebookMenu;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.client.gui.GuiGraphics;
@@ -26,14 +27,6 @@ public final class NotebookScreen extends AbstractContainerScreen<NotebookMenu>
     private static final int PAGE_STEP_Y = 41;
     private static final int PAGE_COLUMNS = 5;
     private static final ResourceLocation PAGE_ATLAS = texture("gui/notebook_pages");
-    private static final ResourceLocation GENERIC_SYMBOL = texture("item/page_symbol");
-    private static final ResourceLocation UNRESOLVED_SYMBOL = texture("item/page_unresolved");
-    private static final ResourceLocation STANDARD_TERRAIN = texture("item/page_symbol_terrain_standard");
-    private static final ResourceLocation NATIVE_BIOMES = texture("item/page_symbol_biome_native");
-    private static final ResourceLocation NORMAL_LIGHTING = texture("item/page_symbol_lighting_normal");
-    private static final ResourceLocation NORMAL_WEATHER = texture("item/page_symbol_weather_normal");
-    private static final ResourceLocation NORMAL_TIME = texture("item/page_symbol_celestial_normal_time");
-    private static final ResourceLocation CAVES = texture("item/page_symbol_feature_caves");
     private EditBox textInput;
     private boolean draggingScrollbar;
     private boolean surfaceClickPendingRelease;
@@ -47,6 +40,8 @@ public final class NotebookScreen extends AbstractContainerScreen<NotebookMenu>
         inventoryLabelY = 123;
     }
 
+    @Override public boolean isPauseScreen() { return false; }
+
     @Override
     protected void init() {
         super.init();
@@ -260,7 +255,7 @@ public final class NotebookScreen extends AbstractContainerScreen<NotebookMenu>
                 case BLANK -> { }
                 case LINK_PANEL -> graphics.fill(x + 5, y + 6, x + 25, y + 20, 0xFF000000);
                 case SYMBOL, UNRESOLVED_SYMBOL -> graphics.blit(symbolTexture(page), x + 1, y + 6,
-                        28, 28, 16, 16, 96, 96, 128, 128);
+                        28, 28, 0, 0, 128, 128, 128, 128);
             }
         }
         if (dimmed) {
@@ -271,20 +266,8 @@ public final class NotebookScreen extends AbstractContainerScreen<NotebookMenu>
         }
     }
 
-    private static ResourceLocation symbolTexture(ItemStack page) {
+    static ResourceLocation symbolTexture(ItemStack page) {
-        var content = PageItem.content(page);
+        return SymbolPageTextures.forPage(page);
-        if (content.kind() == net.dnorberg.rivencraft.writing.PageContent.Kind.UNRESOLVED_SYMBOL) {
-            return UNRESOLVED_SYMBOL;
-        }
-        return switch (content.symbol().orElseThrow().id().toString()) {
-            case "rivencraft:terrain/standard" -> STANDARD_TERRAIN;
-            case "rivencraft:biome/native" -> NATIVE_BIOMES;
-            case "rivencraft:lighting/normal" -> NORMAL_LIGHTING;
-            case "rivencraft:weather/normal" -> NORMAL_WEATHER;
-            case "rivencraft:celestial/normal_time" -> NORMAL_TIME;
-            case "rivencraft:feature/caves" -> CAVES;
-            default -> GENERIC_SYMBOL;
-        };
     }
 
     private static ResourceLocation texture(String path) {

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

@@ -1,63 +1,396 @@
 package net.dnorberg.rivencraft.client.screen;
 
+import java.util.List;
+import java.util.Locale;
+import java.util.ArrayList;
+import java.util.Comparator;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.client.SymbolPageTextures;
+import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.menu.WritingDeskMenu;
+import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import net.minecraft.client.gui.GuiGraphics;
+import net.minecraft.client.gui.components.Button;
+import net.minecraft.client.gui.components.EditBox;
+import net.minecraft.client.gui.components.Tooltip;
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
 import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import org.lwjgl.glfw.GLFW;
 
-/** Functional storage surface; full Legacy transcription controls are a later Milestone 4 slice. */
+/** Legacy desk atlas layout, with four visible tabs out of the desk's 88 collections. */
 public final class WritingDeskScreen extends AbstractContainerScreen<WritingDeskMenu> {
+    private static final ResourceLocation PAGE_ATLAS = ResourceLocation.fromNamespaceAndPath(
+            Rivencraft.MOD_ID, "textures/gui/notebook_pages.png");
+    private static final ResourceLocation LEGACY_DESK = ResourceLocation.fromNamespaceAndPath(
+            Rivencraft.MOD_ID, "textures/gui/writing_desk_legacy.png");
+    private static final ResourceLocation SCROLLBAR = ResourceLocation.fromNamespaceAndPath(
+            Rivencraft.MOD_ID, "textures/gui/scrollbar.png");
+    private int lastCollection = -1;
+    private int selectedPage;
+    private int scrollRows;
+    private boolean allMode;
+    private boolean sortAlphabetically;
+    private int selectedCollection = -1;
+    private ResourceLocation selectedCategory;
+    private EditBox search;
+    private Button categoryButton;
+    private Button allButton;
+    private Button sortButton;
+    private boolean draggingScrollbar;
+    private record DisplayPage(int collection, int index, ItemStack stack) {}
+    private DisplayPage pageDragSource;
+    private double pageDragStartX;
+    private double pageDragStartY;
+    private boolean draggingPage;
+
+    private boolean isPhysicalPageView() {
+        return !allMode && !sortAlphabetically && selectedCategory == null
+                && (search == null || search.getValue().isBlank());
+    }
+
     public WritingDeskScreen(WritingDeskMenu menu, Inventory inventory, Component title) {
         super(menu, inventory, title);
-        imageWidth = 398;
+        imageWidth = 409;
-        imageHeight = 176;
+        imageHeight = 186;
         titleLabelX = 222;
-        inventoryLabelX = 224;
+    }
-        inventoryLabelY = 79;
+
+    @Override public boolean isPauseScreen() { return false; }
+
+    @Override protected void init() {
+        super.init();
+        sortButton = addRenderableWidget(Button.builder(Component.literal("AZ"), button -> {
+            sortAlphabetically = !sortAlphabetically;
+            scrollRows = 0;
+        }).bounds(leftPos + 58, topPos, 20, 18)
+                .tooltip(Tooltip.create(Component.translatable("screen.rivencraft.writing_desk.sort"))).build());
+        allButton = addRenderableWidget(Button.builder(Component.literal("ALL"), button -> {
+            allMode = !allMode;
+            scrollRows = 0;
+            if (!allMode) {
+                selectedCollection = -1;
+                selectedPage = 0;
+                if (minecraft != null && minecraft.gameMode != null)
+                    minecraft.gameMode.handleInventoryButtonClick(menu.containerId, WritingDeskMenu.PAGE_BUTTON_BASE);
+            }
+        }).bounds(leftPos + 80, topPos, 28, 18)
+                .tooltip(Tooltip.create(Component.translatable("screen.rivencraft.writing_desk.all"))).build());
+        search = new EditBox(font, leftPos + 110, topPos, 101, 18,
+                Component.translatable("screen.rivencraft.writing_desk.search"));
+        search.setMaxLength(64);
+        search.setHint(Component.translatable("screen.rivencraft.writing_desk.search"));
+        search.setResponder(value -> scrollRows = 0);
+        addRenderableWidget(search);
+        categoryButton = addRenderableWidget(Button.builder(Component.literal("C"), button -> {
+            List<ResourceLocation> categories = menu.catalog().stream()
+                    .map(SymbolDisplayMetadata::category).distinct().sorted().toList();
+            int next = selectedCategory == null ? 0 : categories.indexOf(selectedCategory) + 1;
+            selectedCategory = next >= categories.size() ? null : categories.get(next);
+            categoryButton.setMessage(Component.literal(selectedCategory == null ? "C" : "C*"));
+            scrollRows = 0;
+        }).bounds(leftPos + 213, topPos, 18, 18).build());
+    }
+
+    private List<DisplayPage> filteredPages() {
+        String query = search == null ? "" : search.getValue().trim().toLowerCase(Locale.ROOT);
+        List<DisplayPage> entries = new ArrayList<>();
+        int from = allMode ? 0 : menu.activeCollection();
+        int until = allMode ? WritingDeskBlockEntity.COLLECTIONS : from + 1;
+        for (int collection = from; collection < until; collection++) {
+            List<ItemStack> pages = pages(collection);
+            int last = -1;
+            for (int i = 0; i < pages.size(); i++) if (!pages.get(i).isEmpty()) last = i;
+            // A notebook has exactly its normal GUI capacity; a loose page has one position.
+            if (isPhysicalPageView()) last = menu.pageCapacity(collection) - 1;
+            for (int i = 0; i <= last; i++) {
+                ItemStack page = i < pages.size() ? pages.get(i) : ItemStack.EMPTY;
+                if (page.isEmpty() && (allMode || sortAlphabetically || !query.isEmpty() || selectedCategory != null)) continue;
+                if (!page.isEmpty() && !query.isEmpty()
+                        && !page.getHoverName().getString().toLowerCase(Locale.ROOT).contains(query)
+                        && !PageItem.content(page).symbol().map(symbol -> symbol.id().toString()
+                        .toLowerCase(Locale.ROOT).contains(query)).orElse(false)) continue;
+                if (!page.isEmpty() && selectedCategory != null) {
+                    ResourceLocation id = PageItem.content(page).symbol().map(symbol -> symbol.id()).orElse(null);
+                    if (menu.catalog().stream().noneMatch(metadata -> metadata.id().equals(id)
+                            && metadata.category().equals(selectedCategory))) continue;
+                }
+                entries.add(new DisplayPage(collection, i, page));
+            }
+        }
+        if (sortAlphabetically) entries.sort(Comparator
+                .comparing((DisplayPage entry) -> entry.stack().getHoverName().getString(), String.CASE_INSENSITIVE_ORDER)
+                .thenComparingInt(DisplayPage::collection).thenComparingInt(DisplayPage::index));
+        return entries;
+    }
+
+    @Override public void renderBackground(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
+        // Keep the world visible, but still draw our GUI backing. The vanilla
+        // container implementation normally calls renderBg from this method.
+        renderBg(graphics, partialTick, mouseX, mouseY);
     }
 
     @Override protected void renderBg(GuiGraphics graphics, float partialTick, int mouseX, int mouseY) {
         int x = leftPos;
         int y = topPos;
-        graphics.fill(x + 4, y + 8, x + 216, y + 174, 0xFF383230);
+        // Legacy GuiWritingDesk draws the entire 176x166 panel, not a stretched swatch.
-        graphics.fill(x + 44, y + 14, x + 210, y + 170, 0xFF221B1A);
+        graphics.blit(LEGACY_DESK, x + 233, y + 20, 0, 0, 176, 166);
-        graphics.fill(x + 218, y + 4, x + 396, y + 174, 0xFF555454);
+        drawTabControl(graphics, 20, 203, menu.firstVisibleTab() > 0);
-        graphics.fill(x + 220, y + 6, x + 394, y + 172, 0xFFB7B7B7);
         for (int i = 0; i < 4; i++) {
-            graphics.fill(x + 6, y + 16 + i * 37, x + 40, y + 48 + i * 37,
+            int tab = menu.firstVisibleTab() + i;
-                    i == menu.activeCollection() ? 0xFF7777B6 : 0xFF999999);
+            int tabY = y + 29 + i * 37;
-            slotFrame(graphics, 12, 20 + i * 37);
+            if (tab == menu.activeCollection() && !allMode) graphics.setColor(0.5F, 0.5F, 1F, 1F);
+            graphics.blit(LEGACY_DESK, x, tabY, 0, 166, 58, 37);
+            graphics.setColor(1F, 1F, 1F, 1F);
+            // Encode the visible one-based tab number with Legacy's numeric word glyph.
+            SymbolPageTextures.drawNumeral(graphics, tab + 1, x + 8, tabY + 3, 19);
+            ItemStack collection = menu.getSlot(tab).getItem();
+            if (!collection.isEmpty()) {
+                String name = collection.getHoverName().getString();
+                float scale = Math.min(1F, 50F / Math.max(1, font.width(name)));
+                graphics.pose().pushPose();
+                graphics.pose().translate(x + 4, tabY + 25, 0);
+                graphics.pose().scale(scale, scale, 1);
+                graphics.drawString(font, name, 0, 0, 0xFF404040, false);
+                graphics.pose().popPose();
+            }
         }
-        slotFrame(graphics, 228, 20);
+        drawTabControl(graphics, 177, 212, menu.firstVisibleTab() < WritingDeskBlockEntity.COLLECTIONS - 4);
-        slotFrame(graphics, 266, 20);
+        // GuiElementVSlider: 4-pixel caps, repeated 22-pixel track, 12x15 thumb.
-        slotFrame(graphics, 304, 20);
+        graphics.blit(SCROLLBAR, x + 213, y + 20, 0, 0, 20, 4, 32, 32);
-        slotFrame(graphics, 342, 20);
+        for (int offset = 4; offset < 162; offset += 22)
-        for (int row = 0; row < 3; row++) {
+            graphics.blit(SCROLLBAR, x + 213, y + 20 + offset, 0, 4, 20, Math.min(22, 162 - offset), 32, 32);
-            for (int column = 0; column < 9; column++) slotFrame(graphics, 224 + column * 18, 91 + row * 18);
+        graphics.blit(SCROLLBAR, x + 213, y + 182, 0, 26, 20, 4, 32, 32);
-        }
+        int totalRows = (filteredPages().size() + 4) / 5;
-        for (int column = 0; column < 9; column++) slotFrame(graphics, 224 + column * 18, 149);
+        int maxScroll = Math.max(0, totalRows - 4);
+        scrollRows = Math.clamp(scrollRows, 0, maxScroll);
+        int thumbY = y + 24 + (maxScroll == 0 ? 0 : scrollRows * 143 / maxScroll);
+        graphics.blit(SCROLLBAR, x + 217, thumbY, 20, draggingScrollbar ? 15 : 0, 12, 15, 32, 32);
+        graphics.fill(x + 365, y + 27, x + 381, y + 97, 0xFF303035);
+        graphics.fill(x + 366, y + 28, x + 380, y + 96, 0xFF6666AA);
+        int filled = 68 * menu.inkRemaining() / 16;
+        if (filled > 0) graphics.fill(x + 366, y + 96 - filled, x + 380, y + 96, 0xFF15151B);
     }
 
-    private void slotFrame(GuiGraphics graphics, int x, int y) {
+    private void drawTabControl(GuiGraphics graphics, int y, int textureY, boolean enabled) {
-        graphics.fill(leftPos + x - 1, topPos + y - 1,
+        if (!enabled) graphics.setColor(0.4F, 0.4F, 0.4F, 1F);
-                leftPos + x + 17, topPos + y + 17, 0xFF4D4D4D);
+        graphics.blit(LEGACY_DESK, leftPos, topPos + y, 0, textureY, 58, 9);
-        graphics.fill(leftPos + x, topPos + y,
+        graphics.setColor(1F, 1F, 1F, 1F);
-                leftPos + x + 16, topPos + y + 16, 0xFF858585);
+    }
+
+    @Override protected void renderLabels(GuiGraphics graphics, int mouseX, int mouseY) {
+        // Legacy leaves the inventory grid unlabeled.
     }
 
     @Override public void render(GuiGraphics graphics, int mouseX, int mouseY, float partialTick) {
         super.render(graphics, mouseX, mouseY, partialTick);
+        if (sortAlphabetically) graphics.renderOutline(leftPos + 58, topPos, 20, 18, 0xFFFFD061);
+        if (allMode) graphics.renderOutline(leftPos + 80, topPos, 28, 18, 0xFFFFD061);
+        renderCollection(graphics);
+        if (draggingPage && pageDragSource != null) {
+            DisplayPage target = pageAtMouse(mouseX, mouseY);
+            if (target != null && canMovePage(pageDragSource, target)) {
+                int x = leftPos + 58 + ((int) mouseX - leftPos - 58) / 31 * 31;
+                int y = topPos + 20 + ((int) mouseY - topPos - 20) / 41 * 41;
+                graphics.renderOutline(x, y, 30, 40, 0xFF57D478);
+            }
+            graphics.renderItem(pageDragSource.stack(), mouseX - 8, mouseY - 8);
+        }
         renderTooltip(graphics, mouseX, mouseY);
+        if (mouseX >= leftPos + 365 && mouseX < leftPos + 381
+                && mouseY >= topPos + 27 && mouseY < topPos + 97) {
+            graphics.renderTooltip(font, Component.translatable("screen.rivencraft.writing_desk.ink",
+                    menu.inkRemaining(), 16), mouseX, mouseY);
+        }
+        if (mouseX >= leftPos + 213 && mouseX < leftPos + 231
+                && mouseY >= topPos && mouseY < topPos + 18) {
+            graphics.renderTooltip(font, Component.translatable("screen.rivencraft.writing_desk.category",
+                    selectedCategory == null
+                            ? Component.translatable("screen.rivencraft.writing_desk.all_categories")
+                            : Component.literal(selectedCategory.toString())), mouseX, mouseY);
+        }
+        if (mouseX >= leftPos && mouseX < leftPos + 58) {
+            int localY = mouseY - topPos;
+            if (localY >= 20 && localY < 29)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.writing_desk.previous_tabs"), mouseX, mouseY);
+            else if (localY >= 177 && localY < 186)
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.writing_desk.next_tabs"), mouseX, mouseY);
+            else if (mouseX < leftPos + 34 && localY >= 29 && localY < 177) {
+                int tab = menu.firstVisibleTab() + (localY - 29) / 37;
+                graphics.renderTooltip(font, Component.translatable("screen.rivencraft.writing_desk.tab_symbol",
+                        tab + 1), mouseX, mouseY);
+            }
+        }
+    }
+
+    private List<ItemStack> pages(int collectionIndex) {
+        ItemStack collection = menu.getSlot(collectionIndex).getItem();
+        if (collection.is(ModItems.PAGE.get())) return List.of(collection);
+        if (collection.is(ModItems.NOTEBOOK.get())) {
+            return collection.getOrDefault(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages();
+        }
+        return List.of();
+    }
+
+    private void renderCollection(GuiGraphics graphics) {
+        if (lastCollection != menu.activeCollection()) {
+            lastCollection = menu.activeCollection();
+            scrollRows = 0;
+            selectedPage = 0;
+            selectedCollection = -1;
+        }
+        List<DisplayPage> entries = filteredPages();
+        for (int i = scrollRows * 5; i < entries.size() && i < scrollRows * 5 + 20; i++) {
+            int column = i % 5;
+            int row = i / 5 - scrollRows;
+            DisplayPage entry = entries.get(i);
+            ItemStack page = entry.stack();
+            int x = leftPos + 58 + column * 31;
+            int y = topPos + 20 + row * 41;
+            drawPage(graphics, page, x, y);
+            if (page.isEmpty()) graphics.fill(x, y, x + 30, y + 40, 0xB8000000);
+            int active = selectedCollection >= 0 ? selectedCollection : menu.activeCollection();
+            if (entry.collection() == active && entry.index() == selectedPage && !page.isEmpty())
+                graphics.renderOutline(x, y, 30, 40, 0xFFFFD061);
+        }
+        int active = selectedCollection >= 0 ? selectedCollection : menu.activeCollection();
+        List<ItemStack> source = pages(active);
+        if (selectedPage >= source.size() || source.get(selectedPage).isEmpty()) return;
+        ItemStack selected = source.get(selectedPage);
+        drawPage(graphics, selected, leftPos + 265, topPos + 26);
+        String title = font.plainSubstrByWidth(selected.getHoverName().getString(), 95);
+        graphics.fill(leftPos + 261, topPos + 81, leftPos + 360, topPos + 95, 0xFF202020);
+        graphics.drawString(font, title, leftPos + 263, topPos + 84, 0xFFE0E0E0, false);
+    }
+
+    private void drawPage(GuiGraphics graphics, ItemStack page, int x, int y) {
+        graphics.blit(PAGE_ATLAS, x, y, 30, 40, 156, 0, 30, 40, 256, 256);
+        if (page.isEmpty()) return;
+        switch (PageItem.content(page).kind()) {
+            case BLANK -> { }
+            case LINK_PANEL -> graphics.fill(x + 5, y + 6, x + 25, y + 20, 0xFF000000);
+            case SYMBOL, UNRESOLVED_SYMBOL -> graphics.blit(NotebookScreen.symbolTexture(page), x + 1, y + 6,
+                    28, 28, 0, 0, 128, 128, 128, 128);
+        }
+    }
+
+    private DisplayPage pageAtMouse(double mouseX, double mouseY) {
+        int x = (int) Math.floor(mouseX - leftPos - 58);
+        int y = (int) Math.floor(mouseY - topPos - 20);
+        if (x < 0 || x >= 155 || y < 0 || y >= 164 || x % 31 >= 30 || y % 41 >= 40) return null;
+        int index = (y / 41 + scrollRows) * 5 + x / 31;
+        List<DisplayPage> entries = filteredPages();
+        return index < entries.size() ? entries.get(index) : null;
+    }
+
+    private boolean canMovePage(DisplayPage source, DisplayPage target) {
+        return !source.stack().isEmpty()
+                && (menu.getSlot(source.collection()).getItem().is(ModItems.NOTEBOOK.get())
+                    || menu.getSlot(source.collection()).getItem().is(ModItems.PAGE.get()))
+                && (menu.getSlot(target.collection()).getItem().is(ModItems.NOTEBOOK.get())
+                    || menu.getSlot(target.collection()).getItem().is(ModItems.PAGE.get()))
+                && (source.collection() != target.collection() || source.index() != target.index());
+    }
+
+    private int extractTargetSlot(double mouseX, double mouseY) {
+        for (Slot slot : menu.slots) {
+            int index = slot.index;
+            if (index >= WritingDeskBlockEntity.COLLECTIONS && index <= WritingDeskMenu.COPY_RESULT) continue;
+            if (!slot.isActive() || !isHovering(slot.x, slot.y, 16, 16, mouseX, mouseY)) continue;
+            ItemStack held = pageDragSource.stack();
+            if (!slot.mayPlace(held)) return -1;
+            ItemStack current = slot.getItem();
+            if (current.isEmpty()) return index;
+            if (index < WritingDeskBlockEntity.COLLECTIONS && current.is(ModItems.NOTEBOOK.get())) {
+                List<ItemStack> pages = current.getOrDefault(
+                        ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages();
+                if (pages.size() < NotebookContents.MAX_PAGES || pages.stream().anyMatch(ItemStack::isEmpty))
+                    return index;
+            } else if (index > WritingDeskMenu.COPY_RESULT && ItemStack.isSameItemSameComponents(current, held)
+                    && current.getCount() < slot.getMaxStackSize(held)) return index;
+            return -1;
+        }
+        return -1;
     }
 
     @Override public boolean mouseClicked(double mouseX, double mouseY, int button) {
-        if (button == 0 && mouseX >= leftPos + 29 && mouseX < leftPos + 40) {
+        if (button == 0) {
-            for (int i = 0; i < 4; i++) {
+            pageDragSource = null;
-                int top = topPos + 16 + i * 37;
+            draggingPage = false;
-                if (mouseY >= top && mouseY < top + 32) {
+        }
+        int surfaceX = (int) Math.floor(mouseX - leftPos - 58);
+        int surfaceY = (int) Math.floor(mouseY - topPos - 20);
+        if ((button == 0 || button == 1) && !menu.getCarried().isEmpty()
+                && surfaceX >= 0 && surfaceX < 155 && surfaceY >= 0 && surfaceY < 164) {
+            if (menu.getCarried().is(ModItems.PAGE.get()) && surfaceX % 31 < 30 && surfaceY % 41 < 40) {
+                int index = (surfaceY / 41 + scrollRows) * 5 + surfaceX / 31;
+                List<DisplayPage> entries = filteredPages();
+                // Only displayed positions are addressable. Filtering never turns
+                // empty screen space into additional storage for a loose-page tab.
+                int collection = index < entries.size() ? entries.get(index).collection() : menu.activeCollection();
+                int page = index < entries.size() ? entries.get(index).index() : index;
+                if (index < entries.size() && page < menu.pageCapacity(collection)
+                        && minecraft != null && minecraft.gameMode != null) {
+                    minecraft.gameMode.handleInventoryButtonClick(menu.containerId,
+                            WritingDeskMenu.PLACE_PAGE_BUTTON_BASE + collection * NotebookContents.MAX_PAGES + page);
+                }
+            }
+            return true;
+        }
+        if (button == 0) {
+            if (mouseX >= leftPos && mouseX < leftPos + 58) {
+                int y = (int) mouseY - topPos;
+                if (y >= 20 && y < 29 || y >= 177 && y < 186) {
+                    if (minecraft != null && minecraft.gameMode != null)
+                        minecraft.gameMode.handleInventoryButtonClick(menu.containerId,
+                                y < 29 ? WritingDeskMenu.PREVIOUS_TABS : WritingDeskMenu.NEXT_TABS);
+                    return true;
+                }
+            }
+            if (mouseX >= leftPos + 213 && mouseX < leftPos + 233
+                    && mouseY >= topPos + 20 && mouseY < topPos + 186) {
+                draggingScrollbar = true;
+                setScrollFromMouse(mouseY);
+                return true;
+            }
+            int x = (int) Math.floor(mouseX - leftPos - 58);
+            int y = (int) Math.floor(mouseY - topPos - 20);
+            if (x >= 0 && x < 155 && y >= 0 && y < 164) {
+                DisplayPage entry = pageAtMouse(mouseX, mouseY);
+                if (entry != null && !entry.stack().isEmpty()) {
+                    selectedCollection = entry.collection();
+                    selectedPage = entry.index();
+                    if (menu.getCarried().isEmpty()) {
+                        pageDragSource = entry;
+                        pageDragStartX = mouseX;
+                        pageDragStartY = mouseY;
+                    }
                     if (minecraft != null && minecraft.gameMode != null) {
-                        minecraft.gameMode.handleInventoryButtonClick(menu.containerId, i);
+                        int id = WritingDeskMenu.ALL_PAGE_BUTTON_BASE
+                                + entry.collection() * NotebookContents.MAX_PAGES + entry.index();
+                        minecraft.gameMode.handleInventoryButtonClick(menu.containerId, id);
+                    }
+                }
+                return true;
+            }
+        }
+        if (button == 0 && mouseX >= leftPos && mouseX < leftPos + 58) {
+            for (int i = 0; i < 4; i++) {
+                int top = topPos + 29 + i * 37;
+                boolean overSlot = mouseX >= leftPos + 36 && mouseX < leftPos + 54
+                        && mouseY >= top + 4 && mouseY < top + 22;
+                if (mouseY >= top && mouseY < top + 37 && !overSlot) {
+                    allMode = false;
+                    selectedCollection = -1;
+                    if (minecraft != null && minecraft.gameMode != null) {
+                        minecraft.gameMode.handleInventoryButtonClick(menu.containerId, menu.firstVisibleTab() + i);
                     }
                     return true;
                 }
@@ -65,4 +398,85 @@ public final class WritingDeskScreen extends AbstractContainerScreen<WritingDesk
         }
         return super.mouseClicked(mouseX, mouseY, button);
     }
+
+    @Override public boolean mouseScrolled(double mouseX, double mouseY, double scrollX, double scrollY) {
+        if (mouseX >= leftPos + 58 && mouseX < leftPos + 233
+                && mouseY >= topPos + 20 && mouseY < topPos + 186) {
+            int rows = (filteredPages().size() + 4) / 5;
+            scrollRows = Math.clamp(scrollRows - (int) Math.signum(scrollY), 0, Math.max(0, rows - 4));
+            return true;
+        }
+        return super.mouseScrolled(mouseX, mouseY, scrollX, scrollY);
+    }
+
+    private void setScrollFromMouse(double mouseY) {
+        int rows = (filteredPages().size() + 4) / 5;
+        int max = Math.max(0, rows - 4);
+        scrollRows = Math.clamp((int) Math.round((mouseY - topPos - 31.5) * max / 143.0), 0, max);
+    }
+
+    @Override public boolean mouseDragged(double mouseX, double mouseY, int button, double dragX, double dragY) {
+        if (button == 0 && pageDragSource != null) {
+            if (Math.abs(mouseX - pageDragStartX) >= 4 || Math.abs(mouseY - pageDragStartY) >= 4)
+                draggingPage = true;
+            return true;
+        }
+        if (button == 0 && draggingScrollbar) {
+            setScrollFromMouse(mouseY);
+            return true;
+        }
+        return super.mouseDragged(mouseX, mouseY, button, dragX, dragY);
+    }
+
+    @Override public boolean mouseReleased(double mouseX, double mouseY, int button) {
+        if (button == 0 && pageDragSource != null) {
+            if (draggingPage) {
+                DisplayPage target = pageAtMouse(mouseX, mouseY);
+                if (target != null && canMovePage(pageDragSource, target)
+                        && minecraft != null && minecraft.gameMode != null) {
+                    selectedCollection = target.collection();
+                    selectedPage = target.index();
+                    minecraft.gameMode.handleInventoryButtonClick(menu.containerId,
+                            WritingDeskMenu.movePageButtonId(pageDragSource.collection(), pageDragSource.index(),
+                                    target.collection(), target.index()));
+                } else if (target == null && minecraft != null && minecraft.gameMode != null) {
+                    int targetSlot = extractTargetSlot(mouseX, mouseY);
+                    minecraft.gameMode.handleInventoryButtonClick(menu.containerId,
+                            WritingDeskMenu.extractPageButtonId(pageDragSource.collection(), pageDragSource.index(),
+                                    targetSlot));
+                }
+            }
+            pageDragSource = null;
+            draggingPage = false;
+            return true;
+        }
+        if (button == 0 && draggingScrollbar) {
+            draggingScrollbar = false;
+            return true;
+        }
+        return super.mouseReleased(mouseX, mouseY, button);
+    }
+
+    @Override public boolean keyPressed(int keyCode, int scanCode, int modifiers) {
+        if (search != null && search.isFocused()) {
+            if (keyCode == 256) {
+                setFocused(null);
+                search.setFocused(false);
+            } else {
+                search.keyPressed(keyCode, scanCode, modifiers);
+            }
+            return true;
+        }
+        if (minecraft != null && minecraft.gameMode != null) {
+            if (keyCode == GLFW.GLFW_KEY_PAGE_UP) {
+                minecraft.gameMode.handleInventoryButtonClick(menu.containerId, WritingDeskMenu.PREVIOUS_TABS);
+                return true;
+            }
+            if (keyCode == GLFW.GLFW_KEY_PAGE_DOWN) {
+                minecraft.gameMode.handleInventoryButtonClick(menu.containerId, WritingDeskMenu.NEXT_TABS);
+                return true;
+            }
+        }
+        return super.keyPressed(keyCode, scanCode, modifiers);
+    }
 }

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

@@ -0,0 +1,173 @@
+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;
+import mezz.jei.api.gui.builder.IRecipeLayoutBuilder;
+import mezz.jei.api.gui.ingredient.IRecipeSlotsView;
+import mezz.jei.api.helpers.IGuiHelper;
+import mezz.jei.api.recipe.IFocusGroup;
+import mezz.jei.api.recipe.RecipeType;
+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;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Loaded by JEI's plugin scanner only when JEI is installed. No common mod class references this type. */
+@JeiPlugin
+public final class RivencraftJeiPlugin implements IModPlugin {
+    private static final RecipeType<WritingGuide> WRITING =
+            RecipeType.create(Rivencraft.MOD_ID, "writing", WritingGuide.class);
+    private static final RecipeType<InkMixerGuide> INK_MIXER =
+            RecipeType.create(Rivencraft.MOD_ID, "ink_mixer", InkMixerGuide.class);
+
+    @Override
+    public ResourceLocation getPluginUid() {
+        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();
+        registration.addRecipeCategories(new WritingCategory(guiHelper), new InkMixerCategory(guiHelper));
+    }
+
+    @Override
+    public void registerRecipes(IRecipeRegistration registration) {
+        ItemStack panel = PageItem.createLinkPanelPage();
+        registration.addRecipes(WRITING, List.of(
+                new WritingGuide(List.of(new ItemStack(Items.PAPER), new ItemStack(ModItems.INK_VIAL.get())),
+                        panel, "jei.rivencraft.writing.link_panel_hand"),
+                new WritingGuide(List.of(panel, new ItemStack(Items.PAPER), new ItemStack(ModItems.INK_VIAL.get())),
+                        panel, "jei.rivencraft.writing.copy"),
+                new WritingGuide(List.of(new ItemStack(Items.LEATHER), panel),
+                        new ItemStack(ModItems.DESCRIPTIVE_BOOK.get()), "jei.rivencraft.writing.bind"),
+                new WritingGuide(List.of(panel, new ItemStack(Items.LEATHER)),
+                        new ItemStack(ModItems.LINKING_BOOK.get()), "jei.rivencraft.writing.linking_book")
+        ));
+        registration.addRecipes(INK_MIXER, List.of(new InkMixerGuide(panel)));
+    }
+
+    @Override
+    public void registerRecipeCatalysts(IRecipeCatalystRegistration registration) {
+        registration.addRecipeCatalysts(WRITING, ModItems.INK_VIAL.get(),
+                ModItems.WRITING_DESK.get(), ModItems.BOOK_BINDER.get());
+        registration.addRecipeCatalysts(INK_MIXER, ModItems.INK_MIXER.get());
+    }
+
+    private record WritingGuide(List<ItemStack> inputs, ItemStack output, String instructionKey) {}
+    private record InkMixerGuide(ItemStack panel) {}
+
+    private static final class InkMixerCategory extends AbstractRecipeCategory<InkMixerGuide> {
+        InkMixerCategory(IGuiHelper guiHelper) {
+            super(INK_MIXER, Component.translatable("jei.rivencraft.ink_mixer"),
+                    guiHelper.createDrawableIngredient(VanillaTypes.ITEM_STACK,
+                            new ItemStack(ModItems.INK_MIXER.get())), 138, 80);
+        }
+
+        @Override
+        public void setRecipe(IRecipeLayoutBuilder builder, InkMixerGuide recipe, IFocusGroup focuses) {
+            builder.addInputSlot(2, 3).setStandardSlotBackground().addItemStack(new ItemStack(Items.PAPER));
+            builder.addInputSlot(23, 3).setStandardSlotBackground()
+                    .addItemStack(new ItemStack(ModItems.INK_VIAL.get()));
+            builder.addOutputSlot(112, 3).setOutputSlotBackground().addItemStack(recipe.panel());
+            builder.addOutputSlot(112, 46).setStandardSlotBackground()
+                    .addItemStack(new ItemStack(Items.GLASS_BOTTLE));
+        }
+
+        @Override
+        public void draw(InkMixerGuide recipe, IRecipeSlotsView slots, GuiGraphics graphics,
+                         double mouseX, double mouseY) {
+            graphics.drawWordWrap(Minecraft.getInstance().font,
+                    Component.translatable("jei.rivencraft.ink_mixer.usage"), 2, 27, 104, 0x404040);
+        }
+    }
+
+    private static final class WritingCategory extends AbstractRecipeCategory<WritingGuide> {
+        WritingCategory(IGuiHelper guiHelper) {
+            super(WRITING, Component.translatable("jei.rivencraft.writing"),
+                    guiHelper.createDrawableIngredient(VanillaTypes.ITEM_STACK,
+                            new ItemStack(ModItems.WRITING_DESK.get())), 138, 80);
+        }
+
+        @Override
+        public void setRecipe(IRecipeLayoutBuilder builder, WritingGuide recipe, IFocusGroup focuses) {
+            for (int index = 0; index < recipe.inputs().size(); index++) {
+                builder.addInputSlot(2 + index * 21, 3).setStandardSlotBackground()
+                        .addItemStack(recipe.inputs().get(index));
+            }
+            builder.addOutputSlot(112, 3).setOutputSlotBackground().addItemStack(recipe.output());
+        }
+
+        @Override
+        public void draw(WritingGuide recipe, IRecipeSlotsView slots, GuiGraphics graphics,
+                         double mouseX, double mouseY) {
+            graphics.drawWordWrap(Minecraft.getInstance().font,
+                    Component.translatable(recipe.instructionKey()), 2, 27, 134, 0x404040);
+        }
+    }
+}

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

@@ -0,0 +1,375 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.book.AgeReference;
+import net.dnorberg.rivencraft.book.AgeDimensionService;
+import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.menu.BookBinderMenu;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+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;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.inventory.ClickType;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder("rivencraft_archive_binder")
+@PrefixGameTestTemplate(false)
+public final class BookBinderGameTests {
+    private BookBinderGameTests() {}
+
+    private static ItemStack terrainPage() {
+        return PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "terrain/standard")));
+    }
+
+    private static ItemStack weatherPage() {
+        return PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "weather/normal")));
+    }
+
+    private static BookBinderBlockEntity place(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.BOOK_BINDER.get().defaultBlockState(), 3);
+        return (BookBinderBlockEntity) helper.getLevel().getBlockEntity(pos);
+    }
+
+    @GameTest(template = "empty")
+    public static void binderInputsAndTitleSurviveSaveLoad(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Ordered Age");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        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");
+        helper.assertTrue(restored.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
+                "Link Panel must persist");
+        helper.assertTrue(ItemStack.matches(restored.getItem(BookBinderBlockEntity.FIRST_PAGE), terrainPage()),
+                "Ordered page must persist");
+        helper.assertTrue(restored.canAssemble(), "Restored binder must remain ready to assemble");
+        AgeReference beforeSave = binder.previewBook().get(ModDataComponents.AGE_REFERENCE.get());
+        var previewSaved = binder.saveWithoutMetadata(helper.getLevel().registryAccess());
+        restored.loadWithComponents(previewSaved, helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.previewBook().get(ModDataComponents.AGE_REFERENCE.get()), beforeSave,
+                "Pending Age identity must survive a world restart");
+        helper.succeed();
+    }
+
+    public static void missingSymbolPageSurvivesReloadButCannotBeAssembled(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Recoverable Writing");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        SymbolReference missing = new SymbolReference(ResourceLocation.parse("example:removed_symbol"));
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, PageItem.createRecoveredPage(missing));
+        var saved = binder.saveWithoutMetadata(helper.getLevel().registryAccess());
+        var restored = new BookBinderBlockEntity(binder.getBlockPos(), binder.getBlockState());
+        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");
+        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");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1, weatherPage());
+        helper.assertFalse(binder.canAssemble(), "Missing Link Panel must prevent assembly");
+        helper.assertFalse(binder.consumeAssembly(), "Failure must consume nothing");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
+                "Rejected assembly must preserve cover");
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(BookBinderMenu.RESULT).hasItem(), "Valid binder must show output");
+        menu.clicked(BookBinderMenu.RESULT, 0, ClickType.PICKUP, player);
+        ItemStack book = menu.getCarried();
+        helper.assertTrue(book.is(ModItems.DESCRIPTIVE_BOOK.get()), "Result must be a Descriptive Book");
+        AgeReference age = book.get(ModDataComponents.AGE_REFERENCE.get());
+        helper.assertTrue(age != null, "Assembled book must already be a written Age book");
+        OrderedWriting writing = book.get(ModDataComponents.BOOK_WRITING.get());
+        helper.assertTrue(writing != null, "Assembled book must keep its writing");
+        helper.assertValueEqual(writing.schemaVersion(), OrderedWriting.CURRENT_SCHEMA_VERSION,
+                "Assembled writing must use the current schema");
+        helper.assertValueEqual(writing.entries().size(), 3, "Link Panel and two pages must be present");
+        helper.assertValueEqual(writing.entries().get(0).kind(), WritingEntry.Kind.LINK_PANEL,
+                "Link Panel must be first");
+        helper.assertValueEqual(writing.entries().get(1).symbol().orElseThrow().id().toString(),
+                "rivencraft:terrain/standard", "Terrain page order must be preserved");
+        helper.assertValueEqual(writing.entries().get(2).symbol().orElseThrow().id().toString(),
+                "rivencraft:weather/normal", "Weather page order must be preserved");
+        helper.assertTrue(AgeRegistrySavedData.get(helper.getLevel()).find(age.id()).isPresent(),
+                "Taking the completed book must register its random Age definition");
+        ItemStack copy = book.copy();
+        helper.assertValueEqual(copy.get(ModDataComponents.BOOK_WRITING.get()), writing,
+                "A book copy must retain identical ordered writing");
+        helper.assertValueEqual(copy.get(ModDataComponents.AGE_REFERENCE.get()), age,
+                "A book copy must retain the same Age rather than assigning a new one");
+        var savedBook = (net.minecraft.nbt.CompoundTag) copy.saveOptional(helper.getLevel().registryAccess());
+        ItemStack restoredBook = ItemStack.parseOptional(helper.getLevel().registryAccess(), savedBook);
+        helper.assertValueEqual(restoredBook.get(ModDataComponents.BOOK_WRITING.get()), writing,
+                "Versioned ordered writing must survive full book save/load");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).isEmpty(), "Cover must be consumed once");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).isEmpty(), "Link Panel must be consumed once");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.FIRST_PAGE).isEmpty(), "Pages must be consumed once");
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty(), "No duplicate output may remain");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void linkPanelOnlyCreatesCompletedRandomAgeBook(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Random Binder Age");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        menu.clicked(BookBinderMenu.RESULT, 0, ClickType.PICKUP, player);
+        ItemStack book = menu.getCarried();
+        AgeReference age = book.get(ModDataComponents.AGE_REFERENCE.get());
+        helper.assertTrue(age != null, "Link-Panel-only output must be written, not unwritten");
+        helper.assertValueEqual(age.name(), "Random Binder Age", "The assigned title must name the Age");
+        helper.assertValueEqual(book.get(ModDataComponents.BOOK_WRITING.get()).entries().size(), 1,
+                "A random Age book must contain only its Link Panel when no symbols are supplied");
+        helper.assertTrue(AgeRegistrySavedData.get(helper.getLevel()).find(age.id()).isPresent(),
+                "Taking the book must register its random Age definition");
+        helper.assertTrue(AgeDimensionService.resolve(player, age).isPresent(),
+                "The completed book must resolve to a usable random Age");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void notebookImportPreservesOrderAndRejectsOverflow(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        ItemStack notebook = new ItemStack(ModItems.NOTEBOOK.get());
+        notebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(
+                PageItem.createLinkPanelPage(), terrainPage(), weatherPage())));
+        binder.setItem(BookBinderBlockEntity.NOTEBOOK, notebook);
+        helper.assertTrue(binder.importNotebook(), "Notebook pages must import together");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
+                "Imported Link Panel must use its dedicated slot");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE), terrainPage()),
+                "First Notebook symbol must stay first");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1), weatherPage()),
+                "Second Notebook symbol must stay second");
+        helper.assertValueEqual(binder.getItem(BookBinderBlockEntity.NOTEBOOK)
+                .getOrDefault(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pageCount(), 0,
+                "Empty Notebook cover must remain recoverable");
+        for (int slot = BookBinderBlockEntity.FIRST_PAGE + 2; slot < BookBinderBlockEntity.SIZE; slot++)
+            binder.setItem(slot, terrainPage());
+        ItemStack overflow = new ItemStack(ModItems.NOTEBOOK.get());
+        overflow.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(weatherPage())));
+        binder.setItem(BookBinderBlockEntity.NOTEBOOK, overflow);
+        helper.assertFalse(binder.importNotebook(), "Full binder must reject Notebook import");
+        helper.assertValueEqual(binder.getItem(BookBinderBlockEntity.NOTEBOOK)
+                .getOrDefault(ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pageCount(), 1,
+                "Rejected import must preserve the Notebook page");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void pageControlsAndBreakingPreserveStoredInputs(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        helper.assertFalse(menu.clickMenuButton(player, BookBinderMenu.MOVE_PREVIOUS),
+                "Move without selection must be rejected");
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.SELECT_BASE), "Page selection must succeed");
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.MOVE_NEXT), "Page move must succeed");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.FIRST_PAGE).isEmpty(), "Old position must be empty");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1), terrainPage()),
+                "Moved page must keep its data");
+        helper.assertFalse(menu.clickMenuButton(player, 999), "Unknown action must be rejected");
+        BlockPos pos = binder.getBlockPos();
+        helper.getLevel().setBlock(pos, Blocks.AIR.defaultBlockState(), 3);
+        helper.assertFalse(menu.stillValid(player), "Removed binder must invalidate the menu");
+        var drops = helper.getLevel().getEntitiesOfClass(ItemEntity.class, new AABB(pos).inflate(2));
+        int leather = drops.stream().filter(entity -> entity.getItem().is(Items.LEATHER))
+                .mapToInt(entity -> entity.getItem().getCount()).sum();
+        int pages = drops.stream().filter(entity -> entity.getItem().is(ModItems.PAGE.get()))
+                .mapToInt(entity -> entity.getItem().getCount()).sum();
+        helper.assertValueEqual(leather, 1, "Cover must drop once");
+        helper.assertValueEqual(pages, 2, "Link Panel and writing page must drop once each");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void fullInventoryCannotConsumeBinderInputs(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Full Inventory");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        for (int slot = 0; slot < 36; slot++)
+            player.getInventory().setItem(slot, new ItemStack(Items.COBBLESTONE, 64));
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        helper.assertTrue(menu.quickMoveStack(player, BookBinderMenu.RESULT).isEmpty(),
+                "Full inventory must reject output transfer");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
+                "Rejected transfer must preserve cover");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
+                "Rejected transfer must preserve Link Panel");
+        helper.assertTrue(menu.getSlot(BookBinderMenu.RESULT).hasItem(),
+                "Result must remain available after inventory space is freed");
+        helper.assertFalse(menu.setTitle(player, "A title that is much too long for the binder slot"),
+                "Oversized title packet must be rejected");
+        helper.assertValueEqual(binder.title(), "Full Inventory", "Rejected title must preserve existing title");
+        helper.succeed();
+    }
+
+    public static void forgedBinderActionsAndReplayedOutputCannotDuplicateBook(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setTitle("Single Assembly");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        var first = helper.makeMockServerPlayerInLevel();
+        var second = helper.makeMockServerPlayerInLevel();
+        for (var player : List.of(first, second)) player.moveTo(binder.getBlockPos().getX() + 0.5,
+                binder.getBlockPos().getY() + 0.5, binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu firstMenu = new BookBinderMenu(1, first.getInventory(), binder);
+        BookBinderMenu secondMenu = new BookBinderMenu(2, second.getInventory(), binder);
+        helper.assertFalse(firstMenu.clickMenuButton(first, BookBinderMenu.SELECT_BASE + BookBinderBlockEntity.PAGE_COUNT),
+                "A fabricated page selection must be rejected");
+        helper.assertFalse(firstMenu.clickMenuButton(first, BookBinderMenu.STRIP_CLICK_BASE
+                + BookBinderBlockEntity.PAGE_COUNT + 1), "A fabricated strip address must be rejected");
+        helper.assertTrue(firstMenu.quickMoveStack(first, BookBinderMenu.RESULT).is(ModItems.DESCRIPTIVE_BOOK.get()),
+                "The first viewer must receive the single assembled book");
+        helper.assertTrue(secondMenu.quickMoveStack(second, BookBinderMenu.RESULT).isEmpty(),
+                "Another viewer must not take a stale result");
+        helper.assertTrue(firstMenu.quickMoveStack(first, BookBinderMenu.RESULT).isEmpty(),
+                "Replaying the output request must not create a second book");
+        int books = first.getInventory().items.stream().filter(stack -> stack.is(ModItems.DESCRIPTIVE_BOOK.get()))
+                .mapToInt(ItemStack::getCount).sum();
+        helper.assertValueEqual(books, 1, "Only one completed book may be emitted");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).isEmpty(), "Cover must be consumed once");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).isEmpty(), "Panel must be consumed once");
+        helper.getLevel().setBlock(binder.getBlockPos(), Blocks.AIR.defaultBlockState(), 3);
+        helper.assertFalse(firstMenu.clickMenuButton(first, BookBinderMenu.IMPORT_NOTEBOOK),
+                "A stale binder menu must reject packets after block removal");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void legacyStripInsertsAndRemovesPagesInOrder(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        menu.setCarried(PageItem.createLinkPanelPage());
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE),
+                "The first thumbnail must accept a Link Panel");
+        helper.assertTrue(menu.getCarried().isEmpty(), "Inserted panel must leave the cursor");
+        menu.setCarried(terrainPage());
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE + 1),
+                "The strip must accept a written Page");
+        menu.setCarried(weatherPage());
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE + 1),
+                "Inserting before a Page must shift it right");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE), weatherPage()),
+                "Inserted Page must be first");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1), terrainPage()),
+                "Existing Page must move right");
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE + 1),
+                "Clicking a thumbnail with an empty cursor must take the Page");
+        helper.assertTrue(ItemStack.matches(menu.getCarried(), weatherPage()),
+                "Removed Page must return to the cursor");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE), terrainPage()),
+                "Removal must close the gap");
+        helper.assertFalse(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE),
+                "A symbol Page must not replace the Link Panel");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void legacyStripImportsNotebookAtClickedPosition(GameTestHelper helper) {
+        BookBinderBlockEntity binder = place(helper);
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(binder.getBlockPos().getX() + 0.5, binder.getBlockPos().getY() + 0.5,
+                binder.getBlockPos().getZ() + 0.5);
+        BookBinderMenu menu = new BookBinderMenu(1, player.getInventory(), binder);
+        ItemStack notebook = new ItemStack(ModItems.NOTEBOOK.get());
+        notebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(weatherPage())));
+        menu.setCarried(notebook);
+        helper.assertTrue(menu.clickMenuButton(player, BookBinderMenu.STRIP_CLICK_BASE + 1),
+                "Notebook pages must import where clicked");
+        helper.assertValueEqual(menu.getCarried().getOrDefault(
+                ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pageCount(), 0,
+                "The empty Notebook must remain on the cursor");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE), weatherPage()),
+                "Imported Page must occupy the clicked position");
+        helper.assertTrue(ItemStack.matches(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1), terrainPage()),
+                "Existing Page must shift right");
+        helper.succeed();
+    }
+}

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

@@ -0,0 +1,109 @@
+package net.dnorberg.rivencraft.gametest;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Small default smoke suite; the detailed milestone regressions are opt-in. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class CoreGameTests {
+    private CoreGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void previewBackendSelection(GameTestHelper helper) {
+        LinkingGameTests.previewBackendSelectionCoversOptionalDependencyMatrix(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void linkTargetPersistence(GameTestHelper helper) {
+        LinkingGameTests.linkTargetSurvivesItemSerialization(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void deterministicAgeDefinition(GameTestHelper helper) {
+        LinkingGameTests.ageDefinitionIsCreatedOnceWithDeterministicData(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void blockedLinkDestination(GameTestHelper helper) {
+        LinkingGameTests.travelRejectsBlockedDestination(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void legacyWritingAndPageFreeBooks(GameTestHelper helper) {
+        WritingDataGameTests.oldBareListWritingAndPageFreeBooksRemainReadable(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void pagePersistenceAndUnknownSymbols(GameTestHelper helper) {
+        WritingDataGameTests.pageItemPreservesContentAndRejectsForgedUnknownSymbols(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void semanticSymbolSchema(GameTestHelper helper) {
+        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);
+    }
+
+    @GameTest(template = "empty")
+    public static void deskCopyTransaction(GameTestHelper helper) {
+        WritingDeskGameTests.takingCopySpendsPaperAndOneInkThenReturnsGlassBottle(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void deskRejectsForgedAndStaleActions(GameTestHelper helper) {
+        WritingDeskGameTests.forgedDeskSelectionsAndStaleMenuCannotCopy(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void twoBlockDeskDropsOnce(GameTestHelper helper) {
+        WritingDeskGameTests.twoBlockDeskSharesOneInventoryAndBreaksTogether(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void oldDeskMigration(GameTestHelper helper) {
+        WritingDeskGameTests.oldDeskInventoryMigratesAndAll88TabsPersist(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void binderKeepsMissingSymbolsRecoverable(GameTestHelper helper) {
+        BookBinderGameTests.missingSymbolPageSurvivesReloadButCannotBeAssembled(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void binderAssemblyTransaction(GameTestHelper helper) {
+        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);
+    }
+
+    @GameTest(template = "empty")
+    public static void mixerOutputTransaction(GameTestHelper helper) {
+        InkMixerGameTests.linkPanelRequiresTakingOutputAndPersistsInk(helper);
+    }
+
+    @GameTest(template = "empty")
+    public static void linkingBookRecipe(GameTestHelper helper) {
+        LinkingBookRecipeGameTests.legacyRecipeRequiresExactlyLeatherAndLinkPanel(helper);
+    }
+}

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

@@ -0,0 +1,111 @@
+package net.dnorberg.rivencraft.gametest;
+
+import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
+import net.dnorberg.rivencraft.menu.InkMixerMenu;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.WritingInkService;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.world.inventory.ClickType;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.entity.item.ItemEntity;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder("rivencraft_archive_mixer")
+@PrefixGameTestTemplate(false)
+public final class InkMixerGameTests {
+    private InkMixerGameTests() {}
+
+    private static InkMixerBlockEntity place(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.INK_MIXER.get().defaultBlockState(), 3);
+        return (InkMixerBlockEntity) helper.getLevel().getBlockEntity(pos);
+    }
+
+    public static void linkPanelRequiresTakingOutputAndPersistsInk(GameTestHelper helper) {
+        InkMixerBlockEntity mixer = place(helper);
+        mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+        mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(mixer.getBlockPos().getX() + 0.5, mixer.getBlockPos().getY() + 0.5,
+                mixer.getBlockPos().getZ() + 0.5);
+        InkMixerMenu menu = new InkMixerMenu(1, player.getInventory(), mixer);
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(InkMixerMenu.RESULT).getItem().is(ModItems.PAGE.get()),
+                "Paper and filled basin must preview a Link Panel");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 2,
+                "Preview must not consume paper");
+        helper.assertValueEqual(mixer.inkRemaining(), 16, "Vial must fill the basin");
+        helper.assertTrue(mixer.getItem(InkMixerBlockEntity.BOTTLES).is(Items.GLASS_BOTTLE),
+                "Consumed vial must return a vanilla glass bottle");
+        menu.clicked(InkMixerMenu.RESULT, 0, ClickType.PICKUP, player);
+        helper.assertTrue(menu.getCarried().is(ModItems.PAGE.get()), "Taking result must give a Link Panel");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
+                "Taking result must use exactly one paper");
+        helper.assertValueEqual(mixer.inkRemaining(), 16 - WritingInkService.linkPanelCost(),
+                "Taking result must spend the configured ink cost");
+        var saved = mixer.saveWithoutMetadata(helper.getLevel().registryAccess());
+        var restored = new InkMixerBlockEntity(mixer.getBlockPos(), ModBlocks.INK_MIXER.get().defaultBlockState());
+        restored.loadWithComponents(saved, helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.inkRemaining(), mixer.inkRemaining(), "Ink basin must persist");
+        helper.assertValueEqual(restored.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
+                "Paper input must persist");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void bottleCapacityBlocksAndThenPermitsRefill(GameTestHelper helper) {
+        InkMixerBlockEntity mixer = place(helper);
+        mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        mixer.setItem(InkMixerBlockEntity.BOTTLES, new ItemStack(Items.GLASS_BOTTLE, 64));
+        mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        helper.assertValueEqual(mixer.inkRemaining(), 0, "Full bottle output must block refill");
+        helper.assertTrue(mixer.getItem(InkMixerBlockEntity.INK).is(ModItems.INK_VIAL.get()),
+                "Blocked refill must preserve vial");
+        helper.assertFalse(mixer.canCreateLinkPanel(), "Blocked refill must suppress output");
+        mixer.removeItem(InkMixerBlockEntity.BOTTLES, 1);
+        helper.assertValueEqual(mixer.inkRemaining(), 16, "Making bottle space must immediately refill");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.BOTTLES).getCount(), 64,
+                "One bottle must be returned after refill");
+        helper.assertTrue(mixer.canCreateLinkPanel(), "Refill must enable Link Panel output");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void shiftClickNeedsInventorySpaceAndBreakingReturnsInputs(GameTestHelper helper) {
+        InkMixerBlockEntity mixer = place(helper);
+        mixer.setItem(InkMixerBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+        mixer.setItem(InkMixerBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(mixer.getBlockPos().getX() + 0.5, mixer.getBlockPos().getY() + 0.5,
+                mixer.getBlockPos().getZ() + 0.5);
+        InkMixerMenu menu = new InkMixerMenu(1, player.getInventory(), mixer);
+        for (int slot = 0; slot < 36; slot++) player.getInventory().setItem(slot, new ItemStack(Items.STONE, 64));
+        helper.assertTrue(menu.quickMoveStack(player, InkMixerMenu.RESULT).isEmpty(),
+                "Full inventory must not consume mixer output");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 2,
+                "Full inventory must preserve paper");
+        player.getInventory().setItem(0, ItemStack.EMPTY);
+        helper.assertTrue(menu.quickMoveStack(player, InkMixerMenu.RESULT).is(ModItems.PAGE.get()),
+                "Free inventory space must accept the Link Panel");
+        helper.assertValueEqual(mixer.getItem(InkMixerBlockEntity.PAPER).getCount(), 1,
+                "Shift-click must consume only one paper");
+        helper.getLevel().setBlock(mixer.getBlockPos(), Blocks.AIR.defaultBlockState(), 3);
+        helper.assertFalse(menu.stillValid(player), "Breaking the mixer must invalidate its menu");
+        var drops = helper.getLevel().getEntitiesOfClass(ItemEntity.class,
+                new AABB(mixer.getBlockPos()).inflate(2));
+        int paper = drops.stream().filter(entity -> entity.getItem().is(Items.PAPER))
+                .mapToInt(entity -> entity.getItem().getCount()).sum();
+        int bottles = drops.stream().filter(entity -> entity.getItem().is(Items.GLASS_BOTTLE))
+                .mapToInt(entity -> entity.getItem().getCount()).sum();
+        helper.assertValueEqual(paper, 1, "Breaking the mixer must return unused paper once");
+        helper.assertValueEqual(bottles, 1, "Breaking the mixer must return the consumed vial's bottle once");
+        helper.succeed();
+    }
+}

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

@@ -0,0 +1,65 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.LinkingBookRecipe;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.network.chat.Component;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.crafting.CraftingBookCategory;
+import net.minecraft.world.item.crafting.CraftingInput;
+import net.minecraft.world.item.crafting.RecipeType;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder("rivencraft_archive_recipe")
+@PrefixGameTestTemplate(false)
+public final class LinkingBookRecipeGameTests {
+    private LinkingBookRecipeGameTests() {}
+
+    public static void legacyRecipeRequiresExactlyLeatherAndLinkPanel(GameTestHelper helper) {
+        LinkingBookRecipe recipe = new LinkingBookRecipe(CraftingBookCategory.MISC);
+        ItemStack panel = PageItem.createLinkPanelPage();
+        CraftingInput valid = CraftingInput.of(2, 1, List.of(panel, new ItemStack(Items.LEATHER)));
+        helper.assertTrue(recipe.matches(valid, helper.getLevel()), "Link Panel and leather must match");
+        helper.assertTrue(recipe.matches(CraftingInput.of(2, 1,
+                List.of(new ItemStack(Items.LEATHER), panel)), helper.getLevel()),
+                "The Legacy recipe must be shapeless");
+        helper.assertFalse(recipe.matches(CraftingInput.of(2, 1,
+                List.of(new ItemStack(Items.BOOK), new ItemStack(Items.ENDER_PEARL))), helper.getLevel()),
+                "The old placeholder recipe must no longer match");
+        helper.assertFalse(recipe.matches(CraftingInput.of(2, 1,
+                List.of(new ItemStack(ModItems.PAGE.get()), new ItemStack(Items.LEATHER))), helper.getLevel()),
+                "A blank Page must not substitute for a Link Panel");
+        helper.assertFalse(recipe.matches(CraftingInput.of(3, 1,
+                List.of(panel, new ItemStack(Items.LEATHER), new ItemStack(Items.PAPER))), helper.getLevel()),
+                "An extra ingredient must invalidate the recipe");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void outputIsUnwrittenAndRegisteredRecipeLoads(GameTestHelper helper) {
+        ItemStack panel = PageItem.createLinkPanelPage();
+        panel.set(DataComponents.CUSTOM_NAME, Component.literal("Home Panel"));
+        CraftingInput input = CraftingInput.of(2, 1, List.of(panel, new ItemStack(Items.LEATHER)));
+        var holder = helper.getLevel().getRecipeManager()
+                .getRecipeFor(RecipeType.CRAFTING, input, helper.getLevel()).orElseThrow();
+        helper.assertValueEqual(holder.id(), ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "linking_book"),
+                "The registered recipe must replace the old placeholder");
+        ItemStack result = holder.value().assemble(input, helper.getLevel().registryAccess());
+        helper.assertTrue(result.is(ModItems.LINKING_BOOK.get()), "Crafting must produce a Linking Book");
+        helper.assertValueEqual(result.getCount(), 1, "Crafting must produce one book");
+        helper.assertFalse(result.has(ModDataComponents.LINK_TARGET.get()), "The book must be unwritten/unbound");
+        helper.assertFalse(result.has(ModDataComponents.PAGE_CONTENT.get()), "Page identity must not leak onto the book");
+        helper.assertValueEqual(result.get(DataComponents.CUSTOM_NAME), Component.literal("Home Panel"),
+                "The panel's custom name must survive crafting");
+        helper.succeed();
+    }
+}

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;
@@ -34,7 +37,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
 /** Server-side regression coverage for persistent linking-book data and travel safety. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_linking")
 @PrefixGameTestTemplate(false)
 public final class LinkingGameTests {
     private static final BlockPos ORIGIN = new BlockPos(0, 1, 0);
@@ -42,7 +45,6 @@ public final class LinkingGameTests {
     private LinkingGameTests() {
     }
 
-    @GameTest(template = "empty")
     public static void previewBackendSelectionCoversOptionalDependencyMatrix(GameTestHelper helper) {
         assertPreviewBackend(helper, RivencraftClientConfig.PreviewMode.AUTO, true, true,
                 PreviewBackendSelector.Backend.IMMERSIVE_PORTALS);
@@ -127,7 +129,6 @@ public final class LinkingGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void linkTargetSurvivesItemSerialization(GameTestHelper helper) {
         LinkTarget expected = new LinkTarget(
                 GlobalPos.of(helper.getLevel().dimension(), helper.absolutePos(ORIGIN)),
@@ -181,7 +182,6 @@ public final class LinkingGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void ageDefinitionIsCreatedOnceWithDeterministicData(GameTestHelper helper) {
         UUID ageId = UUID.randomUUID();
         String requestedName = "Test Age " + ageId;
@@ -421,46 +421,34 @@ public final class LinkingGameTests {
             }
             if (profile.equals(AgeGenerationProfiles.AMPLIFIED)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
-                helper.assertValueEqual(
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                        biomeSource.possibleBiomes().size(),
+                                && biomeSource.possibleBiomes().size() <= 4,
-                        2,
+                        "Random Tiled distribution must use two to four seeded biomes");
-                        "Tiled Biome Distribution must expose exactly two 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");
+                        "Adjacent 256-block Tiled squares must use different biomes");
-                helper.assertTrue(origin.equals(diagonalTile),
-                        "Diagonal 256-block Tiled squares must repeat the biome");
             }
             if (profile.equals(AgeGenerationProfiles.ISLAND)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
-                helper.assertValueEqual(
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                        biomeSource.possibleBiomes().size(),
+                                && biomeSource.possibleBiomes().size() <= 4,
-                        2,
+                        "Random Grid distribution must use two to four seeded biomes");
-                        "Grid Biome Distribution must expose exactly two 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");
+                        "Adjacent Grid chunks must use different biomes");
-                helper.assertTrue(origin.equals(diagonalChunk),
-                        "Diagonal Grid chunks must repeat the biome");
             }
             if (profile.equals(AgeGenerationProfiles.CAVE)) {
                 var biomeSource = level.getChunkSource().getGenerator().getBiomeSource();
                 helper.assertTrue(biomeSource instanceof net.dnorberg.rivencraft.world.ScaledBiomeSource,
                         "Tiny Biome Distribution must use the serializable scaled biome source");
-                helper.assertValueEqual(
+                helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                        biomeSource.possibleBiomes().size(),
+                                && biomeSource.possibleBiomes().size() <= 3,
-                        3,
+                        "Random cave Tiny distribution must use two to three eligible biomes");
-                        "Tiny Biome Distribution must expose exactly three seeded biomes"
-                );
                 java.util.Set<net.minecraft.core.Holder<net.minecraft.world.level.biome.Biome>> sampled =
                         new java.util.HashSet<>();
                 for (int x = -32; x <= 32; x += 4) {
@@ -534,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(
+            helper.assertTrue(biomeSource.possibleBiomes().size() >= 2
-                    biomeSource.possibleBiomes().size(),
+                            && biomeSource.possibleBiomes().size() <= 6,
-                    3,
+                    distribution + " random distribution must use two to six seeded biomes");
-                    distribution + " Biome Distribution must expose exactly three seeded biomes"
-            );
             helper.assertValueEqual(
                     ((net.dnorberg.rivencraft.world.ScaledBiomeSource)biomeSource).scale(),
                     scale,
@@ -556,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) {
+        var plan = new AgeGenerationPlan(AgeGenerationPlan.CURRENT_VERSION, seed, OrderedWriting.EMPTY,
-            seed++;
+                java.util.List.of(), AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD),
-        }
+                new AgeBiomeSelection(AgeTraits.BiomeDistribution.SINGLE, java.util.List.of(biome.location())));
         UUID id = UUID.randomUUID();
         AgeDefinition definition = new AgeDefinition(
                 id,
@@ -592,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");
@@ -666,7 +640,6 @@ public final class LinkingGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void travelRejectsBlockedDestination(GameTestHelper helper) {
         BlockPos absoluteOrigin = helper.absolutePos(ORIGIN);
         for (BlockPos position : BlockPos.betweenClosed(

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

@@ -1,12 +1,19 @@
 package net.dnorberg.rivencraft.gametest;
 
+import com.google.gson.JsonParser;
 import com.mojang.serialization.JsonOps;
 import io.netty.buffer.Unpooled;
+import java.util.Arrays;
 import java.util.List;
-import net.dnorberg.rivencraft.Rivencraft;
+import java.util.UUID;
+import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
+import net.dnorberg.rivencraft.writing.SymbolDefinition;
+import net.dnorberg.rivencraft.writing.SymbolSemantics;
+import net.dnorberg.rivencraft.writing.SymbolPoems;
+import net.dnorberg.rivencraft.writing.SymbolNumerals;
 import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.dnorberg.rivencraft.writing.NotebookContents;
@@ -29,7 +36,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
 /** Acceptance coverage for Milestone 4's persistent writing contracts. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_writing")
 @PrefixGameTestTemplate(false)
 public final class WritingDataGameTests {
     private WritingDataGameTests() {
@@ -46,6 +53,8 @@ public final class WritingDataGameTests {
         ));
 
         var json = OrderedWriting.CODEC.encodeStart(JsonOps.INSTANCE, original).result().orElseThrow();
+        helper.assertValueEqual(json.getAsJsonObject().get("schema_version").getAsInt(),
+                OrderedWriting.CURRENT_SCHEMA_VERSION, "Writing must save an explicit schema version");
         OrderedWriting persistentCopy = OrderedWriting.CODEC.parse(JsonOps.INSTANCE, json).result().orElseThrow();
         helper.assertValueEqual(persistentCopy, original,
                 "Persistent writing codec must retain entry order and unknown symbol IDs");
@@ -58,6 +67,27 @@ public final class WritingDataGameTests {
         helper.succeed();
     }
 
+    public static void oldBareListWritingAndPageFreeBooksRemainReadable(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(), WritingEntry.symbol(reference("example:removed_symbol"))));
+        var oldJson = WritingEntry.CODEC.listOf().encodeStart(JsonOps.INSTANCE, writing.entries())
+                .result().orElseThrow();
+        OrderedWriting migrated = OrderedWriting.CODEC.parse(JsonOps.INSTANCE, oldJson).result().orElseThrow();
+        helper.assertValueEqual(migrated, writing,
+                "0.3.7.2 bare-list writing must load into schema version 1 intact");
+
+        ItemStack oldPageFreeBook = new ItemStack(ModItems.DESCRIPTIVE_BOOK.get());
+        AgeReference originalAge = new AgeReference(UUID.randomUUID(), "Legacy Page-Free Age");
+        oldPageFreeBook.set(ModDataComponents.AGE_REFERENCE.get(), originalAge);
+        CompoundTag saved = (CompoundTag) oldPageFreeBook.saveOptional(helper.getLevel().registryAccess());
+        ItemStack restored = ItemStack.parseOptional(helper.getLevel().registryAccess(), saved);
+        helper.assertValueEqual(restored.get(ModDataComponents.AGE_REFERENCE.get()), originalAge,
+                "A page-free book must keep its existing Age identity");
+        helper.assertValueEqual(restored.getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY),
+                OrderedWriting.EMPTY, "Older page-free books must not require writing migration");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void serverCatalogResolvesBuiltinsAndKeepsUnknownReferencesReadable(GameTestHelper helper) {
         SymbolReference known = reference("rivencraft:terrain/standard");
@@ -76,6 +106,96 @@ 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();
+        helper.assertValueEqual(builtIn.schemaVersion(), 2, "Built-in symbol must use semantic schema v2");
+        helper.assertValueEqual(builtIn.semantics().orElseThrow().role(), SymbolSemantics.Role.TERRAIN,
+                "Built-in terrain symbol must declare its grammar role");
+        helper.assertValueEqual(builtIn.poem(), "Terrain Form Tradition Flow",
+                "Built-in page artwork must carry its four-word Legacy poem");
+        helper.assertValueEqual(SymbolPoems.builtIn(reference("rivencraft:terrain/standard").id()), builtIn.poem(),
+                "Pre-artwork saved starter pages must retain their original poem");
+        helper.assertTrue(Arrays.equals(SymbolNumerals.componentsForDigit(0), new int[] {1}),
+                "Zero must use Legacy's dedicated number mark");
+        helper.assertTrue(Arrays.equals(SymbolNumerals.componentsForDigit(1), new int[] {56}),
+                "One must use Legacy's first bottom-row mark");
+        helper.assertTrue(Arrays.equals(SymbolNumerals.componentsForDigit(24), new int[] {63, 59}),
+                "Twenty-four must combine Legacy's five and unit marks");
+        helper.assertTrue(Arrays.equals(SymbolNumerals.digitsFor(25), new int[] {1, 0}),
+                "Twenty-five must start a second base-25 place");
+        helper.assertTrue(Arrays.equals(SymbolNumerals.digitsFor(88), new int[] {3, 13}),
+                "Last writing-desk tab must retain its numeric value");
+
+        String display = "\"name\":\"symbol.example.test\","
+                + "\"description\":\"symbol.example.test.description\","
+                + "\"category\":\"example:terrain\"";
+        SymbolDefinition legacy = SymbolDefinition.parse(JsonParser.parseString(
+                "{\"schema_version\":1," + display + "}"));
+        helper.assertTrue(legacy.semantics().isEmpty(), "Existing v1 definitions must remain display-only");
+        SymbolDefinition oldCategory = SymbolDefinition.parse(JsonParser.parseString(
+                "{\"schema_version\":1,\"name\":\"symbol.example.test\","
+                        + "\"description\":\"symbol.example.test.description\","
+                        + "\"category\":\"terrain\"}"));
+        helper.assertValueEqual(oldCategory.category().toString(), "minecraft:terrain",
+                "A v1 category without a namespace must retain the old ResourceLocation behavior");
+        helper.assertValueEqual(legacy.display(reference("example:test").id()).id(),
+                reference("example:test").id(), "Display metadata must preserve the symbol ID");
+
+        SymbolDefinition period = SymbolDefinition.parse(JsonParser.parseString(
+                "{\"schema_version\":2," + display
+                        + ",\"semantics\":{\"role\":\"period_modifier\",\"value\":0}}"));
+        helper.assertValueEqual(period.semantics().orElseThrow().role(), SymbolSemantics.Role.PERIOD_MODIFIER,
+                "Zero-length modifier must be accepted");
+        rejectDefinition(helper, "{\"schema_version\":2," + display
+                + ",\"semantics\":{\"role\":\"unknown\",\"value\":\"normal\"}}", "role");
+        rejectDefinition(helper, "{\"schema_version\":2," + display
+                + ",\"semantics\":{\"role\":\"weather\",\"value\":\"blizzard\"}}", "value");
+        rejectDefinition(helper, "{\"schema_version\":2," + display
+                + ",\"semantics\":{\"role\":\"period_modifier\",\"value\":2.01}}", "value");
+        rejectDefinition(helper, "{\"schema_version\":2," + display
+                + ",\"semantics\":{\"role\":\"terrain\",\"value\":\"minecraft:overworld\",\"extra\":1}}", "extra");
+        rejectDefinition(helper, "{\"schema_version\":1," + display
+                + ",\"semantics\":{\"role\":\"weather\",\"value\":\"normal\"}}", "v1");
+
+        var clientJson = builtIn.display(reference("rivencraft:terrain/standard").id());
+        var encoded = net.dnorberg.rivencraft.writing.SymbolDisplayMetadata.CODEC
+                .encodeStart(JsonOps.INSTANCE, clientJson).result().orElseThrow();
+        helper.assertFalse(encoded.getAsJsonObject().has("semantics"),
+                "Client display payload must never contain generation semantics");
+        helper.assertValueEqual(encoded.getAsJsonObject().get("poem").getAsString(), builtIn.poem(),
+                "Client display payload must carry page artwork metadata");
+        rejectDefinition(helper, "{\"schema_version\":2," + display
+                + ",\"semantics\":{\"role\":\"weather\",\"value\":\"normal\"},\"poem\":\"only two\"}", "poem");
+        helper.succeed();
+    }
+
+    private static void rejectDefinition(GameTestHelper helper, String json, String diagnostic) {
+        boolean rejected = false;
+        try {
+            SymbolDefinition.parse(JsonParser.parseString(json));
+        } catch (IllegalArgumentException exception) {
+            rejected = exception.getMessage().contains(diagnostic);
+        }
+        helper.assertTrue(rejected, "Invalid symbol must be rejected with diagnostic containing '" + diagnostic + "'");
+    }
+
     @GameTest(template = "empty")
     public static void pageStatesPersistAndNetworkRoundTrip(GameTestHelper helper) {
         SymbolReference known = reference("rivencraft:terrain/standard");
@@ -100,7 +220,6 @@ public final class WritingDataGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void pageItemPreservesContentAndRejectsForgedUnknownSymbols(GameTestHelper helper) {
         SymbolReference known = reference("rivencraft:terrain/standard");
         SymbolReference unknown = reference("example:forged_symbol");
@@ -116,6 +235,10 @@ public final class WritingDataGameTests {
         );
 
         ItemStack recovered = PageItem.createRecoveredPage(unknown);
+        CompoundTag recoveredTag = (CompoundTag) recovered.saveOptional(helper.getLevel().registryAccess());
+        ItemStack restoredRecovered = ItemStack.parseOptional(helper.getLevel().registryAccess(), recoveredTag);
+        helper.assertValueEqual(PageItem.content(restoredRecovered).symbol().orElseThrow(), unknown,
+                "A missing symbol must survive a full Page item reload");
         helper.assertFalse(PageItem.isUsableWriting(recovered),
                 "An unresolved page must remain recoverable without becoming valid writing");
         try {
@@ -126,7 +249,6 @@ public final class WritingDataGameTests {
         }
     }
 
-    @GameTest(template = "empty")
     public static void notebookContentsPreserveOrderGapsNamesAndUnknownPages(GameTestHelper helper) {
         ItemStack first = PageItem.createSymbolPage(reference("rivencraft:terrain/standard"));
         first.set(net.minecraft.core.component.DataComponents.CUSTOM_NAME,
@@ -244,14 +366,14 @@ public final class WritingDataGameTests {
     @GameTest(template = "empty")
     public static void linkPanelPreparationConsumesOnePageAndConfiguredInkOnlyOnSuccess(GameTestHelper helper) {
         var player = helper.makeMockServerPlayerInLevel();
-        ItemStack pages = new ItemStack(ModItems.PAGE.get(), 2);
+        ItemStack pages = new ItemStack(Items.PAPER, 2);
         ItemStack vial = new ItemStack(ModItems.INK_VIAL.get());
         player.setItemInHand(InteractionHand.MAIN_HAND, vial);
         player.setItemInHand(InteractionHand.OFF_HAND, pages);
 
         helper.assertTrue(WritingInkService.prepareLinkPanel(player, InteractionHand.MAIN_HAND),
-                "A blank Page and sufficient ink must prepare one link panel");
+                "Paper and sufficient ink must prepare one link panel");
-        helper.assertValueEqual(pages.getCount(), 1, "Preparation must consume exactly one blank Page");
+        helper.assertValueEqual(pages.getCount(), 1, "Preparation must consume exactly one paper");
         helper.assertValueEqual(InkVialItem.remaining(player.getMainHandItem()),
                 InkVialItem.CAPACITY - WritingInkService.linkPanelCost(),
                 "Preparation must consume exactly the server-configured ink cost");
@@ -274,14 +396,14 @@ public final class WritingDataGameTests {
         ItemStack lowInk = new ItemStack(ModItems.INK_VIAL.get());
         lowInk.set(ModDataComponents.INK_REMAINING.get(), WritingInkService.linkPanelCost() - 1);
         player.setItemInHand(InteractionHand.MAIN_HAND, lowInk);
-        player.setItemInHand(InteractionHand.OFF_HAND, new ItemStack(ModItems.PAGE.get()));
+        player.setItemInHand(InteractionHand.OFF_HAND, new ItemStack(Items.PAPER));
         helper.assertFalse(WritingInkService.prepareLinkPanel(player, InteractionHand.MAIN_HAND),
                 "Insufficient ink must reject link-panel preparation");
         helper.assertValueEqual(InkVialItem.remaining(player.getMainHandItem()),
                 WritingInkService.linkPanelCost() - 1,
                 "Insufficient ink must remain untouched");
-        helper.assertValueEqual(PageItem.content(player.getOffhandItem()).kind(), PageContent.Kind.BLANK,
+        helper.assertTrue(player.getOffhandItem().is(Items.PAPER),
-                "Insufficient ink must leave the Page blank");
+                "Insufficient ink must leave paper untouched");
 
         lowInk.set(ModDataComponents.INK_REMAINING.get(), WritingInkService.linkPanelCost());
         helper.assertTrue(WritingInkService.prepareLinkPanel(player, InteractionHand.MAIN_HAND),
@@ -290,7 +412,7 @@ public final class WritingDataGameTests {
                 "A depleted Ink Vial must return a reusable glass bottle");
         helper.assertValueEqual(PageItem.content(player.getOffhandItem()).kind(),
                 PageContent.Kind.LINK_PANEL,
-                "A single blank Page must be replaced by one Link Panel Page");
+                "A single paper must be replaced by one Link Panel Page");
         helper.succeed();
     }
 
@@ -298,7 +420,7 @@ public final class WritingDataGameTests {
     public static void stackedInkVialsSplitWithoutChangingTheOtherVials(GameTestHelper helper) {
         var player = helper.makeMockServerPlayerInLevel();
         player.setItemInHand(InteractionHand.MAIN_HAND, new ItemStack(ModItems.INK_VIAL.get(), 2));
-        player.setItemInHand(InteractionHand.OFF_HAND, new ItemStack(ModItems.PAGE.get()));
+        player.setItemInHand(InteractionHand.OFF_HAND, new ItemStack(Items.PAPER));
 
         helper.assertTrue(WritingInkService.prepareLinkPanel(player, InteractionHand.MAIN_HAND),
                 "A stack of full vials must support preparing one panel");

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

@@ -1,21 +1,31 @@
 package net.dnorberg.rivencraft.gametest;
 
-import net.dnorberg.rivencraft.Rivencraft;
+import java.util.List;
 import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
+import net.dnorberg.rivencraft.block.WritingDeskBlock;
 import net.dnorberg.rivencraft.menu.WritingDeskMenu;
+import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingDeskCatalog;
 import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.resources.ResourceLocation;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.world.entity.item.ItemEntity;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.inventory.ClickType;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.phys.AABB;
 import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_desk")
 @PrefixGameTestTemplate(false)
 public final class WritingDeskGameTests {
     private WritingDeskGameTests() {}
@@ -26,7 +36,7 @@ public final class WritingDeskGameTests {
         var original = new WritingDeskBlockEntity(pos, ModBlocks.WRITING_DESK.get().defaultBlockState());
         original.setItem(0, new ItemStack(ModItems.NOTEBOOK.get()));
         original.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
-        original.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(ModItems.PAGE.get(), 12));
+        original.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 12));
         original.setActiveCollection(2);
         var saved = original.saveWithoutMetadata(helper.getLevel().registryAccess());
         var restored = new WritingDeskBlockEntity(pos, ModBlocks.WRITING_DESK.get().defaultBlockState());
@@ -46,14 +56,14 @@ public final class WritingDeskGameTests {
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
         desk.setItem(0, new ItemStack(ModItems.NOTEBOOK.get()));
         desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
-        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(ModItems.PAGE.get(), 12));
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 12));
         helper.getLevel().setBlock(pos, Blocks.AIR.defaultBlockState(), 3);
         var drops = helper.getLevel().getEntitiesOfClass(ItemEntity.class, new AABB(pos).inflate(2));
         int notebooks = drops.stream().filter(e -> e.getItem().is(ModItems.NOTEBOOK.get())).mapToInt(e -> e.getItem().getCount()).sum();
-        int ink = drops.stream().filter(e -> e.getItem().is(ModItems.INK_VIAL.get())).mapToInt(e -> e.getItem().getCount()).sum();
+        int bottles = drops.stream().filter(e -> e.getItem().is(Items.GLASS_BOTTLE)).mapToInt(e -> e.getItem().getCount()).sum();
-        int pages = drops.stream().filter(e -> e.getItem().is(ModItems.PAGE.get())).mapToInt(e -> e.getItem().getCount()).sum();
+        int pages = drops.stream().filter(e -> e.getItem().is(Items.PAPER)).mapToInt(e -> e.getItem().getCount()).sum();
         helper.assertValueEqual(notebooks, 1, "Notebook must drop exactly once");
-        helper.assertValueEqual(ink, 1, "Ink must drop exactly once");
+        helper.assertValueEqual(bottles, 1, "Consumed vial must return one glass bottle on break");
         helper.assertValueEqual(pages, 12, "Pages must drop without loss");
         helper.succeed();
     }
@@ -65,21 +75,572 @@ public final class WritingDeskGameTests {
         WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
         var player = helper.makeMockServerPlayerInLevel();
         player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
-        player.getInventory().setItem(9, new ItemStack(ModItems.PAGE.get(), 12));
+        player.getInventory().setItem(9, new ItemStack(Items.PAPER, 12));
         WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
         helper.assertTrue(menu.stillValid(player), "Placed desk must keep its menu valid");
         helper.assertTrue(menu.clickMenuButton(player, 3), "Active collection control must accept a valid tab");
         helper.assertValueEqual(desk.activeCollection(), 3, "Selected tab must be stored on the desk");
-        menu.quickMoveStack(player, 8);
+        menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT + 1);
         helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 12, "Shift-click must deposit all pages");
         helper.assertTrue(player.getInventory().getItem(9).isEmpty(), "Shift-click must consume player source stack");
         menu.quickMoveStack(player, WritingDeskBlockEntity.PAPER);
         helper.assertTrue(desk.getItem(WritingDeskBlockEntity.PAPER).isEmpty(), "Shift-click must empty desk source slot");
-        int total = player.getInventory().items.stream().filter(stack -> stack.is(ModItems.PAGE.get()))
+        int total = player.getInventory().items.stream().filter(stack -> stack.is(Items.PAPER))
                 .mapToInt(ItemStack::getCount).sum();
         helper.assertValueEqual(total, 12, "Round-trip must not lose or duplicate pages");
         helper.getLevel().setBlock(pos, Blocks.AIR.defaultBlockState(), 3);
         helper.assertFalse(menu.stillValid(player), "Removed desk must invalidate menu");
         helper.succeed();
     }
+
+    public static void takingCopySpendsPaperAndOneInkThenReturnsGlassBottle(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ItemStack source = PageItem.createLinkPanelPage();
+        desk.setItem(0, source.copy());
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem().is(ModItems.PAGE.get()),
+                "A source page with paper and ink must preview one copy");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 2,
+                "Previewing must not consume paper");
+        helper.assertValueEqual(desk.inkRemaining(), 16, "Inserting a vial must fill the empty bar before copying");
+        menu.clicked(WritingDeskMenu.COPY_RESULT, 0, ClickType.PICKUP, player);
+        helper.assertTrue(menu.getCarried().is(ModItems.PAGE.get()), "Taking result must give the copied page");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 1,
+                "Taking a copy must consume one paper");
+        helper.assertValueEqual(desk.inkRemaining(), 15, "First copy must consume one ink");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.INK).isEmpty(), "Refill must consume one vial");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.RETURN).is(Items.GLASS_BOTTLE),
+                "Refill must return a vanilla glass bottle");
+        helper.assertTrue(desk.getItem(0).is(ModItems.PAGE.get()), "Source page must remain untouched");
+        helper.assertTrue(menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT).is(ModItems.PAGE.get()),
+                "A second copy must remain available from the same ink fill");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.PAPER).isEmpty(),
+                "Two copies must consume exactly two paper");
+        helper.assertValueEqual(desk.inkRemaining(), 14, "Two copies must spend exactly two of sixteen ink");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.RETURN).getCount(), 1,
+                "A second copy must not consume another vial");
+        var saved = desk.saveWithoutMetadata(helper.getLevel().registryAccess());
+        var restored = new WritingDeskBlockEntity(pos, ModBlocks.WRITING_DESK.get().defaultBlockState());
+        restored.loadWithComponents(saved, helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.inkRemaining(), 14, "Ink meter must persist across saves");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void emptyDeskInkBarRefillsWithoutCopying(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get(), 2));
+        helper.assertValueEqual(desk.inkRemaining(), 16, "Inserting a vial must refill immediately");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.INK).getCount(), 1,
+                "Refill must consume exactly one vial");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.RETURN).is(Items.GLASS_BOTTLE),
+                "Refill must put a vanilla glass bottle in the return slot");
+        helper.runAfterDelay(2, () -> {
+            helper.assertValueEqual(desk.inkRemaining(), 16, "Full bar must not refill again");
+            helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.INK).getCount(), 1,
+                    "Full bar must leave the second vial untouched");
+            helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.RETURN).getCount(), 1,
+                    "Full bar must not create another bottle");
+            helper.succeed();
+        });
+    }
+
+    @GameTest(template = "empty")
+    public static void emptyDeskInkBarWaitsForBottleSpace(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(WritingDeskBlockEntity.RETURN, new ItemStack(Items.GLASS_BOTTLE, 64));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        helper.assertValueEqual(desk.inkRemaining(), 0, "Full bottle slot must block automatic refill");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.INK).is(ModItems.INK_VIAL.get()),
+                "Blocked refill must preserve the vial");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.RETURN).getCount(), 64,
+                "Blocked refill must preserve the bottle stack");
+        desk.removeItem(WritingDeskBlockEntity.RETURN, 1);
+        helper.assertValueEqual(desk.inkRemaining(), 16, "Removing a bottle must immediately permit refill");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.INK).isEmpty(),
+                "Refill must consume the waiting vial");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.RETURN).getCount(), 64,
+                "Refill must return one glass bottle to the available space");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void shiftClickCopiesOnlyWhenResourcesAndBottleSpaceExist(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 2));
+        desk.setItem(WritingDeskBlockEntity.RETURN, new ItemStack(Items.GLASS_BOTTLE, 64));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        helper.assertTrue(menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT).isEmpty(),
+                "Full bottle return must block refill without consuming supplies");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 2,
+                "Blocked copy must leave paper untouched");
+        desk.removeItem(WritingDeskBlockEntity.RETURN, 1);
+        ItemStack copied = menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT);
+        helper.assertTrue(copied.is(ModItems.PAGE.get()), "Shift-click must transfer one copy");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 1,
+                "Shift-click must consume one paper");
+        helper.assertValueEqual(desk.inkRemaining(), 15, "Shift-click must consume one ink");
+        int copies = player.getInventory().items.stream().filter(stack -> stack.is(ModItems.PAGE.get()))
+                .mapToInt(ItemStack::getCount).sum();
+        helper.assertValueEqual(copies, 1, "Shift-click must give exactly one page");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void selectedNotebookPageControlsCopyPreview(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ItemStack notebook = new ItemStack(ModItems.NOTEBOOK.get());
+        notebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(),
+                new NotebookContents(List.of(ItemStack.EMPTY, PageItem.createLinkPanelPage())));
+        desk.setItem(0, notebook);
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem().isEmpty(),
+                "An empty selected position must not create a copy");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.PAGE_BUTTON_BASE + 1), "Second page selection must be accepted");
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem().is(ModItems.PAGE.get()),
+                "Selecting the populated page must show a copy");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void twoViewersCannotTakeTheSameLastSheet(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var first = helper.makeMockServerPlayerInLevel();
+        var second = helper.makeMockServerPlayerInLevel();
+        first.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        second.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu firstMenu = new WritingDeskMenu(1, first.getInventory(), desk);
+        WritingDeskMenu secondMenu = new WritingDeskMenu(2, second.getInventory(), desk);
+        firstMenu.broadcastChanges();
+        secondMenu.broadcastChanges();
+        helper.assertTrue(firstMenu.quickMoveStack(first, WritingDeskMenu.COPY_RESULT).is(ModItems.PAGE.get()),
+                "First viewer should take the last available copy");
+        helper.assertTrue(secondMenu.quickMoveStack(second, WritingDeskMenu.COPY_RESULT).isEmpty(),
+                "Second viewer must not copy the already-consumed paper");
+        helper.assertTrue(firstMenu.quickMoveStack(first, WritingDeskMenu.COPY_RESULT).isEmpty(),
+                "Replaying the first viewer's output request must not make another page");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.PAPER).isEmpty(),
+                "Shared desk must spend paper only once");
+        helper.succeed();
+    }
+
+    public static void forgedDeskSelectionsAndStaleMenuCannotCopy(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.CATALOG_BUTTON_BASE + 999),
+                "A fabricated catalog index must be rejected");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.ALL_PAGE_BUTTON_BASE + 27),
+                "A fabricated page address must be rejected");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 0,
+                WritingDeskBlockEntity.PAPER)), "A page cannot be extracted into a material slot");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 1,
+                "Forged actions must not spend paper");
+        helper.assertTrue(desk.getItem(0).is(ModItems.PAGE.get()), "Forged actions must not remove the source");
+        helper.getLevel().setBlock(pos, Blocks.AIR.defaultBlockState(), 3);
+        helper.assertFalse(menu.clickMenuButton(player, 0), "A stale menu must reject selection packets");
+        helper.assertTrue(menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT).isEmpty(),
+                "A stale menu must reject output packets");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void catalogAggregatesKnownSymbolsAcrossCollections(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ResourceLocation known = ResourceLocation.parse("rivencraft:terrain/standard");
+        ItemStack page = PageItem.createSymbolPage(new SymbolReference(known));
+        ItemStack notebook = new ItemStack(ModItems.NOTEBOOK.get());
+        notebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(page.copy())));
+        desk.setItem(0, page);
+        desk.setItem(1, notebook);
+        helper.assertValueEqual(WritingDeskCatalog.available(desk).size(), 1,
+                "Duplicate symbols across loose pages and notebooks must appear once");
+        helper.assertValueEqual(WritingDeskCatalog.available(desk).getFirst().id(), known,
+                "Catalog must retain the authoritative symbol ID");
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.CATALOG_BUTTON_BASE + 1), "Out-of-range catalog index must be rejected");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.CATALOG_BUTTON_BASE), "Known catalog symbol must be selectable");
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        menu.broadcastChanges();
+        helper.assertTrue(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem().is(ModItems.PAGE.get()),
+                "Catalog selection must preview a copy of the known symbol");
+        desk.setItem(0, ItemStack.EMPTY);
+        desk.setItem(1, ItemStack.EMPTY);
+        menu.broadcastChanges();
+        helper.assertTrue(menu.catalog().isEmpty(), "Removed sources must invalidate catalog for the viewer");
+        helper.assertTrue(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem().isEmpty(),
+                "Removed sources must invalidate the copy output");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void fullInventoryCannotConsumeCopyMaterials(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(0, PageItem.createLinkPanelPage());
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        for (int i = 0; i < 36; i++) player.getInventory().setItem(i, new ItemStack(Items.COBBLESTONE, 64));
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        helper.assertTrue(menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT).isEmpty(),
+                "Full inventory must reject shift-click copy");
+        helper.assertValueEqual(desk.getItem(WritingDeskBlockEntity.PAPER).getCount(), 1,
+                "Rejected copy must preserve paper");
+        helper.assertValueEqual(desk.inkRemaining(), 16, "Rejected copy must preserve the filled ink meter");
+        helper.assertTrue(desk.getItem(WritingDeskBlockEntity.INK).isEmpty(),
+                "The vial should already have refilled the empty meter");
+        helper.succeed();
+    }
+
+    public static void twoBlockDeskSharesOneInventoryAndBreaksTogether(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        var block = ModBlocks.WRITING_DESK.get();
+        var state = block.defaultBlockState().setValue(WritingDeskBlock.FACING, Direction.NORTH);
+        helper.getLevel().setBlock(pos, state, 3);
+        block.setPlacedBy(helper.getLevel(), pos, state, null, new ItemStack(block));
+        BlockPos extension = pos.relative(Direction.EAST);
+        helper.assertTrue(helper.getLevel().getBlockState(extension).is(block),
+                "Placing a desk must reserve the adjacent second block");
+        helper.assertTrue(helper.getLevel().getBlockState(extension).getValue(WritingDeskBlock.EXTENSION),
+                "Adjacent half must be marked as an extension");
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        helper.assertTrue(helper.getLevel().getBlockEntity(extension) == null,
+                "Extension must not duplicate the inventory");
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER, 7));
+        helper.getLevel().destroyBlock(extension, true);
+        helper.assertTrue(helper.getLevel().getBlockState(pos).isAir(),
+                "Breaking the extension must remove the controller");
+        var drops = helper.getLevel().getEntitiesOfClass(ItemEntity.class, new AABB(pos).inflate(3));
+        int desks = drops.stream().filter(e -> e.getItem().is(block.asItem()))
+                .mapToInt(e -> e.getItem().getCount()).sum();
+        int paper = drops.stream().filter(e -> e.getItem().is(Items.PAPER))
+                .mapToInt(e -> e.getItem().getCount()).sum();
+        helper.assertValueEqual(desks, 1, "Breaking either half must drop one desk");
+        helper.assertValueEqual(paper, 7, "Breaking either half must drop stored paper once");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void breakingControllerRemovesExtensionWithoutDuplicateDesk(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        var block = ModBlocks.WRITING_DESK.get();
+        var state = block.defaultBlockState().setValue(WritingDeskBlock.FACING, Direction.NORTH);
+        helper.getLevel().setBlock(pos, state, 3);
+        block.setPlacedBy(helper.getLevel(), pos, state, null, new ItemStack(block));
+        BlockPos extension = pos.relative(Direction.EAST);
+        helper.getLevel().destroyBlock(pos, true);
+        helper.assertTrue(helper.getLevel().getBlockState(extension).isAir(),
+                "Breaking the controller must remove the extension");
+        var drops = helper.getLevel().getEntitiesOfClass(ItemEntity.class, new AABB(pos).inflate(3));
+        int desks = drops.stream().filter(e -> e.getItem().is(block.asItem()))
+                .mapToInt(e -> e.getItem().getCount()).sum();
+        helper.assertValueEqual(desks, 1, "Controller break must drop exactly one desk");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void openDeskDoesNotOccludeTerrain(GameTestHelper helper) {
+        helper.assertFalse(ModBlocks.WRITING_DESK.get().defaultBlockState().canOcclude(),
+                "Open shelves must not cull terrain behind the desk");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void allPagesSelectionUsesTheRequestedPhysicalTab(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        WritingDeskBlockEntity desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ItemStack first = PageItem.createLinkPanelPage();
+        ItemStack second = PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.parse("rivencraft:terrain/standard")));
+        desk.setItem(0, first);
+        ItemStack notebook = new ItemStack(ModItems.NOTEBOOK.get());
+        notebook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(),
+                new NotebookContents(List.of(ItemStack.EMPTY, second)));
+        desk.setItem(1, notebook);
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        WritingDeskMenu menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.ALL_PAGE_BUTTON_BASE + 2 * NotebookContents.MAX_PAGES),
+                "ALL view must reject empty cross-tab positions");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.ALL_PAGE_BUTTON_BASE + NotebookContents.MAX_PAGES + 1),
+                "ALL view must accept the populated second tab page");
+        helper.assertTrue(ItemStack.matches(menu.getSlot(WritingDeskMenu.COPY_RESULT).getItem(), second),
+                "Copy preview must match the physical page selected from the other tab");
+        helper.assertValueEqual(desk.activeCollection(), 0,
+                "Selecting from ALL must not silently change the active tab");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void tabGroupsCycleByFourAndProtectHiddenSlots(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        var menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        var otherViewer = new WritingDeskMenu(2, player.getInventory(), desk);
+        menu.clickMenuButton(player, WritingDeskMenu.PREVIOUS_TABS);
+        helper.assertValueEqual(menu.firstVisibleTab(), 0, "Previous must stop at tabs 1-4");
+        menu.clickMenuButton(player, WritingDeskMenu.NEXT_TABS);
+        helper.assertValueEqual(menu.firstVisibleTab(), 4, "Next must show tabs 5-8");
+        helper.assertValueEqual(otherViewer.firstVisibleTab(), 0, "Cycling must not move another viewer's slots");
+        helper.assertFalse(menu.getSlot(0).isActive(), "Earlier tab slots must be hidden");
+        helper.assertTrue(menu.getSlot(4).isActive(), "New group's slots must be interactive");
+        desk.setItem(0, new ItemStack(ModItems.NOTEBOOK.get()));
+        menu.clicked(0, 0, ClickType.PICKUP, player);
+        helper.assertTrue(menu.getCarried().isEmpty(), "Hidden slot clicks must not take items");
+        helper.assertTrue(menu.quickMoveStack(player, 0).isEmpty(), "Hidden shift-click must be rejected");
+        player.getInventory().setItem(9, new ItemStack(ModItems.NOTEBOOK.get()));
+        menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT + 1);
+        helper.assertTrue(desk.getItem(4).is(ModItems.NOTEBOOK.get()), "Shift-click must use the visible group");
+        for (int i = 0; i < 30; i++) menu.clickMenuButton(player, WritingDeskMenu.NEXT_TABS);
+        helper.assertValueEqual(menu.firstVisibleTab(), 84, "Last group must be tabs 85-88");
+        helper.assertTrue(menu.clickMenuButton(player, 87), "Tab 88 must be selectable without page-ID collisions");
+        helper.assertValueEqual(desk.activeCollection(), 87, "Tab 88 must become active");
+        helper.assertFalse(menu.clickMenuButton(player, 88), "Tab 89 must not exist");
+        desk.setItem(87, PageItem.createLinkPanelPage());
+        desk.setItem(WritingDeskBlockEntity.PAPER, new ItemStack(Items.PAPER));
+        desk.setItem(WritingDeskBlockEntity.INK, new ItemStack(ModItems.INK_VIAL.get()));
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.ALL_PAGE_BUTTON_BASE + 87 * NotebookContents.MAX_PAGES),
+                "ALL must select a physical page from tab 88");
+        helper.assertTrue(menu.quickMoveStack(player, WritingDeskMenu.COPY_RESULT).is(ModItems.PAGE.get()),
+                "Tab 88's page must be copyable");
+        menu.clickMenuButton(player, WritingDeskMenu.PREVIOUS_TABS);
+        helper.assertValueEqual(menu.firstVisibleTab(), 80, "Previous must move back four tabs");
+        helper.succeed();
+    }
+
+    public static void oldDeskInventoryMigratesAndAll88TabsPersist(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        var registries = helper.getLevel().registryAccess();
+        var oldItems = net.minecraft.core.NonNullList.withSize(8, ItemStack.EMPTY);
+        oldItems.set(0, new ItemStack(ModItems.NOTEBOOK.get()));
+        oldItems.set(3, PageItem.createLinkPanelPage());
+        oldItems.set(4, new ItemStack(ModItems.INK_VIAL.get(), 2));
+        oldItems.set(5, new ItemStack(Items.GLASS_BOTTLE, 3));
+        oldItems.set(6, new ItemStack(Items.PAPER, 12));
+        oldItems.set(7, PageItem.createLinkPanelPage());
+        var oldTag = new net.minecraft.nbt.CompoundTag();
+        net.minecraft.world.ContainerHelper.saveAllItems(oldTag, oldItems, registries);
+        oldTag.putInt("InkRemaining", 7);
+        oldTag.putInt("ActiveCollection", 3);
+        var desk = new WritingDeskBlockEntity(pos, ModBlocks.WRITING_DESK.get().defaultBlockState());
+        desk.loadWithComponents(oldTag, registries);
+        for (int i = 0; i < 4; i++) {
+            helper.assertTrue(ItemStack.matches(desk.getItem(i), oldItems.get(i)), "Original tab must survive migration");
+            helper.assertTrue(ItemStack.matches(desk.getItem(WritingDeskBlockEntity.INK + i), oldItems.get(4 + i)),
+                    "Original supplies and legacy output must survive migration");
+            helper.assertTrue(desk.getItem(4 + i).isEmpty(), "Supplies must not be duplicated into new tabs");
+        }
+        helper.assertValueEqual(desk.inkRemaining(), 7, "Migration must preserve ink meter");
+        helper.assertValueEqual(desk.activeCollection(), 3, "Migration must preserve active tab");
+        for (int i = 0; i < WritingDeskBlockEntity.COLLECTIONS; i++) desk.setItem(i, PageItem.createLinkPanelPage());
+        desk.setActiveCollection(87);
+        var restored = new WritingDeskBlockEntity(pos, ModBlocks.WRITING_DESK.get().defaultBlockState());
+        restored.loadWithComponents(desk.saveWithoutMetadata(registries), registries);
+        for (int i = 0; i < WritingDeskBlockEntity.COLLECTIONS; i++)
+            helper.assertTrue(restored.getItem(i).is(ModItems.PAGE.get()), "All 88 tab contents must survive save/load");
+        helper.assertValueEqual(restored.activeCollection(), 87, "Tab 88 selection must survive save/load");
+        helper.assertValueEqual(restored.getItem(WritingDeskBlockEntity.PAPER).getCount(), 12, "Reload must not repeat migration");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void surfacePlacesCarriedPagesWithoutLossOrOverwrite(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        desk.setItem(87, new ItemStack(ModItems.NOTEBOOK.get()));
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        var menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        ItemStack held = PageItem.createLinkPanelPage().copyWithCount(3);
+        ItemStack expectedPage = held.copyWithCount(1);
+        player.getInventory().setItem(9, held);
+        menu.clicked(WritingDeskMenu.COPY_RESULT + 1, 0, ClickType.PICKUP, player);
+        int lastPosition = WritingDeskMenu.PLACE_PAGE_BUTTON_BASE + 87 * NotebookContents.MAX_PAGES + 26;
+        helper.assertTrue(menu.clickMenuButton(player, lastPosition), "Surface must place into final notebook position");
+        helper.assertValueEqual(menu.getCarried().getCount(), 2, "Placing must consume exactly one held page");
+        var pages = desk.getItem(87).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
+        helper.assertValueEqual(pages.size(), 27, "Placement must preserve addressed position");
+        helper.assertTrue(pages.get(0).isEmpty() && pages.get(25).isEmpty(), "Placement must preserve preceding gaps");
+        helper.assertTrue(ItemStack.matches(pages.get(26), expectedPage), "Stored page must preserve components");
+        helper.assertFalse(menu.clickMenuButton(player, lastPosition), "Occupied position must not be overwritten");
+        helper.assertValueEqual(menu.getCarried().getCount(), 2, "Rejected placement must preserve cursor");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE + 88 * NotebookContents.MAX_PAGES),
+                "Out-of-range placement must be rejected");
+        helper.assertValueEqual(menu.pageCapacity(87), NotebookContents.MAX_PAGES, "Notebook tab must expose normal notebook capacity");
+        helper.assertValueEqual(menu.pageCapacity(0), 0, "Empty tab has no page storage");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE), "Empty tab must require a collection first");
+        desk.setItem(0, PageItem.createLinkPanelPage());
+        helper.assertValueEqual(menu.pageCapacity(0), 1, "Loose page tab must expose exactly one position");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE), "Loose page must not be replaced");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.PLACE_PAGE_BUTTON_BASE + 1), "Loose page tab must not grow extra positions");
+        helper.assertValueEqual(menu.getCarried().getCount(), 2, "Rejected placements must preserve cursor");
+        helper.assertTrue(menu.clickMenuButton(player, lastPosition - 1), "A second empty notebook position must accept a page");
+        helper.assertTrue(menu.clickMenuButton(player, lastPosition - 2), "A third empty notebook position must accept the last page");
+        helper.assertTrue(menu.getCarried().isEmpty(), "Final placement must clear cursor");
+        menu.setCarried(new ItemStack(Items.DIAMOND));
+        helper.assertFalse(menu.clickMenuButton(player, lastPosition - 3), "Non-page items must be rejected");
+        helper.assertTrue(menu.getCarried().is(Items.DIAMOND), "Rejected item must remain held");
+        var restored = new WritingDeskBlockEntity(pos, ModBlocks.WRITING_DESK.get().defaultBlockState());
+        restored.loadWithComponents(desk.saveWithoutMetadata(helper.getLevel().registryAccess()), helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.getItem(87).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pageCount(), 3,
+                "Placed pages must persist in the notebook");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void deskSurfaceDragMovesAndSwapsNotebookPages(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ItemStack linkPanel = PageItem.createLinkPanelPage();
+        ItemStack terrain = PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.parse("rivencraft:terrain/standard")));
+        ItemStack firstBook = new ItemStack(ModItems.NOTEBOOK.get());
+        firstBook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(linkPanel, terrain)));
+        desk.setItem(0, firstBook);
+        desk.setItem(1, new ItemStack(ModItems.NOTEBOOK.get()));
+        desk.setItem(2, PageItem.createLinkPanelPage());
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        var menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        int moveToEmpty = WritingDeskMenu.movePageButtonId(0, 0, 0, 26);
+        helper.assertTrue(menu.clickMenuButton(player, moveToEmpty), "Drag must move to a distant empty notebook position");
+        var pages = desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
+        helper.assertTrue(pages.get(0).isEmpty(), "Moving must clear the source position");
+        helper.assertTrue(ItemStack.matches(pages.get(26), linkPanel), "Moving must preserve page components");
+        helper.assertValueEqual(desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pageCount(), 2,
+                "Moving must preserve total page count");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 26, 0, 1)),
+                "Drag onto an occupied position must swap pages");
+        pages = desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
+        helper.assertTrue(ItemStack.matches(pages.get(1), linkPanel) && ItemStack.matches(pages.get(26), terrain),
+                "Swap must preserve both pages");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 1, 1, 5)),
+                "Drag into another notebook must work");
+        var otherPages = desk.getItem(1).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
+        helper.assertTrue(ItemStack.matches(otherPages.get(5), linkPanel)
+                && desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages().get(1).isEmpty(),
+                "Cross notebook move must have one destination and no old source");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(0, 1, 1, 6)),
+                "Dragging an empty source must be rejected");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(2, 0, 1, 6)),
+                "A loose page should move into a notebook position");
+        helper.assertTrue(desk.getItem(2).isEmpty()
+                && desk.getItem(1).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages().get(6).is(ModItems.PAGE.get()),
+                "Moving a loose page must empty its tab without losing the item");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(1, 5, 1, 5)),
+                "A no-op drag must be rejected");
+        menu.setCarried(new ItemStack(Items.DIAMOND));
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.movePageButtonId(1, 5, 1, 6)),
+                "Held inventory items must not be moved by a panel drag");
+        helper.assertTrue(ItemStack.matches(desk.getItem(1).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages().get(5), linkPanel),
+                "Rejected drags must leave notebook data intact");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void deskSurfaceDragExtractsPagesToInventoryAndTabs(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.WRITING_DESK.get().defaultBlockState(), 3);
+        var desk = (WritingDeskBlockEntity) helper.getLevel().getBlockEntity(pos);
+        ItemStack page = PageItem.createLinkPanelPage();
+        ItemStack source = new ItemStack(ModItems.NOTEBOOK.get());
+        source.set(ModDataComponents.NOTEBOOK_CONTENTS.get(),
+                new NotebookContents(List.of(page, page, page, page, page, page)));
+        desk.setItem(0, source);
+        ItemStack otherBook = new ItemStack(ModItems.NOTEBOOK.get());
+        ItemStack terrain = PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.parse("rivencraft:terrain/standard")));
+        otherBook.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(List.of(terrain)));
+        desk.setItem(2, otherBook);
+        var player = helper.makeMockServerPlayerInLevel();
+        player.moveTo(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        player.getInventory().setItem(10, page.copyWithCount(2));
+        var menu = new WritingDeskMenu(1, player.getInventory(), desk);
+        int inventoryStart = WritingDeskMenu.COPY_RESULT + 1;
+
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 0, -1)),
+                "Dropping away from a slot must return the page to the cursor");
+        helper.assertTrue(ItemStack.matches(menu.getCarried(), page), "Cursor must hold the original page item");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 1, inventoryStart)),
+                "Extraction must not replace an occupied cursor");
+        menu.setCarried(ItemStack.EMPTY);
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 1, inventoryStart)),
+                "Dropping on player inventory must transfer a page");
+        helper.assertTrue(ItemStack.matches(player.getInventory().getItem(9), page),
+                "Transferred page must retain its components");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 2, 1)),
+                "Dropping on an empty tab must store a loose page");
+        helper.assertTrue(ItemStack.matches(desk.getItem(1), page), "Tab must hold the extracted page");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 3, 2)),
+                "Dropping on a notebook tab must insert the page");
+        var otherPages = desk.getItem(2).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pages();
+        helper.assertTrue(ItemStack.matches(otherPages.get(0), terrain)
+                && ItemStack.matches(otherPages.get(1), page), "Notebook drop must preserve existing pages");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 4, inventoryStart + 1)),
+                "Dropping on a matching inventory stack must merge one page");
+        helper.assertValueEqual(player.getInventory().getItem(10).getCount(), 3, "Merge must add exactly one page");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 5, 1)),
+                "Occupied loose-page tabs must reject a drop");
+        helper.assertFalse(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(0, 5, WritingDeskBlockEntity.INK)),
+                "Ink slot must not accept an extracted page");
+        helper.assertValueEqual(desk.getItem(0).get(ModDataComponents.NOTEBOOK_CONTENTS.get()).pageCount(), 1,
+                "Rejected drops must leave the remaining source page in the notebook");
+        helper.assertTrue(menu.clickMenuButton(player, WritingDeskMenu.extractPageButtonId(1, 0, -1)),
+                "A loose page shown on the panel must be draggable back to the cursor");
+        helper.assertTrue(desk.getItem(1).isEmpty() && ItemStack.matches(menu.getCarried(), page),
+                "Extracting a loose page must empty its tab and return the same item");
+        helper.succeed();
+    }
 }

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,22 +1,36 @@
 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.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.component.CustomModelData;
 import net.minecraft.world.item.Item;
 import net.minecraft.world.item.ItemStack;
 import net.minecraft.world.item.TooltipFlag;
 
 /** One stackable Page item whose server-owned component identifies its writing state. */
 public final class PageItem extends Item {
+    private static final Map<String, SymbolDisplayMetadata> CREATIVE_SYMBOLS = loadCreativeSymbols();
+
     public PageItem(Properties properties) {
         super(properties);
     }
@@ -28,6 +42,65 @@ public final class PageItem extends Item {
         return create(PageContent.symbol(reference));
     }
 
+    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(metadata.id());
+        ItemStack page = create(PageContent.symbol(reference));
+        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);
     }
@@ -100,7 +173,6 @@ public final class PageItem extends Item {
     private static ItemStack create(PageContent content) {
         ItemStack stack = new ItemStack(ModItems.PAGE.get());
         stack.set(ModDataComponents.PAGE_CONTENT.get(), content);
-        stack.set(DataComponents.CUSTOM_MODEL_DATA, new CustomModelData(modelIndex(content)));
         if (content.kind() == PageContent.Kind.SYMBOL) {
             stack.set(ModDataComponents.PAGE_SYMBOL_DISPLAY.get(),
                     SymbolCatalog.display(content.symbol().orElseThrow()));
@@ -111,25 +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()
+        if (!metadata.resolved()) return Component.translatable("item.rivencraft.page.unresolved");
-                ? Component.translatable(metadata.nameTranslationKey())
+        return reference.id().getNamespace().equals(Rivencraft.MOD_ID)
-                : Component.translatable("item.rivencraft.page.unresolved");
+                && reference.id().getPath().startsWith("biome/")
+                ? Component.translatableWithFallback(metadata.nameTranslationKey(),
+                        BiomeSymbolPages.fallbackName(reference.id()))
+                : Component.translatable(metadata.nameTranslationKey());
     }
 
-    private static int modelIndex(PageContent content) {
-        return switch (content.kind()) {
-            case BLANK -> 0;
-            case LINK_PANEL -> 1;
-            case UNRESOLVED_SYMBOL -> 2;
-            case SYMBOL -> switch (content.symbol().orElseThrow().id().toString()) {
-                case "rivencraft:terrain/standard" -> 100;
-                case "rivencraft:biome/native" -> 101;
-                case "rivencraft:lighting/normal" -> 102;
-                case "rivencraft:weather/normal" -> 103;
-                case "rivencraft:celestial/normal_time" -> 104;
-                case "rivencraft:feature/caves" -> 105;
-                default -> 3;
-            };
-        };
-    }
 }

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

@@ -0,0 +1,248 @@
+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;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.ClickType;
+import net.minecraft.world.inventory.DataSlot;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Fixed, ordered binder slots and a server-owned virtual result. */
+public final class BookBinderMenu extends AbstractContainerMenu {
+    public static final int RESULT = BookBinderBlockEntity.SIZE;
+    public static final int SELECT_BASE = 100;
+    public static final int MOVE_PREVIOUS = 200;
+    public static final int MOVE_NEXT = 201;
+    public static final int IMPORT_NOTEBOOK = 202;
+    public static final int STRIP_CLICK_BASE = 300;
+    private static final int PLAYER_START = RESULT + 1;
+
+    private final BookBinderBlockEntity binder;
+    private final Container inputs;
+    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())
+                instanceof BookBinderBlockEntity found ? found : null);
+    }
+
+    public BookBinderMenu(int id, Inventory inventory, BookBinderBlockEntity binder) {
+        super(ModMenus.BOOK_BINDER.get(), id);
+        this.binder = binder;
+        inputs = binder == null ? new SimpleContainer(BookBinderBlockEntity.SIZE) : binder;
+        clientSide = inventory.player.level().isClientSide;
+        addDataSlot(new DataSlot() {
+            @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));
+        for (int page = 0; page < BookBinderBlockEntity.PAGE_COUNT; page++) {
+            addSlot(new BinderSlot(BookBinderBlockEntity.FIRST_PAGE + page, -1000, -1000, 1));
+        }
+        addSlot(new ResultSlot(result, 0, 152, 27));
+        for (int row = 0; row < 3; row++) {
+            for (int column = 0; column < 9; column++) {
+                addSlot(new Slot(inventory, column + row * 9 + 9, 8 + column * 18, 99 + row * 18));
+            }
+        }
+        for (int column = 0; column < 9; column++) {
+            addSlot(new Slot(inventory, column, 8 + column * 18, 157));
+        }
+        refreshResult();
+    }
+
+    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
+                || title.length() > BookBinderBlockEntity.MAX_TITLE_LENGTH) return false;
+        binder.setTitle(title);
+        refreshResult();
+        broadcastChanges();
+        return true;
+    }
+
+    @Override public boolean stillValid(Player player) {
+        return binder != null && binder.stillValid(player);
+    }
+
+    @Override public boolean clickMenuButton(Player player, int id) {
+        if (clientSide || !stillValid(player)) return false;
+        if (id >= STRIP_CLICK_BASE && id <= STRIP_CLICK_BASE + BookBinderBlockEntity.PAGE_COUNT) {
+            if (!clickStrip(id - STRIP_CLICK_BASE)) return false;
+        } else if (id >= SELECT_BASE && id < SELECT_BASE + BookBinderBlockEntity.PAGE_COUNT) {
+            selectedPage = id - SELECT_BASE;
+        } else if (id == MOVE_PREVIOUS || id == MOVE_NEXT) {
+            int target = selectedPage + (id == MOVE_PREVIOUS ? -1 : 1);
+            if (selectedPage < 0 || target < 0 || target >= BookBinderBlockEntity.PAGE_COUNT
+                    || binder.getItem(BookBinderBlockEntity.FIRST_PAGE + selectedPage).isEmpty()
+                    || !getCarried().isEmpty()) return false;
+            int fromSlot = BookBinderBlockEntity.FIRST_PAGE + selectedPage;
+            int toSlot = BookBinderBlockEntity.FIRST_PAGE + target;
+            ItemStack from = binder.getItem(fromSlot);
+            ItemStack to = binder.getItem(toSlot);
+            binder.setItem(fromSlot, to);
+            binder.setItem(toSlot, from);
+            selectedPage = target;
+        } else if (id == IMPORT_NOTEBOOK) {
+            if (!binder.importNotebook()) return false;
+        } else return false;
+        refreshResult();
+        broadcastChanges();
+        return true;
+    }
+
+    private boolean clickStrip(int index) {
+        ItemStack carried = getCarried();
+        if (carried.is(ModItems.NOTEBOOK.get())) {
+            ItemStack emptied = binder.importNotebookFromStack(carried, Math.min(index == 0 ? 0 : index - 1,
+                    binder.nextPageIndex()));
+            if (emptied.isEmpty()) return false;
+            setCarried(emptied);
+            return true;
+        }
+        if (!carried.isEmpty()) {
+            if (index == 0) {
+                if (!binder.getItem(BookBinderBlockEntity.LINK_PANEL).isEmpty()
+                        || !binder.canPlaceItem(BookBinderBlockEntity.LINK_PANEL, carried)) return false;
+                binder.setItem(BookBinderBlockEntity.LINK_PANEL, carried.copyWithCount(1));
+            } else if (!binder.insertPage(index - 1, carried.copyWithCount(1))) return false;
+            ItemStack remainder = carried.copy();
+            remainder.shrink(1);
+            setCarried(remainder);
+            return true;
+        }
+        ItemStack removed;
+        if (index == 0) {
+            removed = binder.removeItem(BookBinderBlockEntity.LINK_PANEL, 1);
+        } else {
+            removed = binder.takePage(index - 1);
+        }
+        if (removed.isEmpty()) return false;
+        setCarried(removed);
+        return true;
+    }
+
+    @Override public ItemStack quickMoveStack(Player player, int index) {
+        if (!stillValid(player) || index < 0 || index >= slots.size()) return ItemStack.EMPTY;
+        if (index == RESULT) {
+            refreshResult();
+            if (!binder.canAssemble()) return ItemStack.EMPTY;
+            ItemStack book = binder.previewBook();
+            ItemStack remainder = book.copy();
+            if (!moveItemStackTo(remainder, PLAYER_START, slots.size(), true) || !remainder.isEmpty()) {
+                return ItemStack.EMPTY;
+            }
+            binder.consumeAssembly();
+            refreshResult();
+            return book;
+        }
+        Slot sourceSlot = slots.get(index);
+        if (!sourceSlot.hasItem()) return ItemStack.EMPTY;
+        ItemStack source = sourceSlot.getItem();
+        ItemStack original = source.copy();
+        boolean moved;
+        if (index < RESULT) {
+            moved = moveItemStackTo(source, PLAYER_START, slots.size(), true);
+        } else if (source.is(Items.LEATHER) || BookBinderBlockEntity.validCover(source)) {
+            moved = moveItemStackTo(source, BookBinderBlockEntity.COVER, BookBinderBlockEntity.COVER + 1, false);
+        } else if (source.is(ModItems.NOTEBOOK.get())) {
+            ItemStack emptied = binder.importNotebookFromStack(source, binder.nextPageIndex());
+            if (emptied.isEmpty()) return ItemStack.EMPTY;
+            sourceSlot.setByPlayer(emptied);
+            refreshResult();
+            return original;
+        } else if (source.is(ModItems.PAGE.get())
+                && PageItem.content(source).kind() == PageContent.Kind.LINK_PANEL) {
+            moved = moveItemStackTo(source, BookBinderBlockEntity.LINK_PANEL,
+                    BookBinderBlockEntity.LINK_PANEL + 1, false);
+        } else if (source.is(ModItems.PAGE.get())) {
+            moved = moveItemStackTo(source, BookBinderBlockEntity.FIRST_PAGE, RESULT, false);
+        } else moved = false;
+        if (!moved) return ItemStack.EMPTY;
+        if (source.isEmpty()) sourceSlot.setByPlayer(ItemStack.EMPTY);
+        else sourceSlot.setChanged();
+        refreshResult();
+        return original;
+    }
+
+    @Override public void clicked(int slotId, int button, ClickType clickType, Player player) {
+        if (!stillValid(player)) {
+            player.closeContainer();
+            return;
+        }
+        refreshResult();
+        super.clicked(slotId, button, clickType, player);
+    }
+
+    @Override public void broadcastChanges() {
+        refreshResult();
+        super.broadcastChanges();
+    }
+
+    private void refreshResult() {
+        if (clientSide) return;
+        ItemStack preview = binder == null ? ItemStack.EMPTY : binder.previewBook();
+        if (!ItemStack.matches(result.getItem(0), preview)) result.setItem(0, preview);
+    }
+
+    private final class BinderSlot extends Slot {
+        private final int capacity;
+        private BinderSlot(int index, int x, int y, int capacity) {
+            super(inputs, index, x, y);
+            this.capacity = capacity;
+        }
+        @Override public boolean mayPlace(ItemStack stack) { return inputs.canPlaceItem(getContainerSlot(), stack); }
+        @Override public int getMaxStackSize() { return capacity; }
+    }
+
+    private final class ResultSlot extends Slot {
+        private ResultSlot(Container container, int index, int x, int y) { super(container, index, x, y); }
+        @Override public boolean mayPlace(ItemStack stack) { return false; }
+        @Override public boolean mayPickup(Player player) {
+            return clientSide ? hasItem() : stillValid(player) && binder.canAssemble();
+        }
+        @Override public void onTake(Player player, ItemStack stack) {
+            if (!clientSide && binder.consumeAssembly()) refreshResult();
+            super.onTake(player, stack);
+        }
+    }
+}

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

@@ -0,0 +1,119 @@
+package net.dnorberg.rivencraft.menu;
+
+import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.registry.ModMenus;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.world.Container;
+import net.minecraft.world.SimpleContainer;
+import net.minecraft.world.entity.player.Inventory;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.world.inventory.DataSlot;
+import net.minecraft.world.inventory.Slot;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Server-owned virtual output; taking it spends paper and the configured ink cost once. */
+public final class InkMixerMenu extends AbstractContainerMenu {
+    public static final int RESULT = InkMixerBlockEntity.SIZE;
+    private static final int PLAYER_START = RESULT + 1;
+    private final InkMixerBlockEntity mixer;
+    private final Container inputs;
+    private final SimpleContainer result = new SimpleContainer(1);
+    private final boolean clientSide;
+    private int inkRemaining;
+
+    public InkMixerMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
+        this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
+                instanceof InkMixerBlockEntity found ? found : null);
+    }
+
+    public InkMixerMenu(int id, Inventory inventory, InkMixerBlockEntity mixer) {
+        super(ModMenus.INK_MIXER.get(), id);
+        this.mixer = mixer;
+        inputs = mixer == null ? new SimpleContainer(InkMixerBlockEntity.SIZE) : mixer;
+        clientSide = inventory.player.level().isClientSide;
+        addDataSlot(new DataSlot() {
+            @Override public int get() { return clientSide ? inkRemaining : mixer.inkRemaining(); }
+            @Override public void set(int value) { inkRemaining = value; }
+        });
+        addSlot(new MixerSlot(InkMixerBlockEntity.INK, 8, 27));
+        addSlot(new MixerSlot(InkMixerBlockEntity.PAPER, 8, 48));
+        addSlot(new MixerSlot(InkMixerBlockEntity.BOTTLES, 152, 27));
+        addSlot(new ResultSlot(152, 48));
+        for (int row = 0; row < 3; row++)
+            for (int column = 0; column < 9; column++)
+                addSlot(new Slot(inventory, column + row * 9 + 9, 8 + column * 18, 99 + row * 18));
+        for (int column = 0; column < 9; column++)
+            addSlot(new Slot(inventory, column, 8 + column * 18, 157));
+        refreshResult();
+    }
+
+    public int inkRemaining() { return inkRemaining; }
+
+    @Override public boolean stillValid(Player player) {
+        return mixer != null && mixer.stillValid(player);
+    }
+
+    @Override public void broadcastChanges() {
+        refreshResult();
+        super.broadcastChanges();
+    }
+
+    private void refreshResult() {
+        if (clientSide) return;
+        ItemStack preview = mixer != null && mixer.canCreateLinkPanel()
+                ? PageItem.createLinkPanelPage() : ItemStack.EMPTY;
+        if (!ItemStack.matches(result.getItem(0), preview)) result.setItem(0, preview);
+    }
+
+    @Override public ItemStack quickMoveStack(Player player, int index) {
+        if (!stillValid(player) || index < 0 || index >= slots.size()) return ItemStack.EMPTY;
+        if (index == RESULT) {
+            refreshResult();
+            if (!mixer.canCreateLinkPanel()) return ItemStack.EMPTY;
+            ItemStack output = result.getItem(0).copy();
+            ItemStack remainder = output.copy();
+            if (!moveItemStackTo(remainder, PLAYER_START, slots.size(), true) || !remainder.isEmpty())
+                return ItemStack.EMPTY;
+            if (!mixer.consumeLinkPanelMaterials()) return ItemStack.EMPTY;
+            refreshResult();
+            return output;
+        }
+        Slot slot = slots.get(index);
+        if (!slot.hasItem()) return ItemStack.EMPTY;
+        ItemStack source = slot.getItem();
+        ItemStack original = source.copy();
+        boolean moved;
+        if (index < RESULT) moved = moveItemStackTo(source, PLAYER_START, slots.size(), true);
+        else if (source.is(ModItems.INK_VIAL.get()))
+            moved = moveItemStackTo(source, InkMixerBlockEntity.INK, InkMixerBlockEntity.INK + 1, false);
+        else if (source.is(Items.PAPER))
+            moved = moveItemStackTo(source, InkMixerBlockEntity.PAPER, InkMixerBlockEntity.PAPER + 1, false);
+        else moved = false;
+        if (!moved) return ItemStack.EMPTY;
+        if (source.isEmpty()) slot.setByPlayer(ItemStack.EMPTY);
+        else slot.setChanged();
+        refreshResult();
+        return original;
+    }
+
+    private final class MixerSlot extends Slot {
+        MixerSlot(int index, int x, int y) { super(inputs, index, x, y); }
+        @Override public boolean mayPlace(ItemStack stack) { return inputs.canPlaceItem(getContainerSlot(), stack); }
+    }
+
+    private final class ResultSlot extends Slot {
+        ResultSlot(int x, int y) { super(result, 0, x, y); }
+        @Override public boolean mayPlace(ItemStack stack) { return false; }
+        @Override public boolean mayPickup(Player player) {
+            return clientSide ? hasItem() : stillValid(player) && mixer.canCreateLinkPanel();
+        }
+        @Override public void onTake(Player player, ItemStack stack) {
+            if (!clientSide && mixer.consumeLinkPanelMaterials()) refreshResult();
+            super.onTake(player, stack);
+        }
+    }
+}

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

@@ -1,8 +1,21 @@
 package net.dnorberg.rivencraft.menu;
 
 import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.dnorberg.rivencraft.registry.ModMenus;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.PageContent;
+import net.dnorberg.rivencraft.writing.SymbolCatalog;
+import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingDeskCatalog;
+import net.dnorberg.rivencraft.network.WritingDeskCatalogPayload;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerPlayer;
+import net.neoforged.neoforge.network.PacketDistributor;
+import java.util.List;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.world.Container;
 import net.minecraft.world.SimpleContainer;
@@ -12,49 +25,278 @@ import net.minecraft.world.inventory.AbstractContainerMenu;
 import net.minecraft.world.inventory.DataSlot;
 import net.minecraft.world.inventory.Slot;
 import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
 
 public final class WritingDeskMenu extends AbstractContainerMenu {
-    private static final int PLAYER_START = WritingDeskBlockEntity.SIZE;
+    public static final int COPY_RESULT = WritingDeskBlockEntity.SIZE;
+    public static final int VISIBLE_TABS = 4;
+    public static final int PREVIOUS_TABS = 90;
+    public static final int NEXT_TABS = 91;
+    public static final int PAGE_BUTTON_BASE = 128;
+    public static final int CATALOG_BUTTON_BASE = 512;
+    public static final int ALL_PAGE_BUTTON_BASE = 32768;
+    public static final int PLACE_PAGE_BUTTON_BASE = 65536;
+    private static final int PAGE_ADDRESS_COUNT = WritingDeskBlockEntity.COLLECTIONS * NotebookContents.MAX_PAGES;
+    public static final int MOVE_PAGE_BUTTON_BASE = PLACE_PAGE_BUTTON_BASE + PAGE_ADDRESS_COUNT;
+    private static final int PLAYER_START = COPY_RESULT + 1;
+    private static final int EXTRACT_TARGET_COUNT = PLAYER_START + 36 + 1;
+    public static final int EXTRACT_PAGE_BUTTON_BASE = MOVE_PAGE_BUTTON_BASE + PAGE_ADDRESS_COUNT * PAGE_ADDRESS_COUNT;
     private final Container desk;
     private final WritingDeskBlockEntity blockEntity;
+    private final SimpleContainer result = new SimpleContainer(1);
+    private final boolean clientSide;
     private int syncedActiveCollection;
+    private int syncedInkRemaining;
+    private int firstVisibleTab;
+    private int selectedPage;
+    private int selectedCollection = -1;
+    private ResourceLocation selectedSymbol;
+    private List<SymbolDisplayMetadata> catalog = List.of();
+    private final ServerPlayer serverViewer;
 
     public WritingDeskMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
         this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
                 instanceof WritingDeskBlockEntity found ? found : null);
+        catalog = WritingDeskCatalog.read(data);
     }
 
     public WritingDeskMenu(int id, Inventory inventory, WritingDeskBlockEntity blockEntity) {
         super(ModMenus.WRITING_DESK.get(), id);
         this.blockEntity = blockEntity;
         this.desk = blockEntity == null ? new SimpleContainer(WritingDeskBlockEntity.SIZE) : blockEntity;
+        this.clientSide = inventory.player.level().isClientSide;
+        this.serverViewer = inventory.player instanceof ServerPlayer serverPlayer ? serverPlayer : null;
+        if (blockEntity != null && !clientSide) catalog = WritingDeskCatalog.available(blockEntity);
+        firstVisibleTab = blockEntity == null ? 0 : blockEntity.activeCollection() / VISIBLE_TABS * VISIBLE_TABS;
+        addDataSlot(new DataSlot() {
+            @Override public int get() { return firstVisibleTab; }
+            @Override public void set(int value) { firstVisibleTab = value; }
+        });
         addDataSlot(new DataSlot() {
             @Override public int get() { return WritingDeskMenu.this.blockEntity == null
                     ? syncedActiveCollection : WritingDeskMenu.this.blockEntity.activeCollection(); }
             @Override public void set(int value) { syncedActiveCollection = value; }
         });
+        addDataSlot(new DataSlot() {
+            @Override public int get() { return WritingDeskMenu.this.blockEntity == null
+                    ? syncedInkRemaining : WritingDeskMenu.this.blockEntity.inkRemaining(); }
+            @Override public void set(int value) { syncedInkRemaining = value; }
+        });
         for (int i = 0; i < WritingDeskBlockEntity.COLLECTIONS; i++) {
-            addSlot(new DeskSlot(desk, i, 12, 20 + i * 37, 1));
+            addSlot(new DeskSlot(desk, i, 37, 34 + (i % VISIBLE_TABS) * 37, 1));
         }
-        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.INK, 228, 20, 1));
+        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.INK, 385, 28, 16));
-        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.SOURCE, 266, 20, 1));
+        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.RETURN, 385, 80, 64));
-        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.PAPER, 304, 20, 64));
+        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.PAPER, 241, 28, 64));
-        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.OUTPUT, 342, 20, 64));
+        addSlot(new DeskSlot(desk, WritingDeskBlockEntity.LEGACY_OUTPUT, -1000, -1000, 64));
+        addSlot(new CopySlot(result, 0, 241, 80));
         for (int row = 0; row < 3; row++) {
             for (int column = 0; column < 9; column++) {
-                addSlot(new Slot(inventory, column + row * 9 + 9, 224 + column * 18, 91 + row * 18));
+                addSlot(new Slot(inventory, column + row * 9 + 9, 241 + column * 18, 104 + row * 18));
             }
         }
         for (int column = 0; column < 9; column++) {
-            addSlot(new Slot(inventory, column, 224 + column * 18, 149));
+            addSlot(new Slot(inventory, column, 241 + column * 18, 162));
         }
     }
 
     public int activeCollection() { return syncedActiveCollection; }
+    public int firstVisibleTab() { return firstVisibleTab; }
+    public int inkRemaining() { return syncedInkRemaining; }
+    public int pageCapacity(int collectionIndex) {
+        if (collectionIndex < 0 || collectionIndex >= WritingDeskBlockEntity.COLLECTIONS) return 0;
+        ItemStack collection = desk.getItem(collectionIndex);
+        return collection.is(ModItems.NOTEBOOK.get()) ? NotebookContents.MAX_PAGES
+                : collection.is(ModItems.PAGE.get()) ? 1 : 0;
+    }
+    public List<SymbolDisplayMetadata> catalog() { return catalog; }
+    public void setCatalog(List<SymbolDisplayMetadata> symbols) { catalog = List.copyOf(symbols); }
+
+    public static int movePageButtonId(int sourceCollection, int sourcePage, int targetCollection, int targetPage) {
+        int source = sourceCollection * NotebookContents.MAX_PAGES + sourcePage;
+        int target = targetCollection * NotebookContents.MAX_PAGES + targetPage;
+        return MOVE_PAGE_BUTTON_BASE + source * PAGE_ADDRESS_COUNT + target;
+    }
+
+    /** targetSlot is -1 for the cursor, otherwise a visible player or desk-tab slot. */
+    public static int extractPageButtonId(int sourceCollection, int sourcePage, int targetSlot) {
+        int source = sourceCollection * NotebookContents.MAX_PAGES + sourcePage;
+        return EXTRACT_PAGE_BUTTON_BASE + source * EXTRACT_TARGET_COUNT + targetSlot + 1;
+    }
 
     @Override public boolean clickMenuButton(Player player, int id) {
-        if (blockEntity == null || !stillValid(player) || id < 0 || id >= WritingDeskBlockEntity.COLLECTIONS) return false;
+        if (blockEntity == null || !stillValid(player)) return false;
-        blockEntity.setActiveCollection(id);
+        if (id == PREVIOUS_TABS || id == NEXT_TABS) {
+            firstVisibleTab = Math.clamp(firstVisibleTab + (id == NEXT_TABS ? VISIBLE_TABS : -VISIBLE_TABS),
+                    0, WritingDeskBlockEntity.COLLECTIONS - VISIBLE_TABS);
+            return true;
+        } else if (id >= 0 && id < WritingDeskBlockEntity.COLLECTIONS) {
+            if (id < firstVisibleTab || id >= firstVisibleTab + VISIBLE_TABS) return false;
+            blockEntity.setActiveCollection(id);
+            selectedPage = 0;
+            selectedCollection = -1;
+            selectedSymbol = null;
+        } else if (id >= EXTRACT_PAGE_BUTTON_BASE
+                && id < EXTRACT_PAGE_BUTTON_BASE + PAGE_ADDRESS_COUNT * EXTRACT_TARGET_COUNT) {
+            int offset = id - EXTRACT_PAGE_BUTTON_BASE;
+            int source = offset / EXTRACT_TARGET_COUNT;
+            int targetSlot = offset % EXTRACT_TARGET_COUNT - 1;
+            if (!extractPage(source / NotebookContents.MAX_PAGES, source % NotebookContents.MAX_PAGES,
+                    targetSlot)) return false;
+        } else if (id >= MOVE_PAGE_BUTTON_BASE && id < MOVE_PAGE_BUTTON_BASE + PAGE_ADDRESS_COUNT * PAGE_ADDRESS_COUNT) {
+            int offset = id - MOVE_PAGE_BUTTON_BASE;
+            int source = offset / PAGE_ADDRESS_COUNT;
+            int target = offset % PAGE_ADDRESS_COUNT;
+            if (!movePage(source / NotebookContents.MAX_PAGES, source % NotebookContents.MAX_PAGES,
+                    target / NotebookContents.MAX_PAGES, target % NotebookContents.MAX_PAGES)) return false;
+        } else if (id >= PLACE_PAGE_BUTTON_BASE
+                && id < PLACE_PAGE_BUTTON_BASE + WritingDeskBlockEntity.COLLECTIONS * NotebookContents.MAX_PAGES) {
+            int offset = id - PLACE_PAGE_BUTTON_BASE;
+            if (!placeCarriedPage(offset / NotebookContents.MAX_PAGES, offset % NotebookContents.MAX_PAGES)) return false;
+        } else if (id >= PAGE_BUTTON_BASE && id < PAGE_BUTTON_BASE + NotebookContents.MAX_PAGES) {
+            selectedPage = id - PAGE_BUTTON_BASE;
+            selectedCollection = -1;
+            selectedSymbol = null;
+        } else if (id >= ALL_PAGE_BUTTON_BASE && id < ALL_PAGE_BUTTON_BASE + WritingDeskBlockEntity.COLLECTIONS * NotebookContents.MAX_PAGES) {
+            int offset = id - ALL_PAGE_BUTTON_BASE;
+            int collection = offset / NotebookContents.MAX_PAGES;
+            int page = offset % NotebookContents.MAX_PAGES;
+            if (pageAt(collection, page).isEmpty()) return false;
+            selectedCollection = collection;
+            selectedPage = page;
+            selectedSymbol = null;
+        } else if (id >= CATALOG_BUTTON_BASE && id < CATALOG_BUTTON_BASE + catalog.size()) {
+            List<SymbolDisplayMetadata> available = WritingDeskCatalog.available(blockEntity);
+            if (!catalog.equals(available)) {
+                refreshCatalog(available);
+                return false;
+            }
+            selectedSymbol = available.get(id - CATALOG_BUTTON_BASE).id();
+        } else return false;
+        refreshOutput();
+        return true;
+    }
+
+    private boolean placeCarriedPage(int collectionIndex, int pageIndex) {
+        // Resolve the actual storage position on the server, never a filtered list index.
+        ItemStack carried = getCarried();
+        if (clientSide || !carried.is(ModItems.PAGE.get())) return false;
+        ItemStack collection = desk.getItem(collectionIndex);
+        if (collection.is(ModItems.NOTEBOOK.get())) {
+            var pages = new java.util.ArrayList<>(collection.getOrDefault(
+                    ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages());
+            while (pages.size() <= pageIndex) pages.add(ItemStack.EMPTY);
+            if (!pages.get(pageIndex).isEmpty()) return false;
+            pages.set(pageIndex, carried.copyWithCount(1));
+            ItemStack updated = collection.copy();
+            updated.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(pages));
+            desk.setItem(collectionIndex, updated);
+        } else return false;
+        carried.shrink(1);
+        setCarried(carried.isEmpty() ? ItemStack.EMPTY : carried);
+        selectedCollection = collectionIndex;
+        selectedPage = pageIndex;
+        selectedSymbol = null;
+        refreshCatalog();
+        broadcastChanges();
+        return true;
+    }
+
+    private boolean movePage(int sourceCollection, int sourcePage, int targetCollection, int targetPage) {
+        if (!getCarried().isEmpty() || sourceCollection == targetCollection && sourcePage == targetPage) return false;
+        ItemStack sourceBook = desk.getItem(sourceCollection);
+        ItemStack targetBook = desk.getItem(targetCollection);
+        boolean sourceNotebook = sourceBook.is(ModItems.NOTEBOOK.get());
+        boolean targetNotebook = targetBook.is(ModItems.NOTEBOOK.get());
+        if ((!sourceNotebook && (!sourceBook.is(ModItems.PAGE.get()) || sourcePage != 0))
+                || (!targetNotebook && (!targetBook.is(ModItems.PAGE.get()) || targetPage != 0))) return false;
+        var sourcePages = sourceNotebook ? new java.util.ArrayList<>(sourceBook.getOrDefault(
+                ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages()) : null;
+        if (sourceNotebook && (sourcePage >= sourcePages.size() || sourcePages.get(sourcePage).isEmpty())) return false;
+        ItemStack moving = sourceNotebook ? sourcePages.get(sourcePage) : sourceBook;
+        if (moving.getCount() != 1) return false;
+        if (!targetNotebook && targetBook.getCount() != 1) return false;
+        var targetPages = targetNotebook ? sourceCollection == targetCollection ? sourcePages
+                : new java.util.ArrayList<>(targetBook.getOrDefault(
+                        ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages()) : null;
+        if (targetNotebook) while (targetPages.size() <= targetPage) targetPages.add(ItemStack.EMPTY);
+        ItemStack displaced = targetNotebook ? targetPages.get(targetPage) : targetBook;
+        if (targetNotebook) targetPages.set(targetPage, moving);
+        if (sourceNotebook) {
+            sourcePages.set(sourcePage, displaced);
+            ItemStack updatedSource = sourceBook.copy();
+            updatedSource.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(sourcePages));
+            desk.setItem(sourceCollection, updatedSource);
+        } else desk.setItem(sourceCollection, displaced.isEmpty() ? ItemStack.EMPTY : displaced.copyWithCount(1));
+        if (targetNotebook && sourceCollection != targetCollection) {
+            ItemStack updatedTarget = targetBook.copy();
+            updatedTarget.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(targetPages));
+            desk.setItem(targetCollection, updatedTarget);
+        } else if (!targetNotebook) desk.setItem(targetCollection, moving.copyWithCount(1));
+        selectedCollection = targetCollection;
+        selectedPage = targetPage;
+        selectedSymbol = null;
+        refreshCatalog();
+        broadcastChanges();
+        return true;
+    }
+
+    private boolean extractPage(int sourceCollection, int sourcePage, int targetSlot) {
+        if (!getCarried().isEmpty() || targetSlot < -1 || targetSlot >= slots.size()) return false;
+        ItemStack sourceBook = desk.getItem(sourceCollection);
+        boolean sourceNotebook = sourceBook.is(ModItems.NOTEBOOK.get());
+        if (!sourceNotebook && (!sourceBook.is(ModItems.PAGE.get()) || sourcePage != 0)) return false;
+        var sourcePages = sourceNotebook ? new java.util.ArrayList<>(sourceBook.getOrDefault(
+                ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages()) : null;
+        if (sourceNotebook && (sourcePage >= sourcePages.size() || sourcePages.get(sourcePage).isEmpty())) return false;
+        ItemStack moving = sourceNotebook ? sourcePages.get(sourcePage).copyWithCount(1) : sourceBook.copyWithCount(1);
+        if (!sourceNotebook && sourceBook.getCount() != 1) return false;
+
+        if (targetSlot == -1) {
+            setCarried(moving);
+        } else {
+            if (targetSlot >= WritingDeskBlockEntity.COLLECTIONS && targetSlot < PLAYER_START) return false;
+            Slot target = slots.get(targetSlot);
+            if (!target.isActive() || !target.mayPlace(moving)) return false;
+            ItemStack current = target.getItem();
+            if (targetSlot < WritingDeskBlockEntity.COLLECTIONS && current.is(ModItems.NOTEBOOK.get())) {
+                var targetPages = targetSlot == sourceCollection ? sourcePages
+                        : new java.util.ArrayList<>(current.getOrDefault(
+                                ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages());
+                int position = -1;
+                for (int i = 0; i < NotebookContents.MAX_PAGES; i++) {
+                    if (i >= targetPages.size() || targetPages.get(i).isEmpty()) {
+                        position = i;
+                        break;
+                    }
+                }
+                if (position < 0) return false;
+                while (targetPages.size() <= position) targetPages.add(ItemStack.EMPTY);
+                targetPages.set(position, moving);
+                if (targetSlot != sourceCollection) {
+                    ItemStack updatedTarget = current.copy();
+                    updatedTarget.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(targetPages));
+                    target.setByPlayer(updatedTarget);
+                }
+            } else if (current.isEmpty()) {
+                target.setByPlayer(moving);
+            } else if (targetSlot >= PLAYER_START && ItemStack.isSameItemSameComponents(current, moving)
+                    && current.getCount() < target.getMaxStackSize(moving)) {
+                target.setByPlayer(current.copyWithCount(current.getCount() + 1));
+            } else return false;
+        }
+
+        if (sourceNotebook) {
+            sourcePages.set(sourcePage, ItemStack.EMPTY);
+            ItemStack updatedSource = sourceBook.copy();
+            updatedSource.set(ModDataComponents.NOTEBOOK_CONTENTS.get(), new NotebookContents(sourcePages));
+            desk.setItem(sourceCollection, updatedSource);
+        } else desk.setItem(sourceCollection, ItemStack.EMPTY);
+        selectedCollection = sourceCollection;
+        selectedPage = sourcePage;
+        selectedSymbol = null;
+        refreshCatalog();
+        broadcastChanges();
         return true;
     }
 
@@ -64,11 +306,24 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
 
     @Override public ItemStack quickMoveStack(Player player, int index) {
         if (!stillValid(player) || index < 0 || index >= slots.size()) return ItemStack.EMPTY;
+        if (index == COPY_RESULT) {
+            refreshOutput();
+            if (!canCopy()) return ItemStack.EMPTY;
+            ItemStack copy = selectedSource().copyWithCount(1);
+            ItemStack movingCopy = copy.copy();
+            if (!moveItemStackTo(movingCopy, PLAYER_START, slots.size(), true) || !movingCopy.isEmpty()) {
+                return ItemStack.EMPTY;
+            }
+            blockEntity.consumeCopyMaterials();
+            refreshOutput();
+            return copy;
+        }
         Slot slot = slots.get(index);
+        if (!slot.isActive()) return ItemStack.EMPTY;
         if (!slot.hasItem()) return ItemStack.EMPTY;
         ItemStack moving = slot.getItem();
         ItemStack original = moving.copy();
-        if (index < PLAYER_START) {
+        if (index < COPY_RESULT) {
             if (!moveItemStackTo(moving, PLAYER_START, slots.size(), true)) return ItemStack.EMPTY;
         } else if (!moveIntoDesk(moving)) {
             return ItemStack.EMPTY;
@@ -79,23 +334,115 @@ public final class WritingDeskMenu extends AbstractContainerMenu {
     }
 
     private boolean moveIntoDesk(ItemStack moving) {
-        if (moving.is(ModItems.INK_VIAL.get())) return moveItemStackTo(moving, 4, 5, false);
+        if (moving.is(ModItems.INK_VIAL.get())) return moveItemStackTo(moving,
-        if (moving.is(ModItems.NOTEBOOK.get())) return moveItemStackTo(moving, 0, 4, false);
+                WritingDeskBlockEntity.INK, WritingDeskBlockEntity.INK + 1, false);
-        if (moving.is(ModItems.PAGE.get())) {
+        if (moving.is(ModItems.NOTEBOOK.get())) return moveItemStackTo(moving, firstVisibleTab, firstVisibleTab + VISIBLE_TABS, false);
-            return moveItemStackTo(moving, 6, 7, false)
+        if (moving.is(Items.PAPER))
-                    || moveItemStackTo(moving, 0, 4, false)
+            return moveItemStackTo(moving, WritingDeskBlockEntity.PAPER,
-                    || moveItemStackTo(moving, 5, 6, false);
+                    WritingDeskBlockEntity.PAPER + 1, false);
-        }
+        if (moving.is(ModItems.PAGE.get())) return moveItemStackTo(moving, firstVisibleTab, firstVisibleTab + VISIBLE_TABS, false);
         return false;
     }
 
-    private static final class DeskSlot extends Slot {
+    private ItemStack selectedSource() {
+        if (selectedSymbol != null) {
+            SymbolReference reference = new SymbolReference(selectedSymbol);
+            return SymbolCatalog.isKnown(reference)
+                    && blockEntity != null
+                    && WritingDeskCatalog.available(blockEntity).stream()
+                    .anyMatch(entry -> entry.id().equals(selectedSymbol))
+                    ? PageItem.createSymbolPage(reference) : ItemStack.EMPTY;
+        }
+        int collectionIndex = selectedCollection >= 0 ? selectedCollection
+                : blockEntity == null ? syncedActiveCollection : blockEntity.activeCollection();
+        return pageAt(collectionIndex, selectedPage);
+    }
+
+    private ItemStack pageAt(int collectionIndex, int pageIndex) {
+        if (collectionIndex < 0 || collectionIndex >= WritingDeskBlockEntity.COLLECTIONS
+                || pageIndex < 0 || pageIndex >= NotebookContents.MAX_PAGES) return ItemStack.EMPTY;
+        ItemStack collection = desk.getItem(collectionIndex);
+        if (collection.is(ModItems.PAGE.get())) return pageIndex == 0 ? collection : ItemStack.EMPTY;
+        if (collection.is(ModItems.NOTEBOOK.get())) {
+            List<ItemStack> pages = collection.getOrDefault(
+                    ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages();
+            return pageIndex < pages.size() ? pages.get(pageIndex) : ItemStack.EMPTY;
+        }
+        return ItemStack.EMPTY;
+    }
+
+    private boolean canCopy() {
+        ItemStack source = selectedSource();
+        return blockEntity != null && source.is(ModItems.PAGE.get())
+                && PageItem.content(source).kind() != PageContent.Kind.BLANK
+                && PageItem.isUsableWriting(source) && blockEntity.canConsumeCopyMaterials();
+    }
+
+    private void refreshOutput() {
+        if (clientSide) return;
+        if (blockEntity != null) blockEntity.setDisplayPage(selectedSource());
+        ItemStack preview = canCopy() ? selectedSource().copyWithCount(1) : ItemStack.EMPTY;
+        if (!ItemStack.matches(result.getItem(0), preview)) result.setItem(0, preview);
+    }
+
+    private void refreshCatalog() {
+        if (clientSide || blockEntity == null) return;
+        refreshCatalog(WritingDeskCatalog.available(blockEntity));
+    }
+
+    private void refreshCatalog(List<SymbolDisplayMetadata> current) {
+        if (clientSide || blockEntity == null) return;
+        if (!current.equals(catalog)) {
+            catalog = current;
+            if (serverViewer != null && serverViewer.containerMenu == this) {
+                PacketDistributor.sendToPlayer(serverViewer, new WritingDeskCatalogPayload(containerId, catalog));
+            }
+        }
+    }
+
+    @Override public void broadcastChanges() {
+        refreshCatalog();
+        refreshOutput();
+        super.broadcastChanges();
+    }
+
+    @Override public void clicked(int slotId, int button, net.minecraft.world.inventory.ClickType clickType,
+                                  Player player) {
+        if (!stillValid(player)) {
+            player.closeContainer();
+            return;
+        }
+        refreshCatalog();
+        refreshOutput();
+        if (slotId >= 0 && slotId < slots.size() && !slots.get(slotId).isActive()) return;
+        super.clicked(slotId, button, clickType, player);
+    }
+
+    private final class CopySlot extends Slot {
+        private CopySlot(Container container, int index, int x, int y) { super(container, index, x, y); }
+        @Override public boolean mayPlace(ItemStack stack) { return false; }
+        @Override public boolean mayPickup(Player player) {
+            return clientSide ? hasItem() : WritingDeskMenu.this.stillValid(player) && canCopy();
+        }
+        @Override public void onTake(Player player, ItemStack stack) {
+            if (!clientSide && blockEntity.consumeCopyMaterials()) refreshOutput();
+            super.onTake(player, stack);
+        }
+    }
+
+    private final class DeskSlot extends Slot {
         private final int limit;
         private DeskSlot(Container container, int index, int x, int y, int limit) {
             super(container, index, x, y);
             this.limit = limit;
         }
-        @Override public boolean mayPlace(ItemStack stack) { return container.canPlaceItem(getContainerSlot(), stack); }
+        @Override public boolean isActive() {
+            int slot = getContainerSlot();
+            return slot >= WritingDeskBlockEntity.COLLECTIONS
+                    || slot >= firstVisibleTab && slot < firstVisibleTab + VISIBLE_TABS;
+        }
+        @Override public boolean mayPickup(Player player) { return isActive(); }
+        @Override public boolean mayPlace(ItemStack stack) { return isActive() && container.canPlaceItem(getContainerSlot(), stack); }
         @Override public int getMaxStackSize() { return limit; }
     }
 }

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

@@ -5,15 +5,24 @@ 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;
 import net.dnorberg.rivencraft.client.ClientAgeCelestialAngles;
+import net.dnorberg.rivencraft.client.ClientWritingDeskCatalog;
 import net.dnorberg.rivencraft.event.AgeCelestialAngleSync;
 import net.dnorberg.rivencraft.item.DescriptiveBookItem;
 import net.dnorberg.rivencraft.item.LinkingBookItem;
+import net.dnorberg.rivencraft.menu.BookBinderMenu;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
+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;
@@ -48,7 +57,7 @@ public final class ModNetworking {
     }
 
     public static void register(RegisterPayloadHandlersEvent event) {
-        PayloadRegistrar registrar = event.registrar("10");
+        PayloadRegistrar registrar = event.registrar("13");
         registrar.playToServer(RequestDescriptiveBookScreenPayload.TYPE, RequestDescriptiveBookScreenPayload.STREAM_CODEC,
                 ModNetworking::requestDescriptiveBookScreen);
         registrar.playToClient(OpenDescriptiveBookScreenPayload.TYPE, OpenDescriptiveBookScreenPayload.STREAM_CODEC,
@@ -68,6 +77,18 @@ public final class ModNetworking {
                 ClientLinkPreviewHandler::handle);
         registrar.playToClient(AgeCelestialAnglePayload.TYPE, AgeCelestialAnglePayload.STREAM_CODEC,
                 ClientAgeCelestialAngles::handle);
+        registrar.playToClient(WritingDeskCatalogPayload.TYPE, WritingDeskCatalogPayload.STREAM_CODEC,
+                ClientWritingDeskCatalog::handle);
+        registrar.playToServer(SetBookBinderTitlePayload.TYPE, SetBookBinderTitlePayload.STREAM_CODEC,
+                ModNetworking::setBookBinderTitle);
+    }
+
+    private static void setBookBinderTitle(SetBookBinderTitlePayload payload, IPayloadContext context) {
+        if (context.player() instanceof ServerPlayer player
+                && player.containerMenu instanceof BookBinderMenu menu
+                && menu.containerId == payload.containerId()) {
+            menu.setTitle(player, payload.title());
+        }
     }
 
     private static void requestDescriptiveBookScreen(RequestDescriptiveBookScreenPayload payload, IPayloadContext context) {
@@ -89,10 +110,17 @@ public final class ModNetworking {
         // Requests run on the same server thread as Age creation. A request queued
         // during generation can only open the finished book, never a stale client copy.
         player.inventoryMenu.broadcastChanges();
+        List<SymbolDisplayMetadata> writingSymbols = access.stack()
+                .getOrDefault(ModDataComponents.BOOK_WRITING.get(), OrderedWriting.EMPTY).entries().stream()
+                .filter(entry -> entry.kind() == WritingEntry.Kind.SYMBOL)
+                .map(entry -> SymbolCatalog.display(entry.symbol().orElseThrow()))
+                .toList();
         PacketDistributor.sendToPlayer(player, new OpenDescriptiveBookScreenPayload(
                 payload.fromStand(), payload.offhand(),
                 GlobalPos.of(player.level().dimension(), payload.standPos()), access.stack().copy(),
-                definition == null ? null : definition.traits()));
+                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) {
@@ -110,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/network/OpenDescriptiveBookScreenPayload.java

@@ -1,7 +1,11 @@
 package net.dnorberg.rivencraft.network;
 
+import java.util.ArrayList;
+import java.util.List;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.book.AgeTraits;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import net.minecraft.core.GlobalPos;
 import net.minecraft.network.RegistryFriendlyByteBuf;
 import net.minecraft.network.codec.StreamCodec;
@@ -16,7 +20,8 @@ public record OpenDescriptiveBookScreenPayload(
         boolean offhand,
         GlobalPos source,
         ItemStack book,
-        @Nullable AgeTraits traits
+        @Nullable AgeTraits traits,
+        List<SymbolDisplayMetadata> writingSymbols
 )
         implements CustomPacketPayload {
     public static final Type<OpenDescriptiveBookScreenPayload> TYPE = new Type<>(
@@ -40,6 +45,11 @@ public record OpenDescriptiveBookScreenPayload(
             buffer.writeFloat(traits.celestialAngle());
             buffer.writeFloat(traits.celestialPhase());
         }
+        if (payload.writingSymbols().size() > OrderedWriting.MAX_ENTRIES) {
+            throw new IllegalArgumentException("Too many book symbol displays");
+        }
+        buffer.writeVarInt(payload.writingSymbols().size());
+        payload.writingSymbols().forEach(symbol -> SymbolDisplayMetadata.STREAM_CODEC.encode(buffer, symbol));
     }
 
     private static OpenDescriptiveBookScreenPayload decode(RegistryFriendlyByteBuf buffer) {
@@ -57,7 +67,16 @@ public record OpenDescriptiveBookScreenPayload(
                         buffer.readFloat()
                 )
                 : null;
-        return new OpenDescriptiveBookScreenPayload(fromStand, offhand, source, book, traits);
+        int count = buffer.readVarInt();
+        if (count < 0 || count > OrderedWriting.MAX_ENTRIES) {
+            throw new IllegalArgumentException("Invalid book symbol display count " + count);
+        }
+        List<SymbolDisplayMetadata> writingSymbols = new ArrayList<>(count);
+        for (int index = 0; index < count; index++) {
+            writingSymbols.add(SymbolDisplayMetadata.STREAM_CODEC.decode(buffer));
+        }
+        return new OpenDescriptiveBookScreenPayload(fromStand, offhand, source, book, traits,
+                List.copyOf(writingSymbols));
     }
 
     @Override

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

@@ -0,0 +1,19 @@
+package net.dnorberg.rivencraft.network;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.ByteBufCodecs;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+
+public record SetBookBinderTitlePayload(int containerId, String title) implements CustomPacketPayload {
+    public static final Type<SetBookBinderTitlePayload> TYPE = new Type<>(
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "set_book_binder_title"));
+    public static final StreamCodec<RegistryFriendlyByteBuf, SetBookBinderTitlePayload> STREAM_CODEC =
+            StreamCodec.composite(ByteBufCodecs.VAR_INT, SetBookBinderTitlePayload::containerId,
+                    ByteBufCodecs.STRING_UTF8, SetBookBinderTitlePayload::title,
+                    SetBookBinderTitlePayload::new);
+
+    @Override public Type<? extends CustomPacketPayload> type() { return TYPE; }
+}

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

@@ -0,0 +1,26 @@
+package net.dnorberg.rivencraft.network;
+
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
+import net.dnorberg.rivencraft.writing.WritingDeskCatalog;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.network.codec.StreamCodec;
+import net.minecraft.network.protocol.common.custom.CustomPacketPayload;
+import net.minecraft.resources.ResourceLocation;
+
+/** Current server-approved symbols from this open Writing Desk menu. */
+public record WritingDeskCatalogPayload(int containerId, List<SymbolDisplayMetadata> symbols)
+        implements CustomPacketPayload {
+    public static final Type<WritingDeskCatalogPayload> TYPE = new Type<>(
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "writing_desk_catalog"));
+    public static final StreamCodec<RegistryFriendlyByteBuf, WritingDeskCatalogPayload> STREAM_CODEC =
+            StreamCodec.of(
+                    (buffer, payload) -> {
+                        buffer.writeVarInt(payload.containerId());
+                        WritingDeskCatalog.write(buffer, payload.symbols());
+                    },
+                    buffer -> new WritingDeskCatalogPayload(buffer.readVarInt(), WritingDeskCatalog.read(buffer)));
+
+    @Override public Type<? extends CustomPacketPayload> type() { return TYPE; }
+}

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

@@ -2,7 +2,9 @@ package net.dnorberg.rivencraft.registry;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.block.entity.BookStandBlockEntity;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
+import net.dnorberg.rivencraft.block.entity.InkMixerBlockEntity;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.world.level.block.entity.BlockEntityType;
 import net.neoforged.bus.api.IEventBus;
@@ -20,6 +22,12 @@ public final class ModBlockEntities {
     public static final DeferredHolder<BlockEntityType<?>, BlockEntityType<WritingDeskBlockEntity>> WRITING_DESK =
             BLOCK_ENTITIES.register("writing_desk", () -> BlockEntityType.Builder
                     .of(WritingDeskBlockEntity::new, ModBlocks.WRITING_DESK.get()).build(null));
+    public static final DeferredHolder<BlockEntityType<?>, BlockEntityType<BookBinderBlockEntity>> BOOK_BINDER =
+            BLOCK_ENTITIES.register("book_binder", () -> BlockEntityType.Builder
+                    .of(BookBinderBlockEntity::new, ModBlocks.BOOK_BINDER.get()).build(null));
+    public static final DeferredHolder<BlockEntityType<?>, BlockEntityType<InkMixerBlockEntity>> INK_MIXER =
+            BLOCK_ENTITIES.register("ink_mixer", () -> BlockEntityType.Builder
+                    .of(InkMixerBlockEntity::new, ModBlocks.INK_MIXER.get()).build(null));
 
     private ModBlockEntities() {
     }

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

@@ -2,7 +2,9 @@ package net.dnorberg.rivencraft.registry;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.block.BookStandBlock;
+import net.dnorberg.rivencraft.block.BookBinderBlock;
 import net.dnorberg.rivencraft.block.WritingDeskBlock;
+import net.dnorberg.rivencraft.block.InkMixerBlock;
 import net.minecraft.world.level.block.Blocks;
 import net.minecraft.world.level.block.state.BlockBehaviour;
 import net.neoforged.bus.api.IEventBus;
@@ -19,7 +21,15 @@ public final class ModBlocks {
     );
     public static final DeferredBlock<WritingDeskBlock> WRITING_DESK = BLOCKS.registerBlock(
             "writing_desk", WritingDeskBlock::new,
-            BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE)
+            BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion()
+    );
+    public static final DeferredBlock<BookBinderBlock> BOOK_BINDER = BLOCKS.registerBlock(
+            "book_binder", BookBinderBlock::new,
+            BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion()
+    );
+    public static final DeferredBlock<InkMixerBlock> INK_MIXER = BLOCKS.registerBlock(
+            "ink_mixer", InkMixerBlock::new,
+            BlockBehaviour.Properties.ofFullCopy(Blocks.CRAFTING_TABLE).noOcclusion()
     );
 
     private ModBlocks() {

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

@@ -23,6 +23,8 @@ public final class ModCreativeTabs {
                         output.accept(ModItems.NOTEBOOK.get());
                         output.accept(ModItems.INK_VIAL.get());
                         output.accept(ModItems.WRITING_DESK.get());
+                        output.accept(ModItems.INK_MIXER.get());
+                        output.accept(ModItems.BOOK_BINDER.get());
                     })
                     .build());
 
@@ -33,6 +35,7 @@ public final class ModCreativeTabs {
                     .displayItems((parameters, output) -> {
                         output.accept(ModItems.PAGE.get());
                         output.accept(PageItem.createLinkPanelPage());
+                        PageItem.creativeSymbolPages(parameters.holders()).forEach(output::accept);
                     })
                     .build());
 

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

@@ -5,6 +5,7 @@ import net.dnorberg.rivencraft.book.LinkTarget;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolDisplayMetadata;
 import com.mojang.serialization.Codec;
 import net.minecraft.core.component.DataComponentType;
@@ -61,6 +62,12 @@ public final class ModDataComponents {
                     .networkSynchronized(NotebookContents.STREAM_CODEC)
                     .cacheEncoding()
                     .build());
+    public static final DeferredHolder<DataComponentType<?>, DataComponentType<OrderedWriting>> BOOK_WRITING =
+            DATA_COMPONENTS.register("book_writing", () -> DataComponentType.<OrderedWriting>builder()
+                    .persistent(OrderedWriting.CODEC)
+                    .networkSynchronized(OrderedWriting.STREAM_CODEC)
+                    .cacheEncoding()
+                    .build());
     public static final DeferredHolder<DataComponentType<?>, DataComponentType<Integer>> INK_REMAINING =
             DATA_COMPONENTS.register("ink_remaining", () -> DataComponentType.<Integer>builder()
                     .persistent(Codec.intRange(0, 16))

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

@@ -41,6 +41,8 @@ public final class ModItems {
             new Item.Properties().stacksTo(16)
     );
     public static final DeferredItem<BlockItem> WRITING_DESK = ITEMS.registerSimpleBlockItem(ModBlocks.WRITING_DESK);
+    public static final DeferredItem<BlockItem> BOOK_BINDER = ITEMS.registerSimpleBlockItem(ModBlocks.BOOK_BINDER);
+    public static final DeferredItem<BlockItem> INK_MIXER = ITEMS.registerSimpleBlockItem(ModBlocks.INK_MIXER);
 
     private ModItems() {
     }

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

@@ -3,6 +3,8 @@ package net.dnorberg.rivencraft.registry;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.menu.NotebookMenu;
 import net.dnorberg.rivencraft.menu.WritingDeskMenu;
+import net.dnorberg.rivencraft.menu.BookBinderMenu;
+import net.dnorberg.rivencraft.menu.InkMixerMenu;
 import net.minecraft.core.registries.Registries;
 import net.minecraft.world.inventory.MenuType;
 import net.neoforged.bus.api.IEventBus;
@@ -18,6 +20,10 @@ public final class ModMenus {
             MENUS.register("notebook", () -> IMenuTypeExtension.create(NotebookMenu::new));
     public static final DeferredHolder<MenuType<?>, MenuType<WritingDeskMenu>> WRITING_DESK =
             MENUS.register("writing_desk", () -> IMenuTypeExtension.create(WritingDeskMenu::new));
+    public static final DeferredHolder<MenuType<?>, MenuType<BookBinderMenu>> BOOK_BINDER =
+            MENUS.register("book_binder", () -> IMenuTypeExtension.create(BookBinderMenu::new));
+    public static final DeferredHolder<MenuType<?>, MenuType<InkMixerMenu>> INK_MIXER =
+            MENUS.register("ink_mixer", () -> IMenuTypeExtension.create(InkMixerMenu::new));
 
     private ModMenus() {
     }

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

@@ -0,0 +1,24 @@
+package net.dnorberg.rivencraft.registry;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.writing.LinkingBookRecipe;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.item.crafting.SimpleCraftingRecipeSerializer;
+import net.neoforged.bus.api.IEventBus;
+import net.neoforged.neoforge.registries.DeferredHolder;
+import net.neoforged.neoforge.registries.DeferredRegister;
+
+public final class ModRecipeSerializers {
+    private static final DeferredRegister<RecipeSerializer<?>> SERIALIZERS =
+            DeferredRegister.create(Registries.RECIPE_SERIALIZER, Rivencraft.MOD_ID);
+
+    public static final DeferredHolder<RecipeSerializer<?>, RecipeSerializer<LinkingBookRecipe>> LINKING_BOOK =
+            SERIALIZERS.register("linking_book", () -> new SimpleCraftingRecipeSerializer<>(LinkingBookRecipe::new));
+
+    private ModRecipeSerializers() {}
+
+    public static void register(IEventBus modEventBus) {
+        SERIALIZERS.register(modEventBus);
+    }
+}

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

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

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

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

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

@@ -0,0 +1,43 @@
+package net.dnorberg.rivencraft.writing;
+
+import java.util.Arrays;
+import java.util.Locale;
+import java.util.Optional;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.ResourceLocation;
+
+/** Built-in fallback pages for registered vanilla biomes without hand-authored symbol JSON. */
+public final class BiomeSymbolPages {
+    private static final ResourceLocation CATEGORY = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome");
+
+    private BiomeSymbolPages() { }
+
+    public static ResourceLocation symbolId(ResourceLocation biomeId) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome/" + biomeId.getPath());
+    }
+
+    public static SymbolDefinition definition(ResourceLocation biomeId) {
+        String path = biomeId.getPath();
+        String glyphWord = Arrays.stream(path.split("_"))
+                .map(part -> part.replaceAll("[^A-Za-z]", ""))
+                .filter(part -> !part.isEmpty())
+                .map(part -> part.substring(0, 1).toUpperCase(Locale.ROOT) + part.substring(1))
+                .reduce("", String::concat);
+        if (glyphWord.isEmpty()) glyphWord = "World";
+        return new SymbolDefinition(SymbolDefinition.CURRENT_SCHEMA_VERSION,
+                "symbol.rivencraft.biome." + path,
+                "symbol.rivencraft.biome.generated.description",
+                CATEGORY,
+                Optional.of(new SymbolSemantics(SymbolSemantics.Role.BIOME,
+                        new SymbolSemantics.ResourceValue(biomeId))),
+                "Nature Form " + glyphWord + " Biome");
+    }
+
+    public static String fallbackName(ResourceLocation symbolId) {
+        String path = symbolId.getPath().substring("biome/".length());
+        return Arrays.stream(path.split("_"))
+                .filter(part -> !part.isEmpty())
+                .map(part -> part.substring(0, 1).toUpperCase(Locale.ROOT) + part.substring(1))
+                .reduce((left, right) -> left + " " + right).orElse("Unknown") + " Biome";
+    }
+}

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

@@ -0,0 +1,43 @@
+package net.dnorberg.rivencraft.writing;
+
+import net.dnorberg.rivencraft.item.InkVialItem;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.minecraft.core.NonNullList;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+
+/** Shared, server-side vial-to-meter exchange for the Desk and Ink Mixer. */
+public final class InkVialExchange {
+    private InkVialExchange() {}
+
+    public static boolean canPay(NonNullList<ItemStack> items, int inkSlot, int bottleSlot,
+                                 int storedInk, int cost) {
+        return storedInk >= cost || canExchange(items, inkSlot, bottleSlot)
+                && storedInk + vialInk(items.get(inkSlot)) >= cost;
+    }
+
+    /** Returns added ink; zero means no inputs were changed. */
+    public static int exchange(NonNullList<ItemStack> items, int inkSlot, int bottleSlot) {
+        if (!canExchange(items, inkSlot, bottleSlot)) return 0;
+        ItemStack vial = items.get(inkSlot);
+        int addedInk = vialInk(vial);
+        vial.shrink(1);
+        if (vial.isEmpty()) items.set(inkSlot, ItemStack.EMPTY);
+        ItemStack bottles = items.get(bottleSlot);
+        if (bottles.isEmpty()) items.set(bottleSlot, new ItemStack(Items.GLASS_BOTTLE));
+        else bottles.grow(1);
+        return addedInk;
+    }
+
+    private static boolean canExchange(NonNullList<ItemStack> items, int inkSlot, int bottleSlot) {
+        ItemStack vial = items.get(inkSlot);
+        ItemStack bottles = items.get(bottleSlot);
+        return vial.is(ModItems.INK_VIAL.get()) && vialInk(vial) > 0
+                && (bottles.isEmpty() || bottles.is(Items.GLASS_BOTTLE)
+                && bottles.getCount() < bottles.getMaxStackSize());
+    }
+
+    private static int vialInk(ItemStack vial) {
+        return Math.clamp(InkVialItem.remaining(vial), 0, InkVialItem.CAPACITY);
+    }
+}

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

@@ -0,0 +1,80 @@
+package net.dnorberg.rivencraft.writing;
+
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.registry.ModRecipeSerializers;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.core.NonNullList;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.crafting.CraftingBookCategory;
+import net.minecraft.world.item.crafting.CraftingInput;
+import net.minecraft.world.item.crafting.CustomRecipe;
+import net.minecraft.world.item.crafting.Ingredient;
+import net.minecraft.world.item.crafting.RecipeSerializer;
+import net.minecraft.world.level.Level;
+import net.neoforged.neoforge.common.crafting.DataComponentIngredient;
+
+/** Legacy's shapeless leather + Link Panel recipe, adapted to page components. */
+public final class LinkingBookRecipe extends CustomRecipe {
+    public LinkingBookRecipe(CraftingBookCategory category) {
+        super(category);
+    }
+
+    private static ItemStack findPanel(CraftingInput input) {
+        if (input.ingredientCount() != 2) return ItemStack.EMPTY;
+        ItemStack panel = ItemStack.EMPTY;
+        boolean leather = false;
+        for (ItemStack stack : input.items()) {
+            if (stack.isEmpty()) continue;
+            if (stack.is(ModItems.PAGE.get()) && PageItem.content(stack).kind() == PageContent.Kind.LINK_PANEL
+                    && panel.isEmpty()) {
+                panel = stack;
+            } else if (stack.is(Items.LEATHER) && !leather) {
+                leather = true;
+            } else {
+                return ItemStack.EMPTY;
+            }
+        }
+        return leather ? panel : ItemStack.EMPTY;
+    }
+
+    @Override
+    public boolean matches(CraftingInput input, Level level) {
+        return !findPanel(input).isEmpty();
+    }
+
+    @Override
+    public ItemStack assemble(CraftingInput input, HolderLookup.Provider registries) {
+        ItemStack panel = findPanel(input);
+        if (panel.isEmpty()) return ItemStack.EMPTY;
+        ItemStack book = new ItemStack(ModItems.LINKING_BOOK.get());
+        // Legacy copied the panel's data. Only its custom name is meaningful to a
+        // 1.21.1 Linking Book today; page-only components must not reach the book.
+        if (panel.has(DataComponents.CUSTOM_NAME)) {
+            book.set(DataComponents.CUSTOM_NAME, panel.get(DataComponents.CUSTOM_NAME));
+        }
+        return book;
+    }
+
+    @Override
+    public boolean canCraftInDimensions(int width, int height) {
+        return width * height >= 2;
+    }
+
+    @Override
+    public NonNullList<Ingredient> getIngredients() {
+        NonNullList<Ingredient> ingredients = NonNullList.create();
+        ingredients.add(DataComponentIngredient.of(false,
+                net.dnorberg.rivencraft.registry.ModDataComponents.PAGE_CONTENT.get(),
+                PageContent.LINK_PANEL, ModItems.PAGE.get()));
+        ingredients.add(Ingredient.of(Items.LEATHER));
+        return ingredients;
+    }
+
+    @Override
+    public RecipeSerializer<?> getSerializer() {
+        return ModRecipeSerializers.LINKING_BOOK.get();
+    }
+}

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

@@ -2,6 +2,7 @@ package net.dnorberg.rivencraft.writing;
 
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.DataResult;
+import com.mojang.serialization.codecs.RecordCodecBuilder;
 import io.netty.buffer.ByteBuf;
 import java.util.ArrayList;
 import java.util.List;
@@ -10,30 +11,50 @@ import net.minecraft.network.codec.ByteBufCodecs;
 import net.minecraft.network.codec.StreamCodec;
 
 /** Immutable ordered writing shared by pages, notebooks, desks, and books. */
-public record OrderedWriting(List<WritingEntry> entries) {
+public record OrderedWriting(int schemaVersion, List<WritingEntry> entries) {
+    public static final int CURRENT_SCHEMA_VERSION = 1;
     public static final int MAX_ENTRIES = 256;
     public static final OrderedWriting EMPTY = new OrderedWriting(List.of());
-    public static final Codec<OrderedWriting> CODEC = WritingEntry.CODEC.listOf()
+    private static final Codec<List<WritingEntry>> ENTRIES_CODEC = WritingEntry.CODEC.listOf()
             .validate(entries -> entries.size() <= MAX_ENTRIES
                     ? DataResult.success(entries)
-                    : DataResult.error(() -> "Writing exceeds " + MAX_ENTRIES + " entries"))
+                    : DataResult.error(() -> "Writing exceeds " + MAX_ENTRIES + " entries"));
-            .xmap(OrderedWriting::new, OrderedWriting::entries);
+    private static final Codec<OrderedWriting> VERSIONED_CODEC = RecordCodecBuilder.create(instance -> instance.group(
+            Codec.intRange(CURRENT_SCHEMA_VERSION, CURRENT_SCHEMA_VERSION)
+                    .fieldOf("schema_version").forGetter(OrderedWriting::schemaVersion),
+            ENTRIES_CODEC.fieldOf("entries").forGetter(OrderedWriting::entries)
+    ).apply(instance, OrderedWriting::new));
+    // 0.3.7.2 stored BOOK_WRITING as a bare list. Decode it without changing its order.
+    public static final Codec<OrderedWriting> CODEC = Codec.withAlternative(
+            VERSIONED_CODEC, ENTRIES_CODEC.xmap(OrderedWriting::new, OrderedWriting::entries));
     public static final StreamCodec<ByteBuf, OrderedWriting> STREAM_CODEC = StreamCodec.of(
             OrderedWriting::encode, OrderedWriting::decode);
 
     public OrderedWriting {
+        if (schemaVersion != CURRENT_SCHEMA_VERSION) {
+            throw new IllegalArgumentException("Unsupported writing schema version " + schemaVersion);
+        }
         entries = List.copyOf(Objects.requireNonNull(entries, "entries"));
         if (entries.size() > MAX_ENTRIES) {
             throw new IllegalArgumentException("Writing exceeds " + MAX_ENTRIES + " entries");
         }
     }
 
+    public OrderedWriting(List<WritingEntry> entries) {
+        this(CURRENT_SCHEMA_VERSION, entries);
+    }
+
     private static void encode(ByteBuf buffer, OrderedWriting writing) {
+        ByteBufCodecs.VAR_INT.encode(buffer, writing.schemaVersion);
         ByteBufCodecs.VAR_INT.encode(buffer, writing.entries.size());
         writing.entries.forEach(entry -> WritingEntry.STREAM_CODEC.encode(buffer, entry));
     }
 
     private static OrderedWriting decode(ByteBuf buffer) {
+        int schemaVersion = ByteBufCodecs.VAR_INT.decode(buffer);
+        if (schemaVersion != CURRENT_SCHEMA_VERSION) {
+            throw new IllegalArgumentException("Unsupported writing schema version " + schemaVersion);
+        }
         int size = ByteBufCodecs.VAR_INT.decode(buffer);
         if (size < 0 || size > MAX_ENTRIES) {
             throw new IllegalArgumentException("Invalid writing entry count " + size);
@@ -42,6 +63,6 @@ public record OrderedWriting(List<WritingEntry> entries) {
         for (int index = 0; index < size; index++) {
             entries.add(WritingEntry.STREAM_CODEC.decode(buffer));
         }
-        return new OrderedWriting(entries);
+        return new OrderedWriting(schemaVersion, entries);
     }
 }

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

@@ -3,12 +3,13 @@ package net.dnorberg.rivencraft.writing;
 import com.google.gson.Gson;
 import com.google.gson.GsonBuilder;
 import com.google.gson.JsonElement;
-import com.mojang.serialization.JsonOps;
 import java.util.HashMap;
 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;
@@ -24,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) {
@@ -47,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
@@ -56,10 +60,18 @@ public final class SymbolCatalog {
                              ResourceManager resourceManager,
                              ProfilerFiller profiler) {
             Map<ResourceLocation, SymbolDefinition> loaded = new HashMap<>();
-            resources.forEach((id, json) -> SymbolDefinition.CODEC.parse(JsonOps.INSTANCE, json)
+            resources.forEach((id, json) -> {
-                    .resultOrPartial(error -> Rivencraft.LOGGER.error(
+                try {
-                            "Ignoring invalid writing symbol {}: {}", id, error))
+                    loaded.put(id, SymbolDefinition.parse(json));
-                    .ifPresent(definition -> loaded.put(id, definition)));
+                } catch (IllegalArgumentException exception) {
+                    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/SymbolDefinition.java

@@ -1,47 +1,127 @@
 package net.dnorberg.rivencraft.writing;
 
-import com.mojang.serialization.Codec;
+import com.google.gson.JsonElement;
-import com.mojang.serialization.DataResult;
+import com.google.gson.JsonObject;
-import com.mojang.serialization.codecs.RecordCodecBuilder;
+import com.google.gson.JsonPrimitive;
 import java.util.Objects;
+import java.util.Optional;
+import java.util.Set;
 import java.util.regex.Pattern;
 import net.minecraft.resources.ResourceLocation;
 
-/** Server-loaded, non-executable display metadata for a writing symbol. */
+/** Server-only symbol definition. Only display metadata crosses to clients. */
 public record SymbolDefinition(
         int schemaVersion,
         String nameTranslationKey,
         String descriptionTranslationKey,
-        ResourceLocation category
+        ResourceLocation category,
+        Optional<SymbolSemantics> semantics,
+        String poem
 ) {
-    public static final int CURRENT_SCHEMA_VERSION = 1;
+    public static final int CURRENT_SCHEMA_VERSION = 2;
     private static final Pattern TRANSLATION_KEY = Pattern.compile("[a-z0-9_.-]+");
-    private static final Codec<String> TRANSLATION_KEY_CODEC = Codec.STRING.comapFlatMap(
+    private static final Set<String> V2_FIELDS = Set.of(
-            value -> TRANSLATION_KEY.matcher(value).matches()
+            "schema_version", "name", "description", "category", "semantics", "poem");
-                    ? DataResult.success(value)
-                    : DataResult.error(() -> "Invalid translation key: " + value),
-            value -> value
-    );
-    public static final Codec<SymbolDefinition> CODEC = RecordCodecBuilder.<SymbolDefinition>create(instance -> instance.group(
-            Codec.INT.fieldOf("schema_version").forGetter(SymbolDefinition::schemaVersion),
-            TRANSLATION_KEY_CODEC.fieldOf("name").forGetter(SymbolDefinition::nameTranslationKey),
-            TRANSLATION_KEY_CODEC.fieldOf("description").forGetter(SymbolDefinition::descriptionTranslationKey),
-            ResourceLocation.CODEC.fieldOf("category").forGetter(SymbolDefinition::category)
-    ).apply(instance, SymbolDefinition::new)).flatXmap(SymbolDefinition::validate, SymbolDefinition::validate);
 
     public SymbolDefinition {
         Objects.requireNonNull(nameTranslationKey, "nameTranslationKey");
         Objects.requireNonNull(descriptionTranslationKey, "descriptionTranslationKey");
         Objects.requireNonNull(category, "category");
+        semantics = Objects.requireNonNull(semantics, "semantics");
+        poem = Objects.requireNonNull(poem, "poem");
+        if (schemaVersion != 1 && schemaVersion != CURRENT_SCHEMA_VERSION) {
+            throw new IllegalArgumentException("Unsupported schema_version " + schemaVersion);
+        }
+        if (schemaVersion == 1 && semantics.isPresent()) {
+            throw new IllegalArgumentException("Schema v1 symbols cannot have semantics");
+        }
+        if (schemaVersion == CURRENT_SCHEMA_VERSION && semantics.isEmpty()) {
+            throw new IllegalArgumentException("Schema v2 symbols require semantics");
+        }
+        validateTranslationKey(nameTranslationKey, "name");
+        validateTranslationKey(descriptionTranslationKey, "description");
+        if (!poem.isEmpty() && (poem.length() > 96
+                || !poem.matches("[A-Za-z]+(?: [A-Za-z]+){3}"))) {
+            throw new IllegalArgumentException("'poem' must contain exactly four alphabetic words");
+        }
+    }
+
+    /** v1 remains display-only; v2 has an exact field set and typed semantics. */
+    public static SymbolDefinition parse(JsonElement json) {
+        if (json == null || !json.isJsonObject()) {
+            throw new IllegalArgumentException("Symbol definition must be a JSON object");
+        }
+        JsonObject object = json.getAsJsonObject();
+        int version = requiredInteger(object, "schema_version");
+        if (version != 1 && version != CURRENT_SCHEMA_VERSION) {
+            throw new IllegalArgumentException("Unsupported schema_version " + version);
+        }
+        if (version == CURRENT_SCHEMA_VERSION) {
+            for (String field : object.keySet()) {
+                if (!V2_FIELDS.contains(field)) {
+                    throw new IllegalArgumentException("Unknown symbol field '" + field + "'");
+                }
+            }
+        } else if (object.has("semantics")) {
+            throw new IllegalArgumentException("Schema v1 cannot declare semantics; use schema_version 2");
+        }
+        String name = requiredString(object, "name");
+        String description = requiredString(object, "description");
+        ResourceLocation category = requiredResourceLocation(object, "category",
+                version == CURRENT_SCHEMA_VERSION);
+        Optional<SymbolSemantics> semantics = version == CURRENT_SCHEMA_VERSION
+                ? Optional.of(SymbolSemantics.parse(object.get("semantics")))
+                : Optional.empty();
+        String poem = object.has("poem") ? requiredString(object, "poem") : "";
+        return new SymbolDefinition(version, name, description, category, semantics, poem);
     }
 
     public SymbolDisplayMetadata display(ResourceLocation id) {
-        return new SymbolDisplayMetadata(id, nameTranslationKey, descriptionTranslationKey, category, true);
+        return new SymbolDisplayMetadata(id, nameTranslationKey, descriptionTranslationKey, category, true, poem);
     }
 
-    private static DataResult<SymbolDefinition> validate(SymbolDefinition definition) {
+    static String requiredString(JsonObject object, String field) {
-        return definition.schemaVersion == CURRENT_SCHEMA_VERSION
+        JsonElement element = object.get(field);
-                ? DataResult.success(definition)
+        if (element == null || !element.isJsonPrimitive()
-                : DataResult.error(() -> "Unsupported symbol schema_version " + definition.schemaVersion);
+                || !element.getAsJsonPrimitive().isString()) {
+            throw new IllegalArgumentException("'" + field + "' must be a string");
+        }
+        return element.getAsString();
+    }
+
+    static ResourceLocation requiredResourceLocation(JsonObject object, String field) {
+        return requiredResourceLocation(object, field, true);
+    }
+
+    private static ResourceLocation requiredResourceLocation(JsonObject object, String field, boolean canonical) {
+        String value = requiredString(object, field);
+        ResourceLocation id = ResourceLocation.tryParse(value);
+        if (id == null || (canonical && !id.toString().equals(value))) {
+            throw new IllegalArgumentException("'" + field + "' must be "
+                    + (canonical ? "a canonical namespaced ID" : "a resource location") + ": " + value);
+        }
+        return id;
+    }
+
+    private static int requiredInteger(JsonObject object, String field) {
+        JsonElement element = object.get(field);
+        if (element == null || !element.isJsonPrimitive()) {
+            throw new IllegalArgumentException("'" + field + "' must be an integer");
+        }
+        JsonPrimitive primitive = element.getAsJsonPrimitive();
+        if (!primitive.isNumber() || !primitive.getAsString().matches("-?\\d+")) {
+            throw new IllegalArgumentException("'" + field + "' must be an integer");
+        }
+        try {
+            return Integer.parseInt(primitive.getAsString());
+        } catch (NumberFormatException exception) {
+            throw new IllegalArgumentException("'" + field + "' is outside the integer range", exception);
+        }
+    }
+
+    private static void validateTranslationKey(String value, String field) {
+        if (!TRANSLATION_KEY.matcher(value).matches()) {
+            throw new IllegalArgumentException("Invalid '" + field + "' translation key: " + value);
+        }
     }
 }

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

@@ -14,14 +14,16 @@ public record SymbolDisplayMetadata(
         String nameTranslationKey,
         String descriptionTranslationKey,
         ResourceLocation category,
-        boolean resolved
+        boolean resolved,
+        String poem
 ) {
     public static final Codec<SymbolDisplayMetadata> CODEC = RecordCodecBuilder.create(instance -> instance.group(
             ResourceLocation.CODEC.fieldOf("id").forGetter(SymbolDisplayMetadata::id),
             Codec.STRING.fieldOf("name").forGetter(SymbolDisplayMetadata::nameTranslationKey),
             Codec.STRING.fieldOf("description").forGetter(SymbolDisplayMetadata::descriptionTranslationKey),
             ResourceLocation.CODEC.fieldOf("category").forGetter(SymbolDisplayMetadata::category),
-            Codec.BOOL.fieldOf("resolved").forGetter(SymbolDisplayMetadata::resolved)
+            Codec.BOOL.fieldOf("resolved").forGetter(SymbolDisplayMetadata::resolved),
+            Codec.STRING.optionalFieldOf("poem", "").forGetter(SymbolDisplayMetadata::poem)
     ).apply(instance, SymbolDisplayMetadata::new));
     public static final StreamCodec<ByteBuf, SymbolDisplayMetadata> STREAM_CODEC = StreamCodec.composite(
             ResourceLocation.STREAM_CODEC, SymbolDisplayMetadata::id,
@@ -29,6 +31,7 @@ public record SymbolDisplayMetadata(
             ByteBufCodecs.STRING_UTF8, SymbolDisplayMetadata::descriptionTranslationKey,
             ResourceLocation.STREAM_CODEC, SymbolDisplayMetadata::category,
             ByteBufCodecs.BOOL, SymbolDisplayMetadata::resolved,
+            ByteBufCodecs.STRING_UTF8, SymbolDisplayMetadata::poem,
             SymbolDisplayMetadata::new
     );
 
@@ -38,7 +41,8 @@ public record SymbolDisplayMetadata(
                 "symbol.rivencraft.unresolved",
                 "symbol.rivencraft.unresolved.description",
                 ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "unresolved"),
-                false
+                false,
+                ""
         );
     }
 }

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

@@ -0,0 +1,30 @@
+package net.dnorberg.rivencraft.writing;
+
+/**
+ * Number components from Mystcraft Legacy's ModWords#constructNumber.
+ * Legacy registers 0–25; larger Rivencraft tab numbers use positional base 25.
+ */
+public final class SymbolNumerals {
+    private SymbolNumerals() {}
+
+    public static int[] digitsFor(int number) {
+        if (number < 0) throw new IllegalArgumentException("Numeral must be non-negative");
+        if (number < 25) return new int[] {number};
+        int count = 0;
+        for (int remaining = number; remaining > 0; remaining /= 25) count++;
+        int[] digits = new int[count];
+        for (int remaining = number, index = count - 1; index >= 0; index--, remaining /= 25)
+            digits[index] = remaining % 25;
+        return digits;
+    }
+
+    public static int[] componentsForDigit(int digit) {
+        if (digit < 0 || digit >= 25) throw new IllegalArgumentException("Numeral digit must be in [0, 24]");
+        if (digit == 0) return new int[] {1};
+        int fifths = digit / 5;
+        int remainder = digit % 5;
+        if (fifths == 0) return new int[] {55 + remainder};
+        if (remainder == 0) return new int[] {59 + fifths};
+        return new int[] {59 + fifths, 55 + remainder};
+    }
+}

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

@@ -0,0 +1,26 @@
+package net.dnorberg.rivencraft.writing;
+
+import net.minecraft.resources.ResourceLocation;
+
+/** Legacy poems for existing starter pages, including stacks saved before poem metadata existed. */
+public final class SymbolPoems {
+    private SymbolPoems() {}
+
+    public static String builtIn(ResourceLocation id) {
+        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";
+            case "celestial/normal_time" -> "Transform Time System Balance";
+            case "feature/caves" -> "Terrain Transform Void Flow";
+            default -> "";
+        };
+    }
+}

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

@@ -0,0 +1,120 @@
+package net.dnorberg.rivencraft.writing;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonPrimitive;
+import java.util.Arrays;
+import java.util.Objects;
+import java.util.Set;
+import net.minecraft.resources.ResourceLocation;
+
+/** Bounded grammar role and value, retained by the server catalog only. */
+public record SymbolSemantics(Role role, Value value) {
+    public SymbolSemantics {
+        Objects.requireNonNull(role, "role");
+        Objects.requireNonNull(value, "value");
+        if (!role.accepts(value)) {
+            throw new IllegalArgumentException("Invalid semantics.value for role '" + role.id
+                    + "': " + value + "; expected " + role.expected());
+        }
+    }
+
+    public static SymbolSemantics parse(JsonElement json) {
+        if (json == null || !json.isJsonObject()) {
+            throw new IllegalArgumentException("'semantics' must be an object");
+        }
+        JsonObject object = json.getAsJsonObject();
+        for (String field : object.keySet()) {
+            if (!field.equals("role") && !field.equals("value")) {
+                throw new IllegalArgumentException("Unknown semantics field '" + field + "'");
+            }
+        }
+        String roleId = SymbolDefinition.requiredString(object, "role");
+        Role role = Arrays.stream(Role.values()).filter(candidate -> candidate.id.equals(roleId))
+                .findFirst().orElseThrow(() -> new IllegalArgumentException("Unknown semantic role '" + roleId + "'"));
+        JsonElement raw = object.get("value");
+        if (raw == null || !raw.isJsonPrimitive()) {
+            throw new IllegalArgumentException("'semantics.value' is required");
+        }
+        JsonPrimitive primitive = raw.getAsJsonPrimitive();
+        Value value;
+        if (role.kind == Kind.RESOURCE) {
+            value = new ResourceValue(SymbolDefinition.requiredResourceLocation(object, "value"));
+        } else if (role.kind == Kind.NUMBER) {
+            if (!primitive.isNumber()) {
+                throw new IllegalArgumentException("'semantics.value' for " + role.id + " must be a number");
+            }
+            value = new NumberValue(primitive.getAsDouble());
+        } else {
+            value = new ChoiceValue(SymbolDefinition.requiredString(object, "value"));
+        }
+        return new SymbolSemantics(role, value);
+    }
+
+    public sealed interface Value permits ResourceValue, ChoiceValue, NumberValue {}
+
+    public record ResourceValue(ResourceLocation id) implements Value {
+        public ResourceValue { Objects.requireNonNull(id, "id"); }
+    }
+
+    public record ChoiceValue(String id) implements Value {
+        public ChoiceValue { Objects.requireNonNull(id, "id"); }
+    }
+
+    public record NumberValue(double amount) implements Value {
+        public NumberValue {
+            if (!Double.isFinite(amount)) {
+                throw new IllegalArgumentException("Semantic numeric value must be finite");
+            }
+        }
+    }
+
+    private enum Kind { RESOURCE, CHOICE, NUMBER }
+
+    public enum Role {
+        TERRAIN("terrain", Kind.RESOURCE),
+        BIOME_CONTROLLER("biome_controller", Kind.CHOICE,
+                "native", "single", "tiled", "grid", "tiny", "small", "medium", "large", "huge"),
+        BIOME("biome", Kind.RESOURCE),
+        LIGHTING("lighting", Kind.CHOICE, "normal", "dark", "bright"),
+        WEATHER("weather", Kind.CHOICE,
+                "normal", "fast", "slow", "off", "always", "cloudy", "rain", "snow", "storm"),
+        CELESTIAL("celestial", Kind.CHOICE, "normal_time"),
+        PERIOD_MODIFIER("period_modifier", Kind.NUMBER),
+        ANGLE_MODIFIER("angle_modifier", Kind.NUMBER),
+        PHASE_MODIFIER("phase_modifier", Kind.NUMBER),
+        FEATURE("feature", Kind.RESOURCE);
+
+        private final String id;
+        private final Kind kind;
+        private final Set<String> choices;
+
+        Role(String id, Kind kind, String... choices) {
+            this.id = id;
+            this.kind = kind;
+            this.choices = Set.of(choices);
+        }
+
+        public String id() { return id; }
+
+        private boolean accepts(Value value) {
+            if (kind == Kind.RESOURCE) return value instanceof ResourceValue;
+            if (kind == Kind.CHOICE) return value instanceof ChoiceValue choice && choices.contains(choice.id());
+            if (!(value instanceof NumberValue number)) return false;
+            return switch (this) {
+                case PERIOD_MODIFIER -> number.amount() >= 0.0 && number.amount() <= 2.0;
+                case ANGLE_MODIFIER, PHASE_MODIFIER -> number.amount() >= 0.0 && number.amount() < 360.0;
+                default -> false;
+            };
+        }
+
+        private String expected() {
+            return switch (kind) {
+                case RESOURCE -> "a canonical namespaced ID";
+                case CHOICE -> "one of " + choices.stream().sorted().toList();
+                case NUMBER -> this == PERIOD_MODIFIER ? "a finite number in [0, 2]"
+                        : "a finite number in [0, 360) degrees";
+            };
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+package net.dnorberg.rivencraft.writing;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import net.dnorberg.rivencraft.block.entity.WritingDeskBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.minecraft.network.RegistryFriendlyByteBuf;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+
+/** A bounded, server-derived view of symbols physically present in the desk. */
+public final class WritingDeskCatalog {
+    private static final int MAX_ENTRIES = WritingDeskBlockEntity.COLLECTIONS * NotebookContents.MAX_PAGES;
+
+    private WritingDeskCatalog() {}
+
+    public static List<SymbolDisplayMetadata> available(WritingDeskBlockEntity desk) {
+        Map<ResourceLocation, SymbolDisplayMetadata> unique = new HashMap<>();
+        for (int slot = 0; slot < WritingDeskBlockEntity.COLLECTIONS; slot++) {
+            ItemStack collection = desk.getItem(slot);
+            if (collection.is(ModItems.PAGE.get())) add(unique, collection);
+            if (collection.is(ModItems.NOTEBOOK.get())) {
+                List<ItemStack> pages = collection.getOrDefault(
+                        ModDataComponents.NOTEBOOK_CONTENTS.get(), NotebookContents.EMPTY).pages();
+                pages.forEach(page -> add(unique, page));
+            }
+        }
+        return unique.values().stream()
+                .sorted(Comparator.comparing((SymbolDisplayMetadata symbol) -> symbol.category().toString())
+                        .thenComparing(symbol -> symbol.id().toString()))
+                .toList();
+    }
+
+    private static void add(Map<ResourceLocation, SymbolDisplayMetadata> unique, ItemStack page) {
+        if (!page.is(ModItems.PAGE.get())) return;
+        PageContent content = PageItem.content(page).resolve();
+        if (content.kind() != PageContent.Kind.SYMBOL) return;
+        SymbolReference reference = content.symbol().orElseThrow();
+        SymbolCatalog.find(reference).ifPresent(definition ->
+                unique.put(reference.id(), definition.display(reference.id())));
+    }
+
+    public static void write(RegistryFriendlyByteBuf buffer, List<SymbolDisplayMetadata> entries) {
+        if (entries.size() > MAX_ENTRIES) throw new IllegalArgumentException("Desk symbol catalog exceeds limit");
+        buffer.writeVarInt(entries.size());
+        entries.forEach(entry -> SymbolDisplayMetadata.STREAM_CODEC.encode(buffer, entry));
+    }
+
+    public static List<SymbolDisplayMetadata> read(RegistryFriendlyByteBuf buffer) {
+        int count = buffer.readVarInt();
+        if (count < 0 || count > MAX_ENTRIES) throw new IllegalArgumentException("Invalid desk symbol count " + count);
+        List<SymbolDisplayMetadata> entries = new ArrayList<>(count);
+        for (int index = 0; index < count; index++) {
+            entries.add(SymbolDisplayMetadata.STREAM_CODEC.decode(buffer));
+        }
+        return List.copyOf(entries);
+    }
+}

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/java/net/dnorberg/rivencraft/writing/WritingInkService.java

@@ -29,7 +29,7 @@ public final class WritingInkService {
         int remaining = InkVialItem.remaining(vial);
         return vial.is(ModItems.INK_VIAL.get()) && remaining >= linkPanelCost()
                 && remaining <= InkVialItem.CAPACITY
-                && page.is(ModItems.PAGE.get()) && PageItem.content(page).kind() == PageContent.Kind.BLANK;
+                && page.is(Items.PAPER);
     }
 
     public static boolean prepareLinkPanel(Player player, InteractionHand vialHand) {

src/main/resources/assets/rivencraft/blockstates/book_binder.json

@@ -0,0 +1,8 @@
+{
+  "variants": {
+    "facing=north": {"model":"rivencraft:block/book_binder"},
+    "facing=east": {"model":"rivencraft:block/book_binder","y":90},
+    "facing=south": {"model":"rivencraft:block/book_binder","y":180},
+    "facing=west": {"model":"rivencraft:block/book_binder","y":270}
+  }
+}

src/main/resources/assets/rivencraft/blockstates/ink_mixer.json

@@ -0,0 +1,5 @@
+{
+  "variants": {
+    "": { "model": "rivencraft:block/ink_mixer" }
+  }
+}

src/main/resources/assets/rivencraft/blockstates/writing_desk.json

@@ -1,8 +1,12 @@
 {
   "variants": {
-    "facing=north": { "model": "rivencraft:block/writing_desk" },
+    "facing=north,extension=false": {"model":"rivencraft:block/writing_desk"},
-    "facing=east": { "model": "rivencraft:block/writing_desk", "y": 90 },
+    "facing=east,extension=false": {"model":"rivencraft:block/writing_desk","y":90},
-    "facing=south": { "model": "rivencraft:block/writing_desk", "y": 180 },
+    "facing=south,extension=false": {"model":"rivencraft:block/writing_desk","y":180},
-    "facing=west": { "model": "rivencraft:block/writing_desk", "y": 270 }
+    "facing=west,extension=false": {"model":"rivencraft:block/writing_desk","y":270},
+    "facing=north,extension=true": {"model":"rivencraft:block/writing_desk_extension"},
+    "facing=east,extension=true": {"model":"rivencraft:block/writing_desk_extension","y":90},
+    "facing=south,extension=true": {"model":"rivencraft:block/writing_desk_extension","y":180},
+    "facing=west,extension=true": {"model":"rivencraft:block/writing_desk_extension","y":270}
   }
 }

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

@@ -18,8 +18,45 @@
   "item.rivencraft.ink_vial": "Ink Vial",
   "block.rivencraft.writing_desk": "Writing Desk",
   "container.rivencraft.writing_desk": "Writing Desk",
+  "block.rivencraft.book_binder": "Book Binder",
+  "container.rivencraft.book_binder": "Book Binder",
+  "block.rivencraft.ink_mixer": "Ink Mixer",
+  "container.rivencraft.ink_mixer": "Ink Mixer",
+  "screen.rivencraft.ink_mixer.ink": "Ink: %s/%s",
+  "screen.rivencraft.book_binder.title": "Book title",
+  "screen.rivencraft.book_binder.title_hint": "Name the book",
+  "screen.rivencraft.book_binder.missing_panel": "Link Panel required as the first page",
+  "screen.rivencraft.book_binder.cover": "Cover · Link Panel · Notebook",
+  "screen.rivencraft.book_binder.import": "Import Notebook",
+  "screen.rivencraft.book_binder.import.tooltip": "Move all Notebook pages into the binder in order",
+  "screen.rivencraft.book_binder.move_previous": "Move selected page left",
+  "screen.rivencraft.book_binder.move_next": "Move selected page right",
+  "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)",
+  "screen.rivencraft.writing_desk.all": "Show pages from all tabs",
+  "screen.rivencraft.writing_desk.category": "Cycle page category: %s",
+  "screen.rivencraft.writing_desk.all_categories": "All categories",
+  "screen.rivencraft.writing_desk.previous_tabs": "Previous four tabs (Page Up)",
+  "screen.rivencraft.writing_desk.next_tabs": "Next four tabs (Page Down)",
+  "screen.rivencraft.writing_desk.tab_symbol": "Tab %s",
+  "screen.rivencraft.writing_desk.no_symbols": "No available symbols",
   "item.rivencraft.ink_vial.remaining": "Ink: %s/%s",
-  "item.rivencraft.ink_vial.usage": "Use with a blank Page in the other hand to prepare a Link Panel.",
+  "item.rivencraft.ink_vial.usage": "Use with paper in the other hand to prepare a Link Panel.",
   "screen.rivencraft.notebook.search": "Search pages",
   "screen.rivencraft.notebook.move_previous": "Move selected page left",
   "screen.rivencraft.notebook.move_next": "Move selected page right",
@@ -32,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",
@@ -46,6 +84,10 @@
   "screen.rivencraft.age.name_prompt": "Name this Age before writing the Descriptive Book",
   "screen.rivencraft.age.create": "Create",
   "screen.rivencraft.age.generator": "Terrain: %s",
+  "screen.rivencraft.age.pages": "Pages",
+  "screen.rivencraft.age.details": "Details",
+  "screen.rivencraft.age.pages_count": "Writing %s/%s",
+  "screen.rivencraft.age.pages_not_applied": "Symbols not applied yet",
   "screen.rivencraft.age.trait.biomes": "Biomes: %s",
   "screen.rivencraft.age.trait.lighting": "Lighting: %s",
   "screen.rivencraft.age.trait.weather": "Weather: %s",
@@ -78,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",
@@ -96,10 +181,18 @@
   "generator.rivencraft.void": "Void",
   "generator.rivencraft.random_vanilla": "Standard",
   "screen.rivencraft.book.preview_pending": "Loading destination...",
-  "screen.rivencraft.book.click_to_link": "Click the panel to link",
   "screen.rivencraft.book.explore": "Explore",
   "screen.rivencraft.book.exploring": "Exploring",
   "screen.rivencraft.book.return_from_explore": "Right-click to return",
+  "screen.rivencraft.book.previous_page": "Previous page (Left Arrow)",
+  "screen.rivencraft.book.next_page": "Next page (Right Arrow)",
+  "jei.rivencraft.writing": "Rivencraft Writing",
+  "jei.rivencraft.writing.link_panel_hand": "Hold paper and an Ink Vial in opposite hands; use the vial to make a Link Panel.",
+  "jei.rivencraft.ink_mixer": "Ink Mixer",
+  "jei.rivencraft.ink_mixer.usage": "Paper + ink makes a Link Panel. One vial fills 16 ink; each panel uses the configured ink cost. The empty vial returns as a glass bottle.",
+  "jei.rivencraft.writing.copy": "At a Writing Desk, select a stored Page, add paper and ink, then take the copy. The source Page stays.",
+  "jei.rivencraft.writing.bind": "At a Book Binder, name the Age and add a cover plus Link Panel. Optional symbol Pages follow the panel.",
+  "jei.rivencraft.writing.linking_book": "Craft one Link Panel Page with leather to make an unwritten Linking Book. Open it to name and bind it.",
   "itemGroup.rivencraft": "Rivencraft",
   "itemGroup.rivencraft.pages": "Rivencraft Pages"
 }

src/main/resources/assets/rivencraft/models/block/book_binder.json

@@ -0,0 +1,61 @@
+{
+  "parent": "minecraft:block/block",
+  "textures": {
+    "particle": "rivencraft:block/book_binder",
+    "body": "rivencraft:block/book_binder",
+    "press": "rivencraft:block/book_binder_press"
+  },
+  "elements": [
+    {
+      "from": [0, 0, 0], "to": [16, 10, 16],
+      "faces": {
+        "north": {"texture":"#body","uv":[0,4,4,6.5]},
+        "east": {"texture":"#body","uv":[4,4,8,6.5]},
+        "south": {"texture":"#body","uv":[8,4,12,6.5]},
+        "west": {"texture":"#body","uv":[12,4,16,6.5]},
+        "up": {"texture":"#body","uv":[4,0,8,4]},
+        "down": {"texture":"#body","uv":[8,0,12,4]}
+      }
+    },
+    {
+      "from": [0, 10, 1], "to": [3, 14, 15],
+      "faces": {
+        "north": {"texture":"#press","uv":[0,4,1.5,6]},
+        "east": {"texture":"#press","uv":[0,0,7,2]},
+        "south": {"texture":"#press","uv":[2,4,3.5,6]},
+        "west": {"texture":"#press","uv":[0,2,7,4]},
+        "up": {"texture":"#press","uv":[7,0,8.5,6]},
+        "down": {"texture":"#press","uv":[8.5,0,10,7]}
+      }
+    },
+    {
+      "from": [13, 10, 1], "to": [16, 14, 15],
+      "faces": {
+        "north": {"texture":"#press","uv":[0,4,1.5,6]},
+        "east": {"texture":"#press","uv":[0,0,7,2]},
+        "south": {"texture":"#press","uv":[2,4,3.5,6]},
+        "west": {"texture":"#press","uv":[0,2,7,4]},
+        "up": {"texture":"#press","uv":[7,0,8.5,6]},
+        "down": {"texture":"#press","uv":[8.5,0,10,7]}
+      }
+    },
+    {
+      "from": [3, 11, 3], "to": [13, 12, 4],
+      "faces": {
+        "north": {"texture":"#press","uv":[1,15.5,6,16]},
+        "south": {"texture":"#press","uv":[7,15.5,12,16]},
+        "up": {"texture":"#press","uv":[0.5,15,5.5,15.5]},
+        "down": {"texture":"#press","uv":[5.5,15,10.5,15.5]}
+      }
+    },
+    {
+      "from": [3, 11, 12], "to": [13, 12, 13],
+      "faces": {
+        "north": {"texture":"#press","uv":[1,15.5,6,16]},
+        "south": {"texture":"#press","uv":[7,15.5,12,16]},
+        "up": {"texture":"#press","uv":[0.5,15,5.5,15.5]},
+        "down": {"texture":"#press","uv":[5.5,15,10.5,15.5]}
+      }
+    }
+  ]
+}

src/main/resources/assets/rivencraft/models/block/ink_mixer.json

@@ -0,0 +1,23 @@
+{
+  "parent": "minecraft:block/block",
+  "textures": {
+    "particle": "rivencraft:block/ink_mixer_side",
+    "side": "rivencraft:block/ink_mixer_side",
+    "top": "rivencraft:block/ink_mixer_top",
+    "bottom": "rivencraft:block/ink_mixer_bottom"
+  },
+  "elements": [
+    {
+      "from": [0, 0, 0],
+      "to": [16, 12, 16],
+      "faces": {
+        "north": { "texture": "#side", "uv": [0, 4, 16, 16] },
+        "east": { "texture": "#side", "uv": [0, 4, 16, 16] },
+        "south": { "texture": "#side", "uv": [0, 4, 16, 16] },
+        "west": { "texture": "#side", "uv": [0, 4, 16, 16] },
+        "up": { "texture": "#top" },
+        "down": { "texture": "#bottom" }
+      }
+    }
+  ]
+}

src/main/resources/assets/rivencraft/models/block/writing_desk.json

@@ -1,8 +1,62 @@
 {
-  "parent": "minecraft:block/cube_bottom_top",
+	"format_version": "26.3",
-  "textures": {
+	"credit": "Made with Blockbench",
-    "top": "rivencraft:item/writing_desk",
+	"parent": "minecraft:block/block",
-    "side": "minecraft:block/oak_planks",
+	"textures": {
-    "bottom": "minecraft:block/oak_planks"
+		"2": "rivencraft:block/writing_desk",
-  }
+		"particle": "rivencraft:block/writing_desk"
+	},
+	"elements": [
+		{
+			"from": [0, 11, 0],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 3, 0]},
+			"faces": {
+				"north": {"uv": [1, 2, 2, 2.125], "texture": "#2"},
+				"east": {"uv": [2.82031, 4.01563, 3.82031, 4.125], "texture": "#2"},
+				"south": {"uv": [0, 2, 1, 2.125], "texture": "#2"},
+				"west": {"uv": [2.9375, 0.125, 3, 2.125], "rotation": 90, "texture": "#2"},
+				"up": {"uv": [1, 0, 2, 2], "texture": "#2"},
+				"down": {"uv": [3, 0, 3.9375, 2], "texture": "#2"}
+			}
+		},
+		{
+			"from": [0, 0, 1],
+			"to": [1, 11, 15],
+			"faces": {
+				"north": {"uv": [7.6875, 2.625, 7.75, 4], "texture": "#2"},
+				"east": {"uv": [7.6875, 2.625, 6.6875, 4], "texture": "#2"},
+				"south": {"uv": [1.42188, 10.78125, 2.4375, 11.85938], "texture": "#2"},
+				"west": {"uv": [5.67969, 2.625, 6.6875, 4], "texture": "#2"},
+				"up": {"uv": [0.08594, 10.36719, 1.14063, 11.83594], "texture": "#2"},
+				"down": {"uv": [5.75, 5.25, 5.8125, 7.10938], "texture": "#2"}
+			}
+		},
+		{
+			"from": [1, 5, 1],
+			"to": [16, 6, 15],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 2, 0]},
+			"faces": {
+				"north": {"uv": [3, 2, 3.9375, 2.125], "texture": "#2"},
+				"east": {"uv": [2.8125, 4, 3.75, 4.125], "texture": "#2"},
+				"south": {"uv": [1.35938, 11.71875, 2.44531, 12.71875], "texture": "#2"},
+				"west": {"uv": [0.03125, 11.66406, 0.99219, 12.66406], "texture": "#2"},
+				"up": {"uv": [1.875, 4, 2.8125, 2.125], "texture": "#2"},
+				"down": {"uv": [0.9375, 2.125, 1.875, 4], "texture": "#2"}
+			}
+		},
+		{
+			"from": [0, 0, 15],
+			"to": [16, 11, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, -9, 0]},
+			"faces": {
+				"north": {"uv": [8.0625, 0, 9.0625, 1.375], "texture": "#2"},
+				"east": {"uv": [6.625, 0.125, 6.6875, 1.5], "texture": "#2"},
+				"south": {"uv": [5.625, 2.625, 6.625, 4], "texture": "#2"},
+				"west": {"uv": [7.6875, 2.625, 7.75, 4], "texture": "#2"},
+				"up": {"uv": [0, 15, 16, 16], "texture": "#2"},
+				"down": {"uv": [0, 9.17969, 16, 10.17969], "texture": "#2"}
+			}
+		}
+	]
 }

src/main/resources/assets/rivencraft/models/block/writing_desk_extension.json

@@ -0,0 +1,88 @@
+{
+	"format_version": "26.3",
+	"credit": "Made with Blockbench",
+	"parent": "minecraft:block/block",
+	"textures": {
+		"2": "rivencraft:block/writing_desk",
+		"particle": "rivencraft:block/writing_desk"
+	},
+	"elements": [
+		{
+			"from": [1, 0, 1],
+			"to": [15, 1, 15],
+			"rotation": {"angle": 0, "axis": "y", "origin": [1, 0, 0]},
+			"faces": {
+				"north": {"uv": [1.8125, 4.125, 2.8125, 4.25], "texture": "#2"},
+				"east": {"uv": [0.21875, 11.88281, 1.04688, 12.88281], "texture": "#2"},
+				"south": {"uv": [1.53906, 10.5625, 2.63281, 11.5625], "texture": "#2"},
+				"west": {"uv": [0.14063, 10.5625, 1.17969, 11.5625], "texture": "#2"},
+				"up": {"uv": [1.8125, 4.125, 2.8125, 2.125], "texture": "#2"},
+				"down": {"uv": [4, 0, 5, 2], "texture": "#2"}
+			}
+		},
+		{
+			"from": [0, 11, 0],
+			"to": [16, 12, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, 3, 0]},
+			"faces": {
+				"north": {"uv": [2, 2, 3, 2.125], "texture": "#2"},
+				"east": {"uv": [1, 0, 1.0625, 2], "rotation": 90, "texture": "#2"},
+				"south": {"uv": [3, 2, 4, 2.125], "texture": "#2"},
+				"west": {"uv": [2.8125, 4, 3.8125, 4.125], "texture": "#2"},
+				"up": {"uv": [2, 0, 3, 2], "texture": "#2"},
+				"down": {"uv": [9, 0, 10, 2], "texture": "#2"}
+			}
+		},
+		{
+			"from": [15, 0, 1],
+			"to": [16, 11, 15],
+			"faces": {
+				"north": {"uv": [7.6875, 2.625, 7.75, 4], "texture": "#2"},
+				"east": {"uv": [10.00156, 0.625, 11.00156, 2], "texture": "#2"},
+				"south": {"uv": [1.99219, 10.77344, 2.99219, 12.02344], "texture": "#2"},
+				"west": {"uv": [6.6875, 2.625, 7.6875, 4], "texture": "#2"},
+				"up": {"uv": [0.49219, 10.96094, 1.49219, 12.08594], "texture": "#2"},
+				"down": {"uv": [5.75313, 5.36719, 5.8125, 7.125], "texture": "#2"}
+			}
+		},
+		{
+			"from": [0, 0, 1],
+			"to": [1, 11, 15],
+			"rotation": {"angle": 0, "axis": "y", "origin": [-15, 0, 0]},
+			"faces": {
+				"north": {"uv": [7.68828, 2.625, 7.75078, 4], "texture": "#2"},
+				"east": {"uv": [7.6875, 2.62539, 6.6875, 4.00039], "texture": "#2"},
+				"south": {"uv": [0.05469, 12.22656, 1.05469, 13.32031], "texture": "#2"},
+				"west": {"uv": [3, 0, 4, 1.375], "texture": "#2"},
+				"up": {"uv": [0.15625, 10.83594, 1.15625, 11.97656], "texture": "#2"},
+				"down": {"uv": [7, 4.60156, 7.0625, 6.375], "texture": "#2"}
+			}
+		},
+		{
+			"from": [1, 5, 1],
+			"to": [15, 6, 15],
+			"rotation": {"angle": 0, "axis": "y", "origin": [1, 2, 0]},
+			"faces": {
+				"north": {"uv": [1.8125, 4.25, 2.8125, 4.125], "texture": "#2"},
+				"east": {"uv": [1.86719, 11.82813, 2.79688, 12.82813], "texture": "#2"},
+				"south": {"uv": [0.32813, 11.80469, 1.28906, 12.80469], "texture": "#2"},
+				"west": {"uv": [0.27344, 10.5625, 1.53125, 11.5625], "texture": "#2"},
+				"up": {"uv": [1.8125, 4.125, 2.8125, 2.125], "texture": "#2"},
+				"down": {"uv": [9, 0, 10, 2], "texture": "#2"}
+			}
+		},
+		{
+			"from": [0, 0, 15],
+			"to": [16, 11, 16],
+			"rotation": {"angle": 0, "axis": "y", "origin": [0, -9, 0]},
+			"faces": {
+				"north": {"uv": [9, 0.125, 10, 1.5], "texture": "#2"},
+				"east": {"uv": [10.8125, 0.625, 10.875, 2], "texture": "#2"},
+				"south": {"uv": [10.875, 0.625, 11.875, 2], "texture": "#2"},
+				"west": {"uv": [6.6875, 0.125, 6.75, 1.5], "texture": "#2"},
+				"up": {"uv": [0, 15, 16, 16], "texture": "#2"},
+				"down": {"uv": [2.8125, 4, 3.8125, 4.125], "texture": "#2"}
+			}
+		}
+	]
+}

src/main/resources/assets/rivencraft/models/item/book_binder.json

@@ -0,0 +1,3 @@
+{
+  "parent": "rivencraft:block/book_binder"
+}

src/main/resources/assets/rivencraft/models/item/ink_mixer.json

@@ -0,0 +1,3 @@
+{
+  "parent": "rivencraft:block/ink_mixer"
+}

src/main/resources/assets/rivencraft/models/item/page.json

@@ -1,17 +1,13 @@
 {
-  "parent": "minecraft:item/generated",
+  "parent": "builtin/entity",
-  "textures": {
+  "gui_light": "front",
-    "layer0": "rivencraft:item/page"
+  "display": {
-  },
+    "ground": { "translation": [0, 2, 0], "scale": [0.5, 0.5, 0.5] },
-  "overrides": [
+    "head": { "rotation": [0, 180, 0], "translation": [0, 13, 7] },
-    { "predicate": { "custom_model_data": 1 }, "model": "rivencraft:item/page_link_panel" },
+    "thirdperson_righthand": { "translation": [0, 3, 1], "scale": [0.55, 0.55, 0.55] },
-    { "predicate": { "custom_model_data": 2 }, "model": "rivencraft:item/page_unresolved" },
+    "thirdperson_lefthand": { "translation": [0, 3, 1], "scale": [0.55, 0.55, 0.55] },
-    { "predicate": { "custom_model_data": 3 }, "model": "rivencraft:item/page_symbol" },
+    "firstperson_righthand": { "rotation": [0, -90, 25], "translation": [1.13, 3.2, 1.13], "scale": [0.68, 0.68, 0.68] },
-    { "predicate": { "custom_model_data": 100 }, "model": "rivencraft:item/page_symbol_terrain_standard" },
+    "firstperson_lefthand": { "rotation": [0, 90, -25], "translation": [1.13, 3.2, 1.13], "scale": [0.68, 0.68, 0.68] },
-    { "predicate": { "custom_model_data": 101 }, "model": "rivencraft:item/page_symbol_biome_native" },
+    "fixed": { "rotation": [0, 180, 0] }
-    { "predicate": { "custom_model_data": 102 }, "model": "rivencraft:item/page_symbol_lighting_normal" },
+  }
-    { "predicate": { "custom_model_data": 103 }, "model": "rivencraft:item/page_symbol_weather_normal" },
-    { "predicate": { "custom_model_data": 104 }, "model": "rivencraft:item/page_symbol_celestial_normal_time" },
-    { "predicate": { "custom_model_data": 105 }, "model": "rivencraft:item/page_symbol_feature_caves" }
-  ]
 }

src/main/resources/assets/rivencraft/models/item/page_symbol_biome_native.json

@@ -1,4 +0,0 @@
-{
-  "parent": "minecraft:item/generated",
-  "textures": { "layer0": "rivencraft:item/page_symbol_biome_native" }
-}

src/main/resources/assets/rivencraft/models/item/page_symbol_celestial_normal_time.json

@@ -1,4 +0,0 @@
-{
-  "parent": "minecraft:item/generated",
-  "textures": { "layer0": "rivencraft:item/page_symbol_celestial_normal_time" }
-}