Complete Milestone 5 acceptance and streamline tests and assets (#42)

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

README.md

@@ -4,12 +4,13 @@ Rivencraft is a clean, incremental port of the ideas and gameplay of
 [Mystcraft Legacy](https://github.com/Mystcraft/Mystcraft-Legacy) to Minecraft
 1.21.1 on NeoForge.
 
-The bootstrap, books/linking, Ages, and writing-system milestones are complete.
+The bootstrap, books/linking, Ages, writing-system, and Age-grammar milestones are complete.
 The writing system uses a data-pack symbol catalog and persistent
-ordered-writing model. The project currently provides functional Linking Books
-and randomly seeded, persistent vanilla-like Ages created from page-free
-Descriptive Books. Instability and full symbol-to-world grammar interpretation
-have not been ported yet.
+ordered-writing model. Linking Books and Descriptive Books create persistent
+Ages from either authored supported symbols or seeded random completion.
+Instability and the remaining unsupported Legacy symbol effects have not been
+ported yet. The [Milestone 5 acceptance record](docs/MILESTONE_5_ACCEPTANCE.md)
+lists the supported grammar, optional integrations, and limits.
 
 Milestone 4 now includes stackable blank Pages plus server-created symbol,
 unresolved-symbol, and baseline link-panel states. Page visuals follow the
@@ -117,14 +118,14 @@ symbol meanings, page order, and runtime profile, so later data-pack changes do
 not reinterpret an existing Age. An authored terrain page selects its runtime
 profile. Built-in pages cover Standard, Amplified, Cave, Island, Flat, and Void;
 authored biome, environment, and supported feature pages also affect new Ages.
-Further symbol effects are scheduled for later Milestone 5 slices. The
+The
 writing is also stored on the book; the Descriptive Book screen's turned pages
 show ordered symbols and unresolved IDs. The Descriptive Book screen follows
 Legacy's book spread: the title and Age details are on the left, the destination
 preview is on the right, and clicks in the bottom corners turn pages. Ordered
-symbol pages appear before the final blank spread; their pictograms await
-Milestone 5. Link-panel-only books show their details in the enchantment-table
-font.
+symbol pages appear before the final blank spread with their runtime-rendered
+pictograms. Link-panel-only books use Rivencraft glyphs for their generated
+Age description.
 
 ## Linking Book
 

build.gradle

@@ -17,7 +17,7 @@ tasks.named('wrapper', Wrapper).configure {
 version = mod_version
 group = mod_group_id
 
-List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'desk', 'binder', 'mixer', 'recipe']
+List<String> archivedGameTestSuites = ['linking', 'environment', 'writing', 'grammar', 'generation', 'desk', 'binder', 'mixer', 'recipe']
 List<String> selectedArchivedGameTestSuites = providers.gradleProperty('withArchivedGameTests')
         .map { it.toBoolean() }.orElse(false).get() ? archivedGameTestSuites
         : providers.gradleProperty('archivedGameTestSuites').orElse('').get()

docs/AGE_PROFILES.md

@@ -40,6 +40,153 @@ profiles, not claims that Legacy had identically named terrain symbols.
 Every family retains a safe cobblestone arrival platform. An omitted terrain
 page still uses the deterministic seed-selected profile.
 
+The separate **Floating Islands** feature page adds rare high-altitude island
+clusters above Standard, Amplified, Sky Islands, Flat, or Void terrain; it does
+not replace the terrain page. The feature is seeded by the Age and saved with the written
+plan, so revisiting an Age recreates the same islands. Without a preceding
+Block page, the Age seed chooses one valid full-collision block from the Block
+Pages pool for the island body. A full-block material page immediately before
+Floating Islands overrides that choice. Ordinary surface biomes still get
+dirt/grass top layers; Nether and End biomes use the chosen block throughout.
+The feature is additive even on Sky Islands terrain,
+which already forms its own islands. Cave terrain rejects it. A page-free random
+Age may also roll Floating Islands as one of its material features.
+
+An unpaired Block or Fluid page chooses a compatible feature from the Age seed:
+full blocks can become Rocks, Floating Islands, Tendrils, Spheres, or Spikes; source fluids can become one
+of the lake features. Flat terrain can use Floating Islands, Tendrils, Spheres,
+or Spikes; Void can use Floating Islands, Tendrils, or Spheres; Cave can use
+Spheres or Tendrils. A page-free
+random Age rolls zero, one, or two distinct compatible material features, choosing each
+material from the Block or Fluid Pages pool. The choices are saved on the Age
+definition, so opening the Age again does not reroll them.
+Repeated Block/Fluid and Feature pages remain separate entries in authored
+writing. Each unpaired material gets its own compatible feature, and repeated
+decorations use separate placement rolls. Repeated unmodified feature pages
+choose different compatible materials until their material pool is exhausted.
+
+Structure pages are separate Feature symbols. Legacy's Dungeons, Mineshafts,
+Nether Fortresses, Strongholds, and Villages have writable pages, as do modern
+Trial Chambers, Bastion Remnants, Buried Treasure, Shipwrecks, Ocean Ruins,
+Pillager Outposts, Ruined Portals, Nether Fossils, Ancient Cities, and Trail
+Ruins. They use Minecraft's 1.21.1 structure templates and placement rules,
+not a recreation of 1.12.2 structure geometry. A page enables only its own
+structure set; absent pages do not inherit these structures from a biome.
+Nether Fortresses and Bastions use separate sets instead of vanilla's shared
+Nether-complexes set, so writing one does not enable the other. Dungeons use
+the vanilla monster-room feature with eight attempts per chunk; unpaged Ages
+do not inherit biome-default monster-room attempts. A page-free random Age
+may choose zero to two distinct compatible structure types, frozen on creation.
+An authored structure needs a compatible biome in the Age's selected pool.
+Fortresses, Bastions, and Nether Fossils require Cave terrain plus a Nether
+biome; surface-only structures reject Cave terrain. Void rejects all of these
+structure pages. Villages and Strongholds can also be written into Flat Ages.
+
+For visual testing, write a Standard/Plains/Single Age with Mineshafts,
+Villages, and Trial Chambers, then use `/locate structure` in that Age to find
+each. An unwritten Pillager Outpost should not locate there. Test a Cave Age
+with Nether Wastes/Single and either the Nether Fortresses or Bastion page:
+only the selected type should locate. Ocean structures need their matching
+ocean or beach biome page; Ancient Cities need Deep Dark. Check the new pages
+in Rivencraft's Feature creative tab and JEI as well.
+
+**Dense Ores** is an authored-only Feature page. Each copy replays one extra
+pass of every ore placement registered in the Age's nearby biomes, using that
+placement's existing height, vein-size, rarity, and biome rules. It therefore
+also densifies conventional mod-added ores without hard-coded mod IDs. Output
+blocks tagged `c:ores` qualify; OreConfiguration outputs with `_ore` in their
+registry name also qualify. A mod with a custom, non-OreConfiguration placed
+feature can opt in by tagging that feature `rivencraft:dense_ores`. Non-ore
+stone/dirt blobs are not repeated. Flat and Void reject the page, as does a
+biome pool without any ore placements. Page-free random Ages never roll Dense
+Ores. The extra pass applies only as new chunks generate; it does not retrofit
+existing chunks or discover ore systems that bypass biome placed features.
+
+For an in-game check, write a Standard/Plains/Single Age with Dense Ores and
+verify that new underground chunks contain visibly more vanilla ore while
+stone/dirt blob frequency remains unchanged. With an ore-adding mod installed,
+write an Age using a biome where that mod registers its ore and verify the ore
+also appears more often. Check that Flat plus Dense Ores is rejected by the
+Binder and that a random, Link-Panel-only Age has no Dense Ores feature page.
+
+**Obelisks** adds Legacy-shaped, rare 4×4 plinths with a 2×2 shaft rising 12
+blocks, at most one attempt per 128 chunks per page. A preceding full-block
+Block page chooses the material; otherwise the Age seed chooses from valid
+block pages. Repeated Obelisks pages make independent attempts. Generation is
+deterministic and stays within one chunk; it requires a reasonably level,
+exposed solid surface, so Cave and Void terrain reject the page. Standard,
+Amplified, Sky Islands, and Flat terrain permit it. Page-free random surface
+Ages can roll Obelisks as one of their material features.
+
+For a visual check, write a Standard or Flat Age with an Obelisks page and
+search newly generated terrain for the 4×4 base and 12-block shaft. Try a
+Block page such as Obsidian immediately before Obelisks to verify its material
+changes. The Binder should reject Obelisks in Cave and Void Ages. Placement
+is deliberately rare, so several hundred fresh chunks may be needed.
+
+For an in-game visual check, bind Descriptive Books with a Link Panel,
+one of Standard, Amplified, Sky Islands, Flat, or Void terrain, and the Floating Islands
+feature page in that order. Fly through each Age at roughly Y=170–220 and
+verify the elevated clusters appear above its unchanged base terrain. Reopen
+the same Age to check that island positions stay fixed. Islands should be less
+common than in the first test build (one source chunk in 128 instead of 64).
+Sky Islands should retain its terrain islands and gain occasional additional
+feature islands. Try Cave terrain too; the Binder should reject that pairing.
+
+**Skylands** is a separate subtractive feature, not the Sky Islands terrain
+profile or the additive Floating Islands feature. Following Legacy's primer
+filter, it removes base terrain below a smooth, seven-octave cutoff around
+world Y=76 and removes liquid above the cutoff. The selected terrain still
+generates first; Floating Islands and Tendrils are added afterward, so they
+can coexist with Skylands. Skylands has no Block-page modifier. It can be
+authored on every terrain, though Flat loses its low ground and Void has no
+base terrain to change. Page-free random noise Ages have a seeded one-in-eight
+chance to gain Skylands; random Flat and Void Ages do not roll this ineffective
+filter. The cloud-height and horizon changes from Legacy are not included yet.
+
+For an in-game check, compare Standard terrain with and without a Skylands
+page. Skylands should leave upper hills suspended over open space, while a
+Floating Islands page instead adds isolated high islands without removing the
+ground below. Try Sky Islands terrain plus Skylands to confirm the page filters
+the terrain rather than replacing its generator. A book with both Skylands and
+Floating Islands should retain the added feature islands above the cutoff.
+
+The **Tendrils** feature adapts Legacy's winding, branching cave-node geometry
+into solid tubes. It is additive on all current terrain families, including
+Flat, Void, and Cave; it does not change biome selection. A preceding full-
+collision Block page chooses the tendril material. Otherwise the Age seed
+chooses a valid Block Pages material, consistent with other authored material
+features. Page-free random Ages can select Tendrils as a solid-material feature,
+including on Cave terrain where the surface material features are unavailable.
+The shape and placement use only the Age seed and source-chunk coordinates, so
+revisiting an Age recreates the same geometry.
+
+**Spheres** and **Spikes** are two separate Feature pages. Spheres adds
+winding chains of solid sphere nodes within terrain generation; like Tendrils,
+it works on all terrain families, even Void and Cave. Spikes is a later,
+rarer surface decoration (roughly one attempt per 18 chunks) that rises from
+solid ground on Standard, Amplified, Sky Islands, or Flat terrain. Cave and
+Void reject the Spikes page because they do not provide a suitable exposed
+surface. Each page accepts its own immediately preceding full-collision Block
+page; without one, the Age seed chooses a compatible material. The pages
+remain distinct in the catalog, Creative menu, JEI, ordered writing, and
+saved Age definition. Page-free random Ages can select either where compatible.
+
+For an in-game check, make separate Void/Spheres and Flat/Spikes books with
+Glowstone Block pages directly before their respective Feature pages. Spheres
+should form connected bright globes across chunk boundaries in Void; Spikes
+should appear as rare upward clusters rooted on the Flat surface. Revisit the
+same Ages to confirm stable locations. Check that a Void/Spikes book is
+rejected, and that Spheres and Spikes remain two independently selectable
+pages in Creative and JEI.
+
+For a clear visual check, bind a Void Age with a Glowstone Block page followed
+by Tendrils. Fly around world Y=0–120 across several chunks: branching solid
+forms should appear in the otherwise empty dimension, continue across chunk
+borders, and remain in place after leaving and returning. Repeat with a lone
+Tendrils page to confirm its seed-chosen material, and with Cave terrain to
+confirm the feature does not require a surface biome.
+
 ## Written biome selection (generation version 16)
 
 Biome pages follow the terrain page and precede the distribution-control page
@@ -72,8 +219,15 @@ also accepted. Other cave/biome pairings are diagnosed and blocked for now.
 Milestone 6 instability should allow such illegal combinations as unstable
 Ages, without silently treating them as ordinary cave generation. Flat terrain
 uses Overworld choices when a distribution is authored; its Native default
-remains Plains. Void terrain defaults to The Void and needs additional authored
-biomes for a multi-biome distribution.
+remains Plains. Void terrain defaults to The Void when no biome page is written,
+but accepts authored biome pages. One authored biome uses Single distribution
+when no controller is written. An explicit multi-biome distribution needs enough
+authored biomes; The Void is not silently added to fill missing positions. These
+biome regions exist even without blocks or a Floating Islands page, so biome-
+dependent weather and optional season behavior can still vary there. To check
+this in-game, bind Void terrain with a Desert Biome page and no feature page:
+the Age should be empty while F3 reports Desert. A Void book without biome
+pages should instead report The Void.
 
 The resolved list of biome IDs, their order/repetitions, and distribution are
 frozen into the Age plan. A removed biome ID emits a warning and uses an

docs/ASSET_PROVENANCE.md

@@ -7,9 +7,8 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | Rivencraft asset | Upstream asset | Upstream revision | Changes |
 | --- | --- | --- | --- |
 | `assets/rivencraft/textures/item/page.png` | `assets/mystcraft/textures/items/page_background.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
-| `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; Notebook draws the native 30×40 page at atlas coordinates `(156, 0)` |
+| `assets/rivencraft/textures/gui/notebook_pages.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared by the Notebook, Desk, Binder, and turned left book page after removing a byte-identical duplicate |
 | `assets/rivencraft/textures/gui/bookui_cover.png` | `assets/mystcraft/gui/bookui_cover.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; shared book cover, with gold edges drawn only for Descriptive Books |
-| `assets/rivencraft/textures/gui/bookui_pagel.png` | `assets/mystcraft/gui/bookui_pagel.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; turned left page |
 | `assets/rivencraft/textures/gui/bookui_pager.png` | `assets/mystcraft/gui/bookui_pager.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; link-panel frame on the first right page |
 | `assets/rivencraft/textures/gui/bookui_rpage_full.png` | `assets/mystcraft/gui/bookui_rpage_full.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only; full right written page |
 | `assets/rivencraft/textures/item/writing_desk.png` | `assets/mystcraft/textures/items/writingdesk.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Namespace/path rename only |
@@ -25,6 +24,10 @@ project's GNU LGPL v3 license. Rivencraft itself uses the same license.
 | `assets/rivencraft/textures/item/page_link_panel.png` | `page_background.png` and `PageBuilder.BasicPageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Reproduces the legacy 160 px scale, black panel at `(25,30)`–`(135,75)`, and 128 px resample |
 | `assets/rivencraft/textures/gui/symbolcomponents.png` | `assets/mystcraft/textures/symbolcomponents.png` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Byte-identical shared 512×512 component sheet for client-side page composition |
 | Runtime-composed symbol pages (`SymbolPageTextures`) | `page_background.png`, `textures/symbolcomponents.png`, `WordData`, `ModSymbols`, and `PageBuilder.PageSprite` | `9bc8ddc061845df0cd5ea47f4fdef773cff786ae` | Replaces the six pre-generated symbol PNGs; layers four poem words on the shared page background and caches bounded client textures |
+| `assets/rivencraft/textures/block/crystal_block.png` | `assets/mystcraft/textures/blocks/crystal.png` | Legacy 0.13.7.06 local extraction | Exact 16×16 blue tile shared by Crystal Block and Budding Crystal models after removing a byte-identical duplicate |
+| `assets/rivencraft/textures/block/{small,medium,large}_crystal_bud.png`, `crystal_cluster.png` | Minecraft 1.21.1 `textures/block/{small,medium,large}_amethyst_bud.png`, `amethyst_cluster.png` | Minecraft 1.21.1 | Original 16×16 alpha masks and silhouettes preserved; hue shifted toward Legacy blue, with brighter saturation; exported as 8-bit RGBA (not indexed PNG) |
+| `assets/rivencraft/textures/item/crystal_shard.png` | Original sprite generated with OpenAI ImageGen from the Legacy crystal palette | 2026-10-05 | Cropped and nearest-neighbor scaled to 16×16 |
+| `assets/rivencraft/sounds/linking/link-fissure.ogg` | `assets/mystcraft/sounds/linking/link-fissure.ogg` | Legacy 0.13.7.06 local extraction | Namespace/path rename only; plays when a Star Fissure returns an entity home |
 
 Mystcraft Legacy identifies XCompWiz as its project developer and includes the
 full LGPL v3 text in its root `LICENSE` file. Rivencraft's root `LICENSE`

docs/DESCRIPTIVE_BOOK_PRESENTATION.md

@@ -4,13 +4,13 @@ The Legacy-style front spread has the Age name and author on the left and the de
 
 The Binder records the taking player's name on the finished book; direct Age binding also records the binding player. Older books without this component display `Unknown author` rather than attributing them to whoever happens to open them. Link-Panel-only and older page-free books retain their random-Age glyph details and destination preview. On authored books, hovering the front-page name exposes the existing trait summary without filling the left page with text.
 
-The server resolves symbol display metadata from its current catalog and sends advisory grammar diagnostics with the book-opening payload. A missing data-pack symbol draws the unresolved page artwork and its original ID. An affected page displays a red `!` with the server's diagnostic on hover; separate writing-note pages show all diagnostics, including incomplete branches that the Age compiler filled. These UI notices do not alter or recompile the persisted Age plan. Symbol pages use the same bounded, runtime glyph composition as Page items and do not require Create, Ponder, or Immersive Portals.
+The server resolves symbol display metadata from its current catalog. A missing data-pack symbol draws the unresolved page artwork and its original ID. Descriptive Books do not show writing notes or grammar warning markers; grammar validation remains in the Binder and on the server when an Age is created. Opening a book never changes its persisted Age plan. Symbol pages use the same bounded, runtime glyph composition as Page items and do not require Create, Ponder, or Immersive Portals.
 
 ## Manual visual and behavior checks
 
 1. Bind a Descriptive Book with two distinct symbol pages. Open it: the front spread shows its Age name, your player name, and the link panel. Turn twice and confirm exactly one large symbol on each right page, in authored order, with no plain-text symbol description or blank trailing page.
 2. Hover the front-page name to confirm the trait summary remains accessible. Click the link panel to confirm normal travel; repeat from a lectern to check the name, panel, and page-turn layout.
 3. Open a Link-Panel-only book and confirm its existing random-Age details and destination preview still appear.
-4. In a copy of a test world, remove a data pack that supplied one authored symbol. Reopen the book: its original symbol ID should remain readable beside the unresolved artwork, and the writing notes should explain the missing definition. Restore the pack and verify the page artwork returns without changing the saved Age.
+4. In a copy of a test world, remove a data pack that supplied one authored symbol. Reopen the book: its original symbol ID should remain readable beside the unresolved artwork, with no writing-notes pages. Restore the pack and verify the page artwork returns without changing the saved Age.
 
 `./gradlew build --offline` verifies compilation and jar assembly. The visual and data-pack-removal checks require an in-game client.

docs/GAMETESTS.md

@@ -17,10 +17,15 @@ core tests when investigating an issue:
 ```shell
 ./gradlew runGameTestServer -ParchivedGameTestSuites=desk
 ./gradlew runGameTestServer -ParchivedGameTestSuites=grammar,binder
+./gradlew runGameTestServer -ParchivedGameTestSuites=generation
 ```
 
-Available suite names are `linking`, `environment`, `writing`, `grammar`, `desk`,
-`binder`, `mixer`, and `recipe`. Run all Rivencraft tests before a
+Available suite names are `linking`, `environment`, `writing`, `grammar`,
+`generation`, `desk`, `binder`, `mixer`, and `recipe`. The `generation` archive
+keeps the detailed feature, structure, ore, crystal, and fissure regressions
+out of the default smoke run. Three checks formerly registered twice in the
+core and their archives now run only through the core wrapper. Run all
+Rivencraft tests before a
 release or after broad cross-system changes:
 
 ```shell
@@ -47,6 +52,27 @@ automated check, and hand its exact scenario to the player for in-game
 verification. Do not keep retrying a stalled test or leave its process running.
 Keep the narrower non-stalling plan, persistence, and runtime checks automated.
 
+For issue #41, the combined archive and the focused `linking` archive initially
+stalled during the multi-profile travel acceptance test. That test is no longer
+registered with GameTest; the rerun passed all 116 registered tests before the
+subsequent random-biome-count adjustment. The 51-test core suite passes after
+that adjustment, but the full archive stalled again late in its first batch;
+do not treat that interrupted run as a pass. Verify its
+scenario manually: in a fresh world, bind
+one Descriptive Book for each of Standard, Flat, Amplified, Island, Cave, and
+Void terrain (use the corresponding Terrain Page to select each one). Visit
+each Age, confirm a safe arrival platform and headroom, and
+travel back using a bound Linking Book. The narrower creation, persistence,
+terrain, and travel checks remain automated. See
+[random Age weights](RANDOM_AGE_WEIGHTS.md) for the Legacy rank mapping and
+the opt-in weighting regression.
+
+Also bind several Link-Panel-only Descriptive Books with no authored biome
+pages. Check that each Age retains its biome set after leaving, unloading, and
+reopening it, and that the selected biome count varies between Ages without
+exceeding the eligible pool. This covers the bounded random-biome path touched
+after the last successful full-archive run.
+
 The optional `-PwithSereneSeasons=true` runtime is for a real dev client, not
 the GameTest server: Serene Seasons sends a season payload to GameTest mock
 players, which cannot negotiate its channel. Follow the real-client Serene test in

docs/LEGACY_AGE_GRAMMAR_AUDIT.md

@@ -18,7 +18,7 @@ Legacy does **not** reject a book just because it omits terrain, biome, weather,
 | `WeatherNorm`, `Fast`, `Slow`, `Off`, `On`, `Cloudy`, `Rain`, `Snow`, `Storm` | `AgeTraits.Weather` has matching names except Legacy `On` maps to `ALWAYS` | Compile weather semantics separately from biome selection. `Snow` must remain deferred until optional season integration; do not silently substitute another weather mode. |
 | Suns, moons, starfields; angle, phase, period, color/gradient/sunset modifiers | One `celestialPeriod`, `celestialAngle`, `celestialPhase` on `AgeTraits` | Compile only the representable single-cycle subset first. Multiple celestial bodies, independent periods, custom stars, gradients and sunsets need a richer definition and renderer, not flattening into one value. |
 | Sky/fog/cloud/grass/foliage/water colors, natural variants, horizon, rainbow | Existing sky/dimension visuals and preview | Require an explicit modern client/biome-color design; metadata-only symbol pages must not pretend to change rendering. |
-| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile and vanilla data-pack generation | Compile only features for which registered 1.21.1 placed features/structures exist. Defer bespoke structures and polish to milestone 7. |
+| Caves, ores, huge trees, lakes, floating islands, tendrils, skylands, spheres, spikes, crystals; vanilla villages, strongholds, mineshafts, dungeons, fortresses, obelisks, fissures | Current cave profile, authored Floating Islands/Tendrils/Skylands/Spheres/Spikes/Obelisks/Crystal Formations/Star Fissures and Dense Ores, and page-gated vanilla Dungeons/Mineshafts/Nether Fortresses/Strongholds/Villages | The five Legacy vanilla structure symbols gate Minecraft 1.21.1 generation. Dungeons use monster-room placement; the others use vanilla structure sets. Obelisks use a bespoke 4×4 plinth and 2×12×2 shaft with safe modern placement. Crystal Formations retain Legacy's blue tile and one-in-fifteen attempt rate but use new budding, shard-producing mounds. Star Fissures reproduce Legacy's spawn-chunk footprint, open-to-sky columns, home link, and sound. Their renderer uses the modern End Portal pipeline in place of Legacy's retired fixed-function OpenGL calls. Exact 1.12 geometry for other structures remains separate work. |
 | `EnvAccel`, explosions, lightning, meteors, scorching; PvP and dummy suppression pages | No equivalent Age-definition effect | Defer environmental hazards/instability effects to milestone 6, PvP rule to a separately scoped server policy; retain authored IDs without fake behavior. |
 
 The Legacy symbol list and page names come from [ModSymbols](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/ModSymbols.java#L129-L240) and [SymbolRules](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/data/SymbolRules.java#L19-L137). Rivencraft's [catalog](../src/main/java/net/dnorberg/rivencraft/writing/SymbolCatalog.java) currently holds display metadata only; its built-in set is just standard terrain, native biomes, normal weather, normal lighting, normal time, and caves. [OrderedWriting](../src/main/java/net/dnorberg/rivencraft/writing/OrderedWriting.java) preserves page order, but no compiler yet connects it to [AgeTraits](../src/main/java/net/dnorberg/rivencraft/book/AgeTraits.java) or [Age profiles](AGE_PROFILES.md).

docs/MILESTONE_5_ACCEPTANCE.md

@@ -0,0 +1,39 @@
+# Milestone 5 acceptance: Age grammar
+
+This is the completion record for [Gitea issue #42](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/issues/42) and release 0.5.0.0. Issues #28–#41, #45–#59, #61, and #62 are closed. #39 was closed with an explicit Ecliptic Seasons limitation, not with a working Ecliptic adapter. #42 is the final gate. Issues #43, #44, and #60 are separate open follow-ups, not hidden Milestone 5 completion claims.
+
+## Authoring and generation contract
+
+- Schema-v2 symbol JSON lives at `data/<namespace>/rivencraft/symbols/<path>.json`. Its file path is the stable page ID; `name`, `description`, and `category` are display metadata, while typed `semantics.role` and `semantics.value` control generation on the server. See [schema and role table](SYMBOL_SEMANTICS.md). Schema v1 remains display-only. Registry-derived biome, solid-block, and source-fluid pages are generated from valid registered entries rather than requiring one PNG or JSON definition per material.
+- Ordered writing is parsed as Link Panel, terrain, biomes/controller, weather, season, lighting, sky, celestial modifiers/celestial, then material/feature pairs. Missing branches are seeded completion warnings. Unresolved symbols, unsupported combinations, conflicting single-choice pages, incorrect order, and an invalid Link Panel produce Binder diagnostics before items are consumed. Repeated feature and material pages retain their occurrence order. See [grammar and diagnostics](WRITING_GRAMMAR.md).
+- Legacy's grammar ranks informed the random-choice weights; Rivencraft does not claim to run Legacy's complete 1.12.2 grammar or reproduce its terrain byte-for-byte. The [source audit](LEGACY_AGE_GRAMMAR_AUDIT.md), [weight table](RANDOM_AGE_WEIGHTS.md), and [runtime profiles](AGE_PROFILES.md) record exact mappings and adaptations. Authored supported symbols override seeded choices. A page-free or Link-Panel-only Descriptive Book creates a random Age. The resolved plan, seed, profile, biome IDs, traits, features, and writing order are saved with its Age identity before chunks generate. Reopening a book or restarting must not reroll it.
+- Feature pages cover decorations, terrain additions, dense ores, crystals, fissures, and supported structures including Trial Chambers and newer vanilla structures. Material pages may explicitly choose a compatible block/fluid or receive a seeded compatible feature. Terrain and biome eligibility still restrict combinations; incompatibility is reported rather than silently ignored. [Age documentation](AGES.md) and [feature rules](WRITING_GRAMMAR.md) describe the supported subset.
+
+## Optional integrations and fallback
+
+| Integration | Milestone 5 result |
+| --- | --- |
+| TerraBlender | Optional adapter reads registered Overworld and Nether region biome IDs. Any compatible biome-producing mod using those regions can supply eligible pages; no Biomes O' Plenty ID is hard-coded. Missing TerraBlender leaves vanilla Age generation intact. A removed biome warns and uses an eligible load-time fallback without rewriting the saved plan. See [TerraBlender checks](TERRABLENDER_COMPATIBILITY.md). |
+| Serene Seasons | Optional per-Age seasonal modes: No Seasons, Seasons, Eternal Winter/Summer/Fall/Spring. The adapter enrolls dynamic Age IDs in Serene's whitelist and synchronizes connected clients without a restart. Its internal config/saved-clock hooks are version-sensitive because a public dynamic-dimension registration/fixed-season API is unavailable. Without Serene, only No Seasons is valid for a *new* book; saved Ages retain their data with effects inactive. See [config and real-client checks](SERENE_SEASONS_COMPATIBILITY.md). |
+| Ecliptic Seasons | Deliberately not integrated. Its 1.21.1 `ValidDimensions` setting requires a world restart and caches validity on server/client level load; no supported live registration or per-dimension calendar-control API was found. Issue #39 records the blocker and the upstream API needed to revisit it. Rivencraft does not require Ecliptic and does not support both season mods together. |
+| JEI, Create/Ponder, Immersive Portals | Optional presentation/integration paths; none is required for core dedicated-server loading or Age grammar. Existing preview fallback and manual checks remain in [preview compatibility](PREVIEW_COMPATIBILITY.md). |
+
+## Migration, limits, and milestone boundary
+
+Existing saved writing keeps its stable IDs and order. Unresolved pages remain recoverable in books instead of being silently replaced. Existing bound books without a plan are not reinterpreted as newly authored grammar. A frozen plan can load without the old symbol definition or runtime-profile JSON, but missing referenced registry resources prevent or alter that load as documented in [runtime profiles](AGE_PROFILES.md); restore the data pack/mod and keep a backup. The migration regression suite covers legacy writing components, schema-v1 display pages, missing symbols, and old Binder/Desk data. It is **not** a promise of full compatibility with every pre-release world; that broader requirement is tracked separately by open issue #60.
+
+Milestone 5 owns recognized symbol semantics, ordered grammar, deterministic completion, persistent Age configuration, and supported feature/integration effects. Milestone 6 owns instability from invalid or excessive writing and server-safe instability effects. Milestone 7 owns remaining structures/polish, portals, recipes, models, sounds, advancements, and migration depth. Several Legacy structures and crystals were pulled forward into Milestone 5 as their own closed port issues; that does not imply the rest of Milestone 7 is complete. Custom multi-body skies, gradients, unsupported direct Rain/Snow pages, and exact Legacy terrain/feature parity remain outside the accepted M5 subset. Open issue #44 tracks custom skybox work.
+
+## Test and acceptance matrix
+
+| Check | Result or handoff |
+| --- | --- |
+| Default dedicated-server GameTests, no optional mods | 26/26 passed after moving 25 detailed generation checks to the selectable `generation` archive. Core persistence, grammar, transaction, and migration checks remain. |
+| Focused generation archive | 51/51 passed on the reduced core plus `-ParchivedGameTestSuites=generation`. No generation test was deleted; 25 detailed checks moved out of the default run. |
+| Full archive | Previously passed 116/116 before the final random-biome-count adjustment in #41. Its later rerun stalled in the first batch and was stopped under the project GameTest rule; **not** claimed as a passing current run. Manual random-Age biome and six-terrain travel checks are in [GameTest handoffs](GAMETESTS.md). |
+| Optional TerraBlender | An earlier optional-mod GameTest run passed 51/51; Biomes O' Plenty/Nether-region behavior was checked in-game during #37. The published jar does not bundle TerraBlender. |
+| Optional Serene Seasons | In-game acceptance was recorded on #38 for six pages, saved whitelist, and no-restart sync. The GameTest mock player cannot negotiate Serene's season packet; the real-client path is documented. |
+| Gradle build and JAR | `./gradlew build --offline --no-daemon` passed and produced `build/libs/rivencraft-0.5.0.0.jar`. Its SHA-256 is attached to the Gitea release. |
+| Asset audit | Three byte-identical PNGs were replaced by references to their retained counterparts; no other unreferenced shipped textures or sounds were found. The user-provided `dev images` reference remains untouched. |
+
+Completion checklist: implementation issues reviewed; #39 explicitly scoped as unsupported; schema/Legacy/grammar/generation/integration/migration boundaries documented; core and focused validation recorded; current archive stall disclosed; release JAR and SHA-256 published; issue #42 and Milestone 5 closed **only after** those release artifacts are verified.

docs/PORTING.md

@@ -34,12 +34,13 @@ acceptance issue and all required implementation issues are complete.
    renderer compatibility. **Complete.** See
    [Milestone 3](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/8).
 4. **Writing system** — pages, notebooks, desks, book assembly, and the baseline
-   Ink Mixer for Link Panels. Symbol effects are deferred until Milestone 5.
+   Ink Mixer for Link Panels. Symbol effects were deferred to Milestone 5.
    **Complete.** See [Milestone 4](https://gitea.tail180fb1.ts.net/dnorberg/rivencraft/milestone/9)
    and [writing-system data and migration](WRITING_DATA.md).
-5. **Age grammar** — translate symbol combinations into modern biome, noise,
-   dimension-type, and world-generation configuration. Optional integrations
-   may add composable biome regions and seasonal behavior. See the
+5. **Age grammar** — translate supported symbol combinations into modern biome,
+   noise, dimension-type, and world-generation configuration, with optional
+   TerraBlender and Serene Seasons integration. **Complete for the supported
+   subset.** See the [acceptance record](MILESTONE_5_ACCEPTANCE.md) and
    [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md).
 6. **Instability** — deterministic validation and server-safe effects.
 7. **Structures and polish** — libraries, crystals, portals, recipes, models,
@@ -61,17 +62,16 @@ live rendering when their dependencies are installed. The tested selection
 matrix and integration boundaries are documented in
 [PREVIEW_COMPATIBILITY.md](PREVIEW_COMPATIBILITY.md).
 
-The writing system and Age grammar will build on the existing page-free Age
-path. Page-free books remain a useful deterministic fallback and test fixture
-after written symbol combinations become available.
+The writing system and Age grammar build on the existing page-free Age path.
+Page-free books remain a useful deterministic fallback and test fixture.
 
 Milestone 4 delivered a versioned, data-pack-defined symbol catalog and an
 immutable ordered-writing model. See [WRITING_DATA.md](WRITING_DATA.md). These
-contracts preserve unknown symbol identifiers and store author intent; they do
-not interpret symbols into Age generation, which remains Milestone 5 work.
+contracts preserve unknown symbol identifiers and store author intent;
+Milestone 5 adds the server-owned interpretation and persistent Age plan.
 The Ink Mixer is included in Milestone 4 after book assembly; it
 uses paper and Ink Vials to make baseline Link Panels. Adding modifier
-ingredients and symbol-driven link properties belongs to Milestone 5.
+ingredients and symbol-driven link properties were delivered in Milestone 5.
 
 ## Provenance rules
 

docs/RANDOM_AGE_WEIGHTS.md

@@ -0,0 +1,18 @@
+# Random Age selection (issue #41)
+
+Page-free and Link-Panel-only books still make one random Age definition from the Age seed. A written page overrides its branch; random completion never rewrites the book. The resulting terrain, traits, season mode, biome pool, and feature choices are saved with the Age identity, so loading an existing Age does not reroll it. This change affects **new** Ages only.
+
+The rank-weight calculation follows Mystcraft Legacy's `GrammarGenerator.buildRankWeights` in the user-provided 0.13.7.06 classes: starting at the highest numbered (rarest) rank, a rank's weight is at least one greater than the preceding rank's total divided by the number of entries at the current rank. A missing intermediate rank still advances the weight. The corresponding `SymbolRules` entries supply the ranks. This is a selection policy, not a port of Legacy's full grammar tree or its Minecraft 1.12 world generator.
+
+| Branch | Relative tickets for supported choices |
+| --- | --- |
+| Terrain | Standard 6, Flat 5, Amplified/Island/Cave/Void 1 each. Cave and Island occupy the rare slots corresponding to Legacy Nether and End terrain. Additional data-pack runtime profiles default to the rare rank and cause the group weights to be recomputed. |
+| Biome controller | Native/Single/Medium 3 each; Tiled/Grid/Tiny/Small/Large/Huge 1 each. The selected controller still applies terrain eligibility and minimum-biome rules. |
+| Additional random biomes | After Rivencraft's existing controller minimum, each extra biome has a 2-in-3 continuation chance and a 1-in-3 stop chance, capped by the eligible biome pool (including optional TerraBlender additions). This mirrors Legacy's ranked biome-list branch without changing the project's authored-page minimums. |
+| Lighting | Normal 3; Dark/Bright 1 each. |
+| Weather | Normal 9; Fast/Slow/Off/Always/Cloudy/Rain/Snow/Storm 1 each. WeatherOn is named Always here. |
+| Season (Serene Seasons only) | Seasons 6, No Seasons 5, each eternal season 1. These are Rivencraft ranks for features absent from Legacy; normal cycling is most common and eternal seasons are rare. No season policy is rolled without Serene Seasons. |
+
+Random-feature selection remains bounded to two material features and two structures. Within those limits, surface/deep lakes have Legacy rank 1; lava lakes rank 2 as a separate new fluid choice; spheres/spikes/obelisks rank 3; and floating islands/tendrils rank 4. Rocks, which are a Rivencraft generalization, use rank 4. For structures, villages/strongholds/mineshafts use rank 1, dungeons/Nether fortresses rank 2, and newer Minecraft structures rank 3. Eligibility filtering still removes features incompatible with the selected terrain/biomes. Separate rare Skylands, Crystals, and Legacy-weighted Star Fissure rolls remain. This preserves Rivencraft's existing count limits rather than claiming exact parity with the full Legacy feature grammar. Existing saved random feature lists are retained. The current celestial stopped-time chance (1 in 7) follows the verified Legacy period ranks; other numeric celestial values still use Rivencraft's documented range.
+
+Regression coverage: `RandomAgeWeightGameTests` (archived grammar suite) checks exact terrain rank tickets and stable selections across many seeds. Core Age persistence tests cover page-free and Link-Panel-only books, plan/trait round-trips, and migrated definitions. Binder and grammar archives cover page order, missing symbols, rejected assembly, and replayed output. The default GameTest runtime has none of TerraBlender, Serene Seasons, Ecliptic Seasons, JEI, Create, Ponder, or Immersive Portals installed. Optional-mod interactions and real unload/restart checks remain manual per `GAMETESTS.md`.

docs/SERENE_SEASONS_COMPATIBILITY.md

@@ -40,10 +40,12 @@ For an eternal mode, Rivencraft sets Serene's per-Age saved clock to the midpoin
 
 - The Serene adapter uses Serene's internal saved season state because there is no public per-dimension season-freeze API. The real-client behavior above, including each eternal mode and No Seasons, still needs player verification. Serene's [temperature and precipitation hooks](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHooks.java) only cool eligible biomes.
 - Serene Seasons' [season tick](https://github.com/Glitchfiend/SereneSeasons/blob/1.21.1/common/src/main/java/sereneseasons/season/SeasonHandler.java) advances from a dimension's day-time changes. A Rivencraft Age with a stopped celestial cycle may also have a stopped season; this needs an in-game check.
-- Rivencraft's non-Normal weather modes currently control weather in each Age independently. Their timing can conflict with Serene Seasons' weather-frequency changes. Ecliptic Seasons integration remains issue #39; simultaneous installation is not a supported target.
+- Rivencraft's non-Normal weather modes currently control weather in each Age independently. Their timing can conflict with Serene Seasons' weather-frequency changes. Ecliptic Seasons integration was closed as unsupported for live dynamic Ages in issue #39; simultaneous installation is not a supported target.
 
 ## Verification so far
 
 `./gradlew build` passed for candidate 0.4.9.2, and the baseline plus archived environment GameTests passed (35 required tests). The archive now covers seasonal page visibility, exclusivity, and saved-plan persistence without Serene installed. With Serene Seasons 10.1.0.8 and GlitchCore 2.1.0.2 in the optional local runtime, the GameTest server previously crashed when Serene Seasons sent `sereneseasons:sync_season_cycle` to a GameTest mock player that had not negotiated its client payload channel. The stack trace originates in Serene Seasons' `SeasonHandler.sendSeasonUpdate`, through GlitchCore's packet handler and NeoForge's packet check. This is a GameTest mock-network limitation, not a completed absent/present compatibility check. Do not keep rerunning that suite with Serene Seasons; use the real-client test path above instead.
 
 For candidate 0.4.10.1, `./gradlew build --offline` and the focused environment archive passed (36 required GameTests). The new regression check covers omitted-page selection, explicit-page precedence, no-Serene behavior, and save/reload. Actual Serene weather, whitelisting, and eternal-season visuals still require the real-client steps above.
+
+The user subsequently reported an in-game pass for issue #38, recorded in its Gitea comment and release V0.4.9.2. The earlier candidate notes above describe the historical automated checks; the real-client matrix remains useful when upgrading Serene Seasons or GlitchCore.

docs/SYMBOL_SEMANTICS.md

@@ -16,7 +16,7 @@ Milestone 5 issue #29 adds typed meaning to the existing data-pack symbol catalo
 }
 ```
 
-`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that a later compiler must resolve and validate. A syntactically valid resource ID alone does not guarantee the profile or feature exists.
+`name` and `description` are translation keys. `category` is for display and sorting; it does not determine grammar. `semantics.role` and its typed `value` are server-owned. The terrain value above names an Age runtime profile that the compiler resolves and validates. A syntactically valid resource ID alone does not guarantee the profile or feature exists.
 
 `poem` is optional, client-safe artwork metadata: exactly four alphabetic words, ordered top, right, bottom, left. The client layers their glyphs from the shared Legacy component sheet at runtime. GUI thumbnails use the full transparent artwork over their page backgrounds; item icons use the same artwork reduced from 16 to 13 pixels across, over the page texture. Unregistered words use a stable generated component combination; when a symbol has no poem, the six original built-in IDs retain their Legacy poems and other IDs produce four stable fallback words. This affects appearance only, never Age generation. Generated images are cached up to 256 entries and discarded on resource reload.
 
@@ -28,17 +28,20 @@ The Writing Desk's 88 collection tabs use Legacy's number components, chiefly th
 | `biome_controller` | `native`, `single`, `tiled`, `grid`, `tiny`, `small`, `medium`, `large`, or `huge`. |
 | `biome` | Canonical namespaced biome ID. |
 | `lighting` | `normal`, `dark`, or `bright`. |
+| `sky` | `overworld`, `nether`, or `end`. |
 | `weather` | `normal`, `fast`, `slow`, `off`, `always`, `cloudy`, `rain`, `snow`, or `storm`. |
+| `season` | `no_seasons`, `seasons`, `eternal_winter`, `eternal_summer`, `eternal_fall`, or `eternal_spring`. Seasonal effects other than No Seasons require optional Serene Seasons. |
 | `celestial` | `normal_time` (the first representable single-cycle behavior). |
 | `period_modifier` | JSON number in `[0, 2]`; zero is stopped time. |
 | `angle_modifier` | JSON number in `[0, 360)` degrees. |
 | `phase_modifier` | JSON number in `[0, 360)` degrees; the compiler will convert to turns. |
-| `feature` | Canonical namespaced feature-effect ID; future generation mapping must recognize it. |
+| `block` | Canonical namespaced material ID for a compatible following feature; registered full-collision blocks and source fluids receive generated Pages. |
+| `feature` | Canonical namespaced feature-effect ID; the compiler must recognize and validate it. This includes supported decorations and structures. |
 
-These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, special structures, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field.
+These are schema bounds, not claims that Legacy shipped numeric config ranges. See the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) for the source values and biome-count rules. Roles outside this table—including multiple suns, gradients, and hazards—are intentionally unsupported by schema v2. Their meaning requires a later versioned extension, not an unvalidated free-form field. Recognized schema values can still be rejected by the current compiler when their runtime effect is unsupported, such as angle modifiers or direct Rain/Snow weather pages.
 
 The server rejects a v2 definition with an unknown top-level or semantics field, missing/incorrectly typed field, unknown role or choice, malformed/non-canonical resource ID, or out-of-range/non-finite number. An invalid definition is logged with its file ID and excluded from the active catalog. Saved pages and books still retain that ID, allowing the player to recover them if the data pack is corrected. A reload atomically replaces the catalog rather than mutating saved writing.
 
-Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only `SymbolDisplayMetadata` (ID, translation keys, category, resolved flag); semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, but does **not yet apply** written symbols to Age generation; issue #31 adds compilation.
+Schema v1 definitions remain readable as **display-only** symbols; existing packs need not be rewritten merely to show or copy pages. A v1 definition cannot add a `semantics` field. To make one eligible for Age grammar parsing, publish a v2 definition with the **same file path and ID**, adding a valid role and value. Do not rename the page ID or reorder a book's `OrderedWriting`. The client receives only display metadata; semantic definitions are not serialized to it. The [ordered-writing parser](WRITING_GRAMMAR.md) validates new books, and the server compiles supported writing into a frozen Age plan before Binder inputs are consumed.
 
 The six built-in definitions demonstrate terrain, biome-controller, lighting, weather, celestial, and feature roles. A third-party pack may add its own definitions under its namespace. Use an explicit semantic role even when the display category has the same name; the two fields serve different purposes.

docs/WRITING_GRAMMAR.md

@@ -4,9 +4,9 @@
 
 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; sky effects; zero or more period or phase modifiers; one celestial page; then zero or more distinct features, each optionally preceded by a compatible block-material page. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, lighting, sky, and celestial are single-choice categories; identical repeats are duplicates and differing values conflict. Repeated modifiers are intentional. Biome pages may repeat, preserving author order and any future weighting; feature IDs may not repeat. Angle modifiers remain recognized in the schema but are rejected at binding until a sky renderer can apply sun tilt.
+The supported order follows the representable subset of the [Legacy grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md): terrain; zero or more biome pages; biome controller; weather; season; lighting; sky effects; zero or more period or phase modifiers; one celestial page; then zero or more features, each optionally preceded by a compatible material page. Biome pages precede the controller that consumes them, and celestial modifiers precede the celestial page. Terrain, controller, weather, season, lighting, sky, and celestial are single-choice categories; identical repeats are duplicates and differing values conflict. Repeated modifiers, biome pages, feature pages, and material pages are intentional and retain their order. An unpaired material page receives a seeded compatible feature during compilation. Angle modifiers remain recognized in the schema but are rejected at binding until a sky renderer can apply sun tilt.
 
-Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains seed-selected traits for missing branches. An omitted terrain page uses a seed-selected profile compatible with authored feature pages, so changing the Age name cannot accidentally select Flat, Void, or Cave terrain for Rocks or Lakes. If no profile can support the writing, binding still rejects it. The minimum biome count is zero for Native, one for Single, and two for Tiled/Grid and Tiny–Huge. Native cannot consume authored biome pages; Single accepts only one. Unknown IDs, schema-v1 display-only symbols, wrong ordering, misplaced modifiers, duplicates, conflicts, missing/extra Link Panels, and oversized writing are errors. The Binder disables output and exposes the first error on the result-slot tooltip. When that error belongs to a page, its thumbnail is tinted and outlined red, the strip scrolls to it, and hovering it shows the diagnostic. This maps the parser's compact entry position back through any empty page positions. Rejected inputs remain removable. Binding an unwritten Descriptive Book rechecks its server-owned writing and reports the first error without creating an Age. A terrain symbol whose profile is unavailable is also rejected before Binder inputs are consumed.
+Missing terrain, controller, weather, lighting, celestial, or the controller's minimum biome count is an **incomplete** warning, not an error: the compiler retains seed-selected traits for missing branches. An omitted terrain page uses a seed-selected profile compatible with authored feature pages, so changing the Age name cannot accidentally select Flat, Void, or Cave terrain for Rocks or Lakes. If no profile can support the writing, binding still rejects it. Native consumes no authored biome pages; Single accepts one; Tiled/Grid and Tiny–Huge require two, with seeded filler when pages are missing. Unknown IDs, schema-v1 display-only symbols, wrong ordering, misplaced modifiers, duplicates in single-choice categories, 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 overrides random terrain selection; an omitted terrain uses a seed-selected compatible profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages affect new Ages, and the supported feature subset below is compiled into the same frozen plan; instability remains Milestone 6 work.
 
@@ -14,8 +14,12 @@ The plan stores the original writing order, the authoritative semantic value of
 
 Feature pages come after the celestial section. Their order is retained in the plan and in decoration placement. The Caves page adds a second, Age-seeded vanilla cave-carving pass to Noise terrain, including Standard, Amplified, Island, and Cave terrain. It chooses the vanilla Overworld or Nether cave carver from the source biome. This is separate from the Milestone 7 issue about Cave **terrain** generation. Flat and Void terrain have no suitable solid noise body and reject Caves with a binder diagnostic.
 
-Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and Small Lakes add vanilla placed features after normal biome decoration. Huge Trees currently use vanilla old-growth spruce placement as a modern approximation of Legacy's huge-tree page; it is not the custom Legacy tree generator. Without a preceding material page, Rocks select a valid solid block and each lake page selects a valid source-fluid block from the registered pool. The selection is deterministic for an Age seed and feature ID, so all chunks in that Age use the same material across restarts with the same block registry. The page-specific feature preserves vanilla placement rules other than the biome-list filter, since an authored page deliberately adds it to the Age. Surface and Small Lakes use a more visible one-in-twelve-chunks attempt rate instead of vanilla lava lakes' one-in-two-hundred; Deep Lakes retain their underground placement. Vanilla biome lava lakes are separate and can still appear alongside authored fluid lakes. These decorations require surface Noise terrain; Cave, Flat, and Void reject them. Flowers and both tree pages require at least one surface Overworld biome and only run in compatible chunks; Nether, End, and tagged cave biomes do not receive surface vegetation. Ravines add a separate Age-seeded vanilla canyon-carving pass to Noise terrain. Unsupported feature IDs and missing vanilla registry entries produce diagnostics instead of becoming no-ops.
+Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and Lava Lakes add vanilla placed features after normal biome decoration. Huge Trees currently use vanilla old-growth spruce placement as a modern approximation of Legacy's huge-tree page; it is not the custom Legacy tree generator. Without a preceding material page, each material-bearing feature selects a valid solid block or source fluid from the registered pool. The selection is deterministic for the Age seed and feature occurrence, so repeated feature pages can receive different materials while remaining stable across restarts with the same block registry. The page-specific feature preserves vanilla placement rules other than the biome-list filter, since an authored page deliberately adds it to the Age. Surface and Lava Lakes use a more visible one-in-twelve-chunks attempt rate instead of vanilla lava lakes' one-in-two-hundred; Deep Lakes retain their underground placement. Vanilla biome lava lakes are separate and can still appear alongside authored fluid lakes. These decorations require surface Noise terrain; Cave, Flat, and Void reject them. Flowers and both tree pages require at least one surface Overworld biome and only run in compatible chunks; Nether, End, and tagged cave biomes do not receive surface vegetation. Ravines add a separate Age-seeded vanilla canyon-carving pass to Noise terrain. Unsupported feature IDs and missing vanilla registry entries produce diagnostics instead of becoming no-ops.
 
-Material pages are generated for registered full-collision, non-fluid blocks and genuine source-fluid blocks, including eligible blocks supplied by other mods. Blocks with block entities are excluded. Waterlogged plants and coral are not fluid blocks and receive no pages. Valid source-fluid blocks appear only in the Fluid Pages creative tab; valid full-collision solids appear only in Block Pages. Both categories use the same saved material-page semantics. Put a Block Page immediately before Rocks to choose a rock material, or a Fluid Page immediately before Surface Lakes, Deep Lakes, or Small Lakes to choose a lake fluid. A material page left alone, placed before a different category, or attached to an incompatible feature is rejected. Both the feature and material ID are frozen in the saved plan, so future chunks retain their choice after restart. Existing chunks are not retroactively decorated. Custom structures, crystals, portals, and the Cave-terrain bug are outside this slice.
+Material pages are generated for registered full-collision, non-fluid blocks and genuine source-fluid blocks, including eligible blocks supplied by other mods. Blocks with block entities are excluded. Waterlogged plants and coral are not fluid blocks and receive no pages. Valid source-fluid blocks appear only in the Fluid Pages creative tab; valid full-collision solids appear only in Block Pages. Both categories use the same saved material-page semantics. Put a Block Page before a compatible solid feature (Rocks, Floating Islands, Tendrils, Spheres, Spikes, or Obelisks), or a Fluid Page before a lake feature. A material page with no explicit feature receives a seeded compatible one. A material directly attached to an incompatible feature is rejected. The effective feature and material IDs are frozen with the Age, so future chunks retain their choices after restart. Existing chunks are not retroactively decorated.
+
+Crystal Formations are an authored, material-free feature on exposed solid terrain, including Flat terrain; Cave and Void reject the page. Like Legacy, one in fifteen eligible chunks attempts a formation, with the site fixed by the Age seed and chunk coordinates. The modern formation is a compact mound with budding hearts instead of Legacy's long crystal lines. Budding blocks grow through small, medium, and large buds into clusters using vanilla amethyst timing and sounds. Non-silk cluster harvest yields Crystal Shards; four shards craft one Crystal Block. These blocks and shards use 16×16 textures: Legacy's crystal tile for solids and hue-shifted vanilla amethyst sprites for buds and clusters. A page-free Age can also randomly select Crystal Formations; an authored page always retains its exact choice in the saved plan.
+
+Star Fissures are a material-free feature on every terrain profile, including Cave and Void. The fissure is generated once beside the first resolved spawn, using Legacy's spawn-chunk offset and 10–17 paired, irregular X-span rows running along +Z. Legacy's y=0 portal floor maps to the modern dimension's minimum build height, replacing lower bedrock if present. The rift opens to the sky on ordinary terrain; in Cave terrain it opens into the cavern but stops below the upper bedrock roof. Water in the carved columns is cleared before the portal is placed. Its non-solid portal links to the Overworld spawn with the Legacy fissure sound; the animated starfield is drawn with Minecraft's current End Portal renderer, which uses the same end-sky/end-portal art as Legacy's custom renderer. Random Ages sample Legacy's default small-feature grammar for fissure selection: the stop/one/repeat branches have rank-derived weights 1:1:3, and the fissure has weight 1 of 9 among its small-feature rules. The remainder of random feature selection still follows Rivencraft's current pipeline, rather than running Legacy's entire Age grammar.
 
 The Rivencraft symbol-page creative tabs read a generated index of bundled symbol definitions and group Pages by each definition's category, except biome-controller roles, which appear in a separate Biome Generation tab rather than the Biome tab. Adding another valid JSON symbol under `src/main/resources/data/rivencraft/rivencraft/symbols/` includes its page in the matching category tab on the next build; a new bundled category receives its own tab. Registry-derived Block and Fluid Pages have separate tabs and both appear in optional JEI. Link Pages have a separate tab. Blank Pages appear in neither the creative tabs nor JEI's ingredient list. The server catalog still decides whether a page is valid for writing. External server data-pack symbols are not included in this bundled index.

gradle.properties

@@ -36,7 +36,7 @@ mod_name=Rivencraft
 # The license of the mod. Review your options at https://choosealicense.com/. All Rights Reserved is the default.
 mod_license=LGPL-3.0-or-later
 # The mod version. Rivencraft uses the x.y.z.b policy documented in README.md.
-mod_version=0.4.10.1
+mod_version=0.5.0.0
 immersive_portals_version=6.0.7
 terrablender_version=4.1.0.8
 serene_seasons_version_id=B6nTjh4b

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

@@ -0,0 +1,45 @@
+package net.dnorberg.rivencraft.block;
+
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.RandomSource;
+import net.minecraft.world.level.block.AmethystBlock;
+import net.minecraft.world.level.block.AmethystClusterBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.BuddingAmethystBlock;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.Fluids;
+
+/** Vanilla amethyst growth, mapped to Rivencraft's blue crystal stages. */
+public final class BuddingCrystalBlock extends AmethystBlock {
+    public BuddingCrystalBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    protected void randomTick(BlockState state, ServerLevel level, BlockPos pos, RandomSource random) {
+        if (random.nextInt(5) != 0) return;
+        Direction direction = Direction.values()[random.nextInt(Direction.values().length)];
+        BlockPos target = pos.relative(direction);
+        BlockState existing = level.getBlockState(target);
+        Block next = nextStage(existing, direction);
+        if (next == null) return;
+        level.setBlockAndUpdate(target, next.defaultBlockState()
+                .setValue(AmethystClusterBlock.FACING, direction)
+                .setValue(AmethystClusterBlock.WATERLOGGED,
+                        existing.getFluidState().getType() == Fluids.WATER));
+    }
+
+    public static Block nextStage(BlockState existing, Direction direction) {
+        if (BuddingAmethystBlock.canClusterGrowAtState(existing)) return ModBlocks.SMALL_CRYSTAL_BUD.get();
+        if (!existing.hasProperty(AmethystClusterBlock.FACING)
+                || existing.getValue(AmethystClusterBlock.FACING) != direction) return null;
+        if (existing.is(ModBlocks.SMALL_CRYSTAL_BUD)) return ModBlocks.MEDIUM_CRYSTAL_BUD.get();
+        if (existing.is(ModBlocks.MEDIUM_CRYSTAL_BUD)) return ModBlocks.LARGE_CRYSTAL_BUD.get();
+        if (existing.is(ModBlocks.LARGE_CRYSTAL_BUD)) return ModBlocks.CRYSTAL_CLUSTER.get();
+        return null;
+    }
+}

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

@@ -0,0 +1,84 @@
+package net.dnorberg.rivencraft.block;
+
+import com.mojang.serialization.MapCodec;
+import net.dnorberg.rivencraft.block.entity.StarFissureBlockEntity;
+import net.dnorberg.rivencraft.book.LinkingService;
+import net.dnorberg.rivencraft.registry.ModSounds;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.sounds.SoundSource;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.BaseEntityBlock;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Portal;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockBehaviour;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.material.Fluid;
+import net.minecraft.world.level.portal.DimensionTransition;
+import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.phys.shapes.BooleanOp;
+import net.minecraft.world.phys.shapes.CollisionContext;
+import net.minecraft.world.phys.shapes.Shapes;
+import net.minecraft.world.phys.shapes.VoxelShape;
+
+/** A starry, non-obtainable portal at the base of a generated fissure. */
+public final class StarFissureBlock extends BaseEntityBlock implements Portal {
+    public static final MapCodec<StarFissureBlock> CODEC = simpleCodec(StarFissureBlock::new);
+    private static final VoxelShape SHAPE = Block.box(0, 0, 0, 16, 1.6, 16);
+
+    public StarFissureBlock(BlockBehaviour.Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    protected MapCodec<? extends BaseEntityBlock> codec() {
+        return CODEC;
+    }
+
+    @Override
+    public BlockEntity newBlockEntity(BlockPos pos, BlockState state) {
+        return new StarFissureBlockEntity(pos, state);
+    }
+
+    @Override
+    protected VoxelShape getShape(BlockState state, BlockGetter level, BlockPos pos, CollisionContext context) {
+        return SHAPE;
+    }
+
+    @Override
+    protected void entityInside(BlockState state, Level level, BlockPos pos, Entity entity) {
+        if (entity.canUsePortal(false) && Shapes.joinIsNotEmpty(
+                Shapes.create(entity.getBoundingBox().move(-pos.getX(), -pos.getY(), -pos.getZ())),
+                state.getShape(level, pos), BooleanOp.AND)) {
+            entity.setAsInsidePortal(this, pos);
+        }
+    }
+
+    @Override
+    public DimensionTransition getPortalDestination(ServerLevel level, Entity entity, BlockPos pos) {
+        if (level.dimension() == Level.OVERWORLD) return null;
+        ServerLevel overworld = level.getServer().overworld();
+        if (overworld == null) return null;
+        Vec3 destination = LinkingService.resolveDestination(overworld, overworld.getSharedSpawnPos(), true)
+                .orElse(overworld.getSharedSpawnPos().getBottomCenter());
+        level.playSound(null, pos, ModSounds.LINK_FISSURE.get(), SoundSource.BLOCKS, 1.0F, 1.0F);
+        return new DimensionTransition(overworld, destination,
+                entity.getDeltaMovement(), entity.getYRot(), entity.getXRot(),
+                DimensionTransition.PLACE_PORTAL_TICKET);
+    }
+
+    @Override
+    public ItemStack getCloneItemStack(LevelReader level, BlockPos pos, BlockState state) {
+        return ItemStack.EMPTY;
+    }
+
+    @Override
+    protected boolean canBeReplaced(BlockState state, Fluid fluid) {
+        return false;
+    }
+}

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

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

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

@@ -48,7 +48,8 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
             distribution = AgeTraits.BiomeDistribution.SINGLE;
         }
         if (controller.isEmpty() && !authored.isEmpty()) {
-            if (distribution == AgeTraits.BiomeDistribution.NATIVE
+            if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID
+                    || distribution == AgeTraits.BiomeDistribution.NATIVE
                     || (distribution == AgeTraits.BiomeDistribution.SINGLE && authored.size() > 1)) {
                 distribution = authored.size() == 1 ? AgeTraits.BiomeDistribution.SINGLE
                         : authored.size() == 2 ? AgeTraits.BiomeDistribution.TILED
@@ -79,15 +80,17 @@ public record AgeBiomeSelection(AgeTraits.BiomeDistribution distribution, List<R
         int minimum = minimum(distribution);
         int target = minimum;
         if (authored.isEmpty()) {
-            // The terrain's available pool is the upper bound, including any
-            // compatible TerraBlender region biomes present at creation time.
+            // Legacy's BiomesAdv continuation/stop ranks are 2:3, which yield
+            // two continuation tickets for every one stop ticket. Keep our
+            // existing minimum and cap the list at the available biome pool.
             int availableBiomeCount = new LinkedHashSet<>(availableBiomes).size();
             int maximum = distribution == AgeTraits.BiomeDistribution.SINGLE ? 1 : availableBiomeCount;
-            if (maximum >= minimum) {
-                target += new Random(seed ^ 0x42494F4D45434F55L).nextInt(maximum - minimum + 1);
-            }
+            Random countRandom = new Random(seed ^ 0x42494F4D45434F55L);
+            while (target < maximum && countRandom.nextInt(3) != 0) target++;
         }
-        List<ResourceLocation> filler = new ArrayList<>(availableBiomes);
+        // An authored Void Age must not acquire The Void as an unrequested second biome.
+        List<ResourceLocation> filler = profile.terrain() == AgeRuntimeProfile.Terrain.VOID && !authored.isEmpty()
+                ? new ArrayList<>() : new ArrayList<>(availableBiomes);
         java.util.Collections.shuffle(filler, new Random(seed ^ 0x42494F4D45504F4FL));
         for (ResourceLocation id : filler) {
             if (distinct.size() >= target) break;

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

@@ -1,6 +1,7 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.Objects;
+import java.util.List;
 import java.util.UUID;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.core.BlockPos;
@@ -19,7 +20,8 @@ public record AgeDefinition(
         BlockPos spawn,
         AgeTraits traits,
         AgeGenerationPlan plan,
-        @Nullable AgeSeasonMode seasonMode
+        @Nullable AgeSeasonMode seasonMode,
+        List<AgeFeatureSelection.Choice> randomFeatures
 ) {
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
@@ -32,6 +34,10 @@ public record AgeDefinition(
         Objects.requireNonNull(generationProfile, "generationProfile");
         Objects.requireNonNull(dimensionId, "dimensionId");
         Objects.requireNonNull(traits, "traits");
+        randomFeatures = List.copyOf(randomFeatures);
+        if (plan != null && !randomFeatures.isEmpty()) {
+            throw new IllegalArgumentException("Authored Ages cannot also have random features");
+        }
         if (plan != null && plan.ageSeed() != seed) {
             throw new IllegalArgumentException("Age plan seed does not match its Age definition");
         }
@@ -41,14 +47,22 @@ public record AgeDefinition(
                          int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                          BlockPos spawn, AgeTraits traits) {
         this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, null, null);
+                dimensionId, spawn, traits, null, null, List.of());
     }
 
     public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
                          int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                          BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan) {
         this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, plan, null);
+                dimensionId, spawn, traits, plan, null, List.of());
+    }
+
+    public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
+                         int generationVersion, long createdGameTime, ResourceLocation dimensionId,
+                         BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
+                         @Nullable AgeSeasonMode seasonMode) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, List.of());
     }
 
     public static ResourceLocation dimensionId(UUID ageId) {
@@ -79,6 +93,6 @@ public record AgeDefinition(
 
     public AgeDefinition withSpawn(BlockPos spawn) {
         return new AgeDefinition(id, name, seed, generationProfile, generationVersion,
-                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode, randomFeatures);
     }
 }

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

@@ -15,6 +15,7 @@ import java.util.Random;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.compat.ImmersivePortalsChunkLoaders;
 import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
+import net.dnorberg.rivencraft.compat.TerraBlenderBiomes;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.GlobalPos;
@@ -39,6 +40,7 @@ import net.minecraft.world.level.biome.MultiNoiseBiomeSource;
 import net.dnorberg.rivencraft.world.ScaledBiomeSource;
 import net.dnorberg.rivencraft.world.AgeFlatChunkGenerator;
 import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.StarFissureFeature;
 import net.minecraft.world.level.chunk.ChunkGenerator;
 import net.minecraft.world.level.dimension.BuiltinDimensionTypes;
 import net.minecraft.world.level.dimension.DimensionType;
@@ -98,6 +100,13 @@ public final class AgeDimensionService {
         if (spawn == null) {
             applyInitialCelestialPhase(level, definition);
             spawn = createSafeSpawn(level, definition);
+            if (AgeFeatureSelection.resolved(definition.plan()).stream()
+                    .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES))
+                    || definition.randomFeatures().stream()
+                    .anyMatch(choice -> choice.id().equals(AgeFeatureSelection.STAR_FISSURES))) {
+                StarFissureFeature.generate(level, definition.seed(), spawn,
+                        AgeBiomeSelection.isCave(runtimeProfile(definition)));
+            }
             definition = AgeRegistrySavedData.get(level).setSpawn(definition.id(), spawn);
         }
         return Optional.of(new LinkTarget(
@@ -302,6 +311,8 @@ public final class AgeDimensionService {
     private static ChunkGenerator createGenerator(MinecraftServer server, AgeDefinition age) {
         AgeRuntimeProfile profile = runtimeProfile(age);
         BiomeSource biomeSource = createBiomeSource(server, age, profile);
+        List<AgeFeatureSelection.Choice> features = age.plan() == null
+                ? age.randomFeatures() : AgeFeatureSelection.resolved(age.plan());
         if (profile.terrain() == AgeRuntimeProfile.Terrain.FLAT) {
             var settings = FlatLevelGeneratorSettings.getDefault(
                     server.registryAccess().lookupOrThrow(Registries.BIOME),
@@ -309,7 +320,7 @@ public final class AgeDimensionService {
                     server.registryAccess().lookupOrThrow(Registries.PLACED_FEATURE)
             );
             return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
-                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings, features, age.seed());
         }
         if (profile.terrain() == AgeRuntimeProfile.Terrain.VOID) {
             FlatLevelGeneratorSettings settings = new FlatLevelGeneratorSettings(
@@ -319,7 +330,7 @@ public final class AgeDimensionService {
             );
             settings.updateLayers();
             return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
-                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings);
+                    ? new FlatLevelSource(settings) : new AgeFlatChunkGenerator(biomeSource, settings, features, age.seed());
         }
 
         var noiseSettings = server.registryAccess().lookupOrThrow(Registries.NOISE_SETTINGS);
@@ -327,9 +338,11 @@ public final class AgeDimensionService {
                 Registries.NOISE_SETTINGS, profile.noiseSettings());
         NoiseGeneratorSettings baseSettings = noiseSettings.getOrThrow(settingsKey).value();
         Holder<NoiseGeneratorSettings> settings = Holder.direct(withBiomeMaterialRules(baseSettings));
-        List<AgeFeatureSelection.Choice> features = AgeFeatureSelection.resolved(age.plan());
-        return features.isEmpty() ? new NoiseBasedChunkGenerator(biomeSource, settings)
-                : new AgeFeatureChunkGenerator(biomeSource, settings, features, age.seed());
+        boolean caveTerrain = AgeBiomeSelection.isCave(profile);
+        return age.generationVersion() < AgeDefinition.CURRENT_GENERATION_VERSION
+                ? new NoiseBasedChunkGenerator(biomeSource, settings)
+                : new AgeFeatureChunkGenerator(biomeSource, settings, features, age.seed(),
+                        caveTerrain, caveTerrain ? TerraBlenderBiomes.nether(server.registryAccess()) : List.of());
     }
 
     private static NoiseGeneratorSettings withBiomeMaterialRules(NoiseGeneratorSettings base) {

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

@@ -3,11 +3,17 @@ package net.dnorberg.rivencraft.book;
 import com.mojang.serialization.Codec;
 import com.mojang.serialization.codecs.RecordCodecBuilder;
 import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
+import java.util.Random;
 import net.dnorberg.rivencraft.writing.BlockSymbolPages;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.dnorberg.rivencraft.world.AgeDenseOres;
 import net.minecraft.core.Holder;
 import net.minecraft.core.RegistryAccess;
 import net.minecraft.core.registries.BuiltInRegistries;
@@ -20,6 +26,16 @@ import net.minecraft.world.level.block.Blocks;
 
 /** Validates and freezes supported feature pages and their preceding material modifiers. */
 public final class AgeFeatureSelection {
+    private static final List<ResourceLocation> BLOCK_FEATURES = List.of(
+            id("rocks"), id("floating_islands"), id("tendrils"), id("spheres"), id("spikes"),
+            id("obelisks"));
+    private static final List<ResourceLocation> FLUID_FEATURES = List.of(
+            id("surface_lakes"), id("deep_lakes"), id("lava_lakes"));
+    private static final long RANDOM_SKYLANDS_SALT = 0x534B594C414E4453L;
+    private static final long RANDOM_STAR_FISSURES_SALT = 0x535441524752414DL;
+    public static final ResourceLocation CRYSTAL_FORMATIONS = id("crystal_formations");
+    public static final ResourceLocation STAR_FISSURES = id("star_fissures");
+
     private AgeFeatureSelection() {}
 
     public record Choice(ResourceLocation id, Optional<ResourceLocation> material) {
@@ -34,11 +50,15 @@ public final class AgeFeatureSelection {
     }
 
     public static List<Choice> compile(WritingGrammar.Result writing, AgeRuntimeProfile profile,
-                                       AgeBiomeSelection biomes, RegistryAccess registries) {
+                                       AgeBiomeSelection biomes, RegistryAccess registries, long ageSeed) {
         List<Choice> choices = choices(writing.symbols().stream()
-                .map(symbol -> symbol.semantics()).toList());
+                .map(symbol -> symbol.semantics()).toList(), profile, ageSeed);
         for (Choice choice : choices) {
             String error = error(choice.id(), profile, registries);
+            if (error == null && AgeStructureSelection.feature(choice.id()))
+                error = AgeStructureSelection.error(choice.id(), profile, biomes, registries);
+            if (error == null && choice.id().equals(AgeDenseOres.ID))
+                error = AgeDenseOres.error(profile, biomes, registries);
             if (error == null) error = materialError(choice);
             if (error != null) throw new IllegalArgumentException(error);
             if (surfaceVegetation(choice.id()) && biomes.biomes().stream()
@@ -50,10 +70,15 @@ public final class AgeFeatureSelection {
         return choices;
     }
 
-    private static List<Choice> choices(List<SymbolSemantics> symbols) {
+    private static List<Choice> choices(List<SymbolSemantics> symbols, AgeRuntimeProfile profile, long ageSeed) {
         List<Choice> choices = new ArrayList<>();
         ResourceLocation pendingMaterial = null;
-        for (SymbolSemantics semantics : symbols) {
+        for (int index = 0; index < symbols.size(); index++) {
+            SymbolSemantics semantics = symbols.get(index);
+            if (pendingMaterial != null && semantics.role() != SymbolSemantics.Role.FEATURE) {
+                choices.add(implied(pendingMaterial, profile, ageSeed, index - 1));
+                pendingMaterial = null;
+            }
             if (semantics.role() == SymbolSemantics.Role.BLOCK) {
                 pendingMaterial = ((SymbolSemantics.ResourceValue) semantics.value()).id();
             } else if (semantics.role() == SymbolSemantics.Role.FEATURE) {
@@ -62,29 +87,182 @@ public final class AgeFeatureSelection {
                 pendingMaterial = null;
             }
         }
+        if (pendingMaterial != null) choices.add(implied(pendingMaterial, profile, ageSeed, symbols.size() - 1));
         return List.copyOf(choices);
     }
 
+    private static Choice implied(ResourceLocation material, AgeRuntimeProfile profile, long ageSeed, int index) {
+        List<ResourceLocation> candidates = compatibleFeatures(material, profile);
+        if (candidates.isEmpty()) throw new IllegalArgumentException("No compatible feature for material "
+                + material + " on " + profile.terrain() + " terrain");
+        long mixed = mix(ageSeed ^ (long) material.hashCode() * 0x9E3779B97F4A7C15L ^ index);
+        return new Choice(candidates.get(Math.floorMod(mixed, candidates.size())), Optional.of(material));
+    }
+
+    public static boolean supportsUnpairedMaterials(WritingGrammar.Result writing, AgeRuntimeProfile profile) {
+        List<SymbolSemantics> symbols = writing.symbols().stream().map(symbol -> symbol.semantics()).toList();
+        ResourceLocation pending = null;
+        for (SymbolSemantics symbol : symbols) {
+            if (pending != null && symbol.role() != SymbolSemantics.Role.FEATURE) {
+                if (compatibleFeatures(pending, profile).isEmpty()) return false;
+                pending = null;
+            }
+            if (symbol.role() == SymbolSemantics.Role.BLOCK)
+                pending = ((SymbolSemantics.ResourceValue) symbol.value()).id();
+            else if (symbol.role() == SymbolSemantics.Role.FEATURE) pending = null;
+        }
+        return pending == null || !compatibleFeatures(pending, profile).isEmpty();
+    }
+
+    private static List<ResourceLocation> compatibleFeatures(ResourceLocation material, AgeRuntimeProfile profile) {
+        var block = BuiltInRegistries.BLOCK.getOptional(material);
+        if (block.isEmpty()) return List.of();
+        List<ResourceLocation> candidates = BlockSymbolPages.isFluidMaterial(block.orElseThrow())
+                ? FLUID_FEATURES : BlockSymbolPages.isRockMaterial(block.orElseThrow())
+                ? BLOCK_FEATURES : List.of();
+        return candidates.stream().filter(id -> compatible(id, profile)).toList();
+    }
+
+    private static boolean compatible(ResourceLocation feature, AgeRuntimeProfile profile) {
+        if (tendrils(feature) || spheres(feature)) return true;
+        if (obelisks(feature)) return !AgeBiomeSelection.isCave(profile)
+                && profile.terrain() != AgeRuntimeProfile.Terrain.VOID;
+        if (AgeBiomeSelection.isCave(profile)) return false;
+        if (spikes(feature)) return profile.terrain() != AgeRuntimeProfile.Terrain.VOID;
+        return floatingIslands(feature) || profile.terrain() == AgeRuntimeProfile.Terrain.NOISE;
+    }
+
     public static List<Choice> resolved(AgeGenerationPlan plan) {
         if (plan == null) return List.of();
-        return choices(plan.symbols().stream().map(symbol -> symbol.semantics()).toList()).stream()
-                .map(choice -> choice.material().isPresent() || !isRock(choice.id()) && !isLake(choice.id())
-                        ? choice : new Choice(choice.id(), Optional.of(randomMaterial(plan.ageSeed(), choice.id()))))
-                .toList();
+        Map<ResourceLocation, List<ResourceLocation>> materialOrders = new HashMap<>();
+        Map<ResourceLocation, Integer> occurrences = new HashMap<>();
+        List<Choice> resolved = new ArrayList<>();
+        for (Choice choice : choices(plan.symbols().stream().map(symbol -> symbol.semantics()).toList(),
+                plan.runtimeProfile(), plan.ageSeed())) {
+            if (choice.material().isPresent()
+                    || !isRock(choice.id()) && !isLake(choice.id())
+                    && !floatingIslands(choice.id()) && !tendrils(choice.id())
+                    && !spheres(choice.id()) && !spikes(choice.id())
+                    && !obelisks(choice.id())) {
+                resolved.add(choice);
+                continue;
+            }
+            List<ResourceLocation> materials = materialOrders.computeIfAbsent(choice.id(),
+                    id -> shuffledMaterials(plan.ageSeed(), id));
+            int occurrence = occurrences.merge(choice.id(), 1, Integer::sum) - 1;
+            resolved.add(new Choice(choice.id(), Optional.of(materials.get(occurrence % materials.size()))));
+        }
+        return List.copyOf(resolved);
     }
 
-    private static ResourceLocation randomMaterial(long ageSeed, ResourceLocation feature) {
-        var category = isRock(feature) ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
-        List<ResourceLocation> pool = BlockSymbolPages.availableBlocks(category).stream()
-                .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList();
+    /** Page-free Ages roll up to two material features, plus rare Skylands, once at creation. */
+    public static List<Choice> randomChoices(long ageSeed, AgeRuntimeProfile profile, RegistryAccess registries) {
+        Random random = new Random(ageSeed ^ 0x4D4154455249414CL);
+        int count = random.nextInt(3);
+        List<LegacyRankChoice.Option<ResourceLocation>> features = new ArrayList<>();
+        for (ResourceLocation id : BLOCK_FEATURES) if (error(id, profile, registries) == null)
+            features.add(new LegacyRankChoice.Option<>(id, randomMaterialRank(id)));
+        for (ResourceLocation id : FLUID_FEATURES) if (error(id, profile, registries) == null)
+            features.add(new LegacyRankChoice.Option<>(id, randomMaterialRank(id)));
+        List<Choice> choices = new ArrayList<>();
+        while (choices.size() < count && !features.isEmpty()) {
+            ResourceLocation feature = LegacyRankChoice.choose(random, features);
+            features.removeIf(option -> option.value().equals(feature));
+            var category = solidFeature(feature)
+                    ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
+            List<ResourceLocation> materials = BlockSymbolPages.availableBlocks(category).stream()
+                    .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList();
+            if (!materials.isEmpty()) choices.add(new Choice(feature,
+                    Optional.of(materials.get(random.nextInt(materials.size())))));
+        }
+        if (profile.terrain() == AgeRuntimeProfile.Terrain.NOISE
+                && Math.floorMod(mix(ageSeed ^ RANDOM_SKYLANDS_SALT), 8) == 0)
+            choices.add(new Choice(id("skylands"), Optional.empty()));
+        if (error(CRYSTAL_FORMATIONS, profile, registries) == null && random.nextInt(10) == 0)
+            choices.add(new Choice(CRYSTAL_FORMATIONS, Optional.empty()));
+        if (randomStarFissure(ageSeed))
+            choices.add(new Choice(STAR_FISSURES, Optional.empty()));
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(WritingGrammar.parse(OrderedWriting.EMPTY),
+                AgeTraits.select(ageSeed), profile, ageSeed, registries);
+        choices.addAll(AgeStructureSelection.randomChoices(ageSeed, profile, biomes, registries));
+        return List.copyOf(choices);
+    }
+
+    static int randomMaterialRank(ResourceLocation feature) {
+        if (feature.equals(id("surface_lakes")) || feature.equals(id("deep_lakes"))) return 1;
+        if (feature.equals(id("lava_lakes"))) return 2; // New separate fluid choice.
+        if (spheres(feature) || spikes(feature) || obelisks(feature)) return 3;
+        return 4; // Legacy Floating Islands/Tendrils and the new Rocks choice.
+    }
+
+    /**
+     * Legacy's default FeatureSmalls0 grammar: stop without a feature (rank 4),
+     * emit one (rank 4), or emit one and repeat (rank 2). Its rank-derived
+     * weights are 1:1:3. Within FEATURE_SMALL, the Star Fissure rule has weight
+     * 1 of 9: three rank-3 choices have weight 1 each and two rank-1 lake
+     * choices have weight 3 each. Other small features remain selected by this
+     * port's existing random feature pipeline; only the fissure result is used.
+     */
+    private static boolean randomStarFissure(long ageSeed) {
+        Random random = new Random(mix(ageSeed ^ RANDOM_STAR_FISSURES_SALT));
+        for (int step = 0; step < 27; step++) {
+            int branch = random.nextInt(5);
+            if (branch == 0) return false;
+            if (random.nextInt(9) == 0) return true;
+            if (branch == 1) return false;
+        }
+        return false;
+    }
+
+    private static List<ResourceLocation> shuffledMaterials(long ageSeed, ResourceLocation feature) {
+        var category = solidFeature(feature)
+                ? BlockSymbolPages.CATEGORY : BlockSymbolPages.FLUID_CATEGORY;
+        List<ResourceLocation> pool = new ArrayList<>(BlockSymbolPages.availableBlocks(category).stream()
+                .filter(id -> materialError(new Choice(feature, Optional.of(id))) == null).toList());
         if (pool.isEmpty()) throw new IllegalStateException("No valid material blocks for " + feature);
-        long mixed = ageSeed ^ (long) feature.hashCode() * 0x9E3779B97F4A7C15L;
-        mixed = (mixed ^ mixed >>> 30) * 0xBF58476D1CE4E5B9L;
-        mixed = (mixed ^ mixed >>> 27) * 0x94D049BB133111EBL;
-        return pool.get(Math.floorMod(mixed ^ mixed >>> 31, pool.size()));
+        Collections.shuffle(pool, new Random(mix(ageSeed ^ (long) feature.hashCode() * 0x9E3779B97F4A7C15L)));
+        return pool;
+    }
+
+    private static long mix(long value) {
+        value = (value ^ value >>> 30) * 0xBF58476D1CE4E5B9L;
+        value = (value ^ value >>> 27) * 0x94D049BB133111EBL;
+        return value ^ value >>> 31;
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath("rivencraft", path);
     }
 
     public static String error(ResourceLocation choice, AgeRuntimeProfile profile, RegistryAccess registries) {
+        if (AgeStructureSelection.feature(choice))
+            return AgeStructureSelection.error(choice, profile, null, registries);
+        if (choice.equals(AgeDenseOres.ID))
+            return AgeDenseOres.error(profile, null, registries);
+        if (choice.equals(CRYSTAL_FORMATIONS)) {
+            if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+                return "Feature " + choice + " needs exposed solid ground, not Cave or Void terrain";
+            return null;
+        }
+        if (choice.equals(STAR_FISSURES)) return null;
+        if (skylands(choice)) return null;
+        if (tendrils(choice)) return null;
+        if (spheres(choice)) return null;
+        if (spikes(choice)) {
+            if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+                return "Feature " + choice + " needs an exposed solid surface, not Cave or Void terrain";
+            return null;
+        }
+        if (obelisks(choice)) {
+            if (AgeBiomeSelection.isCave(profile) || profile.terrain() == AgeRuntimeProfile.Terrain.VOID)
+                return "Feature " + choice + " needs exposed solid surface terrain, not Cave or Void";
+            return null;
+        }
+        if (floatingIslands(choice)) {
+            if (AgeBiomeSelection.isCave(profile))
+                return "Feature " + choice + " cannot form above Cave terrain";
+            return null;
+        }
         if (caves(choice) || ravines(choice)) {
             if (profile.terrain() != AgeRuntimeProfile.Terrain.NOISE) {
                 return "Feature " + choice + " requires noise terrain with stone to carve; not Flat or Void";
@@ -118,7 +296,7 @@ public final class AgeFeatureSelection {
         if (block.isEmpty() || block.orElseThrow() == Blocks.AIR) {
             return "Feature " + choice.id() + " references missing block material " + material;
         }
-        if (isRock(choice.id())) {
+        if (solidFeature(choice.id())) {
             if (!BlockSymbolPages.isRockMaterial(block.orElseThrow())) {
                 return "Feature " + choice.id() + " needs a full solid block without a block entity: " + material;
             }
@@ -133,25 +311,64 @@ public final class AgeFeatureSelection {
     }
 
     public static boolean isRock(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "rocks"));
+        return is(choice, "rocks");
     }
 
     public static boolean isLake(ResourceLocation choice) {
-        return choice.getNamespace().equals("rivencraft") && List.of(
-                "surface_lakes", "deep_lakes", "lava_lakes").contains(choice.getPath());
+        if (!choice.getNamespace().equals("rivencraft")) return false;
+        return switch (choice.getPath()) {
+            case "surface_lakes", "deep_lakes", "lava_lakes" -> true;
+            default -> false;
+        };
     }
 
     public static boolean surfaceVegetation(ResourceLocation choice) {
-        return choice.getNamespace().equals("rivencraft")
-                && List.of("flowers", "trees", "huge_trees").contains(choice.getPath());
+        if (!choice.getNamespace().equals("rivencraft")) return false;
+        return switch (choice.getPath()) {
+            case "flowers", "trees", "huge_trees" -> true;
+            default -> false;
+        };
     }
 
     public static boolean caves(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "caves"));
+        return is(choice, "caves");
     }
 
     public static boolean ravines(ResourceLocation choice) {
-        return choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "ravines"));
+        return is(choice, "ravines");
+    }
+
+    public static boolean floatingIslands(ResourceLocation choice) {
+        return is(choice, "floating_islands");
+    }
+
+    public static boolean tendrils(ResourceLocation choice) {
+        return is(choice, "tendrils");
+    }
+
+    public static boolean spheres(ResourceLocation choice) {
+        return is(choice, "spheres");
+    }
+
+    public static boolean spikes(ResourceLocation choice) {
+        return is(choice, "spikes");
+    }
+
+    public static boolean obelisks(ResourceLocation choice) {
+        return is(choice, "obelisks");
+    }
+
+    private static boolean solidFeature(ResourceLocation choice) {
+        return isRock(choice) || floatingIslands(choice) || tendrils(choice)
+                || spheres(choice) || spikes(choice) || obelisks(choice);
+    }
+
+    public static boolean skylands(ResourceLocation choice) {
+        return is(choice, "skylands");
+    }
+
+    private static boolean is(ResourceLocation choice, String path) {
+        return choice.getNamespace().equals("rivencraft") && choice.getPath().equals(path);
     }
 
     public static boolean supportsSurfaceVegetation(ResourceLocation id, RegistryAccess registries) {
@@ -173,6 +390,7 @@ public final class AgeFeatureSelection {
             case "trees" -> ResourceLocation.withDefaultNamespace("trees_plains");
             case "huge_trees" -> ResourceLocation.withDefaultNamespace("trees_old_growth_spruce_taiga");
             case "rocks" -> ResourceLocation.withDefaultNamespace("forest_rock");
+            case "dungeons" -> ResourceLocation.fromNamespaceAndPath("rivencraft", "dungeons");
             case "surface_lakes", "lava_lakes" -> ResourceLocation.withDefaultNamespace("lake_lava_surface");
             case "deep_lakes" -> ResourceLocation.withDefaultNamespace("lake_lava_underground");
             default -> null;

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

@@ -65,7 +65,7 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         AgeRuntimeProfile profile = AgeRuntimeProfiles.profiles().get(selected);
         if (profile == null) throw new IllegalArgumentException("Unsupported Age terrain profile " + selected);
         AgeBiomeSelection biomes = AgeBiomeSelection.compile(parsed, traits, profile, ageSeed, registries);
-        AgeFeatureSelection.compile(parsed, profile, biomes, registries);
+        AgeFeatureSelection.compile(parsed, profile, biomes, registries, ageSeed);
         AgeGenerationPlan plan = new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
                 parsed.symbols().stream().map(symbol -> new ResolvedSymbol(
                         symbol.index(), symbol.reference(), symbol.semantics())).toList(),

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

@@ -1,6 +1,8 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.List;
+import java.util.Random;
+import java.util.Comparator;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.resources.ResourceLocation;
 
@@ -13,24 +15,37 @@ public final class AgeGenerationProfiles {
     public static final ResourceLocation FLAT = id("flat");
     public static final ResourceLocation VOID = id("void");
 
-    private static final List<ResourceLocation> RANDOM_PROFILES = List.of(
-            STANDARD, AMPLIFIED, ISLAND, CAVE, FLAT, VOID
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> RANDOM_PROFILES = List.of(
+            new LegacyRankChoice.Option<>(STANDARD, 1),
+            new LegacyRankChoice.Option<>(FLAT, 2),
+            new LegacyRankChoice.Option<>(AMPLIFIED, 3),
+            new LegacyRankChoice.Option<>(ISLAND, 3),
+            new LegacyRankChoice.Option<>(CAVE, 3),
+            new LegacyRankChoice.Option<>(VOID, 3)
     );
+    private static final List<LegacyRankChoice.Option<ResourceLocation>> SORTED_RANDOM_PROFILES =
+            RANDOM_PROFILES.stream().sorted(Comparator.comparing(LegacyRankChoice.Option::value)).toList();
 
     private AgeGenerationProfiles() {
     }
 
     /** Selects one stable base terrain from the Age's already-persisted seed. */
     public static ResourceLocation select(long seed) {
-        return RANDOM_PROFILES.get(Math.floorMod(Long.hashCode(seed), RANDOM_PROFILES.size()));
+        return LegacyRankChoice.choose(new Random(seed ^ 0x5445525241494E4CL), SORTED_RANDOM_PROFILES);
     }
 
     public static boolean isSupported(ResourceLocation profile) {
-        return RANDOM_PROFILES.contains(profile);
+        return RANDOM_PROFILES.stream().anyMatch(option -> option.value().equals(profile));
     }
 
     public static List<ResourceLocation> all() {
-        return RANDOM_PROFILES;
+        return RANDOM_PROFILES.stream().map(LegacyRankChoice.Option::value).toList();
+    }
+
+    static int randomRank(ResourceLocation profile) {
+        if (profile.equals(STANDARD)) return 1;
+        if (profile.equals(FLAT)) return 2;
+        return 3;
     }
 
     /** Maps removed legacy aliases to a stable built-in profile. */

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

@@ -66,7 +66,34 @@ public final class AgePersistenceGameTests {
                 new AgeReference(UUID.randomUUID(), "Panel Only"),
                 new OrderedWriting(List.of(WritingEntry.linkPanel())));
         helper.assertTrue(pageFree.plan() == null && panelOnly.plan() == null,
-                "Old and Link-Panel-only books must retain the random Age path");
+                "Page-free and Link-Panel-only books must retain the random Age path");
+        for (AgeDefinition age : List.of(pageFree, panelOnly)) {
+            helper.assertTrue(age.randomFeatures().stream().filter(choice -> choice.material().isPresent())
+                            .count() <= 2,
+                    "A random Age may roll at most two material features");
+            helper.assertTrue(age.randomFeatures().stream().filter(choice ->
+                    AgeFeatureSelection.skylands(choice.id())).count() <= 1,
+                    "A random Age may roll at most one Skylands filter");
+            helper.assertTrue(age.randomFeatures().stream().filter(choice ->
+                    AgeStructureSelection.feature(choice.id())).count() <= 2,
+                    "A random Age may roll at most two distinct structure features");
+            for (AgeFeatureSelection.Choice choice : age.randomFeatures()) {
+                helper.assertTrue(AgeFeatureSelection.skylands(choice.id())
+                                || choice.id().equals(AgeFeatureSelection.CRYSTAL_FORMATIONS)
+                                || choice.id().equals(AgeFeatureSelection.STAR_FISSURES)
+                                || AgeStructureSelection.feature(choice.id())
+                                ? choice.material().isEmpty()
+                                : choice.material().isPresent()
+                                && AgeFeatureSelection.materialError(choice) == null,
+                        "Random material features need valid blocks or fluids; material-free features need none");
+            }
+        }
+        AgeRegistrySavedData registry = AgeRegistrySavedData.get(helper.getLevel());
+        var restored = AgeRegistrySavedData.load(
+                registry.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.find(pageFree.id()).orElseThrow().randomFeatures(),
+                pageFree.randomFeatures(), "Random material features must survive a saved-data round trip");
         helper.succeed();
     }
 

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

@@ -33,6 +33,7 @@ public final class AgeRegistrySavedData extends SavedData {
     private static final String SPAWN_Z_TAG = "SpawnZ";
     private static final String TRAITS_TAG = "Traits";
     private static final String PLAN_TAG = "GenerationPlan";
+    private static final String RANDOM_FEATURES_TAG = "RandomFeatures";
     private static final String SEASON_MODE_TAG = "SeasonMode";
     private static final String BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
     private static final String LIGHTING_TAG = "Lighting";
@@ -133,7 +134,9 @@ public final class AgeRegistrySavedData extends SavedData {
                 null,
                 AgeEnvironmentCompiler.apply(plan, traits),
                 plan,
-                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons"))
+                AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons")),
+                plan == null ? AgeFeatureSelection.randomChoices(seed,
+                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of()
         );
         ages.put(created.id(), created);
         setDirty();
@@ -179,7 +182,8 @@ public final class AgeRegistrySavedData extends SavedData {
                     entry.contains(PLAN_TAG, CompoundTag.TAG_COMPOUND)
                             ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null,
                     entry.contains(SEASON_MODE_TAG, CompoundTag.TAG_STRING)
-                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null
+                            ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null,
+                    readRandomFeatures(entry)
             ));
         }
         return data;
@@ -213,6 +217,16 @@ public final class AgeRegistrySavedData extends SavedData {
                     traits.putFloat(CELESTIAL_PHASE_TAG, age.traits().celestialPhase());
                     entry.put(TRAITS_TAG, traits);
                     if (age.plan() != null) entry.put(PLAN_TAG, age.plan().save());
+                    if (!age.randomFeatures().isEmpty()) {
+                        ListTag featureTags = new ListTag();
+                        for (AgeFeatureSelection.Choice choice : age.randomFeatures()) {
+                            CompoundTag feature = new CompoundTag();
+                            feature.putString("Id", choice.id().toString());
+                            choice.material().ifPresent(id -> feature.putString("Material", id.toString()));
+                            featureTags.add(feature);
+                        }
+                        entry.put(RANDOM_FEATURES_TAG, featureTags);
+                    }
                     if (age.seasonMode() != null) entry.putString(SEASON_MODE_TAG, age.seasonMode().name());
                     serializedAges.add(entry);
                 });
@@ -220,6 +234,18 @@ public final class AgeRegistrySavedData extends SavedData {
         return tag;
     }
 
+    private static List<AgeFeatureSelection.Choice> readRandomFeatures(CompoundTag age) {
+        ListTag tags = age.getList(RANDOM_FEATURES_TAG, CompoundTag.TAG_COMPOUND);
+        List<AgeFeatureSelection.Choice> features = new java.util.ArrayList<>();
+        for (int index = 0; index < tags.size(); index++) {
+            CompoundTag item = tags.getCompound(index);
+            features.add(new AgeFeatureSelection.Choice(ResourceLocation.parse(item.getString("Id")),
+                    item.contains("Material", CompoundTag.TAG_STRING)
+                            ? Optional.of(ResourceLocation.parse(item.getString("Material"))) : Optional.empty()));
+        }
+        return List.copyOf(features);
+    }
+
     private static AgeTraits readTraits(CompoundTag age) {
         if (!age.contains(TRAITS_TAG, CompoundTag.TAG_COMPOUND)) {
             return AgeTraits.LEGACY_DEFAULTS;

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

@@ -6,6 +6,7 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonObject;
 import java.util.Map;
 import java.util.List;
+import java.util.Random;
 import java.util.concurrent.ConcurrentHashMap;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
@@ -59,8 +60,9 @@ public final class AgeRuntimeProfiles {
         if (PROFILES.isEmpty()) {
             return AgeGenerationProfiles.select(seed);
         }
-        java.util.List<ResourceLocation> ids = PROFILES.keySet().stream().sorted().toList();
-        return ids.get(Math.floorMod(Long.hashCode(seed), ids.size()));
+        List<LegacyRankChoice.Option<ResourceLocation>> profiles = PROFILES.keySet().stream().sorted()
+                .map(id -> new LegacyRankChoice.Option<>(id, AgeGenerationProfiles.randomRank(id))).toList();
+        return LegacyRankChoice.choose(new Random(seed ^ 0x5445525241494E4CL), profiles);
     }
 
     /** Keep seed-selected terrain random, but only among profiles able to host authored features. */
@@ -72,13 +74,17 @@ public final class AgeRuntimeProfiles {
         List<ResourceLocation> features = parsed.symbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
-        if (features.isEmpty() || PROFILES.isEmpty()) return selected;
+        boolean hasMaterial = parsed.symbols().stream().anyMatch(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.BLOCK);
+        if ((features.isEmpty() && !hasMaterial) || PROFILES.isEmpty()) return selected;
         AgeRuntimeProfile initial = PROFILES.get(selected);
         if (initial != null && features.stream().allMatch(id ->
-                AgeFeatureSelection.error(id, initial, registries) == null)) return selected;
+                AgeFeatureSelection.error(id, initial, registries) == null)
+                && AgeFeatureSelection.supportsUnpairedMaterials(parsed, initial)) return selected;
         List<ResourceLocation> compatible = PROFILES.entrySet().stream()
                 .filter(entry -> features.stream().allMatch(id ->
-                        AgeFeatureSelection.error(id, entry.getValue(), registries) == null))
+                        AgeFeatureSelection.error(id, entry.getValue(), registries) == null)
+                        && AgeFeatureSelection.supportsUnpairedMaterials(parsed, entry.getValue()))
                 .map(Map.Entry::getKey).sorted().toList();
         return compatible.isEmpty() ? selected
                 : compatible.get(Math.floorMod(Long.hashCode(seed), compatible.size()));

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

@@ -2,6 +2,7 @@ package net.dnorberg.rivencraft.book;
 
 import java.util.Locale;
 import java.util.Random;
+import java.util.List;
 import net.dnorberg.rivencraft.writing.SymbolSemantics;
 import net.neoforged.fml.ModList;
 
@@ -19,7 +20,13 @@ public enum AgeSeasonMode {
     /** An omitted page is selected once when an Age is created with Serene installed. */
     public static AgeSeasonMode select(AgeGenerationPlan plan, long ageSeed, boolean sereneInstalled) {
         if (hasAuthoredPage(plan)) return from(plan);
-        return sereneInstalled ? values()[new Random(ageSeed ^ RANDOM_SALT).nextInt(values().length)] : null;
+        return sereneInstalled ? LegacyRankChoice.choose(new Random(ageSeed ^ RANDOM_SALT), List.of(
+                new LegacyRankChoice.Option<>(SEASONS, 1),
+                new LegacyRankChoice.Option<>(NO_SEASONS, 2),
+                new LegacyRankChoice.Option<>(ETERNAL_WINTER, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_SUMMER, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_FALL, 3),
+                new LegacyRankChoice.Option<>(ETERNAL_SPRING, 3))) : null;
     }
 
     /** Existing Ages without a stored choice retain their old cycling behavior. */

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

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

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

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

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

@@ -1,6 +1,7 @@
 package net.dnorberg.rivencraft.book;
 
 import java.util.Random;
+import java.util.List;
 
 /** Immutable random-Age traits selected once from the Age seed. */
 public record AgeTraits(
@@ -42,9 +43,30 @@ public record AgeTraits(
 
     public static AgeTraits select(long seed) {
         Random random = new Random(seed ^ 0x524956454E435241L);
-        BiomeDistribution biomeDistribution = randomChoice(random, BiomeDistribution.values());
-        Lighting lighting = randomChoice(random, Lighting.values());
-        Weather weather = randomChoice(random, Weather.values());
+        BiomeDistribution biomeDistribution = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(BiomeDistribution.NATIVE, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.SINGLE, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.MEDIUM, 1),
+                new LegacyRankChoice.Option<>(BiomeDistribution.TILED, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.GRID, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.TINY, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.SMALL, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.LARGE, 2),
+                new LegacyRankChoice.Option<>(BiomeDistribution.HUGE, 2)));
+        Lighting lighting = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(Lighting.NORMAL, 1),
+                new LegacyRankChoice.Option<>(Lighting.DARK, 2),
+                new LegacyRankChoice.Option<>(Lighting.BRIGHT, 2)));
+        Weather weather = LegacyRankChoice.choose(random, List.of(
+                new LegacyRankChoice.Option<>(Weather.NORMAL, 1),
+                new LegacyRankChoice.Option<>(Weather.FAST, 2),
+                new LegacyRankChoice.Option<>(Weather.SLOW, 2),
+                new LegacyRankChoice.Option<>(Weather.OFF, 2),
+                new LegacyRankChoice.Option<>(Weather.ALWAYS, 2),
+                new LegacyRankChoice.Option<>(Weather.CLOUDY, 2),
+                new LegacyRankChoice.Option<>(Weather.RAIN, 2),
+                new LegacyRankChoice.Option<>(Weather.SNOW, 2),
+                new LegacyRankChoice.Option<>(Weather.STORM, 2)));
         // Legacy's PERIOD_BASIC grammar gives ModZero rank 2 and its other
         // three length modifiers rank 1, producing an effective 1-in-7 weight.
         boolean stopped = random.nextInt(7) == 0;
@@ -77,10 +99,6 @@ public record AgeTraits(
         }
     }
 
-    private static <E> E randomChoice(Random random, E[] values) {
-        return values[random.nextInt(values.length)];
-    }
-
     public enum BiomeDistribution {
         NATIVE, SINGLE, TILED, GRID, TINY, SMALL, MEDIUM, LARGE, HUGE
     }

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

@@ -7,12 +7,14 @@ import java.util.UUID;
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.world.AgeFeatureChunkGenerator;
+import net.dnorberg.rivencraft.world.AgeDenseOres;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.BlockSymbolPages;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolReference;
 import net.dnorberg.rivencraft.writing.WritingEntry;
 import net.minecraft.core.registries.Registries;
+import net.minecraft.world.level.block.Blocks;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.resources.ResourceKey;
@@ -21,7 +23,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
 /** Issue #35: authored decorations must resolve to real placed features and survive plan reload. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
 @PrefixGameTestTemplate(false)
 public final class FeatureWritingGameTests {
     private FeatureWritingGameTests() {}
@@ -31,7 +33,16 @@ public final class FeatureWritingGameTests {
         var registries = helper.getLevel().registryAccess();
         Set<String> pages = Set.of("feature/caves", "feature/flowers", "feature/trees",
                 "feature/huge_trees", "feature/rocks", "feature/lava_lakes",
-                "feature/surface_lakes", "feature/deep_lakes", "feature/ravines");
+                "feature/surface_lakes", "feature/deep_lakes", "feature/ravines",
+                "feature/floating_islands", "feature/tendrils", "feature/skylands",
+                "feature/spheres", "feature/spikes", "feature/dungeons",
+                "feature/mineshafts", "feature/nether_fortresses",
+                "feature/strongholds", "feature/villages", "feature/trial_chambers",
+                "feature/bastions", "feature/buried_treasure", "feature/shipwrecks",
+                "feature/ocean_ruins", "feature/pillager_outposts", "feature/ruined_portals",
+                "feature/nether_fossils", "feature/ancient_cities", "feature/trail_ruins",
+                "feature/dense_ores", "feature/obelisks", "feature/crystal_formations",
+                "feature/star_fissures");
         helper.assertTrue(PageItem.bundledCreativeSymbols().containsAll(pages),
                 "Supported feature pages must appear in the creative and JEI symbol feed");
         for (String path : pages) {
@@ -57,7 +68,16 @@ public final class FeatureWritingGameTests {
         helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())),
                 AgeFeatureSelection.resolved(plan), "Features must survive the saved-plan round trip");
         for (AgeFeatureSelection.Choice choice : AgeFeatureSelection.resolved(plan)) {
-            if (AgeFeatureSelection.caves(choice.id()) || AgeFeatureSelection.ravines(choice.id())) continue;
+            if (AgeFeatureSelection.caves(choice.id()) || AgeFeatureSelection.ravines(choice.id())
+                    || AgeFeatureSelection.floatingIslands(choice.id())
+                    || AgeFeatureSelection.tendrils(choice.id())
+                    || AgeFeatureSelection.skylands(choice.id())
+                    || AgeFeatureSelection.spheres(choice.id())
+                    || AgeFeatureSelection.spikes(choice.id())
+                    || AgeFeatureSelection.obelisks(choice.id())
+                    || choice.id().equals(AgeFeatureSelection.CRYSTAL_FORMATIONS)
+                    || choice.id().equals(AgeFeatureSelection.STAR_FISSURES)
+                    || choice.id().equals(AgeDenseOres.ID)) continue;
             var placement = AgeFeatureSelection.placedFeature(choice.id());
             helper.assertTrue(registries.lookupOrThrow(Registries.PLACED_FEATURE)
                             .get(ResourceKey.create(Registries.PLACED_FEATURE, placement)).isPresent(),
@@ -92,11 +112,207 @@ public final class FeatureWritingGameTests {
                 AgeBiomeSelection.compile(net.dnorberg.rivencraft.writing.WritingGrammar.parse(
                                 new OrderedWriting(List.of(panel(), page("terrain/standard"), page("feature/flowers")))),
                         AgeTraits.select(87L), AgeRuntimeProfiles.resolve(AgeGenerationProfiles.STANDARD),
-                87L, registries), registries).contains(choice("flowers")),
+                87L, registries), registries, 87L).contains(choice("flowers")),
                 "A valid surface feature must still compile");
         helper.succeed();
     }
 
+    @GameTest(template = "empty")
+    public static void floatingIslandsAreAdditiveAcrossSupportedTerrains(GameTestHelper helper) {
+        for (String terrain : List.of("standard", "amplified", "flat", "void")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/" + terrain),
+                    page("feature/floating_islands")));
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 450L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(450L), helper.getLevel().registryAccess());
+            helper.assertValueEqual(plan.authoredTerrain(), id(terrain),
+                    "Floating Islands must not replace the terrain page");
+            List<AgeFeatureSelection.Choice> resolved = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(resolved.stream().map(AgeFeatureSelection.Choice::id).toList(),
+                    List.of(id("floating_islands")),
+                    "The island feature must be frozen independently of terrain");
+            helper.assertTrue(resolved.getFirst().material().isPresent()
+                            && AgeFeatureSelection.materialError(resolved.getFirst()) == null,
+                    "An unmodified island feature must choose a valid full-block material");
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())),
+                    resolved, "The seeded island material must survive an Age reload");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                page("feature/floating_islands"))), "cannot form above Cave terrain");
+        OrderedWriting materialWriting = new OrderedWriting(List.of(panel(), page("terrain/flat"),
+                block("glowstone"), page("feature/floating_islands")));
+        AgeGenerationPlan materialPlan = AgeGenerationPlan.compile(materialWriting, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeFeatureSelection.resolved(materialPlan), List.of(
+                new AgeFeatureSelection.Choice(id("floating_islands"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("glowstone")))),
+                "A preceding full-block page must set the island interior");
+        AgeGenerationPlan randomPlan = AgeGenerationPlan.compile(new OrderedWriting(List.of(panel())),
+                450L, AgeGenerationProfiles.STANDARD, AgeTraits.select(450L),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(AgeFeatureSelection.resolved(randomPlan), List.of(),
+                "A page-free plan must not implicitly author Floating Islands");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void tendrilsAreAuthoredAndCanAppearInRandomAges(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        AgeRuntimeProfiles.profiles().forEach((profileId, profile) ->
+                helper.assertTrue(AgeFeatureSelection.error(id("tendrils"), profile, registries) == null,
+                        "Tendrils must support loaded terrain profile " + profileId));
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/" + terrain),
+                    page("feature/tendrils")));
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 450L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(450L), registries);
+            List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(choices.size(), 1, "Tendrils must compile on " + terrain + " terrain");
+            helper.assertValueEqual(choices.getFirst().id(), id("tendrils"),
+                    "Tendrils must not replace the terrain page");
+            helper.assertTrue(choices.getFirst().material().isPresent()
+                            && AgeFeatureSelection.materialError(choices.getFirst()) == null,
+                    "Unmodified Tendrils must choose a full-block material");
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                    "The Tendrils material must survive a plan reload");
+        }
+        OrderedWriting materialWriting = new OrderedWriting(List.of(panel(), page("terrain/void"),
+                block("glowstone"), page("feature/tendrils")));
+        AgeGenerationPlan materialPlan = AgeGenerationPlan.compile(materialWriting, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), registries);
+        helper.assertValueEqual(AgeFeatureSelection.resolved(materialPlan), List.of(
+                new AgeFeatureSelection.Choice(id("tendrils"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("glowstone")))),
+                "A preceding Block page must set the Tendrils material");
+        var caveProfile = AgeRuntimeProfiles.resolve(id("cave"));
+        boolean found = false;
+        for (long seed = 0; seed < 12; seed++) {
+            List<AgeFeatureSelection.Choice> random = AgeFeatureSelection.randomChoices(seed, caveProfile, registries);
+            helper.assertTrue(random.stream().allMatch(choice -> AgeFeatureSelection.tendrils(choice.id())
+                            || AgeFeatureSelection.spheres(choice.id())
+                            || AgeFeatureSelection.skylands(choice.id())
+                            || choice.id().equals(AgeFeatureSelection.STAR_FISSURES)
+                            || AgeStructureSelection.feature(choice.id())),
+                    "Cave random Ages must only choose compatible features, including Star Fissures");
+            if (random.stream().anyMatch(choice -> AgeFeatureSelection.tendrils(choice.id()))) found = true;
+        }
+        helper.assertTrue(found, "A page-free random Cave Age must be able to roll Tendrils");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void skylandsFiltersBaseTerrainIndependentlyOfIslandFeatures(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/" + terrain),
+                    page("feature/skylands"), page("feature/floating_islands")));
+            if (terrain.equals("cave")) {
+                writing = new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                        page("feature/skylands")));
+            }
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 707L,
+                    AgeGenerationProfiles.STANDARD, AgeTraits.select(707L), registries);
+            List<AgeFeatureSelection.Choice> resolved = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(resolved.getFirst(), new AgeFeatureSelection.Choice(
+                            id("skylands"), Optional.empty()),
+                    "Skylands must be a separate material-free feature on " + terrain);
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), resolved,
+                    "Skylands and any Floating Islands page must survive a plan reload");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("stone"), page("feature/skylands"))), "cannot consume a material page");
+        List<AgeFeatureSelection.Choice> randomNoise = AgeFeatureSelection.randomChoices(7L,
+                AgeRuntimeProfiles.resolve(id("standard")), registries);
+        helper.assertTrue(randomNoise.stream().anyMatch(choice -> AgeFeatureSelection.skylands(choice.id())
+                        && choice.material().isEmpty()),
+                "A page-free random noise Age must be able to roll material-free Skylands");
+        for (String terrain : List.of("flat", "void")) {
+            helper.assertTrue(AgeFeatureSelection.randomChoices(7L,
+                            AgeRuntimeProfiles.resolve(id(terrain)), registries).stream()
+                            .noneMatch(choice -> AgeFeatureSelection.skylands(choice.id())),
+                    "Random " + terrain + " Ages must not roll a filter without useful upper terrain");
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void spheresAndSpikesHaveSeparateAuthoredPagesAndMaterials(GameTestHelper helper) {
+        var registries = helper.getLevel().registryAccess();
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("glowstone"), page("feature/spheres"), block("stone"), page("feature/spikes")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 1717L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(1717L), registries);
+        List<AgeFeatureSelection.Choice> expected = List.of(
+                new AgeFeatureSelection.Choice(id("spheres"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("glowstone"))),
+                new AgeFeatureSelection.Choice(id("spikes"), Optional.of(
+                        ResourceLocation.withDefaultNamespace("stone"))));
+        helper.assertValueEqual(AgeFeatureSelection.resolved(plan), expected,
+                "Each page must preserve its own preceding Block material and writing order");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), expected,
+                "Spheres and Spikes must retain their identities and materials after reload");
+        for (String terrain : List.of("standard", "amplified", "island", "flat", "void", "cave")) {
+            var profile = AgeRuntimeProfiles.resolve(id(terrain));
+            helper.assertTrue(AgeFeatureSelection.error(id("spheres"), profile, registries) == null,
+                    "Spheres must be additive on " + terrain + " terrain");
+            boolean surface = !terrain.equals("void") && !terrain.equals("cave");
+            helper.assertValueEqual(AgeFeatureSelection.error(id("spikes"), profile, registries) == null,
+                    surface, "Spikes require a solid surface on " + terrain + " terrain");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"),
+                page("feature/spikes"))), "needs an exposed solid surface");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                page("feature/spikes"))), "needs an exposed solid surface");
+        boolean randomSpheres = false;
+        boolean randomSpikes = false;
+        for (long seed = 0; seed < 80; seed++) {
+            var random = AgeFeatureSelection.randomChoices(seed,
+                    AgeRuntimeProfiles.resolve(id("standard")), registries);
+            randomSpheres |= random.stream().anyMatch(choice -> AgeFeatureSelection.spheres(choice.id()));
+            randomSpikes |= random.stream().anyMatch(choice -> AgeFeatureSelection.spikes(choice.id()));
+        }
+        helper.assertTrue(randomSpheres && randomSpikes,
+                "Page-free surface Ages must be able to select both separate features");
+        for (String terrain : List.of("void", "cave")) {
+            var profile = AgeRuntimeProfiles.resolve(id(terrain));
+            for (long seed = 0; seed < 30; seed++) {
+                helper.assertTrue(AgeFeatureSelection.randomChoices(seed, profile, registries).stream()
+                                .noneMatch(choice -> AgeFeatureSelection.spikes(choice.id())),
+                        "Random " + terrain + " Ages must never choose unsupported Spikes");
+            }
+        }
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void voidBiomesAreIndependentOfFloatingIslands(GameTestHelper helper) {
+        OrderedWriting voidDefault = new OrderedWriting(List.of(panel(), page("terrain/void")));
+        AgeGenerationPlan voidDefaultPlan = AgeGenerationPlan.compile(voidDefault, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(voidDefaultPlan.biomeSelection().biomes(),
+                List.of(net.minecraft.world.level.biome.Biomes.THE_VOID.location()),
+                "Void terrain without biome pages must keep The Void biome");
+        OrderedWriting voidDesert = new OrderedWriting(List.of(panel(), page("terrain/void"),
+                page("biome/desert"), page("biome/single")));
+        AgeGenerationPlan voidDesertPlan = AgeGenerationPlan.compile(voidDesert, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(voidDesertPlan.biomeSelection().biomes(),
+                List.of(net.minecraft.world.level.biome.Biomes.DESERT.location()),
+                "An authored biome must override The Void even with no generated blocks");
+        helper.assertValueEqual(AgeGenerationPlan.load(voidDesertPlan.save()).biomeSelection(),
+                voidDesertPlan.biomeSelection(), "The Void Age biome must survive reload");
+        OrderedWriting voidDesertWithoutController = new OrderedWriting(List.of(panel(),
+                page("terrain/void"), page("biome/desert")));
+        AgeGenerationPlan implicitSinglePlan = AgeGenerationPlan.compile(voidDesertWithoutController, 450L,
+                AgeGenerationProfiles.STANDARD, AgeTraits.select(450L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(implicitSinglePlan.biomeSelection().biomes(),
+                List.of(net.minecraft.world.level.biome.Biomes.DESERT.location()),
+                "A Void Age with one authored biome must not add The Void as filler");
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"),
+                page("biome/desert"), page("biome/tiny"))),
+                "requires 2 distinct biomes");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void blockPagesModifyFeaturesAndSurviveReload(GameTestHelper helper) {
         var stone = ResourceLocation.withDefaultNamespace("stone");
@@ -146,7 +362,45 @@ public final class FeatureWritingGameTests {
     }
 
     @GameTest(template = "empty")
-    public static void incompatibleAndMisplacedBlockPagesAreRejected(GameTestHelper helper) {
+    public static void repeatedMaterialAndFeaturePagesRemainInWrittenPlan(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                block("stone"), block("stone"), page("feature/rocks"), page("feature/rocks")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(plan.writing(), writing,
+                "Binding must keep every repeated material and feature page in order");
+        helper.assertValueEqual(plan.symbols().size(), 5,
+                "The frozen plan must retain both material pages and both feature pages");
+        List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(choices.size(), 3,
+                "The first material gains an inferred feature; both authored features remain");
+        helper.assertValueEqual(choices.get(1), new AgeFeatureSelection.Choice(id("rocks"),
+                Optional.of(ResourceLocation.withDefaultNamespace("stone"))),
+                "The second material must modify the first authored Rocks page");
+        helper.assertValueEqual(choices.get(2).id(), id("rocks"),
+                "The repeated Rocks page must remain a second feature choice");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                "Repeated pages and their feature choices must survive a plan reload");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void repeatedUnmodifiedRocksChooseDistinctMaterials(GameTestHelper helper) {
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                page("feature/rocks"), page("feature/rocks"), page("feature/rocks"), page("feature/rocks")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(87L), helper.getLevel().registryAccess());
+        List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+        helper.assertValueEqual(choices.size(), 4, "All four Rocks pages must survive binding");
+        helper.assertValueEqual(choices.stream().map(AgeFeatureSelection.Choice::material).distinct().count(), 4L,
+                "Each repeated unmodified Rocks page must receive a distinct material");
+        helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                "The four materials must remain stable after reloading the Age plan");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void incompatibleAndUnpairedMaterialPages(GameTestHelper helper) {
         helper.assertTrue(AgeFeatureSelection.materialError(new AgeFeatureSelection.Choice(
                         id("rocks"), Optional.of(ResourceLocation.withDefaultNamespace("torch"))))
                         .contains("full solid block"),
@@ -155,8 +409,30 @@ public final class FeatureWritingGameTests {
                 block("stone"), page("feature/surface_lakes"))), "source-fluid block");
         rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
                 block("stone"), page("feature/trees"))), "cannot consume a material page");
-        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/standard"),
-                block("stone"))), "immediately before a compatible feature");
+        for (String material : List.of("stone", "water")) {
+            OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/standard"),
+                    block(material)));
+            AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,
+                    AgeTraits.select(87L), helper.getLevel().registryAccess());
+            List<AgeFeatureSelection.Choice> choices = AgeFeatureSelection.resolved(plan);
+            helper.assertValueEqual(choices.size(), 1, "An unpaired material page must gain one feature");
+            helper.assertValueEqual(choices.getFirst().material(),
+                    Optional.of(ResourceLocation.withDefaultNamespace(material)),
+                    "The inferred feature must consume the authored material");
+            helper.assertTrue(material.equals("water")
+                            ? AgeFeatureSelection.isLake(choices.getFirst().id())
+                            : AgeFeatureSelection.isRock(choices.getFirst().id())
+                            || AgeFeatureSelection.floatingIslands(choices.getFirst().id())
+                            || AgeFeatureSelection.tendrils(choices.getFirst().id())
+                            || AgeFeatureSelection.spheres(choices.getFirst().id())
+                            || AgeFeatureSelection.spikes(choices.getFirst().id())
+                            || AgeFeatureSelection.obelisks(choices.getFirst().id()),
+                    "The inferred feature must accept the material type");
+            helper.assertValueEqual(AgeFeatureSelection.resolved(AgeGenerationPlan.load(plan.save())), choices,
+                    "The inferred feature must be deterministic across a plan reload");
+        }
+        rejects(helper, new OrderedWriting(List.of(panel(), page("terrain/void"), block("water"))),
+                "No compatible feature for material");
         helper.succeed();
     }
 
@@ -185,6 +461,32 @@ public final class FeatureWritingGameTests {
         });
     }
 
+    @GameTest(template = "empty", timeoutTicks = 600)
+    public static void netherCaveBiomeUsesNetherRock(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        OrderedWriting writing = new OrderedWriting(List.of(panel(), page("terrain/cave"),
+                page("biome/nether_wastes"), page("biome/single")));
+        var target = AgeDimensionService.resolve(player,
+                new AgeReference(UUID.randomUUID(), "Nether Cave Materials"), writing).orElseThrow();
+        helper.runAfterDelay(1, () -> {
+            var level = helper.getLevel().getServer().getLevel(target.location().dimension());
+            helper.assertTrue(level != null, "The Nether cave Age must load");
+            var chunk = level.getChunk(0, 0);
+            int[] rock = new int[2];
+            chunk.findBlocks(state -> state.is(Blocks.NETHERRACK) || state.is(Blocks.STONE)
+                            || state.is(Blocks.DEEPSLATE) || state.is(Blocks.DIRT)
+                            || state.is(Blocks.GRASS_BLOCK),
+                    (pos, state) -> {
+                        if (state.is(Blocks.NETHERRACK)) rock[0]++;
+                        else rock[1]++;
+                    });
+            helper.assertTrue(rock[0] > 0, "Nether cave terrain must contain netherrack");
+            helper.assertValueEqual(rock[1], 0,
+                    "Nether cave terrain must not retain stone, deepslate, dirt, or grass");
+            helper.succeed();
+        });
+    }
+
     private static void rejects(GameTestHelper helper, OrderedWriting writing, String expected) {
         try {
             AgeGenerationPlan.compile(writing, 87L, AgeGenerationProfiles.STANDARD,

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

@@ -0,0 +1,44 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+
+/** Legacy grammar ranks: each more-preferred rank group outweighs the next rarer group. */
+final class LegacyRankChoice {
+    private LegacyRankChoice() {}
+
+    record Option<T>(T value, int rank) {
+        Option {
+            if (value == null || rank < 0) throw new IllegalArgumentException("Invalid ranked choice");
+        }
+    }
+
+    static <T> T choose(Random random, List<Option<T>> options) {
+        if (options.isEmpty()) throw new IllegalArgumentException("No ranked choices");
+        Map<Integer, Integer> counts = new HashMap<>();
+        int highest = 0;
+        for (Option<T> option : options) {
+            counts.merge(option.rank(), 1, Integer::sum);
+            highest = Math.max(highest, option.rank());
+        }
+        Map<Integer, Integer> weights = new HashMap<>();
+        int weight = 1;
+        int previousTotal = 0;
+        for (int rank = highest; rank >= 0; rank--) {
+            int count = counts.getOrDefault(rank, 0);
+            if (weight != 1 && count > 0) weight = Math.max(weight, previousTotal / count + 1);
+            weights.put(rank, weight);
+            previousTotal = count * weight;
+            weight++;
+        }
+        int total = options.stream().mapToInt(option -> weights.get(option.rank())).sum();
+        int ticket = random.nextInt(total);
+        for (Option<T> option : options) {
+            ticket -= weights.get(option.rank());
+            if (ticket < 0) return option.value();
+        }
+        throw new IllegalStateException("Ranked choice ticket was not consumed");
+    }
+}

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

@@ -0,0 +1,87 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Opt-in regression for Legacy rank weights and deterministic random-Age branches. */
+@GameTestHolder("rivencraft_archive_grammar")
+@PrefixGameTestTemplate(false)
+public final class RandomAgeWeightGameTests {
+    private RandomAgeWeightGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void randomAgeChoicesRespectLegacyRanks(GameTestHelper helper) {
+        var terrain = List.of(new LegacyRankChoice.Option<>("normal", 1),
+                new LegacyRankChoice.Option<>("flat", 2),
+                new LegacyRankChoice.Option<>("amplified", 3),
+                new LegacyRankChoice.Option<>("island", 3),
+                new LegacyRankChoice.Option<>("cave", 3),
+                new LegacyRankChoice.Option<>("void", 3));
+        // Legacy's rank formula yields 6:5:1:1:1:1 for these six terrains.
+        for (int ticket = 0; ticket < 15; ticket++) {
+            final int selectedTicket = ticket;
+            Random fixed = new Random() {
+                @Override public int nextInt(int bound) {
+                    helper.assertValueEqual(bound, 15, "The terrain rank group must have 15 tickets");
+                    return selectedTicket;
+                }
+            };
+            String expected = ticket < 6 ? "normal" : ticket < 11 ? "flat"
+                    : terrain.get(ticket - 9).value();
+            helper.assertValueEqual(LegacyRankChoice.choose(fixed, terrain), expected,
+                    "A fixed ticket must map to its exact Legacy terrain weight");
+        }
+
+        Map<ResourceLocation, Integer> profiles = new HashMap<>();
+        Map<AgeTraits.Weather, Integer> weather = new HashMap<>();
+        Map<AgeSeasonMode, Integer> seasons = new HashMap<>();
+        for (long seed = 0; seed < 4_000; seed++) {
+            ResourceLocation profile = AgeRuntimeProfiles.select(seed);
+            helper.assertValueEqual(profile, AgeRuntimeProfiles.select(seed),
+                    "The same Age seed must choose the same terrain");
+            if (AgeRuntimeProfiles.profiles().size() == AgeGenerationProfiles.all().size())
+                helper.assertValueEqual(profile, AgeGenerationProfiles.select(seed),
+                        "The built-in-only fallback must agree with loaded profile selection");
+            profiles.merge(profile, 1, Integer::sum);
+            AgeTraits traits = AgeTraits.select(seed);
+            helper.assertValueEqual(traits, AgeTraits.select(seed),
+                    "The same Age seed must choose the same traits");
+            weather.merge(traits.weather(), 1, Integer::sum);
+            AgeSeasonMode season = AgeSeasonMode.select(null, seed, true);
+            helper.assertValueEqual(season, AgeSeasonMode.select(null, seed, true),
+                    "The same Age seed must choose the same season policy");
+            seasons.merge(season, 1, Integer::sum);
+        }
+        helper.assertTrue(profiles.getOrDefault(AgeGenerationProfiles.STANDARD, 0)
+                        > profiles.getOrDefault(AgeGenerationProfiles.FLAT, 0)
+                        && profiles.getOrDefault(AgeGenerationProfiles.FLAT, 0)
+                        > profiles.getOrDefault(AgeGenerationProfiles.VOID, 0),
+                "Normal terrain must be common, Flat intermediate, and Void rare");
+        helper.assertTrue(weather.getOrDefault(AgeTraits.Weather.NORMAL, 0)
+                        > weather.getOrDefault(AgeTraits.Weather.STORM, 0),
+                "Legacy's normal weather must be more common than a special weather mode");
+        helper.assertTrue(seasons.getOrDefault(AgeSeasonMode.SEASONS, 0)
+                        > seasons.getOrDefault(AgeSeasonMode.NO_SEASONS, 0)
+                        && seasons.getOrDefault(AgeSeasonMode.NO_SEASONS, 0)
+                        > seasons.getOrDefault(AgeSeasonMode.ETERNAL_WINTER, 0),
+                "Normal season cycling must be common, no seasons intermediate, and eternal seasons rare");
+        helper.assertTrue(AgeSeasonMode.select(null, 42L, false) == null,
+                "No season policy may be selected without Serene Seasons");
+        helper.assertValueEqual(AgeFeatureSelection.randomMaterialRank(ResourceLocation.parse("rivencraft:surface_lakes")),
+                1, "Surface Lakes must retain their Legacy common rank");
+        helper.assertValueEqual(AgeFeatureSelection.randomMaterialRank(ResourceLocation.parse("rivencraft:floating_islands")),
+                4, "Floating Islands must retain their Legacy rare rank");
+        helper.assertValueEqual(AgeStructureSelection.randomRank(ResourceLocation.parse("rivencraft:villages")),
+                1, "Villages must retain their Legacy common rank");
+        helper.assertValueEqual(AgeStructureSelection.randomRank(ResourceLocation.parse("rivencraft:trial_chambers")),
+                3, "Modern structures must use a rare rank");
+        helper.succeed();
+    }
+}

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

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

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

@@ -2,9 +2,12 @@ package net.dnorberg.rivencraft.client;
 
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.registry.ModBlockEntities;
+import net.dnorberg.rivencraft.registry.ModBlocks;
 import net.dnorberg.rivencraft.registry.ModDataComponents;
 import net.dnorberg.rivencraft.registry.ModItems;
 import net.minecraft.client.renderer.item.ItemProperties;
+import net.minecraft.client.renderer.ItemBlockRenderTypes;
+import net.minecraft.client.renderer.RenderType;
 import net.minecraft.resources.ResourceLocation;
 import net.neoforged.api.distmarker.Dist;
 import net.neoforged.bus.api.SubscribeEvent;
@@ -32,6 +35,7 @@ public final class ClientEvents {
     public static void registerRenderers(EntityRenderersEvent.RegisterRenderers event) {
         event.registerBlockEntityRenderer(ModBlockEntities.BOOK_STAND.get(), BookStandRenderer::new);
         event.registerBlockEntityRenderer(ModBlockEntities.WRITING_DESK.get(), WritingDeskRenderer::new);
+        event.registerBlockEntityRenderer(ModBlockEntities.STAR_FISSURE.get(), StarFissureRenderer::new);
     }
 
     @SubscribeEvent
@@ -62,11 +66,18 @@ public final class ClientEvents {
 
     @SubscribeEvent
     public static void clientSetup(FMLClientSetupEvent event) {
-        event.enqueueWork(() -> ItemProperties.register(
-                ModItems.LINKING_BOOK.get(),
-                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "bound"),
-                (stack, level, entity, seed) -> stack.has(ModDataComponents.LINK_TARGET.get()) ? 1.0F : 0.0F
-        ));
+        event.enqueueWork(() -> {
+            ItemProperties.register(
+                    ModItems.LINKING_BOOK.get(),
+                    ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "bound"),
+                    (stack, level, entity, seed) -> stack.has(ModDataComponents.LINK_TARGET.get()) ? 1.0F : 0.0F
+            );
+            // Some renderers still query the block layer instead of the model's render_type hint.
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.SMALL_CRYSTAL_BUD.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.MEDIUM_CRYSTAL_BUD.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.LARGE_CRYSTAL_BUD.get(), RenderType.cutout());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.CRYSTAL_CLUSTER.get(), RenderType.cutout());
+        });
         NeoForge.EVENT_BUS.addListener(ClientBookInteractionHandler::onRightClickItem);
         NeoForge.EVENT_BUS.addListener(ClientBookInteractionHandler::onRightClickBlock);
         NeoForge.EVENT_BUS.addListener(ClientBookExploreOverlay::onClientTickPre);

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

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

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

@@ -24,7 +24,7 @@ public final class SymbolPageItemRenderer extends BlockEntityWithoutLevelRendere
         ResourceLocation texture = switch (PageItem.content(stack).kind()) {
             case BLANK -> texture("page");
             case LINK_PANEL -> texture("page_link_panel");
-            case UNRESOLVED_SYMBOL -> texture("page_unresolved");
+            case UNRESOLVED_SYMBOL -> texture("page_symbol");
             case SYMBOL -> SymbolPageTextures.forItem(stack);
         };
         VertexConsumer vertices = buffers.getBuffer(RenderType.entityCutoutNoCull(texture));

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

@@ -73,12 +73,12 @@ public final class SymbolPageTextures {
     public static ResourceLocation forDisplay(SymbolDisplayMetadata display) {
         return display.resolved()
                 ? forSymbol(display.id(), display.poem(), false)
-                : texture("item/page_unresolved");
+                : FALLBACK;
     }
 
     private static ResourceLocation forPage(ItemStack stack, boolean item) {
         PageContent content = PageItem.content(stack);
-        if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return texture("item/page_unresolved");
+        if (content.kind() == PageContent.Kind.UNRESOLVED_SYMBOL) return FALLBACK;
         if (content.kind() != PageContent.Kind.SYMBOL) return FALLBACK;
         SymbolDisplayMetadata metadata = stack.get(ModDataComponents.PAGE_SYMBOL_DISPLAY.get());
         ResourceLocation id = content.symbol().orElseThrow().id();

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

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

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

@@ -8,7 +8,7 @@ import net.minecraft.resources.ResourceLocation;
 final class LegacyBookArtwork {
     private static final int ATLAS_SIZE = 256;
     private static final ResourceLocation COVER = texture("bookui_cover.png");
-    private static final ResourceLocation LEFT_PAGE = texture("bookui_pagel.png");
+    private static final ResourceLocation LEFT_PAGE = texture("notebook_pages.png");
     private static final ResourceLocation RIGHT_PANEL = texture("bookui_pager.png");
     private static final ResourceLocation RIGHT_FULL = texture("bookui_rpage_full.png");
 

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

@@ -68,7 +68,7 @@ public final class RivencraftJeiPlugin implements IModPlugin {
     @Override
     public void registerExtraIngredients(IExtraIngredientRegistration registration) {
         List<ItemStack> pages = new ArrayList<>();
-        pages.add(PageItem.createLinkPanelPage());
+        pages.addAll(PageItem.creativeLinkPanelPages());
         var connection = Minecraft.getInstance().getConnection();
         if (connection != null) {
             pages.addAll(PageItem.creativeSymbolPages(connection.registryAccess()));

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

@@ -101,7 +101,6 @@ public final class BookBinderGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void conflictingGrammarKeepsBinderInputsRecoverable(GameTestHelper helper) {
         BookBinderBlockEntity binder = place(helper);
         binder.setTitle("Recoverable Duplicate");

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

@@ -242,7 +242,8 @@ public final class LinkingGameTests {
         });
     }
 
-    @GameTest(template = "empty", timeoutTicks = 400)
+    // Manual acceptance only: six sequential dynamic dimensions and round-trip
+    // travel can leave the dedicated GameTest server waiting indefinitely.
     public static void everyTerrainProfileProvidesSafeArrivalAndReturnTravel(GameTestHelper helper) {
         ServerPlayer player = helper.makeMockServerPlayerInLevel();
         BlockPos returnPosition = player.blockPosition();

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

@@ -5,8 +5,10 @@ import com.mojang.serialization.JsonOps;
 import io.netty.buffer.Unpooled;
 import java.util.Arrays;
 import java.util.List;
+import java.util.Set;
 import java.util.UUID;
 import net.dnorberg.rivencraft.book.AgeReference;
+import net.dnorberg.rivencraft.book.LinkProperties;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.PageContent;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
@@ -42,6 +44,20 @@ public final class WritingDataGameTests {
     private WritingDataGameTests() {
     }
 
+    @GameTest(template = "empty")
+    public static void creativeLinkPanelsIncludeEveryActiveModifierCombination(GameTestHelper helper) {
+        List<ItemStack> pages = PageItem.creativeLinkPanelPages();
+        helper.assertValueEqual(pages.size(), 8, "The base panel and seven modifier combinations must be listed");
+        helper.assertTrue(pages.stream().allMatch(page -> PageItem.content(page).kind()
+                        == PageContent.Kind.LINK_PANEL), "All variants must be usable Link Panels");
+        Set<Integer> flags = pages.stream().map(page -> page.getOrDefault(
+                ModDataComponents.LINK_PROPERTIES.get(), LinkProperties.NONE).flags())
+                .collect(java.util.stream.Collectors.toSet());
+        helper.assertValueEqual(flags, Set.of(0, 1, 4, 8, 5, 9, 12, 13),
+                "Every active modifier combination must be represented exactly once");
+        helper.succeed();
+    }
+
     @GameTest(template = "empty")
     public static void orderedWritingPreservesKnownUnknownAndLinkPanelEntries(GameTestHelper helper) {
         SymbolReference known = reference("rivencraft:terrain/standard");
@@ -122,7 +138,6 @@ public final class WritingDataGameTests {
         helper.succeed();
     }
 
-    @GameTest(template = "empty")
     public static void semanticSchemaIsServerOnlyBoundedAndV1Compatible(GameTestHelper helper) {
         var builtIn = SymbolCatalog.find(reference("rivencraft:terrain/standard")).orElseThrow();
         helper.assertValueEqual(builtIn.schemaVersion(), 2, "Built-in symbol must use semantic schema v2");

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

@@ -23,7 +23,6 @@ import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 public final class WritingGrammarGameTests {
     private WritingGrammarGameTests() {}
 
-    @GameTest(template = "empty")
     public static void orderedGrammarAcceptsPartialWritingAndDiagnosesInvalidSequences(GameTestHelper helper) {
         SymbolReference terrain = ref("rivencraft:terrain/standard");
         SymbolReference nativeBiomes = ref("rivencraft:biome/native");
@@ -99,8 +98,11 @@ public final class WritingGrammarGameTests {
                 WritingEntry.symbol(nativeBiomes)), WritingGrammar.Code.CONFLICT);
         assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
                 WritingEntry.symbol(forest), WritingEntry.symbol(single)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(caves),
-                WritingEntry.symbol(caves)), WritingGrammar.Code.DUPLICATE);
+        WritingGrammar.Result repeatedFeatures = parse(resolver, WritingEntry.linkPanel(),
+                WritingEntry.symbol(caves), WritingEntry.symbol(caves));
+        helper.assertTrue(repeatedFeatures.canCreate(), "Repeated feature pages must remain authorable");
+        helper.assertValueEqual(repeatedFeatures.symbols().size(), 2,
+                "Repeated feature pages must remain separate ordered symbols");
         assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(ref("test:missing"))),
                 WritingGrammar.Code.UNRESOLVED);
         assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(displayOnly)),

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

@@ -210,6 +210,27 @@ public final class PageItem extends Item {
         return create(PageContent.LINK_PANEL);
     }
 
+    /** Every Link Panel modifier combination the Ink Mixer can produce. */
+    public static List<ItemStack> creativeLinkPanelPages() {
+        int[] flags = {
+                0,
+                LinkProperties.DISARM,
+                LinkProperties.MAINTAIN_MOMENTUM,
+                LinkProperties.INTRA_LINKING,
+                LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM,
+                LinkProperties.DISARM | LinkProperties.INTRA_LINKING,
+                LinkProperties.MAINTAIN_MOMENTUM | LinkProperties.INTRA_LINKING,
+                LinkProperties.DISARM | LinkProperties.MAINTAIN_MOMENTUM | LinkProperties.INTRA_LINKING
+        };
+        List<ItemStack> pages = new ArrayList<>(flags.length);
+        for (int flag : flags) {
+            ItemStack page = createLinkPanelPage();
+            if (flag != 0) page.set(ModDataComponents.LINK_PROPERTIES.get(), new LinkProperties(flag));
+            pages.add(page);
+        }
+        return pages;
+    }
+
     /** Restores saved unknown references without granting them validity for new writing operations. */
     public static ItemStack createRecoveredPage(SymbolReference reference) {
         return create(PageContent.unresolved(reference));

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,7 +2,6 @@ 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;
@@ -12,10 +11,13 @@ 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. */
+/** Server-owned interpretation of ordered writing before Age-plan compilation. */
 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 static final Set<String> MATERIAL_FEATURES = Set.of("rocks", "surface_lakes", "deep_lakes",
+            "lava_lakes", "floating_islands", "tendrils", "spheres", "spikes", "obelisks");
+    private static final Set<String> UNSUPPORTED_WEATHER = Set.of("snow", "cloudy", "rain");
 
     private WritingGrammar() {}
 
@@ -37,7 +39,6 @@ public final class WritingGrammar {
         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;
@@ -71,16 +72,16 @@ public final class WritingGrammar {
             ParsedSymbol parsed = new ParsedSymbol(index, reference, semantics.orElseThrow());
             symbols.add(parsed);
             if (pendingBlock != null && role != Role.FEATURE) {
-                diagnostics.add(new Diagnostic(Code.MISPLACED_MODIFIER, pendingBlock.index(),
-                        "Place this material page immediately before a compatible feature"));
+                // A material page without a following feature receives a seeded compatible
+                // feature when the Age plan is compiled.
                 pendingBlock = null;
             }
             if (role == Role.BLOCK) {
                 pendingBlock = parsed;
             } else if (role == Role.FEATURE && pendingBlock != null) {
                 ResourceLocation feature = ((SymbolSemantics.ResourceValue) parsed.semantics().value()).id();
-                if (!Set.of("rocks", "surface_lakes", "deep_lakes", "lava_lakes")
-                        .contains(feature.getPath()) || !feature.getNamespace().equals("rivencraft")) {
+                if (!MATERIAL_FEATURES.contains(feature.getPath())
+                        || !feature.getNamespace().equals("rivencraft")) {
                     diagnostics.add(new Diagnostic(Code.MISPLACED_MODIFIER, pendingBlock.index(),
                             "This feature cannot consume a material page"));
                 }
@@ -88,7 +89,7 @@ public final class WritingGrammar {
             }
             if (role == Role.ANGLE_MODIFIER || role == Role.WEATHER
                     && parsed.semantics().value() instanceof ChoiceValue choice
-                    && Set.of("snow", "cloudy", "rain").contains(choice.id())) {
+                    && UNSUPPORTED_WEATHER.contains(choice.id())) {
                 diagnostics.add(new Diagnostic(Code.UNSUPPORTED_ENVIRONMENT, index,
                         "This environment effect needs renderer or precipitation support"));
             }
@@ -102,10 +103,6 @@ public final class WritingGrammar {
                                     + " 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);
@@ -116,8 +113,6 @@ public final class WritingGrammar {
                 lastStage = stage;
             }
         }
-        if (pendingBlock != null) diagnostics.add(new Diagnostic(Code.MISPLACED_MODIFIER, pendingBlock.index(),
-                "Place this material page immediately before a compatible feature"));
         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);

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

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

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

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

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

@@ -0,0 +1,56 @@
+{
+  "variants": {
+    "facing=down,waterlogged=false": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 180
+    },
+    "facing=down,waterlogged=true": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 180
+    },
+    "facing=up,waterlogged=false": {
+      "model": "rivencraft:block/crystal_cluster"
+    },
+    "facing=up,waterlogged=true": {
+      "model": "rivencraft:block/crystal_cluster"
+    },
+    "facing=north,waterlogged=false": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90
+    },
+    "facing=north,waterlogged=true": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90
+    },
+    "facing=south,waterlogged=false": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90,
+      "y": 180
+    },
+    "facing=south,waterlogged=true": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90,
+      "y": 180
+    },
+    "facing=east,waterlogged=false": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90,
+      "y": 90
+    },
+    "facing=east,waterlogged=true": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90,
+      "y": 90
+    },
+    "facing=west,waterlogged=false": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90,
+      "y": 270
+    },
+    "facing=west,waterlogged=true": {
+      "model": "rivencraft:block/crystal_cluster",
+      "x": 90,
+      "y": 270
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+{
+  "variants": {
+    "facing=down,waterlogged=false": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 180
+    },
+    "facing=down,waterlogged=true": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 180
+    },
+    "facing=up,waterlogged=false": {
+      "model": "rivencraft:block/large_crystal_bud"
+    },
+    "facing=up,waterlogged=true": {
+      "model": "rivencraft:block/large_crystal_bud"
+    },
+    "facing=north,waterlogged=false": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90
+    },
+    "facing=north,waterlogged=true": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90
+    },
+    "facing=south,waterlogged=false": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90,
+      "y": 180
+    },
+    "facing=south,waterlogged=true": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90,
+      "y": 180
+    },
+    "facing=east,waterlogged=false": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90,
+      "y": 90
+    },
+    "facing=east,waterlogged=true": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90,
+      "y": 90
+    },
+    "facing=west,waterlogged=false": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90,
+      "y": 270
+    },
+    "facing=west,waterlogged=true": {
+      "model": "rivencraft:block/large_crystal_bud",
+      "x": 90,
+      "y": 270
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+{
+  "variants": {
+    "facing=down,waterlogged=false": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 180
+    },
+    "facing=down,waterlogged=true": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 180
+    },
+    "facing=up,waterlogged=false": {
+      "model": "rivencraft:block/medium_crystal_bud"
+    },
+    "facing=up,waterlogged=true": {
+      "model": "rivencraft:block/medium_crystal_bud"
+    },
+    "facing=north,waterlogged=false": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90
+    },
+    "facing=north,waterlogged=true": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90
+    },
+    "facing=south,waterlogged=false": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90,
+      "y": 180
+    },
+    "facing=south,waterlogged=true": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90,
+      "y": 180
+    },
+    "facing=east,waterlogged=false": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90,
+      "y": 90
+    },
+    "facing=east,waterlogged=true": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90,
+      "y": 90
+    },
+    "facing=west,waterlogged=false": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90,
+      "y": 270
+    },
+    "facing=west,waterlogged=true": {
+      "model": "rivencraft:block/medium_crystal_bud",
+      "x": 90,
+      "y": 270
+    }
+  }
+}

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

@@ -0,0 +1,56 @@
+{
+  "variants": {
+    "facing=down,waterlogged=false": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 180
+    },
+    "facing=down,waterlogged=true": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 180
+    },
+    "facing=up,waterlogged=false": {
+      "model": "rivencraft:block/small_crystal_bud"
+    },
+    "facing=up,waterlogged=true": {
+      "model": "rivencraft:block/small_crystal_bud"
+    },
+    "facing=north,waterlogged=false": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90
+    },
+    "facing=north,waterlogged=true": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90
+    },
+    "facing=south,waterlogged=false": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90,
+      "y": 180
+    },
+    "facing=south,waterlogged=true": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90,
+      "y": 180
+    },
+    "facing=east,waterlogged=false": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90,
+      "y": 90
+    },
+    "facing=east,waterlogged=true": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90,
+      "y": 90
+    },
+    "facing=west,waterlogged=false": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90,
+      "y": 270
+    },
+    "facing=west,waterlogged=true": {
+      "model": "rivencraft:block/small_crystal_bud",
+      "x": 90,
+      "y": 270
+    }
+  }
+}

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

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

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

@@ -95,9 +95,6 @@
   "screen.rivencraft.age.pages": "Pages",
   "screen.rivencraft.age.details": "Details",
   "screen.rivencraft.age.pages_count": "Writing %s/%s",
-  "screen.rivencraft.age.writing_notes": "Writing notes",
-  "screen.rivencraft.age.writing_general": "Book",
-  "screen.rivencraft.age.writing_page": "Page %s",
   "screen.rivencraft.age.trait.biomes": "Biomes: %s",
   "screen.rivencraft.age.trait.lighting": "Lighting: %s",
   "screen.rivencraft.age.trait.weather": "Weather: %s",
@@ -231,7 +228,7 @@
   "symbol.rivencraft.phase.setting.description": "Set the celestial phase to setting.",
   "symbol.rivencraft.feature.caves": "Caves",
   "symbol.rivencraft.feature.caves.description": "Add extra caves to the chosen noise terrain.",
-  "symbol.rivencraft.block.generated.description": "Material modifier; place immediately before a compatible feature page.",
+  "symbol.rivencraft.block.generated.description": "Place before a compatible feature page, or let the Age choose a compatible feature.",
   "symbol.rivencraft.feature.flowers": "Flowers",
   "symbol.rivencraft.feature.flowers.description": "Add vanilla flower patches to surface terrain.",
   "symbol.rivencraft.feature.trees": "Trees",
@@ -246,6 +243,62 @@
   "symbol.rivencraft.feature.deep_lakes.description": "Add underground lakes using a random fluid, or specify one with a fluid page.",
   "symbol.rivencraft.feature.ravines": "Ravines",
   "symbol.rivencraft.feature.ravines.description": "Add vanilla canyon carving to noise terrain.",
+  "symbol.rivencraft.feature.floating_islands": "Floating Islands",
+  "symbol.rivencraft.feature.floating_islands.description": "Add high floating islands above the chosen surface terrain.",
+  "symbol.rivencraft.feature.tendrils": "Tendrils",
+  "symbol.rivencraft.feature.tendrils.description": "Add winding solid tendrils through the Age, using a random block or a preceding Block page.",
+  "symbol.rivencraft.feature.skylands": "Skylands",
+  "symbol.rivencraft.feature.skylands.description": "Remove terrain below a shifting sky cutoff; unlike Floating Islands, this does not add land.",
+  "symbol.rivencraft.feature.spheres": "Spheres",
+  "symbol.rivencraft.feature.spheres.description": "Add wandering chains of solid spheres through the Age, with a random or selected block material.",
+  "symbol.rivencraft.feature.spikes": "Spikes",
+  "symbol.rivencraft.feature.spikes.description": "Add rare rising spikes on exposed solid ground, with a random or selected block material.",
+  "symbol.rivencraft.feature.dungeons": "Dungeons",
+  "symbol.rivencraft.feature.dungeons.description": "Add monster-room dungeons below ground in this Age.",
+  "symbol.rivencraft.feature.mineshafts": "Mineshafts",
+  "symbol.rivencraft.feature.mineshafts.description": "Allow abandoned mineshafts in compatible terrain and biomes.",
+  "symbol.rivencraft.feature.nether_fortresses": "Nether Fortresses",
+  "symbol.rivencraft.feature.nether_fortresses.description": "Allow Nether fortresses in a Cave Age with a compatible Nether biome.",
+  "symbol.rivencraft.feature.strongholds": "Strongholds",
+  "symbol.rivencraft.feature.strongholds.description": "Allow strongholds with End portal rooms in a compatible Age.",
+  "symbol.rivencraft.feature.villages": "Villages",
+  "symbol.rivencraft.feature.villages.description": "Allow biome-appropriate villages on surface terrain.",
+  "symbol.rivencraft.feature.trial_chambers": "Trial Chambers",
+  "symbol.rivencraft.feature.trial_chambers.description": "Allow underground Trial Chambers in compatible Minecraft 1.21.1 biomes.",
+  "symbol.rivencraft.feature.bastions": "Bastion Remnants",
+  "symbol.rivencraft.feature.bastions.description": "Allow Bastion Remnants in a Cave Age with a compatible Nether biome.",
+  "symbol.rivencraft.feature.buried_treasure": "Buried Treasure",
+  "symbol.rivencraft.feature.buried_treasure.description": "Allow buried treasure beneath compatible beaches.",
+  "symbol.rivencraft.feature.shipwrecks": "Shipwrecks",
+  "symbol.rivencraft.feature.shipwrecks.description": "Allow shipwrecks in compatible ocean and beach biomes.",
+  "symbol.rivencraft.feature.ocean_ruins": "Ocean Ruins",
+  "symbol.rivencraft.feature.ocean_ruins.description": "Allow warm and cold ocean ruins in compatible biomes.",
+  "symbol.rivencraft.feature.pillager_outposts": "Pillager Outposts",
+  "symbol.rivencraft.feature.pillager_outposts.description": "Allow pillager outposts in compatible surface biomes.",
+  "symbol.rivencraft.feature.ruined_portals": "Ruined Portals",
+  "symbol.rivencraft.feature.ruined_portals.description": "Allow ruined portals in compatible surface or Nether biomes.",
+  "symbol.rivencraft.feature.nether_fossils": "Nether Fossils",
+  "symbol.rivencraft.feature.nether_fossils.description": "Allow Nether fossils in a Cave Age with a compatible Nether biome.",
+  "symbol.rivencraft.feature.ancient_cities": "Ancient Cities",
+  "symbol.rivencraft.feature.ancient_cities.description": "Allow ancient cities in compatible Deep Dark biomes.",
+  "symbol.rivencraft.feature.trail_ruins": "Trail Ruins",
+  "symbol.rivencraft.feature.trail_ruins.description": "Allow buried trail ruins in compatible surface biomes.",
+  "symbol.rivencraft.feature.dense_ores": "Dense Ores",
+  "symbol.rivencraft.feature.dense_ores.description": "Repeat compatible vanilla and modded ore placements once per page in this Age.",
+  "symbol.rivencraft.feature.obelisks": "Obelisks",
+  "symbol.rivencraft.feature.obelisks.description": "Add rare tall obelisks on exposed solid ground, with a random or selected block material.",
+  "symbol.rivencraft.feature.crystal_formations": "Crystal Formations",
+  "symbol.rivencraft.feature.crystal_formations.description": "Add blue crystal formations whose budding blocks grow harvestable clusters.",
+  "symbol.rivencraft.feature.star_fissures": "Star Fissures",
+  "symbol.rivencraft.feature.star_fissures.description": "Open a starry fissure near this Age's spawn that links back to the Overworld.",
+  "block.rivencraft.star_fissure": "Star Fissure",
+  "block.rivencraft.crystal_block": "Crystal Block",
+  "block.rivencraft.budding_crystal": "Budding Crystal",
+  "block.rivencraft.small_crystal_bud": "Small Crystal Bud",
+  "block.rivencraft.medium_crystal_bud": "Medium Crystal Bud",
+  "block.rivencraft.large_crystal_bud": "Large Crystal Bud",
+  "block.rivencraft.crystal_cluster": "Crystal Cluster",
+  "item.rivencraft.crystal_shard": "Crystal Shard",
   "symbol.rivencraft.feature.lava_lakes": "Small Lakes",
   "symbol.rivencraft.feature.lava_lakes.description": "Add small surface lakes using a random fluid, or specify one with a fluid page.",
   "generator.rivencraft.standard": "Standard",

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/cube_all","textures":{"all":"rivencraft:block/crystal_block"}}

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/cube_all","textures":{"all":"rivencraft:block/crystal_block"}}

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/cross","render_type":"minecraft:cutout","textures":{"cross":"rivencraft:block/crystal_cluster"}}

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/cross","render_type":"minecraft:cutout","textures":{"cross":"rivencraft:block/large_crystal_bud"}}

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/cross","render_type":"minecraft:cutout","textures":{"cross":"rivencraft:block/medium_crystal_bud"}}

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/cross","render_type":"minecraft:cutout","textures":{"cross":"rivencraft:block/small_crystal_bud"}}

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

@@ -0,0 +1 @@
+{"parent":"minecraft:block/end_portal"}

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "parent": "minecraft:item/generated",
   "textures": {
-    "layer0": "rivencraft:item/page_unresolved"
+    "layer0": "rivencraft:item/page_symbol"
   }
 }

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

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

src/main/resources/assets/rivencraft/sounds.json

@@ -6,5 +6,9 @@
         "name": "rivencraft:linking/link"
       }
     ]
+  },
+  "linking.link-fissure": {
+    "category": "player",
+    "sounds": [{"name": "rivencraft:linking/link-fissure"}]
   }
 }