Port bounded colored decay and align Legacy defaults (#68)

Persist repaired Age writing and provisional instability penalties, retain fatal diagnostics for unsupported content, and hide TerraBlender's deferred placeholder biome from creative and JEI.

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_CLOUD_PLATFORM.md

@@ -0,0 +1,7 @@
+# Age arrival cloud platform
+
+Newly created Ages now place a 5×5 solid cloud platform instead of cobblestone at their saved spawn. The block has full collision, passes skylight, renders translucently, has no loot table, and cannot be obtained with pick-block. Existing Ages retain their already-placed platform; this change does not overwrite a player's saved world.
+
+The block texture is `assets/rivencraft/textures/block/cloud_platform.png`, verified at exactly 16×16 RGBA. Legacy's supplied assets contain no cloud-block texture, so this one was generated with the built-in image tool, then reduced by nearest-neighbor sampling. The final prompt requested a seamless Minecraft block-face pixel-art tile with 2–3 chunky white, icy-blue, and powder-blue cloud swirls, genuine transparent holes between them, strong 16×16-scale contrast, and no background or text.
+
+The separate [decay provider](INSTABILITY_DECAY.md) protects the saved spawn area by position, so its protection remains in force regardless of the platform's material.

docs/AGE_PROFILES.md

@@ -65,6 +65,65 @@ 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
@@ -140,7 +199,7 @@ eligible biomes for Tiled/Grid and Tiny–Huge. The eligible pool comes from the
 terrain's biome preset, or `#rivencraft:cave_biomes` for Cave terrain, so future
 biome integrations can expand it without changing the count rule. Single uses
 one; Native uses its preset biome pool. This random-age maximum does not truncate
-authored pages: the Binder's 27 symbol-page positions bound an authored book.
+authored pages: the Binder's 252 symbol-page positions bound an authored book. Legacy's Binder itself had no explicit page-count check; this remains a fixed-slot storage ceiling.
 Native cannot be paired with explicit biome pages. Legacy filled Tiny–Huge to
 three; Rivencraft deliberately uses two so a pair of written biome pages stays
 exactly as written.

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/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/INSTABILITY_DECAY.md

@@ -0,0 +1,13 @@
+# Colored decay (Milestone 6, issue #68)
+
+Legacy defines seven decay block-state colors and has a texture/model for every one: black, red, green, blue, purple, yellow, and white. That does not mean all seven are active instability hazards. Its active provider deck registers blue, purple, red, and white. Black has a decay handler and provider class, but its provider registration is commented out; green and yellow have visual states without registered spread handlers. Rivencraft currently implements the four active provider colors. Their 16×16 textures are exact copies of the local Mystcraft 1.12.2-0.13.7.06 assets at `assets/mystcraft/textures/blocks/decay_{blue,purple,red,white}.png`. Legacy's `blockdecay.json` and `blockdecay_*.json` map these to cube-all models; Rivencraft uses the same mapping.
+
+The local Legacy bytecode (`EffectDecayBasic`, `DecayHandlerSpreading`, and the four color handlers) seeds decay in a chunk, then spreads to six neighbors. Blue prefers softer blocks, red uses explosion resistance, purple is slower, and white converts almost anything and damages entities on contact. Rivencraft preserves the four colors, six-neighbor growth, relative conversion tendencies, and white contact damage. It adapts the exact difficulty formulas to modern block hardness and safety checks; fluids are not replaced, and provider attempts are deterministic from the Age seed and persisted attempt counter.
+
+Decay requires both `instability.world_mutation=true` and `instability_decay.enabled=true` in the server config. Both now default to true, matching Legacy's enabled-by-default Age instability and provider registration. Existing config files retain their saved values, including `false`; change them explicitly to opt in after updating an existing installation. At most `instability_decay.max_attempts_per_call` neighbors (default four) are examined, each within radius one, and at most one block can be replaced per provider run. The shared Age action budget may lower that further. Only chunks already loaded and supplied by the scheduler are touched; no cross-dimension or force-loading path exists. A per-Age `rivencraft_decay` saved data file stores a bounded frontier (1024 positions per color) and attempt counter. Disabling decay stops seeding, spreading, and white contact damage; existing blocks remain so re-enabling can resume.
+
+Decay rejects the saved Age spawn and its nearby 5×5 arrival platform (with a two-block margin), block entities, fluids, unbreakable blocks, vanilla portal/command/structure infrastructure, blocks in `#minecraft:portals`, all non-decay Rivencraft blocks, and blocks in `#rivencraft:decay_protected`. Data packs can append other mods' protected blocks to that tag. A fake-player break event is posted before replacement, and a placement event after it; a cancellation prevents or restores the change. As with other fake-player automation, protection mods need to handle NeoForge block events for this safeguard to apply.
+
+GameTests cover persistence, frontier deduplication, selected-chunk limits, and Overworld isolation. A real-client check should enable both settings in a disposable Age, observe growth, leave/reload that Age, then disable decay and verify growth stops. Also test a claim-protected block and a block entity if a protection mod is installed.
+
+For current test builds, an operator standing in an Age can use `/rivencraft age decay pulse white 32` (or `blue`, `purple`, `red`). This performs at most 32 budgeted provider calls in the player's already-loaded chunk and reports how many blocks converted. It does not edit the saved Age plan or instability score. Repeat the command to observe spread, leave/reload the Age to check persistence, then disable decay and confirm the command refuses to act. This test hook remains useful because the provisional authored-page scoring does not yet provide a reliable route to the Legacy eating deck's 15,000-point gate.

docs/INSTABILITY_RUNTIME.md

@@ -0,0 +1,9 @@
+# Instability provider runtime (Milestone 6, issue #66)
+
+Each new Age stores an `InstabilityPlan` beside its frozen `Instability` score. The version-1 plan contains provider IDs and levels. Selection uses the saved score rounded down to a 500-point step and the Age seed. It independently walks Legacy's basic, harsh, destructive, eating, and death decks with their audited entry costs (0, 2,500, 10,000, 15,000, 20,000), shuffling each deck deterministically before paying its weighted card costs. The source card weights and default provider costs are copied from the user's local Mystcraft 0.13.7.06 `InstabilityData` class. This preserves Legacy's multiple-deck behavior, but does not claim byte-for-byte reproduction of its historical Java RNG state, difficulty multiplier, config overrides, or 400-chunk block profiling delay.
+
+The saved provider IDs are independent of installed handlers. A missing optional handler leaves its ID and level intact and is skipped at runtime. A syntactically invalid saved ID or unsupported plan version fails loading explicitly; an unknown but valid ID is preserved and logged once when encountered. Disabling instability or world mutation never rewrites a saved score or provider plan. Saves from #64 with a frozen score but no provider plan are selected once from that score and Age seed, then marked dirty for persistence. Older pre-score Ages remain neutral and inert.
+
+The server scheduler runs only for loaded `rivencraft:age/*` levels with a player present and an Age definition. It uses only chunks already loaded near those players, never requests a chunk, and rotates among eligible Ages when the per-tick cap is reached. Configuration bounds the cooldown (minimum 20 ticks), active Ages, handlers and actions per Age, effective provider level, and examined loaded chunks. A handler must claim a shared action permit before each effect. A throwing handler is logged and quarantined temporarily without stopping the server. World-mutating handlers are enabled by default to match Legacy; the setting can still disable them. These limits are guards for upcoming providers, not proof that an arbitrary third-party handler cannot misuse world APIs.
+
+Issue #67 registers the non-world-mutating potion handlers; see [status-effect policy](INSTABILITY_STATUS_EFFECTS.md). Issue #68 adds configurable [colored decay](INSTABILITY_DECAY.md), enabled by default for newly generated configs. Other world hazards remain for #69–#70. The runtime rejects Overworld and preview dimension IDs; its player requirement excludes unattended snapshot chunk loaders. GameTests cover deterministic selection, save round-trips, score-only migration, unknown IDs, scope checks, fair admission, and action caps.

docs/INSTABILITY_SCORE.md

@@ -0,0 +1,9 @@
+# Frozen Age instability score (Milestone 6, issue #64)
+
+Every newly created Age now gets a version-1 `Instability` compound inside its server-owned `rivencraft_ages` saved definition. It contains the total `Score` and an ordered `Breakdown` of reason, original page index (zero-based, or -1 for an Age-wide cause), points, and explanation. `AgeRegistrySavedData.instability(UUID)` is the read-only server query. No client tooltip or live data-pack lookup is needed to read a saved score.
+
+The baseline is explicitly zero for page-free and Link-Panel-only random Ages, and for authored Ages. Incomplete writing receives seed-based completion and a zero-point explanatory entry. Supported writing defects use the provisional Milestone 6 grammar costs: duplicate/conflicting single-choice pages +500, out-of-order or misplaced pages +100. Legacy's audited bright-lighting symbol adds +500 whether authored or seed-selected. Other balance costs are not guessed for symbols that Rivencraft has not implemented. The score is not yet an active hazard or effect selection.
+
+The score is calculated after the Age plan and effective traits are chosen, then saved with the Age identity before its dimension is generated. The same UUID returns the existing definition, including the same score, on repeated use. Spawn updates preserve it. Reload only deserializes the frozen breakdown; it never reruns the current grammar or catalog. An older Age definition without `Instability` is migrated to a persisted version-1 neutral score of zero, rather than retroactively scoring its writing. A future scoring-rule change must introduce an explicit new schema/migration policy, not silently reinterpret existing Ages. Issue #66 additionally freezes a provider selection from this score; see [runtime policy](INSTABILITY_RUNTIME.md).
+
+Unknown or unsupported pages remain invalid for *new* Ages. Their absence from a later registry does not change an already saved score. Focused GameTests cover stable/defective writing, random baseline and bright lighting, repeated identity, save round-trip, and missing-symbol/old-save behavior.

docs/INSTABILITY_STATUS_EFFECTS.md

@@ -0,0 +1,9 @@
+# Age status effects (Milestone 6, issue #67)
+
+This slice activates the Legacy potion cards selected and saved by issue #66. The user-provided Mystcraft 0.13.7.06 `EffectPotion` chooses a random living entity in a chunk section. A local card requires sky visibility; a global card does not. `EffectPotionEnemy` excludes players. Its amplifier is selected level minus one. The defaults in `InstabilityData` give blindness and nausea 60 ticks, mining fatigue/hunger/poison/slowness/weakness 80 ticks, wither 30 ticks, and enemy regeneration/resistance 200 ticks. Rivencraft preserves those durations, sky rules, and level-to-amplifier mapping, subject to the server's lower duration/level caps.
+
+General debuffs can affect survival/adventure players and other living entities, as Legacy did. The two enemy buffs affect hostile mobs only; Legacy affected any non-player living entity, so excluding passive animals is a deliberate modern adaptation. Creative and spectator players are exempt per issue #67, although the inspected Legacy potion class did not have that exemption. Existing effects from vanilla or another mod are never overwritten.
+
+The issue #66 scheduler chooses an already-loaded chunk near a player, at most the configured number of provider calls and action claims per Age run. This provider queries at most `max_candidates_per_attempt` living entities in that chunk, picks one deterministically from the bounded candidates, and claims an action before applying. It holds at most `max_active_per_age` short-lived, owned-effect leases. It neither force-loads chunks nor scans all entities or chunks. Exact target RNG therefore intentionally differs from Legacy's random chunk-section walk; the target types, local/global distinction, duration, and strength are retained.
+
+The server config can disable all status effects, player targets, general non-player targets, or hostile buffs, and can lower active leases, candidates, and duration. Leaving an Age, logging out, disabling effects, or stopping the server removes only an effect instance this provider actually installed; it will not remove a replacement from another mod. Leases also expire automatically after their short duration. The runtime never runs in the Overworld or a preview dimension. Automated tests cover mappings, target eligibility, creative/spectator exemption, and Overworld isolation. In-game multiplayer, Age-to-Age travel, and restart checks remain useful because GameTests do not create a second dynamic Age for this slice.

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, vanilla data-pack generation, and authored Floating Islands/Tendrils/Skylands/Spheres/Spikes | Compile supported vanilla placements and port bespoke shapes explicitly. Remaining bespoke structures and polish stay in later issues. |
+| 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/LEGACY_INSTABILITY_AUDIT.md

@@ -0,0 +1,64 @@
+# Mystcraft Legacy instability audit (Milestone 6, issue #63)
+
+This is a behavior contract for Milestone 6, **not a completed runtime instability system**. It compares the user-provided 0.13.7.06 class files at `/home/dnorberg/Documents/mystcraft-src/mystcraft-1.12.2-0.13.7.06/` with [Mystcraft Legacy source at commit `9bc8ddc`](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae). Values below are source defaults, not a claim that every historical config or server used them. Rivencraft 0.5.1.0 saves a provisional writing-instability score and repaired active-page order, but has no hazard loop yet.
+
+## Score, grammar, and selection in Legacy
+
+Legacy's [`AgeController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java) calculates `debug + symbol + block + book/base + bonus`, then applies difficulty 0/1/2/3 multipliers of 0.25/0.5/1/1.75. Global instability is enabled by default; an Age also has its own enable flag. The unmodified score is not simply “number of bad pages.” Block profiling may delay a usable score: `blockinstability` is null until **more than** 400 Age chunks are profiled, and `getInstabilityScore()` returns zero until then. It is recalculated after additional profiling. [`ChunkProfiler`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/profiling/ChunkProfiler.java) compares watched block abundance with a baseline, subtracting only positive excess above each baseline. The baseline is profiled or read from balance config; [`InstabilityDataCalculator`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/profiling/InstabilityDataCalculator.java) sets its default tolerance to 1.05, and default `useconfigs=false`. We should not copy its 400-chunk profiling delay or dynamic block scan into 1.21.1 without a separate performance case.
+
+| Input | Verified Legacy behavior | Rivencraft M6 interpretation |
+| --- | --- | --- |
+| Missing required controller | Terrain, biome controller, weather, and lighting are generated when missing. `InstabilityData.missing.controller = 0`; lighting explicitly adds zero. Missing pages themselves are not a penalty. | Keep Age-seeded completion. No penalty solely for an omitted branch. |
+| Repeated same symbol | `addSymbol` increments a per-`IAgeSymbol` count and adds that symbol's `instabilityModifier(count)`. This method is symbol-specific; there is no universal “duplicate = N” rule. | Distinguish legal repeated features/materials from repeated single-choice pages. Do not add a flat duplicate penalty to every occurrence. |
+| Extra/conflicting controller | Registering a second terrain, biome, weather, or lighting controller adds `InstabilityData.extra.controller = 500`; the **last registered** controller replaces the prior one. This is separate from each symbol's own modifier. | Eligible supported conflicts may become unstable rather than fatal in #65, with deterministic winner and a saved penalty. |
+| Dangling modifier | An unconsumed modifier contributes its `dangling` value; a default `Modifier` has `dangling=100`. Replacing a pending modifier charges the old one. `clearModifiers()` charges 20% (`clearPercentage=0.20`) of each pending value, with Java integer compound-assignment truncation. | Record the ordered offending page and a reason; calculate a deterministic penalty from the consumed/leftover modifier semantics, not from GUI position alone. |
+| Unsupported/unmatched page | Legacy logs unmatched symbols during reconstruction and skips their logic; its `AgeData.getBaseInstability()` still has a TODO for calculating instability from pages. This is not a sound compatibility contract. | Remains fatal for *new* books until semantic and runtime support exists; never silently erase the page or pretend its effect applied. Existing saved books retain their IDs. |
+| Other penalties/bonuses | `AgeController.addInstability(int)` is available to symbol logic. The base/book score is persisted as a `short`; Legacy's [`InstabilityBonusManager`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/bonus/InstabilityBonusManager.java) also has dynamic player death/behavior components. | Persist a versioned score breakdown for Age writing and environmental contributions. Do not infer death/troll mechanics from the mere existence of Legacy classes. |
+
+Source for controller and modifier defaults: [`InstabilityData`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java), [`AgeController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/world/AgeController.java). The local 0.13.7.06 `Modifier.class` confirms `dangling_default=100`. Legacy grammar **ranks** weight which missing symbols are selected; they are not a direct instability score or deck tier. See [grammar audit](LEGACY_AGE_GRAMMAR_AUDIT.md) and [random weights](RANDOM_AGE_WEIGHTS.md).
+
+[`InstabilityController`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityController.java) rounds its working score toward zero to the current smallest registered positive provider cost (500 by default), then rebuilds active effects when that rounded score changes. Each seeded deck preserves its saved card order; new cards are shuffled with the Age seed. For each deck it subtracts the deck entry cost, then walks cards in order, paying each provider activation cost until the next card cannot be afforded. A provider's occurrences become its level. **Deck costs are gates, not mutually exclusive severity bands**: at high score multiple decks can contribute effects. Provider `.enabled` config can remove cards. The actual effect set cannot be inferred from a score alone without the saved deck orders and enabled providers ([`Deck`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/Deck.java), [`InstabilityManager`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityManager.java)).
+
+| Legacy deck | Entry cost | Examples of registered cards |
+| --- | ---: | --- |
+| basic | 0 | enemy regeneration/resistance, fatigue, hunger, poison, slowness, weakness |
+| harsh | 2,500 | stronger/global potions, burning, lightning, wither |
+| destructive | 10,000 | crumble, explosions, lightning, meteors, wither |
+| eating | 15,000 | colored decay, blindness, nausea, wither |
+| death | 20,000 | global blindness/nausea/wither, colored decay |
+
+These entry costs are from [`InstabilityData.initialize()`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java), not guaranteed first-activation scores: each card also costs 500–5,000 depending on provider. A zero-cost basic deck still needs enough score to buy its first card. `stability.*` numbers in that file are provider activation costs, despite the misleading field name.
+
+## Effect inventory and modern policy
+
+[`InstabilityData.initialize()`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/InstabilityData.java) is the authoritative list of *registered* providers. Some implemented classes are commented out there; their existence does not mean they occur normally. Each Legacy environmental effect is called for chunks that the Age's runtime processes, often with its own chance. No per-Age global work budget is visible in these effect classes.
+
+| Family | Legacy behavior | M6 disposition |
+| --- | --- | --- |
+| Player and hostile-mob potions | Local/global blindness, fatigue, hunger, nausea, poison, slowness, weakness, wither; hostile regeneration/resistance ([`EffectPotion`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectPotion.java)). | Implement in #67 with server-only, Age-scoped entity targeting and rate limits. No effects in preview/snapshot worlds. |
+| Colored decay | Blue, purple, red, white providers place advancing decay and extra-tick it; black provider is commented out. Decay handlers differ in spread/consumption ([providers](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/providers), [handlers](https://github.com/Mystcraft/Mystcraft-Legacy/tree/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/instability/decay)). | Implement bounded, reversible-by-admin world mutation in #68; exact 1.12 spread/update rates require adaptation and tests. Exclude protected spawn/portal areas. Black/green/yellow are **not** proven active Legacy providers. |
+| Lightning and explosions | Random per-chunk strike/explosion attempts ([`EffectLightning`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectLightning.java), [`EffectExplosions`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectExplosions.java)). | Implement in #69 with explicit block-damage and fire policy; no effect outside the Age. |
+| Meteor, scorching | Meteor entity spawn and sky-exposed entity ignition ([`EffectMeteor`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectMeteor.java), [`EffectScorched`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectScorched.java)). | #70: modern meteor entity/impact needs an explicit damage budget; scorching can use modern fire/damage checks. Legacy `meteor/roar.ogg` is available. |
+| Crumble and erosion | Crumble maps blocks to weaker states; erosion spreads adjacent fluids and has extra lake-generation methods ([`EffectCrumble`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectCrumble.java), [`EffectErosion`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectErosion.java)). | #70: bounded block palette and protected-area checks. Erosion's provider is commented out in Legacy registration: treat it as deliberate opt-in adaptation, not baseline parity. |
+| Extra ticks | Registered alongside blue/purple/red/white decay, targeting decay blocks ([`EffectExtraTicks`](https://github.com/Mystcraft/Mystcraft-Legacy/blob/9bc8ddc061845df0cd5ea47f4fdef773cff786ae/src/main/java/com/xcompwiz/mystcraft/effects/EffectExtraTicks.java)). | Implement only as a bounded decay helper in #68; do not accelerate arbitrary blocks/block entities. |
+| Other dormant code | Black decay, global burning, bedrock crumble, erosion provider are commented out. | Defer unless a later issue explicitly requests them. An authored symbol requiring one must fail clearly until supported. |
+
+Assets in the supplied local tree: `assets/mystcraft/textures/blocks/decay_{black,blue,green,purple,red,white,yellow}.png`, corresponding decay block/item model JSON, and `assets/mystcraft/sounds/entity/meteor/roar.ogg`. Before importing, review attribution/license and fit modern 16×16 assets. Texture availability does not make an effect active. Use current Minecraft effects/sounds where adaptation is cleaner; no new artwork is needed for this audit.
+
+## Rivencraft boundary and proposed safety contract
+
+[`WritingGrammar`](../src/main/java/net/dnorberg/rivencraft/writing/WritingGrammar.java) classifies `INCOMPLETE` as seeded completion and supported writing defects as accepted instability. `AgeGenerationPlan.compile()` freezes the original writing, repaired active-page indexes, and a provisional writing-instability score before world generation. #64 now persists a versioned score breakdown; saved provider/deck choice remains future work. The plan must not mutate an already-created Age when a data pack changes. Server-side settings may disable execution, but should not rewrite the saved authored score.
+
+For #65, **eligible-to-become-unstable** means a known, supported page whose semantics and resulting world are still deterministic: repeated/conflicting single-choice pages and otherwise valid out-of-order or misplaced pages. The implementation retains every original page, uses the last single-choice page, sorts active categories, and saves 500 per extra/conflicting choice or 100 per misplaced page. These are provisional Rivencraft values, not a full port of every `IAgeSymbol.instabilityModifier`. Missing branches are explicitly classified as zero-cost seeded completion; legal repeated feature/material pages are not automatically errors. **Remain fatal**: missing/duplicate/misordered Link Panel, over-capacity book, unresolved or schema-v1 display-only symbol, unsupported weather/angle/runtime profile/biome/feature, unavailable required optional mod, and any combination the compiler cannot represent safely. Binder and unbound-book previews distinguish blocked writing, seeded completion, and accepted instability before binding; the server revalidates on output. This intentionally differs from Legacy's silent unmatched-symbol skip, universal controller cost assumptions, and modifier-specific dangling costs. A full symbol-specific Legacy penalty port remains a separate balance task, not a claim of parity in this slice.
+
+Automated #65 checks cover classification, preserved input slots on rejection, and an accepted unstable preview. The live output/one-time Age creation check is assigned to in-game testing because the GameTest storage phase stalled when that transaction ran; the test world is not retained.
+
+Issue #66 establishes a server-only scheduler with bounded per-Age actions, provider calls, levels, cooldowns, loaded-chunk candidates, and rotating active-Age admission. World-mutating handlers are **off by default**. No provider effects are registered yet; #67–#70 must enforce protected spawn/link platforms, portals, and provider-specific damage/spread limits before activation. These are **Rivencraft safety adaptations**, not Legacy defaults. Expose score breakdown, selected effects, enablement, and budget suppression in server diagnostics (#72). See [runtime policy](INSTABILITY_RUNTIME.md).
+
+M6 owns scoring, selection, effects, controls, and regression. M7 still owns portal/transport and broader polish; M6 must not depend on new M7 structures. An illegal biome/terrain combination that is presently unrepresentable remains a generation failure until a separate, safe compiler path exists; instability must not be used to disguise absent worldgen support. Existing pre-release saves need explicit migration behavior in #73 rather than a silent rescore.
+
+## Verification and open questions
+
+- Inspected pinned source for `AgeController`, `AgeData`, `GrammarTree`, `InstabilityData`, `InstabilityManager`, `InstabilityController`, `Deck`, all active provider families, effect classes, `ChunkProfiler`, and `InstabilityDataCalculator`; checked matching local 0.13.7.06 class names and `Modifier.dangling_default` with `javap`.
+- The supplied extraction has no generated user balance config; registered defaults can be overridden or providers disabled. There is no single universal instability value for “wrong order” or “duplicate page.” `IAgeSymbol.instabilityModifier(count)` implementations and runtime configs determine the final Legacy value.
+- Exact Legacy visual/decay behavior, dynamic bonus registration, and full 1.12 block-baseline parity need focused checks when their slices are implemented. Do not label proposed modern caps as source facts.

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,14 +34,17 @@ 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.
+6. **Instability** — deterministic validation and server-safe effects. Start with the
+   [Legacy instability audit](LEGACY_INSTABILITY_AUDIT.md), which separates
+   source behavior from proposed 1.21.1 safety limits.
 7. **Structures and polish** — libraries, crystals, portals, recipes, models,
    sounds, advancements, compatibility, and migration tests.
 
@@ -61,17 +64,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_DATA.md

@@ -87,10 +87,10 @@ placement. The surface draws the native 30×40 portrait page region from
 Legacy's book UI atlas; symbols are layered at a uniform scale, while the
 square item models remain unchanged in inventories.
 
-A Notebook holds 27 ordered positions. Its pages, names, gaps, and unresolved
+A Notebook holds 252 ordered positions. Its pages, names, gaps, and unresolved
 IDs are saved on the item, so moving the Notebook between an inventory, Desk,
 and Binder does not rearrange them. A loose Page in a Desk tab exposes just one
-position; a Notebook exposes all 27. The Desk has 88 persistent collection
+position; a Notebook exposes all 252. The Desk has 88 persistent collection
 tabs, shown four at a time. Use the up/down tab controls to move by four, put
 paper and Ink Vials in their input slots, select a stored page, and take the
 copy from the virtual output. Taking it spends one paper and the configured
@@ -100,7 +100,7 @@ copying. Moving a page within the Desk or dragging it into the inventory removes
 the original only when the destination accepts it.
 
 The Book Binder takes a leather or empty-Notebook cover, an Age title, one Link
-Panel, and optionally up to 27 ordered written Pages. A filled Notebook can be
+Panel, and optionally up to 252 ordered written Pages. A filled Notebook can be
 imported at a chosen strip position; the empty Notebook remains recoverable.
 The preview result is virtual. Taking the completed Descriptive Book commits the
 inputs once, creates its Age identity, and saves schema-versioned

docs/WRITING_GRAMMAR.md

@@ -2,20 +2,24 @@
 
 `WritingGrammar` interprets the saved `OrderedWriting` on the server using only `SymbolCatalog`'s schema-v2 semantics. Client display metadata, page names, and supplied translations never determine an Age's meaning. The parser is pure: it returns immutable parsed entries and indexed diagnostics without changing a book or its pages.
 
-New Binder writing has at most one Link Panel plus 27 symbol pages. The Link Panel must be first. A Link-Panel-only book, or an older book with no writing component, keeps the existing random Age path. Any authored supported symbol makes the book a partial or complete grammar. From 0.4.3.0, the server compiles it into a persistent Age plan before consuming Binder inputs or generating chunks.
+New Binder writing has at most one Link Panel plus 252 symbol pages (the current fixed-slot save-format ceiling, not a Legacy gameplay limit). 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 consumes one; Tiled/Grid and Tiny–Huge require two, with seeded filler when pages are missing. From 0.5.1.0, known misplaced or repeated pages no longer block creation: the book keeps its original order, while the server repairs category order, uses the last single-choice controller, and stores a writing-instability score in the Age plan. A conflicting/repeated choice adds 500; an out-of-order page or misplaced modifier adds 100. Native ignores surplus authored biome pages and Single uses the first, with the conflict recorded as instability. These are Rivencraft's provisional penalties, not a claim of exact Legacy values for every symbol. Incorrectly placed pages are **not** red-highlighted; their warning remains available as a tooltip. Unknown IDs, schema-v1 display-only symbols, unavailable dependencies/profiles, unsupported semantic effects or feature/material pairs, missing/extra Link Panels, and oversized writing still reject a new Age. The Binder disables output for those fatal errors and shows a red page indication where applicable. Rejected inputs remain removable.
 
-The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the Age seed, and a copy of the selected runtime profile. An explicit terrain page overrides random terrain selection; an omitted terrain uses a seed-selected compatible profile. The built-in Standard, Amplified, Cave, Island, Flat, and Void terrain pages select their matching generation resources. Age loading uses the frozen runtime profile and does not need the original symbol definition or runtime-profile JSON, though its referenced noise, biome-preset, and dimension-type registry entries must remain available. Existing bound books without plans are not reinterpreted. Page-free and Link-Panel-only books keep the pre-existing random path. Biome and environment pages affect new Ages, and the supported feature subset below is compiled into the same frozen plan; instability remains Milestone 6 work.
+The plan stores the original writing order, the authoritative semantic value of each resolved symbol, the active repaired-page indexes, the writing-instability score, 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. Runtime effects for a nonzero writing-instability score are not implemented yet.
 
 ## Supported feature pages (issue #35)
 
 Feature pages come after the celestial section. Their order is retained in the plan and in decoration placement. The Caves page adds a second, Age-seeded vanilla cave-carving pass to Noise terrain, including Standard, Amplified, Island, and Cave terrain. It chooses the vanilla Overworld or Nether cave carver from the source biome. This is separate from the Milestone 7 issue about Cave **terrain** generation. Flat and Void terrain have no suitable solid noise body and reject Caves with a binder diagnostic.
 
-Flowers, Trees, Huge Trees, Rocks, Surface Lakes, Deep Lakes, and Small Lakes add vanilla placed features after normal biome decoration. Huge Trees currently use vanilla old-growth spruce placement as a modern approximation of Legacy's huge-tree page; it is not the custom Legacy tree generator. Without a preceding material page, Rocks select a valid solid block and each lake page selects a valid source-fluid block from the registered pool. The selection is deterministic for an Age seed and feature ID, so all chunks in that Age use the same material across restarts with the same block registry. The page-specific feature preserves vanilla placement rules other than the biome-list filter, since an authored page deliberately adds it to the Age. Surface and Small Lakes use a more visible one-in-twelve-chunks attempt rate instead of vanilla lava lakes' one-in-two-hundred; Deep Lakes retain their underground placement. Vanilla biome lava lakes are separate and can still appear alongside authored fluid lakes. These decorations require surface Noise terrain; Cave, Flat, and Void reject them. Flowers and both tree pages require at least one surface Overworld biome and only run in compatible chunks; Nether, End, and tagged cave biomes do not receive surface vegetation. Ravines add a separate Age-seeded vanilla canyon-carving pass to Noise terrain. Unsupported feature IDs and missing vanilla registry entries produce diagnostics instead of becoming no-ops.
+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.
 
-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.
+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. Registry-derived biome pages share a creative/JEI feed; `terrablender:deferred_placeholder` is excluded because it is TerraBlender's internal staging biome, not a player-facing biome choice. Other modded biomes remain listed. 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.14.0
+mod_version=0.5.6.4
 immersive_portals_version=6.0.7
 terrablender_version=4.1.0.8
 serene_seasons_version_id=B6nTjh4b

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

@@ -21,6 +21,9 @@ import net.dnorberg.rivencraft.config.RivencraftClientConfig;
 import net.dnorberg.rivencraft.compat.SereneSeasonsCompatibility;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeWeatherService;
+import net.dnorberg.rivencraft.book.AgeInstabilityRuntime;
+import net.dnorberg.rivencraft.book.AgeStatusEffectProviders;
+import net.dnorberg.rivencraft.book.AgeDecayProviders;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.neoforged.bus.api.IEventBus;
@@ -37,6 +40,8 @@ public final class Rivencraft {
 
     public Rivencraft(IEventBus modEventBus, ModContainer modContainer) {
         AgeDimensionService.register();
+        AgeStatusEffectProviders.register();
+        AgeDecayProviders.register();
         modContainer.registerConfig(ModConfig.Type.SERVER, RivencraftConfig.SPEC);
         modContainer.registerConfig(ModConfig.Type.CLIENT, RivencraftClientConfig.SPEC);
         modEventBus.addListener(ModNetworking::register);
@@ -52,11 +57,18 @@ public final class Rivencraft {
         ModCreativeTabs.register(modEventBus);
         NeoForge.EVENT_BUS.addListener(BookStandConversionHandler::onRightClickBlock);
         NeoForge.EVENT_BUS.addListener(AgeWeatherService::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeInstabilityRuntime::onLevelTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onServerTickPost);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onEntityTravel);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onPlayerChangedDimension);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onPlayerLoggedOut);
         NeoForge.EVENT_BUS.addListener(SereneSeasonsCompatibility::onLevelTickPost);
         NeoForge.EVENT_BUS.addListener(AgeCelestialAngleSync::onPlayerLoggedIn);
         NeoForge.EVENT_BUS.addListener(AgeCelestialAngleSync::onPlayerChangedDimension);
         NeoForge.EVENT_BUS.addListener(AgeLifecycleEvents::onPlayerLoggedOut);
         NeoForge.EVENT_BUS.addListener(AgeLifecycleEvents::onServerStopping);
+        NeoForge.EVENT_BUS.addListener(AgeInstabilityRuntime::onServerStopping);
+        NeoForge.EVENT_BUS.addListener(AgeStatusEffectProviders::onServerStopping);
         NeoForge.EVENT_BUS.addListener(RivencraftCommands::register);
         NeoForge.EVENT_BUS.addListener(AgeRuntimeProfiles::register);
         NeoForge.EVENT_BUS.addListener(SymbolCatalog::register);

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/CloudPlatformBlock.java

@@ -0,0 +1,36 @@
+package net.dnorberg.rivencraft.block;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.level.BlockGetter;
+import net.minecraft.world.level.LevelReader;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+
+/** Solid footing for Age arrivals, rendered as a translucent cloud. */
+public final class CloudPlatformBlock extends Block {
+    public CloudPlatformBlock(Properties properties) {
+        super(properties);
+    }
+
+    @Override
+    public ItemStack getCloneItemStack(LevelReader level, BlockPos pos, BlockState state) {
+        return ItemStack.EMPTY;
+    }
+
+    @Override
+    protected boolean skipRendering(BlockState state, BlockState adjacent, Direction side) {
+        return adjacent.is(this) || super.skipRendering(state, adjacent, side);
+    }
+
+    @Override
+    protected boolean propagatesSkylightDown(BlockState state, BlockGetter level, BlockPos pos) {
+        return true;
+    }
+
+    @Override
+    protected int getLightBlock(BlockState state, BlockGetter level, BlockPos pos) {
+        return 0;
+    }
+}

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

@@ -0,0 +1,46 @@
+package net.dnorberg.rivencraft.block;
+
+import net.dnorberg.rivencraft.book.AgeInstabilityRuntime;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.util.StringRepresentable;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.level.Level;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.block.state.StateDefinition;
+import net.minecraft.world.level.block.state.properties.EnumProperty;
+
+/** The four colored decay variants selected by the current instability deck. */
+public final class DecayBlock extends Block {
+    public static final EnumProperty<Color> COLOR = EnumProperty.create("color", Color.class);
+
+    public DecayBlock(Properties properties) {
+        super(properties);
+        registerDefaultState(stateDefinition.any().setValue(COLOR, Color.BLUE));
+    }
+
+    @Override
+    protected void createBlockStateDefinition(StateDefinition.Builder<Block, BlockState> builder) {
+        builder.add(COLOR);
+    }
+
+    @Override
+    public void stepOn(Level level, BlockPos pos, BlockState state, Entity entity) {
+        if (!level.isClientSide && state.getValue(COLOR) == Color.WHITE
+                && RivencraftConfig.decayEnabled() && RivencraftConfig.instabilityWorldMutation()
+                && AgeInstabilityRuntime.isAgeDimension(level.dimension().location())) {
+            entity.hurt(level.damageSources().magic(), 1.0F);
+        }
+        super.stepOn(level, pos, state, entity);
+    }
+
+    public enum Color implements StringRepresentable {
+        BLUE, PURPLE, RED, WHITE;
+
+        @Override
+        public String getSerializedName() {
+            return name().toLowerCase(java.util.Locale.ROOT);
+        }
+    }
+}

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

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

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

@@ -5,7 +5,6 @@ import java.util.List;
 import java.util.UUID;
 import net.dnorberg.rivencraft.book.AgeReference;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
-import net.dnorberg.rivencraft.book.AgeGenerationPlan;
 import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
 import net.dnorberg.rivencraft.book.AgeRuntimeProfiles;
 import net.dnorberg.rivencraft.item.PageItem;
@@ -117,19 +116,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             if (!page.isEmpty() && (!validPage(page) || !PageItem.isUsableWriting(page) || page.getCount() != 1
                     || PageItem.content(page).kind() == PageContent.Kind.BLANK)) return false;
         }
-        OrderedWriting writing = currentWriting();
-        if (!writingGrammar().canCreate()) return false;
-        try {
-            if (level instanceof ServerLevel serverLevel) {
-                AgeRegistrySavedData.validateNewWriting(serverLevel, title, writing);
-            } else {
-                AgeGenerationPlan.compile(writing, 0L, AgeGenerationProfiles.STANDARD,
-                        net.dnorberg.rivencraft.book.AgeTraits.select(0L), level.registryAccess());
-            }
-            return true;
-        } catch (IllegalArgumentException exception) {
-            return false;
-        }
+        return writingGrammar().canCreate();
     }
 
     public WritingGrammar.Result writingGrammar() {
@@ -138,7 +125,7 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
         List<WritingGrammar.Diagnostic> diagnostics = new ArrayList<>(parsed.diagnostics());
         var terrain = parsed.symbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
-                .findFirst();
+                .reduce((first, last) -> last);
         if (terrain.isPresent()) {
             var profileId = ((SymbolSemantics.ResourceValue) terrain.orElseThrow().semantics().value()).id();
             if (!AgeRuntimeProfiles.profiles().containsKey(profileId)) {
@@ -181,18 +168,21 @@ public final class BookBinderBlockEntity extends BlockEntity implements Containe
             // check. This also pinpoints biome-pool conflicts that cannot be inferred from
             // an individual feature page alone (for example Trees with only Nether biomes).
             if (level instanceof ServerLevel serverLevel && diagnostics.stream().noneMatch(
-                    diagnostic -> diagnostic.code() == WritingGrammar.Code.UNSUPPORTED_FEATURE)) {
+                    WritingGrammar.Diagnostic::error)) {
                 try {
                     AgeRegistrySavedData.validateNewWriting(serverLevel, title, currentWriting());
                 } catch (IllegalArgumentException exception) {
-                    if (exception.getMessage() != null && (exception.getMessage().startsWith("Feature ")
-                            || exception.getMessage().startsWith("Caves "))) {
-                        parsed.symbols().stream().filter(symbol -> symbol.semantics().role()
-                                        == SymbolSemantics.Role.FEATURE).findFirst().ifPresent(symbol ->
-                                diagnostics.add(new WritingGrammar.Diagnostic(
-                                        WritingGrammar.Code.UNSUPPORTED_FEATURE, symbol.index(),
-                                        exception.getMessage())));
-                    }
+                    boolean feature = exception.getMessage() != null
+                            && (exception.getMessage().startsWith("Feature ")
+                            || exception.getMessage().startsWith("Caves "));
+                    int index = feature ? parsed.symbols().stream()
+                            .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
+                            .mapToInt(WritingGrammar.ParsedSymbol::index).findFirst().orElse(-1) : -1;
+                    diagnostics.add(new WritingGrammar.Diagnostic(
+                            feature ? WritingGrammar.Code.UNSUPPORTED_FEATURE
+                                    : WritingGrammar.Code.UNSUPPORTED_COMBINATION,
+                            index, exception.getMessage() == null ? "The Age compiler rejected this writing"
+                                    : exception.getMessage()));
                 }
             }
         }

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

@@ -80,13 +80,13 @@ 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++;
         }
         // An authored Void Age must not acquire The Void as an unrequested second biome.
         List<ResourceLocation> filler = profile.terrain() == AgeRuntimeProfile.Terrain.VOID && !authored.isEmpty()

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

@@ -0,0 +1,87 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class AgeDecayGameTests {
+    private AgeDecayGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void frontierRoundTripsWithoutDuplicates(GameTestHelper helper) {
+        AgeDecaySavedData data = new AgeDecaySavedData();
+        BlockPos first = new BlockPos(3, 70, 5);
+        data.add(DecayBlock.Color.BLUE, first);
+        data.add(DecayBlock.Color.BLUE, first);
+        data.add(DecayBlock.Color.WHITE, new BlockPos(-4, 64, 9));
+        helper.assertValueEqual(data.frontier(DecayBlock.Color.BLUE).size(), 1,
+                "One frontier block must not be stored twice");
+        helper.assertValueEqual(data.nextAttempt(), 0L, "First attempt starts at zero");
+        AgeDecaySavedData restored = AgeDecaySavedData.load(
+                data.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.nextAttempt(), 1L, "Attempt sequence survives reload");
+        helper.assertValueEqual(restored.frontier(DecayBlock.Color.BLUE).getFirst(), first,
+                "Blue frontier survives reload");
+        helper.assertValueEqual(restored.frontier(DecayBlock.Color.WHITE).size(), 1,
+                "White frontier survives reload independently");
+        restored.remove(DecayBlock.Color.BLUE, first);
+        helper.assertTrue(restored.frontier(DecayBlock.Color.BLUE).isEmpty(),
+                "Removed frontier is not scheduled for further spread");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void targetMustRemainInChosenLoadedChunk(GameTestHelper helper) {
+        BlockPos center = helper.absolutePos(new BlockPos(1, 1, 1));
+        ChunkPos chunk = new ChunkPos(center);
+        helper.assertTrue(AgeDecayProviders.isLoadedTarget(helper.getLevel(), List.of(chunk), center),
+                "An already-loaded target inside the selected chunk is eligible");
+        BlockPos outside = new BlockPos((chunk.x + 1) << 4, center.getY(), center.getZ());
+        helper.assertTrue(!AgeDecayProviders.isLoadedTarget(helper.getLevel(), List.of(chunk), outside),
+                "Spread cannot cross into a chunk absent from this Age run");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void overworldCannotRunDecayProvider(GameTestHelper helper) {
+        UUID ageId = UUID.randomUUID();
+        AgeDefinition age = new AgeDefinition(ageId, "Decay isolation", 100L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(ageId), null,
+                AgeTraits.LEGACY_DEFAULTS);
+        AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(1);
+        var context = new AgeInstabilityRuntime.Context(helper.getLevel(), age,
+                List.of(new ChunkPos(helper.absolutePos(new BlockPos(1, 1, 1)))),
+                helper.getLevel().getServer().getTickCount(), budget);
+        AgeDecayProviders.apply(context, ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "decayblue"), 1);
+        helper.assertValueEqual(budget.remaining(), 1, "Overworld decay cannot claim an Age action");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void savedSpawnAndPlatformAreProtected(GameTestHelper helper) {
+        UUID ageId = UUID.randomUUID();
+        BlockPos spawn = new BlockPos(0, 65, 0);
+        AgeDefinition age = new AgeDefinition(ageId, "Protected arrival", 100L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(ageId), spawn,
+                AgeTraits.LEGACY_DEFAULTS);
+        helper.assertTrue(AgeDecayProviders.isSpawnProtected(age, spawn.below().offset(2, 0, 2)),
+                "Arrival platform must not decay");
+        helper.assertTrue(AgeDecayProviders.isSpawnProtected(age, spawn.offset(4, 0, 4)),
+                "The protective margin must not decay");
+        helper.assertTrue(!AgeDecayProviders.isSpawnProtected(age, spawn.offset(5, 0, 0)),
+                "Spawn protection is bounded");
+        helper.succeed();
+    }
+}

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

@@ -0,0 +1,202 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.tags.BlockTags;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.levelgen.Heightmap;
+import net.neoforged.neoforge.common.NeoForge;
+import net.neoforged.neoforge.common.util.BlockSnapshot;
+import net.neoforged.neoforge.common.util.FakePlayerFactory;
+import net.neoforged.neoforge.event.level.BlockEvent;
+
+/** Bounded, per-Age decay seeding and six-direction Legacy-style spreading. */
+public final class AgeDecayProviders {
+    public static final TagKey<Block> PROTECTED = TagKey.create(Registries.BLOCK,
+            ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "decay_protected"));
+    private static final Map<ResourceLocation, DecayBlock.Color> COLORS = Map.of(
+            id("decayblue"), DecayBlock.Color.BLUE,
+            id("decaypurple"), DecayBlock.Color.PURPLE,
+            id("decayred"), DecayBlock.Color.RED,
+            id("decaywhite"), DecayBlock.Color.WHITE);
+    private static final Direction[] DIRECTIONS = Direction.values();
+
+    private AgeDecayProviders() {}
+
+    public static void register() {
+        COLORS.keySet().forEach(id -> AgeInstabilityRuntime.register(id, true, AgeDecayProviders::apply));
+    }
+
+    /** Operator test hook; never changes the Age's saved instability score or provider plan. */
+    public static int pulseForTesting(ServerPlayer player, DecayBlock.Color color, int count) {
+        ServerLevel level = player.serverLevel();
+        if (!RivencraftConfig.decayEnabled() || !RivencraftConfig.instabilityWorldMutation()
+                || !AgeInstabilityRuntime.isAgeDimension(level.dimension().location())
+                || !level.getChunkSource().hasChunk(player.chunkPosition().x, player.chunkPosition().z)) return -1;
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null) return -1;
+        ResourceLocation id = id("decay" + color.getSerializedName());
+        int changed = 0;
+        for (int i = 0; i < Math.min(count, 32); i++) {
+            AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(1);
+            apply(new AgeInstabilityRuntime.Context(level, age, List.of(player.chunkPosition()),
+                    level.getServer().getTickCount(), budget), id, 1);
+            changed += 1 - budget.remaining();
+        }
+        return changed;
+    }
+
+    static void apply(AgeInstabilityRuntime.Context context, ResourceLocation id, int level) {
+        if (!RivencraftConfig.decayEnabled() || !RivencraftConfig.instabilityWorldMutation()
+                || !AgeInstabilityRuntime.isAgeDimension(context.level().dimension().location())
+                || !context.age().dimensionId().equals(context.level().dimension().location())
+                || context.loadedChunks().isEmpty()) return;
+        DecayBlock.Color color = COLORS.get(id);
+        if (color == null) return;
+        AgeDecaySavedData data = AgeDecaySavedData.get(context.level());
+        Random random = new Random(context.age().seed() ^ data.nextAttempt() * 0x9E3779B97F4A7C15L
+                ^ id.hashCode());
+        List<BlockPos> frontier = data.frontier(color);
+        BlockPos source = selectLoadedSource(context.level(), context.loadedChunks(), frontier, random);
+        if (source == null) {
+            seed(context, color, data, random);
+            return;
+        }
+        BlockState sourceState = context.level().getBlockState(source);
+        if (!sourceState.is(ModBlocks.DECAY.get()) || sourceState.getValue(DecayBlock.COLOR) != color) {
+            data.remove(color, source);
+            return;
+        }
+        for (int attempt = 0; attempt < RivencraftConfig.decayMaxAttempts(); attempt++) {
+            BlockPos target = source.relative(DIRECTIONS[random.nextInt(DIRECTIONS.length)]);
+            if (!isLoadedTarget(context.level(), context.loadedChunks(), target)
+                    || isSpawnProtected(context.age(), target)) continue;
+            BlockState prior = context.level().getBlockState(target);
+            if (!canReplace(context.level(), target, prior, color)) continue;
+            int difficulty = conversionDifficulty(context.level(), target, prior, color);
+            if (random.nextInt(difficulty) != 0) continue;
+            if (replace(context, target, prior, color)) data.add(color, target);
+            return;
+        }
+    }
+
+    private static void seed(AgeInstabilityRuntime.Context context, DecayBlock.Color color,
+                             AgeDecaySavedData data, Random random) {
+        ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+        int x = chunk.getMinBlockX() + random.nextInt(16);
+        int z = chunk.getMinBlockZ() + random.nextInt(16);
+        BlockPos pos = new BlockPos(x,
+                context.level().getHeight(Heightmap.Types.MOTION_BLOCKING_NO_LEAVES, x, z) - 1, z);
+        if (!isLoadedTarget(context.level(), context.loadedChunks(), pos)
+                || isSpawnProtected(context.age(), pos)) return;
+        BlockState prior = context.level().getBlockState(pos);
+        if (canReplace(context.level(), pos, prior, color) && replace(context, pos, prior, color)) {
+            data.add(color, pos);
+        }
+    }
+
+    private static BlockPos selectLoadedSource(ServerLevel level, List<ChunkPos> chunks,
+                                                List<BlockPos> frontier, Random random) {
+        if (frontier.isEmpty()) return null;
+        int start = random.nextInt(frontier.size());
+        for (int i = 0; i < Math.min(frontier.size(), 16); i++) {
+            BlockPos pos = frontier.get((start + i) % frontier.size());
+            if (isLoadedTarget(level, chunks, pos)) return pos;
+        }
+        return null;
+    }
+
+    static boolean isLoadedTarget(ServerLevel level, List<ChunkPos> chunks, BlockPos pos) {
+        return level.isInWorldBounds(pos) && level.getChunkSource().hasChunk(pos.getX() >> 4, pos.getZ() >> 4)
+                && chunks.contains(new ChunkPos(pos));
+    }
+
+    static boolean isSpawnProtected(AgeDefinition age, BlockPos pos) {
+        BlockPos spawn = age.spawn();
+        return spawn != null && Math.abs(pos.getX() - spawn.getX()) <= 4
+                && Math.abs(pos.getZ() - spawn.getZ()) <= 4
+                && pos.getY() >= spawn.getY() - 2 && pos.getY() <= spawn.getY() + 4;
+    }
+
+    static boolean canReplace(ServerLevel level, BlockPos pos, BlockState prior, DecayBlock.Color color) {
+        if (!AgeInstabilityRuntime.isAgeDimension(level.dimension().location())
+                || !level.isInWorldBounds(pos) || !level.getChunkSource().hasChunk(pos.getX() >> 4, pos.getZ() >> 4)
+                || prior.is(PROTECTED) || prior.is(BlockTags.PORTALS)
+                || prior.hasBlockEntity() || level.getBlockEntity(pos) != null
+                || prior.getDestroySpeed(level, pos) < 0 || !prior.getFluidState().isEmpty()
+                || isCritical(prior)) return false;
+        return !prior.is(ModBlocks.DECAY.get()) || prior.getValue(DecayBlock.COLOR) != color;
+    }
+
+    private static boolean isCritical(BlockState prior) {
+        return prior.is(Blocks.BEDROCK) || prior.is(Blocks.BARRIER)
+                || prior.is(Blocks.END_PORTAL) || prior.is(Blocks.END_PORTAL_FRAME)
+                || prior.is(Blocks.END_GATEWAY) || prior.is(Blocks.NETHER_PORTAL)
+                || prior.is(Blocks.COMMAND_BLOCK) || prior.is(Blocks.CHAIN_COMMAND_BLOCK)
+                || prior.is(Blocks.REPEATING_COMMAND_BLOCK) || prior.is(Blocks.STRUCTURE_BLOCK)
+                || prior.is(Blocks.JIGSAW) || prior.is(Blocks.LIGHT)
+                || prior.is(Blocks.REINFORCED_DEEPSLATE)
+                || prior.getBlock() != ModBlocks.DECAY.get()
+                && net.minecraft.core.registries.BuiltInRegistries.BLOCK.getKey(prior.getBlock())
+                        .getNamespace().equals(Rivencraft.MOD_ID);
+    }
+
+    static int conversionDifficulty(ServerLevel level, BlockPos pos, BlockState state, DecayBlock.Color color) {
+        if (state.isAir()) return switch (color) {
+            case BLUE, RED -> 20;
+            case PURPLE -> 8;
+            case WHITE -> 50;
+        };
+        if (state.is(ModBlocks.DECAY.get())) return color == DecayBlock.Color.WHITE ? 1 : 5;
+        float hardness = Math.min(1000.0F, Math.max(0.0F, state.getDestroySpeed(level, pos)));
+        return switch (color) {
+            case BLUE -> Math.max(1, (int) hardness * 2);
+            case RED -> Math.max(1, (int) hardness);
+            case PURPLE -> Math.max(1, ((int) hardness + 1) * 10);
+            case WHITE -> 1;
+        };
+    }
+
+    private static boolean replace(AgeInstabilityRuntime.Context context, BlockPos pos, BlockState prior,
+                                   DecayBlock.Color color) {
+        ServerLevel level = context.level();
+        // A fake player gives claim/protection listeners the Age and exact block position.
+        var actor = FakePlayerFactory.getMinecraft(level);
+        actor.setPos(pos.getX() + 0.5, pos.getY() + 0.5, pos.getZ() + 0.5);
+        if (!prior.isAir()) {
+            var breakEvent = new BlockEvent.BreakEvent(level, pos, prior, actor);
+            NeoForge.EVENT_BUS.post(breakEvent);
+            if (breakEvent.isCanceled()) return false;
+        }
+        if (level.getBlockState(pos) != prior || !context.budget().claim()) return false;
+        var snapshot = BlockSnapshot.create(level.dimension(), level, pos);
+        BlockState decay = ModBlocks.DECAY.get().defaultBlockState().setValue(DecayBlock.COLOR, color);
+        if (!level.setBlock(pos, decay, 3)) return false;
+        var placeEvent = new BlockEvent.EntityPlaceEvent(snapshot, prior, actor);
+        NeoForge.EVENT_BUS.post(placeEvent);
+        if (placeEvent.isCanceled()) {
+            snapshot.restore();
+            return false;
+        }
+        return true;
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+}

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

@@ -0,0 +1,81 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.List;
+import net.dnorberg.rivencraft.block.DecayBlock;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.HolderLookup;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.util.datafix.DataFixTypes;
+import net.minecraft.world.level.saveddata.SavedData;
+
+/** Small, per-Age frontier and deterministic attempt counter; never stores chunk references. */
+public final class AgeDecaySavedData extends SavedData {
+    private static final int MAX_FRONTIER_PER_COLOR = 1024;
+    private static final Factory<AgeDecaySavedData> FACTORY = new Factory<>(AgeDecaySavedData::new,
+            AgeDecaySavedData::load, DataFixTypes.SAVED_DATA_MAP_DATA);
+    private final EnumMap<DecayBlock.Color, List<BlockPos>> frontiers = new EnumMap<>(DecayBlock.Color.class);
+    private long attempts;
+
+    public AgeDecaySavedData() {
+        for (DecayBlock.Color color : DecayBlock.Color.values()) frontiers.put(color, new ArrayList<>());
+    }
+
+    public static AgeDecaySavedData get(ServerLevel level) {
+        return level.getDataStorage().computeIfAbsent(FACTORY, "rivencraft_decay");
+    }
+
+    public long nextAttempt() {
+        setDirty();
+        return attempts++;
+    }
+
+    public List<BlockPos> frontier(DecayBlock.Color color) {
+        return frontiers.get(color);
+    }
+
+    public void add(DecayBlock.Color color, BlockPos pos) {
+        List<BlockPos> frontier = frontiers.get(color);
+        if (frontier.contains(pos)) return;
+        if (frontier.size() >= MAX_FRONTIER_PER_COLOR) frontier.remove(0);
+        frontier.add(pos.immutable());
+        setDirty();
+    }
+
+    public void remove(DecayBlock.Color color, BlockPos pos) {
+        if (frontiers.get(color).remove(pos)) setDirty();
+    }
+
+    @Override
+    public CompoundTag save(CompoundTag tag, HolderLookup.Provider registries) {
+        tag.putLong("Attempts", attempts);
+        for (DecayBlock.Color color : DecayBlock.Color.values()) {
+            ListTag positions = new ListTag();
+            for (BlockPos pos : frontiers.get(color)) {
+                CompoundTag entry = new CompoundTag();
+                entry.putInt("X", pos.getX());
+                entry.putInt("Y", pos.getY());
+                entry.putInt("Z", pos.getZ());
+                positions.add(entry);
+            }
+            tag.put(color.getSerializedName(), positions);
+        }
+        return tag;
+    }
+
+    static AgeDecaySavedData load(CompoundTag tag, HolderLookup.Provider registries) {
+        AgeDecaySavedData data = new AgeDecaySavedData();
+        data.attempts = Math.max(0L, tag.getLong("Attempts"));
+        for (DecayBlock.Color color : DecayBlock.Color.values()) {
+            ListTag positions = tag.getList(color.getSerializedName(), CompoundTag.TAG_COMPOUND);
+            for (int index = 0; index < Math.min(positions.size(), MAX_FRONTIER_PER_COLOR); index++) {
+                CompoundTag entry = positions.getCompound(index);
+                data.frontiers.get(color).add(new BlockPos(entry.getInt("X"), entry.getInt("Y"), entry.getInt("Z")));
+            }
+        }
+        return data;
+    }
+}

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

@@ -21,7 +21,9 @@ public record AgeDefinition(
         AgeTraits traits,
         AgeGenerationPlan plan,
         @Nullable AgeSeasonMode seasonMode,
-        List<AgeFeatureSelection.Choice> randomFeatures
+        List<AgeFeatureSelection.Choice> randomFeatures,
+        AgeInstability instability,
+        AgeInstabilityPlan instabilityPlan
 ) {
     public static final ResourceLocation RANDOM_VANILLA_PROFILE = ResourceLocation.fromNamespaceAndPath(
             Rivencraft.MOD_ID, "random_vanilla"
@@ -34,6 +36,8 @@ public record AgeDefinition(
         Objects.requireNonNull(generationProfile, "generationProfile");
         Objects.requireNonNull(dimensionId, "dimensionId");
         Objects.requireNonNull(traits, "traits");
+        Objects.requireNonNull(instability, "instability");
+        Objects.requireNonNull(instabilityPlan, "instabilityPlan");
         randomFeatures = List.copyOf(randomFeatures);
         if (plan != null && !randomFeatures.isEmpty()) {
             throw new IllegalArgumentException("Authored Ages cannot also have random features");
@@ -47,14 +51,14 @@ 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, List.of());
+                dimensionId, spawn, traits, null, null, List.of(), AgeInstability.legacyNeutral());
     }
 
     public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
                          int generationVersion, long createdGameTime, ResourceLocation dimensionId,
                          BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan) {
         this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, plan, null, List.of());
+                dimensionId, spawn, traits, plan, null, List.of(), AgeInstability.legacyNeutral());
     }
 
     public AgeDefinition(UUID id, String name, long seed, ResourceLocation generationProfile,
@@ -62,7 +66,25 @@ public record AgeDefinition(
                          BlockPos spawn, AgeTraits traits, AgeGenerationPlan plan,
                          @Nullable AgeSeasonMode seasonMode) {
         this(id, name, seed, generationProfile, generationVersion, createdGameTime,
-                dimensionId, spawn, traits, plan, seasonMode, List.of());
+                dimensionId, spawn, traits, plan, seasonMode, List.of(), AgeInstability.legacyNeutral());
+    }
+
+    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, List<AgeFeatureSelection.Choice> randomFeatures) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, randomFeatures, AgeInstability.legacyNeutral());
+    }
+
+    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, List<AgeFeatureSelection.Choice> randomFeatures,
+                         AgeInstability instability) {
+        this(id, name, seed, generationProfile, generationVersion, createdGameTime,
+                dimensionId, spawn, traits, plan, seasonMode, randomFeatures, instability,
+                AgeInstabilityPlan.empty());
     }
 
     public static ResourceLocation dimensionId(UUID ageId) {
@@ -93,6 +115,7 @@ public record AgeDefinition(
 
     public AgeDefinition withSpawn(BlockPos spawn) {
         return new AgeDefinition(id, name, seed, generationProfile, generationVersion,
-                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode, randomFeatures);
+                createdGameTime, dimensionId, spawn.immutable(), traits, plan, seasonMode,
+                randomFeatures, instability, instabilityPlan);
     }
 }

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

@@ -13,8 +13,10 @@ import java.util.Collections;
 import java.util.Comparator;
 import java.util.Random;
 import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.registry.ModBlocks;
 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 +41,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 +101,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(
@@ -219,7 +229,7 @@ public final class AgeDimensionService {
         for (int x = -PLATFORM_RADIUS; x <= PLATFORM_RADIUS; x++) {
             for (int z = -PLATFORM_RADIUS; z <= PLATFORM_RADIUS; z++) {
                 BlockPos floor = floorCenter.offset(x, 0, z);
-                level.setBlock(floor, Blocks.COBBLESTONE.defaultBlockState(), 2);
+                level.setBlock(floor, ModBlocks.CLOUD_PLATFORM.get().defaultBlockState(), 2);
                 for (int y = 1; y <= 4; y++) {
                     level.setBlock(floor.above(y), Blocks.AIR.defaultBlockState(), 2);
                 }
@@ -329,8 +339,11 @@ public final class AgeDimensionService {
                 Registries.NOISE_SETTINGS, profile.noiseSettings());
         NoiseGeneratorSettings baseSettings = noiseSettings.getOrThrow(settingsKey).value();
         Holder<NoiseGeneratorSettings> settings = Holder.direct(withBiomeMaterialRules(baseSettings));
-        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/AgeEnvironmentCompiler.java

@@ -15,14 +15,14 @@ public final class AgeEnvironmentCompiler {
         AgeTraits.Weather weather = seeded.weather();
         double period = seeded.celestialPeriod();
         float phase = seeded.celestialPhase();
-        boolean normalTime = plan.symbols().stream()
+        boolean normalTime = plan.activeSymbols().stream()
                 .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.CELESTIAL);
         if (normalTime) period = 1.0D;
         boolean writtenPeriod = false;
         boolean writtenPhase = false;
         float phaseDegrees = 0.0F;
 
-        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.symbols()) {
+        for (AgeGenerationPlan.ResolvedSymbol symbol : plan.activeSymbols()) {
             SymbolSemantics semantics = symbol.semantics();
             switch (semantics.role()) {
                 case LIGHTING -> lighting = AgeTraits.Lighting.valueOf(
@@ -61,7 +61,7 @@ public final class AgeEnvironmentCompiler {
     /** Vanilla effects are the sky styles the current renderer can honor exactly. */
     public static ResourceLocation skyEffects(AgeGenerationPlan plan, ResourceLocation fallback) {
         if (plan == null) return fallback;
-        return plan.symbols().stream()
+        return plan.activeSymbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SKY)
                 .map(symbol -> ((SymbolSemantics.ChoiceValue) symbol.semantics().value()).id())
                 .map(choice -> switch (choice) {
@@ -73,7 +73,7 @@ public final class AgeEnvironmentCompiler {
     }
 
     public static boolean hasWrittenPhase(AgeGenerationPlan plan) {
-        return plan != null && plan.symbols().stream()
+        return plan != null && plan.activeSymbols().stream()
                 .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.PHASE_MODIFIER);
     }
 

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

@@ -10,8 +10,10 @@ 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;
@@ -25,10 +27,14 @@ 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("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() {}
 
@@ -49,6 +55,10 @@ public final class AgeFeatureSelection {
                 .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()
@@ -115,6 +125,8 @@ public final class AgeFeatureSelection {
 
     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;
@@ -125,12 +137,13 @@ public final class AgeFeatureSelection {
         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(),
+        for (Choice choice : choices(plan.activeSymbols().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())) {
+                    && !spheres(choice.id()) && !spikes(choice.id())
+                    && !obelisks(choice.id())) {
                 resolved.add(choice);
                 continue;
             }
@@ -146,13 +159,15 @@ public final class AgeFeatureSelection {
     public static List<Choice> randomChoices(long ageSeed, AgeRuntimeProfile profile, RegistryAccess registries) {
         Random random = new Random(ageSeed ^ 0x4D4154455249414CL);
         int count = random.nextInt(3);
-        List<ResourceLocation> features = new ArrayList<>();
-        for (ResourceLocation id : BLOCK_FEATURES) if (error(id, profile, registries) == null) features.add(id);
-        for (ResourceLocation id : FLUID_FEATURES) if (error(id, profile, registries) == null) features.add(id);
-        Collections.shuffle(features, random);
+        List<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<>();
-        for (ResourceLocation feature : features) {
-            if (choices.size() >= count) break;
+        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()
@@ -163,9 +178,42 @@ public final class AgeFeatureSelection {
         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;
@@ -187,6 +235,16 @@ public final class AgeFeatureSelection {
     }
 
     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;
@@ -195,6 +253,11 @@ public final class AgeFeatureSelection {
                 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";
@@ -248,50 +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 choice.equals(ResourceLocation.fromNamespaceAndPath("rivencraft", "floating_islands"));
+        return is(choice, "floating_islands");
     }
 
     public static boolean tendrils(ResourceLocation choice) {
-        return choice.equals(id("tendrils"));
+        return is(choice, "tendrils");
     }
 
     public static boolean spheres(ResourceLocation choice) {
-        return choice.equals(id("spheres"));
+        return is(choice, "spheres");
     }
 
     public static boolean spikes(ResourceLocation choice) {
-        return choice.equals(id("spikes"));
+        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);
+                || spheres(choice) || spikes(choice) || obelisks(choice);
     }
 
     public static boolean skylands(ResourceLocation choice) {
-        return choice.equals(id("skylands"));
+        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) {
@@ -313,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

@@ -16,8 +16,9 @@ import net.minecraft.resources.ResourceLocation;
 
 /** A frozen interpretation of authored pages. Later slices consume its resolved branches. */
 public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
-                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
-    public static final int CURRENT_VERSION = 2;
+                                AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection,
+                                List<Integer> activeSymbolIndices, int writingInstability) {
+    public static final int CURRENT_VERSION = 3;
 
     public AgeGenerationPlan {
         if (version < 1 || version > CURRENT_VERSION) {
@@ -25,12 +26,14 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         }
         Objects.requireNonNull(writing, "writing");
         symbols = List.copyOf(symbols);
+        activeSymbolIndices = List.copyOf(activeSymbolIndices);
+        if (writingInstability < 0) throw new IllegalArgumentException("Negative writing instability");
         Objects.requireNonNull(runtimeProfile, "runtimeProfile");
         if (runtimeProfile.schemaVersion() != AgeRuntimeProfile.CURRENT_SCHEMA_VERSION) {
             throw new IllegalArgumentException("Unsupported runtime profile snapshot version");
         }
-        if (version == CURRENT_VERSION && biomeSelection == null) {
-            throw new IllegalArgumentException("Version 2 Age plan requires a biome selection snapshot");
+        if (version >= 2 && biomeSelection == null) {
+            throw new IllegalArgumentException("Version 2+ Age plan requires a biome selection snapshot");
         }
         for (ResolvedSymbol symbol : symbols) {
             if (symbol.index() < 0 || symbol.index() >= writing.entries().size()
@@ -38,12 +41,31 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
                 throw new IllegalArgumentException("Resolved symbol does not match original page order");
             }
         }
+        if (version >= 3 && !symbols.isEmpty() && activeSymbolIndices.isEmpty()) {
+            throw new IllegalArgumentException("Version 3 Age plan has no active symbols");
+        }
+        if (activeSymbolIndices.stream().distinct().count() != activeSymbolIndices.size()) {
+            throw new IllegalArgumentException("Age plan repeats an active symbol index");
+        }
+        for (int index : activeSymbolIndices) {
+            if (symbols.stream().noneMatch(symbol -> symbol.index() == index)) {
+                throw new IllegalArgumentException("Active symbol is not in the saved writing: " + index);
+            }
+        }
     }
 
     /** Existing version 1 plans retain their original biome behavior on reload. */
     public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
                              AgeRuntimeProfile runtimeProfile) {
-        this(version, ageSeed, writing, symbols, runtimeProfile, null);
+        this(version, ageSeed, writing, symbols, runtimeProfile, null,
+                symbols.stream().map(ResolvedSymbol::index).toList(), 0);
+    }
+
+    /** Existing call sites and version-2 plans retain every resolved symbol. */
+    public AgeGenerationPlan(int version, long ageSeed, OrderedWriting writing, List<ResolvedSymbol> symbols,
+                             AgeRuntimeProfile runtimeProfile, AgeBiomeSelection biomeSelection) {
+        this(version, ageSeed, writing, symbols, runtimeProfile, biomeSelection,
+                symbols.stream().map(ResolvedSymbol::index).toList(), 0);
     }
 
     /** No plan is made for old page-free books or Link-Panel-only random Ages. */
@@ -52,7 +74,9 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         WritingGrammar.Result parsed = WritingGrammar.parse(writing);
         if (!parsed.canCreate()) throw new IllegalArgumentException(parsed.firstError().orElseThrow().message());
         if (parsed.randomFallback()) return null;
-        ResourceLocation terrain = parsed.symbols().stream()
+        List<WritingGrammar.ParsedSymbol> active = parsed.activeSymbols();
+        WritingGrammar.Result effective = new WritingGrammar.Result(active, parsed.diagnostics());
+        ResourceLocation terrain = active.stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
                 .findFirst().orElse(null);
@@ -64,23 +88,29 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
         ResourceLocation selected = terrain == null ? seedProfile : terrain;
         AgeRuntimeProfile profile = AgeRuntimeProfiles.profiles().get(selected);
         if (profile == null) throw new IllegalArgumentException("Unsupported Age terrain profile " + selected);
-        AgeBiomeSelection biomes = AgeBiomeSelection.compile(parsed, traits, profile, ageSeed, registries);
-        AgeFeatureSelection.compile(parsed, profile, biomes, registries, ageSeed);
+        AgeBiomeSelection biomes = AgeBiomeSelection.compile(effective, traits, profile, ageSeed, registries);
+        AgeFeatureSelection.compile(effective, profile, biomes, registries, ageSeed);
         AgeGenerationPlan plan = new AgeGenerationPlan(CURRENT_VERSION, ageSeed, writing,
                 parsed.symbols().stream().map(symbol -> new ResolvedSymbol(
                         symbol.index(), symbol.reference(), symbol.semantics())).toList(),
-                profile, biomes);
+                profile, biomes, active.stream().map(WritingGrammar.ParsedSymbol::index).toList(),
+                parsed.writingInstability());
         AgeEnvironmentCompiler.apply(plan, traits);
         AgeSeasonMode.validate(plan);
         return plan;
     }
 
     public ResourceLocation authoredTerrain() {
-        return symbols.stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
+        return activeSymbols().stream().filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id())
                 .findFirst().orElse(null);
     }
 
+    public List<ResolvedSymbol> activeSymbols() {
+        return activeSymbolIndices.stream().map(index -> symbols.stream()
+                .filter(symbol -> symbol.index() == index).findFirst().orElseThrow()).toList();
+    }
+
     public CompoundTag save() {
         CompoundTag tag = new CompoundTag();
         tag.putInt("Version", version);
@@ -106,6 +136,10 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
             resolved.add(item);
         }
         tag.put("Resolved", resolved);
+        if (version >= 3) {
+            tag.putIntArray("ActiveSymbolIndices", activeSymbolIndices);
+            tag.putInt("WritingInstability", writingInstability);
+        }
         CompoundTag profile = new CompoundTag();
         profile.putInt("Version", runtimeProfile.schemaVersion());
         profile.putString("Terrain", runtimeProfile.terrain().name());
@@ -162,12 +196,16 @@ public record AgeGenerationPlan(int version, long ageSeed, OrderedWriting writin
             selection = new AgeBiomeSelection(AgeTraits.BiomeDistribution.valueOf(
                     biomeTag.getString("Distribution")), ids);
         }
+        List<Integer> activeIndices = version >= 3
+                ? java.util.Arrays.stream(tag.getIntArray("ActiveSymbolIndices")).boxed().toList()
+                : resolved.stream().map(ResolvedSymbol::index).toList();
         return new AgeGenerationPlan(version, tag.getLong("AgeSeed"), new OrderedWriting(pages), resolved,
                 new AgeRuntimeProfile(profile.getInt("Version"),
                         AgeRuntimeProfile.Terrain.valueOf(profile.getString("Terrain")),
                         ResourceLocation.parse(profile.getString("Noise")),
                         ResourceLocation.parse(profile.getString("Biomes")),
-                        ResourceLocation.parse(profile.getString("Dimension"))), selection);
+                        ResourceLocation.parse(profile.getString("Dimension"))), selection,
+                activeIndices, version >= 3 ? tag.getInt("WritingInstability") : 0);
     }
 
     public record ResolvedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {

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/AgeInstability.java

@@ -0,0 +1,95 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Objects;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+
+/** Frozen, server-owned score. Only new Age creation consults the current symbol catalog. */
+public record AgeInstability(int version, int score, List<Contribution> breakdown) {
+    public static final int CURRENT_VERSION = 1;
+
+    public AgeInstability {
+        if (version != CURRENT_VERSION) throw new IllegalArgumentException("Unsupported instability version " + version);
+        breakdown = List.copyOf(breakdown);
+        if (score < 0 || score != breakdown.stream().mapToInt(Contribution::points).sum()) {
+            throw new IllegalArgumentException("Instability score does not match breakdown");
+        }
+    }
+
+    /** Pre-scoring saves are explicitly neutral, never rescored from current data packs. */
+    public static AgeInstability legacyNeutral() {
+        return new AgeInstability(CURRENT_VERSION, 0,
+                List.of(new Contribution("legacy_neutral", -1, 0, "Age predates frozen instability scoring")));
+    }
+
+    static AgeInstability compute(AgeGenerationPlan plan, AgeTraits traits) {
+        Objects.requireNonNull(traits, "traits");
+        List<Contribution> contributions = new ArrayList<>();
+        if (plan == null) {
+            contributions.add(new Contribution("random_baseline", -1, 0, "Page-free or Link-Panel-only Age"));
+        } else {
+            contributions.add(new Contribution("authored_baseline", -1, 0, "Authored Age"));
+            WritingGrammar.Result parsed = WritingGrammar.parse(plan.writing());
+            if (!parsed.canCreate() || parsed.writingInstability() != plan.writingInstability()) {
+                throw new IllegalArgumentException("Writing changed between Age compilation and scoring");
+            }
+            for (WritingGrammar.Diagnostic diagnostic : parsed.diagnostics()) {
+                contributions.add(new Contribution(diagnostic.code().name().toLowerCase(java.util.Locale.ROOT),
+                        diagnostic.index(), diagnostic.instability(), diagnostic.message()));
+            }
+        }
+        // Legacy's bright-lighting symbol adds +500. Other balance costs are deferred
+        // until their corresponding authored symbols and audited values exist.
+        if (traits.lighting() == AgeTraits.Lighting.BRIGHT) {
+            int pageIndex = plan == null ? -1 : plan.activeSymbols().stream()
+                    .filter(symbol -> symbol.semantics().role()
+                            == net.dnorberg.rivencraft.writing.SymbolSemantics.Role.LIGHTING)
+                    .mapToInt(AgeGenerationPlan.ResolvedSymbol::index).findFirst().orElse(-1);
+            contributions.add(new Contribution("bright_lighting", pageIndex, 500,
+                    pageIndex < 0 ? "Seeded bright lighting" : "Authored bright lighting"));
+        }
+        return new AgeInstability(CURRENT_VERSION,
+                contributions.stream().mapToInt(Contribution::points).sum(), contributions);
+    }
+
+    public CompoundTag save() {
+        CompoundTag tag = new CompoundTag();
+        tag.putInt("Version", version);
+        tag.putInt("Score", score);
+        ListTag entries = new ListTag();
+        for (Contribution contribution : breakdown) {
+            CompoundTag entry = new CompoundTag();
+            entry.putString("Reason", contribution.reason());
+            entry.putInt("PageIndex", contribution.pageIndex());
+            entry.putInt("Points", contribution.points());
+            entry.putString("Detail", contribution.detail());
+            entries.add(entry);
+        }
+        tag.put("Breakdown", entries);
+        return tag;
+    }
+
+    public static AgeInstability load(CompoundTag tag) {
+        ListTag entries = tag.getList("Breakdown", CompoundTag.TAG_COMPOUND);
+        List<Contribution> contributions = new ArrayList<>();
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            contributions.add(new Contribution(entry.getString("Reason"), entry.getInt("PageIndex"),
+                    entry.getInt("Points"), entry.getString("Detail")));
+        }
+        return new AgeInstability(tag.getInt("Version"), tag.getInt("Score"), contributions);
+    }
+
+    public record Contribution(String reason, int pageIndex, int points, String detail) {
+        public Contribution {
+            Objects.requireNonNull(reason, "reason");
+            Objects.requireNonNull(detail, "detail");
+            if (reason.isBlank() || pageIndex < -1 || points < 0) {
+                throw new IllegalArgumentException("Invalid instability contribution");
+            }
+        }
+    }
+}

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

@@ -0,0 +1,78 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Random;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.ListTag;
+import net.minecraft.resources.ResourceLocation;
+
+/** Frozen provider selection; handler availability and server settings never reroll this plan. */
+public record AgeInstabilityPlan(int version, List<ProviderLevel> providers) {
+    public static final int CURRENT_VERSION = 1;
+
+    public AgeInstabilityPlan {
+        if (version != CURRENT_VERSION) throw new IllegalArgumentException("Unsupported provider-plan version " + version);
+        providers = List.copyOf(providers);
+        if (providers.stream().map(ProviderLevel::id).distinct().count() != providers.size()) {
+            throw new IllegalArgumentException("Duplicate provider ID in saved Age plan");
+        }
+    }
+
+    public static AgeInstabilityPlan empty() { return new AgeInstabilityPlan(CURRENT_VERSION, List.of()); }
+
+    public static AgeInstabilityPlan select(AgeInstability instability, long ageSeed) {
+        int roundedScore = instability.score() / 500 * 500;
+        Map<ResourceLocation, Integer> levels = new LinkedHashMap<>();
+        for (InstabilityProviderCatalog.Deck deck : InstabilityProviderCatalog.Deck.values()) {
+            int remaining = roundedScore - deck.entryCost();
+            if (remaining <= 0) continue;
+            List<InstabilityProviderCatalog.Card> cards = new ArrayList<>(InstabilityProviderCatalog.cards(deck));
+            Collections.shuffle(cards, new Random(ageSeed ^ (0x9E3779B97F4A7C15L * (deck.ordinal() + 1))));
+            for (InstabilityProviderCatalog.Card card : cards) {
+                if (remaining < card.cost()) break;
+                remaining -= card.cost();
+                levels.merge(card.id(), 1, Integer::sum);
+            }
+        }
+        return new AgeInstabilityPlan(CURRENT_VERSION, levels.entrySet().stream()
+                .map(entry -> new ProviderLevel(entry.getKey(), entry.getValue())).toList());
+    }
+
+    public CompoundTag save() {
+        CompoundTag tag = new CompoundTag();
+        tag.putInt("Version", version);
+        ListTag entries = new ListTag();
+        for (ProviderLevel provider : providers) {
+            CompoundTag entry = new CompoundTag();
+            entry.putString("Id", provider.id().toString());
+            entry.putInt("Level", provider.level());
+            entries.add(entry);
+        }
+        tag.put("Providers", entries);
+        return tag;
+    }
+
+    public static AgeInstabilityPlan load(CompoundTag tag) {
+        ListTag entries = tag.getList("Providers", CompoundTag.TAG_COMPOUND);
+        List<ProviderLevel> providers = new ArrayList<>();
+        for (int index = 0; index < entries.size(); index++) {
+            CompoundTag entry = entries.getCompound(index);
+            ResourceLocation id = ResourceLocation.tryParse(entry.getString("Id"));
+            if (id == null) throw new IllegalArgumentException("Invalid saved instability provider ID at " + index);
+            providers.add(new ProviderLevel(id, entry.getInt("Level")));
+        }
+        return new AgeInstabilityPlan(tag.getInt("Version"), providers);
+    }
+
+    public record ProviderLevel(ResourceLocation id, int level) {
+        public ProviderLevel {
+            Objects.requireNonNull(id, "id");
+            if (level < 1 || level > 255) throw new IllegalArgumentException("Invalid provider level " + level);
+        }
+    }
+}

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

@@ -0,0 +1,171 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.ChunkPos;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.LevelTickEvent;
+
+/** Server-only scheduler. Effect handlers are registered by later provider slices. */
+public final class AgeInstabilityRuntime {
+    private static final Map<ResourceLocation, Handler> HANDLERS = new HashMap<>();
+    private static final Map<MinecraftServer, TickState> TICKS = new WeakHashMap<>();
+    private static final Map<ServerLevel, Map<ResourceLocation, Long>> FAILURES = new WeakHashMap<>();
+    private static final Set<ResourceLocation> UNKNOWN_LOGGED = new HashSet<>();
+
+    private AgeInstabilityRuntime() {}
+
+    /** Register once during mod setup. Missing optional handlers never alter saved provider IDs. */
+    public static void register(ResourceLocation id, boolean worldMutating, ProviderEffect effect) {
+        Objects.requireNonNull(id, "id");
+        Objects.requireNonNull(effect, "effect");
+        if (HANDLERS.putIfAbsent(id, new Handler(worldMutating, effect)) != null) {
+            throw new IllegalArgumentException("Duplicate instability handler " + id);
+        }
+    }
+
+    public static void onLevelTickPost(LevelTickEvent.Post event) {
+        if (!(event.getLevel() instanceof ServerLevel level) || !RivencraftConfig.instabilityEnabled()
+                || !isAgeDimension(level.dimension().location()) || level.players().isEmpty()) return;
+        MinecraftServer server = level.getServer();
+        long tick = server.getTickCount();
+        int cooldown = RivencraftConfig.instabilityCooldown();
+        if (tick % cooldown != 0) return;
+        TickState state = TICKS.computeIfAbsent(server, ignored -> new TickState());
+        if (state.tick != tick) {
+            state.tick = tick;
+            state.eligible = loadedPlayerAges(server);
+        }
+        if (!admitted(state.eligible, level.dimension().location(), tick / cooldown,
+                RivencraftConfig.instabilityMaxAges())) return;
+        AgeDefinition age = AgeRegistrySavedData.get(level).findByDimension(level.dimension().location()).orElse(null);
+        if (age == null || age.instabilityPlan().providers().isEmpty()) return;
+        List<ChunkPos> chunks = loadedChunksNearPlayers(level, RivencraftConfig.instabilityMaxChunks());
+        if (chunks.isEmpty()) return;
+        Budget budget = new Budget(RivencraftConfig.instabilityMaxActions());
+        Context context = new Context(level, age, chunks, tick, budget);
+        List<AgeInstabilityPlan.ProviderLevel> providers = age.instabilityPlan().providers();
+        int first = (int) Math.floorMod(tick / cooldown + age.seed(), providers.size());
+        int ran = 0;
+        for (int offset = 0; offset < providers.size() && ran < RivencraftConfig.instabilityMaxProviders()
+                && budget.remaining() > 0; offset++) {
+            AgeInstabilityPlan.ProviderLevel provider = providers.get((first + offset) % providers.size());
+            Handler handler = HANDLERS.get(provider.id());
+            if (handler == null) {
+                if (!InstabilityProviderCatalog.contains(provider.id()) && UNKNOWN_LOGGED.add(provider.id())) {
+                    Rivencraft.LOGGER.warn("Saved Age references unknown instability provider {}; skipping it",
+                            provider.id());
+                }
+                continue;
+            }
+            if (handler.worldMutating() && !RivencraftConfig.instabilityWorldMutation()) continue;
+            long retryAfter = FAILURES.computeIfAbsent(level, ignored -> new HashMap<>())
+                    .getOrDefault(provider.id(), 0L);
+            if (tick < retryAfter) continue;
+            ran++;
+            try {
+                handler.effect().apply(context, provider.id(),
+                        Math.min(provider.level(), RivencraftConfig.instabilityMaxLevel()));
+            } catch (RuntimeException exception) {
+                FAILURES.get(level).put(provider.id(), tick + Math.max(200L, cooldown * 10L));
+                Rivencraft.LOGGER.error("Instability provider {} failed in Age {}; temporarily quarantined",
+                        provider.id(), age.id(), exception);
+            }
+        }
+    }
+
+    public static void onServerStopping(ServerStoppingEvent event) {
+        TICKS.remove(event.getServer());
+        FAILURES.clear();
+        UNKNOWN_LOGGED.clear();
+    }
+
+    public static boolean isAgeDimension(ResourceLocation id) {
+        return id.getNamespace().equals(Rivencraft.MOD_ID) && id.getPath().startsWith("age/");
+    }
+
+    static boolean admitted(List<ResourceLocation> eligible, ResourceLocation id, long run,
+                            int maximum) {
+        int index = eligible.indexOf(id);
+        if (index < 0 || maximum < 1) return false;
+        if (eligible.size() <= maximum) return true;
+        return Math.floorMod(index - (int) Math.floorMod(run, eligible.size()), eligible.size()) < maximum;
+    }
+
+    private static List<ResourceLocation> loadedPlayerAges(MinecraftServer server) {
+        List<ResourceLocation> eligible = new ArrayList<>();
+        AgeRegistrySavedData registry = AgeRegistrySavedData.get(server.overworld());
+        for (ServerLevel level : server.getAllLevels()) {
+            ResourceLocation id = level.dimension().location();
+            if (isAgeDimension(id) && !level.players().isEmpty()
+                    && registry.findByDimension(id).filter(age -> !age.instabilityPlan().providers().isEmpty())
+                    .isPresent()) eligible.add(id);
+        }
+        eligible.sort(Comparator.comparing(ResourceLocation::toString));
+        return List.copyOf(eligible);
+    }
+
+    private static List<ChunkPos> loadedChunksNearPlayers(ServerLevel level, int maximum) {
+        Set<ChunkPos> chunks = new LinkedHashSet<>();
+        for (var player : level.players()) {
+            ChunkPos center = player.chunkPosition();
+            for (int dx = -1; dx <= 1; dx++) {
+                for (int dz = -1; dz <= 1; dz++) {
+                    int x = center.x + dx;
+                    int z = center.z + dz;
+                    if (level.getChunkSource().hasChunk(x, z)) chunks.add(new ChunkPos(x, z));
+                    if (chunks.size() >= maximum) return List.copyOf(chunks);
+                }
+            }
+        }
+        return List.copyOf(chunks);
+    }
+
+    @FunctionalInterface
+    public interface ProviderEffect {
+        /** Claim budget before each effect action; only use chunks supplied in the context. */
+        void apply(Context context, ResourceLocation id, int effectiveLevel);
+    }
+
+    public record Context(ServerLevel level, AgeDefinition age, List<ChunkPos> loadedChunks,
+                          long serverTick, Budget budget) {
+        public Context { loadedChunks = List.copyOf(loadedChunks); }
+    }
+
+    public static final class Budget {
+        private int remaining;
+
+        public Budget(int maximum) {
+            if (maximum < 0) throw new IllegalArgumentException("Negative work budget");
+            remaining = maximum;
+        }
+
+        public boolean claim() {
+            if (remaining == 0) return false;
+            remaining--;
+            return true;
+        }
+
+        public int remaining() { return remaining; }
+    }
+
+    private record Handler(boolean worldMutating, ProviderEffect effect) {}
+
+    private static final class TickState {
+        private long tick = Long.MIN_VALUE;
+        private List<ResourceLocation> eligible = List.of();
+    }
+}

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

@@ -0,0 +1,81 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.nbt.CompoundTag;
+import net.minecraft.resources.ResourceLocation;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Pure server-side provider-plan and scheduler-boundary checks for issue #66. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class AgeInstabilityRuntimeGameTests {
+    private AgeInstabilityRuntimeGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void selectionIsDeterministicAndFrozen(GameTestHelper helper) {
+        AgeInstability score = new AgeInstability(AgeInstability.CURRENT_VERSION, 30_000,
+                List.of(new AgeInstability.Contribution("fixture", -1, 30_000, "provider selection")));
+        AgeInstabilityPlan first = AgeInstabilityPlan.select(score, 44L);
+        helper.assertTrue(!first.providers().isEmpty(), "An eligible score must select providers");
+        helper.assertValueEqual(AgeInstabilityPlan.select(score, 44L), first,
+                "The same Age seed and frozen score must select the same providers");
+        helper.assertValueEqual(AgeInstabilityPlan.load(first.save()), first,
+                "Saved provider IDs and levels must survive a round trip");
+        helper.assertTrue(first.providers().stream().allMatch(provider -> provider.level() > 0
+                        && InstabilityProviderCatalog.contains(provider.id())),
+                "Only audited providers with positive levels may be selected");
+        helper.assertTrue(AgeInstabilityPlan.select(AgeInstability.legacyNeutral(), 44L)
+                        .providers().isEmpty(), "Neutral old Ages must stay inert");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void savedPlanSurvivesAgeUpdatesAndMissingHandlers(GameTestHelper helper) {
+        ResourceLocation optional = ResourceLocation.parse("example:optional_provider");
+        AgeInstabilityPlan plan = new AgeInstabilityPlan(1,
+                List.of(new AgeInstabilityPlan.ProviderLevel(optional, 2)));
+        helper.assertValueEqual(AgeInstabilityPlan.load(plan.save()), plan,
+                "A syntactically valid provider ID must persist even if no handler is installed");
+        UUID id = UUID.randomUUID();
+        AgeDefinition age = new AgeDefinition(id, "Runtime", 91L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(id), null,
+                AgeTraits.LEGACY_DEFAULTS, null, null, List.of(), AgeInstability.legacyNeutral(), plan);
+        helper.assertValueEqual(age.withSpawn(new BlockPos(1, 64, 2)).instabilityPlan(), plan,
+                "Setting an Age spawn must not reroll selected providers");
+        CompoundTag corrupt = plan.save();
+        corrupt.getList("Providers", CompoundTag.TAG_COMPOUND).getCompound(0)
+                .putString("Id", "bad provider id");
+        boolean rejected = false;
+        try { AgeInstabilityPlan.load(corrupt); }
+        catch (IllegalArgumentException expected) { rejected = true; }
+        helper.assertTrue(rejected, "Malformed provider IDs must fail clearly");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void ageScopeRotationAndActionBudgetAreBounded(GameTestHelper helper) {
+        ResourceLocation first = ResourceLocation.parse("rivencraft:age/first");
+        ResourceLocation second = ResourceLocation.parse("rivencraft:age/second");
+        ResourceLocation third = ResourceLocation.parse("rivencraft:age/third");
+        helper.assertTrue(!AgeInstabilityRuntime.isAgeDimension(helper.getLevel().dimension().location()),
+                "The GameTest Overworld must never be treated as an Age");
+        helper.assertTrue(!AgeInstabilityRuntime.isAgeDimension(ResourceLocation.parse("rivencraft:preview")),
+                "Preview worlds must not receive Age effects");
+        List<ResourceLocation> loaded = List.of(first, second, third);
+        helper.assertTrue(AgeInstabilityRuntime.admitted(loaded, first, 0, 1)
+                        && AgeInstabilityRuntime.admitted(loaded, second, 1, 1)
+                        && AgeInstabilityRuntime.admitted(loaded, third, 2, 1),
+                "A global cap must rotate fairly among loaded Ages");
+        AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(2);
+        helper.assertTrue(budget.claim() && budget.claim() && !budget.claim(),
+                "A handler cannot claim more actions than the Age budget");
+        helper.assertValueEqual(budget.remaining(), 0, "The budget must not go negative");
+        helper.succeed();
+    }
+}

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

@@ -6,6 +6,7 @@ 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.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.core.BlockPos;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
@@ -55,6 +56,124 @@ public final class AgePersistenceGameTests {
                 registry.save(new CompoundTag(), helper.getLevel().registryAccess()),
                 helper.getLevel().registryAccess()).find(id).orElseThrow();
         helper.assertValueEqual(restored, created, "The complete plan must survive a saved-data round trip");
+        helper.assertValueEqual(restored.instability(), created.instability(),
+                "The complete instability breakdown must survive reload");
+        helper.assertValueEqual(restored.instabilityPlan(), created.instabilityPlan(),
+                "The selected provider levels must not reroll on reload");
+        helper.assertValueEqual(registry.instability(id).orElseThrow(), created.instability(),
+                "The server diagnostic query must return the saved score");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void instabilitySeparatesStableAndDefectiveWriting(GameTestHelper helper) {
+        OrderedWriting stable = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal")))
+        ));
+        OrderedWriting defective = new OrderedWriting(List.of(
+                WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:lighting/normal"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard"))),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))
+        ));
+        AgeDefinition stableAge = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Stable Writing"), stable);
+        AgeDefinition defectiveAge = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Defective Writing"), defective);
+        helper.assertValueEqual(stableAge.instability().score(), 0,
+                "Missing seeded branches do not add instability");
+        helper.assertValueEqual(defectiveAge.instability().score(), 600,
+                "Out-of-order and repeated terrain pages each add their saved penalty");
+        helper.assertTrue(defectiveAge.instability().breakdown().stream()
+                        .anyMatch(part -> part.reason().equals("duplicate") && part.pageIndex() == 3),
+                "The score must explain the offending page");
+        AgeDefinition reused = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(defectiveAge.id(), "Changed Name"), stable);
+        helper.assertValueEqual(reused, defectiveAge, "Repeated book use must not rescore an Age");
+        CompoundTag scoreOnlySave = AgeRegistrySavedData.get(helper.getLevel())
+                .save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag savedAges = scoreOnlySave.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < savedAges.size(); index++) {
+            CompoundTag entry = savedAges.getCompound(index);
+            if (entry.getUUID("Id").equals(defectiveAge.id())) entry.remove("InstabilityPlan");
+        }
+        AgeRegistrySavedData migrated = AgeRegistrySavedData.load(scoreOnlySave,
+                helper.getLevel().registryAccess());
+        AgeDefinition migratedAge = migrated.find(defectiveAge.id()).orElseThrow();
+        helper.assertValueEqual(migratedAge.instabilityPlan(),
+                AgeInstabilityPlan.select(defectiveAge.instability(), defectiveAge.seed()),
+                "A score-only save must receive one deterministic provider migration");
+        helper.assertValueEqual(AgeRegistrySavedData.load(
+                        migrated.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                        helper.getLevel().registryAccess()).find(defectiveAge.id()).orElseThrow().instabilityPlan(),
+                migratedAge.instabilityPlan(), "Migrated provider selection must then remain frozen");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void randomBaselineAndBrightBalanceAreFrozen(GameTestHelper helper) {
+        AgeDefinition random = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Random Score"), OrderedWriting.EMPTY);
+        helper.assertTrue(random.instability().breakdown().stream()
+                        .anyMatch(part -> part.reason().equals("random_baseline") && part.points() == 0),
+                "Random Ages require an explicit baseline entry");
+        helper.assertValueEqual(random.instability().score(),
+                random.traits().lighting() == AgeTraits.Lighting.BRIGHT ? 500 : 0,
+                "Seeded bright lighting must use the audited balance cost");
+        AgeInstability bright = AgeInstability.compute(null, new AgeTraits(
+                AgeTraits.LEGACY_DEFAULTS.biomeDistribution(), AgeTraits.Lighting.BRIGHT,
+                AgeTraits.LEGACY_DEFAULTS.weather(), AgeTraits.LEGACY_DEFAULTS.celestialPeriod(),
+                AgeTraits.LEGACY_DEFAULTS.celestialAngle(), AgeTraits.LEGACY_DEFAULTS.celestialPhase()));
+        helper.assertValueEqual(bright.score(), 500, "Bright lighting has the audited Legacy cost");
+        helper.assertValueEqual(AgeInstability.load(bright.save()), bright,
+                "A score must survive its own versioned round trip");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void missingRegistryEntryDoesNotReinterpretAnOldAge(GameTestHelper helper) {
+        UUID id = UUID.randomUUID();
+        CompoundTag root = new CompoundTag();
+        ListTag entries = new ListTag();
+        entries.add(entry(id, "Old Age", 17L, AgeGenerationProfiles.STANDARD, 15, 1L,
+                AgeDefinition.dimensionId(id), new BlockPos(0, 64, 0), AgeTraits.LEGACY_DEFAULTS));
+        root.put("Ages", entries);
+        AgeRegistrySavedData old = AgeRegistrySavedData.load(root, helper.getLevel().registryAccess());
+        helper.assertValueEqual(old.instability(id).orElseThrow(), AgeInstability.legacyNeutral(),
+                "Old Ages without a score must migrate to a neutral saved value");
+        helper.assertTrue(old.instabilityPlan(id).orElseThrow().providers().isEmpty(),
+                "Pre-score Ages must not acquire effects during migration");
+        helper.assertValueEqual(AgeRegistrySavedData.load(
+                old.save(new CompoundTag(), helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess()).instability(id).orElseThrow(), AgeInstability.legacyNeutral(),
+                "Neutral migration must persist after restart");
+        OrderedWriting missing = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:missing_symbol")))));
+        helper.assertTrue(!WritingGrammar.parse(missing, symbol -> java.util.Optional.empty()).canCreate(),
+                "Missing registry symbols remain fatal for new Ages");
+
+        OrderedWriting authored = new OrderedWriting(List.of(WritingEntry.linkPanel(),
+                WritingEntry.symbol(new SymbolReference(ResourceLocation.parse("rivencraft:terrain/standard")))));
+        AgeDefinition created = AgeRegistrySavedData.resolveOrCreate(helper.getLevel(),
+                new AgeReference(UUID.randomUUID(), "Catalog Snapshot"), authored);
+        CompoundTag saved = AgeRegistrySavedData.get(helper.getLevel())
+                .save(new CompoundTag(), helper.getLevel().registryAccess());
+        ListTag savedAges = saved.getList("Ages", CompoundTag.TAG_COMPOUND);
+        for (int index = 0; index < savedAges.size(); index++) {
+            CompoundTag savedAge = savedAges.getCompound(index);
+            if (!savedAge.getUUID("Id").equals(created.id())) continue;
+            CompoundTag plan = savedAge.getCompound("GenerationPlan");
+            plan.getList("Resolved", CompoundTag.TAG_COMPOUND).getCompound(0)
+                    .putString("Symbol", "rivencraft:removed_from_catalog");
+            plan.getList("Writing", CompoundTag.TAG_COMPOUND).getCompound(1)
+                    .putString("Symbol", "rivencraft:removed_from_catalog");
+        }
+        AgeDefinition restored = AgeRegistrySavedData.load(saved, helper.getLevel().registryAccess())
+                .find(created.id()).orElseThrow();
+        helper.assertValueEqual(restored.instability(), created.instability(),
+                "A removed symbol must not reroll or reinterpret the frozen instability score");
         helper.succeed();
     }
 
@@ -74,12 +193,18 @@ public final class AgePersistenceGameTests {
             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, including Spheres and Spikes, need valid blocks or fluids; Skylands needs none");
+                        "Random material features need valid blocks or fluids; material-free features need none");
             }
         }
         AgeRegistrySavedData registry = AgeRegistrySavedData.get(helper.getLevel());
@@ -164,6 +289,8 @@ public final class AgePersistenceGameTests {
                 "Definitions predating traits must receive stable legacy defaults");
         helper.assertTrue(definition.plan() == null,
                 "Existing Ages must not be reinterpreted as authored plans during migration");
+        helper.assertValueEqual(definition.instability(), AgeInstability.legacyNeutral(),
+                "Old Ages must not be rescored from modern page rules");
 
         CompoundTag serialized = migrated.save(new CompoundTag(), helper.getLevel().registryAccess());
         AgeDefinition reloaded = AgeRegistrySavedData.load(serialized, helper.getLevel().registryAccess())

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

@@ -35,6 +35,8 @@ public final class AgeRegistrySavedData extends SavedData {
     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 INSTABILITY_TAG = "Instability";
+    private static final String INSTABILITY_PLAN_TAG = "InstabilityPlan";
     private static final String BIOME_DISTRIBUTION_TAG = "BiomeDistribution";
     private static final String LIGHTING_TAG = "Lighting";
     private static final String WEATHER_TAG = "Weather";
@@ -89,6 +91,15 @@ public final class AgeRegistrySavedData extends SavedData {
         return Optional.ofNullable(ages.get(ageId));
     }
 
+    /** Read-only server diagnostic; never compiles writing or mutates a saved Age. */
+    public Optional<AgeInstability> instability(UUID ageId) {
+        return find(ageId).map(AgeDefinition::instability);
+    }
+
+    public Optional<AgeInstabilityPlan> instabilityPlan(UUID ageId) {
+        return find(ageId).map(AgeDefinition::instabilityPlan);
+    }
+
     public Optional<AgeDefinition> findByDimension(ResourceLocation dimensionId) {
         return ages.values().stream()
                 .filter(age -> age.dimensionId().equals(dimensionId))
@@ -123,6 +134,9 @@ public final class AgeRegistrySavedData extends SavedData {
         ResourceLocation seedProfile = AgeRuntimeProfiles.selectForWriting(seed, writing, registries);
         AgeTraits traits = AgeTraits.select(seed);
         AgeGenerationPlan plan = AgeGenerationPlan.compile(writing, seed, seedProfile, traits, registries);
+        AgeTraits effectiveTraits = AgeEnvironmentCompiler.apply(plan, traits);
+        AgeInstability instability = AgeInstability.compute(plan, effectiveTraits);
+        AgeInstabilityPlan instabilityPlan = AgeInstabilityPlan.select(instability, seed);
         AgeDefinition created = new AgeDefinition(
                 reference.id(),
                 name,
@@ -132,11 +146,13 @@ public final class AgeRegistrySavedData extends SavedData {
                 createdGameTime,
                 dimensionId,
                 null,
-                AgeEnvironmentCompiler.apply(plan, traits),
+                effectiveTraits,
                 plan,
                 AgeSeasonMode.select(plan, seed, ModList.get().isLoaded("sereneseasons")),
                 plan == null ? AgeFeatureSelection.randomChoices(seed,
-                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of()
+                        AgeRuntimeProfiles.resolve(seedProfile), registries) : List.of(),
+                instability,
+                instabilityPlan
         );
         ages.put(created.id(), created);
         setDirty();
@@ -169,6 +185,19 @@ public final class AgeRegistrySavedData extends SavedData {
             BlockPos spawn = entry.contains(SPAWN_Y_TAG)
                     ? new BlockPos(entry.getInt(SPAWN_X_TAG), entry.getInt(SPAWN_Y_TAG), entry.getInt(SPAWN_Z_TAG))
                     : null;
+            AgeInstability instability = entry.contains(INSTABILITY_TAG, CompoundTag.TAG_COMPOUND)
+                    ? AgeInstability.load(entry.getCompound(INSTABILITY_TAG)) : AgeInstability.legacyNeutral();
+            AgeInstabilityPlan instabilityPlan;
+            if (entry.contains(INSTABILITY_PLAN_TAG, CompoundTag.TAG_COMPOUND)) {
+                instabilityPlan = AgeInstabilityPlan.load(entry.getCompound(INSTABILITY_PLAN_TAG));
+            } else {
+                // The previous release froze scores but did not yet choose providers.
+                // Migrate once from that frozen score, then persist the result.
+                instabilityPlan = entry.contains(INSTABILITY_TAG, CompoundTag.TAG_COMPOUND)
+                        ? AgeInstabilityPlan.select(instability, entry.getLong(SEED_TAG))
+                        : AgeInstabilityPlan.empty();
+                data.setDirty();
+            }
             data.ages.put(id, new AgeDefinition(
                     id,
                     normalizedName(entry.getString(NAME_TAG)),
@@ -183,7 +212,9 @@ public final class AgeRegistrySavedData extends SavedData {
                             ? AgeGenerationPlan.load(entry.getCompound(PLAN_TAG)) : null,
                     entry.contains(SEASON_MODE_TAG, CompoundTag.TAG_STRING)
                             ? AgeSeasonMode.parseOrNull(entry.getString(SEASON_MODE_TAG)) : null,
-                    readRandomFeatures(entry)
+                    readRandomFeatures(entry),
+                    instability,
+                    instabilityPlan
             ));
         }
         return data;
@@ -228,6 +259,8 @@ public final class AgeRegistrySavedData extends SavedData {
                         entry.put(RANDOM_FEATURES_TAG, featureTags);
                     }
                     if (age.seasonMode() != null) entry.putString(SEASON_MODE_TAG, age.seasonMode().name());
+                    entry.put(INSTABILITY_TAG, age.instability().save());
+                    entry.put(INSTABILITY_PLAN_TAG, age.instabilityPlan().save());
                     serializedAges.add(entry);
                 });
         tag.put(AGES_TAG, serializedAges);

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,30 +60,33 @@ 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. */
     public static ResourceLocation selectForWriting(long seed, OrderedWriting writing, RegistryAccess registries) {
         ResourceLocation selected = select(seed);
         WritingGrammar.Result parsed = WritingGrammar.parse(writing);
-        if (parsed.symbols().stream().anyMatch(symbol ->
+        if (parsed.activeSymbols().stream().anyMatch(symbol ->
                 symbol.semantics().role() == SymbolSemantics.Role.TERRAIN)) return selected;
-        List<ResourceLocation> features = parsed.symbols().stream()
+        List<ResourceLocation> features = parsed.activeSymbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.FEATURE)
                 .map(symbol -> ((SymbolSemantics.ResourceValue) symbol.semantics().value()).id()).toList();
-        boolean hasMaterial = parsed.symbols().stream().anyMatch(symbol ->
+        boolean hasMaterial = parsed.activeSymbols().stream().anyMatch(symbol ->
                 symbol.semantics().role() == SymbolSemantics.Role.BLOCK);
         if ((features.isEmpty() && !hasMaterial) || PROFILES.isEmpty()) return selected;
         AgeRuntimeProfile initial = PROFILES.get(selected);
         if (initial != null && features.stream().allMatch(id ->
                 AgeFeatureSelection.error(id, initial, registries) == null)
-                && AgeFeatureSelection.supportsUnpairedMaterials(parsed, initial)) return selected;
+                && AgeFeatureSelection.supportsUnpairedMaterials(
+                        new WritingGrammar.Result(parsed.activeSymbols(), parsed.diagnostics()), initial)) return selected;
         List<ResourceLocation> compatible = PROFILES.entrySet().stream()
                 .filter(entry -> features.stream().allMatch(id ->
                         AgeFeatureSelection.error(id, entry.getValue(), registries) == null)
-                        && AgeFeatureSelection.supportsUnpairedMaterials(parsed, entry.getValue()))
+                        && AgeFeatureSelection.supportsUnpairedMaterials(
+                                new WritingGrammar.Result(parsed.activeSymbols(), parsed.diagnostics()), 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. */
@@ -28,7 +35,7 @@ public enum AgeSeasonMode {
     }
 
     public static boolean hasAuthoredPage(AgeGenerationPlan plan) {
-        return plan != null && plan.symbols().stream()
+        return plan != null && plan.activeSymbols().stream()
                 .anyMatch(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON);
     }
 
@@ -42,7 +49,7 @@ public enum AgeSeasonMode {
 
     public static AgeSeasonMode from(AgeGenerationPlan plan) {
         if (plan == null) return SEASONS;
-        return plan.symbols().stream()
+        return plan.activeSymbols().stream()
                 .filter(symbol -> symbol.semantics().role() == SymbolSemantics.Role.SEASON)
                 .map(symbol -> valueOf(((SymbolSemantics.ChoiceValue) symbol.semantics().value())
                         .id().toUpperCase(Locale.ROOT)))

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

@@ -0,0 +1,94 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.level.GameType;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Focused mapping, targeting, and isolation checks for issue #67. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class AgeStatusEffectGameTests {
+    private AgeStatusEffectGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void legacyPotionMappingRetainsShortDurationsAndSkyRule(GameTestHelper helper) {
+        helper.assertValueEqual(AgeStatusEffectProviders.legacyDuration(id("wither")), 30,
+                "Legacy Wither lasts only 30 ticks per application");
+        helper.assertValueEqual(AgeStatusEffectProviders.legacyDuration(id("poison_global")), 80,
+                "Global Poison retains Legacy's 80-tick duration");
+        helper.assertValueEqual(AgeStatusEffectProviders.legacyDuration(id("enemyregen_global")), 200,
+                "The enemy regeneration card retains its 200-tick duration");
+        helper.assertTrue(AgeStatusEffectProviders.localRequiresSky(id("poison"))
+                        && !AgeStatusEffectProviders.localRequiresSky(id("poison_global")),
+                "Only local potion cards require open sky");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void generalDebuffsIncludeLivingEntitiesButCreativePlayersAreExempt(GameTestHelper helper) {
+        var player = helper.makeMockPlayer(GameType.SURVIVAL);
+        var cow = helper.spawnWithNoFreeWill(EntityType.COW, new BlockPos(1, 1, 1));
+        var hostile = helper.spawnWithNoFreeWill(EntityType.SPIDER, new BlockPos(2, 1, 1));
+        helper.assertTrue(player.isAlive(), "Mock survival player must be alive");
+        helper.assertTrue(player.level() == helper.getLevel(), "Mock survival player must be in the test level");
+        helper.assertTrue(!player.isCreative() && !player.isSpectator(),
+                "Mock survival player must not be creative or spectator");
+        helper.assertTrue(RivencraftConfig.statusEffectsPlayers(), "Player status effects must be enabled");
+        helper.assertTrue(AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), player, id("poison_global")),
+                "A survival player is eligible for a general Legacy debuff");
+        helper.assertTrue(AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), cow, id("poison_global")),
+                "General Legacy debuffs are not limited to players");
+        helper.assertTrue(hostile.isAlive() && hostile.level() == helper.getLevel(),
+                "Mock hostile mob must be alive in the test level");
+        helper.assertTrue(RivencraftConfig.statusEffectsHostiles(), "Hostile status effects must be enabled");
+        helper.assertTrue(hostile.getEffect(MobEffects.REGENERATION) == null,
+                "Mock hostile mob must not already have regeneration");
+        helper.assertTrue(hostile.canBeAffected(new MobEffectInstance(MobEffects.REGENERATION, 200, 0)),
+                "Mock hostile mob must accept regeneration");
+        helper.assertTrue(AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), hostile,
+                        id("enemyregen_global")), "Hostile mobs can receive the enemy buff");
+        helper.assertTrue(!AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), cow,
+                        id("enemyregen_global")), "Passive mobs do not receive the adapted enemy buff");
+        var creative = helper.makeMockPlayer(GameType.CREATIVE);
+        helper.assertTrue(!AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), creative,
+                        id("poison_global")), "Creative players must be exempt");
+        var spectator = helper.makeMockPlayer(GameType.SPECTATOR);
+        helper.assertTrue(!AgeStatusEffectProviders.eligibleTarget(helper.getLevel(), spectator,
+                        id("poison_global")), "Spectators must be exempt");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void overworldCannotRunAnAgeStatusProvider(GameTestHelper helper) {
+        var player = helper.makeMockServerPlayerInLevel();
+        player.setGameMode(GameType.SURVIVAL);
+        UUID ageId = UUID.randomUUID();
+        AgeDefinition age = new AgeDefinition(ageId, "Isolated", 100L, AgeGenerationProfiles.STANDARD,
+                AgeDefinition.CURRENT_GENERATION_VERSION, 0L, AgeDefinition.dimensionId(ageId), null,
+                AgeTraits.LEGACY_DEFAULTS);
+        AgeInstabilityRuntime.Budget budget = new AgeInstabilityRuntime.Budget(1);
+        var context = new AgeInstabilityRuntime.Context(helper.getLevel(), age,
+                List.of(player.chunkPosition()), helper.getLevel().getServer().getTickCount(), budget);
+        AgeStatusEffectProviders.apply(context, id("poison_global"), 1);
+        helper.assertTrue(player.getEffect(MobEffects.POISON) == null,
+                "An Age provider must not apply in the Overworld");
+        helper.assertValueEqual(budget.remaining(), 1,
+                "A rejected cross-world attempt must not consume the Age budget");
+        helper.succeed();
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+}

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

@@ -0,0 +1,218 @@
+package net.dnorberg.rivencraft.book;
+
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
+import java.util.WeakHashMap;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.config.RivencraftConfig;
+import net.minecraft.core.Holder;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.effect.MobEffect;
+import net.minecraft.world.effect.MobEffectInstance;
+import net.minecraft.world.effect.MobEffects;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.LivingEntity;
+import net.minecraft.world.entity.monster.Monster;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.level.ChunkPos;
+import net.minecraft.world.level.entity.EntityTypeTest;
+import net.minecraft.world.phys.AABB;
+import net.neoforged.neoforge.event.entity.EntityTravelToDimensionEvent;
+import net.neoforged.neoforge.event.entity.player.PlayerEvent;
+import net.neoforged.neoforge.event.server.ServerStoppingEvent;
+import net.neoforged.neoforge.event.tick.ServerTickEvent;
+
+/** Legacy potion cards adapted to bounded, Age-local server effects. */
+public final class AgeStatusEffectProviders {
+    private static final int MAX_TRACKED_AGES = 64;
+    private static final Map<ResourceLocation, Spec> SPECS = createSpecs();
+    private static final Map<ServerLevel, List<Lease>> LEASES = new WeakHashMap<>();
+
+    private AgeStatusEffectProviders() {}
+
+    public static void register() {
+        SPECS.keySet().forEach(id -> AgeInstabilityRuntime.register(id, false, AgeStatusEffectProviders::apply));
+    }
+
+    static void apply(AgeInstabilityRuntime.Context context, ResourceLocation id, int level) {
+        if (!RivencraftConfig.statusEffectsEnabled()
+                || !AgeInstabilityRuntime.isAgeDimension(context.level().dimension().location())
+                || !context.age().dimensionId().equals(context.level().dimension().location())) return;
+        Spec spec = SPECS.get(id);
+        if (spec == null || spec.target() == Target.HOSTILE && !RivencraftConfig.statusEffectsHostiles()
+                || spec.target() == Target.GENERAL && !RivencraftConfig.statusEffectsPlayers()
+                && !RivencraftConfig.statusEffectsNonplayers()) return;
+        List<Lease> leases = LEASES.get(context.level());
+        if (leases == null) {
+            if (LEASES.size() >= MAX_TRACKED_AGES) return;
+            leases = new ArrayList<>();
+            LEASES.put(context.level(), leases);
+        }
+        prune(context.level(), leases, context.serverTick(), false);
+        if (leases.size() >= RivencraftConfig.statusEffectsMaxActive()) return;
+
+        Random random = new Random(context.age().seed() ^ (context.serverTick() * 0x9E3779B97F4A7C15L)
+                ^ id.hashCode());
+        ChunkPos chunk = context.loadedChunks().get(random.nextInt(context.loadedChunks().size()));
+        AABB bounds = new AABB(chunk.getMinBlockX(), context.level().getMinBuildHeight(), chunk.getMinBlockZ(),
+                chunk.getMaxBlockX() + 1, context.level().getMaxBuildHeight(), chunk.getMaxBlockZ() + 1);
+        int duration = Math.min(spec.legacyDuration(), RivencraftConfig.statusEffectsMaxDuration());
+        int amplifier = Math.max(0, level - 1);
+        MobEffectInstance instance = new MobEffectInstance(spec.effect(), duration, amplifier);
+        List<LivingEntity> candidates = new ArrayList<>();
+        context.level().getEntities(EntityTypeTest.forClass(LivingEntity.class), bounds,
+                entity -> eligible(context.level(), entity, spec, instance), candidates,
+                RivencraftConfig.statusEffectsMaxCandidates());
+        if (candidates.isEmpty()) return;
+        candidates.sort(Comparator.comparing(Entity::getUUID));
+        LivingEntity target = candidates.get(random.nextInt(candidates.size()));
+        if (!context.budget().claim() || !target.addEffect(instance)) return;
+        leases.add(new Lease(new WeakReference<>(target), instance,
+                context.serverTick() + duration, spec.target()));
+    }
+
+    private static boolean eligible(ServerLevel level, LivingEntity entity, Spec spec,
+                                    MobEffectInstance instance) {
+        if (!entity.isAlive() || entity.isRemoved() || entity.level() != level
+                || entity.getEffect(spec.effect()) != null || !entity.canBeAffected(instance)
+                || !spec.global() && !level.canSeeSky(entity.blockPosition())) return false;
+        return allowedByPolicy(spec.target(), entity);
+    }
+
+    private static boolean allowedByPolicy(Target target, LivingEntity entity) {
+        if (entity instanceof Player player) {
+            return target == Target.GENERAL && RivencraftConfig.statusEffectsPlayers()
+                    && !player.isCreative() && !player.isSpectator();
+        }
+        return target == Target.GENERAL ? RivencraftConfig.statusEffectsNonplayers()
+                : entity instanceof Monster && RivencraftConfig.statusEffectsHostiles();
+    }
+
+    public static void onServerTickPost(ServerTickEvent.Post event) {
+        if (event.getServer().getTickCount() % 20 != 0) return;
+        boolean disabled = !RivencraftConfig.instabilityEnabled() || !RivencraftConfig.statusEffectsEnabled();
+        long tick = event.getServer().getTickCount();
+        for (var entry : LEASES.entrySet()) prune(entry.getKey(), entry.getValue(), tick, disabled);
+        LEASES.values().removeIf(List::isEmpty);
+    }
+
+    public static void onEntityTravel(EntityTravelToDimensionEvent event) {
+        Entity entity = event.getEntity();
+        if (entity instanceof LivingEntity living && !entity.level().dimension().equals(event.getDimension())) {
+            clearEntity(living);
+        }
+    }
+
+    public static void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) clearEntity(player);
+    }
+
+    public static void onPlayerLoggedOut(PlayerEvent.PlayerLoggedOutEvent event) {
+        if (event.getEntity() instanceof ServerPlayer player) clearEntity(player);
+    }
+
+    public static void onServerStopping(ServerStoppingEvent event) {
+        long tick = event.getServer().getTickCount();
+        for (var entry : LEASES.entrySet()) prune(entry.getKey(), entry.getValue(), tick, true);
+        LEASES.clear();
+    }
+
+    private static void clearEntity(LivingEntity entity) {
+        for (List<Lease> leases : LEASES.values()) {
+            Iterator<Lease> iterator = leases.iterator();
+            while (iterator.hasNext()) {
+                Lease lease = iterator.next();
+                if (lease.entity().get() != entity) continue;
+                removeOwnedEffect(entity, lease);
+                iterator.remove();
+            }
+        }
+    }
+
+    private static void prune(ServerLevel level, List<Lease> leases, long tick, boolean removeAll) {
+        Iterator<Lease> iterator = leases.iterator();
+        while (iterator.hasNext()) {
+            Lease lease = iterator.next();
+            LivingEntity entity = lease.entity().get();
+            if (entity == null || entity.isRemoved() || entity.getEffect(lease.instance().getEffect()) == null) {
+                iterator.remove();
+                continue;
+            }
+            boolean revoke = removeAll || entity.level() != level
+                    || !allowedByPolicy(lease.target(), entity);
+            if (revoke || tick >= lease.expiresAt()) {
+                removeOwnedEffect(entity, lease);
+                iterator.remove();
+            }
+        }
+    }
+
+    private static void removeOwnedEffect(LivingEntity entity, Lease lease) {
+        // addEffect stores the supplied instance when no effect exists. Do not remove
+        // a replacement from another mod (or a stronger/extended effect).
+        if (entity.getEffect(lease.instance().getEffect()) == lease.instance()
+                && lease.instance().getAmplifier() == lease.amplifier()
+                && lease.instance().getDuration() <= lease.originalDuration()) {
+            entity.removeEffect(lease.instance().getEffect());
+        }
+    }
+
+    static int legacyDuration(ResourceLocation id) {
+        Spec spec = SPECS.get(id);
+        return spec == null ? -1 : spec.legacyDuration();
+    }
+
+    static boolean localRequiresSky(ResourceLocation id) {
+        Spec spec = SPECS.get(id);
+        return spec != null && !spec.global();
+    }
+
+    static boolean eligibleTarget(ServerLevel level, LivingEntity entity, ResourceLocation id) {
+        Spec spec = SPECS.get(id);
+        return spec != null && eligible(level, entity, spec,
+                new MobEffectInstance(spec.effect(), spec.legacyDuration(), 0));
+    }
+
+    private static Map<ResourceLocation, Spec> createSpecs() {
+        Map<ResourceLocation, Spec> specs = new HashMap<>();
+        addPair(specs, "blindness", MobEffects.BLINDNESS, 60);
+        addPair(specs, "fatigue", MobEffects.DIG_SLOWDOWN, 80);
+        addPair(specs, "hunger", MobEffects.HUNGER, 80);
+        addPair(specs, "nausea", MobEffects.CONFUSION, 60);
+        addPair(specs, "poison", MobEffects.POISON, 80);
+        addPair(specs, "slow", MobEffects.MOVEMENT_SLOWDOWN, 80);
+        addPair(specs, "weakness", MobEffects.WEAKNESS, 80);
+        addPair(specs, "wither", MobEffects.WITHER, 30);
+        specs.put(id("enemyregen_global"), new Spec(MobEffects.REGENERATION, 200, true, Target.HOSTILE));
+        specs.put(id("enemyresist_global"), new Spec(MobEffects.DAMAGE_RESISTANCE, 200, true, Target.HOSTILE));
+        return Map.copyOf(specs);
+    }
+
+    private static void addPair(Map<ResourceLocation, Spec> specs, String name,
+                                Holder<MobEffect> effect, int duration) {
+        specs.put(id(name), new Spec(effect, duration, false, Target.GENERAL));
+        specs.put(id(name + "_global"), new Spec(effect, duration, true, Target.GENERAL));
+    }
+
+    private static ResourceLocation id(String path) {
+        return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path);
+    }
+
+    private enum Target { GENERAL, HOSTILE }
+    private record Spec(Holder<MobEffect> effect, int legacyDuration, boolean global, Target target) {}
+    private record Lease(WeakReference<LivingEntity> entity, MobEffectInstance instance, long expiresAt,
+                         Target target, int amplifier, int originalDuration) {
+        private Lease(WeakReference<LivingEntity> entity, MobEffectInstance instance, long expiresAt,
+                      Target target) {
+            this(entity, instance, expiresAt, target, instance.getAmplifier(), instance.getDuration());
+        }
+    }
+}

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/CloudPlatformGameTests.java

@@ -0,0 +1,27 @@
+package net.dnorberg.rivencraft.book;
+
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class CloudPlatformGameTests {
+    private CloudPlatformGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void cloudIsSolidFootingWithoutAnObtainableItem(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        var state = ModBlocks.CLOUD_PLATFORM.get().defaultBlockState();
+        helper.getLevel().setBlock(pos, state, 2);
+        helper.assertTrue(!state.getCollisionShape(helper.getLevel(), pos).isEmpty(),
+                "Cloud platform must support a standing player");
+        helper.assertTrue(ModBlocks.CLOUD_PLATFORM.get().getCloneItemStack(helper.getLevel(), pos, state).isEmpty(),
+                "Cloud platform must not provide a pick-block item");
+        helper.succeed();
+    }
+}

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

@@ -91,8 +91,10 @@ public final class EnvironmentWritingGameTests {
                 AgeSeasonMode.NO_SEASONS, "The Age's seasonal policy must survive reload");
         OrderedWriting conflict = new OrderedWriting(List.of(WritingEntry.linkPanel(),
                 page("season/no_seasons"), page("season/eternal_winter")));
-        helper.assertFalse(WritingGrammar.parse(conflict).canCreate(),
-                "Only one seasonal page may be used in an Age");
+        helper.assertTrue(WritingGrammar.parse(conflict).canCreate(),
+                "A repeated seasonal page must be recoverable as unstable writing");
+        helper.assertValueEqual(WritingGrammar.parse(conflict).writingInstability(), 500,
+                "The seasonal conflict must contribute instability");
         helper.succeed();
     }
 

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() {}
@@ -33,7 +35,14 @@ public final class FeatureWritingGameTests {
                 "feature/huge_trees", "feature/rocks", "feature/lava_lakes",
                 "feature/surface_lakes", "feature/deep_lakes", "feature/ravines",
                 "feature/floating_islands", "feature/tendrils", "feature/skylands",
-                "feature/spheres", "feature/spikes");
+                "feature/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) {
@@ -64,7 +73,11 @@ public final class FeatureWritingGameTests {
                     || AgeFeatureSelection.tendrils(choice.id())
                     || AgeFeatureSelection.skylands(choice.id())
                     || AgeFeatureSelection.spheres(choice.id())
-                    || AgeFeatureSelection.spikes(choice.id())) continue;
+                    || 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(),
@@ -176,8 +189,10 @@ public final class FeatureWritingGameTests {
             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())),
-                    "Cave random Ages must not choose incompatible surface features");
+                            || 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");
@@ -410,7 +425,8 @@ public final class FeatureWritingGameTests {
                             || AgeFeatureSelection.floatingIslands(choices.getFirst().id())
                             || AgeFeatureSelection.tendrils(choices.getFirst().id())
                             || AgeFeatureSelection.spheres(choices.getFirst().id())
-                            || AgeFeatureSelection.spikes(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");
@@ -445,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/InstabilityProviderCatalog.java

@@ -0,0 +1,74 @@
+package net.dnorberg.rivencraft.book;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.minecraft.resources.ResourceLocation;
+
+/** Frozen Legacy 0.13.7.06 deck cards and default activation costs, not effect implementations. */
+public final class InstabilityProviderCatalog {
+    public enum Deck {
+        BASIC(0), HARSH(2_500), DESTRUCTIVE(10_000), EATING(15_000), DEATH(20_000);
+
+        private final int entryCost;
+
+        Deck(int entryCost) { this.entryCost = entryCost; }
+        public int entryCost() { return entryCost; }
+    }
+
+    public record Card(ResourceLocation id, int cost) {
+        public Card {
+            if (cost <= 0) throw new IllegalArgumentException("Provider cost must be positive");
+        }
+    }
+
+    private static final List<List<Card>> DECKS = createDecks();
+
+    private InstabilityProviderCatalog() {}
+
+    public static List<Card> cards(Deck deck) { return DECKS.get(deck.ordinal()); }
+
+    public static boolean contains(ResourceLocation id) {
+        return DECKS.stream().flatMap(List::stream).anyMatch(card -> card.id().equals(id));
+    }
+
+    private static List<List<Card>> createDecks() {
+        List<List<Card>> decks = new ArrayList<>();
+        for (Deck ignored : Deck.values()) decks.add(new ArrayList<>());
+        add(decks, "blindness", 1000, 0, 0, 0, 1, 0);
+        add(decks, "blindness_global", 1500, 0, 0, 0, 0, 1);
+        add(decks, "enemyregen_global", 1000, 5, 2, 0, 0, 0);
+        add(decks, "enemyresist_global", 1000, 2, 1, 0, 0, 0);
+        add(decks, "fatigue", 500, 5, 0, 0, 0, 0);
+        add(decks, "fatigue_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "hunger", 500, 8, 2, 0, 0, 0);
+        add(decks, "hunger_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "nausea", 1000, 0, 0, 0, 1, 0);
+        add(decks, "nausea_global", 1500, 0, 0, 0, 0, 1);
+        add(decks, "poison", 500, 9, 3, 0, 0, 0);
+        add(decks, "poison_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "slow", 500, 6, 1, 0, 0, 0);
+        add(decks, "slow_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "weakness", 500, 8, 2, 0, 0, 0);
+        add(decks, "weakness_global", 1000, 0, 5, 0, 0, 0);
+        add(decks, "wither", 1000, 0, 1, 1, 2, 0);
+        add(decks, "wither_global", 2000, 0, 0, 1, 1, 1);
+        add(decks, "burning", 500, 0, 1, 0, 0, 0);
+        add(decks, "crumble", 2000, 0, 0, 6, 0, 0);
+        add(decks, "decayblue", 2000, 0, 0, 0, 2, 1);
+        add(decks, "decaypurple", 2000, 0, 0, 0, 2, 1);
+        add(decks, "decayred", 2000, 0, 0, 0, 2, 1);
+        add(decks, "decaywhite", 5000, 0, 0, 0, 1, 3);
+        add(decks, "explosions", 1000, 0, 0, 8, 0, 0);
+        add(decks, "lightning", 1000, 0, 4, 4, 0, 0);
+        add(decks, "meteors", 1000, 0, 0, 4, 0, 0);
+        return decks.stream().map(List::copyOf).toList();
+    }
+
+    private static void add(List<List<Card>> decks, String path, int cost, int... copies) {
+        Card card = new Card(ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path), cost);
+        for (Deck deck : Deck.values()) {
+            for (int copy = 0; copy < copies[deck.ordinal()]; copy++) decks.get(deck.ordinal()).add(card);
+        }
+    }
+}

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/book/TerrainWritingGameTests.java

@@ -1,5 +1,7 @@
 package net.dnorberg.rivencraft.book;
 
+import net.dnorberg.rivencraft.registry.ModBlocks;
+
 import com.google.gson.JsonParser;
 import java.util.List;
 import java.util.UUID;
@@ -250,7 +252,7 @@ public final class TerrainWritingGameTests {
             helper.assertTrue(level != null, "The written Age must create a runtime dimension");
             assertGenerator(helper, level, age.plan().runtimeProfile());
             BlockPos spawn = target.location().pos();
-            helper.assertTrue(level.getBlockState(spawn.below()).is(Blocks.COBBLESTONE)
+            helper.assertTrue(level.getBlockState(spawn.below()).is(ModBlocks.CLOUD_PLATFORM.get())
                             && level.getBlockState(spawn).isAir()
                             && level.getBlockState(spawn.above()).isAir(),
                     "Every written terrain family must retain a safe arrival platform");

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,19 @@ 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());
+            ItemBlockRenderTypes.setRenderLayer(ModBlocks.CLOUD_PLATFORM.get(), RenderType.translucent());
+        });
         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/BookBinderScreen.java

@@ -6,6 +6,7 @@ import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
 import net.dnorberg.rivencraft.item.PageItem;
 import net.dnorberg.rivencraft.menu.BookBinderMenu;
 import net.dnorberg.rivencraft.network.SetBookBinderTitlePayload;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
 import net.minecraft.client.gui.GuiGraphics;
 import net.minecraft.client.gui.components.EditBox;
 import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
@@ -106,14 +107,33 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
         }
         graphics.disableScissor();
         drawScrollEnds(graphics);
+        var severity = menu.grammarSeverity().orElse(null);
+        Component status = severity == WritingGrammar.Severity.FATAL
+                ? Component.translatable("screen.rivencraft.book_binder.status.fatal")
+                : severity == WritingGrammar.Severity.INSTABILITY
+                ? Component.translatable("screen.rivencraft.book_binder.status.unstable", menu.grammarInstability())
+                : severity == WritingGrammar.Severity.SEEDED_COMPLETION
+                ? Component.translatable("screen.rivencraft.book_binder.status.seeded") : null;
+        if (status != null) graphics.drawString(font, status, leftPos + 77, topPos + 30,
+                severity == WritingGrammar.Severity.FATAL ? 0xFFAA3030
+                        : severity == WritingGrammar.Severity.INSTABILITY ? 0xFF924F18 : 0xFF50624B, false);
         Component grammarTooltip = menu.grammarError().map(code -> Component.translatable(
                 "screen.rivencraft.book_binder.grammar." + code.name().toLowerCase(Locale.ROOT),
                 errorStripIndex + 1)).orElse(null);
-        if (menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty()
-                && mouseX >= leftPos + 152 && mouseX < leftPos + 168
+        if (grammarTooltip != null && ((mouseX >= leftPos + 77 && mouseX < leftPos + 151)
+                || (mouseX >= leftPos + 152 && mouseX < leftPos + 168))
                 && mouseY >= topPos + 27 && mouseY < topPos + 43
-                && grammarTooltip != null) {
-            graphics.renderTooltip(font, grammarTooltip, mouseX, mouseY);
+                && (status != null || menu.getSlot(BookBinderMenu.RESULT).getItem().isEmpty())) {
+            java.util.List<Component> details = new java.util.ArrayList<>();
+            if (status != null) details.add(status);
+            details.add(grammarTooltip);
+            if (menu.grammarInstability() > 0 && severity != WritingGrammar.Severity.INSTABILITY)
+                details.add(Component.translatable("screen.rivencraft.book_binder.status.unstable",
+                        menu.grammarInstability()));
+            if (menu.grammarIncompleteCount() > 0 && severity != WritingGrammar.Severity.SEEDED_COMPLETION)
+                details.add(Component.translatable("screen.rivencraft.book_binder.status.seeded_count",
+                        menu.grammarIncompleteCount()));
+            graphics.renderComponentTooltip(font, details, mouseX, mouseY);
             return;
         }
         if (mouseY >= topPos + STRIP_Y && mouseY < topPos + STRIP_Y + STRIP_HEIGHT) {
@@ -169,7 +189,8 @@ public final class BookBinderScreen extends AbstractContainerScreen<BookBinderMe
             case SYMBOL, UNRESOLVED_SYMBOL -> graphics.blit(NotebookScreen.symbolTexture(page),
                     x + 1, y + 5, 24, 24, 0, 0, 128, 128, 128, 128);
         }
-        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()) {
+        if (index == menu.grammarErrorStripIndex() && menu.grammarError().isPresent()
+                && !menu.grammarWarning()) {
             graphics.fill(x, y, x + PAGE_WIDTH, y + PAGE_HEIGHT, 0x55FF2020);
             graphics.renderOutline(x, y, PAGE_WIDTH, PAGE_HEIGHT, 0xFFFF3030);
         }

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

@@ -16,6 +16,7 @@ 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;
@@ -226,6 +227,22 @@ public final class DescriptiveBookScreen extends Screen implements ExplorableBoo
                     x, top + 40, 110);
             drawWrappedWithoutShadow(graphics, Component.translatable("screen.rivencraft.age.name_prompt"),
                     x, top + 52, 110);
+            WritingGrammar.Result grammar = WritingGrammar.parse(writing);
+            boolean unresolved = writingSymbols.stream().anyMatch(display -> !display.resolved());
+            if (!grammar.canCreate() || unresolved) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.fatal"),
+                        x, top + 132, 110, UNRESOLVED_TEXT_COLOR);
+            } else if (grammar.writingInstability() > 0) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.unstable",
+                                grammar.writingInstability()), x, top + 132, 110);
+            }
+            if (grammar.firstIncomplete().isPresent()) {
+                drawWrappedWithoutShadow(graphics,
+                        Component.translatable("screen.rivencraft.age.writing.seeded"),
+                        x, top + 145, 110);
+            }
             return;
         }
         int nameEnd = drawWrappedWithoutShadow(graphics, Component.literal(age.name()),

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/command/RivencraftCommands.java

@@ -1,7 +1,10 @@
 package net.dnorberg.rivencraft.command;
 
 import com.mojang.brigadier.arguments.StringArgumentType;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import net.dnorberg.rivencraft.block.DecayBlock;
 import net.dnorberg.rivencraft.book.AgeDefinition;
+import net.dnorberg.rivencraft.book.AgeDecayProviders;
 import net.dnorberg.rivencraft.book.AgeDimensionService;
 import net.dnorberg.rivencraft.book.AgeRegistrySavedData;
 import net.minecraft.commands.Commands;
@@ -30,7 +33,20 @@ public final class RivencraftCommands {
                                         .executes(context -> unloadAge(
                                                 context.getSource(),
                                                 StringArgumentType.getString(context, "dimension")
-                                        ))))));
+                                        ))))
+                        .then(Commands.literal("decay")
+                                .then(Commands.literal("pulse")
+                                        .then(Commands.argument("color", StringArgumentType.word())
+                                                .suggests((context, builder) -> {
+                                                    for (DecayBlock.Color color : DecayBlock.Color.values()) {
+                                                        builder.suggest(color.getSerializedName());
+                                                    }
+                                                    return builder.buildFuture();
+                                                })
+                                                .then(Commands.argument("attempts", IntegerArgumentType.integer(1, 32))
+                                                        .executes(context -> pulseDecay(context.getSource(),
+                                                                StringArgumentType.getString(context, "color"),
+                                                                IntegerArgumentType.getInteger(context, "attempts")))))))));
     }
 
     private static int listAges(net.minecraft.commands.CommandSourceStack source) {
@@ -80,4 +96,26 @@ public final class RivencraftCommands {
             }
         };
     }
+
+    private static int pulseDecay(net.minecraft.commands.CommandSourceStack source, String colorName, int attempts) {
+        DecayBlock.Color color;
+        try {
+            color = DecayBlock.Color.valueOf(colorName.toUpperCase(java.util.Locale.ROOT));
+        } catch (IllegalArgumentException exception) {
+            source.sendFailure(Component.literal("Unknown decay color: " + colorName));
+            return 0;
+        }
+        if (source.getPlayer() == null) {
+            source.sendFailure(Component.literal("Run this command as a player standing in an Age."));
+            return 0;
+        }
+        int changed = AgeDecayProviders.pulseForTesting(source.getPlayer(), color, attempts);
+        if (changed < 0) {
+            source.sendFailure(Component.literal("Enter a loaded Age and enable instability.world_mutation and instability_decay.enabled first."));
+            return 0;
+        }
+        source.sendSuccess(() -> Component.literal("Decay " + colorName + ": " + changed
+                + " block(s) converted in " + attempts + " bounded attempt(s)."), true);
+        return changed;
+    }
 }

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

@@ -18,6 +18,23 @@ public final class RivencraftConfig {
     private static final ModConfigSpec.IntValue SYMBOL_INK_COST;
     private static final ModConfigSpec.IntValue LINK_PANEL_INK_COST;
     private static final ModConfigSpec.BooleanValue AUTO_WHITELIST_SERENE_AGES;
+    private static final ModConfigSpec.BooleanValue INSTABILITY_ENABLED;
+    private static final ModConfigSpec.BooleanValue INSTABILITY_WORLD_MUTATION;
+    private static final ModConfigSpec.IntValue INSTABILITY_COOLDOWN;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_AGES;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_PROVIDERS;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_ACTIONS;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_LEVEL;
+    private static final ModConfigSpec.IntValue INSTABILITY_MAX_CHUNKS;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_ENABLED;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_PLAYERS;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_NONPLAYERS;
+    private static final ModConfigSpec.BooleanValue STATUS_EFFECTS_HOSTILES;
+    private static final ModConfigSpec.IntValue STATUS_EFFECTS_MAX_ACTIVE;
+    private static final ModConfigSpec.IntValue STATUS_EFFECTS_MAX_CANDIDATES;
+    private static final ModConfigSpec.IntValue STATUS_EFFECTS_MAX_DURATION;
+    private static final ModConfigSpec.BooleanValue DECAY_ENABLED;
+    private static final ModConfigSpec.IntValue DECAY_MAX_ATTEMPTS;
 
     static {
         ModConfigSpec.Builder builder = new ModConfigSpec.Builder();
@@ -40,6 +57,46 @@ public final class RivencraftConfig {
                 "Existing entries are preserved; disabling this does not remove previously added Ages."
         ).define("auto_whitelist_ages", true);
         builder.pop();
+        builder.push("instability");
+        INSTABILITY_ENABLED = builder.comment("Run selected instability providers in loaded Ages. Disabling does not alter saved plans.")
+                .define("enabled", true);
+        INSTABILITY_WORLD_MUTATION = builder.comment("Allow selected instability providers to change blocks or create explosions, as in Legacy.")
+                .define("world_mutation", true);
+        INSTABILITY_COOLDOWN = builder.comment("Minimum ticks between instability runs for each loaded Age.")
+                .defineInRange("cooldown_ticks", 20, 20, 1200);
+        INSTABILITY_MAX_AGES = builder.comment("Maximum loaded Ages processed in one server tick.")
+                .defineInRange("max_ages_per_tick", 4, 1, 16);
+        INSTABILITY_MAX_PROVIDERS = builder.comment("Maximum provider handlers called in one Age run.")
+                .defineInRange("max_providers_per_age", 2, 1, 16);
+        INSTABILITY_MAX_ACTIONS = builder.comment("Shared effect-action budget for one Age run.")
+                .defineInRange("max_actions_per_age", 1, 1, 16);
+        INSTABILITY_MAX_LEVEL = builder.comment("Maximum effective level passed to an effect handler; saved levels are unchanged.")
+                .defineInRange("max_effect_level", 3, 1, 16);
+        INSTABILITY_MAX_CHUNKS = builder.comment("Maximum already-loaded candidate chunks inspected per Age run.")
+                .defineInRange("max_loaded_chunks", 16, 1, 64);
+        builder.pop();
+        builder.push("instability_status_effects");
+        STATUS_EFFECTS_ENABLED = builder.comment("Allow bounded instability status effects in loaded Ages.")
+                .define("enabled", true);
+        STATUS_EFFECTS_PLAYERS = builder.comment("Allow instability status effects on survival/adventure players.")
+                .define("affect_players", true);
+        STATUS_EFFECTS_NONPLAYERS = builder.comment("Allow general instability status effects on non-player living entities, as in Legacy.")
+                .define("affect_nonplayers", true);
+        STATUS_EFFECTS_HOSTILES = builder.comment("Allow regeneration and resistance on hostile mobs.")
+                .define("buff_hostiles", true);
+        STATUS_EFFECTS_MAX_ACTIVE = builder.comment("Maximum Rivencraft-owned active effect leases per Age.")
+                .defineInRange("max_active_per_age", 32, 1, 128);
+        STATUS_EFFECTS_MAX_CANDIDATES = builder.comment("Maximum living entities examined in one chosen loaded chunk.")
+                .defineInRange("max_candidates_per_attempt", 8, 1, 16);
+        STATUS_EFFECTS_MAX_DURATION = builder.comment("Maximum duration in ticks for one instability status effect.")
+                .defineInRange("max_duration_ticks", 200, 20, 200);
+        builder.pop();
+        builder.push("instability_decay");
+        DECAY_ENABLED = builder.comment("Allow destructive colored decay inside loaded Ages, as in Legacy. Also requires instability.world_mutation.")
+                .define("enabled", true);
+        DECAY_MAX_ATTEMPTS = builder.comment("Maximum six-neighbor decay conversion attempts per provider call; at most one block changes.")
+                .defineInRange("max_attempts_per_call", 4, 1, 6);
+        builder.pop();
         SPEC = builder.build();
     }
 
@@ -61,4 +118,22 @@ public final class RivencraftConfig {
     public static boolean autoWhitelistSereneAges() {
         return AUTO_WHITELIST_SERENE_AGES.get();
     }
+
+    public static boolean instabilityEnabled() { return INSTABILITY_ENABLED.get(); }
+    public static boolean instabilityWorldMutation() { return INSTABILITY_WORLD_MUTATION.get(); }
+    public static int instabilityCooldown() { return INSTABILITY_COOLDOWN.get(); }
+    public static int instabilityMaxAges() { return INSTABILITY_MAX_AGES.get(); }
+    public static int instabilityMaxProviders() { return INSTABILITY_MAX_PROVIDERS.get(); }
+    public static int instabilityMaxActions() { return INSTABILITY_MAX_ACTIONS.get(); }
+    public static int instabilityMaxLevel() { return INSTABILITY_MAX_LEVEL.get(); }
+    public static int instabilityMaxChunks() { return INSTABILITY_MAX_CHUNKS.get(); }
+    public static boolean statusEffectsEnabled() { return STATUS_EFFECTS_ENABLED.get(); }
+    public static boolean statusEffectsPlayers() { return STATUS_EFFECTS_PLAYERS.get(); }
+    public static boolean statusEffectsNonplayers() { return STATUS_EFFECTS_NONPLAYERS.get(); }
+    public static boolean statusEffectsHostiles() { return STATUS_EFFECTS_HOSTILES.get(); }
+    public static int statusEffectsMaxActive() { return STATUS_EFFECTS_MAX_ACTIVE.get(); }
+    public static int statusEffectsMaxCandidates() { return STATUS_EFFECTS_MAX_CANDIDATES.get(); }
+    public static int statusEffectsMaxDuration() { return STATUS_EFFECTS_MAX_DURATION.get(); }
+    public static boolean decayEnabled() { return DECAY_ENABLED.get(); }
+    public static int decayMaxAttempts() { return DECAY_MAX_ATTEMPTS.get(); }
 }

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");
@@ -109,21 +108,22 @@ public final class BookBinderGameTests {
         binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
         binder.setItem(BookBinderBlockEntity.FIRST_PAGE, terrainPage());
         binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 5, terrainPage());
-        helper.assertFalse(binder.canAssemble(), "Duplicate terrain must not assemble a new Age");
-        int errorEntry = binder.writingGrammar().firstError().orElseThrow().index();
+        helper.assertTrue(binder.canAssemble(), "Duplicate terrain must create an unstable Age");
+        int errorEntry = binder.writingGrammar().firstWarning().orElseThrow().index();
         helper.assertValueEqual(errorEntry, 2, "Parser must identify the second authored symbol");
         helper.assertValueEqual(binder.writingStripIndex(errorEntry), 6,
-                "A grammar error must highlight the correct strip page despite empty positions");
-        helper.assertFalse(binder.consumeAssembly(), "Rejected grammar must not consume binder inputs");
+                "An instability warning must highlight the correct strip page despite empty positions");
+        helper.assertValueEqual(binder.writingGrammar().writingInstability(), 500,
+                "An extra controller must carry a persisted writing penalty");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER),
-                "Rejected grammar must leave the cover recoverable");
+                "Warning preview must not consume the cover");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.LINK_PANEL).is(ModItems.PAGE.get()),
-                "Rejected grammar must leave the Link Panel recoverable");
+                "Warning preview must not consume the Link Panel");
         helper.assertTrue(binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 5).is(ModItems.PAGE.get()),
-                "Rejected grammar must leave the duplicate page removable");
+                "Unstable writing must remain editable before assembly");
         ItemStack removed = binder.takePage(5);
-        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to correct the duplicate page");
-        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must become assemblable");
+        helper.assertTrue(removed.is(ModItems.PAGE.get()), "Player must be able to remove the duplicate page");
+        helper.assertTrue(binder.canAssemble(), "Corrected partial writing must remain assemblable");
         helper.succeed();
     }
 

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

@@ -0,0 +1,68 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.ArrayList;
+import java.util.List;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.NotebookContents;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class BookPageCapacityGameTests {
+    private BookPageCapacityGameTests() {}
+
+    private static ItemStack page(String path) {
+        return PageItem.createSymbolPage(new SymbolReference(
+                ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, path)));
+    }
+
+    @GameTest(template = "empty")
+    public static void binderAndNotebookRetainPagesBeyondOldLimit(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.BOOK_BINDER.get().defaultBlockState(), 3);
+        BookBinderBlockEntity binder = (BookBinderBlockEntity) helper.getLevel().getBlockEntity(pos);
+        binder.setTitle("Long Age");
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        for (int index = 0; index < 32; index++) {
+            helper.assertTrue(binder.insertPage(index, page("terrain/standard")),
+                    "Binder must accept page " + (index + 1));
+        }
+        binder.setItem(BookBinderBlockEntity.SIZE - 1, page("weather/normal"));
+        BookBinderBlockEntity restored = new BookBinderBlockEntity(pos, binder.getBlockState());
+        restored.setLevel(helper.getLevel());
+        restored.loadWithComponents(binder.saveWithoutMetadata(helper.getLevel().registryAccess()),
+                helper.getLevel().registryAccess());
+        helper.assertValueEqual(restored.nextPageIndex(), BookBinderBlockEntity.PAGE_COUNT,
+                "Binder must retain its highest valid page position after reload");
+        helper.assertTrue(restored.getItem(BookBinderBlockEntity.FIRST_PAGE + 31).is(ModItems.PAGE.get()),
+                "Page 32 must survive reload");
+        helper.assertTrue(restored.getItem(BookBinderBlockEntity.SIZE - 1).is(ModItems.PAGE.get()),
+                "The final fixed-slot page must survive reload");
+        helper.assertValueEqual(restored.writingGrammar().symbols().size(), 33,
+                "Grammar must retain all authored pages");
+
+        List<ItemStack> notebookPages = new ArrayList<>();
+        for (int index = 0; index < NotebookContents.MAX_PAGES; index++) notebookPages.add(ItemStack.EMPTY);
+        notebookPages.set(31, page("terrain/standard"));
+        notebookPages.set(NotebookContents.MAX_PAGES - 1, page("weather/normal"));
+        NotebookContents notebook = new NotebookContents(notebookPages);
+        helper.assertValueEqual(notebook.pages().size(), NotebookContents.MAX_PAGES,
+                "Notebook must retain its highest valid page position");
+        helper.assertValueEqual(notebook.pageCount(), 2,
+                "Sparse Notebook contents must retain both pages");
+        helper.succeed();
+    }
+}

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

@@ -101,6 +101,11 @@ public final class CoreGameTests {
         helper.assertFalse(BiomeSymbolPages.symbolId(ResourceLocation.parse("example:orchard"))
                         .equals(BiomeSymbolPages.symbolId(ResourceLocation.parse("another:orchard"))),
                 "Equal biome paths from different mods must not share a page ID");
+        helper.assertFalse(BiomeSymbolPages.isPublicPageBiome(
+                        ResourceLocation.parse("terrablender:deferred_placeholder")),
+                "TerraBlender's internal staging biome must not appear as a creative or JEI page");
+        helper.assertTrue(BiomeSymbolPages.isPublicPageBiome(ResourceLocation.parse("biomesoplenty:orchard")),
+                "Real modded biome pages must remain visible");
         helper.succeed();
     }
 

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

@@ -1,5 +1,7 @@
 package net.dnorberg.rivencraft.gametest;
 
+import net.dnorberg.rivencraft.registry.ModBlocks;
+
 import net.dnorberg.rivencraft.Rivencraft;
 import net.dnorberg.rivencraft.book.AgeDefinition;
 import net.dnorberg.rivencraft.book.AgeBiomeSelection;
@@ -234,7 +236,7 @@ public final class LinkingGameTests {
             helper.assertValueEqual(ageLevel.getSeed(), definition.seed(),
                     "The runtime dimension seed must match the persisted Age definition");
             BlockPos spawn = target.location().pos();
-            helper.assertTrue(ageLevel.getBlockState(spawn.below()).is(Blocks.COBBLESTONE),
+            helper.assertTrue(ageLevel.getBlockState(spawn.below()).is(ModBlocks.CLOUD_PLATFORM.get()),
                     "The generated Age must have a cobblestone arrival platform");
             helper.assertTrue(ageLevel.getBlockState(spawn).isAir() && ageLevel.getBlockState(spawn.above()).isAir(),
                     "The generated Age arrival must have clear headroom");
@@ -242,7 +244,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();
@@ -284,7 +287,7 @@ public final class LinkingGameTests {
             var ageLevel = player.getServer().getLevel(destination.location().dimension());
             helper.assertTrue(ageLevel != null, profile + " must create a loaded runtime dimension");
             BlockPos spawn = destination.location().pos();
-            helper.assertTrue(ageLevel != null && ageLevel.getBlockState(spawn.below()).is(Blocks.COBBLESTONE),
+            helper.assertTrue(ageLevel != null && ageLevel.getBlockState(spawn.below()).is(ModBlocks.CLOUD_PLATFORM.get()),
                     profile + " must create a solid arrival platform");
             helper.assertTrue(ageLevel != null && ageLevel.getBlockState(spawn).isAir()
                             && ageLevel.getBlockState(spawn.above()).isAir(),

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

@@ -0,0 +1,106 @@
+package net.dnorberg.rivencraft.gametest;
+
+import java.util.List;
+import java.util.UUID;
+import net.dnorberg.rivencraft.Rivencraft;
+import net.dnorberg.rivencraft.block.entity.BookBinderBlockEntity;
+import net.dnorberg.rivencraft.book.AgeReference;
+import net.dnorberg.rivencraft.item.PageItem;
+import net.dnorberg.rivencraft.registry.ModBlocks;
+import net.dnorberg.rivencraft.registry.ModDataComponents;
+import net.dnorberg.rivencraft.registry.ModItems;
+import net.dnorberg.rivencraft.writing.OrderedWriting;
+import net.dnorberg.rivencraft.writing.SymbolReference;
+import net.dnorberg.rivencraft.writing.WritingEntry;
+import net.dnorberg.rivencraft.writing.WritingGrammar;
+import net.minecraft.core.BlockPos;
+import net.minecraft.gametest.framework.GameTest;
+import net.minecraft.gametest.framework.GameTestHelper;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.neoforged.neoforge.gametest.GameTestHolder;
+import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
+
+/** Focused classification and transaction checks for Milestone 6 issue #65. */
+@GameTestHolder(Rivencraft.MOD_ID)
+@PrefixGameTestTemplate(false)
+public final class Milestone6GrammarGameTests {
+    private Milestone6GrammarGameTests() {}
+
+    @GameTest(template = "empty")
+    public static void writingOutcomesAreDistinct(GameTestHelper helper) {
+        var terrain = symbol("rivencraft:terrain/standard");
+        var weather = symbol("rivencraft:weather/normal");
+        var missing = symbol("example:missing_definition");
+        var fatal = WritingGrammar.parse(new OrderedWriting(List.of(terrain)));
+        helper.assertValueEqual(fatal.firstError().orElseThrow().severity(), WritingGrammar.Severity.FATAL,
+                "A missing Link Panel is fatal");
+        helper.assertTrue(!WritingGrammar.parse(new OrderedWriting(List.of(WritingEntry.linkPanel(), missing)))
+                        .canCreate(), "An unresolved symbol must remain fatal");
+
+        var incomplete = WritingGrammar.parse(new OrderedWriting(List.of(WritingEntry.linkPanel(), terrain)));
+        helper.assertTrue(incomplete.canCreate() && incomplete.firstIncomplete().isPresent(),
+                "Missing branches should be seeded rather than rejected");
+        helper.assertValueEqual(incomplete.firstIncomplete().orElseThrow().severity(),
+                WritingGrammar.Severity.SEEDED_COMPLETION, "Seeded completion needs its own classification");
+        helper.assertValueEqual(incomplete.writingInstability(), 0,
+                "Missing branches alone must not make an Age unstable");
+
+        OrderedWriting unstableWriting = new OrderedWriting(List.of(WritingEntry.linkPanel(), weather,
+                terrain, terrain));
+        var unstable = WritingGrammar.parse(unstableWriting);
+        helper.assertTrue(unstable.canCreate() && unstable.firstInstability().isPresent(),
+                "Supported order and duplicate defects should remain authorable");
+        helper.assertValueEqual(unstable.writingInstability(), 600,
+                "A misplaced terrain and duplicate choice should score once each");
+        helper.assertValueEqual(unstable.symbols().size(), 3,
+                "The diagnostic must preserve all authored page IDs and order");
+        helper.assertValueEqual(unstable.symbols().get(2).reference().id(),
+                ResourceLocation.parse("rivencraft:terrain/standard"),
+                "The duplicate page must remain in the frozen writing");
+        helper.succeed();
+    }
+
+    @GameTest(template = "empty")
+    public static void rejectedBinderKeepsInputsAndUnstablePreview(GameTestHelper helper) {
+        BlockPos pos = helper.absolutePos(new BlockPos(1, 1, 1));
+        helper.getLevel().setBlock(pos, ModBlocks.BOOK_BINDER.get().defaultBlockState(), 3);
+        var binder = (BookBinderBlockEntity) helper.getLevel().getBlockEntity(pos);
+        helper.assertTrue(binder != null, "Binder must exist");
+        binder.setTitle("Grammar Transaction " + UUID.randomUUID());
+        binder.setItem(BookBinderBlockEntity.COVER, new ItemStack(Items.LEATHER));
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE, page("rivencraft:terrain/standard"));
+        helper.assertTrue(!binder.canAssemble() && !binder.consumeAssembly(),
+                "Missing panel must reject before consuming inputs");
+        helper.assertTrue(binder.getItem(BookBinderBlockEntity.COVER).is(Items.LEATHER)
+                        && binder.getItem(BookBinderBlockEntity.FIRST_PAGE).is(ModItems.PAGE.get()),
+                "A structural failure must preserve cover and page");
+
+        binder.setItem(BookBinderBlockEntity.LINK_PANEL, PageItem.createLinkPanelPage());
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1,
+                PageItem.createRecoveredPage(new SymbolReference(ResourceLocation.parse("example:missing"))));
+        helper.assertTrue(!binder.canAssemble() && !binder.consumeAssembly(),
+                "Missing registry entry must reject without consuming ink or pages");
+        helper.assertTrue(!binder.getItem(BookBinderBlockEntity.LINK_PANEL).isEmpty()
+                        && !binder.getItem(BookBinderBlockEntity.FIRST_PAGE + 1).isEmpty(),
+                "Rejected writing must keep the Link Panel and unresolved Page");
+
+        binder.setItem(BookBinderBlockEntity.FIRST_PAGE + 1, page("rivencraft:terrain/standard"));
+        helper.assertTrue(binder.canAssemble(), "Known duplicate terrain should be accepted as unstable");
+        helper.assertValueEqual(binder.writingGrammar().writingInstability(), 500,
+                "Binder must expose the instability cost before assembly");
+        ItemStack preview = binder.previewBook();
+        helper.assertTrue(preview.get(ModDataComponents.AGE_REFERENCE.get()) instanceof AgeReference,
+                "Accepted writing must preview a stable Age identity without consuming inputs");
+        helper.succeed();
+    }
+
+    private static WritingEntry symbol(String id) {
+        return WritingEntry.symbol(new SymbolReference(ResourceLocation.parse(id)));
+    }
+
+    private static ItemStack page(String id) {
+        return PageItem.createSymbolPage(new SymbolReference(ResourceLocation.parse(id)));
+    }
+}

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

@@ -138,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

@@ -4,6 +4,9 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
+import net.dnorberg.rivencraft.book.AgeGenerationPlan;
+import net.dnorberg.rivencraft.book.AgeGenerationProfiles;
+import net.dnorberg.rivencraft.book.AgeTraits;
 import net.dnorberg.rivencraft.writing.OrderedWriting;
 import net.dnorberg.rivencraft.writing.SymbolCatalog;
 import net.dnorberg.rivencraft.writing.SymbolDefinition;
@@ -23,7 +26,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");
@@ -85,20 +87,42 @@ public final class WritingGrammarGameTests {
         WritingGrammar.Result repeatedModifiers = parse(resolver, WritingEntry.linkPanel(),
                 WritingEntry.symbol(periodHalf), WritingEntry.symbol(periodFull), WritingEntry.symbol(celestial));
         helper.assertTrue(repeatedModifiers.canCreate(), "Repeated period modifiers must remain legal");
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
                 WritingEntry.symbol(terrain)), WritingGrammar.Code.DUPLICATE);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
-                WritingEntry.symbol(alternateTerrain)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+        WritingGrammar.Result replacedTerrain = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(terrain),
+                WritingEntry.symbol(alternateTerrain));
+        assertPenalty(helper, replacedTerrain, WritingGrammar.Code.CONFLICT);
+        helper.assertValueEqual(replacedTerrain.activeSymbols().getFirst().reference(), alternateTerrain,
+                "The last supported controller must supply the effective terrain");
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(weather),
                 WritingEntry.symbol(terrain)), WritingGrammar.Code.OUT_OF_ORDER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(celestial),
                 WritingEntry.symbol(periodHalf)), WritingGrammar.Code.MISPLACED_MODIFIER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(nativeBiomes),
                 WritingEntry.symbol(plains)), WritingGrammar.Code.OUT_OF_ORDER);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+        assertPenalty(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
                 WritingEntry.symbol(nativeBiomes)), WritingGrammar.Code.CONFLICT);
-        assertCode(helper, parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
-                WritingEntry.symbol(forest), WritingEntry.symbol(single)), WritingGrammar.Code.CONFLICT);
+        WritingGrammar.Result extraBiomes = parse(resolver, WritingEntry.linkPanel(), WritingEntry.symbol(plains),
+                WritingEntry.symbol(forest), WritingEntry.symbol(single));
+        assertPenalty(helper, extraBiomes, WritingGrammar.Code.CONFLICT);
+        helper.assertValueEqual(extraBiomes.activeSymbols().stream().filter(symbol ->
+                symbol.semantics().role() == SymbolSemantics.Role.BIOME).count(), 1L,
+                "Single-biome distribution must consume only one authored biome");
+        OrderedWriting repaired = writing(WritingEntry.linkPanel(), WritingEntry.symbol(weather),
+                WritingEntry.symbol(terrain), WritingEntry.symbol(ref("rivencraft:terrain/flat")));
+        AgeGenerationPlan plan = AgeGenerationPlan.compile(repaired, 42L, AgeGenerationProfiles.STANDARD,
+                AgeTraits.select(42L), helper.getLevel().registryAccess());
+        helper.assertValueEqual(plan.authoredTerrain(), ResourceLocation.parse("rivencraft:flat"),
+                "The last terrain controller must win without deleting earlier pages");
+        helper.assertValueEqual(plan.writingInstability(), 600,
+                "An extra controller and repaired ordering must be counted once each");
+        helper.assertValueEqual(plan.symbols().size(), 3,
+                "The saved plan must retain all authored pages, including the extra controller");
+        AgeGenerationPlan loaded = AgeGenerationPlan.load(plan.save());
+        helper.assertValueEqual(loaded.writingInstability(), 600,
+                "Writing instability must survive a saved-plan round trip");
+        helper.assertValueEqual(loaded.activeSymbolIndices(), plan.activeSymbolIndices(),
+                "The effective writing order must not reroll on load");
         WritingGrammar.Result repeatedFeatures = parse(resolver, WritingEntry.linkPanel(),
                 WritingEntry.symbol(caves), WritingEntry.symbol(caves));
         helper.assertTrue(repeatedFeatures.canCreate(), "Repeated feature pages must remain authorable");
@@ -143,4 +167,11 @@ public final class WritingGrammarGameTests {
         helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
                 "Writing must report " + code + " rather than silently dropping a page");
     }
+
+    private static void assertPenalty(GameTestHelper helper, WritingGrammar.Result result, WritingGrammar.Code code) {
+        helper.assertTrue(result.canCreate(), "Known writing defect " + code + " must not block Age creation");
+        helper.assertTrue(result.writingInstability() > 0, "Known writing defect must contribute instability");
+        helper.assertTrue(result.diagnostics().stream().anyMatch(diagnostic -> diagnostic.code() == code),
+                "Writing must report " + code + " rather than silently dropping a page");
+    }
 }

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

@@ -102,6 +102,7 @@ public final class PageItem extends Item {
         Set<String> bundled = CREATIVE_SYMBOLS.keySet();
         registries.lookupOrThrow(Registries.BIOME).listElements()
                 .map(holder -> holder.key().location())
+                .filter(BiomeSymbolPages::isPublicPageBiome)
                 .filter(id -> !bundled.contains(BiomeSymbolPages.symbolId(id).getPath()))
                 .sorted()
                 .forEach(id -> pages.add(createCreativeBiomePage(id)));

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

@@ -23,11 +23,11 @@ import net.minecraft.world.item.Items;
 /** Fixed, ordered binder slots and a server-owned virtual result. */
 public final class BookBinderMenu extends AbstractContainerMenu {
     public static final int RESULT = BookBinderBlockEntity.SIZE;
-    public static final int SELECT_BASE = 100;
-    public static final int MOVE_PREVIOUS = 200;
-    public static final int MOVE_NEXT = 201;
-    public static final int IMPORT_NOTEBOOK = 202;
-    public static final int STRIP_CLICK_BASE = 300;
+    public static final int SELECT_BASE = 1000;
+    public static final int MOVE_PREVIOUS = 2000;
+    public static final int MOVE_NEXT = 2001;
+    public static final int IMPORT_NOTEBOOK = 2002;
+    public static final int STRIP_CLICK_BASE = 3000;
     private static final int PLAYER_START = RESULT + 1;
 
     private final BookBinderBlockEntity binder;
@@ -38,6 +38,9 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     private int selectedPage = -1;
     private int grammarErrorCode = -1;
     private int grammarErrorStripIndex = -1;
+    private int grammarInstability;
+    private int grammarIncompleteCount;
+    private WritingGrammar.Result serverGrammar;
 
     public BookBinderMenu(int id, Inventory inventory, RegistryFriendlyByteBuf data) {
         this(id, inventory, inventory.player.level().getBlockEntity(data.readBlockPos())
@@ -56,18 +59,34 @@ public final class BookBinderMenu extends AbstractContainerMenu {
         });
         addDataSlot(new DataSlot() {
             @Override public int get() {
-                return clientSide || binder == null ? grammarErrorCode : binder.writingGrammar().firstError()
-                        .map(error -> error.code().ordinal()).orElse(-1);
+                return clientSide || binder == null ? grammarErrorCode : binderDiagnostic()
+                        .map(diagnostic -> diagnostic.code().ordinal()).orElse(-1);
             }
             @Override public void set(int value) { grammarErrorCode = value; }
         });
         addDataSlot(new DataSlot() {
             @Override public int get() {
-                return clientSide || binder == null ? grammarErrorStripIndex : binder.writingGrammar().firstError()
-                        .map(error -> binder.writingStripIndex(error.index())).orElse(-1);
+                return clientSide || binder == null ? grammarErrorStripIndex : binderDiagnostic()
+                        .map(diagnostic -> binder.writingStripIndex(diagnostic.index())).orElse(-1);
             }
             @Override public void set(int value) { grammarErrorStripIndex = value; }
         });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarInstability
+                        : serverGrammar().writingInstability();
+            }
+            @Override public void set(int value) { grammarInstability = value; }
+        });
+        addDataSlot(new DataSlot() {
+            @Override public int get() {
+                return clientSide || binder == null ? grammarIncompleteCount
+                        : (int) serverGrammar().diagnostics().stream()
+                        .filter(diagnostic -> diagnostic.severity()
+                                == WritingGrammar.Severity.SEEDED_COMPLETION).count();
+            }
+            @Override public void set(int value) { grammarIncompleteCount = value; }
+        });
         addSlot(new BinderSlot(BookBinderBlockEntity.COVER, 8, 27, 64));
         addSlot(new BinderSlot(BookBinderBlockEntity.LINK_PANEL, -1000, -1000, 1));
         addSlot(new BinderSlot(BookBinderBlockEntity.NOTEBOOK, -1000, -1000, 1));
@@ -87,11 +106,27 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     }
 
     public int selectedPage() { return selectedPage; }
+    private WritingGrammar.Result serverGrammar() {
+        if (serverGrammar == null) serverGrammar = binder.writingGrammar();
+        return serverGrammar;
+    }
+    private Optional<WritingGrammar.Diagnostic> binderDiagnostic() {
+        WritingGrammar.Result grammar = serverGrammar();
+        return grammar.firstError().or(grammar::firstInstability).or(grammar::firstIncomplete);
+    }
     public Optional<WritingGrammar.Code> grammarError() {
         WritingGrammar.Code[] codes = WritingGrammar.Code.values();
         return grammarErrorCode >= 0 && grammarErrorCode < codes.length
                 ? Optional.of(codes[grammarErrorCode]) : Optional.empty();
     }
+    public boolean grammarWarning() {
+        return grammarSeverity().orElse(null) == WritingGrammar.Severity.INSTABILITY;
+    }
+    public Optional<WritingGrammar.Severity> grammarSeverity() {
+        return grammarError().map(WritingGrammar.Code::severity);
+    }
+    public int grammarInstability() { return grammarInstability; }
+    public int grammarIncompleteCount() { return grammarIncompleteCount; }
     public int grammarErrorStripIndex() { return grammarErrorStripIndex; }
     public String title() { return binder == null ? "" : binder.title(); }
     public boolean setTitle(Player player, String title) {
@@ -218,6 +253,7 @@ public final class BookBinderMenu extends AbstractContainerMenu {
     }
 
     @Override public void broadcastChanges() {
+        serverGrammar = null;
         refreshResult();
         super.broadcastChanges();
     }

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

@@ -40,11 +40,9 @@ public final class NotebookMenu extends AbstractContainerMenu {
         this.openedHotbarSlot = inventory.selected;
         this.contents = new NotebookContainer(inventory, hand);
 
-        for (int row = 0; row < 3; row++) {
-            for (int column = 0; column < 9; column++) {
-                // The client draws these pages on a filtered, scrollable surface instead.
-                addSlot(new PageSlot(contents, column + row * 9, -1000, -1000));
-            }
+        for (int page = 0; page < NOTEBOOK_SLOTS; page++) {
+            // The client draws these pages on a filtered, scrollable surface instead.
+            addSlot(new PageSlot(contents, page, -1000, -1000));
         }
         for (int row = 0; row < 3; row++) {
             for (int column = 0; column < 9; column++) {

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/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,14 @@ 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.dnorberg.rivencraft.block.DecayBlock;
+import net.dnorberg.rivencraft.block.CloudPlatformBlock;
+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 +38,32 @@ 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));
+    public static final DeferredBlock<DecayBlock> DECAY = BLOCKS.registerBlock("decay",
+            DecayBlock::new, BlockBehaviour.Properties.ofFullCopy(Blocks.STONE)
+                    .strength(5.0F, 10.0F).noLootTable());
+    public static final DeferredBlock<CloudPlatformBlock> CLOUD_PLATFORM = BLOCKS.registerBlock("cloud_platform",
+            CloudPlatformBlock::new, BlockBehaviour.Properties.ofFullCopy(Blocks.WHITE_STAINED_GLASS)
+                    .strength(1.5F).noOcclusion().noLootTable());
 
     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());
 

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

@@ -6,14 +6,18 @@ 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;
@@ -25,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;
@@ -37,6 +42,7 @@ 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;
@@ -51,26 +57,63 @@ 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) {
@@ -152,6 +195,8 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator {
         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;
@@ -160,6 +205,18 @@ public final class AgeFeatureChunkGenerator extends NoiseBasedChunkGenerator {
                         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(

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

@@ -9,6 +9,7 @@ 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;
@@ -71,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
@@ -122,10 +124,13 @@ public final class AgeFlatChunkGenerator extends ChunkGenerator {
     @Override
     public void applyBiomeDecoration(WorldGenLevel level, ChunkAccess chunk, StructureManager structures) {
         super.applyBiomeDecoration(level, chunk, structures);
-        int occurrence = 0;
+        int spikeOccurrence = 0;
+        int obeliskOccurrence = 0;
         for (AgeFeatureSelection.Choice choice : features) {
             if (AgeFeatureSelection.spikes(choice.id()))
-                SpikesFeature.generate(level, chunk, ageSeed, choice, occurrence++);
+                SpikesFeature.generate(level, chunk, ageSeed, choice, spikeOccurrence++);
+            if (AgeFeatureSelection.obelisks(choice.id()))
+                ObelisksFeature.generate(level, chunk, ageSeed, choice, obeliskOccurrence++);
         }
     }
 
@@ -150,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/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/SkylandsFeatureGameTests.java

@@ -1,6 +1,5 @@
 package net.dnorberg.rivencraft.world;
 
-import net.dnorberg.rivencraft.Rivencraft;
 import net.minecraft.gametest.framework.GameTest;
 import net.minecraft.gametest.framework.GameTestHelper;
 import net.minecraft.world.level.block.Blocks;
@@ -8,7 +7,7 @@ import net.neoforged.neoforge.gametest.GameTestHolder;
 import net.neoforged.neoforge.gametest.PrefixGameTestTemplate;
 
 /** Checks the Legacy-style filter independently of a slow dimension-generation test. */
-@GameTestHolder(Rivencraft.MOD_ID)
+@GameTestHolder("rivencraft_archive_generation")
 @PrefixGameTestTemplate(false)
 public final class SkylandsFeatureGameTests {
     private SkylandsFeatureGameTests() {}

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/writing/BiomeSymbolPages.java

@@ -9,9 +9,16 @@ import net.minecraft.resources.ResourceLocation;
 /** Registry-derived pages for biomes without hand-authored symbol JSON. */
 public final class BiomeSymbolPages {
     private static final ResourceLocation CATEGORY = ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome");
+    private static final ResourceLocation TERRABLENDER_DEFERRED_PLACEHOLDER =
+            ResourceLocation.fromNamespaceAndPath("terrablender", "deferred_placeholder");
 
     private BiomeSymbolPages() { }
 
+    /** TerraBlender's internal staging biome is registered, but is not a player-authorable biome page. */
+    public static boolean isPublicPageBiome(ResourceLocation biomeId) {
+        return !TERRABLENDER_DEFERRED_PLACEHOLDER.equals(biomeId);
+    }
+
     public static ResourceLocation symbolId(ResourceLocation biomeId) {
         // Preserve old vanilla page IDs, while keeping modded namespaces distinct.
         return ResourceLocation.fromNamespaceAndPath(Rivencraft.MOD_ID, "biome/"

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

@@ -13,7 +13,9 @@ import net.minecraft.world.item.ItemStack;
 
 /** A bounded, position-preserving collection of Page stacks stored on a Notebook item. */
 public record NotebookContents(List<ItemStack> pages) {
-    public static final int MAX_PAGES = 27;
+    // Legacy did not impose a book-page cap. Our fixed-slot binder persists slot IDs
+    // as unsigned bytes; 252 page positions (after its three input slots) fit safely.
+    public static final int MAX_PAGES = 252;
     public static final NotebookContents EMPTY = new NotebookContents(List.of());
     public static final Codec<NotebookContents> CODEC = ItemStack.OPTIONAL_CODEC.listOf()
             .validate(NotebookContents::validate)

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

@@ -1,6 +1,7 @@
 package net.dnorberg.rivencraft.writing;
 
 import java.util.ArrayList;
+import java.util.Comparator;
 import java.util.EnumMap;
 import java.util.List;
 import java.util.Objects;
@@ -11,10 +12,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.
+    // A newly assembled book has one Link Panel plus the binder's 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() {}
 
@@ -77,22 +81,21 @@ public final class WritingGrammar {
                 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",
-                                "floating_islands", "tendrils", "spheres", "spikes")
-                        .contains(feature.getPath()) || !feature.getNamespace().equals("rivencraft")) {
-                    diagnostics.add(new Diagnostic(Code.MISPLACED_MODIFIER, pendingBlock.index(),
+                if (!MATERIAL_FEATURES.contains(feature.getPath())
+                        || !feature.getNamespace().equals("rivencraft")) {
+                    diagnostics.add(new Diagnostic(Code.UNSUPPORTED_FEATURE, pendingBlock.index(),
                             "This feature cannot consume a material page"));
                 }
                 pendingBlock = null;
             }
             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"));
             }
             if (singular(role)) {
-                ParsedSymbol previous = singular.putIfAbsent(role, parsed);
+                ParsedSymbol previous = singular.put(role, parsed);
                 if (previous != null) {
                     Code code = previous.semantics().value().equals(parsed.semantics().value())
                             ? Code.DUPLICATE : Code.CONFLICT;
@@ -172,16 +175,40 @@ public final class WritingGrammar {
     public enum Code {
         TOO_MANY, MISSING_PANEL, PANEL_ORDER, DUPLICATE_PANEL, UNRESOLVED, UNSUPPORTED,
         DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER, INCOMPLETE, UNSUPPORTED_PROFILE,
-        UNKNOWN_BIOME, UNSUPPORTED_BIOME, UNSUPPORTED_ENVIRONMENT, UNSUPPORTED_FEATURE
+        UNKNOWN_BIOME, UNSUPPORTED_BIOME, UNSUPPORTED_ENVIRONMENT, UNSUPPORTED_FEATURE,
+        UNSUPPORTED_COMBINATION;
+
+        public Severity severity() {
+            return switch (this) {
+                case INCOMPLETE -> Severity.SEEDED_COMPLETION;
+                case DUPLICATE, CONFLICT, OUT_OF_ORDER, MISPLACED_MODIFIER -> Severity.INSTABILITY;
+                default -> Severity.FATAL;
+            };
+        }
     }
 
+    public enum Severity { FATAL, SEEDED_COMPLETION, INSTABILITY }
+
     public record Diagnostic(Code code, int index, String message) {
         public Diagnostic {
             Objects.requireNonNull(code, "code");
             Objects.requireNonNull(message, "message");
         }
 
-        public boolean error() { return code != Code.INCOMPLETE; }
+        public Severity severity() {
+            return code.severity();
+        }
+
+        public boolean error() { return severity() == Severity.FATAL; }
+
+        /** The known writing defects have an explicit, provisional M6 score. */
+        public int instability() {
+            return switch (code) {
+                case DUPLICATE, CONFLICT -> 500;
+                case OUT_OF_ORDER, MISPLACED_MODIFIER -> 100;
+                default -> 0;
+            };
+        }
     }
 
     public record ParsedSymbol(int index, SymbolReference reference, SymbolSemantics semantics) {
@@ -200,5 +227,45 @@ public final class WritingGrammar {
         public boolean randomFallback() { return symbols.isEmpty() && diagnostics.isEmpty(); }
         public boolean canCreate() { return diagnostics.stream().noneMatch(Diagnostic::error); }
         public Optional<Diagnostic> firstError() { return diagnostics.stream().filter(Diagnostic::error).findFirst(); }
+        public Optional<Diagnostic> firstWarning() {
+            return firstInstability();
+        }
+        public Optional<Diagnostic> firstInstability() {
+            return diagnostics.stream().filter(diagnostic -> diagnostic.severity() == Severity.INSTABILITY).findFirst();
+        }
+        public Optional<Diagnostic> firstIncomplete() {
+            return diagnostics.stream().filter(diagnostic -> diagnostic.severity() == Severity.SEEDED_COMPLETION).findFirst();
+        }
+        public int writingInstability() {
+            return diagnostics.stream().mapToInt(Diagnostic::instability).sum();
+        }
+
+        /** Preserve the book's original entries, but compile a repaired Legacy-style order. */
+        public List<ParsedSymbol> activeSymbols() {
+            EnumMap<Role, ParsedSymbol> lastChoice = new EnumMap<>(Role.class);
+            for (ParsedSymbol symbol : symbols) {
+                if (singular(symbol.semantics().role())) lastChoice.put(symbol.semantics().role(), symbol);
+            }
+            List<ParsedSymbol> active = new ArrayList<>();
+            for (ParsedSymbol symbol : symbols) {
+                if (!singular(symbol.semantics().role())
+                        || lastChoice.get(symbol.semantics().role()) == symbol) active.add(symbol);
+            }
+            active.sort(Comparator.comparingInt(symbol -> stage(symbol.semantics().role())));
+            ParsedSymbol controller = lastChoice.get(Role.BIOME_CONTROLLER);
+            if (controller != null && controller.semantics().value() instanceof ChoiceValue choice) {
+                if (choice.id().equals("native")) {
+                    active.removeIf(symbol -> symbol.semantics().role() == Role.BIOME);
+                } else if (choice.id().equals("single")) {
+                    boolean retained = false;
+                    for (int index = 0; index < active.size(); index++) {
+                        if (active.get(index).semantics().role() != Role.BIOME) continue;
+                        if (!retained) retained = true;
+                        else active.remove(index--);
+                    }
+                }
+            }
+            return List.copyOf(active);
+        }
     }
 }

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

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